`gemath`

Examples: Array
Creation and Information
This web page provides examples of using various `gemath`

array manipulation functions.

For more information see the
module listing documentation.
Or, for any command *cmd*,
type `help(`

*cmd*`)`

at the Python
prompt to get the docstring documentation.

In all the examples, assume the following import statements have been made:

>>> import Numeric as N >>> import gemath as G

Often you'll want to create an array filled with the equivalent
1-D indices (i.e. the address an element would have if the array
was `ravel`

'ed).
`Numeric`

's `arange`

function does this for
vectors:

>>> a = N.arange(6) >>> a [0,1,2,3,4,5,] >>> a = N.arange(6.0) >>> a [ 0., 1., 2., 3., 4., 5.,]

How can you do this for arrays of arbitrary dimension? The
`gemath`

`dindgen`

,
`findgen`

, and
`lindgen`

functions do this. They have the
same syntax and produce the same results, with the only
difference being that
`dindgen`

produces a double-precision floating array,
`findgen`

a single-precision floating array, and
`lindgen`

a long integer array:

>>> a = G.findgen(6) >>> a [ 0., 1., 2., 3., 4., 5.,] >>> a = G.findgen((2,3)) >>> a [[ 0., 1., 2.,] [ 3., 4., 5.,]] >>> a = G.findgen((3,2)) >>> a [[ 0., 1.,] [ 2., 3.,] [ 4., 5.,]]

If the argument for `*indgen`

is scalar, a rank 1 vector
is created with that number of elements. If the argument is a
tuple, an array is created with a shape give by that tuple.

Because floating point numbers are not exactly represented in
binary computers, you have to be careful when comparing floating
point numbers. `Numeric`

provides the function
`allclose`

which checks whether two arrays (or one
array and a scalar) are element-wise "equal" to each other.
If the arrays are integer, exact comparison is used.
If they are floating,
safe
comparisons are done.

** has_close:**
In

`gemath`

the `has_close`

function
does an element-wise comparison of an array to a scalar.
If any of the elements equals the scalar, 1 is returned;
otherwise 0 is returned. Safe comparison is used if the
type is floating:

>>> a = G.findgen(6) >>> a [ 0., 1., 2., 3., 4., 5.,] >>> G.has_close(a, 2.) 1 >>> G.has_close(a, 2.00001) 1 >>> G.has_close(a, 2.0001) 0

** where_close:**
If you want produce a mask showing which elements of an
array are equal to another array (or an array and/or scalar
combination), you can use the

`where_close`

function. Again, if either input is floating, safe comparisons
are used. If the inputs are all integer, strict comparison is used:

>>> a = G.findgen(6) >>> a [ 0., 1., 2., 3., 4., 5.,] >>> G.where_close(a, 2.00001) [0,0,1,0,0,0,] >>> G.where_close(a, 2.0001) [0,0,0,0,0,0,] >>> b = N.array([1., 3., 2., -2., 4., 5.]) >>> G.where_close(a, b) [0,0,1,0,1,1,]