Function.Cts2Cts

java.lang.Object
- la.la.Value
- - la.la.Function
  - - la.la.Function.Native
    - - la.la.Function.Cts2Cts

All Implemented Interfaces:

java.lang.Comparable<Value>

Direct Known Subclasses:

Function.Cts2Cts.Derivative, Function.Cts2Cts.WithInverse, Library.Power

Enclosing class:

Function
```
public abstract static class Function.Cts2Cts
extends Function.Native
```
The class of Cts → Cts Functions. Define apply_x(.) and all else follows. A Cts2Cts has a derivative and an integral. Also see Function.Cts2Cts2Cts.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`Function.Cts2Cts.Derivative` This default Derivative of a given function '`f`' uses finite-differences – see `apply_x(x)` and `apply_xx(δ,x)`.
`class`	`Function.Cts2Cts.Integral` Integral: Cts→Cts→Cts (±) integrates `f` from 'lo' to 'hi'.
`static class`	`Function.Cts2Cts.WithInverse` This class exists so that one can create an anonymous `Cts2Cts` which (implements) `HasInverse`.

Nested classes/interfaces inherited from class la.la.Function
Function.Cts2Cts, Function.Cts2Cts2Cts, Function.CtsD2CtsD, Function.HasInverse, Function.Native, Function.Native2, Function.Native3

Nested classes/interfaces inherited from class la.la.Value
Value.Atomic, Value.Bool, Value.Char, Value.Chars, Value.Cts, Value.Defer, Value.Discrete, Value.Enum, Value.Inc_Or, Value.Int, Value.Lambda, Value.List, Value.Maybe, Value.Option, Value.Real, Value.Scannable, Value.Structured, Value.Triv, Value.Tuple

Field Summary
- Fields inherited from class la.la.Value
  C, comparator, CR, E, eight, ffalse, five, fiveR, four, fourR, half, negCR, negOne, negOneR, negTenR, nilVal, nine, None, one, oneR, PI, PIby2, point01, point1, point5, point9, quarter, seven, six, ten, tenR, three, threeR, triv, ttrue, two, twoR, zero, zeroR

Constructor Summary

Constructors
Constructor and Description

Cts2Cts()

Constructors
Constructor and Description
`Cts2Cts()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract double`	`apply_x(double x)` apply_x(x) is used by `apply(c)`.
`Value.Cts`	`apply(Value c)` Calls `apply_x(c.x())`.
`Function.Cts2Cts`	`d_dx()` Return the derivative of 'this' function, d/dx this.
`Function.Cts2Cts`	`d2_dx2()` The second derivative, d²/dx² this, that is `d_dx()` twice.
`Function.Cts2Cts2Cts`	`exactIntegral(Function.Cts2Cts F)` Creates a definite integral from an indefinite one, F, if such a closed form is known.
`static Function.Cts2Cts`	`fromFunction(Function f)` (Static) fromFunction(f) creates a Cts2Cts from a Function, 'f', where f is not an instance of class Cts2Cts but f does in fact accept, and return, Cts values.
`Function.Cts2Cts2Cts`	`integral()` Return the integral of 'this' function, ∫ this(x) dx.
`protected Function.Cts2Cts`	`make_d_dx()` Slave worker for `d_dx()`.
`protected Function.Cts2Cts2Cts`	`make_integral()` Slave worker for `integral()`.
`double`	`NewtonRaphson(double x0)` Use Newton-Raphson to solve f(x) = 0, where 'f' is 'this' Cts2Cts, given an initial guess, x0.
`double`	`root(double x0)` Solve f(x) = 0, where 'f' is 'this' Cts2Cts, given an initial guess, x0.
`double`	`turning(double x0)` Find a turning point of 'this' Cts2Cts, 'f', that is find x such that `f'(x)`=0, given an initial guess, x0.
`Function.Cts2Cts`	`uOp(int op)` For example, sin.uOp(minus) satisfies (sin.uOp(minus))(x) = −sin(x).

Methods inherited from class la.la.Function
bOp, fromBop, fromUop, main, toString, type

Methods inherited from class la.la.Value
AoM, bOp, compareTo, cons, cts, elt, errMsg, error, force, isTuple, just, n, nElts, nlAoM, pair, print, quad, real, RTE, triple, tuple, UOE, x

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - Cts2Cts
```
public Cts2Cts()
```
- Method Detail
  - apply_x
```
public abstract double apply_x(double x)
```
    apply_x(x) is used by apply(c). Define apply_x(.) to make an instance of Cts2Cts.
  - apply
```
public Value.Cts apply(Value c)
```
    Calls apply_x(c.x()). Note, if c.AoM()>zero, apply(.) also calls the derivative to get an AoM() for the result.
    
    Specified by:
    
    apply in class Function.Native
  - fromFunction
```
public static Function.Cts2Cts fromFunction(Function f)
```
    (Static) fromFunction(f) creates a Cts2Cts from a Function, 'f', where f is not an instance of class Cts2Cts but f does in fact accept, and return, Cts values.
  - uOp
```
public Function.Cts2Cts uOp(int op)
```
    For example, sin.uOp(minus) satisfies (sin.uOp(minus))(x) = −sin(x). Also see uOp(int).
    
    Overrides:
    
    uOp in class Function
  - turning
```
public double turning(double x0)
```
    Find a turning point of 'this' Cts2Cts, 'f', that is find x such that f'(x)=0, given an initial guess, x0. Uses root.
  - root
```
public double root(double x0)
```
    Solve f(x) = 0, where 'f' is 'this' Cts2Cts, given an initial guess, x0. Currently it uses NewtonRaphson(x0).
  - NewtonRaphson
```
public double NewtonRaphson(double x0)
```
    Use Newton-Raphson to solve f(x) = 0, where 'f' is 'this' Cts2Cts, given an initial guess, x0. The central step is x1=x0−f(x0)/df_dx_(x0); it helps if f has a closed-form derivative, d_dx. (If Newton-Raphson fails, plan B is binary search.)
  - d_dx
```
public final Function.Cts2Cts d_dx()
```
    Return the derivative of 'this' function, d/dx this. Caches the result of make_d_dx().
  - d2_dx2
```
public final Function.Cts2Cts d2_dx2()
```
    The second derivative, d²/dx² this, that is d_dx() twice.
  - make_d_dx
```
protected Function.Cts2Cts make_d_dx()
```
    Slave worker for d_dx(). This default returns new Derivative() which works by finite differences. Override make_d_dx if there is a closed form.
  - integral
```
public final Function.Cts2Cts2Cts integral()
```
    Return the integral of 'this' function, ∫ this(x) dx. Caches the result of make_integral(). Note that integral:R→R→R is a curried function, integral(ko)(hi)=_lo∫^hithis.
  - make_integral
```
protected Function.Cts2Cts2Cts make_integral()
```
    Slave worker for integral(). This default implementation returns new Integral() which uses numerical integretaion. Override make_integral if there is a closed form (as in Derivative). Also see exactIntegral(F).
  - exactIntegral
```
public Function.Cts2Cts2Cts exactIntegral(Function.Cts2Cts F)
```
    Creates a definite integral from an indefinite one, F, if such a closed form is known. That is if there is an F such that _lo∫^hithis=F(hi)−F(lo). In such a case exactIntegral(F) can be used in make_integral().

Class Function.Cts2Cts

Nested Class Summary

Nested classes/interfaces inherited from class la.la.Function

Nested classes/interfaces inherited from class la.la.Value

Field Summary

Fields inherited from class la.la.Value

Constructor Summary

Method Summary

Methods inherited from class la.la.Function

Methods inherited from class la.la.Value

Methods inherited from class java.lang.Object

Constructor Detail

Cts2Cts

Method Detail

apply_x

apply

fromFunction

uOp

turning

root

NewtonRaphson

d_dx

d2_dx2

make_d_dx

integral

make_integral

exactIntegral