User:Coderjoe/Sandbox2: Difference between revisions
No edit summary |
No edit summary |
||
| Line 70: | Line 70: | ||
disp(compose(f1{i}, f2{i})(.5)) |
disp(compose(f1{i}, f2{i})(.5)) |
||
endfor</lang> |
endfor</lang> |
||
=={{header|Oz}}== |
|||
To be executed in the REPL. |
|||
<lang oz>declare |
|||
fun {Compose F G} |
|||
fun {$ X} |
|||
{F {G X}} |
|||
end |
|||
end |
|||
fun {Cube X} X*X*X end |
|||
fun {CubeRoot X} {Number.pow X 1.0/3.0} end |
|||
in |
|||
for |
|||
F in [Float.sin Float.cos Cube] |
|||
I in [Float.asin Float.acos CubeRoot] |
|||
do |
|||
{Show {{Compose I F} 0.5}} |
|||
end |
|||
</lang> |
|||
=={{header|PARI/GP}}== |
|||
{{works with|PARI/GP|2.4.2 and above}} |
|||
<lang parigp>compose(f,g)={ |
|||
x -> f(g(x)) |
|||
}; |
|||
fcf()={ |
|||
my(A,B); |
|||
A=[x->sin(x), x->cos(x), x->x^2]; |
|||
B=[x->asin(x), x->acos(x), x->sqrt(x)]; |
|||
for(i=1,#A, |
|||
print(compose(A[i],B[i])(.5)) |
|||
) |
|||
};</lang> |
|||
Usage note: In Pari/GP 2.4.3 the vectors can be written as |
|||
<lang parigp> A=[sin, cos, x->x^2]; |
|||
B=[asin, acos, x->sqrt(x)];</lang> |
|||
=={{header|Perl}}== |
|||
<lang perl>use Math::Complex ':trig'; |
|||
sub compose { |
|||
my ($f, $g) = @_; |
|||
sub { |
|||
$f -> ($g -> (@_)); |
|||
}; |
|||
} |
|||
my $cube = sub { $_[0] ** (3) }; |
|||
my $croot = sub { $_[0] ** (1/3) }; |
|||
my @flist1 = ( \&Math::Complex::sin, \&Math::Complex::cos, $cube ); |
|||
my @flist2 = ( \&asin, \&acos, $croot ); |
|||
print join "\n", map { |
|||
compose($flist1[$_], $flist2[$_]) -> (0.5) |
|||
} 0..2;</lang> |
|||
=={{header|Perl 6}}== |
|||
{{works with|Rakudo|2011.06}} |
|||
<lang perl6>sub compose (&g, &f) { return { g f $^x } } |
|||
my $x = *.sin; |
|||
my $xi = *.asin; |
|||
my $y = *.cos; |
|||
my $yi = *.acos; |
|||
my $z = * ** 3; |
|||
my $zi = * ** (1/3); |
|||
my @functions = $x, $y, $z; |
|||
my @inverses = $xi, $yi, $zi; |
|||
for @functions Z @inverses { say compose($^g, $^f)(.5) }</lang> |
|||
Output: |
|||
<pre>0.5 |
|||
0.5 |
|||
0.5</pre> |
|||
Revision as of 20:37, 16 July 2011
Nemerle
<lang Nemerle>using System; using System.Console; using System.Math; using Nemerle.Collections.NCollectionsExtensions;
module FirstClassFunc {
Main() : void
{
def cube = fun (x) {x * x * x};
def croot = fun (x) {Pow(x, 1.0/3.0)};
def compose = fun(f, g) {fun (x) {f(g(x))}};
def funcs = [Sin, Cos, cube];
def ifuncs = [Asin, Acos, croot];
WriteLine($[compose(f, g)(0.5) | (f, g) in ZipLazy(funcs, ifuncs)]);
}
}</lang>
newLISP
<lang newLISP>> (define (compose f g) (expand (lambda (x) (f (g x))) 'f 'g)) (lambda (f g) (expand (lambda (x) (f (g x))) 'f 'g)) > (define (cube x) (pow x 3)) (lambda (x) (pow x 3)) > (define (cube-root x) (pow x (div 1 3))) (lambda (x) (pow x (div 1 3))) > (define functions '(sin cos cube)) (sin cos cube) > (define inverses '(asin acos cube-root)) (asin acos cube-root) > (map (fn (f g) ((compose f g) 0.5)) functions inverses) (0.5 0.5 0.5) </lang>
OCaml
<lang ocaml># let cube x = x ** 3. ;; val cube : float -> float = <fun>
- let croot x = x ** (1. /. 3.) ;;
val croot : float -> float = <fun>
- let compose f g = fun x -> f (g x) ;; (* we could have written "let compose f g x = f (g x)" but we show this for clarity *)
val compose : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b = <fun>
- let funclist = [sin; cos; cube] ;;
val funclist : (float -> float) list = [<fun>; <fun>; <fun>]
- let funclisti = [asin; acos; croot] ;;
val funclisti : (float -> float) list = [<fun>; <fun>; <fun>]
- List.map2 (fun f inversef -> (compose inversef f) 0.5) funclist funclisti ;;
- : float list = [0.5; 0.499999999999999889; 0.5]</lang>
Octave
<lang octave>function r = cube(x)
r = x.^3;
endfunction
function r = croot(x)
r = x.^(1/3);
endfunction
compose = @(f,g) @(x) f(g(x));
f1 = {@sin, @cos, @cube}; f2 = {@asin, @acos, @croot};
for i = 1:3
disp(compose(f1{i}, f2{i})(.5))
endfor</lang>