Class VisualNumerics.math.ComplexVector

All Packages  Class Hierarchy  This Package  Previous  Next  Index

Class VisualNumerics.math.ComplexVector

java.lang.Object
   |
   +----VisualNumerics.math.ComplexVector

public final class ComplexVector
extends Object

Complex vector manipulation functions. This class cannot be instantiated.

add(Complex, Complex[]): Add a Complex scalar to each element of the vector, z_i + b for all values of the index i.
add(Complex[], Complex[]): Add a Complex vector to a Complex vector.
add(double, Complex[]): Add a scalar of type double to each element of the vector, z_i + b for all values of the index i.
add(double[], Complex[]): Add a double vector to a Complex vector.
conjugate(Complex[]): Return the complex conjugate of each Complex object in the array.
imag(Complex[]): Return the imaginary part of each Complex element of the array.
infinityNorm(Complex[]): Calculate the infinity norm of a vector.
innerProduct(Complex[], Complex[]): Calculate the dot product of two vectors.
multiply(Complex, Complex[]): Multiply a Complex vector by a Complex scalar, z_i * b for all values of the index i.
multiply(Complex[], Complex[]): Multiply a Complex vector by a Complex vector.
multiply(double, Complex[]): Multiply a Complex vector by a scalar of type double, z_i * b for all values of the index i.
multiply(double[], Complex[]): Multiply a Complex vector by a double vector.
oneNorm(Complex[]): Calculate the one norm of a vector.
product(Complex[]): Calculate the product of the array elements.
real(Complex[]): Return the real part of each Complex element of the array.
subtract(Complex[], Complex): Subtract a Complex scalar from a Complex vector, z_i - b, for all values of the index i.
subtract(Complex[], Complex[]): Subtract a Complex vector from a Complex vector, b - z.
subtract(Complex[], double): Subtract a scalar of type double from a Complex vector, z_i - b for all values of the index i.
subtract(Complex[], double[]): Subtract a double vector from a Complex vector, z - b.
subtract(double[], Complex[]): Subtract a Complex vector from a double vector, b - z.
sum(Complex[]): Calculate the sum of the array elements.
twoNorm(Complex[]): Calculate the Euclidean or two norm of a vector.

ComplexVector

  public ComplexVector()

conjugate

  public static Complex[] conjugate(Complex z[])

Return the complex conjugate of each Complex object in the array.

Parameters:: z - A vector with Complex elements.
Returns:: A vector whose elements are complex conjugates of corresponding elements in the input vector.

sum

  public static Complex sum(Complex z[])

Calculate the sum of the array elements.

Parameters:: z - A vector with Complex elements.
Returns:: A Complex object equal to the sum of the array elements.

product

  public static Complex product(Complex z[])

Calculate the product of the array elements.

Parameters:: z - A vector with Complex elements.
Returns:: A Complex object equal to the product of the array elements.

innerProduct

  public static Complex innerProduct(Complex x[],
                                     Complex y[])

Calculate the dot product of two vectors.

Parameters:: x - A vector with Complex elements.; y - A vector with Complex elements.
Returns:: A Complex object equal to the dot product of the two vectors.

oneNorm

  public static double oneNorm(Complex z[])

Calculate the one norm of a vector.

Parameters:: z - A vector with Complex elements.
Returns:: A double value equal to the sum of the absolute values of the elements.

twoNorm

  public static double twoNorm(Complex z[])

Calculate the Euclidean or two norm of a vector.

Parameters:: z - A vector with Complex elements.
Returns:: A double value equal to its Euclidean norm.

infinityNorm

  public static double infinityNorm(Complex z[])

Calculate the infinity norm of a vector.

Parameters:: z - A vector with elements of type Complex.
Returns:: A double value equal to the maximum of the absolute values of the elements of the array.

real

  public static double[] real(Complex z[])

Return the real part of each Complex element of the array.

Parameters:: z - A vector with Complex elements.
Returns:: A vector whose elements are the real parts of corresponding elements in the input vector.

imag

  public static double[] imag(Complex z[])

Return the imaginary part of each Complex element of the array.

Parameters:: z - A vector with Complex elements.
Returns:: A vector whose elements are the imaginary parts of corresponding elements in the input vector.

add

  public static Complex[] add(double b,
                              Complex z[])

Add a scalar of type double to each element of the vector, z_i + b for all values of the index i.

Parameters:: b - A double value.; z - A vector with Complex elements.
Returns:: A Complex vector where each element is the sum of the corresponding element in z and the input scalar b.

add

  public static Complex[] add(Complex b,
                              Complex z[])

Add a Complex scalar to each element of the vector, z_i + b for all values of the index i.

Parameters:: b - A Complex object.; z - A vector with Complex elements.
Returns:: A Complex vector where each element is the sum of the corresponding element in z and the input scalar b.

add

  public static Complex[] add(double b[],
                              Complex z[])

Add a double vector to a Complex vector.

Parameters:: b - A vector with elements of type double.; z - A vector with Complex elements.
Returns:: A Complex vector containing the elementwise sum of b and z.
Throws: IllegalArgumentException: This exception is thrown when the input vectors do not have the same length.

add

  public static Complex[] add(Complex b[],
                              Complex z[])

Add a Complex vector to a Complex vector.

Parameters:: b - A vector with Complex elements.; z - A vector with Complex elements.
Returns:: A Complex vector containing the elementwise sum of b and z.
Throws: IllegalArgumentException: This exception is thrown when the input vectors do not have the same length.

subtract

  public static Complex[] subtract(Complex z[],
                                   double b)

Subtract a scalar of type double from a Complex vector, z_i - b for all values of the index i.

Parameters:: z - A vector with Complex elements.; b - A double value.
Returns:: A Complex vector where each element is the difference between the corresponding element of z and the input scalar b.

subtract

  public static Complex[] subtract(Complex z[],
                                   Complex b)

Subtract a Complex scalar from a Complex vector, z_i - b, for all values of the index i.

Parameters:: z - A vector with Complex elements.; b - A Complex object.
Returns:: A Complex vector where each element is the difference between the corresponding element in z and the input scalar b.

subtract

  public static Complex[] subtract(double b[],
                                   Complex z[])

Subtract a Complex vector from a double vector, b - z.

Parameters:: b - A vector with elements of type double.; z - A vector with Complex elements.
Returns:: A Complex vector containing the elementwise difference between the input vectors.
Throws: IllegalArgumentException: This exception is thrown when the input vectors do not have the same length.

subtract

  public static Complex[] subtract(Complex z[],
                                   double b[])

Subtract a double vector from a Complex vector, z - b.

Parameters:: z - A vector with Complex elements.; b - A vector with elements of type double.
Returns:: A Complex vector containing the elementwise difference between the input vectors.
Throws: IllegalArgumentException: This exception is thrown when the input vectors do not have the same length.

subtract

  public static Complex[] subtract(Complex b[],
                                   Complex z[])

Subtract a Complex vector from a Complex vector, b - z.

Parameters:: b - A vector with Complex elements.; z - A vector with Complex elements.
Returns:: A Complex vector containing the elementwise difference between the input vectors.
Throws: IllegalArgumentException: This exception is thrown when the input vectors do not have the same length.

multiply

  public static Complex[] multiply(double b,
                                   Complex z[])

Multiply a Complex vector by a scalar of type double, z_i * b for all values of the index i.

Parameters:: b - A double value.; z - A vector with Complex elements.
Returns:: A Complex vector where each element is the product of the corresponding element in the input vector and the input scalar b.

multiply

  public static Complex[] multiply(Complex b,
                                   Complex z[])

Multiply a Complex vector by a Complex scalar, z_i * b for all values of the index i.

Parameters:: b - A Complex object.; z - A vector with Complex elements.
Returns:: A Complex vector where each element is the product of the corresponding element in the input vector and the input scalar b.

multiply

  public static Complex[] multiply(double b[],
                                   Complex z[])

Multiply a Complex vector by a double vector.

Parameters:: b - A vector with elements of type double.; z - A vector with Complex elements.
Returns:: A Complex vector containing the elementwise product of the input vectors.
Throws: IllegalArgumentException: This exception is thrown when the input vectors do not have the same length.

multiply

  public static Complex[] multiply(Complex b[],
                                   Complex z[])

Multiply a Complex vector by a Complex vector.

Parameters:: b - A vector with Complex elements.; z - A vector with Complex elements.
Returns:: A Complex vector containing the elementwise product of the input vectors.
Throws: IllegalArgumentException: This exception is thrown when the input vectors do not have the same length.

All Packages  Class Hierarchy  This Package  Previous  Next  Index