|
|||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of Function in de.cm.frw.core.fun.impl |
---|
Subclasses of Function in de.cm.frw.core.fun.impl | |
---|---|
static class |
LP.ConsCell
A functional implementation of an (immutable) cons cell where values for car and cdr are captured in a closure when the cons cell function is created. |
static class |
LP.ConsPair
Use a ConsCell to implement Pair |
static class |
LP.EmptyConsCell
|
static class |
NUM.Binary
Class to simplify the definition of numerical with two argument. |
static class |
NUM.BinaryTest
|
static class |
NUM.Unary
Class to simplify the definition of numerical with one argument. |
class |
PF
PF is a name space for static components in support of pure functional programming. |
Fields in de.cm.frw.core.fun.impl declared as Function | |
---|---|
static Function |
PF.adapt
adapt is a function of three arguments
f : a function of n arguments
i : an integer with 0 <= i < n
g : a function of one argument
that produces a new function a of n arguments that computes its result
by applying f to its arguments using g(x) in parameter position i: |
static Function |
NUM.add
Function to add two numbers |
static Function |
FP.add
|
static Function |
FP.alpha
Apply to all elements of a sequence. |
static Function |
FP.and
|
static Function |
FP.apndl
Append left |
static Function |
FP.apndr
Append left |
static Function |
LP.append
|
static Function |
FP.atom
atom tests if the given argument is an atom
(i.e. |
static Function |
NUM.avgDamp
|
static Function |
PF.bind
bind is a function of three arguments
f : a function of n arguments
i : an integer with 0 <= i < n
x : an Object
that produces a new function b of n - 1 arguments that computes its result
by applying f to its n - 1 arguments using x in parameter position i: |
static Function |
FP.bu
Binary to unary |
static Function |
LP.car
|
static Function |
LP.cdr
|
static Function |
PF.compose
compose is a function of two arguments
f : a function of one argument
g : a function of n arguments
that produces an new function c of n arguments (i.e. |
static Function |
FP.compose
Returns the composition of functions f and g: |
static Function |
FP.cond
conditional function application |
static Function |
LP.cons
The cons function creates a cons cell with the given objects |
static Function |
FP.constant
Returns a constant function with given value: |
static Function |
FP.construct
Combines functions in given collection into a function producing a sequence of results f_i(x). |
static Function |
NUM.continuedFraction
|
static Function |
LZ.delay
(delay <exp>)
is syntactic sugar for
(lambda () <exp>) |
static Function |
NUM.deriv
|
static Function |
FP.distl
Distribute left |
static Function |
FP.distr
Distribute right |
static Function |
NUM.divide
Function to divide two numbers |
static Function |
FP.divide
|
static Function |
LZ.enumerateInterval
|
static Function |
FP.eq
Equals: |
static Function |
NUM.equal
|
static Function |
LZ.filter
|
static Function |
LP.filter
|
static Function |
NUM.fixedPoint
|
static Function |
LZ.force
Force simply calls the procedure (of no arguments) produced by delay, so we can implement force as a procedure: |
static Function |
FP.id
Identity: |
static Function |
FP.insert
Insert a binary function into a sequence. |
static Function |
NUM.inv
|
static Function |
FP.length
Length |
static Function |
LP.list
The list function takes 0 or more arguments to form a list made from cons cells |
static Function |
PF.map
|
static Function |
MAP.map
|
static Function |
LZ.map
|
static Function |
NUM.min
|
static Function |
NUM.multiply
Function to multiply two numbers |
static Function |
FP.multiply
|
static Function |
NUM.newtonsMethod
|
static Function |
FP.not
|
static Function |
FP.nul
Null: function to test if a given object is the empty sequence |
static Function |
FP.or
|
static Function |
NUM.power
|
static Function |
PF.reduce
reduce is a function of two arguments
f : a function of two arguments,
init : an object
that produces a new Function R of one arguments
I : an Iterable instance { i_1, ..., i_n }
as follows: |
static Function |
LP.reduce
|
static Function |
FP.reverse
Reverse |
static Function |
FP.rotl
|
static Function |
FP.rotr
|
static Function |
FP.rsel
rsel creates a numeric selector function (counting from one) |
static Function |
FP.rtail
rtail produces the tail of a sequence x , i.e. |
static Function |
FP.sel
sel creates a numeric selector function (counting from one) |
static Function |
NUM.sqrt
|
static Function |
NUM.square
|
static Function |
FP.substract
|
static Function |
NUM.subtract
Function to subtract two numbers |
static Function |
FP.tail
tail produces the tail of a sequence x , i.e. |
static Function |
FP.transpose
|
static Function |
PF.unary
unary is a function of one argument
f : a function of n parameters
that produces a new function U of one argument
x : an object
that puts its single argument x in all parameter positions of f, hence |
static Function |
FP.whyle
Build a while loop from a given predicate p
and a function f : |
Methods in de.cm.frw.core.fun.impl that return Function | |
---|---|
static Function |
PF.adapt(Function f,
int i,
Function a)
|
static Function |
NUM.avgDamp(Function f)
|
static Function |
PF.bind(Function f,
int i,
java.lang.Object arg)
|
static Function |
PF.compose(Function f,
Function g)
|
static Function |
FP.compose(Function f,
Function g)
|
static Function |
LZ.cons(java.lang.Object a,
Function f,
java.util.Collection args)
Cons-stream is a special form defined so that (cons-stream ) is equivalent to
(cons (delay )) |
static Function |
LZ.delay(Function f,
java.util.Collection args)
Use the functional member delay to delay the application of a given function to the given arguments |
static Function |
NUM.derive(Function g)
|
static Function |
NUM.derive(Function g,
double dx)
|
static Function |
PF.map(Function f)
|
static Function |
MAP.map(java.util.Map map)
|
static Function |
MAP.map(java.lang.Object[][] pairs)
|
static Function |
MAP.map(java.lang.Object[] keys,
java.lang.Object[] values)
|
static Function |
MAP.map(java.lang.Object[] keys,
java.lang.Object[] values,
java.util.Map emptyMap)
|
static Function |
LP.mapcan(Function f,
Function lst)
|
static Function |
PF.reduce(Function f,
java.lang.Object init)
|
static Function |
FP.rsel(int s)
Method to simplify using rsel |
static Function |
FP.sel(int s)
Method to simplify using sel |
static Function |
PF.unary(Function f)
|
static Function |
FP.whyle(Predicate p,
Function f)
|
Methods in de.cm.frw.core.fun.impl with parameters of type Function | |
---|---|
static Function |
PF.adapt(Function f,
int i,
Function a)
|
PF |
PF.adapt(int pos,
Function a)
|
static Function |
NUM.avgDamp(Function f)
|
static Function |
PF.bind(Function f,
int i,
java.lang.Object arg)
|
PF |
PF.compose(Function g)
|
static Function |
PF.compose(Function f,
Function g)
|
static Function |
FP.compose(Function f,
Function g)
|
static Function |
LZ.cons(java.lang.Object a,
Function f,
java.util.Collection args)
Cons-stream is a special form defined so that (cons-stream ) is equivalent to
(cons (delay )) |
static Function |
LZ.delay(Function f,
java.util.Collection args)
Use the functional member delay to delay the application of a given function to the given arguments |
static Function |
NUM.derive(Function g)
|
static Function |
NUM.derive(Function g,
double dx)
|
static java.lang.Number |
NUM.fixedPoint(Function f,
double guess)
|
static Predicate |
Pred.fromFunction(Function f)
|
static Function |
PF.map(Function f)
|
static java.lang.Iterable |
Function.map(Function f,
java.lang.Iterable args)
|
static java.lang.Object |
LZ.map(Function f,
java.lang.Object steam)
|
static Function |
LP.mapcan(Function f,
Function lst)
|
static Function |
PF.reduce(Function f,
java.lang.Object init)
|
static java.lang.Object |
Function.reduce(java.lang.Iterable args,
Function f,
java.lang.Object initial)
|
static Function |
PF.unary(Function f)
|
static Function |
FP.whyle(Predicate p,
Function f)
|
Constructors in de.cm.frw.core.fun.impl with parameters of type Function | |
---|---|
LP.List(Function l)
|
|
PF(Function f)
|
|
Stream.Lazy(java.lang.Object init,
Function generator)
|
|
|||||||||
PREV NEXT | FRAMES NO FRAMES |