sin
Returns the trigonometric sine of its argument. The returned value will be real, complex, or a matrix, depending on the argument. By default, the argument is in radians. This can be changed by specifying the switch /deg.
Syntax
result = sin(angle [, /deg])
Arguments
angle: a number (integer, real, complex) or a matrix, specifying the angle for which the sine is to be calculated. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
Switches
/deg: The argument is in degrees
Examples
To find the sine of the angle 90 degrees, type:
<code>print sin(90, /deg)
See also
function_cos
function_tan
category_trigonometry

cos
Returns the trigonometric cosine of its argument. The returned value will be real, complex, or a matrix, depending on the argument. By default, the argument is in radians. This can be changed by specifying the switch /deg.
Syntax
result = cos(angle [, /deg])
Arguments
angle: a number (integer, real, complex) or a matrix, specifying the angle for which the cosine is to be calculated. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
Switches
/deg: The argument is in degrees
Examples
To find the cosine of the angle 90 degrees, type:
<code>print cos(90, /deg)
See also
function_sin
function_tan
category_trigonometry

tan
Returns the trigonometric tangent of its argument. The returned value will be real, complex, or a matrix, depending on the argument. By default, the argument is in radians. This can be changed by specifying the switch /deg.
Syntax
result = tan(angle [, /deg])
Arguments
angle: a number (integer, real, complex) or a matrix, specifying the angle for which the tangent is to be calculated. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
Switches
/deg: The argument is in degrees
Examples
To find the tangent of the angle 45 degrees, type:
<code>print tan(45, /deg)
See also
function_sin
function_cos
category_trigonometry

sinh
Returns the hyperbolic sine of its argument. The returned value will be real, complex, or a matrix, depending on the argument. By default, the argument is in radians. This can be changed by specifying the switch /deg.
Syntax
result = sinh(angle [, /deg])
Arguments
angle: a number (integer, real, complex) or a matrix, specifying the angle for which the hyperbolic sine is to be calculated. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
Switches
/deg: The argument is in degrees
Examples
To find the hyperbolic sine of the angle 90 degrees, type:
<code>print sinh(90, /deg)
See also
function_cosh
function_tanh
category_trigonometry

cosh
Returns the hyperbolic cosine of its argument. The returned value will be real, complex, or a matrix, depending on the argument. By default, the argument is in radians. This can be changed by specifying the switch /deg.
Syntax
result = cosh(angle [, /deg])
Arguments
angle: a number (integer, real, complex) or a matrix, specifying the angle for which the hyperbolic cosine is to be calculated. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
Switches
/deg: The argument is in degrees
Examples
To find the hyperbolic cosine of the angle 90 degrees, type:
<code>print cosh(90, /deg)
See also
function_sinh
function_tanh
category_trigonometry

tanh
Returns the hyperbolic tangent of its argument. The returned value will be real, complex, or a matrix, depending on the argument. By default, the argument is in radians. This can be changed by specifying the switch /deg.
Syntax
result = tanh(angle [, /deg])
Arguments
angle:a number (integer, real, complex) or a matrix, specifying the angle for which the hyperbolic tangent is to be calculated. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
Switches
/deg: The argument is in degrees
Examples
To find the hyperbolic tangent of the angle 45 degrees, type:
<code>print tanh(45, /deg)
See also
function_sinh
function_cosh
category_trigonometry

asin
Returns the arcus sine of its argument, which can be either real, complex or a matrix. The returned value's type is changed to complex if necessary (when the absolute value of the argument is greater than 1). By default, the returned value is in radians. This can be changed by specifying the switch /deg.
Syntax
result = asin(X [, /deg])
Arguments
X: a number (integer, real, complex) or a matrix, specifying the sine of the angle to be returned. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
Switches
/deg: The result will be in degrees
Examples
To find the angle (in degrees) whose sine is 0.5, type:
<code>print asin(0.5, /deg)
See also
function_acos
function_atan
category_trigonometry

acos
Returns the arcus cosine of its argument, which can be either real, complex or a matrix. The returned value's type is changed to complex if necessary (when the absolute value of the argument is greater than 1). By default, the returned value is in radians. This can be changed by specifying the switch /deg.
Syntax
result = acos(X [, /deg])
Arguments
X: a number (integer, real, complex) or a matrix, specifying the cosine of the angle to be returned. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
Switches
/deg: The result will be in degrees
Examples
To find the angle (in degrees) whose cosine is 0.5, type:
<code>print acos(0.5, /deg)
See also
function_asin
function_atan
category_trigonometry

atan
Returns the arcus tangent of its argument, which can be either real, complex
or a matrix. The returned value has the same type as the argument. By default, the returned value is in radians. This can be changed by specifying the switch /deg.
Syntax
result = atan(X [, Y] [, /deg])
Arguments
X: a number (integer, real, complex) or a matrix, specifying the tangent of the angle to be returned. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
Y: a real number. If given, returns atan(X / Y) for real numbers, quadrant correct.
Switches
/deg: The result will be in degrees
Examples
To find the angle (in degrees) whose tangent is 0.5, type:
<code>print atan(0.5, /deg)
See also
function_asin
function_acos
category_trigonometry

asinh
Returns the hyperbolic arcus sine of its argument, which can be either real, complex or a matrix. By default, the returned value is in radians. This can be changed by specifying the switch /deg.
Syntax
result = asinh(X [, /deg])
Arguments
X: a number (integer, real, complex) or a matrix, specifying the hyperbolic sine of the angle to be returned. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
Switches
/deg: The result will be in degrees
Examples
To find the angle (in degrees) whose hyperbolic sine is 0.5, type:
<code>print asinh(0.5, /deg)
See also
function_acosh
function_atanh
category_trigonometry

acosh
Returns the hyperbolic arcus cosine of its argument, which can be either real, complex or a matrix. By default, the returned value is in radians. This can be changed by specifying the switch /deg.
Syntax
result = acosh(X [, /deg])
Arguments
X: a number (integer, real, complex) or a matrix, specifying the hyperbolic cosine of the angle to be returned. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
Switches
/deg: The result will be in degrees
Examples
To find the angle (in degrees) whose hyperbolic cosine is 0.5, type:
<code>print acosh(0.5, /deg)
See also
function_asinh
function_atanh
category_trigonometry

atanh
Returns the hyperbolic arcus tangent of X, which can be either real, complex or a matrix. By default, the returned value is in radians. This can be changed by specifying the switch /deg.
Syntax
result = atanh(X [, /deg])
Arguments
X: a number (integer, real, complex) or a matrix, specifying the hyperbolic tangent of the angle to be returned. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
Switches
/deg: The result will be in degrees
Examples
To find the angle (in degrees) whose hyperbolic tangent is 0.5, type:
<code>print atanh(0.5, /deg)
See also
function_acosh
function_asinh
category_trigonometry

exp
Returns the exponential function of X. The returned value will be real, complex, or a matrix, depending on the argument. 
Syntax
result = exp(X)
Arguments
X: a number (integer, real, complex) or a matrix. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
See also
function_ln

log
Returns the logarithm of X. If no base is supplied, the logarithm to the base 10 is returned.
Syntax
result = log(X [, base])
Arguments
X: The value whose logarithm is to be returned. This can be a number (integer, real, complex) or a matrix. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
base: If given, the logarithm of X to this base will be returned
See also
function_ln

ln
Returns the logarithm of X to the base e (the natural logarithm).
Syntax
result = ln(X)
Arguments
X: The value whose logarithm is to be returned. This can be a number (integer, real, complex) or a matrix. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
See also
function_log

sqrt
Returns the square root of X.
Syntax
result = sqrt(X)
Arguments
X: The value whose square root is to be returned. This can be a number (integer, real, complex) or a matrix. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.

erf
Returns the error function of X.
Syntax
result = erf(X)
Arguments
X: A real number.

bessel
Returns the bessel function of X.
Syntax
result = bessel(X, kind, order)
Arguments
X: A real number.
kind: An integer number (1 or 2), specifying the kind of the bessel function to be computed.
order: An integer number >= 0, specifying the order of the bessel function to be computed.

int
Returns the integer part of X.
Syntax
result = int(X)
Arguments
X: a real number.
Examples
To print the integer part of the real number -6.7 which is -6, type:
<code>print int(-6.7)
See also
function_round

round
Returns X rounded to the nearest integer.
Syntax
result = round(X)
Arguments
X: a real number.
See also
function_int

frac
Returns the fractional part of X.
Syntax
result = frax(X)
Arguments
X: a real number.

abs
Returns the absolute value of X.
Syntax
result = abs(X)
Arguments
X: The value whose absolute value is to be returned. This can be a number (integer, real, complex) or a matrix. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
See also
function_sign
function_arg
function_real
function_imag

sign
Returns the sign of X.
Syntax
result = sign(X)
Arguments
X: a real number.
See also
function_abs

rad2deg
Returns X in radians converted to degrees. This is equivalent to X*180/pi.
Syntax
result = rad2deg(X)
Arguments
X: The value which is to be converted to degrees. This can be any number (integer, real, complex) or a matrix.
See also
function_deg2rad
category_trigonometry

deg2rad
Returns X in degrees converted to radians. This is equivalent to X*pi/180.
Syntax
result = deg2rad(X)
Arguments
X: The value which is to be converted to radians. This can be any number (integer, real, complex) or a matrix.
See also
function_rad2deg
category_trigonometry

float
Returns the string X converted to a real number.
Syntax
result = float(X)
Arguments
X: A string.

strlen
Returns the length of the string X.
Syntax
result = strlen(X)
Arguments
X: A string.
See also
function_nelements

min
Returns the minimum value of an array or the minimum of two real numbers. Undefined values (INF and NaN) are ignored.
Syntax
result = min(X [, ignore] [,/x | /y | /z | /xy | /xz | /yz])<br>
result = min(a, b)
Arguments
X: A matrix.
ignore: An optional value which should be ignored.
a: A real number.
b: A real number
Switches
/x: Calculate the minimum along the first axis
/y: Calculate the minimum along the second axis
/z: Calculate the minimum along the third axis
/xy: Calculate the minimum along the first and second axes
/xz: Calculate the minimum along the first and third axes
/yz: Calculate the minimum along the second and third axes
Examples
To get a 1D vector of the minima of all slices along a 3D cube:
<code>result = min(cube, /xy)
See also
function_max
function_avg
function_total
function_median
function_stddev
function_meddev
function_variance

max
Returns the maximum value of an array or the maximum of two real numbers. Undefined values (INF and NaN) are ignored.
Syntax
result = max(X [, ignore] [,/x | /y | /z | /xy | /xz | /yz])<br>
result = max(a, b)
Arguments
X: A matrix.
ignore: An optional value which should be ignored.
a: A real number.
b: A real number.
Switches
/x: Calculate the maximum along the first axis
/y: Calculate the maximum along the second axis
/z: Calculate the maximum along the third axis
/xy: Calculate the maximum along the first and second axes
/xz: Calculate the maximum along the first and third axes
/yz: Calculate the maximum along the second and third axes
Examples
To get a 1D vector of the maxima of all slices along a 3D cube:
<code>result = max(cube, /xy)
See also
function_min
function_avg
function_total
function_median
function_stddev
function_meddev
function_variance

avg
Returns the average value of X, optionally omitting a value. Undefined values (INF and NaN) are ignored.
Syntax
result = avg(X [, omit [,/x | /y | /z | /xy | /xz | /yz]])
Arguments
X: A matrix.
omit: A value to be omitted when taking the average.
Switches
/x: Calculate the average along the first axis
/y: Calculate the average along the second axis
/z: Calculate the average along the third axis
/xy: Calculate the average along the first and second axes
/xz: Calculate the average along the first and third axes
/yz: Calculate the average along the second and third axes
Examples
Find the average of the values 0,1,2,3,4 (which is 2):
<code>print avg([0:4])<br>
Calculate an average image of a 3D cube:
<code>result = avg(cube, /z)<br>
This is the same as:
<code>result = cubeavg(cube)
See also
function_max
function_min
function_total
function_median
function_stddev
function_meddev
function_cubeavg
function_variance

total
Returns the sum of all values in X. Undefined values (INF and NaN) are ignored.
Syntax
result = total(X [, ignore] [,/x | /y | /z | /xy | /xz | /yz])
Arguments
X: A matrix.
ignore: An optional value which should be ignored.
Switches
/x: Calculate the sum along the first axis
/y: Calculate the sum along the second axis
/z: Calculate the sum along the third axis
/xy: Calculate the sum along the first and second axes
/xz: Calculate the sum along the first and third axes
/yz: Calculate the sum along the second and third axes
Examples
Calculate a sum image of a 3D cube:
<code>result = total(cube, /z)
See also
function_max
function_min
function_avg
function_median
function_stddev
function_meddev

median
Returns the median value of X, optionally neglecting a value.
Syntax
result = median(X [, omit] [,/x | /y | /z | /xy | /xz | /yz])
Arguments
X: A matrix.
omit: A value which should be omitted when taking the median.
Switches
/x: Calculate the sum along the first axis
/y: Calculate the sum along the second axis
/z: Calculate the sum along the third axis
/xy: Calculate the sum along the first and second axes
/xz: Calculate the sum along the first and third axes
/yz: Calculate the sum along the second and third axes
Examples
Calculate a median image of a 3D cube:
<code>result = median(cube, /z)<br>
This is the same as:
<code>result = cubemedian(cube)
See also
function_max
function_min
function_total
function_avg
function_stddev
function_meddev
function_cubemedian

naxis
Returns the number of axes in X.
Syntax
result = naxis(X [, extension])
Arguments
X: A matrix or a file name
extension: Integer number specifying which extension to read.
See also
function_nelements
function_naxis1
function_naxis2
function_naxis3

naxis1
Returns the length of axis #1 in X.
Syntax
result = naxis1(X [, extension])
Arguments
X: A matrix or a file name
extension: Integer number specifying which extension to read.
See also
function_nelements
function_naxis
function_naxis2
function_naxis3

naxis2
Returns the length of axis #2 in X.
Syntax
result = naxis2(X [, extension])
Arguments
X: A matrix or a file name
extension: Integer number specifying which extension to read.
See also
function_nelements
function_naxis
function_naxis1
function_naxis3

naxis3
Returns the length of axis #3 in X.
Syntax
result = naxis3(X [, extension])
Arguments
X: A matrix or a file name
extension: Integer number specifying which extension to read.
See also
function_nelements
function_naxis
function_naxis1
function_naxis2

xmax
Returns the x coordinate of the maximum in X.
Syntax
result = xmax(X)
Arguments
X: A matrix.
See also
function_ymax
function_xmin
function_ymin
function_xcen
function_ycen
function_maxima
function_centroids
procedure_centroid

ymax
Returns the y coordinate of the maximum in X.
Syntax
result = ymax(X)
Arguments
X: A matrix.
See also
function_xmax
function_xmin
function_ymin
function_xcen
function_ycen
function_maxima
function_centroids
procedure_centroid

xmin
Returns the x coordinate of the minimum in X.
Syntax
result = xmin(X)
Arguments
X: A matrix.
See also
function_ymin
function_xmax
function_ymax
function_xcen
function_ycen
function_maxima
function_centroids
procedure_centroid

ymin
Returns the y coordinate of the minimum in X.
Syntax
result = ymin(X)
Arguments
X: A matrix.
See also
function_xmin
function_xmax
function_ymax
function_xcen
function_ycen
function_maxima
function_centroids
procedure_centroid

xcen
Returns the x coordinate of the centroid in X.
Syntax
result = xcen(X)
Arguments
X: A matrix.
See also
function_xmax
function_ymax
function_xmin
function_ymin
function_ycen
function_maxima
function_centroids
procedure_centroid

ycen
Returns the y coordinate of the centroid in X.
Syntax
result = ycen(X)
Arguments
X: A matrix.
See also
function_xmax
function_ymax
function_xmin
function_ymin
function_xcen
function_maxima
function_centroids
procedure_centroid

real
Returns the real part of the complex number X.
Syntax
result = real(X)
Arguments
X: The value whose real part is to be returned. This can be a number (integer, real, complex) or a matrix. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
See also
function_imag
function_arg
function_abs
function_complex
function_conj

imag
Returns the imaginary part of the complex number X. If X is not a complex number, 0 is returned.
Syntax
result = imag(X)
Arguments
X: The value whose imaginary part is to be returned. This can be a number (integer, real, complex) or a matrix. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
See also
function_real
function_arg
function_abs
function_complex
function_conj

arg
Returns the argument of the complex number X (the angle of the polar representation of a complex number).
Syntax
result = arg(X)
Arguments
X: The value whose imaginary part is to be returned. This can be a number (integer, real, complex) or a matrix. If X is a matrix, a matrix of the same size is returned where each element represents the result of the operation.
See also
function_real
function_imag
function_abs
function_complex
function_conj

jd
Returns the Julian Date of given date. Hour, minute, and second default to 0.
Syntax
result = jd(day, month, year [, hour [, minute [,second]]])
Arguments
day: An integer number.
month: An integer number. 
year: An integer number.
hour: An integer number.
minute: An integer number.
second: A real number.
See also
function_jdnumber
function_jdfraction
function_calday
function_now

jdnumber
Returns the integer part of the Julian Date of given date. Hour, minute, and second default to 0.
Syntax
result = jdnumber(day, month, year [, hour [, minute [,second]]])
Arguments
day: An integer number.
month: An integer number. 
year: An integer number.
hour: An integer number.
minute: An integer number.
second: A real number.
See also
function_jd
function_jdfraction
function_calday
function_now

jdfraction
Returns the fractional part of the Julian Date of given date. Hour, minute, and second default to 0.
Syntax
result = jdfraction(day, month, year [, hour [, minute [,second]]])
Arguments
day: An integer number.
month: An integer number. 
year: An integer number.
hour: An integer number.
minute: An integer number.
second: A real number.
See also
function_jd
function_jdnumber
function_calday
function_now

upper
Converts the string X to upper case.
Syntax
result = upper(X)
Arguments
X: A string.
See also
function_lower
procedure_upper

lower
Converts the string X to lower case.
Syntax
result = lower(X)
Arguments
X: A string.
See also
function_upper
procedure_lower

string
Converts the number X to a string.
Syntax
result = string(X [,/time] [,/deg] [,/rad]
Arguments
X: Any number (integer, real, complex).
Switches
/time: Convert to hours, minutes, and seconds
/deg: Convert to degrees, arcminutes, and arcseconds
/rad: Same as /deg, but the argument is converted to degrees

calday
Returns a nicely formatted string telling the calendar date of given Julian Date JD. If JD_fraction is nonzero, it describes the fractional part.
Syntax
result = calday(JD, JD_fraction)
Arguments
JD: The julian date
JD_fraction: If nonzero, the calendar date for JD+JD_fraction will be returned
See also
function_jd
function_now

header
Returns the FITS header of X.
Syntax
result = header(X [, extension])
Arguments
X: A matrix or a file name
extension: Integer number specifying which extension to read.

dayofweek
Returns the day of the week of specified (julian) date.
Syntax
result = dayofweek(DAY, MONTH, YEAR)<br>
result = dayofweek(JD [,JD_fraction])
Arguments
DAY: An integer number.
MONTH: An integer number.
YEAR: An integer number.
JD: Julian Date.
JD_fraction: A real number.
Examples
A person who was born an Feb 14, 1970 was born on a Saturday:
<code>print dayofweek(14,2,1970)
See also
function_calday
function_jd

fits
Creates an array (or a matrix) of size X x Y x Z. The arguments Y and Z are optional. The resulting matrix will be of type R4 (single precision).
Syntax
result = fits(X [, Y [, Z]])
Arguments
X: An integer number giving the length of the first dimension.
Y: An integer number giving the length of the second dimension.
Z: An integer number giving the length of the third dimension.
See also
function_bytearray
function_shortarray
function_longarray
function_floatarray
function_doublearray
function_complexarray

gauss
Creates an elliptical Gaussian. This is defined by respective FWHM1 and FWHM2, axis position angle (in degrees) and Gaussian center position (x, y) in the array. Optional keywords are naxis1, naxis2 which determine the size of the array. If not set, the size of the array is determined from global variables. If only one argument is given, return the value of a gauss as determined from exp(-4ln(2)*x^2).
Syntax
result = gauss(X0)<br>
result = gauss(X, Y, FWHM1 [, FWHM2 [, ANGLE]] [, naxis1=value] [, naxis2 = value])
Arguments
X0: A 1D vector or single number where to evaluate the function exp(-4ln(2)*X^2)
X: The center of the gaussian in the x-axes
Y: The center of the gaussian in the y-axes
FWHM1: Full-width at half maximum of the major axes
FWHM2: Optional, full-width at half maximum of the minor axes
ANGLE: Optional, position angle of the gaussian
naxis1=value: Optional, the size of the resulting array in the first dimension
naxis2=value: Optional, the size of the resulting array in the second dimension
See also
function_quickgauss

circle
Creates a circle centered on X, Y with the respective radius. Optional keywords are naxis1, naxis2 which determine the size of the array. If not set, the size of the array is determined from global variables.
Syntax
result = circle(X, Y, RADIUS [, naxis1=value] [, naxis2 = value])
Arguments
X: The center of the circle in the x-axes
Y: The center of the circle in the y-axes
RADIUS: The radius of the circle
naxis1=value: Optional, the size of the resulting array in the first dimension
naxis2=value: Optional, the size of the resulting array in the second dimension
See also
function_ellipse

ellipse
Creates an ellipse. This is defined by respective RADIUS1 and RADIUS2, axis position angle (in degrees) and Ellipse center position (x, y) in the array. Optional keywords are naxis1, naxis2 which determine the size of the array. If not set, the size of the array is determined from global variables.
Syntax
result = ellipse(X, Y, RADIUS1 [, RADIUS2 [, ANGLE]] [, naxis1=value] [, naxis2 = value])
Arguments
X: The center of the ellipse in the x-axes
Y: The center of the ellipse in the y-axes
RADIUS1: Radius of the major axes
RADIUS2: Optional, radius of the minor axes
ANGLE: Optional, position angle of the ellipse
naxis1=value: Optional, the size of the resulting array in the first dimension
naxis2=value: Optional, the size of the resulting array in the second dimension
See also
function_circle

rect
Creates a rectangular filter. This is defined by: Respective width and height and center position (X, Y) in the array. Optional keywords are naxis1, naxis2 which determine the size of the array. If not set, the size of the array is determined from global variables.
Syntax
result = rect(X, Y, WIDTH, HEIGHT [, naxis1=value] [, naxis2 = value])
Arguments
X: The center of the rectangle in the x-axes
Y: The center of the rectangle in the y-axes
WIDTH: The width of the rectangle
HEIGHT: the height of the rectangle
naxis1=value: Optional, the size of the resulting array in the first dimension
naxis2=value: Optional, the size of the resulting array in the second dimension

delta
Creates a delta function. This is defined by: All values in the array 0 except for (x, y) which is set to value. If value is not set, 1 will be used. Optional keywords are naxis1, naxis2 which determine the size of the array. If not set, the size of the array is determined from global variables.
Syntax
result = delta(X, Y [, VALUE] [, naxis1=value] [, naxis2 = value])
Arguments
X: The x-position of the nonzero pixel
Y: The y-position of the nonzero pixel
VALUE: Optional, the value of the nonzero pixel
naxis1=value: Optional, the size of the resulting array in the first dimension
naxis2=value: Optional, the size of the resulting array in the second dimension

cosbell
Creates a cosine bell filter. This is defined by: Center position (x, y), inner radius r1, and outer radius r2. Optional keywords are naxis1, naxis2 which determine the size of the array. If not set, the size of the array is determined from global variables.
Syntax
result = cosbell(X, Y, RADIUS1, RADIUS2 [, naxis1=value] [, naxis2 = value])
Arguments
X: The center of the cosine bell filter in the x-axes
Y: The center of the cosine bell filter in the y-axes
RADIUS1: The inner radius where the filter is equal to 1
RADIUS2: The outer radius where the filter is equal to 0
naxis1=value: Optional, the size of the resulting array in the first dimension
naxis2=value: Optional, the size of the resulting array in the second dimension

chinhat
Creates a chinese hat filter. This is defined by: Center position (x, y) and radius. Optional keywords are naxis1, naxis2 which determine the size of the array. If not set, the size of the array is determined from global variables.
Syntax
result = chinhat(X, Y, RADIUS [, naxis1=value] [, naxis2 = value])
Arguments
X: The center of the chinese hat filter in the first dimension
Y: The center of the chinese hat filter in the second dimension
RADIUS: The radius of the chinese hat filter
naxis1=value: Optional, the size of the resulting array in the first dimension
naxis2=value: Optional, the size of the resulting array in the second dimension

airy
Creates an airy function at the center of the array. This is defined by: Telescope diameter [meters], pixel scale [arcsec/pixel], and wavelength [microns]. Optional keywords are naxis1, naxis2 which determine the size of the array. If not set, the size of the array is determined from global variables.
Syntax
result = airy(DIAMETER, PIXELSCALE, WAVELENGTH [, naxis1=value] [, naxis2 = value])
Arguments
DIAMETER: The telescope diameter in meters
PIXELSCALE: The size of a pixel in arcseconds
WAVELENGTH: The observing wavelength in microns
naxis1=value: Optional, the size of the resulting array in the first dimension
naxis2=value: Optional, the size of the resulting array in the second dimension

cubemedian
Does a median of all images in X. The value reject can be used to exclude a value to be taken when calculating the median.
Syntax
result = cubemedian(X [, reject])
Arguments
X: A matrix or a FITS file name. If a FITS file name is given, the global variable tmpmem determines how many bytes of data are read in at a time.
reject: Optional, a value which should be discarded.
See also
function_collapse
Notes
If reject is given and no pixel along the cube is different from reject, a value of 0 will be inserted.

cubeavg
Does an average of all images in X. Optionally, a rejection value can be given
which will not be used in the averaging process.
Syntax
result = cubeavg(X [, reject])
Arguments
X: A matrix or a FITS file name. If a FITS file name is given, only one image is read into memory at a time thus saving memory.
reject: Optional, the value to disregard
Notes
If reject is given and no pixel along the cube is different from reject, a value of 0 will be inserted.

ssa
Calculates the simple shift-and-add of all images in the x datacube. If x is a fits file, a memory saving method will be used to do the ssa. If x is a string, this points to a text file where an arbitrary amount of fits filenames is given as a list. The first image in each of these files will be used for the ssa. If sky, flat, dpl, mask are given, they will be used. An optional keyword method can be given: method = 0 : Shift the brightest pixel to xcen, ycen method = 1 : Integer shift the centroid to xcen, ycen method = 2 : Subpixel shift the centroid to xcen, ycen If method < 0, the same is done as if method were set to 0, but the brightest pixel is searched in a smoothed version of the image. The smoothing is done by convolving with a gaussian of fwhm the negative of method.
Syntax
result = ssa(X, XCENTER, YCENTER, SKY, FLAT, DPL, MASK [, METHOD] [, /resize])
Arguments
X: A FITS datacube
XCENTER: The pixel where to shift in the first dimension
YCENTER: The pixel where to shift in the second dimension
SKY: A sky to be subtracted
FLAT: A flatfield to be multiplied
DPL: A dead pixel list to be applied
MASK: The peak pixel will be searched for in an image multiplied by this mask
METHOD: Optional, controls how the SSA will be done:
METHOD = 0: Shift the brightest pixel to XCENTER, YCENTER (default)
METHOD = 1: Integer shift the centroid to XCENTER, YCENTER
METHOD = 2: Subpixel shift the centroid to XCENTER, YCENTER
METHOD < 0: the same is done as if METHOD were set to 0, but the brightest pixel is searched in a smoothed version of the image. The smoothing is done by convolving with a gaussian of fwhm the negative of method.
Switches
/resize: The resulting images will be resized in the way, that in each direction the respective extend of MASK is added twice.

mosaic
Make a mosaic of the images specified in the file pointed to by FNAME. The file formatis as follows: 3(4) Columns: Filename, xshift, yshift, (scale factor). Negative Shifts result in clipping of the image.
Syntax
result = mosaic(FNAME)<br>
result = mosaic(filename, xshift, yshift [, scale factor])
Arguments
FNAME: A string specifying the file name to use.

shift
Shifts (and optionally wraps) X by specified values.
Syntax
result = shift(X, xs, ys [, zs] [, /wrap])
Arguments
X: The array to be shifted
xs: Shift vector in the first dimension
ys: Shift vector in the second dimension
zs: Shift vector in the third dimension
Switches
wrap: Pixels shifted off the array will be wrapped to the opposide side.
Notes
If either shift vector is non-integer, a subpixel shift is applied and the array type changed to R4. Subpixel shift is only supported in 2 dimensions.

rotate
Rotates X by ANGLE (in degrees, counterclockwise)
Syntax
result = rotate(X, ANGLE [, XCENTER, YCENTER])
Arguments
X: The matrix to be rotated
ANGLE: Rotation angle in degrees. Rotation will we counterclockwise
XCENTER: Optional, the center of the rotation in the first dimension (defaults to the center of X).
YCENTER: Optional, the center of the rotation in the second dimension (defaults to the center of X).

fft
Calculates the fast fourier transform of X. If X is real, the forward transform is computed. If X is complex, the inverse transform is computed.
Syntax
result = fft(X)
Arguments
X: A matrix.
Notes
The fft function uses the FFTW (Fastest Fourier Transform in the West) library, which is not limited to any array size. Still, computing a fft is fastest for arrays of size 2^N (N being an integer number).

reass
Reassembles X.
Syntax
result = reass(X)
Arguments
X: A matrix.

norm
Normalizes X.
Syntax
result = norm(X [, /unity] [, /total] [, /average])
Arguments
X: A matrix.
Switches
/unity: All values are scaled to be between 0 and 1 (default)
/total: The total flux in the resulting array will be 1
/average: The average flux in the resulting array will be 1

clip
Clips values in X. If VALUE is not set, all values below low will be set to low, and all values above high will be set to high. If value is set, all values above low AND below high are set to value.
Syntax
result = clip(X, LOW, HIGH [, VALUE])
Arguments
X: The matrix to be clipped
LOW: All values below this value will be set to LOW
HIGH: All values above this value will be set to HIGH. If HIGH < LOW, no upper clipping will be done
VALUE: Optional, if given then all values above LOW and below HIGH will be set to this value (inclusive clipping)

smooth
Smooths X by multiplying with a gaussian of width FWHM in fourier space. The total flux is kept constant. This is equivalent to reass(fft(fft(X)*fft(gauss(naxis1(X)/2+1,naxis2(X)/2+1,FWHM))))
Syntax
result = smooth(X, FWHM [,/x | /y | /z | /xy])
Arguments
X: A matrix.
FWHM: The full width at half maximum of the gaussian used for smoothing.
Switches
/x: Smooth along the first axis
/y: Smooth along the second axis
/z: Smooth along the third axis
/xy: 2D Smooth along the first and second axes (default)
Examples
Smooth each spectrum in a 3D cube (if the spectra are along the 3rd dimension):
<code>result = smooth(cube, /z)
See also
function_boxcar

boxcar
Computes a running boxcar with radius WIDTH. By default, the value is replaces by the average in the box. This can be changed by specifying one of the switches /minimum, /maximum, or /median.
Syntax
result = boxcar(X, WIDTH [, /minimum | /maximum | /median] [,/x | /y | /z | /xy])
Arguments
X: A matrix.
WIDTH: An integer number specifying the radius of the box.
Switches
/minimum: Each value is replaced with the minimum within a box with radius WIDTH
/maximum: Each value is replaced with the maximum within a box with radius WIDTH
/median: Each value is replaced with the median within a box with radius WIDTH
/x: Boxcar along the first axis
/y: Boxcar along the second axis
/z: Boxcar along the third axis
/xy: 2D boxcar along the first and second axes (default)
See also
function_smooth

3dexpand
Replaces all values in the single images of a datacube by the average in the respective images.
Syntax
result = 3dexpand(X)
Arguments
X: A matrix.

dpixcreate
Creates a dead pixel list of X using a magic threshold. Boxsize defaults to 3 and gives the radius of the running boxcar used. NPASS defaults to 3 and gives the number of passes used.
Syntax
result = dpixcreate(X, THRESHOLD [, BOXSIZE [, NPASS]])
Arguments
X: On this array the dead pixel list will be created
THRESHOLD: Sensitivity of the algorithm (use 5 for a start)
BOXSIZE: Optional, the size of the square box for comparing pixel values (default: 3)
NPASS: Optional, number of iterations

dpixapply
Corrects dead pixels in X using DPL by interpolation. BOXSIZE defaults to 1 and gives the radius of the boxcar used. Each value where DPL is not 0 will be regarded as a dead pixel. Those are not used in the interpolation process.
Syntax
        result = dpixapply(X, DPL [, BOXSIZE [, method = value]] [,/spiffik [,/bezier]])
Arguments
X: The array to be corrected for dead pixels
DPL: A dead pixel list in which all non-zero pixels mark dead pixels in X
BOXSIZE: Optional, gives the size of the averaging box for interpolation
method = value: Optional, gives the type of correction:
method = 0: Interpolation from boxcar average (default)
method = 1: Interpolation along first dimension
method = 2: Interpolation along second dimension
Switches
/spiffik : obsolete
/bezier : obsolete

flip
Flips X by specified AXIS
Syntax
result = flip(X, AXIS)
Arguments
X: The array to be flipped
AXIS: Which axis to flip: 1 = x, 2 = y

enlarge
Enlarges X by specified integer SCALE.
Syntax
result = enlarge(X, SCALE [, method])
Arguments
X: The array to be enlarged
SCALE: The resulting array will be SIZE times bigger than X
method: Optional, determines how to enlarge:
method = 0: Center original image (default)
method = 1: Center original image, edge values are mean of edge
method = 2: Blow up pixels

resize
Resizes X to the new axis lengths. The argument NAXIS3 is optional. If the new dimension is smaller than in X, the image will be clipped, else the image will be in the lower left corner.
Syntax
result = resize(X, NAXIS1, NAXIS2 [, NAXIS3])
Arguments
X: A matrix.
NAXIS1: The new length in the first dimension.
NAXIS2: The new length in the second dimension.
NAXIS3: The new length in the third dimension.

wien
Performs a wiener filtered deconvolution of X using PSF as dirty beam. HEIGHT gives the maximum of the delta function used as filter function and defaults to 1.
Syntax
result = wien(X, PSF [, HEIGHT])
Arguments
X: A matrix.
PSF: A matrix.
HEIGHT: A real number.
See also
function_lucy
function_clean
Notes
The memory required for wiener deconvolution (in bytes) calculates as 33*(Number of pixels in the image).

lucy
Performs a lucy deconvolution of X using PSF as dirty beam and N iterations. THRESHOLD defaults to 0.000003.
 
LUCY DECONVOLUTION ALGORITHM. "Lucy has shown that his iterative scheme is related to the maximum likelihood solution of the deconvolution problem and would converge to that solution after an infinite number of iterations."
 
<code>iteration number      : k
<code>dirty beam            : dbeam
<code>dirty map             : dmap
<code>estimated object      : o(k)
<code>reconvolved estimated
<code>object                : oc(k)
<code>correctin function    : t(k)
<code>multiplication        :  *
<code>convolution           : (*)
 
<code>start:    o(0) = dmap
 
<code>iteration:
<code>oc(k) = o(k) (*) dbeam
<code>t(k)  = (dmap/oc(k)) (*) dbeam
<code>o(k+1)= o(k) * t(k)
 
Due to calculation of the quotient for t(k) the algorithm is sensitive to noise. Therefore a weighting function has been implemented which is unity if the dmap signal is larger than "thresh" and zero elsewhere. t(k) is only calculated in that area and hence the deconvolution is only effective there. Threshold equals input if positive. If input is negative thresh is determined via mean and rms in the area below abs(thresh). If thresh is zero thresh is determined in the area below -0.1 times the maximum flux in dmap. The redetermined threshold is mean value plus 3 times rms.
 
To check on convergence of algorithm the rms between input dmap and current lucy deconvolved map reconvolved with dbeam is calculated.
 
Syntax
result = lucy(X, PSF, N [, THRESHOLD])
Arguments
X: A matrix.
PSF: A matrix.
N: An integer number.
THRESHOLD: A real number.
See also
function_clean
function_wien
Notes
The memory required for lucy deconvolution (in bytes) calculates as 44*(Number of pixels in the image).

center
Shifts the brightest pixel in X to the center.
Syntax
result = center(X)
Arguments
X: A matrix.

3dnorm (obsolete)
Normalizes a 3D datacube.
Syntax
result = 3dnorm(X, filename)
Arguments
X: A matrix.
filename: Path to a file

conj
Returns the complex conjugate of X.
Syntax
result = conj(X)
Arguments
X: A matrix or a complex number.
See also
function_complex
function_real
function_imag
function_arg
function_abs

correl
Returns the cross-correlation of X and Y.
Syntax
result = correl(X, Y)
Arguments
X: A matrix.
Y: A matrix.

readfits
Read specified FITS file into memory. The optional arguments x1, x2, y1, y2, z1, z2 can be used to read in a part of a FITS file. The combination 0, 0 specifies that the complete range of the respective axis should be read in.
Syntax
result = readfits(FILENAME [, x1, x2 [, y1, y2 [, z1, z2]]])
Arguments
FILENAME: A string.
x1, x2: Range in first dimension, defaults to 0, 0
y1, y2: Range in second dimension, defaults to 0, 0
z1, z2: Range in third dimension, defaults to 0, 0
Examples
Read in the 150th to 160th slice of a datacube:
<code>subcube = readfits("cube.fits", 0, 0, 0, 0, 150, 160)
See also
function_readfitsextension
function_readfitsall

3dspec
Returns an average 3D spectrum of X (dispersion along the third dimension) using the mask Y (2-dim) or the center (x,y) with radii r1 and r2.
Syntax
result = 3dspec(X, Y)<br>
result = 3dspec(X, xcenter, ycenter [, r1 [, r2]])
Arguments
X: A three dimensional matrix.
Y: A two dimensional matrix.
xcenter: The central pixel of the spectrum in the first dimension.
ycenter: The central pixel of the spectrum in the second dimension.
r1: The radius of the circular aperture to be used.
r2: The scaled average of all values in the annulus defined by r1 and r2 will be subtracted from the spectrum (local sky subtraction).

stddev
Returns the standard deviation of X, optionally omitting a value.
Syntax
result = stddev(X [, omit])
Arguments
X: A matrix.
omit: A value to be omitted when calculating the standard deviation.
Switches
/x: Calculate the standard deviation along the first axis
/y: Calculate the standard deviation along the second axis
/z: Calculate the standard deviation along the third axis
/xy: Calculate the standard deviation along the first and second axes
/xz: Calculate the standard deviation along the first and third axes
/yz: Calculate the standard deviation along the second and third axes
Examples
To get a 1D vector of the standard deviation of all slices along a 3D cube:
<code>v = stddev(cube, /xy)
See also
function_max
function_min
function_avg
function_total
function_median
function_stddev
function_variance
function_meddev

variance
Returns the variance of X.
Syntax
result = variance(X)
Arguments
X: A matrix.
Switches
/x: Calculate the variance along the first axis
/y: Calculate the variance along the second axis
/z: Calculate the variance along the third axis
/xy: Calculate the variance along the first and second axes
/xz: Calculate the variance along the first and third axes
/yz: Calculate the variance along the second and third axes
Examples
To get a 1D vector of the variance of all slices along a 3D cube:
<code>v = variance(cube, /xy)
See also
function_max
function_min
function_avg
function_total
function_median
function_stddev
function_variance
function_meddev

meddev
Returns the median deviation from the median in X.
Syntax
result = meddev(X)
Arguments
X: A matrix.
Switches
/x: Calculate the median deviation along the first axis
/y: Calculate the median deviation along the second axis
/z: Calculate the median deviation along the third axis
/xy: Calculate the median deviation along the first and second axes
/xz: Calculate the median deviation along the first and third axes
/yz: Calculate the median deviation along the second and third axes
Examples
To get a 1D vector of the median deviation of all slices along a 3D cube:
<code>v = meddev(cube, /xy)
See also
function_max
function_min
function_avg
function_total
function_median
function_stddev

saomark
Interactively mark pixels in ds9 which are marked on the display. The resulting array will have a value of 1 in each marked pixel, a value of 0 elsewhere. Press any key to mark a point, press 'd' to delete an already marked point, press 'q' to quit. (Use ds9 v5.2 or newer!)
Syntax
result = saomark()
Arguments
none

random
Returns a random number between 0 and 1. If SEED is not set, a seed based on the current time is used.
Syntax
result = random([SEED])
Arguments
SEED: An integer number.
See also
function_randomg

import
Imports a text file. If the first character in the file is numeric, the values in the file are written into a numerical array. The number of lines in the file then determine NAXIS2, the number of individual entries in the first line of the file determines NAXIS1. Else the text file will be written into a string array.
Syntax
result = import(FILENAME [, /text] [, /number])
Arguments
FILENAME: A string.
Switches
/text: Force to read into a string array
/number: Force to read into a numerical array

rebin
Rebins X to the new axis lengths X1 and X2 using a bilinear interpolation. The aspect ratio is not preserved.
Syntax
result = rebin(X, X1, X2)
Arguments
X: A matrix.
X1: An integer number.
X2: An integer number.

stringarray
Returns a string array. If X is an integer number, a string array will have X entries which are all initialized to empty strings. If X is a string, the string array will initially have one element which is set to X.
Syntax
result = stringarray(X)
Arguments
X: A positive integer number.

nelements
Returns the number of elements in X. For a matrix, this is the total number of pixels, for a string, the number of characters, and for a stringarray, the number of strings.
Syntax
result = nelements(X)
Arguments
X: A matrix, string, or string array.

ssastat
Returns statistics for ssa. Arguments like ssa. The resulting array will be [xshift, yshift, min, max, flux, fwhm, flag].
Syntax
result = ssastat(X, XCENTER, YCENTER, SKY, FLAT, DPL, MASK [, METHOD])
Arguments
X: A FITS datacube
XCENTER: The pixel where to shift in the first dimension
YCENTER: The pixel where to shift in the second dimension
SKY: A sky to be subtracted
FLAT: A flatfield to be multiplied
DPL: A dead pixel list to be applied
MASK: The peak pixel will be searched for in an image multiplied by this mask
METHOD: Optional, controls how the SSA will be done:
METHOD = 0: Shift the brightest pixel to XCENTER, YCENTER (default)
METHOD = 1: Integer shift the centroid to XCENTER, YCENTER
METHOD = 2: Subpixel shift the centroid to XCENTER, YCENTER
METHOD < 0: the same is done as if METHOD were set to 0, but the brightest pixel is searched in a smoothed version of the image. The smoothing is done by convolving with a gaussian of fwhm the negative of method.
See also
function_ssa
function_sssa

sssa
Calculates the simple shift-and-add of all images in X. If X is a FITS file, a memory saving method will be used to do the ssa.
Syntax
result = sssa(X, STATS, SKY, FLAT, DPL, MASK [, METHOD])
Arguments
X: A FITS datacube
STATS: An array created with the ssastat function. If its flag is not 1, the image will be skipped
SKY: A sky to be subtracted
FLAT: A flatfield to be multiplied
DPL: A dead pixel list to be applied
MASK: The peak pixel will be searched for in an image multiplied by this mask
METHOD: Optional, controls how the SSA will be done:
METHOD = 0: Shift the brightest pixel to XCENTER, YCENTER (default)
METHOD = 1: Integer shift the centroid to XCENTER, YCENTER
METHOD = 2: Subpixel shift the centroid to XCENTER, YCENTER
See also
function_ssa
function_ssastat

ssaselect
Obsolete function

maxentropy
Maximum entropy deconvolution of X using PSF.
Syntax
result = maxentropy(X, PSF, N [, MASK])
Arguments
X: A matrix.
PSF: A matrix.
N: An integer number.
MASK: An optional mask of image regions to be used.

cubeminimum
Returns the minimum of each pixel along the 3rd axis if X is a cube.
Syntax
result = cubeminimum(X)
Arguments
X: A matrix or a FITS file name. If a FITS file name is given, only one image is read into memory at a time thus saving memory.

cubemaximum
Returns the maximum of each pixel along the 3rd axis if X is a cube.
Syntax
result = cubemaximum(X)
Arguments
X: A matrix or a FITS file name. If a FITS file name is given, only one image is read into memory at a time thus saving memory.

fwhm
Returns the second order moment of X centered at [XCENTER, YCENTER] within RADIUS, which corresponds to the FWHM at that location. The parameter RADIUS is optional. If skipped, a default of 5 pixels will be used.
Syntax
result = fwhm(X, XCENTER, YCENTER [, RADIUS])
Arguments
X: A matrix.
XCENTER: An integer number.
YCENTER: An integer number.
RADIUS: An integer number.

setbitpix
Change the pixel type of X.
Syntax
result = setbitpix(X, BITPIX [, BSCALE [, BZERO]])
Arguments
X: The array whose pixel type is to be changed
BITPIX: Desired pixel type:
BITPIX = -128: Complex (note that this does not conform to FITS standard)
BITPIX =  -64: Floating point, double precision
BITPIX =  -32: Floating point, single precision
BITPIX =    8: Unsigned char
BITPIX =   16: Short
BITPIX =   32: Long
BSCALE, BZERO: For integer BITPIX, optionally BSCALE and BZERO can be given. The value represented by each pixel is given by value * BSCALE + BZERO (the defaults are BSCALE = 1 and BZERO = 0)
See also
function_getbitpix

bytearray
Returns an array with bitpix = 8 (all pixels are of type unsigned char). bscale will be set to 1.0, bzero to 0.0.
Syntax
result = bytearray(X [, Y [, Z]])
Arguments
X: An integer number specifying the length of the first dimension.
Y: An integer number specifying the length of the second dimension.
Z: An integer number specifying the length of the third dimension.
See also
function_fits
function_shortarray
function_longarray
function_floatarray
function_doublearray
function_complexarray

shortarray
Returns an array with bitpix = 16 (all pixels are of type short). bscale will be set to 1.0, bzero to 0.0.
Syntax
result = short(array(X [, Y [, Z]])
Arguments
X: An integer number specifying the length of the first dimension.
Y: An integer number specifying the length of the second dimension.
Z: An integer number specifying the length of the third dimension.
See also
function_fits
function_bytearray
function_longarray
function_floatarray
function_doublearray
function_complexarray

longarray
Returns an array with bitpix = 32 (all pixels are of type long). bscale will be set to 1.0, bzero to 0.0.
Syntax
result = longarray(X [, Y [, Z]])
Arguments
X: An integer number specifying the length of the first dimension.
Y: An integer number specifying the length of the second dimension.
Z: An integer number specifying the length of the third dimension.
See also
function_fits
function_bytearray
function_shortarray
function_floatarray
function_doublearray
function_complexarray

floatarray
Returns an array with bitpix = -32 (all pixels are of type float).
Syntax
result = floatarray(X [, Y [, Z]])
Arguments
X: An integer number specifying the length of the first dimension.
Y: An integer number specifying the length of the second dimension.
Z: An integer number specifying the length of the third dimension.
See also
function_fits
function_bytearray
function_shortarray
function_longarray
function_doublearray
function_complexarray

doublearray
Returns an array with bitpix = -64 (all pixels are of type double).
Syntax
result = doublearray(X [, Y [, Z]])
Arguments
X: An integer number specifying the length of the first dimension.
Y: An integer number specifying the length of the second dimension.
Z: An integer number specifying the length of the third dimension.
See also
function_fits
function_bytearray
function_shortarray
function_longarray
function_floatarray
function_complexarray

complexarray
Returns an array with bitpix = -128 (all pixels are of type complex). !!! WARNING: bitpix = -128 does NOT conform to the FITS standard !!!
Syntax
result = complexarray(X [, Y [, Z]])
Arguments
X: An integer number specifying the length of the first dimension.
Y: An integer number specifying the length of the second dimension.
Z: An integer number specifying the length of the third dimension.
See also
function_fits
function_bytearray
function_shortarray
function_longarray
function_floatarray
function_doublearray

shrink
Shrinks X or the specified axis of X by specified FACTOR
Syntax
result = shrink(X, FACTOR [, AXIS])
Arguments
X: A matrix.
FACTOR: An integer number.
AXIS: optionally, which axis to shrink (1, 2, or 3)

getfitskey
Returns the value of specified FITS key in the header of X. The returned type can be either a string, an integer number or a real number. If the specified key does not exist, an empty string is returned.
Syntax
result = getfitskey(X, KEY [, extension] [, /text])
Arguments
X: A matrix or a FITS file.
KEY: A string.
extension: Integer number specifying which extension to read.
Switches
text: Return the fits key as a string.

polyfit
Returns a N-th order polynomial fit to X. X must be 1-dimensional. The function returns a vector of size (N+1)*2. The fittet polynomial has the following form:
<code>f(x) = a0 + a1 * x + ... + aN * X^N
The values a0, ..., aN are returned in the first N elements of the returned vector, their respective errors in the elements N+1...2*N.
Syntax
result = polyfit(X, N [, CHISQ])
Arguments
X: A vector.
N: An integer number.
CHISQ: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
See also
function_polyfitxy
function_polyfitxyerr
function_polyfit2d
function_polyfit2derr

sprintf
RETURNS X (either a real number or an integer) as a string using specified format string. The formatting is done like in the C printf function. The total length of the formatted string is limited to 256 characters.
Syntax
result = sprintf(FORMAT, X)

photometry
Perform aperture photometry on X. This function returns a 3xn matrix with the following information: measured counts, normalized counts (Jansky), magnitude.
Syntax
result = photometry(X, POSLIST, REFLIST, SEARCHBOX, RADIUS, [,/u | /b | /v | /r | /i | /j | /h | /k | /l | /m | /n])
Arguments
X: The image on which to do aperture photometry
POSLIST: A 2xn matrix containing the positions of the stars
REFLIST: A 1xm matrix containing magnitudes of reference stars (in the same order as in poslist), with a value > 20.0 if not to be used
SEARCHBOX: Within a box with this radius the local maximum of the stars are searched
RADIUS: The radius of the circular aperture used for photometry
Switches
/u: Do photometry for U-Band (epsilon = 3.274)
/b: Do photometry for B-Band (epsilon = 3.674)
/v: Do photometry for V-Band (epsilon = 3.581)
/r: Do photometry for R-Band (epsilon = 3.479)
/i: Do photometry for I-Band (epsilon = 3.386)
/j: Do photometry for J-Band (epsilon = 3.248)
/h: Do photometry for H-Band (epsilon = 3.08)
/k: Do photometry for K-Band  (epsilon = 2.8) (default)
/l: Do photometry for L-Band (epsilon = 2.49)
/m: Do photometry for M-Band (epsilon = 2.26)
/n: Do photometry for N-Band (epsilon = 1.63)

transcoords
Transform a set of coordinates from one image to another. The coordinate transformation matrix is described by a first order polynomial if the number of reference sources is <= 6, else a second order polynomial is used. The transformation function will be calculated using a least squares fit to given coordinates. Note that if either in REFSTARS or in IMSTARS a coordinate is exactly (-1, -1), this star will not be used to calculate the transformation matrix.
Syntax
result = transcoords(MASTERLIST, REFSTARS, IMSTARS [, xerror, yerror][, /silent] [, /linear] [, /cubic] [, /rotation])
Arguments
MASTERLIST: A matrix 2xn with the coordinates to be transformed
REFSTARS: A matrix 2xm (m >= 3) with positions of the reference stars in the reference frame (= masterlist)
IMSTARS: A matrix 2xm (same size as REFSTARS) with the positions of the same stars in the image to be transformed.
xerror: If set to a named variable, the residual error of the coordinate transform in the first axis is returned.
yerror: If set to a named variable, the residual error of the coordinate transform in the second axis is returned.
Switches
/silent: Printing of output is suppressed
/linear: A 1st order polynomial is fitted (even when more than 6 reference sources are supplied)
/cubic: A 3rd order polynomial is fitted (at least 10 reference sources)
/rotation: A rotational transformation is fitted (at least 4 reference sources): x' = x0 + f*cos(a)*x - f*sin(a)*y, y' = y0 + f*sin(a)*x + f*cos(a)*y
See also
function_transmatrix
function_transform

findfile
Returns all files that satisfy given PATTERN. All occurrences of a backslash are replaced by a slash. Also, a slash is appended to all directories. The search is started from the current directory and is done recursively through the directory structure.
Syntax
result = findfile(PATTERN)
Arguments
PATTERN: A string.
Examples
Find all text files (files with the suffix .txt) from the current working directory:
<code>print findfile("*.txt")
See also
function_dir
function_fileexists

markpos
Mark positions using ds9. The positions are returned as a 2xn matrix, where n denotes the number of positions marked. Pressing the key 'q' will quit marking positions. When typing numbers between 1 and 9 the values are stored at that specific position. This way values can be overwritten. (Use ds9 v5.2 or newer!)
Syntax
result = markpos(X [, int radius] [, /nocenter])
Arguments
X: The image to be displayed on saoimage
radius: Optional, the radius around which the brightest pixel is searched for using centroid-method.
Switches
nocenter: Has no effect when no radius is supplied. Returns the local maximum in the radius around the marked pixel.
See also
function_saomark

lmst
Calculate the local mean siderial time for given Julian date. If longitude is given (east negative), the local mean sidereal time for that location is returned, else the lmst for Greenwich (longitude 0). NOTE that timezones for given longitude are not taken into account, so always give jd in Universal Time.
Syntax
result = lmst(JD [, LATITUDE])
Arguments
JD: A real number.
LATITUDE: A real number.
See also
function_jd

wsa
Compute weighted shift-and-add of the fits cube X (must be a file). The shift location is defined by xcen, ycen. thresh gives the fraction of the maximum pixel which will be regarded as a speckle. speckles determines the maximum number of speckles used (if there are more, then the image will be smoothed until it is not exceeded). smooth optionally gives the fwhm of a gaussian with which the image where speckles are searched for is smoothed. If bigmask is given, the centroid of mask will be shifted to the centroid of bigmask for each individual image.
Syntax
result = wsa(X, XCENTER, YCENTER, THRESHOLD, SPECKLES, SMOOTH, SKY, FLAT, DPL, MASK [, BIGMASK])
Arguments
X: A FITS filename (enclosed in single quotes).
XCENTER: An integer number specifying the shift position in the first dimension.
YCENTER: An integer number specifying the shift position in the second dimension.
THRESHOLD: A real number.
SPECKLES: An integer number.
SMOOTH: An integer number.
SKY: A matrix.
FLAT: A matrix.
DPL: A matrix.
MASK: A matrix.
BIGMASK: A matrix.

swsa
Compute weighted shift-and-add of the fits cube X (must be a file). flags is a 1-dimensional array that has a value of zero for each image that is to be skipped. The shift location is defined by xcen, ycen. thresh gives the fraction of the maximum pixel which will be regarded as a speckle. speckles determines the maximum number of speckles used (if there are more, then the image will be smoothed until it is not exceeded). smooth optionally gives the fwhm of a gaussian with which the image where speckles are searched for is smoothed. If bigmask is given, the centroid of mask will be shifted to the centroid of bigmask for each individual image.
Syntax
result = wsa(X, FLAGS, XCENTER, YCENTER, THRESHOLD, SPECKLES, SMOOTH, SKY, FLAT, DPL, MASK, BIGMASK)
Arguments
X: A FITS filename (enclosed in single quotes).
FLAGS: A vector.
XCENTER: An integer number specifying the shift position in the first dimension.
YCENTER: An integer number specifying the shift position in the second dimension.
THRESHOLD: A real number.
SPECKLES: An integer number.
SMOOTH: An integer number.
SKY: A matrix.
FLAT: A matrix.
DPL: A matrix.
MASK: A matrix.
BIGMASK: A matrix.

centroids
Returns a 2xn matrix with the centroids (in a RADIUS) on given POSITIONS in X.
Syntax
result = centroids(X, POSITIONS, RADIUS)
Arguments
X: A matrix.
POSITIONS: A 2xn matrix with initial positions.
RADIUS: An integer number.
See also
function_maxima
function_gausspos

maxima
Refind local maxima in X given POSITIONS around RADIUS.
Syntax
result = maxima(X, POSITIONS, RADIUS [, /circle, /box])
Arguments
X: A matrix.
POSITIONS: A 2xn matrix with initial positions.
RADIUS: An integer number.
Switches
/circle: Local maxima are searched for within a circle with RADIUS
/box: Local maxima are search for within a quadratic box with RADIUS
See also
function_centroids
function_gausspos

gausspos
Returns a 2xn matrix with 2D gaussfits (in a RADIUS) on given POSITIONS in X.
Syntax
result = gausspos(X, POSITIONS, RADIUS)
Arguments
X: A matrix.
POSITIONS: A 2xn matrix with initial positions.
RADIUS: An integer number.
See also
function_maxima
function_centroids

fileexists
Test for existence of a file. Returns 1 if the file exist, 0 otherwise.
Syntax
result = fileexists(FILENAME)
Arguments
FILENAME: A string.
See also
function_findfile
function_dir
function_filesize

filesize
Return the length in bytes of a file. Returns -1 if the file does not exist.
Syntax
result = filesize(FILENAME)
Arguments
FILENAME: A string.
See also
function_findfile
function_dir
function_fileexists

dir
Return a directory listing.
Syntax
result = dir([DIRECTORY], [, /recursive])
Arguments
DIRECTORY: Optional, do a directory listing of specified directory, else of the current working directory
Switches
/recursive: Do a recursive listing
Examples
To print a recursive listing of the current directory, type
<code>print dir("", /recursive)
See also
function_findfile
function_filesize
function_fileexists

polyfitxy
Return an n-th order polynomial fit to the vectors X and Y, where y = f(x). If a variable is given as the 4th argument, it will be overwritten with the chi squared of the fit.
Syntax
result = polyfitxy(X, Y, N [, CHISQ])
Arguments
X: A vector.
Y: A vector.
N: An integer number.
CHISQ: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
See also
function_polyfit
function_polyfitxyerr
function_polyfit2d
function_polyfit2derr

sort
Returns an index list of X in ascending order.
Syntax
result = sort(X [, /reverse])
Arguments
X: A matrix, a string or a string array.
Switches
/reverse: The index list will be in descending order
Examples
To sort a directory listing in alphabetical order, type:
<code>list = dir("/tmp"); list = list[sort(list)]

char
Returns the ASCII character which number is N. N is truncated to the range 0...255.
Syntax
result = char(N)
Arguments
N: An integer number.
Examples
To print out the ASCII character set, type:
<code>for (i = 32; i < 256; i++) print char(i)

complex
Returns a complex number generated of the two given values.
Syntax
result = complex(r, i)
Arguments
r: The real part (either a real number or a matrix)
i: the imaginary part (either a real number or a matrix)
See also
function_real
function_imag
function_conj
function_arg
function_abs

strpos
Returns the position of a substring within a string, or -1 if the substring does not occur. If the first argument is a string array, a matrix with the same number of elements as the string is returned.
Syntax
result = strpos(X, Y)
Arguments
X: A string or a string array
Y: The substring to be searched for
Switches
/nocase: The search is done case-insensitive

clean
Performs "cleaning" of the input image. This iterative deconvolution algorithm
searches for the global maximum in the image, shifts the psf to that position and subtracts a scaled psf (multiplied by the gain). The subtracted flux is added to a delta map at the position of the maximum (this is the clean map). Note that clean does not conserve the total flux in the image.
Syntax
result = clean(IMAGE, PSF, N, GAIN [, variable SUB])
Arguments
IMAGE: input map to be cleaned (dirty map)
PSF: Point spread function (dirty beam)
N: Number of iterations
GAIN: Loop gain factor
SUB: Optional, the variable SUB will contain an image in which the sources are subtracted
See also
function_lucy
function_wien

collapse
Collapse one axis of an array. All values along the specified axis will be summed up. The resulting array will have one dimension less than the input.
Syntax
result = collapse(IMAGE, AXIS)
Arguments
IMAGE: A matrix.
AXIS: An integer number.
Examples
Do a sum of all images in a datacube:
<code>s = collapse(cube, 3)
This is exactly the same as:
<code>s = cubeavg(cube) * naxis3(cube)
See also
function_cubeavg

magnify
Resize given array by the scaling factor. Each pixel in the resized array will be blown up and consequently contain scale^2 pixels. The optional argument smooth gives the fwhm of a gaussian with which the resultant array will we smoothed. The total flux in the array will be conserved.
Syntax
result = magnify(IMAGE, scale [, fwhm])
Arguments
IMAGE: A matrix
scale: An integer number.
fwhm: A real number.

wsastat
Compute statistics for the weighted shift-and-add of the fits cube X (must be a file). The shift location is defined by xcen, ycen. thresh gives the fraction of the maximum pixel which will be regarded as a speckle. speckles determines the maximum number of speckles used (if there are more, then the image will be smoothed until it is not exceeded). smooth optionally gives the fwhm of a gaussian with which the image where speckles are searched for is smoothed. If bigmask is given, the centroid of mask will be shifted to the centroid of bigmask for each individual image.
Syntax
result = wsastat(X, XCENTER, YCENTER, THRESHOLD, SPECKLES, SMOOTH, SKY, FLAT, DPL, MASK, BIGMASK)
Arguments
X: A FITS filename (enclosed in single quotes).
XCENTER: An integer number specifying the shift position in the first dimension.
YCENTER: An integer number specifying the shift position in the second dimension.
THRESHOLD: A real number.
SPECKLES: An integer number.
SMOOTH: An integer number.
SKY: A matrix.
FLAT: A matrix.
DPL: A matrix.
MASK: A matrix.
BIGMASK: A matrix.

gaussfit
Fit a one-dimensional gaussian to a vector. The gauss function is defined as G(x) = A + B*exp(-4ln2*(x-x0)^2/fwhm^2).
Syntax
result = gaussfit(X, Y, errors, estimate [, chisq])
Arguments
X: A vector containing the x values to be fit
Y: A vector containing the y values to be fit
errors: The errors in Y
estimate: Initial estimate for the fit of the form [A, B, x0, fwhm]
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
Returns
The returned vector contains the best-fit parameters in the form [A, B, x0, fwhm, d_A, d_B, d_x0, d_fwhm]
See also
function_evalgaussfit

gauss2dfit
Fit a two-dimensional gaussian to a rectangular grid (i.e. an image).
Syntax
result = gauss2dfit(image, errors, estimate [, chisq])
Arguments
image: The image to be fit
errors: The errors in the image values
estimate: Initial estimate for the fit of the form [Offset,Max,x0,y0,fwhm1,fwhm2,angle]
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
Returns
The returned vector contains the best-fit parameters in the form [Offset, Max, x0, y0, fwhm1, fwhm2, angle, d_Offset, d_Max, d_x0, d_y0, d_fwhm1, d_fwhm2, d_angle]
See also
function_gauss2dsimplefit
function_multigauss2dfit

polyfitxyerr
Return an n-th order polynomial fit to the vectors X and Y, where y = f(x). The typical error of the dependent variables is given in ERROR. If a variable is given as the 4th argument, it will be overwritten with the chi squared of the fit.
Syntax
result = polyfitxyerr(X, Y, N, ERROR [, CHISQ])
Arguments
X: A vector.
Y: A vector.
N: An integer number.
ERROR: The error of the Y-values. If this is a real number, all Y-values are assumed to have the same error. If ERROR is a vector, it must have the same length as X and Y and gives the error or each individual Y value.
CHISQ: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
See also
function_polyfit
function_polyfitxy
function_polyfit2d
function_polyfit2derr

psf
Return the average (or median, minimum, maximum) of several stars in an image. The stars locations are given in the second argument.
Syntax
result = psf(X, POSITIONS [, /median] [, /average] [, /minimum] [, /maximum])
Arguments
X: A matrix.
POSITIONS: A 2xn matrix giving the positions of the stars to be averaged.
Switches
/median: Return the median of the stars (default).
/average: Return the average of the stars.
/minimum: Return the minimum of the stars.
/maximum: Return the maximum of the stars.

pwd
Return the absolute path of the current directory.
Syntax
result = pwd()
Arguments
none
Returns
A string with the absolute path of the current directory.
See also
function_dir
procedure_cd

quickgauss
Create a circular gaussian.
Syntax
result = quickgauss(X, Y, FWHM, speed [, naxis1=value] [, naxis2=value])
Arguments
X: The center of the gaussian in the x-axes
Y: The center of the gaussian in the y-axes
FWHM: Full-width at half maximum of the circular gaussian
speed: The gaussian is calculated up to a distance of speed*FWHM from the center location
naxis1=value: Optional, the size of the resulting array in the first dimension
naxis2=value: Optional, the size of the resulting array in the second dimension
Returns
A two-dimensional circular gaussian.
See also
function_gauss

getenv
Return the content of an environment variable.
Syntax
result = getenv(S)
Arguments
S: A string with the name of the environment variable.
Returns
A string with the content of the environment variable. If the environment variable does not exist, an empty string is returned.
See also
procedure_setenv

cblank
Replace all undefined values (like NaN or Inf) by another value. If no value is specified, these values will be replace by 0.0.
Syntax
result = cblank(ARRAY [, value])
Arguments
ARRAY: A matrix
value: Optional, the value to be assigned (defaults to 0)
See also
procedure_cblank

now
Return the julian date of the current system time. The timezone (and daylight saving time, if appropriate) are taken into account.
Syntax
result = now()
Arguments
none
See also
function_jd
function_calday

polar
Returns a complex number generated of the two given values in polar representation. This is equivalent to complex(a * cos(b), a * sin(b)).
Syntax
result = polar(ampl, arg)
Arguments
ampl: The amplitude (either a real number or a matrix)
arg: The argument (either a real number or a matrix)
See also
function_complex
function_real
function_imag
function_conj
function_arg
function_abs

transmatrix
Compute the transformation matrix for two reference coordinate systems. It is described by a first order polynomial if the number of reference sources is <= 6, else a second order polynomial is used. The transformation function will be calculated using a least squares fit to given coordinates. Note that if either in REFSTARS or in IMSTARS a coordinate is exactly (-1, -1), this star will not be used to calculate the transformation matrix.
Syntax
result = transmatrix(REFSTARS, IMSTARS [, xerror, yerror][, /silent] [, /linear] [, /cubic] [, /rotation])
Arguments
REFSTARS: A matrix 2xm (m >= 3) with positions of the reference stars in the reference frame (= masterlist)
IMSTARS: A matrix 2xm (same size as REFSTARS) with the positions of the same stars in the image to be transformed.
xerror: If set to a named variable, the residual error of the coordinate transform in the first axis is returned.
yerror: If set to a named variable, the residual error of the coordinate transform in the second axis is returned.
Switches
/silent: Printing of output is suppressed
/linear: A 1st order polynomial is fitted (even when more than 6 reference sources are supplied)
/cubic: A 3rd order polynomial is fitted (at least 10 reference sources)
/rotation: A rotational transformation is fitted (at least 4 reference sources): x' = x0 + f*cos(a)*x - f*sin(a)*y, y' = y0 + f*sin(a)*x + f*cos(a)*y
Returns
For 1st and 2nd order polynomials: A matrix 2x6 which describes the coordinate transformation matrix:
<code>x' = result[1,1] + result[1,2]*x + result[1,3]*y + result[1,4]*xy + result[1,5]*x^2 + result[1,6]*y^2
<code>y' = result[2,1] + result[2,2]*x + result[2,3]*y + result[2,4]*xy + result[2,5]*x^2 + result[2,6]*y^2<br>
For 3rd order polynomials: A matrix 2x10 which describes the coordinate transformation matrix:
<code>x' = result[1,1] + result[1,2]*x + result[1,3]*y + result[1,4]*xy + result[1,5]*x^2 + result[1,6]*y^2 + result[1,7]*x^2y + result[1,8]*xy^2 + result[1,9]*x^3 + result[1,10]*y^3
<code>y' = result[2,1] + result[2,2]*x + result[2,3]*y + result[2,4]*xy + result[2,5]*x^2 + result[2,6]*y^2 + result[2,7]*x^2y + result[2,8]*xy^2 + result[2,9]*x^3 + result[2,10]*y^3<br> 
For rotational transformation: A matrix 1x4 which describes the coordinate transformation matrix:
<code>x' = result[1] + result[3] * cos(result[4])*x - result[3] * sin(result[4])*y
<code>y' = result[2] + result[3] * sin(result[4])*x + result[3] * cos(result[4])*y
See also
function_transcoords
function_transform

transform
Apply a transformation matrix to a set of coordinates.
Syntax
result = transform(COORDS, TRANS)
Arguments
COORDS: A matrix 2xN with the initial coordinates.
TRANS: A matrix 2x6 which contains the coordinate transformation matrix.
Returns
A matrix 2xN with the transformed coordinates.
See also
function_transcoords
function_transmatrix

invert
Return the inverse of a 2-dimensional, square matrix.
Syntax
result = invert(X)
Arguments
X: A 2-dimensional, square matrix.
Returns
The inverse of X.
Examples
<code>print X # invert(X), /values<
will return a unity matrix

transpose
Return the matrix X transposed, i.e. rows and columns are interchanged.
Syntax
result = transpose(X)
Arguments
X: A vector or a 2-dimensional matrix.

isvariable
Check whether given variable name (as a string) exists in memory.
Syntax
result = isvariable(S)
Arguments
S: A string with the variable name
Returns
1 if the variable exists, 0 otherwise

pi
Return the number PI. It will be computet as 2 * acos(0).
Syntax
result = pi()
Arguments
none
Examples
Print the number pi to 15 significant digits:
<code>DPUSER> print sprintf("%.15f", pi())
<code>3.141592653589793
See also
category_trigonometry

convolve
Convolve an image with a kernel. The resulting array is returned with bitpix -32.
Syntax
result = convolve(a, b)
Arguments
a: The array to be convolved.
b: The kernel to convolve the image with.
Notes
If a and b are of exactly the same size, the two are multiplied in fourier space. If b is smaller than a and a square matrix, a convolved with the kernel b is returned.

gammp
Return the incomplete gamma function P(a, x).
Syntax
result = gammp(a, x)
Arguments
a: A number > 0
x: A number > 0, the value where to evaluate the incomplete gamma function

reform
Resize an array without actually moving data. The number of new elements must exactly match the number of elements in the array to be resized. If no size arguments are given, all array axes with length 1 are removed.
Syntax
result = reform(a, [n1 [, n2 [, n3]]])
Arguments
a: The array to be resized
n1: New axis length
n2: New axis length
n3: New axis length

find
[This documentation is copied literally from IDL's astrolib]
 
Find positive brightness perturbations (i.e stars) in an image. Also returns centroids and shape parameters (roundness & sharpness). Adapted from 1986 STSDAS version of DAOPHOT.
Syntax
result = find(image, hmin, fwhm [, roundlim [, sharplim]] [, /silent])
Arguments
image: 2 dimensional image array for which one wishes to identify the stars present.
hmin: Threshold intensity for a point source - should generally be 3 or 4 sigma above background.
fwhm: FWHM to be used in the convolve filter.
sharplim: 2 element vector giving low and high cutoff for the sharpness statistic (Default: [0.2,1.0]). Change this default only if the stars have significantly larger or or smaller concentration than a Gaussian.
roundlim: 2 element vector giving low and high cutoff for the roundness statistic (Default: [-1.0,1.0]). Change this default only if the stars are significantly elongated.
Switches
silent: Normally, FIND will write out each star that meets all selection criteria. If the SILENT keyword is set then this printout is suppressed.
Returns
The find function returns an array of size 5xnstars with the following entries:<br>
x: vector containing x position of all stars identified by FIND<br> 
y: vector containing y position of all stars identified by FIND<br>
flux: vector containing flux of identified stars as determined by a gaussian fit. Fluxes are NOT converted to magnitudes.<br>
sharp: vector containing sharpness statistic for identified stars<br>
round: vector containing roundness statistic for identified stars
Notes
The sharpness statistic compares the central pixel to the mean of the surrounding pixels.   If this difference is greater than the originally estimated height of the Gaussian or less than 0.2 the height of the Gaussian (for the default values of SHARPLIM) then the star will be rejected.

histogram
Create a histogram of given array.
Syntax
result = histogram(a [, min [, max [, binsize]]] [, /reverse])
Arguments
a: 1D or 2D Array
min: Datapoints with a value smaller than min are neglected.
max: Datapoints with a value greater than max are neglected.
binsize: Default is 1. Values between are rounded
Switches
/reverse: Create the reverse indices of a histogram

meandev
Calculate the mean deviation of given array, optionally omitting a value. This is defined as 1/sqrt(n-1)*stddev(a).
Syntax
result = meandev(a [, omit])
Arguments
a: The array which mean deviation from the average should be returned.
omit: An optional value which should be ignored.
See also
function_stddev
function_avg

version
Return the version string of the currently used DPUSER.
Syntax
result = version()
Arguments
none

spifficube (obsolete)
Create a cube of a SPIFFI raw frame. The wavelength of each slitlet is shifted to one pixel accuracy. The wavelength scale is not being linearized.
Syntax
result = spifficube(inframe, [HK], [K])
Arguments
inframe: A raw SPIFFI frame (1024 x 1024 pixels)
Switches
HK: The shift in wavelength scale is done for the HK grism.
K: The shift in wavelength scale is done for the K grism.
See also
function_spiffiuncube
function_spiffishift

spiffiuncube (obsolete)
Undo cube creation done with spifficube. The resulting frame will be 1024 x 1024 (as for spiffi raw data).
Syntax
result = spiffiuncube(incube, [HK], [K])
Arguments
incube: A SPIFFI cube created with spifficube
Switches
HK: The shift in wavelength scale is done for the HK grism.
K: The shift in wavelength scale is done for the K grism.
See also
function_spifficube
function_spiffishift

spiffishift (obsolete)
Shift slitlets of a raw SPIFFI frame so that the wavelength of each slitlet is shifted to one pixel accuracy. The wavelength scale is not being linearized.
Syntax
result = spiffishift(inframe, [HK], [K])
Arguments
inframe: A raw SPIFFI frame (1024 x 1024 pixels)
Switches
HK: The shift in wavelength scale is done for the HK grism.
K: The shift in wavelength scale is done for the K grism.
See also
function_spifficube
function_spiffiuncube

bezier (obsolete)
xxx
Syntax
result = bezier(xxx [, xxx])
Arguments
xxx: xxx
xxx: xxx
See also
function_bezier1d

bezier1d (obsolete)
xxx
Syntax
result = bezier1d(xxx , xxx)
Arguments
xxx: xxx
xxx: xxx
See also
function_bezier

moffat
Create an elliptical moffat function.
Syntax
result = moffat(x, y, power, fwhm1 [, fwhm2 [, angle]] [, naxis1=value] [, naxis2 = value])
Arguments
X: The center of the moffat in the x-axes
Y: The center of the moffat in the y-axes
power: The power index of the moffat function
fwhm1: Full-width at half maximum of the major axes
fwhm2: Optional, full-width at half maximum of the minor axes
angle: Optional, position angle of the moffat
naxis1=value: Optional, the size of the resulting array in the first dimension
naxis2=value: Optional, the size of the resulting array in the second dimension

readfitsextension
Read specified FITS file extension into memory. The optional arguments x1, x2, y1, y2, z1, z2 can be used to read in a part of a FITS file. The combination 0, 0 specifies that the complete range of the respective axis should be read in.
Syntax
result = readfitsextension(FILENAME, extension [, x1, x2 [, y1, y2 [, z1, z2]]])
Arguments
FILENAME: A string.
extension: Integer number specifying which extension to read.
x1, x2: Range in first dimension, defaults to 0, 0
y1, y2: Range in second dimension, defaults to 0, 0
z1, z2: Range in third dimension, defaults to 0, 0
See also
function_readfits
function_readfitsall

multigauss2dfit
Fit a number of circular gaussians to an image. All gaussians have the save FWHM.
Syntax
result = multigauss2dfit(image, errors, estimate [, chisq])
Arguments
image: The image to be fit
errors: The errors in the image values
estimate: Initial estimate for the fit of the form [Offset,fwhm,height_1,x_1,y_1,height_2,x_2,y_2,...,height_n,x_n,y_n]
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
Returns
The returned vector contains the best-fit parameters in the form [Offset,fwhm,height_1,x_1,y_1,...,height_n,x_n,y_n,d_Offset,d_fwhm,d_height_1,d_x_1,d_y_1,...,d_height_n,d_x_n,d_y_n]
See also
function_gauss2dfit
function_gauss2dsimplefit

sincfit
Fit a sinc function to a set of data points. The function fit is y(x)=A+B*sinc((x+phi)/width)
Syntax
result = sincfit(X, Y, errors, estimate [, chisq])
Arguments
X: A vector containing the x values to be fit
Y: A vector containing the y values to be fit (in radians)
errors: The errors in Y
estimate: Initial estimate for the fit of the form [A,B,phi,width]
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
Returns
The returned vector contains the best-fit parameters in the form [A,B,phi,width,d_A,d_B,d_phi,d_width]

rebin1d
Rebin a one-dimensional vector to new values.
Syntax
result = rebin1d(spectrum, xstart, xend, xdelta [, xvalues])
Arguments
spectrum: A one-dimensional FITS. It should have the correct FITS keywords (CRVAL1, CRPIX1, and CDELT1) or the optional argument xvalues should be given.
xstart: The first channel in the rebinned data
xend: The last channel in the rebinned data
xdelta: The increment step size for the rebinned data
xvalues: A vector of same length as spectrum with the corresponding x-values.
Returns
The returned vector has the data rebinned with the appropritate FITS keywords set.
See also
function_interpol

velmap
Go through a datacube and fit a gaussian to a line. The arguments center and fwhm are used as initial estimate for the gauss-fit.
Syntax
result = velmap(cube, center, fwhm [, threshold])
Arguments
cube: A datacube
center: The approximate center (wavelength) of the line to fit
fwhm: The approximate FWHM of the line to fit
threshold: A lower limit under which no fit is attempted (given as percentage of peak flux)
Returns
A datacube with the following slices:<br>
result[*,*,1]: fit background<br>
result[*,*,2]: fit continuum<br>
result[*,*,3]: fit line center<br>
result[*,*,4]: fit line FWHM<br>
result[*,*,5]: error in background fit<br>
result[*,*,6]: error in continuum fit<br>
result[*,*,7]: error in line center fit<br>
result[*,*,8]: error in line FWHM fit<br>
result[*,*,9]: chi squared of fit<br>

fxcor
Compute the cross-correlation of two spectra. The spectra will be rebinned to the lowest dispersion, continuum subtracted and normalised prior to the cross-correlation.
Syntax
result = fxcor(template, spectrum)
Arguments
template: The template spectrum
spectrum: The object spectrum
Returns
The cross-correlation of the two spectra
See also
function_correlmap

correlmap
Compute the cross-correlation maximum of a datacube and a template spectrum.
Syntax
result = correlmap(cube, template)
Arguments
cube: The datacube to be cross-correlated
template: The template spectrum
Returns
A 2D-map with the maximum of the cross-correlation
See also
function_fxcor

longslit
Create a pseudo-longslit from a datacube.
Syntax
result = longslit(cube, x, y, theta, width)
Arguments
cube: A datacube
x: The x center for the longslit
y: The y center for the longslit
theta: The position angle, in degrees
width: The width of the longslit, in pixels
Returns
A 2D longslit spectrum
See also
function_twodcut

evalvelmap
Evaluate the result of velmap.
Syntax
result = evalvelmap(fit, template)
Arguments
fit: The result of the velmap function
template: A template cube which defines how big the resulting cube will be.
Returns
The evaluated cube, with gaussians at the appropriate places along the third dimension.
See also
function_velmap

sinfit
Fit a sine curve to a set of data points. The function fit is y(x)=A+B*sin(x+phi)
Syntax
result = sinfit(X, Y, errors, estimate [, chisq])
Arguments
X: A vector containing the x values to be fit
Y: A vector containing the y values to be fit (in radians)
errors: The errors in Y
estimate: Initial estimate for the fit of the form [A,B,phi]
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
Returns
The returned vector contains the best-fit parameters in the form [A,B,phi,d_A,d_B,d_phi]

indexbase
Return the base index: 0 for C-notation, 1 for Fortran-notation
Syntax
result = indexbase()
Arguments
none
Returns
The index base
See also
procedure_cnotation
procedure_fortrannotation
procedure_setindexbase

voronoi
Perform adaptive spatial binning of Integral-Field Spectroscopic (IFS) data to reach a chosen constant signal-to-noise ratio per bin. This method is required for the proper analysis of IFS observations, but can also be used for standard photometric imagery or any other two-dimensional data. Further information on VORONOI_2D_BINNING algorithm can be found in Cappellari M., Copin Y., 2003, MNRAS, 342, 345
Syntax
result = voronoi(signal, noise, target, targetSN [, /map])
Arguments
signal: A 2D map with the signal in each pixel
noise: A 2D map specifying the noise in each pixel. Pixels with a noise value of zero will be neglected in the voronoi binning
target: The image which should be binned (can be the same as the signal map)
targetSN: The Signal/Noise value which should be reached
Switches
/map: Instead of applying the binning to an image, return a map with regions and their respective IDs
Returns
Either the binned image or the map of regions
Notes
The original IDL code was written by Michele Cappellari, Leiden Observatory, The Netherlands cappellari@strw.leidenuniv.nl. If you have found this software useful for your research, he would appreciate an acknowledgment to use of `the Voronoi 2D-binning method by Cappellari & Copin (2003)'.

gauss2dsimplefit
Fit a two-dimensional gaussian to a rectangular grid (i.e. an image).
Syntax
result = gauss2dsimplefit(image, x, y, width [, chisq])
Arguments
image: The image to be fit
x: The x-position of the fit center
y: The x-position of the fit center
width: The half-width of the fitting window
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
Returns
The returned vector contains the best-fit parameters in the form [Offset,Max,x0,y0,fwhm1,fwhm2,angle,d_Offset,d_Max,d_x0,d_y0,d_fwhm1,d_fwhm2,d_angle]
See also
function_gauss2dfit
function_multigauss2dfit

transpoly
Compute the transformation matrix for two reference coordinate systems, with errors. It is described by a second order polynomial. The number of reference sources must be >= 6. The transformation function will be calculated using a least squares fit to given coordinates. Note that if either in REFSTARS or in IMSTARS a coordinate is exactly (-1, -1), this star will not be used to calculate the transformation matrix.
Syntax
result = transmatrix(REFSTARS, IMSTARS, ERRORS)
Arguments
REFSTARS: A matrix 2xm (m >= 6) with positions of the reference stars in the reference frame (= masterlist)
IMSTARS: A matrix 2xm (same size as REFSTARS) with the positions of the same stars in the image to be transformed.
ERRORS: A matrix 2xm (same size as REFSTARS) with the errors of the positions in REFSTARS.
Returns
A matrix 2x12 which describes the coordinate transformation matrix:
<code>x' = result[1,1] + result[2,1]*x + result[1,2]*y + result[2,2]*xy + result[1,3]*x^2 + result[2,3]*y^2
<code>y' = result[1,4] + result[2,4]*x + result[1,5]*y + result[2,5]*xy + result[1,6]*x^2 + result[2,6]*y^2<br>
The remaining coordinates [1:2,7:12] are the errors of the respective elements of the transformation matrix.
See also
function_transcoords
function_transform

strtrim
Removes leading and/or trailing blank from the input String.
Syntax
result = strtrim(str)
Arguments
str: A string
Returns
Returns a copy of the string with removed blanks.

right
Tail of a string.
Syntax
result = right(str, n)
Arguments
str: A text string
n: An integer 
Returns
Return the last n characters from string str.

ten
Transforms hours:minutes:seconds into decimal notation
Syntax
result = ten(hh , mm, ss)
Arguments
hh: hours
mm: minutes
ss: seconds
Returns
A decimal value with hours as unit
Examples
Transform 1h, 29min, 60 sec to decimal:
<code>print = ten(1, 29, 60)
<code>      1.5

primes
Creates a vector of given length with prime numbers.
Syntax
result = primes(n)
Arguments
n: The number of prime numbers to return
Returns
A vector of length n with the first n prime numbers.

twodcut
Create a 2D-cut from an image.
Syntax
result = twodcut(image, x, y, theta, width)
Arguments
image: An image
x: The x center for the 2D-cut
y: The y center for the 2D-cut
theta: The position angle, in degrees
width: The width of the cut, in pixels
Returns
A 1D spectrum
See also
function_longslit

simplifywhitespace
Strip all whitespaces at the beginning and the end, and replace all multiple occurrences of whitespaces by one single space.
Syntax
result = simplifywhitespace(s)
Arguments
s: The string to be simplified

strsplit
Split a string into a string array
Syntax
result = strsplit(s [, delimiter])
Arguments
s: The string to be split
delimiter: A single character at which to split (defaults to ' ')

sersic2dfit
Fit a two-dimensional sersic function to a rectangular grid (i.e. an image).<br>
The 2D sersic function is defined as I(x,y) = c + Ie * exp(-bn * (R/Re)^(1/n) - 1).<br>
R is an elliptical equation: R = sqrt(xp^2 + (yp / q)^2).<br>
xp and yp describe a rotation: xp = (x - x0) * cos(angle) + (y - y0) * sin(angle), yp = - (x - x0) * sin(angle) + (y - y0) * cos(angle) and bn = 1.9992 * n - 0.3271
Syntax
result = sersic2dfit(image, errors, estimate [, chisq])
Arguments
image: The image to be fit
errors: The errors in the image values
estimate: Initial estimate for the fit of the form [c, Ie, Re, x0, y0, angle, q, n]. If n is provided with a negative sign, it won't be fitted and assumed as fixed (with positive sign, of course).
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
Returns
The returned vector contains the best-fit parameters in the form [c, Ie, Re, x0, y0, angle, q, n] or [c, Ie, Re, x0, y0, angle, q] if n was kept fixed.
See also
function_sersic2dsimplefit

sersic2dsimplefit
Fit a two-dimensional sersic function to a rectangular grid (i.e. an image) without any given estimates.<br>
The 2D sersic function is defined as I(x,y) = c + Ie * exp(-bn * (R/Re)^(1/n) - 1).<br>
R is an elliptical equation: R = sqrt(xp^2 + (yp / q)^2).<br>
xp and yp describe a rotation: xp = (x - x0) * cos(angle) + (y - y0) * sin(angle), yp = - (x - x0) * sin(angle) + (y - y0) * cos(angle) and bn = 1.9992 * n - 0.3271.
Syntax
result = sersic2dsimplefit(image, x_cen, y_cen, width [, chisq [, n]])
Arguments
image: The image to be fit
x_cen: The x-position of the fit center
y_cen: The x-position of the fit center
width: The half-width of the fitting window
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
n: If n should be fixed and not fitted.
Returns
The returned vector contains the best-fit parameters in the form [c, Ie, Re, x0, y0, angle, q, n] or [c, Ie, Re, x0, y0, angle, q] if n was kept fixed. Angle is in degrees. When the negative reciprocal value in q is returned, then the angle is also increased by 90 degrees.
See also
function_sersic2dfit

sersicfit
Fit a one-dimensional sersic function to a vector. The sersic function is defined as y(x) = c + Ie * exp(-bn * (x/Re)^(1/n) - 1), with bn = 1.9992 * n - 0.3271.
Syntax
result = sersicfit(X, Y, errors, estimates [, chisq])
Arguments
X: A vector containing the x values to be fit
Y: A vector containing the y values to be fit
errors: The errors in Y
estimate: Initial estimate for the fit of the form [c, Ie, Re, n]. If n is provided with a negative sign, it won't be fitted and assumed as fixed (with positive sign, of course).
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
Returns
The returned vector contains the best-fit parameters in the form [c, Ie, Re, n] or [c, Ie, Re] if n was kept fixed. When the negative reciprocal value in q is returned, then the angle is also increased by 90 degrees.

sersic2d
Creates a 2D sersic. The sersic function is defined as y(x) = exp(-bn * (x/Re)^(1/n) - 1), with bn = 1.9992 * n - 0.3271.
Syntax
result = sersic2d(c, x0, y0, angle, q, n [, naxis1=value] [, naxis2 = value])
Arguments
Re: Effective radius that encloses half of the total light
x0: x-position of center
y0: y-position of center
angle: angle in degrees
q: diskiness
n: shape of light model (0.5 = gaussian, 1 = exponential, 4 = de Vaucouleurs)
Examples
<code>result = sersic2d(10,80,70,870,-2,1, naxis1=128, naxis2=128)

randomg
Returns a random number drawn from a Gaussian distribution centered on 0 with width SIGMA. If no SEED is given, a seed based on the current time is used.
Syntax
result = randomg(SIGMA [, SEED])
Arguments
SIGMA: Width of the Gaussian profile from which the number is drawn (real number).
SEED: Seed of the random number algorithm (integer number).
Returns
A random number
See also
function_random

poly
Create a polynomial
Syntax
result = poly(x, c)
Arguments
x: An array or real number
c: The coefficients of the polynomial
Returns
The polynomial of form c[1] + c[2]*x + c[3]*x^2 + ...

polyfit2d
Returns a 2D N-th order polynomial fit to X. X must be 2-dimensional. The function returns a vector of size sum(i+1)*2 (for i=0 to N). The fittet polynomial has the following form:
<code>for N=3: f(x,y) = a0 + a1*x + a2*y + a3*x^2 + a4*x*y + a5*y^2 + a6*x^3 + a7*x^2*y + a8*x*y^2 + a9*y^3
The values a0, ..., a9 are returned in the first 10 elements of the returned vector, their respective errors in the elements 11...20.
Syntax
result = polyfit2d(X, N [, CHISQ])
Arguments
X: A vector.
N: An integer number.
CHISQ: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
See also
function_polyfit
function_polyfitxy
function_polyfitxyerr
function_polyfit2derr

polyfit2derr
Returns a 2D N-th order polynomial fit to X. X must be 2-dimensional. The function returns a vector of size sum(i+1)*2 (for i=0 to N). The fittet polynomial has the following form:
<code>for N=3: f(x,y) = a0 + a1*x + a2*y + a3*x^2 + a4*x*y + a5*y^2 + a6*x^3 + a7*x^2*y + a8*x*y^2 + a9*y^3
The values a0, ..., a9 are returned in the first 10 elements of the returned vector, their respective errors in the elements 11...20.
Syntax
result = polyfit2d(X, N, ERROR [, CHISQ])
Arguments
X: A vector.
N: An integer number.
ERROR: The error of the X-values. If this is a real number, all X-values are assumed to have the same error. If ERROR is a vector, it must have the same length as X and gives the error or each individual X value.
CHISQ: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
See also
function_polyfit
function_polyfitxy
function_polyfitxyerr
function_polyfit2derr

getbitpix
Get the pixel type of X.
Syntax
result = getbitpix(X)
Arguments
X: The array whose pixel type is to be output
Returns
-128: Complex (note that this does not conform to FITS standard)<br>
-64: Floating point, double precision<br>
-32: Floating point, single precision<br>
8: Unsigned char<br>
16: Short<br>
32: Long
See also
function_setbitpix

isnan
Returns a non-zero value if value is 'not-a-number' (NaN), and 0 otherwise.
Syntax
result = isnan(a)
Arguments
a: The value to check
See also
function_isinf

isinf
Returns -1 if value represents negative infinity, 1 if value represents positive infinity, and 0 otherwise.
If the value is complex and 'inf + -inf i' or '-inf + inf i' then -0.5 will be returned.
Syntax
result = isinf(a)
Arguments
a: The value to check
See also
function_isnan

identifylines
This function attempts to find the reference pattern LINES in a list of observed positions PEAKS. In the following documentation a terminology drawn from the context of arc lamp spectra calibration is used for simplicity: the reference pattern is then a list of wavelengths corresponding to a set of reference arc lamp emission lines - the so-called line catalog; while the observed positions are the positions (in pixel) on the CCD, measured along the dispersion direction, of any significant peak of the signal. To identify the observed peaks means to associate them with the right reference wavelength. This is attempted here with a point-pattern matching technique, where the pattern is contained in the vector LINES, and is searched in the vector PEAKS. In order to work, this method just requires a rough expectation value of the spectral dispersion (in Angstrom/pixel), and a line catalog. The line catalog LINES should just include lines that are expected somewhere in the CCD exposure of the calibration lamp (note, however, that a catalog including extra lines at its blue and/or red ends is still allowed). Typically, the arc lamp lines candidates PEAKS will include light contaminations, hot pixels, and other unwanted signal, but only in extreme cases this prevents the pattern-recognition algorithm from identifying all the spectral lines. The pattern is detected even in the case PEAKS contained more arc lamp lines than actually listed in the input line catalog. This method is based on the assumption that the relation between wavelengths and CCD positions is with good approximation locally linear (this is always true, for any modern spectrograph). The ratio between consecutive intervals pairs in wavelength and in pixel is invariant to linear transformations, and therefore this quantity can be used in the recognition of local portions of the searched pattern. All the examined sub-patterns will overlap, leading to the final identification of the whole pattern, notwithstanding the overall non-linearity of the relation between pixels and wavelengths. Ambiguous cases, caused by exceptional regularities in the pattern, or by a number of undetected (but expected) peaks that disrupt the pattern on the data, are recovered by linear interpolation and extrapolation of the safely identified peaks.
Syntax
result = identifylines(PEAKS, LINES, MIN_DISP, MAX_DISP, TOLERANCE)
Arguments
PEAKS:     A 1D-Fits, List of observed positions (e.g., of emission peaks)
LINES:     A 1D-Fits, List of positions in searched pattern (e.g., wavelengths)
MIN_DISP:  Min expected scale (e.g., spectral dispersion in A/pixel)
MAX_DISP:  Max expected scale (e.g., spectral dispersion in A/pixel)
TOLERANCE: Tolerance for interval ratio comparison

evalgaussfit
Evaluate a gaussfit along a vector of x values.
Syntax
result = evalgaussfit(X, fit)
Arguments
X: A vector of x values at which to evaluate the gaussian fit
fit: The gaussian fit, as returned by the gaussfit function
Returns
A vectors, same length as X, with the gaussian evaluated at the X positions supplied.
See also
function_gaussfit

polyroots
Return the roots of a polynomial. The polynomial is defined as P(x) = P[1] + P[2]*x + P[3]*x^2 + ... + P[n]*x^(n-1)
Syntax
result = polyroots(P [, derivative])
Arguments
P: The polynomial
derivative: Optional, if an integer number is given, the nth derivative is returned.
Returns
A vector with the roots (or derivatives of) the polynomial
Examples
Calculate the roots of the polynomias 1 + x^2 = 0:
<code>print polyroots([1, 0, 1]), /values

interpolate
Returns the interpolated value of a given position (x,y). If x and y are integers the value at that position is returned without any interpolation.
Syntax
result = interpolate(A, x, y [, kernel_size])
Arguments
A: A 2D-image.
x: An real number.
x: An real number.
kernel_size: Any integer number, default is 4. Remember that points near the image border can't be interpolated (border-size is half the kernel-size)

radialprofile
Returns a radial profile centered on (x,y)
Syntax
result = radialprofile(A, x, y)
Arguments
A: A 2D-image
x: An integer number, the x center of the profile
y: An integer number, the y center of the profile
See also
function_ellipticalprofile

ellipticalprofile
Returns an elliptical profile centered on (x,y) with position angle a, aspect ratio r, and width w.
Syntax
result = radialprofile(A, x, y, a, r, w)
Arguments
A: A 2D-image
x: An integer number, the x center of the profile
y: An integer number, the y center of the profile
a: A real number denoting the angle of the ellipse
r: A real number denoting the aspect ratio of the ellipse
w: An integer number giving the width of single elements of the ellipse
See also
function_radialprofile

multigaussfit
Fit multiple gaussians to a vector. The gauss function is defined as G(x) = SUM_i [A_i + B_i*exp(-4ln2*(x-x0_i)^2/fwhm_i^2)].
Syntax
result = multigaussfit(X, Y, errors, estimate [, chisq])
Arguments
X: A vector containing the x values to be fit
Y: A vector containing the y values to be fit
errors: The errors in Y
estimate: Initial estimate for the fit of the form [A, B, x0, fwhm]
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
Returns
The returned vector contains the best-fit parameters in the form [A1, B1, x01, fwhm1, A2, ..., d_A1, d_B1, d_x01, d_fwhm1, d_A2, ...]
See also
function_gaussfit

readfitsall
Read a FITS file and all its extensions. The FITS will be stored in a variable to type dpuserTypeList.
Syntax
result = readfitsall(filename)
Arguments
filename: A string pointing to the file to be read
See also
function_readfits
function_readfitsextension

cubequantile
Does a quantile of all images in X.
Syntax
result = cubequantile(X, quantile)
Arguments
X: A matrix or a FITS file name. If a FITS file name is given, the global variable tmpmem determines how many bytes of data are read in at a time.
quantile: The quantile to be returned (0...1).
See also
function_cubemedian

quantile
Compute the quantile of X.
Syntax
result = quantile(X, quantile)
Arguments
X: A matrix.
quantile: The quantile to be returned (0...1).
See also
function_median

sersic2dsmoothfit
Fit a two-dimensional smoothed sersic function to a rectangular grid (i.e. an image).<br>
The 2D sersic function is defined as I(x,y) = c + Ie * exp(-bn * (R/Re)^(1/n) - 1).<br>
R is an elliptical equation: R = sqrt(xp^2 + (yp / q)^2).<br>
xp and yp describe a rotation: xp = (x - x0) * cos(angle) + (y - y0) * sin(angle), yp = - (x - x0) * sin(angle) + (y - y0) * cos(angle) and bn = 1.9992 * n - 0.3271<br>
The resulting 2D sersic function is then smoothed by convolving with a gaussian with a FWHM given by the smooth parameter.
Syntax
result = sersic2dsmoothfit(image, errors, smooth, estimate [, chisq])
Arguments
image: The image to be fit
errors: The errors in the image values
smooth: The FWHM for the gaussian smoothing
estimate: Initial estimate for the fit of the form [c, Ie, Re, x0, y0, angle, q, n]. If n is provided with a negative sign, it won't be fitted and assumed as fixed (with positive sign, of course).
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
Returns
The returned vector contains the best-fit parameters in the form [c, Ie, Re, x0, y0, angle, q, n] or [c, Ie, Re, x0, y0, angle, q] if n was kept fixed.
See also
function_sersic2dfit
function_sersic2dsmoothsimplefit

sersic2dsmoothsimplefit
Fit a two-dimensional smoothed sersic function to a rectangular grid (i.e. an image).<br>
The 2D sersic function is defined as I(x,y) = c + Ie * exp(-bn * (R/Re)^(1/n) - 1).<br>
R is an elliptical equation: R = sqrt(xp^2 + (yp / q)^2).<br>
xp and yp describe a rotation: xp = (x - x0) * cos(angle) + (y - y0) * sin(angle), yp = - (x - x0) * sin(angle) + (y - y0) * cos(angle) and bn = 1.9992 * n - 0.3271<br>
The resulting 2D sersic function is then smoothed by convolving with a gaussian with a FWHM given by the smooth parameter.
Syntax
result = sersic2dsmoothsimplefit(image, errors, x0, y0, width, smooth [, chisq])
Arguments
image: The image to be fit
errors: The errors in the image values
x0, y0: The center coordinates of the window to fit
width: The width of the window to fit
smooth: The FWHM for the gaussian smoothing
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
Returns
The returned vector contains the best-fit parameters in the form [c, Ie, Re, x0, y0, angle, q, n] or [c, Ie, Re, x0, y0, angle, q] if n was kept fixed.
See also
function_sersic2dfit
function_sersic2dsmoothfit

readfitsbintable
Read a FITS binary table from disk file
Syntax
result = readfitsbintable(file, extension, column)
Arguments
file: The FITS file to be read
extension: Which extension to read, either an integer number >= 1, or a string with the EXTNAME
column: Which column to read, either an integer number >= 1, or a string with the Column Name
Returns
The column of the specified FITS binary table

listfitsextensions
List extension names of all extensions in a FITS file
Syntax
result = listfitsextensions(fname)
Arguments
fname: A string containing the FITS file name
Returns
A string array with all FITS extension names

listtablecolumns
List FITS binary table column names of specified extension in a FITS file
Syntax
result = listtablecolumns(fname, extension)
Arguments
fname: A string containing the FITS file name
extension: Which extension to read, either an integer number >= 1, or a string with the EXTNAME
Returns
A string array with all FITS binary table column names

interpol
1D cubic spline interpolation.
Syntax
result = interpol(y, x, x_new)
Arguments
y: The given y-values as array.
x: The given x-values as array. The arrays x and y must be of same length.
x_new: The new x-values as array.
Returns
The new y-values at given points in x_new.
See also
function_rebin1d

where
Create a one-dimensional array of indices which satisfy a given expression.
Syntax
result = where(array comparison scalar)
Arguments
array: An array of any dimension that is to be evaluated
comparison: Any of the known comparison operators (==, !=, >, >=, <, <=)
scalar: A scalar value
Returns
A one-dimensional vector of the indices in array which satisfied the comparison
Examples
Create a sine curve and set all negative values to 0:
<code>sine = sin([0:1000]/100)
<code>sine[where(sine < 0)] = 0

list
Create a FITS list
Syntax
result = list(arg1, ..., arg10)
Arguments
arg1...arg10: Up to 10 FITS or StringArray to be included in the list
Returns
A FITS list with copies of the given arguments

straightlinefit
Fit a straight line to data with errors in both coordinates
Syntax
result = straightlinefit(x, y, dx, dy [, chisq])
Arguments
x: the x values of the data to fit
y: the y values of the data to fit
dx: the errors in x
dy: the errors in y
chisq: If set to a named variable, the variable is overwritten with the chi-squared of the fit.
Returns
The returned vector contains the best-fit parameters

pyvar
Copy a PYTHON variable to DPUSER
Syntax
result = pyvar(variable)
Arguments
variable: A string naming the PYTHON variable
Returns
A deep copy of the PYTHON variable
Examples
Create a variable within the PYTHON module, and then pass this back to DPUSER:
<code>python "a=1"
<code>hhh = pyvar("a")

