@explorable-viz/fluid 0.7.84 → 0.7.85

package/dist/fluid/fluid/lib/prelude.fld

@@ -1,276 +0,0 @@
--- "Num" throughout means (Int + Float).
-
--- Bool -> Bool
-let and False y = False;
-    and True y = y;
-
--- Bool -> Bool
-let or True y = True;
-    or False y = y;
-
--- Bool -> Bool
-let not True = False;
-    not False = True;
-
--- Int -> Int -> Ordering
-let compare x y =
-   if x > y
-   then GT
-   else if x < y
-      then LT
-      else EQ;
-
--- Num -> Num
-let negate = (-) 0;
-
--- Log of x in base y.
--- Float -> Float -> Float
-let logBase x y = log y / log x;
-
--- Float -> Float -> Float
-let ceilingToNearest n m =
-   ceiling (n / m) * m;
-
--- (b -> c) -> (a -> b) -> a -> c
--- Want infix <<<
-let compose f g x = f (g x);
-
--- ((a, b) -> c) -> a -> b -> c
-let curry f x y = f (x, y);
-
--- (a -> b -> c) -> (a, b) -> c
-let uncurry f (x, y) = f x y;
-
--- a -> b -> a
-let const x _ = x;
-
--- (a -> b) -> (a, c) -> (b, c)
-let first f (a, c) = (f a, c);
-
--- (a, b) -> b
-let snd (_, y) = y;
-
--- (a -> b) -> (c, a) -> (c, b)
-let second f (c, a) = (c, f a);
-
--- (a -> b -> c) -> b -> a -> c
-let flip f x y = f y x;
-
--- (a, b) -> a
-let fst (x, _) = x;
-
--- a -> a
-let id x = x;
-
--- (a -> b) -> (a -> c) -> a -> (b, c)
--- Want infix &&&
-let prod f g x = (f x, g x);
-
--- (a, b) -> (b, a)
-let swap (a, b) = (b, a);
-
--- List a -> a
-let head [] = error "Can't take head of empty list";
-    head (x : _) = x;
-
--- List a -> List a
-let tail [] = error "Can't take tail of empty list";
-    tail (_ : xs) = xs;
-
--- Eq a => a -> List a -> Bool
-let elem x [] = False;
-    elem x (x' : xs) = (x == x') `or` (elem x xs);
-
--- (a -> Bool) -> List a -> Option a
-let find p [] = error "not found";
-    find p (x : xs) = if p x then Some x else find p xs;
-
--- String -> String -> List Dict -> Option Dict
-let findWithKey fname fval table = find (fun y -> y.[fname] == fval) table;
-
-let fromSome option = match option as {
-    None -> error "Expected Some!";
-    Some x -> x
-};
-
--- (a -> Bool) -> List a -> List a
-let filter p [] = [];
-    filter p (x : xs) =
-      let ys = filter p xs in
-      if p x then x : ys else ys;
-
--- (a -> Option b) -> List a -> List b
-let filterMap p [] = [];
-    filterMap p (x : xs) =
-      match p x as {
-         None -> filterMap f xs;
-         Some y -> y : filterMap f xs
-      };
-
--- (a -> b -> a) -> a -> List b -> a
-let foldl op z [] = z;
-    foldl op z (x : xs) = foldl op (op z x) xs;
-
--- (a -> b -> a) -> List b -> a
-let foldl1 op (x : xs) = foldl op x xs;
-
--- (a -> b -> b) -> b -> List a -> b
-let foldr op z [] = z;
-    foldr op z (x : xs) = op x (foldr op z xs);
-
--- (a -> b -> b) -> List a -> b
-let foldr1 op [x] = x;
-    foldr1 op (x : y : xs) = op x (foldr1 op (y : xs));
-
--- (a -> b -> a) -> a -> List b -> List a
-let scanl1 op z xs =
-   let go x continue acc =
-      let next = op acc x in
-      next : continue next in
-   foldr go (const []) xs z;
-
--- (a -> b -> a) -> a -> List b -> List a
-let scanl op z xs =
-   z : scanl1 op z xs;
-
--- (a -> b) -> List a -> List b
-let map f [] = [];
-    map f (x : xs) = f x : map f xs;
-
--- (List a, List a) -> List a
-let append ([], ys) = ys;
-    append (x : xs, ys) = x : append (xs, ys);
-
--- List a -> List -> List a
--- Want infix ++
-let concat2 [] ys = ys;
-    concat2 (x : xs) ys = x : concat2 xs ys;
-
--- List (List a) -> List a
-let concat = foldl concat2 [];
-
--- (a -> List b) -> List a -> List b
-let concatMap f xs = concat (map f xs);
-
--- List a -> a -> List a
-let intersperse [] _ = [];
-    intersperse [x] _ = [x];
-    intersperse (x : y : ys) sep = x : sep : intersperse (y : ys) sep;
-
--- Int -> (a -> a) -> a -> List a
-let iterate n f z =
-   if n == 0 then [] else z : map f (iterate (n - 1) f z);
-
--- List Int -> Int
-let sum = foldr (+) 0;
-
--- List a -> a
-let last [x] = x;
-    last (x : y : ys) = last (y : ys);
-
--- List a -> Int
-let length [] = 0;
-    length (_ : xs) = 1 + length xs;
-
--- List a -> List a
-let reverse [] = [];
-    reverse (x : xs) = append (reverse xs, [x]);
-
--- Int -> a -> List a
-let repeat = flip iterate id;
-
--- Int -> List a -> List a
-let take n xs =
-    if n <= 0
-    then []
-    else match xs as {
-       [] -> [];
-       x : xs -> x : take (n - 1) xs
-    };
-
--- Int -> List a -> List a
-let drop n xs =
-   if n <= 0
-   then xs
-   else match xs as {
-      [] -> [];
-      _ : xs -> drop (n - 1) xs
-   };
-
--- Int -> List a -> List a
-let lastN n xs =
-   foldl (compose const (drop 1)) xs (drop n xs);
-
--- Expects non-negative integer as first argument and non-empty list as second argument.
--- Int -> List a -> a
-let nth n (x : xs) =
-   if n == 0 then x else nth (n - 1) xs;
-
--- Matrix Int -> Int -> Int -> Int
-let nth2 i j xss =
-   nth (j - 1) (nth (i - 1) xss);
-
--- Partial; requires k to be in the map.
--- Int -> List (Int, b) -> b
-let lookup k [] = error "Key not found in map";
-    lookup k ((k', v) : kvs) =
-       if k == k' then v else lookup k kvs;
-
--- Int -> Int -> Int
-let max n m =
-   if n > m then n else m;
-
--- Int -> Int -> Int
-let min n m =
-   if n < m then n else m;
-
--- List Int -> Int
-let maximum = foldr1 max;
-
--- List Int -> Int
-let minimum = foldr1 min;
-
--- List (a, b) -> (List a, List b)
-let unzip [] = ([], []);
-    unzip ((x, y) : zs) =
-      let (xs, ys) = unzip zs in
-      (x : xs, y : ys);
-
--- (a -> b -> c) -> List a -> List b -> List c
-let zipWith op [] ys = [];
-    zipWith op (x : xs) [] = [];
-    zipWith op (x : xs) (y : ys) = op x y : zipWith op xs ys;
-
--- List a -> List b -> List (a, b)
-let zip = zipWith (curry id);
-
--- Int -> Int -> List Int
-let enumFromTo n m =
-    if n <= m then n : [n + 1 .. m] else [];
-
-let range (m1, n1) (m2, n2) =
-      [ (i1, i2) | i1 <- [m1 .. m2], i2 <- [n1 .. n2] ];
-
--- Int -> Int -> Int
-let abs x y =
-   if x - y < 0 then negate (x - y) else (x - y);
-
--- Eq a => [a] -> [a]
-let nub xs =
-    let nub' [] _ = [];
-        nub' (x : xs) ys = if x `elem` ys then nub' xs ys else x : nub' xs (x : ys) in
-    nub' xs [];
-
--- Int -> Int -> [a] -> [a]
-let slice begin end xs =
-   take (end - begin) (drop begin xs);
-
-
--- (a -> Boolean) -> List a -> (List a, List a)
-let splitOn p data = 
-    let go fls trs [] = (reverse fls, reverse trs);
-        go fls trs (x : xs) = 
-            if p x
-            then go fls (x : trs) xs
-            else go (x : fls) trs xs
-    in go [] [] data;

package/dist/fluid/fluid/lib/some-constants.fld

@@ -1 +0,0 @@
-let x = 1;

package/dist/fluid/fluid/lib/stats.fld

@@ -1,57 +0,0 @@
-let split [] = ([], []);
-    split (x : xs) =
-      let (ys, zs) = split xs in (x : zs, ys);
-
-let merge xs ys =
-       match (xs, ys) as {
-          ([], _) -> ys;
-          (x : xs', []) -> xs;
-          (x : xs', y : ys') ->
-             if x < y
-             then x : merge xs' ys
-             else y : merge xs ys'
-       };
-
-let mergesort xs =
-       if length xs < 2
-       then xs
-       else
-          let (ys, zs) = split xs in
-          merge (mergesort ys) (mergesort zs);
-
--- assume data is sorted
-let findQuantile q p data = 
-    let rank = (p / q) * (length data - 1)
-    in if rank == floor rank
-    then nth rank data
-    else let x1 = floor rank;
-             x2 = ceiling rank;
-             left = nth x1 data;
-             right = nth x2 data
-        in left + (rank - x1) * (right - left);
-
-let findPercentile = findQuantile 100;
-
-let accumBins data Nil = [];
-    accumBins data [l] = [];
-    accumBins data (l : r : es) =  
-        let (ge, le) = splitOn (fun x -> x <= r) data
-        in (le , r - l) : accumBins ge (r : es);
-
-let cut data nbins = 
-    let low = minimum data;
-        binwidth = (maximum data - low) / nbins;
-        edges = [ low + (x * binwidth) | x <- enumFromTo 0 nbins ]
-    in accumBins data edges;
-
-let qcut data qs = 
-        let low = minimum data;
-            high = maximum data;
-            edges = append (low : [ findPercentile x data | x <- qs], [high])
-        in accumBins data edges;
-
-let likelihoodLE data target = 
-    length (filter (fun x -> x <= target) data) / length data;
-
-let likelihoodGE data target = 
-    length (filter (fun x -> x >= target) data) / length data;

package/dist/fluid/fluid/lib/text-viz.fld

@@ -1,18 +0,0 @@
-let likelihoodMap table prob = (fromSome (find (fun x -> x.prob <= prob) table)).msg;
-
-let mkPercent num = (numToStr (num * 100)) ++ "%";
-
-let leqP n m =
-    if n <= m
-    then "less"
-    else "more";
-
-let gradedLeqP n m =
-    let ratio = n / m
-    in if ratio <= 1.0
-        then if ratio <=0.5
-            then "much less"
-            else "less"
-        else if ratio >= 2.0
-            then "much more"
-            else "more";