In a book about logics (https://www.cl.cam.ac.uk/~jrh13/atp/OCaml/real.ml), I find this kind of code:
let integer_qelim =
simplify ** evalc **
lift_qelim linform (cnnf posineq ** evalc) cooper;;
I have seen ** before, but it was for exponentiation purposes, whereas here I do not think it is used for that, as the datatypes are not numeric. I would say it is some king of function combinator, but no idea.
I think this book was written for a version 3.06, but an updated code for 4 (https://github.com/newca12/ocaml-atp) maintains this, so ** is still used in that way that I do not understand.
In OCaml, you can bind to operators any behavior, e.g.,
let ( ** ) x y = print_endline x; print_endline y
so that "hello" ** "world" would print
hello
world
In the code that you reference, the (**) operator is bound to function composition:
let ( ** ) = fun f g x -> f(g x)
That's an utility-function defined in lib.ml:
let ( ** ) = fun f g x -> f(g x);;
It's a composition-operator, often referred to as compose in other examples.
You can use it like this:
let a x = x^"a" in
let b x = x^"b" in
let c x = x^"c" in
let foo = a ** b ** c in
foo "input-";;
- : string = "input-cba"
You could write it as
let foo x = a (b (c x))
or
let foo x = a ## b ## c x
or
let foo x = c x |> b |> a
as well.
Related
import Debug.Trace
main :: IO ()
main = do
let b = (fff 2 10)
print b
let c = (fff 3 10)
print c
print "---"
ff :: (->) Int Int
ff = do
x <- traceShow "x is: " . traceShowId
pure $ (x)
fff :: Int -> Int -> Int
fff = do
(-) . ff
The trace functions seem to be lazily evaluated or something which means the output can vary from:
"x is: "
2
-8
"x is: "
-7
3
"---"
And in another run:
"x is: "
2
"x is: "
3
-8
-7
"---"
I've tried the suggestions from here: How do I force evaluation of an IO action within `unsafePerformIO`? (BangPatterns Pragma + $!) as well as adding the Strict and StrictData pragmas, however I still get the inconsistent behavior.
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE Strict #-}
{-# LANGUAGE StrictData #-}
import Debug.Trace
main :: IO ()
main = do
let !b = (fff 2 10)
print b
let !c = (fff 3 10)
print c
print "---"
ff :: (->) Int Int
ff = do
x <- id $! (traceShow "x is: " . traceShowId)
pure $ (x)
fff :: Int -> Int -> Int
fff = do
(-) . ff
I've also tried using unsafePerformIo but this has similar behavior:
hmm :: a -> a
hmm x = unsafePerformIO $! do
pure x
ff :: Int -> Int
ff z = do
hmm (trace "x is: " . traceShowId) $ z
Is there a solution without having to have knowledge about strictness / Haskell's evaluation?
Debug.Trace functions print to stderr so interleaving is to be expected.
At the very least, you could put x and the string before it together to distinguish it from other print output.
ff :: Int -> Int
ff x = trace ("x is: " ++ show x) x
You can also use unsafePerformIO to redefine trace functions that print to stdout to enforce some ordering.
It sounds like you're dealing with buffering issues. You can use hFlush or just set the buffering:
hSetBuffering stderr NoBuffering
hSetBuffering stdout NoBuffering
myTrace :: Show a => a -> a
myTrace x = unsafePerformIO $ do
print x
pure x
The above seems to work well. Thanks to https://stackoverflow.com/users/6863749/li-yao-xia
I'm trying to implement a cost function and I currently have
let computeCost (X : Matrix<double>) (y : Vector<double>) (theta : Vector<double>) =
let m = y.Count |> double
let J = (1.0/(2.0*m))*(((X*theta - y) |> Vector.map (fun x -> x*x)).Sum)
J
For some reason I get an error on the half after the first * saying "This function takes too many arguments, or is used in a context where a function is not expected."
However, when I do this
let computeCost (X : Matrix<double>) (y : Vector<double>) (theta : Vector<double>) =
let m = y.Count |> double
let J = (((X*theta - y) |> Vector.map (fun x -> x*x)).Sum)
J
It works perfectly fine and it says that val J:float which is what I expect. But as soon as add in the second piece which is the (1.0/(2.0*m)) part I get the error. I have parenthesis around everything so I don't see how it can be some partial function being applied or something along those lines. I'm sure it's something dumb but I can't seem to figure it out.
Nevermind, I'm dumb and I fell back into my C# ways of using .Sum() The actual way of using it is
let computeCost (X : Matrix<double>) (y : Vector<double>) (theta : Vector<double>) =
let m = y.Count |> double
let J = (1.0/(2.0*m)) * (((X*theta - y) |> Vector.map (fun x -> x*x)) |> Vector.sum)
J
And this seemed to fix it.
I'm trying to learn static member constraints in F#. From reading Tomas Petricek's blog post, I understand that writing an inline function that "uses only operations that are themselves written using static member constraints" will make my function work correctly for all numeric types that satisfy those constraints. This question indicates that inline works somewhat similarly to c++ templates, so I wasn't expecting any performance difference between these two functions:
let MultiplyTyped (A : double[,]) (B : double[,]) =
let rA, cA = (Array2D.length1 A) - 1, (Array2D.length2 A) - 1
let cB = (Array2D.length2 B) - 1
let C = Array2D.zeroCreate<double> (Array2D.length1 A) (Array2D.length2 B)
for i = 0 to rA do
for k = 0 to cA do
for j = 0 to cB do
C.[i,j] <- C.[i,j] + A.[i,k] * B.[k,j]
C
let inline MultiplyGeneric (A : 'T[,]) (B : 'T[,]) =
let rA, cA = Array2D.length1 A - 1, Array2D.length2 A - 1
let cB = Array2D.length2 B - 1
let C = Array2D.zeroCreate<'T> (Array2D.length1 A) (Array2D.length2 B)
for i = 0 to rA do
for k = 0 to cA do
for j = 0 to cB do
C.[i,j] <- C.[i,j] + A.[i,k] * B.[k,j]
C
Nevertheless, to multiply two 1024 x 1024 matrixes, MultiplyTyped completes in an average of 2550 ms on my machine, whereas MultiplyGeneric takes about 5150 ms. I originally thought that zeroCreate was at fault in the generic version, but changing that line to the one below didn't make a difference.
let C = Array2D.init<'T> (Array2D.length1 A) (Array2D.length2 B) (fun i j -> LanguagePrimitives.GenericZero)
Is there something I'm missing here to make MultiplyGeneric perform the same as MultiplyTyped? Or is this expected?
edit: I should mention that this is VS2010, F# 2.0, Win7 64bit, release build. Platform target is x64 (to test larger matrices) - this makes a difference: x86 produces similar results for the two functions.
Bonus question: the type inferred for MultiplyGeneric is the following:
val inline MultiplyGeneric :
^T [,] -> ^T [,] -> ^T [,]
when ( ^T or ^a) : (static member ( + ) : ^T * ^a -> ^T) and
^T : (static member ( * ) : ^T * ^T -> ^a)
Where does the ^a type come from?
edit 2: here's my testing code:
let r = new System.Random()
let A = Array2D.init 1024 1024 (fun i j -> r.NextDouble())
let B = Array2D.init 1024 1024 (fun i j -> r.NextDouble())
let test f =
let sw = System.Diagnostics.Stopwatch.StartNew()
f() |> ignore
sw.Stop()
printfn "%A" sw.ElapsedMilliseconds
for i = 1 to 5 do
test (fun () -> MultiplyTyped A B)
for i = 1 to 5 do
test (fun () -> MultiplyGeneric A B)
Good question. I'll answer the easy part first: the ^a is just part of the natural generalization process. Imagine you had a type like this:
type T = | T with
static member (+)(T, i:int) = T
static member (*)(T, T) = 0
Then you can still use your MultiplyGeneric function with arrays of this type: multiplying elements of A and B will give you ints, but that's okay because you can still add them to elements of C and get back values of type T to store back into C.
As to your performance question, I'm afraid I don't have a great explanation. Your basic understanding is right - using MultiplyGeneric with double[,] arguments should be equivalent to using MultiplyTyped. If you use ildasm to look at the IL the compiler generates for the following F# code:
let arr = Array2D.zeroCreate 1024 1024
let f1 = MultiplyTyped arr
let f2 = MultiplyGeneric arr
let timer = System.Diagnostics.Stopwatch()
timer.Start()
f1 arr |> ignore
printfn "%A" timer.Elapsed
timer.Restart()
f2 arr |> ignore
printfn "%A" timer.Elapsed
then you can see that the compiler really does generate identical code for each of them, putting the inlined code for MultipyGeneric into an internal static function. The only difference that I see in the generated code is in the names of locals, and when running from the command line I get roughly equal elapsed times. However, running from FSI I see a difference similar to what you've reported.
It's not clear to me why this would be. As I see it there are two possibilities:
FSI's code generation may be doing something slightly different than the static compiler
The CLR's JIT compiler may be treat code generated at runtime slightly differently from compiled code. For instance, as I mentioned my code above using MultiplyGeneric actually results in an internal method that contains the inlined body. Perhaps the CLR's JIT handles the difference between public and internal methods differently when they are generated at runtime than when they are in statically compiled code.
I'd like to see your benchmarks. I don't get the same results (VS 2012 F# 3.0 Win 7 64-bit).
let m = Array2D.init 1024 1024 (fun i j -> float i * float j)
let test f =
let sw = System.Diagnostics.Stopwatch.StartNew()
f() |> ignore
sw.Stop()
printfn "%A" sw.Elapsed
test (fun () -> MultiplyTyped m m)
> 00:00:09.6013188
test (fun () -> MultiplyGeneric m m)
> 00:00:09.1686885
Decompiling with Reflector, the functions look identical.
Regarding your last question, the least restrictive constraint is inferred. In this line
C.[i,j] <- C.[i,j] + A.[i,k] * B.[k,j]
because the result type of A.[i,k] * B.[k,j] is unspecified, and is passed immediately to (+), an extra type could be involved. If you want to tighten the constraint you can replace that line with
let temp : 'T = A.[i,k] * B.[k,j]
C.[i,j] <- C.[i,j] + temp
That will change the signature to
val inline MultiplyGeneric :
A: ^T [,] -> B: ^T [,] -> ^T [,]
when ^T : (static member ( * ) : ^T * ^T -> ^T) and
^T : (static member ( + ) : ^T * ^T -> ^T)
EDIT
Using your test, here's the output:
//MultiplyTyped
00:00:09.9904615
00:00:09.5489653
00:00:10.0562346
00:00:09.7023183
00:00:09.5123992
//MultiplyGeneric
00:00:09.1320273
00:00:08.8195283
00:00:08.8523408
00:00:09.2496603
00:00:09.2950196
Here's the same test on ideone (with a few minor changes to stay within the time limit: 512x512 matrix and one test iteration). It runs F# 2.0 and produced similar results.
When type X is defined as:
data X =
X { sVal :: String } |
I { iVal :: Int } |
B { bVal :: Bool }
and I want the Int inside an X value, if there is one, otherwise zero.
returnInt :: X -> Int
How can I determine which type of X the argument to returnInt is?
Use pattern matching.
returnInt :: X -> Int
returnInt (I x) = x
returnInt _ = 0
Use a more flexible definition for all possible X values:
returnInt :: X -> Maybe Int
returnInt (I i) = Just i
returnInt _ = Nothing
Then you can use maybe for the particular defaulting you want—0 might be a valid value (this is known as the semipredicate problem):
*Main> maybe 0 id (returnInt $ X "")
0
*Main> maybe 0 id (returnInt $ I 123)
123
*Main> maybe (-1) id (returnInt $ X "yo")
-1
In contrast, partial functions risk runtime exceptions:
*Main> let returnInt (I i) = i
*Main> :t returnInt
returnInt :: X -> Int
*Main> returnInt (B True)
*** Exception: <interactive>:1:4-22: Non-exhaustive patterns in function returnInt
If you're feeling really froggy, you could use MonadPlus
returnInt :: (MonadPlus m) => X -> m Int
returnInt (I i) = return i
returnInt _ = mzero
to gain even more flexibility:
*Main> maybe 0 id (returnInt $ X "")
0
*Main> maybe 0 id (returnInt $ I 123)
123
*Main> returnInt (I 123) `mplus` returnInt (I 456) :: [Int]
[123,456]
Given a function like this:
returnInt :: X -> Int
returnInt x = {- some integer -}
...the type of x is always X. What you care about is whether x uses the X, I or B type constructor.
Use pattern matching to tell the difference:
returnInt :: X -> Int
returnInt (X _) = error "needed an Int, got a String"
returnInt (I { iVal = n }) = n
returnInt (B _) = error "needed an Int, got a Bool"
Just to clarify a point here, let me rewrite your data type to avoid ambiguities in the meaning of X:
data SomeType = X { myString :: String} | I {myInt :: Int} | B {myBool :: Bool}
In this definition there are no X, I and B types. X, I and B are constructors that create a value of type Sometype . Note what happens when you ask ghci what is the type of any value constructed with those type constructors:
*Main> :t (I 5)
(I 5) :: Sometype
*Main> :t (B False)
(B False) :: Sometype
They belong to the same type!!
Just as you can use X, I and B to construct types, you can use pattern matching to deconstruct the type, like done in the other answers above:
returnInt :: SomeType -> Int
returnInt (I x) = x -- if the pattern matches (I x) then return x
returnInt _ = error "I need an integer value, you moron" -- throw an error otherwise
Just remember that pattern matching occurs in order: if the value matches the pattern in some line, the patterns in lines below that will not be executed.
Note that when you define your type like you did, using what is called Record Syntax (just look here: http://en.wikibooks.org/wiki/Haskell/More_on_datatypes ), you got functions like that for free!!
Try looking on the type of myInt, for example:
*Main> :t myInt
myInt :: SomeType -> Int
And look what this function do:
*Main> myInt (I 5)
5
*Main> myInt (B False)
*** Exception: No match in record selector Main.myInt
This is exactly the behavior of returnInt above defined. The strange error message just tells you that the function don't know how to deal with a member of the type SomeType that doesn't match (I x).
If you define your type using the more common syntax:
data SomeType2 = X String | I Int | B Bool
then you loose those nice record functions.
The error messages terminate the execution of the program. This is annoying sometimes. If you need safer behavior for your functions GBacon's answer is just the way to do it. Learn about the Maybe a type and use it to cope with this kind of computation that need to return some value or return nothing ( try this: http://en.wikibooks.org/wiki/Haskell/Hierarchical_libraries/Maybe ).
I'm trying to learn F# by translating some Haskell code I wrote a very long time ago, but I'm stuck!
percent :: Int -> Int -> Float
percent a b = (fromInt a / fromInt b) * 100
freqs :: String -> [Float]
freqs ws = [percent (count x ws) (lowers ws) | x <- ['a' .. 'z']]
I've managed this:
let percent a b = (float a / float b) * 100.
although i dont like having to have the . after the 100.
What is the name of the operation I am performing in freqs, and how do I translate it to F#?
Edit: count and lowers are Char -> String -> Int and String -> Int respectively, and I have translated these already.
This is a list comprehension, and in F# it looks like the last two lines below:
// stub out since don't know the implementation
let count (c:char) (s:string) = 4
let lowers (s:string) = 10
// your code
let percent a b = (float a / float b) * 100.
let freq ws = [for x in ['a'..'z'] do
yield percent (count x ws) (lowers ws)]
More generally I think Haskell list comprehensions have the form suggested by the example below, and the corresponding F# is shown.
// Haskell
// [e(x,y) | x <- l1, y <- l2, pred(x,y)]
// F#
[for x in l1 do
for y in l2 do
if pred(x,y) then
yield e(x,y)]
Note that Brian's F# code:
let freq ws = [for x in ['a'..'z'] do yield percent (count x ws) (lowers ws)]
Can be written more elegantly as:
let freq ws = [for x in 'a'..'z' -> percent (count x ws) (lowers ws)]