Go to the first, previous, next, last section, table of contents.
Unless otherwise noted, all of the functions described in this chapter
will work for real and complex scalar or matrix arguments.
The following functions are available for working with complex numbers.
Each expects a single argument. They are called mapping functions
because when given a matrix argument, they apply the given function to
each element of the matrix.
- Mapping Function: ceil (x)
-
Return the smallest integer not less than x. If x is
complex, return
ceil (real (x)) + ceil (imag (x)) * I
.
- Mapping Function: exp (x)
-
Compute the exponential of x. To compute the matrix exponential,
see section Linear Algebra.
- Mapping Function: fix (x)
-
Truncate x toward zero. If x is complex, return
fix (real (x)) + fix (imag (x)) * I
.
- Mapping Function: floor (x)
-
Return the largest integer not greater than x. If x is
complex, return
floor (real (x)) + floor (imag (x)) * I
.
- Mapping Function: gcd (x,
...
)
-
Compute the greatest common divisor of the elements of x, or the
list of all the arguments. For example,
gcd (a1, ..., ak)
is the same as
gcd ([a1, ..., ak])
An optional second return value, v
contains an integer vector such that
g = v(1) * a(k) + ... + v(k) * a(k)
- Mapping Function: lcm (x,
...
)
-
Compute the least common multiple of the elements elements of x, or
the list of all the arguments. For example,
lcm (a1, ..., ak)
is the same as
lcm ([a1, ..., ak]).
- Mapping Function: log (x)
-
Compute the natural logarithm for each element of x. To compute the
matrix logarithm, see section Linear Algebra.
See also: log2, log10, logspace, exp
- Mapping Function: log10 (x)
-
Compute the base-10 logarithm for each element of x.
See also: log, log2, logspace, exp
- Mapping Function: y = log2 (x)
-
- Mapping Function: [f, e] log2 (x)
-
Compute the base-2 logarithm of x. With two outputs, returns
f and e such that
1/2 <= abs(f) < 1 and x = f * 2^e.
max (X): maximum value(s) of a vector (matrix)
min (X): minimum value(s) of a vector (matrix)
- Function File: nextpow2 (x)
-
If x is a scalar, returns the first integer n such that
2^n >= abs (x).
If x is a vector, return
nextpow2 (length (x))
.
- Mapping Function: pow2 (x)
-
- Mapping Function: pow2 (f, e)
-
With one argument, computes
2 .^ x
for each element of x. With two arguments, returns
f .* (2 .^ e).
- Mapping Function: rem (x, y)
-
Return the remainder of
x / y
, computed using the
expression
x - y .* fix (x ./ y)
An error message is printed if the dimensions of the arguments do not
agree, or if either of the arguments is complex.
- Mapping Function: round (x)
-
Return the integer nearest to x. If x is complex, return
round (real (x)) + round (imag (x)) * I
.
See also: rem
- Mapping Function: sign (x)
-
Compute the signum function, which is defined as
-1, x < 0;
sign (x) = 0, x = 0;
1, x > 0.
For complex arguments, sign
returns x ./ abs (x)
.
- Mapping Function: sqrt (x)
-
Compute the square root of x. If x is negative, a complex
result is returned. To compute the matrix square root, see
section Linear Algebra.
The following functions are available for working with complex
numbers. Each expects a single argument. Given a matrix they work on
an element by element basis. In the descriptions of the following
functions,
z is the complex number x + iy, where i is
defined as sqrt (-1)
.
- Mapping Function: abs (z)
-
Compute the magnitude of z, defined as
|z| =
sqrt (x^2 + y^2)
.
For example,
abs (3 + 4i)
=> 5
- Mapping Function: angle (z)
-
Compute the argument of z, defined as
theta =
atan (y/x)
.
in radians.
For example,
arg (3 + 4i)
=> 0.92730
- Mapping Function: conj (z)
-
Return the complex conjugate of z, defined as
conj (z)
= x - iy.
See also: real, imag
- Mapping Function: imag (z)
-
Return the imaginary part of z as a real number.
See also: real, conj
- Mapping Function: real (z)
-
Return the real part of z.
See also: imag, conj
Octave provides the following trigonometric functions. Angles are
specified in radians. To convert from degrees to radians multipy by
pi/180
(e.g. sin (30 * pi/180)
returns the sine of 30 degrees).
- Mapping Function: sin (X)
-
sin (X): compute the sin of X for each element of X
- Mapping Function: cos (X)
-
cos (X): compute the cosine of X for each element of X
- Mapping Function: tan (z)
-
tan (X): compute tanget of X for each element of X
- Mapping Function: sec (X)
-
sec (X): compute the secant of X for each element of X
- Mapping Function: csc (X)
-
csc (X): compute the cosecant of X for each element of X
- Mapping Function: cot (X)
-
cot (X): compute the cotangent of X for each element of X
- Mapping Function: asin (X)
-
asin (X): compute inverse sin (X) for each element of X
- Mapping Function: acos (X)
-
acos (X): compute the inverse cosine of X for each element of X
- Mapping Function: atan (X)
-
atan (X): compute the inverse tangent of (X) for each element of X
- Mapping Function: asec (X)
-
asec (X): compute the inverse secant of X for each element of X
- Mapping Function: acsc (X)
-
acsc (X): compute the inverse cosecant of X for each element of X
- Mapping Function: acot (X)
-
acot (X): compute the inverse cotangent of X for each element of X
- Mapping Function: sinh (X)
-
sinh (X): compute the inverse hyperbolic sin of X for each element of X
- Mapping Function: acosh (X)
-
acosh (X): compute the inverse hyperbolic cosine of X for each element of X
- Mapping Function: tanh (X)
-
tanh (X): compute hyperbolic tangent of X for each element of X
- Mapping Function: sech (X)
-
sech (X): compute the hyperbolic secant of X for each element of X
- Mapping Function: coth (X)
-
coth (X): compute the hyperbolic cotangent of X for each element of X
- Mapping Function: asinh (X)
-
asinh (X): compute the inverse hyperbolic sin (X) for each element of X
- Mapping Function: acosh (X)
-
acosh (X): compute the inverse hyperbolic cosine of X for each element of X.
- Mapping Function: atanh (X)
-
atanh (X): compute the inverse hyperbolic tanget of X for each element of X
- Mapping Function: asech (X)
-
asech (X): compute the inverse hyperbolic secant of X for each element of X
- Mapping Function: acsch (X)
-
acsch (X): compute the inverse hyperbolic for each element of X
acoth (z): compute the inverse hyperbolic cotangent for each element of z.
Each of these functions expect a single argument. For matrix arguments,
they work on an element by element basis. For example,
sin ([1, 2; 3, 4])
=> 0.84147 0.90930
0.14112 -0.75680
atan2 (Y, X): atan (Y / X) in range -pi to pi
sum (X): sum of elements
prod (X): products
cumsum (X): cumulative sums
cumprod (X): cumulative products
sumsq (X): sum of squares of elements.
This function is equivalent to computing
sum (X .* conj (X))
but it uses less memory and avoids calling conj if X is real.
- Mapping Function: besseli (alpha, x)
-
- Mapping Function: besselj (alpha, x)
-
- Mapping Function: besselk (alpha, x)
-
- Mapping Function: bessely (alpha, x)
-
Compute Bessel functions of the following types:
besselj
-
Bessel functions of the first kind.
bessely
-
Bessel functions of the second kind.
besseli
-
Modified Bessel functions of the first kind.
besselk
-
Modified Bessel functions of the second kind.
The second argument, x, must be a real matrix, vector, or scalar.
The first argument, alpha, must be greater than or equal to zero.
If alpha is a range, it must have an increment equal to one.
If alpha is a scalar, the result is the same size as x.
If alpha is a range, x must be a vector or scalar, and the
result is a matrix with length(x)
rows and
length(alpha)
columns.
- Mapping Function: beta (a, b)
-
Return the Beta function,
beta (a, b) = gamma (a) * gamma (b) / gamma (a + b).
- Mapping Function: betai (a, b, x)
-
Return the incomplete Beta function,
x
/
betai (a, b, x) = beta (a, b)^(-1) | t^(a-1) (1-t)^(b-1) dt.
/
t=0
If x has more than one component, both a and b must be
scalars. If x is a scalar, a and b must be of
compatible dimensions.
- Mapping Function: bincoeff (n, k)
-
Return the binomial coefficient of n and k, defined as
/ \
| n | n (n-1) (n-2) ... (n-k+1)
| | = -------------------------
| k | k!
\ /
For example,
bincoeff (5, 2)
=> 10
- Mapping Function: erf (z)
-
Computes the error function,
z
/
erf (z) = (2/sqrt (pi)) | e^(-t^2) dt
/
t=0
See also: erfc, erfinv
- Mapping Function: erfc (z)
-
Computes the complementary error function,
1 - erf (z)
.
See also: erf, erfinv
- Mapping Function: erfinv (z)
-
Computes the inverse of the error function,
- Mapping Function: gamma (z)
-
Computes the Gamma function,
infinity
/
gamma (z) = | t^(z-1) exp (-t) dt.
/
t=0
See also: gammai, lgamma
- Mapping Function: gammai (a, x)
-
Computes the incomplete gamma function,
x
1 /
gammai (a, x) = --------- | exp (-t) t^(a-1) dt
gamma (a) /
t=0
If a is scalar, then gammai (a, x)
is returned
for each element of x and vice versa.
If neither a nor x is scalar, the sizes of a and
x must agree, and gammai is applied element-by-element.
- Mapping Function: lgamma (a, x)
-
- Mapping Function: gammaln (a, x)
-
Return the natural logarithm of the gamma function.
See also: gamma, gammai
- Function File: cross (x, y)
-
Computes the vector cross product of the two 3-dimensional vectors
x and y. For example,
cross ([1,1,0], [0,1,1])
=> [ 1; -1; 1 ]
- Function File: commutation_matrix (m, n)
-
Return the commutation matrix
K(m,n)
which is the unique
m*n by m*n
matrix such that
K(m,n) * vec (A) = vec (A')
for all
m by n
matrices
A.
If only one argument m is given,
K(m,m)
is returned.
See Magnus and Neudecker (1988), Matrix differential calculus with
applications in statistics and econometrics.
- Function File: duplication_matrix (n)
-
Return the duplication matrix
D_n
which is the unique
n^2 by n*(n+1)/2
matrix such that
D_n \cdot vech (A) = vec (A)
for all symmetric
n by n
matrices
A.
See Magnus and Neudecker (1988), Matrix differential calculus with
applications in statistics and econometrics.
- Built-in Variable: I
-
- Built-in Variable: J
-
- Built-in Variable: i
-
- Built-in Variable: j
-
A pure imaginary number, defined as
sqrt (-1)
.
The I
and J
forms are true constants, and cannot be
modified. The i
and j
forms are like ordinary variables,
and may be used for other purposes. However, unlike other variables,
they once again assume their special predefined values if they are
cleared See section Status of Variables.
- Built-in Variable: Inf
-
- Built-in Variable: inf
-
Infinity. This is the result of an operation like 1/0, or an operation
that results in a floating point overflow.
- Built-in Variable: NaN
-
- Built-in Variable: nan
-
Not a number. This is the result of an operation like
0/0, or `Inf - Inf',
or any operation with a NaN.
Note that NaN always compares not equal to NaN. This behavior is
specified by the IEEE standard for floating point arithmetic. To
find NaN values, you must use the isnan
function.
- Built-in Variable: pi
-
The ratio of the circumference of a circle to its diameter.
Internally,
pi
is computed as `4.0 * atan (1.0)'.
- Built-in Variable: e
-
The base of natural logarithms. The constant
e
satisfies the equation
log
(e) = 1.
- Built-in Variable: eps
-
The machine precision. More precisely,
eps
is the largest
relative spacing between any two adjacent numbers in the machine's
floating point system. This number is obviously system-dependent. On
machines that support 64 bit IEEE floating point arithmetic, eps
is approximately
2.2204e-16.
- Built-in Variable: realmax
-
The largest floating point number that is representable. The actual
value is system-dependent. On machines that support 64 bit IEEE
floating point arithmetic,
realmax
is approximately
1.7977e+308
- Built-in Variable: realmin
-
The smallest floating point number that is representable. The actual
value is system-dependent. On machines that support 64 bit IEEE
floating point arithmetic,
realmin
is approximately
2.2251e-308
% DO NOT EDIT! Generated automatically by munge-texi.
Go to the first, previous, next, last section, table of contents.