User:Coderjoe/Sandbox2
Groovy
Solution: <lang groovy>def compose = { f, g -> { x -> f(g(x)) } }</lang>
Test program: <lang groovy>def cube = { it * it * it } def cubeRoot = { it ** (1/3) }
funcList = [ Math.&sin, Math.&cos, cube ] inverseList = [ Math.&asin, Math.&acos, cubeRoot ]
println [funcList, inverseList].transpose().collect { compose(it[0],it[1]) }.collect{ it(0.5) } println [inverseList, funcList].transpose().collect { compose(it[0],it[1]) }.collect{ it(0.5) }</lang>
Output:
[0.5, 0.4999999999999999, 0.5000000000346574] [0.5, 0.4999999999999999, 0.5000000000346574]
Haskell
<lang haskell>Prelude> let cube x = x ^ 3 Prelude> let croot x = x ** (1/3) Prelude> let compose f g = \x -> f (g x) -- this is already implemented in Haskell as the "." operator Prelude> -- we could have written "let compose f g x = f (g x)" but we show this for clarity Prelude> let funclist = [sin, cos, cube] Prelude> let funclisti = [asin, acos, croot] Prelude> zipWith (\f inversef -> (compose inversef f) 0.5) funclist funclisti [0.5,0.4999999999999999,0.5]</lang>
Icon and Unicon
The Unicon solution can be modified to work in Icon. See Function_composition#Icon_and_Unicon. <lang Unicon>link compose procedure main(arglist)
fun := [sin,cos,cube]
inv := [asin,acos,cuberoot]
x := 0.5
every i := 1 to *inv do
write("f(",x,") := ", compose(inv[i],fun[i])(x))
end
procedure cube(x) return x*x*x end
procedure cuberoot(x) return x ^ (1./3) end</lang> Please refer to See Function_composition#Icon_and_Unicon for 'compose'.
Sample Output:
f(0.5) := 0.5 f(0.5) := 0.4999999999999999 f(0.5) := 0.5
J
J has some subtleties which are not addressed in this specification (J functions have grammatical character and their gerundial form may be placed in data structures where the spec sort of implies that there be no such distinction).
However, here are the basics which were requested: <lang j> sin=: 1&o.
cos=: 2&o. cube=: ^&3
square=: *:
unqo=: `:6
unqcol=: `:0
quot=: 1 :'{.u`
A=: sin`cos`cube`square
B=: monad def'y unqo inv quot'"0 A
BA=. A dyad def'x unqo@(y unqo) quot'"0 B</lang>
<lang> A unqcol 0.5 0.479426 0.877583 0.125 0.25
BA unqcol 0.5
0.5 0.5 0.5 0.5</lang>
Java
Java doesn't technically have first-class functions. Java can simulate first-class functions to a certain extent, with anonymous classes and generic function interface.
<lang java> public static Function<Double, Double> compose( final Function<Double, Double> f, final Function<Double, Double> g) { return new Function<Double, Double>() { @Override public Double apply(Double x) { return f.apply(g.apply(x)); } }; }
@SuppressWarnings("unchecked") public static void main(String[] args) { ArrayList<Function<Double, Double>> functions = Lists.newArrayList( new Function<Double, Double>() { @Override public Double apply(Double x) { return Math.cos(x); } }, new Function<Double, Double>() { @Override public Double apply(Double x) { return Math.tan(x); } }, new Function<Double, Double>() { @Override public Double apply(Double x) { return x * x; } }); ArrayList<Function<Double, Double>> inverse = Lists.newArrayList( new Function<Double, Double>() { @Override public Double apply(Double x) { return Math.acos(x); } }, new Function<Double, Double>() { @Override public Double apply(Double x) { return Math.atan(x); } }, new Function<Double, Double>() { @Override public Double apply(Double x) { return Math.sqrt(x); } }); for (int i = 0; i < functions.size(); i++) { System.out.println(compose(functions.get(i), inverse.get(i)).apply(0.5)); } } </lang>
JavaScript
assuming the print function is provided by the environment, like a stand-alone shell. In browsers, use alert(), document.write() or similar
<lang javascript>var compose = function (f, g) {
return function (x) {
return f(g(x));
};
};
var fn = [Math.sin, Math.cos, function (x) { return Math.pow(x, 3); }]; var inv = [Math.asin, Math.acos, function (x) { return Math.pow(x, 1/3); }];
(function () {
for (var i = 0; i < 3; i++) {
var f = compose(inv[i], fn[i]);
print(f(0.5)); // 0.5
}
})();
</lang>
Lua
<lang lua> function compose(f,g) return function(...) return f(g(...)) end end
fn = {math.sin, math.cos, function(x) return x^3 end} inv = {math.asin, math.acos, function(x) return x^(1/3) end}
for i, v in ipairs(fn)
local f = compose(v, inv[i]) print(f(0.5)) --> 0.5
end</lang>
Mathematica
The built-in function Composition can do composition, a custom function that does the same would be compose[f_,g_]:=f[g[#]]&. However the latter only works with 2 arguments, Composition works with any number of arguments. <lang Mathematica>funcs = {Sin, Cos, #^3 &}; funcsi = {ArcSin, ArcCos, #^(1/3) &}; compositefuncs = Composition @@@ Transpose[{funcs, funcsi}]; Table[i[0.666], {i, compositefuncs}]</lang> gives back: <lang Mathematica>{0.666, 0.666, 0.666}</lang> Note that I implemented cube and cube-root as pure functions. This shows that Mathematica is fully able to handle functions as variables, functions can return functions, and functions can be given as an argument. Composition can be done in more than 1 way: <lang Mathematica>Composition[f,g,h][x] f@g@h@x x//h//g//f</lang> all give back: <lang Mathematica>f[g[h[x]]]</lang>
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>
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>
PARI/GP
<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>
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>
Perl 6
<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:
0.5 0.5 0.5
PicoLisp
<lang PicoLisp>(load "@lib/math.l")
(de compose (F G)
(curry (F G) (X)
(F (G X)) ) )
(de cube (X)
(pow X 3.0) )
(de cubeRoot (X)
(pow X 0.3333333) )
(mapc
'((Fun Inv)
(prinl (format ((compose Inv Fun) 0.5) *Scl)) )
'(sin cos cube)
'(asin acos cubeRoot) )</lang>
Output:
0.500001 0.499999 0.500000
Prolog
Works with SWI-Prolog and module lambda, written by Ulrich Neumerkel found here: http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl
<lang Prolog>:- use_module(library(lambda)).
compose(F,G, FG) :-
FG = \X^Z^(call(G,X,Y), call(F,Y,Z)).
cube(X, Y) :- Y is X ** 3.
cube_root(X, Y) :- Y is X ** (1/3).
first_class :- L = [sin, cos, cube], IL = [asin, acos, cube_root],
% we create the composed functions maplist(compose, L, IL, Lst),
% we call the functions maplist(call, Lst, [0.5,0.5,0.5], R),
% we display the results maplist(writeln, R). </lang> Output :
?- first_class. 0.5 0.4999999999999999 0.5000000000000001 true.
Python
<lang python>>>> # Some built in functions and their inverses >>> from math import sin, cos, acos, asin >>> # Add a user defined function and its inverse >>> cube = lambda x: x * x * x >>> croot = lambda x: x ** (1/3.0) >>> # First class functions allow run-time creation of functions from functions >>> # return function compose(f,g)(x) == f(g(x)) >>> compose = lambda f1, f2: ( lambda x: f1(f2(x)) ) >>> # first class functions should be able to be members of collection types >>> funclist = [sin, cos, cube] >>> funclisti = [asin, acos, croot] >>> # Apply functions from lists as easily as integers >>> [compose(inversef, f)(.5) for f, inversef in zip(funclist, funclisti)] [0.5, 0.4999999999999999, 0.5] >>></lang>
R
<lang R>cube <- function(x) x^3 croot <- function(x) x^(1/3) compose <- function(f, g) function(x){f(g(x))}
f1 <- c(sin, cos, cube) f2 <- c(asin, acos, croot)
for(i in 1:3) {
print(compose(f1i, f2i)(.5))
}</lang>
Alternatively:
<lang R> sapply(mapply(compose,f1,f2),do.call,list(.5)) </lang>
REBOL
<lang REBOL>REBOL [ Title: "First Class Functions" Author: oofoe Date: 2009-12-05 URL: http://rosettacode.org/wiki/First-class_functions ]
- Functions "foo" and "bar" are used to prove that composition
- actually took place by attaching their signatures to the result.
foo: func [x][reform ["foo:" x]] bar: func [x][reform ["bar:" x]]
cube: func [x][x * x * x] croot: func [x][power x 1 / 3]
- "compose" means something else in REBOL, so I "fashion" an alternative.
fashion: func [f1 f2][ do compose/deep [func [x][(:f1) (:f2) x]]]
A: [foo sine cosine cube] B: [bar arcsine arccosine croot]
while [not tail? A][ fn: fashion get A/1 get B/1 source fn ; Prove that functions actually got composed. print [fn 0.5 crlf]
A: next A B: next B ; Advance to next pair. ]</lang>
Ruby
<lang ruby>irb(main):001:0> cube = proc {|x| x ** 3} => #<Proc:0xb7cac4b8@(irb):1> irb(main):002:0> croot = proc {|x| x ** (1/3.0)} => #<Proc:0xb7ca40d8@(irb):2> irb(main):003:0> compose = proc {|f,g| proc {|x| f[g[x]]}} => #<Proc:0xb7c9996c@(irb):3> irb(main):004:0> funclist = [Math.method(:sin).to_proc, Math.method(:cos).to_proc, cube] => [#<Proc:0xb7c84be8@(irb):4>, #<Proc:0xb7c84bac@(irb):4>, #<Proc:0xb7cac4b8@(irb):1>] irb(main):005:0> funclisti = [Math.method(:asin).to_proc, Math.method(:acos).to_proc, croot] => [#<Proc:0xb7c7a88c@(irb):5>, #<Proc:0xb7c7a850@(irb):5>, #<Proc:0xb7ca40d8@(irb):2>] irb(main):006:0> funclist.zip(funclisti).map {|f,inversef| compose[inversef, f][0.5] } => [0.5, 0.5, 0.5]</lang>
Scala
<lang scala>def cube = (x:Double) => x*x*x def cuberoot = (x:Double) => Math.pow(x,1.0/3)
def compose[A,B,C](f:B=>C,g:A=>B) = (x:A)=>f(g(x))
def fun = List(Math.sin _, Math.cos _, cube) def inv = List(Math.asin _, Math.acos _, cuberoot)
def comp = fun zip inv map Function.tupled(_ compose _)
comp.foreach(f=>println(f(0.5)))</lang>
Here's how you could add a composition operator to make that syntax prettier:
<lang scala>class SweetFunction[B,C](f:B=>C) {
def o[A](g:A=>B) = (x:A)=>f(g(x))
} implicit def sugarOnTop[A,B](f:A=>B) = new SweetFunction(f)
//and now you can do things like this println((cube o cube o cuberoot)(0.5))</lang>
Scheme
<lang scheme>(define (compose f g) (lambda (x) (f (g x)))) (define (cube x) (expt x 3)) (define (cube-root x) (expt x (/ 1 3)))
(define function (list sin cos cube)) (define inverse (list asin acos cube-root))
(define x 0.5) (define (go f g)
(if (not (or (null? f)
(null? g)))
(begin (display ((compose (car f) (car g)) x))
(newline)
(go (cdr f) (cdr g)))))
(go function inverse)</lang> Output:
0.5 0.5 0.5
Slate
Compose is already defined in slate as (note the examples in the comment):
<lang slate>m@(Method traits) ** n@(Method traits) "Answers a new Method whose effect is that of calling the first method on the results of the second method applied to whatever arguments are passed. This composition is associative, i.e. (a ** b) ** c = a ** (b ** c). When the second method, n, does not take a *rest option or the first takes more than one input, then the output is chunked into groups for its consumption. E.g.:
- `er ** #; `er applyTo
- {'a'. 'b'. 'c'. 'd'} => 'abcd'
- `er ** #name `er applyTo
- {#a. #/}. => 'a/'"
[
n acceptsAdditionalArguments \/ [m arity = 1]
ifTrue:
[[| *args | m applyTo: {n applyTo: args}]]
ifFalse:
[[| *args |
m applyTo:
([| :stream |
args do: [| *each | stream nextPut: (n applyTo: each)]
inGroupsOf: n arity] writingAs: {})]]
].
- `er asMethod: #compose: on: {Method traits. Method traits}.</lang>
used as: <lang slate>n@(Number traits) cubed [n raisedTo: 3]. n@(Number traits) cubeRoot [n raisedTo: 1 / 3]. define: #forward -> {#cos `er. #sin `er. #cube `er}. define: #reverse -> {#arcCos `er. #arcSin `er. #cubeRoot `er}.
define: #composedMethods -> (forward with: reverse collect: #compose: `er). composedMethods do: [| :m | inform: (m applyWith: 0.5)].</lang>
Smalltalk
<lang smalltalk>|forward reverse composer compounds| "commodities" Number extend [
cube [ ^self raisedTo: 3 ]
]. Number extend [
cubeRoot [ ^self raisedTo: (1 / 3) ]
].
forward := #( #cos #sin #cube ). reverse := #( #arcCos #arcSin #cubeRoot ).
composer := [ :f :g | [ :x | f value: (g value: x) ] ].
"let us create composed funcs" compounds := OrderedCollection new.
1 to: 3 do: [ :i |
compounds add: ([ :j | composer value: [ :x | x perform: (forward at: j) ]
value: [ :x | x perform: (reverse at: j) ] ] value: i)
].
compounds do: [ :r | (r value: 0.5) displayNl ].</lang>
Output:
0.4999999999999999 0.5 0.5000000000000001
Standard ML
<lang sml>- fun cube x = Math.pow(x, 3.0); val cube = fn : real -> real - fun croot x = Math.pow(x, 1.0 / 3.0); val croot = fn : real -> real - fun compose (f, g) = fn x => f (g x); (* this is already implemented in Standard ML as the "o" operator = we could have written "fun compose (f, g) x = f (g x)" but we show this for clarity *) val compose = fn : ('a -> 'b) * ('c -> 'a) -> 'c -> 'b - val funclist = [Math.sin, Math.cos, cube]; val funclist = [fn,fn,fn] : (real -> real) list - val funclisti = [Math.asin, Math.acos, croot]; val funclisti = [fn,fn,fn] : (real -> real) list - ListPair.map (fn (f, inversef) => (compose (inversef, f)) 0.5) (funclist, funclisti); val it = [0.5,0.5,0.500000000001] : real list</lang>
Tcl
The following is a transcript of an interactive session:
<lang Tcl>% namespace path tcl::mathfunc ;# to import functions like abs() etc. % proc cube x {expr {$x**3}} % proc croot x {expr {$x**(1/3.)}} % proc compose {f g} {list apply {{f g x} {{*}$f [{*}$g $x]}} $f $g}
% compose abs cube ;# returns a partial command, without argument apply {{f g x} {{*}$f [{*}$g $x]}} abs cube
% {*}[compose abs cube] -3 ;# applies the partial command to argument -3 27
% set forward [compose [compose sin cos] cube] ;# omitting to print result % set backward [compose croot [compose acos asin]] % {*}$forward 0.5 0.8372297964617733 % {*}$backward [{*}$forward 0.5] 0.5000000000000017</lang> Obviously, the (C) library implementation of some of the trigonometric functions (on which Tcl depends for its implementation) on the platform used for testing is losing a little bit of accuracy somewhere.
TI-89 BASIC
See the comments at Function as an Argument#TI-89 BASIC for more information on first-class functions or the lack thereof in TI-89 BASIC. In particular, it is not possible to do proper function composition, because functions cannot be passed as values nor be closures.
Therefore, this example does everything but the composition.
(Note: The names of the inverse functions may not display as intended unless you have the “TI Uni” font.)
<lang ti89b>Prgm
Local funs,invs,composed,x,i
Define rc_cube(x) = x^3 © Cannot be local variables Define rc_curt(x) = x^(1/3)
Define funs = {"sin","cos","rc_cube"}
Define invs = {"sin","cos","rc_curt"}
Define x = 0.5 Disp "x = " & string(x) For i,1,3 Disp "f=" & invs[i] & " g=" & funs[i] & " f(g(x))=" & string(#(invs[i])(#(funs[i])(x))) EndFor
DelVar rc_cube,rc_curt © Clean up our globals
EndPrgm</lang>
Ursala
The algorithm is to zip two lists of functions into a list of pairs of functions, make
that a list of functions by composing each pair, "gang" the list of
functions into a single function returning a list, and apply it to the
argument 0.5.
<lang Ursala>#import std
- import flo
functions = <sin,cos,times^/~& sqr> inverses = <asin,acos,math..cbrt>
- cast %eL
main = (gang (+)*p\functions inverses) 0.5</lang> In more detail,
(+)*p\functions inversesevaluates to(+)*p(inverses,functions)by definition of the reverse binary to unary combinator (\)- This expression evaluates to
(+)*p(<asin,acos,math..cbrt>,<sin,cos,times^/~& sqr>)by substitution. - The zipping is indicated by the
psuffix on the map operator, (*) so that(+)*pevaluates to(+)* <(asin,sin),(acos,cos),(cbrt,times^/~& sqr)>. - The composition (
(+)) operator is then mapped over the resulting list of pairs of functions, to obtain the list of functions<asin+sin,acos+cos,cbrt+ times^/~& sqr>. gang<aisn+sin,acos+cos,cbrt+ times^/~& sqr>expresses a function returning a list in terms of a list of functions.
output:
<5.000000e-01,5.000000e-01,5.000000e-01>