Uses of Class
de.cm.frw.core.fun.impl.Function

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)