Next: Invoking astarithmetic, Previous: Reverse polish notation, Up: Arithmetic [Contents][Index]
The recognized operators in Arithmetic are listed below. See Reverse polish notation for more on how the operators and operands should be
ordered on the commandline. The operands to all operators can be a data
array (for example a FITS image) or a number, the output will be an array
or number according to the inputs. For example a number multiplied by an
array will produce an array. The conditional operators will return pixel,
or numerical values of 0 (false) or 1 (true) and stored in an
unsigned char
data type (see Numeric data types).
+
Addition, so “4 5 +
” is equivalent to \(4+5\).

Subtraction, so “4 5 
” is equivalent to \(45\).
x
Multiplication, so “4 5 x
” is equivalent to
\(4\times5\).
/
Division, so “4 5 /
” is equivalent to \(4/5\).
%
Modulo (remainder), so “3 2 %
” is equivalent to
\(1\). Note that the modulo operator only works on integer types.
abs
Absolute value of first operand, so “4 abs
” is
equivalent to \(4\).
pow
First operand to the power of the second, so “4.3 5f pow
” is
equivalent to \(4.3^{5}\). Currently pow
will only work on
single or double precision floating point numbers or images. To be sure
that a number is read as a floating point (even if it doesn’t have any
nonzero decimals) put an f
after it.
sqrt
The square root of the first operand, so “5 sqrt
” is equivalent
to \(\sqrt{5}\). The output type is determined from the input, so the
output of this example will be 2
(since 5
doesn’t have
any nonzero decimal digits). If you want 2.23607
, run
5f sqrt
instead, the f
will ensure that a number will
be read as a floating point number, even if it doesn’t have decimal
digits. If the input image has an integer type, you should explicitly
convert the image to floating point, for example a.fits float
sqrt
, see the type conversion operators below.
log
Natural logarithm of first operand, so “4 log
” is equivalent to
\(\ln(4)\). The output type is determined from the input, see the
explanation under sqrt
for more.
log10
Base10 logarithm of first operand, so “4 log10
” is equivalent
to \(\log(4)\). The output type is determined from the input, see the
explanation under sqrt
for more.
minvalue
Minimum (nonblank) value in the top operand on the stack, so
“a.fits minvalue
” will push the the minimum pixel value in this
image onto the stack. Therefore this operator is mainly intended for data
(for example images), if the top operand is a number, this operator just
returns it without any change. So note that when this operator acts on a
single image, the output will no longer be an image, but a number. The
output of this operand is in the same type as the input.
maxvalue
Maximum (nonblank) value of first operand in the same type, similar to
minvalue
.
numvalue
Number of nonblank elements in first operand in the uint64
type,
similar to minvalue
.
sumvalue
Sum of nonblank elements in first operand in the float32
type,
similar to minvalue
.
meanvalue
Mean value of nonblank elements in first operand in the float32
type, similar to minvalue
.
stdvalue
Standard deviation of nonblank elements in first operand in the
float32
type, similar to minvalue
.
medianvalue
Median of nonblank elements in first operand with the same type, similar
to minvalue
.
min
The first popped operand to this operator must be a positive integer number which specifies how many further operands should be popped from the stack. The given number of operands must have the same type and size. Each pixel of the output of this operator will be set to the minimum value of the given number of operands (images) in that pixel.
For example the following command will produce an image with the same size and type as the inputs but each output pixel is set to the minimum respective pixel value of the three input images.
$ astarithmetic a.fits b.fits c.fits 3 min
Important notes:
min
and max
operators, but for other similar operators
(for example sum
, or average
) the perpixel operations
will be done in double precision floating point and then stored back in the
input type. Therefore, if the input was an integer, C’s internal type
conversion will be used.
max
Similar to min
, but the pixels of the output will contain
the maximum of the respective pixels in all operands in the stack.
num
Similar to min
, but the pixels of the output will contain the
number of the respective nonblank pixels in all input operands.
sum
Similar to min
, but the pixels of the output will contain the sum
of the respective pixels in all input operands.
mean
Similar to min
, but the pixels of the output will contain the
mean (average) of the respective pixels in all operands in the stack.
std
Similar to min
, but the pixels of the output will contain the
standard deviation of the respective pixels in all operands in the stack.
median
Similar to min
, but the pixels of the output will contain
the median of the respective pixels in all operands in the stack.
lt
Less than: If the second popped (or left operand in infix notation, see
Reverse polish notation) value is smaller than the first popped
operand, then this function will return a value of 1, otherwise it will
return a value of 0. If both operands are images, then all the pixels will
be compared with their counterparts in the other image. If only one operand
is an image, then all the pixels will be compared with the the single value
(number) of the other operand. Finally if both are numbers, then the output
is also just one number (0 or 1). When the output is not a single number,
it will be stored as an unsigned char
type.
le
Less or equal: similar to lt
(‘less than’ operator), but returning 1
when the second popped operand is smaller or equal to the first.
gt
Greater than: similar to lt
(‘less than’ operator), but
returning 1 when the second popped operand is greater than the first.
ge
Greater or equal: similar to lt
(‘less than’ operator), but
returning 1 when the second popped operand is larger or equal to the first.
eq
Equality: similar to lt
(‘less than’ operator), but returning 1 when
the two popped operands are equal (to double precision floating point
accuracy).
ne
NonEquality: similar to lt
(‘less than’ operator), but returning 1
when the two popped operands are not equal (to double precision
floating point accuracy).
and
Logical AND: returns 1 if both operands have a nonzero value and 0 if both are zero. Both operands have to be the same kind: either both images or both numbers.
or
Logical OR: returns 1 if either one of the operands is nonzero and 0 only when both operators are zero. Both operands have to be the same kind: either both images or both numbers.
not
Logical NOT: returns 1 when the operand is zero and 0 when the operand is nonzero. The operand can be an image or number, for an image, it is applied to each pixel separately.
isblank
Test for a blank value (see Blank pixels). In essence, this is very similar to the conditional operators: the output is either 1 or 0 (see the ‘less than’ operator above). The difference is that it only needs one operand. Because of the definition of a blank pixel, a blank value is not even equal to itself, so you cannot use the equal operator above to select blank pixels. See the “Blank pixels” box below for more on Blank pixels in Arithmetic.
where
Change the input (pixel) value where/if a certain condition
holds. The conditional operators above can be used to define the
condition. Three operands are required for where
. The input
format is demonstrated in this simplified example:
$ astarithmetic modify.fits binary.fits iftrue.fits where
The value of any pixel in modify.fits that corresponds to a nonzero pixel of binary.fits will be changed to the value of the same pixel in iftrue.fits (this may also be a number). The 3rd and 2nd popped operands (modify.fits and binary.fits respectively, see Reverse polish notation) have to have the same dimensions/size. iftrue.fits can be either a number, or have the same dimension/size as the other two.
The 2nd popped operand (binary.fits) has to have uint8
(or
unsigned char
in standard C) type (see Numeric data types). It
is treated as a binary dataset (with only two values: zero and nonzero,
hence the name binary.fits
in this example). However, commonly you
won’t be dealing with an actual FITS file of a condition/binary image. You
will probably define the condition in the same run based on some other
reference image and use the conditional and logical operators above to make
a true/false (or one/zero) image for you internally. For example the case
below:
$ astarithmetic in.fits reference.fits 100 gt new.fits where
In the example above, any of the in.fits pixels that has a value in
reference.fits greater than 100
, will be replaced with the
corresponding pixel in new.fits. Effectively the
reference.fits 100 gt
part created the condition/binary image which
was added to the stack (in memory) and later used by where
. The
command above is thus equivalent to these two commands:
$ astarithmetic reference.fits 100 gt output=binary.fits $ astarithmetic in.fits binary.fits new.fits where
Finally, the input operands are read and used independently, so you can use the same file more than once as any of the operands.
When the 1st popped operand to where
(iftrue.fits) is a
single number, it may be a NaN value (or any blank value, depending on its
type) like the example below (see Blank pixels). When the number is
blank, it will be converted to the blank value of the type of the 3rd
popped operand (in.fits
). Hence, in the example below, all the
pixels in reference.fits that have a value greater than 100, will
become blank in the natural data type of in.fits (even though NaN
values are only defined for floating point types).
$ astarithmetic in.fits reference.fits 100 gt nan where
bitand
Bitwise AND operator: only bits with values of 1 in both popped operands
will get the value of 1, the rest will be set to 0. For example (assuming
numbers can be written as bit strings on the commandline): 00101000
00100010 bitand
will give 00100000
. Note that the bitwise operators
only work on integer type datasets.
bitor
Bitwise inclusive OR operator: The bits where at least one of the two popped
operands has a 1 value get a value of 1, the others 0. For example
(assuming numbers can be written as bit strings on the commandline):
00101000 00100010 bitand
will give 00101010
. Note that the
bitwise operators only work on integer type datasets.
bitxor
Bitwise exclusive OR operator: A bit will be 1 if it differs between the
two popped operands. For example (assuming numbers can be written as bit
strings on the commandline): 00101000 00100010 bitand
will give
00001010
. Note that the bitwise operators only work on integer type
datasets.
lshift
Bitwise left shift operator: shift all the bits of the first operand to the
left by a number of times given by the second operand. For example
(assuming numbers can be written as bit strings on the commandline):
00101000 2 lshift
will give 10100000
. This is equivalent to
multiplication by 4. Note that the bitwise operators only work on integer
type datasets.
rshift
Bitwise right shift operator: shift all the bits of the first operand to
the right by a number of times given by the second operand. For example
(assuming numbers can be written as bit strings on the commandline):
00101000 2 rshift
will give 00001010
. Note that the bitwise
operators only work on integer type datasets.
bitnot
Bitwise not (more formally known as one’s complement) operator: flip all
the bits of the popped operand (note that this is the only unary, or single
operand, bitwise operator). In other words, any bit with a value of
0
is changed to 1
and viceversa. For example (assuming
numbers can be written as bit strings on the commandline): 00101000
bitnot
will give 11010111
. Note that the bitwise operators only
work on integer type datasets/numbers.
uint8
Convert the type of the popped operand to 8bit unsigned integer type (see Numeric data types). The internal conversion of C will be used.
int8
Convert the type of the popped operand to 8bit signed integer type (see Numeric data types). The internal conversion of C will be used.
uint16
Convert the type of the popped operand to 16bit unsigned integer type (see Numeric data types). The internal conversion of C will be used.
int16
Convert the type of the popped operand to 16bit signed integer (see Numeric data types). The internal conversion of C will be used.
uint32
Convert the type of the popped operand to 32bit unsigned integer type (see Numeric data types). The internal conversion of C will be used.
int32
Convert the type of the popped operand to 32bit signed integer type (see Numeric data types). The internal conversion of C will be used.
uint64
Convert the type of the popped operand to 64bit unsigned integer (see Numeric data types). The internal conversion of C will be used.
float32
Convert the type of the popped operand to 32bit (single precision) floating point (see Numeric data types). The internal conversion of C will be used.
float64
Convert the type of the popped operand to 64bit (double precision) floating point (see Numeric data types). The internal conversion of C will be used.
Blank pixels in Arithmetic: Blank pixels in the image (see
Blank pixels) will be stored based on the data type. When the input
is floating point type, blank values are NaN. One aspect of NaN values is
that by definition they will fail on any comparison. Hence both
equal and notequal operators will fail when both their operands are NaN!
Therefore, the only way to guarantee selection of blank pixels is through
the One way you can exploit this property of the NaN value to your advantage is when you want a fully zerovalued image (even over the blank pixels) based on an already existing image (with same size and world coordinate system settings). The following command will produce this for you: $ astarithmetic input.fits nan eq output=allzeros.fits Note that on the commandline you can write NaN in any case (for example

Next: Invoking astarithmetic, Previous: Reverse polish notation, Up: Arithmetic [Contents][Index]
JavaScript license information
GNU Astronomy Utilities 0.4 manual, September 2017.