fun find_zero (f: int -> int): int = let
fun aux (f: int -> int, i: int): int =
if f (i) = 0 then i
else (
if i <= 0 then aux (f, ~i + 1) else aux (f, ~i)
) in
aux (f, 0)
end
fun f1 (x: int): int = (x - 10) * (x + 11)
fun f2 (x: int): int = (x - 12) * (x + 11)
typedef real = double
#define DELTA 1E-10
fun deriv (f: real -> real, x: real): real = (f (x + DELTA) - f (x)) / DELTA
fun f3 (x: real): real = (x - 10.0) * (x + 11.0)
fun f4 (x: real): real = (x - 12.0) * (x + 11.0)
#define N_newton_raphson 10
fun newton_raphson
(f: real -> real, x0: real)
: real = loop (f, x0, 0) where {
fun loop (f: real -> real, x: real, n: int): real =
if n < N_newton_raphson then let
val x_next = x - f (x) / deriv (f, x)
in
loop (f, x_next, n+1)
end else begin
x end }
#define N_binary 40
fun binary (f: real -> real, x0: real, x1: real): real = let
fun loop (f: real -> real, x0: real, x1: real, n: int): real =
if n < N_binary then let
val x_average = (x0 + x1) / 2
val f_average = f (x_average)
in
if f_average >= 0.0 then loop (f, x0, x_average, n+1)
else loop (f, x_average, x1, n+1)
end else begin
(x0 + x1) / 2 end in
loop (f, x0, x1, 0)
end
fun square_minus_2 (x: real): real = x * x - 2.0
val () = () where { val rt1 = find_zero (f1)
val () = printf ("f1 (%i) = 0\n", @(rt1))
val rt2 = find_zero (f2)
val () = printf ("f2 (%i) = 0\n", @(rt2))
val f3'_10 = deriv (f3, 10.0)
val () = printf ("f3'(10) = %.10f\n", @(f3'_10))
val f4'_10 = deriv (f4, 10.0)
val () = printf ("f4'(10) = %.10f\n", @(f4'_10))
val rt3 = newton_raphson (f3, 0.0)
val () = printf ("f3 (%.10f) = 0\n", @(rt3))
val rt4 = newton_raphson (f4, 0.0)
val () = printf ("f4 (%.10f) = 0\n", @(rt4))
val sqrt2_new = newton_raphson (square_minus_2, 1.0)
val () = printf ("sqrt2_new = %.10f\n", @(sqrt2_new))
val sqrt2_bin = binary (square_minus_2, 1.0, 2.0)
val () = printf ("sqrt2_bin = %.10f\n", @(sqrt2_bin))
}
#define :: list0_cons
#define cons list0_cons
#define nil list0_nil
extern fun{a,b:t@ype} list_map (xs: list0 a, f: a -> b): list0 b
implement{a,b}
list_map (xs, f) = map (xs, f) where {
fun map (xs: list0 a, f: a -> b): list0 b =
case+ xs of
| x :: xs => f (x) :: map (xs, f)
| nil () => nil ()
}
extern fun{a,b:t@ype} list_foldl (xs: list0 a, f: (b, a) -> b, init: b): b
implement{a,b} list_foldl (xs, f, init) = foldl (xs, f, init) where {
fun foldl (xs: list0 a, f: (b, a) -> b, init: b): b =
case+ xs of
| x :: xs => foldl (xs, f, f (init, x)) | nil () => init
}
extern fun{a,b:t@ype} list_foldr (xs: list0 a, f: (a, b) -> b, res: b): b
implement{a,b}
list_foldr (xs, f, res) = foldr (xs, f, res) where {
fun foldr (xs: list0 a, f: (a, b) -> b, res: b): b =
case+ xs of
| x :: xs => f (x, foldr (xs, f, res)) | nil () => res
}
val () = () where { val xs = 1 :: 2 :: 3 :: 4 :: 5 :: 6 :: nil ()
val n = list_foldl<int,int> (xs, f, 0) where {
fun f (init: int, _: int) = init + 1
}
val () = printf ("length (foldl) = %i\n", @(n))
val n = list_foldr<int,int> (xs, f, 0) where {
fun f (_: int, res: int) = res + 1
}
val () = printf ("length (foldr) = %i\n", @(n))
val sum = list_foldr<int,int> (xs, f, 0) where {
fun f (x: int, res: int) = x + res
}
val () = printf ("summation (foldr) = %i\n", @(sum))
val ys = list_map (xs, f) where {
fun f (x: int): int = x + x
}
val _ = list_foldl<int,int> (ys, f, 0) where {
fun f (init: int, x: int): int = (if init > 0 then print ", "; print x; init+1)
}
val () = print_newline ()
}
implement main () = ()