public class MathMap extends Mapping
This program is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public Licence for more details.
You should have received a copy of the GNU General Public Licence along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street,Fifth Floor, Boston, MA 02110-1301, USA
Mapping.Interpolator, Mapping.SpreaderLINEAR_INTERPOLATOR, LINEAR_SPREADER, NEAREST_INTERPOLATOR, NEAREST_SPREADERAST__BAD, AST__TUNULL, pointer| Constructor and Description |
|---|
MathMap(int nin,
int nout,
String[] fwd,
String[] inv)
Create a MathMap.
|
| Modifier and Type | Method and Description |
|---|---|
int |
getSeed()
Get
random number seed for a MathMap.
|
boolean |
getSimpFI()
Get
forward-inverse MathMap pairs simplify.
|
boolean |
getSimpIF()
Get
inverse-forward MathMap pairs simplify.
|
void |
setSeed(int seed)
Set
random number seed for a MathMap.
|
void |
setSimpFI(boolean simpFI)
Set
forward-inverse MathMap pairs simplify.
|
void |
setSimpIF(boolean simpIF)
Set
inverse-forward MathMap pairs simplify.
|
decompose, getInvert, getNin, getNout, getReport, getTranForward, getTranInverse, invert, linearApprox, mapBox, mapSplit, rate, rebin, rebinD, rebinF, rebinI, resample, resampleB, resampleD, resampleF, resampleI, resampleL, resampleS, setInvert, setReport, simplify, tran1, tran2, tranGrid, tranN, tranPannul, clear, copy, delete, equals, finalize, getAstConstantI, getB, getC, getD, getF, getI, getID, getIdent, getL, getNobject, getObjSize, getRefCount, hashCode, isThreaded, reportVersions, sameObject, set, setB, setC, setD, setF, setI, setID, setIdent, setL, show, test, tunepublic MathMap(int nin,
int nout,
String[] fwd,
String[] inv)
A MathMap is a Mapping which allows you to specify a set of forward and/or inverse transformation functions using arithmetic operations and mathematical functions similar to those available in C. The MathMap interprets these functions at run-time, whenever its forward or inverse transformation is required. Because the functions are not compiled in the normal sense (unlike an IntraMap), they may be used to describe coordinate transformations in a transportable manner. A MathMap therefore provides a flexible way of defining new types of Mapping whose descriptions may be stored as part of a dataset and interpreted by other programs.
which defines a transformation from Cartesian to polar coordinates. Here, the variables that appear on the left of each expression ("r" and "theta") provide names for the output variables and those that appear on the right ("x" and "y") are references to input variables.
To complement this, you must also supply expressions for the inverse
transformation via the "inv" parameter. In this case, the number of
expressions given would normally match the number of MathMap input
coordinates (given by the Nin attribute). If Nin is 2, you might use:
- "x = r * cos( theta )"
- "y = r * sin( theta )"
which expresses the transformation from polar to Cartesian coordinates. Note that here the input variables ("x" and "y") are named on the left of each expression, and the output variables ("r" and "theta") are referenced on the right.
Normally, you cannot refer to a variable on the right of an expression
unless it is named on the left of an expression in the complementary
set of functions. Therefore both sets of functions (forward and
inverse) must be formulated using the same consistent set of variable
names. This means that if you wish to leave one of the transformations
undefined, you must supply dummy expressions which simply name each of
the output (or input) variables. For example, you might use:
- "x"
- "y"
for the inverse transformation above, which serves to name the input variables but without defining an inverse transformation.
Here, we first calculate three intermediate results ("r", "rout" and "theta") and then use these to calculate the final results ("xout" and "yout"). The MathMap knows that only the final two results constitute values for the output variables because its Nout attribute is set to 2. You may define as many intermediate variables in this way as you choose. Having defined a variable, you may then refer to it on the right of any subsequent expressions.
Note that when defining the inverse transformation you may only refer to the output variables "xout" and "yout". The intermediate variables "r", "rout" and "theta" (above) are private to the forward transformation and may not be referenced by the inverse transformation. The inverse transformation may, however, define its own private intermediate variables.
A <bad> result (i.e. equal to AST__BAD) is also produced in response to any numerical error (such as division by zero or numerical overflow), or if an invalid argument value is provided to a function or operator.
The following boolean operators are available:
- x1 && x2: Boolean AND between "x1" and "x2", returning 1 if both "x1"
and "x2" are non-zero, and 0 otherwise. This operator implements
tri-state logic. (The synonym ".and." is also provided for compatibility
with Fortran.)
- x1 || x2: Boolean OR between "x1" and "x2", returning 1 if either "x1"
or "x2" are non-zero, and 0 otherwise. This operator implements
tri-state logic. (The synonym ".or." is also provided for compatibility
with Fortran.)
- x1 ^^ x2: Boolean exclusive OR (XOR) between "x1" and "x2", returning
1 if exactly one of "x1" and "x2" is non-zero, and 0 otherwise. Tri-state
logic is not used with this operator. (The synonyms ".neqv." and ".xor."
are also provided for compatibility with Fortran, although the second
of these is not standard.)
- x1 .eqv. x2: This is provided only for compatibility with Fortran
and tests whether the boolean states of "x1" and "x2" (i.e. true/false)
are equal. It is the negative of the exclusive OR (XOR) function.
Tri-state logic is not used with this operator.
- ! x: Boolean unary NOT operation, returning 1 if "x" is zero, and
0 otherwise. (The synonym ".not." is also provided for compatibility
with Fortran.)
The following relational operators are available:
- x1 == x2: Tests whether "x1" equals "x1". (The synonym ".eq." is
also provided for compatibility with Fortran.)
- x1 != x2: Tests whether "x1" is unequal to "x2". (The synonym ".ne."
is also provided for compatibility with Fortran.)
- x1 > x2: Tests whether "x1" is greater than "x2". (The synonym
".gt." is also provided for compatibility with Fortran.)
- x1 >= x2: Tests whether "x1" is greater than or equal to "x2". (The
synonym ".ge." is also provided for compatibility with Fortran.)
- x1 < x2: Tests whether "x1" is less than "x2". (The synonym ".lt."
is also provided for compatibility with Fortran.)
- x1 <= x2: Tests whether "x1" is less than or equal to "x2". (The
synonym ".le." is also provided for compatibility with Fortran.)
Note that relational operators cannot usefully be used to compare values with the <bad> value (representing missing data), because the result is always <bad>. The isbad() function should be used instead.
The following bitwise operators are available:
- x1 >> x2: Rightward bit shift. The integer value of "x2" is taken
(rounding towards zero) and the bits representing "x1" are then
shifted this number of places to the right (or to the left if the
number of places is negative). This is equivalent to dividing "x1" by
the corresponding power of 2.
- x1 << x2: Leftward bit shift. The integer value of "x2" is taken
(rounding towards zero), and the bits representing "x1" are then
shifted this number of places to the left (or to the right if the
number of places is negative). This is equivalent to multiplying "x1"
by the corresponding power of 2.
- x1 & x2: Bitwise AND between the bits of "x1" and those of "x2"
(equivalent to a boolean AND applied at each bit position in turn).
- x1 | x2: Bitwise OR between the bits of "x1" and those of "x2"
(equivalent to a boolean OR applied at each bit position in turn).
- x1 ^ x2: Bitwise exclusive OR (XOR) between the bits of "x1" and
those of "x2" (equivalent to a boolean XOR applied at each bit
position in turn).
Note that no bit inversion operator ("~" in C) is provided. This is because inverting the bits of a twos-complement fixed point binary number is equivalent to simply negating it. This differs from the pure integer case because bits to the right of the binary point are also inverted. To invert only those bits to the left of the binary point, use a bitwise exclusive OR with the value -1 (i.e. "x^-1").
All operators associate from left-to-right, except for unary +, unary -, !, .not. and ** which associate from right-to-left.
nin - Number of input variables for the MathMap. This determines the
value of its Nin attribute.nout - Number of output variables for the MathMap. This determines the
value of its Nout attribute.fwd - an array of Strings describing the forward transformations.
There should be at least nout of these, but
there may be more
(see the note on "Calculating intermediate values").inv - an array of Strings describing the inverse transformations.
There should be at least nin of these, but
there may be more
(see the note on "Calculating intermediate values").AstException - if an error occurred in the AST librarypublic int getSeed()
If required, you may set this Seed attribute to a value of your choosing in order to produce repeatable behaviour from the random number functions. You may also enquire the Seed value (e.g. if an initially unpredictable value has been used) and then use it to reproduce the resulting sequence of random numbers, either from the same MathMap or from another one.
Clearing the Seed attribute gives it a new unpredictable default value.
public void setSeed(int seed)
If required, you may set this Seed attribute to a value of your choosing in order to produce repeatable behaviour from the random number functions. You may also enquire the Seed value (e.g. if an initially unpredictable value has been used) and then use it to reproduce the resulting sequence of random numbers, either from the same MathMap or from another one.
Clearing the Seed attribute gives it a new unpredictable default value.
seed - the Seed attribute of this objectpublic boolean getSimpFI()
By default, the SimpFI attribute is zero, so that AST will not perform this simplification unless you have set SimpFI to indicate that it is safe to do so.
public void setSimpFI(boolean simpFI)
By default, the SimpFI attribute is zero, so that AST will not perform this simplification unless you have set SimpFI to indicate that it is safe to do so.
simpFI - the SimpFI attribute of this objectpublic boolean getSimpIF()
By default, the SimpIF attribute is zero, so that AST will not perform this simplification unless you have set SimpIF to indicate that it is safe to do so.
public void setSimpIF(boolean simpIF)
By default, the SimpIF attribute is zero, so that AST will not perform this simplification unless you have set SimpIF to indicate that it is safe to do so.
simpIF - the SimpIF attribute of this objectCopyright © 2024 Central Laboratory of the Research Councils. All Rights Reserved.