#include <IntBLAS.h>
Inheritance diagram for intblas::IntervalMatrix:

Public Member Functions | |
| IntervalMatrix () | |
| This method creates an empty matrix. | |
| IntervalMatrix (unsigned int n, unsigned int m, bool is_ir=false) | |
| Creates a matrix with the given number of rows and columns. | |
| IntervalMatrix (const IntervalMatrix &m) | |
| Copy construtor, note this is equivelent to assignment. | |
| IntervalMatrix (double **l, double **u, unsigned int rows, unsigned int cols) | |
| This constructs a matrix from two matrices of type double, creating intervals of l and u. | |
| int | getRows () const |
| Returns the number of rows in a matrix. | |
| int | getCols () const |
| Returns the number of columns in a matrix. | |
| Interval & | getAt (unsigned int r, unsigned int c) const |
| Returns a reference to the element at row r and column c. | |
| void | setAt (unsigned int r, unsigned int c, const Interval &i) |
| Sets the value of the element at row r and column c to i. | |
| IntervalMatrix | getIdentity () |
| This method returns an identity matrix of the current size. | |
| Interval * | operator[] (unsigned int index) const |
| This operator returns a reference to the row of the matrix. | |
| void | operator= (const IntervalMatrix &b) |
| Copies the values of the matrix b into this matrix. | |
| bool | operator== (const IntervalMatrix &b) const |
| This operator tests element wise to see if this matrix and b are equivalent. | |
| IntervalMatrix & | operator+ (IntervalMatrix &b) |
| This operator adds b to this matrix. | |
| IntervalMatrix & | operator+ (const Interval &scalar) |
| This operator adds a scalar value to this matrix. | |
| IntervalMatrix & | operator- (IntervalMatrix &b) |
| This operator subtracts b from this matrix. | |
| IntervalMatrix & | operator- (const Interval &scalar) |
| This operator subtracts a scalar value from a. | |
| IntervalMatrix & | operator * (IntervalMatrix &b) |
| This operator multiplies b to this matrix. | |
| IntervalMatrix & | operator * (const Interval &scalar) |
| This operator multiplies the scalar by this matrix. | |
| IntervalVector & | operator * (IntervalVector &v) |
| This operator multiplies this matrix by a vector. | |
| IntervalMatrix & | operator- () |
| This operator takes the unary negation of the matrix. | |
| IntervalMatrix & | transpose () |
| Transpose the this matrix. | |
| double | norm (NORMTYPE n) |
| This method calculates the norm of this matrix. | |
| IntervalMatrix & | diagonalScale (IntervalMatrix &d, bool side=true) |
| This method multiplies a by the diagonal matrix d. | |
| IntervalMatrix & | permute (int p[]) |
| This method moves rows from their original index to the index proveded in p. | |
| bool | encloses (IntervalMatrix &y) |
| Tests to see if the elements of this matrix enclose the elements of y. | |
| bool | interior (IntervalMatrix &y) |
| Tests to see if the elements of y are on the interior of this matrix. | |
| bool | disjoint (IntervalMatrix &y) |
| Tests to see if the elements of y are disjoint to the elements in this matrix. | |
| IntervalMatrix & | operator & (IntervalMatrix &y) |
| This operator calculates the intersection of this matrix and y. | |
| IntervalMatrix & | operator| (IntervalMatrix &y) |
| This operator calculates the union of this matrix and y. | |
| IntervalMatrix & | intervalHull (IntervalMatrix &y) |
| This method calculates the convex interval hull of this matrix and y. | |
| bool | isEmpty () |
| This method returns true if any element is the empty interval. | |
| IntervalMatrix & | lowerBounds () |
| This method returns a matrix containing point intervals of the lower bound of each element. | |
| IntervalMatrix & | upperBounds () |
| This method returns a matrix containing point intervals of the upper bound of each element. | |
| IntervalMatrix & | midpoint () |
| This method returns a matrix containing point intervals of the midpoint of each element. | |
| IntervalMatrix & | widths () |
| This method returns a matrix containing point intervals of the width of each element. | |
| void | lu (IntervalMatrix &lu, int *p) |
| This method calculates the LU decomposition of this matrix based on the elements' midpoint. | |
| IntervalVector & | solveLU (IntervalVector &b, int p[]) |
| This function solves a system of equations using an LU matrix. | |
| IntervalMatrix & | inverse () |
| This function will invert this matrix based on the elements midpoints. | |
| IntervalVector & | toVector (int index, bool row=true) |
| This returns a vector representing a row or column of this matrix. | |
| void | fromVector (IntervalVector &v, int index, bool row=true) |
| This method copies the values of a vector into the given row or column. | |
Static Public Member Functions | |
| static IntervalMatrix | getIdentity (unsigned int rows, unsigned int cols) |
| static void | add (const IntervalMatrix &a, const IntervalMatrix &b, IntervalMatrix &result) |
| This function adds a to b and stores the sum in result. | |
| static void | add (const IntervalMatrix &a, const Interval &scalar, IntervalMatrix &result) |
| This operator adds a scalar value to a matrix, and stores the sum in result. | |
| static void | sub (const IntervalMatrix &a, const IntervalMatrix &b, IntervalMatrix &result) |
| This operator subtracts two matrices and stores the difference in result. | |
| static void | sub (IntervalMatrix &a, const Interval &scalar, IntervalMatrix &result, bool right=true) |
| This method subtracts a scalar value from a, and stores the difference in result. | |
| static void | mult (IntervalMatrix &a, IntervalMatrix &b, IntervalMatrix &result) |
| This method mutliplys a by b, and stores the product in result. | |
| static void | mult (IntervalMatrix &a, const Interval &scalar, IntervalMatrix &result) |
| This method multiplies a matrix by the scalar, and stores the product in result. | |
| static void | mult (IntervalMatrix &a, IntervalVector &v, IntervalVector &result, bool right) |
| This method multiplies a matrix by a vector, storing the product in result. | |
| static void | neg (IntervalMatrix &a, IntervalMatrix &result) |
| This function takes the negation of the matrix. | |
| static void | transpose (IntervalMatrix &a, IntervalMatrix &result) |
| Transpose the matrix a and store the result. | |
| static void | diagonalScale (IntervalMatrix &a, IntervalMatrix &d, IntervalMatrix &result, bool side=true) |
| This function multiplies a by the diagonal matrix d. | |
| static void | diagonalScale (IntervalMatrix &a, IntervalMatrix &b, IntervalMatrix &d, IntervalMatrix &result) |
| This function multiplies b by the diagonal matrix d, and adds the result to a. | |
| static void | diagonalScale2 (IntervalMatrix &a, IntervalMatrix &d1, IntervalMatrix &d2, IntervalMatrix &result) |
| This function efficiently performs two sided diagonal scaling on a matrix. | |
| static void | triangularMult (IntervalMatrix &a, IntervalMatrix &t, IntervalMatrix &result, const Interval &alpha=IntervalMatrix::one, TRIMAT_TYPE tt=LTR_TOP, bool side=false) |
| This function efficently multiplies a matrix against a square triangular matrix of the same dimension. | |
| static void | scaledAccumulation (IntervalMatrix &a, IntervalMatrix &b, IntervalMatrix &result, const Interval &alpha=IntervalMatrix::one, const Interval &beta=IntervalMatrix::one) |
| This function is provided to efficiently calculate the accumulate and scale formula. | |
| static void | accTranspose (IntervalMatrix &a, IntervalMatrix &b, IntervalMatrix &result, const Interval &alpha=IntervalMatrix::one, const Interval &beta=IntervalMatrix::one) |
| This function is provided to efficiently calculate an accumulate and scale formula. | |
| static void | scaledVectorMult (IntervalMatrix &a, IntervalVector &x, IntervalVector &y, IntervalVector &result, const Interval &alpha=IntervalMatrix::one, const Interval &beta=IntervalMatrix::one, bool transpose_a=false) |
| This function performs scaled vector multiplication. | |
| static void | scaledMatrixMult (IntervalMatrix &a, IntervalMatrix &b, IntervalMatrix &c, IntervalMatrix &result, bool a_transpose=false, bool b_transpose=false, const Interval &alpha=IntervalMatrix::one, const Interval &beta=IntervalMatrix::one) |
| This function performs multiple scaled matrix multiplication formulas. | |
| static void | rankOneUpdate (IntervalMatrix &a, IntervalVector &x, IntervalVector &y, IntervalMatrix &result, const Interval &alpha=IntervalMatrix::one, const Interval &beta=IntervalMatrix::one) |
| This function performs a rank one update on matrix a. | |
| static void | permute (IntervalMatrix &a, IntervalMatrix &result, int p[]) |
| This function moves rows from their original index to the index proveded in p. | |
| static void | intervalIntersection (IntervalMatrix &v, IntervalMatrix &y, IntervalMatrix &result) |
| This method calculates the intersection of this matrix v and y and stores the result. | |
| static void | intervalUnion (IntervalMatrix &v, IntervalMatrix &y, IntervalMatrix &result) |
| This operator calculates the union of v and y. | |
| static void | intervalHull (IntervalMatrix &v, IntervalMatrix &y, IntervalMatrix &result) |
| This function calculates the convex interval hull of v and y, and stores the result. | |
| static void | lowerBounds (IntervalMatrix &v, IntervalMatrix &result) |
| This function returns a matrix containing point intervals of the lower bound of each element. | |
| static void | upperBounds (IntervalMatrix &v, IntervalMatrix &result) |
| This function returns a matrix containing point intervals of the upper bound of each element. | |
| static void | midpoint (IntervalMatrix &v, IntervalMatrix &result) |
| This function returns a matrix containing point intervals of the midpoint of each element. | |
| static void | widths (IntervalMatrix &v, IntervalMatrix &result) |
| This function returns a matrix containing point intervals of the width of each element. | |
| static void | lu (IntervalMatrix &a, IntervalMatrix &lu, int *p) |
| static void | solveLU (IntervalVector &b, IntervalMatrix &lu, int p[], IntervalVector &result) |
| This function solves a system of equations using an LU matrix. | |
| static void | inverse (IntervalMatrix &a, IntervalMatrix &result) |
| This function will invert a matrix based on the elements midpoints. | |
| static IntervalMatrix & | getResult (IntervalMatrix *a, IntervalMatrix *b, bool force_new=false) |
| This method returns an intermediary result matrix. | |
| static void | freeResult (IntervalMatrix *a, IntervalMatrix *b, IntervalMatrix &r) |
| This method cleans up intermediary result matrices. | |
| static void | freeResult (IntervalMatrix *a, IntervalMatrix *b=NULL) |
| This method cleans up intermediary result matrices. | |
Static Public Attributes | |
| static const Interval | one |
Protected Member Functions | |
| void | alloc (unsigned int rows, unsigned int cols) |
| This method correctly and efficiently allocates the underlying array. | |
Protected Attributes | |
| Interval ** | a |
| The array that stores the elements. | |
| unsigned int | m_cols |
| The number of columns. | |
| unsigned int | m_rows |
| The number of rows. | |
| bool | ir |
| True if this object is an intermediary result. | |
| Interval *** | a_ptr |
| Work around, ignore it. | |
| Interval * | abase |
Friends | |
| IntervalMatrix | getIdentity (unsigned int rows, unsigned int cols) |
| This function returns an identity matrix of the size rows x cols. | |
| void | swap (IntervalMatrix &a, IntervalMatrix &b) |
| This function efficiently swaps two matrices. | |
| ostream & | operator<< (ostream &out, const IntervalMatrix &mat) |
| This is a convenience operator for outputing the matrix as a string. | |
| istream & | operator>> (istream &in, IntervalMatrix &m) |
This operator reads a matrix from an input stream The matrix must be formated as folows:
| |
| IntervalMatrix & | operator+ (const Interval &scalar, IntervalMatrix &a) |
| IntervalMatrix & | operator- (const Interval &scalar, IntervalMatrix &a) |
| This operator subtracts a scalar value from a. | |
| IntervalMatrix & | operator * (const Interval &scalar, IntervalMatrix &a) |
| This operator multiplies the scalar by matrix a. | |
| IntervalVector & | operator * (IntervalVector &v, IntervalMatrix &a) |
| This operator multiplies this matrix by a vector. | |
| IntervalMatrix & | neg (IntervalMatrix &a) |
| This function takes the negation of the matrix. | |
| IntervalMatrix & | transpose (IntervalMatrix &a) |
| Transpose the matrix a. | |
| double | norm (IntervalMatrix &a, NORMTYPE n) |
| This function calculates the norm of matrix a. | |
| IntervalMatrix & | diagonalScale (IntervalMatrix &a, IntervalMatrix &d, bool side=true) |
| This function multiplies a by the diagonal matrix d. | |
| IntervalMatrix & | diagonalScale (IntervalMatrix &a, IntervalMatrix &b, IntervalMatrix &d) |
| This function multiplies b by the diagonal matrix d, and adds the result to a. | |
| IntervalMatrix & | diagonalScale2 (IntervalMatrix &a, IntervalMatrix &d1, IntervalMatrix &d2) |
| This function efficiently performs two sided diagonal scaling on a matrix. | |
| IntervalMatrix & | triangularMult (IntervalMatrix &a, IntervalMatrix &t, const Interval &alpha=IntervalMatrix::one, TRIMAT_TYPE tt=LTR_TOP, bool side=false) |
| This function efficently multiplies a matrix against a square triangular matrix of the same dimension. | |
| IntervalMatrix & | scaledAccumulation (IntervalMatrix &a, IntervalMatrix &b, const Interval &alpha=IntervalMatrix::one, const Interval &beta=IntervalMatrix::one) |
| This function is provided to efficiently calculate an accumulate and scale formula. | |
| IntervalMatrix & | accTranspose (IntervalMatrix &a, IntervalMatrix &b, const Interval &alpha=IntervalMatrix::one, const Interval &beta=IntervalMatrix::one) |
| This function is provided to efficiently calculate an accumulate and scale formula. | |
| IntervalVector & | scaledVectorMult (IntervalMatrix &a, IntervalVector &x, IntervalVector &y, const Interval &alpha=IntervalMatrix::one, const Interval &beta=IntervalMatrix::one, bool transpose_a=false) |
| This function performs scaled vector multiplication. | |
| IntervalMatrix & | scaledMatrixMult (IntervalMatrix &a, IntervalMatrix &b, IntervalMatrix &c, bool a_transpose=false, bool b_transpose=false, const Interval &alpha=IntervalMatrix::one, const Interval &beta=IntervalMatrix::one) |
| This function performs multiple scaled matrix multiplication formulas. | |
| IntervalMatrix & | rankOneUpdate (IntervalMatrix &a, IntervalVector &x, IntervalVector &y, const Interval &alpha=IntervalMatrix::one, const Interval &beta=IntervalMatrix::one) |
| This function performs a rank one update on matrix a. | |
| IntervalMatrix & | permute (IntervalMatrix &a, int p[]) |
| This function moves rows from their original index to the index proveded in p. | |
| bool | encloses (IntervalMatrix &v, IntervalMatrix &y) |
| Tests to see if the elements of v enclose the elements of y. | |
| bool | interior (IntervalMatrix &v, IntervalMatrix &y) |
| Tests to see if the elements of y are on the interior of v. | |
| bool | disjoint (IntervalMatrix &v, IntervalMatrix &y) |
| Tests to see if the elements of y are disjoint to the elements of v. | |
| IntervalMatrix & | intervalIntersection (IntervalMatrix &v, IntervalMatrix &y) |
| This method calculates the intersection of this matrix v and y. | |
| IntervalMatrix & | intervalUnion (IntervalMatrix &v, IntervalMatrix &y) |
| This operator calculates the union of v and y. | |
| IntervalMatrix & | intervalHull (IntervalMatrix &v, IntervalMatrix &y) |
| This function calculates the convex interval hull of v and y. | |
| bool | isEmpty (IntervalMatrix &v) |
| This method returns true if any element is the empty interval. | |
| IntervalMatrix & | lowerBounds (IntervalMatrix &v) |
| This function returns a matrix containing point intervals of the lower bound of each element. | |
| IntervalMatrix & | upperBounds (IntervalMatrix &v) |
| This function returns a matrix containing point intervals of the upper bound of each element. | |
| IntervalMatrix & | midpoint (IntervalMatrix &v) |
| This function returns a matrix containing point intervals of the midpoint of each element. | |
| IntervalMatrix & | widths (IntervalMatrix &v) |
| This function returns a matrix containing point intervals of the width of each element. | |
| void | lu (IntervalMatrix &a, IntervalMatrix &lu, int *p) |
| This method calculates the LU decomposition of this matrix based on the elements' midpoint. | |
| IntervalVector & | solveLU (IntervalVector &b, IntervalMatrix &lu, int p[]) |
| This function solves a system of equations using an LU matrix. | |
| IntervalMatrix & | inverse (IntervalMatrix &a) |
| This function will invert a matrix based on the elements midpoints. | |
Interval matrices can be treated similarly to a two-dimensional array. They are referenced in row major order, e.g. the interval matrix m's element at the second row third column can be referenced like this, m[2][3]. The matrices are zero indexed which means the first element is at m[0][0].
|
|
This method creates an empty matrix. Empty matrices are only suitable for having other matrices assigned to them. |
|
||||||||||||||||
|
Creates a matrix with the given number of rows and columns. Matrices with rows and columns are called non-empty. All the elements of the matrix are initialized to [0.0,0.0].
|
|
|
Copy construtor, note this is equivelent to assignment.
|
|
||||||||||||||||||||
|
This constructs a matrix from two matrices of type double, creating intervals of l and u. For any given row in the matrices l and u, the resulting element in this matrix will be and interval whose bounds are l and u. The elements of l do not necessarily have to be less than u, the constructor creates proper intervals no matter what.
|
|
||||||||||||||||||||||||
|
This function is provided to efficiently calculate an accumulate and scale formula. This method calculates the formula:
|
|
||||||||||||||||
|
This operator adds a scalar value to a matrix, and stores the sum in result.
|
|
||||||||||||||||
|
This function adds a to b and stores the sum in result. Note this function does not allocate new memory so a, b, and result must all be of the same dimensions.
|
|
||||||||||||
|
This method correctly and efficiently allocates the underlying array.
|
|
||||||||||||||||||||
|
This function multiplies b by the diagonal matrix d, and adds the result to a. This function is faster than using the * operator. This function calculates the following formula:
|
|
||||||||||||||||||||
|
This function multiplies a by the diagonal matrix d. This function is faster than using the * operator.
|
|
||||||||||||
|
This method multiplies a by the diagonal matrix d. This method is faster than using the * operator.
|
|
||||||||||||||||||||
|
This function efficiently performs two sided diagonal scaling on a matrix. This function implments the formula:
|
|
|
Tests to see if the elements of y are disjoint to the elements in this matrix. The comparison is done element wise, i.e. this->a[i][j].disjoint( y[i][j] ).
|
|
|
Tests to see if the elements of this matrix enclose the elements of y. The comparison is done element wise, i.e. this->a[i][j].encloses( y[i][j] ).
|
|
||||||||||||
|
This method cleans up intermediary result matrices. The parameters will be deleted given its ir attribute is true. This method is used when you know the operation required a new intermediary result matrix or the result was not a matrix, for example interior().
|
|
||||||||||||||||
|
This method cleans up intermediary result matrices. This method will delete a and b given that they are not the same memory as result, and their ir attribute is true.
|
|
||||||||||||||||
|
This method copies the values of a vector into the given row or column.
|
|
||||||||||||
|
Returns a reference to the element at row r and column c. This method is identical to IntervalMatrix::operator[](). It exists to make using IntervalMatrix pointers easier.
|
|
|
Returns the number of columns in a matrix.
|
|
|
This method returns an identity matrix of the current size.
|
|
||||||||||||||||
|
This method returns an intermediary result matrix. The matrix that is returned may be a, b, or a new matrix. The method will attempt to recycle a and b if it is possible. This behavior may be undisirable for operations that require a and b to remain unaltered, for example multiplication. The parameters, a and b, are only recycled if their attribute ir is true.
|
|
|
Returns the number of rows in a matrix.
|
|
|
Tests to see if the elements of y are on the interior of this matrix. The comparison is done element wise, i.e. this->a[i][j].interior( y[i][j] ).
|
|
||||||||||||||||
|
This function calculates the convex interval hull of v and y, and stores the result. This is done element wise, i.e. v[i][j].hull( y[i][j] ).
|
|
|
This method calculates the convex interval hull of this matrix and y. This is done element wise, i.e. this->a[i][j].hull( y[i][j] ).
|
|
||||||||||||||||
|
This method calculates the intersection of this matrix v and y and stores the result. This is done element wise, i.e. v[i][j] & y[i][j].
|
|
||||||||||||||||
|
This operator calculates the union of v and y. This is done element wise, i.e. v[i][j] & y[i][j].
|
|
||||||||||||
|
This function will invert a matrix based on the elements midpoints. This function uses midpoint LU decomposition to solve for the inverse. For reasons why to use this function as opposed to inverse(), see the documentation for intervalLU().
|
|
|
This function will invert this matrix based on the elements midpoints. This function uses midpoint LU decomposition to solve for the inverse. For reasons why to use this function as opposed to inverse(), see the documentation for intervalLU().
|
|
|
This method returns true if any element is the empty interval.
|
|
||||||||||||
|
This function returns a matrix containing point intervals of the lower bound of each element.
|
|
|
This method returns a matrix containing point intervals of the lower bound of each element.
|
|
||||||||||||
|
This method calculates the LU decomposition of this matrix based on the elements' midpoint. To aid in avoiding singularity and to speed up computation, only the midpoint of the constituent intervals is used. The LU matrix and an array that represents the P matrix is generated by this function. This function is the first step to solving a system of equations. To get the actual answer call solveLU() next.
|
|
||||||||||||
|
This function returns a matrix containing point intervals of the midpoint of each element.
|
|
|
This method returns a matrix containing point intervals of the midpoint of each element.
|
|
||||||||||||||||||||
|
This method multiplies a matrix by a vector, storing the product in result.
|
|
||||||||||||||||
|
This method multiplies a matrix by the scalar, and stores the product in result.
|
|
||||||||||||||||
|
This method mutliplys a by b, and stores the product in result.
|
|
||||||||||||
|
This function takes the negation of the matrix. This function flips the sign of all the elements in the matrix.
|
|
|
This method calculates the norm of this matrix.
|
|
|
This operator calculates the intersection of this matrix and y. This is done element wise, i.e. this->a[i][j] & y[i][j].
|
|
|
This operator multiplies this matrix by a vector.
|
|
|
This operator multiplies the scalar by this matrix.
|
|
|
This operator multiplies b to this matrix.
|
|
|
This operator adds a scalar value to this matrix.
|
|
|
This operator adds b to this matrix.
|
|
|
This operator takes the unary negation of the matrix. This operator flips the sign of all the elements in the matrix.
|
|
|
This operator subtracts a scalar value from a.
|
|
|
This operator subtracts b from this matrix.
|
|
|
Copies the values of the matrix b into this matrix. This operation can be expensive. This is especially the case if this matrix is not empty or b has a different size.
|
|
|
This operator tests element wise to see if this matrix and b are equivalent.
|
|
|
This operator returns a reference to the row of the matrix.
|
|
|
This operator calculates the union of this matrix and y. This is done element wise, i.e. this->a[i][j] & y[i][j].
|
|
||||||||||||||||
|
This function moves rows from their original index to the index proveded in p. Each element in p contains the new index for the row at that location. For example if p = [2,1,0] it would place a[0] at a[1] and a[1] at a[0]. This means that p must have the same number of elements as a has rows.
|
|
|
This method moves rows from their original index to the index proveded in p. Each element in p contains the new index for the row at that location. For example if p = [2,1,0] it would place a[0] at a[1] and a[1] at a[0]. This means that p must have the same number of elements as this matrix has rows.
|
|
||||||||||||||||||||||||||||
|
This function performs a rank one update on matrix a. This function performs the following formula.
|
|
||||||||||||||||||||||||
|
This function is provided to efficiently calculate the accumulate and scale formula. This method calculates the formula:
|
|
||||||||||||||||||||||||||||||||||||
|
This function performs multiple scaled matrix multiplication formulas. This function calculates:
|
|
||||||||||||||||||||||||||||||||
|
This function performs scaled vector multiplication. As per the standard this function performs the following formula.
|
|
||||||||||||||||
|
Sets the value of the element at row r and column c to i. This method is provided to make using IntervalMatrix pointers easier.
|
|
||||||||||||||||||||
|
This function solves a system of equations using an LU matrix.
This function solves the equation
|
|
||||||||||||
|
This function solves a system of equations using an LU matrix.
This function solves the equation
|
|
||||||||||||||||||||
|
This method subtracts a scalar value from a, and stores the difference in result.
|
|
||||||||||||||||
|
This operator subtracts two matrices and stores the difference in result.
|
|
||||||||||||
|
This returns a vector representing a row or column of this matrix.
|
|
||||||||||||
|
Transpose the matrix a and store the result.
|
|
|
Transpose the this matrix.
|
|
||||||||||||||||||||||||||||
|
This function efficently multiplies a matrix against a square triangular matrix of the same dimension. This function performs the following calculations:
|
|
||||||||||||
|
This function returns a matrix containing point intervals of the upper bound of each element.
|
|
|
This method returns a matrix containing point intervals of the upper bound of each element.
|
|
||||||||||||
|
This function returns a matrix containing point intervals of the width of each element.
|
|
|
This method returns a matrix containing point intervals of the width of each element.
|
|
||||||||||||||||||||
|
This function is provided to efficiently calculate an accumulate and scale formula. This method calculates the formula:
|
|
||||||||||||||||
|
This function multiplies b by the diagonal matrix d, and adds the result to a. This function is faster than using the * operator. This function calculates the following formula:
|
|
||||||||||||||||
|
This function multiplies a by the diagonal matrix d. This function is faster than using the * operator.
|
|
||||||||||||||||
|
This function efficiently performs two sided diagonal scaling on a matrix. This function implments the formula:
|
|
||||||||||||
|
Tests to see if the elements of y are disjoint to the elements of v. The comparison is done element wise, i.e. v[i][j].disjoint( y[i][j] ).
|
|
||||||||||||
|
Tests to see if the elements of v enclose the elements of y. The comparison is done element wise, i.e. v[i][j].encloses( y[i][j] ).
|
|
||||||||||||
|
This function returns an identity matrix of the size rows x cols.
|
|
||||||||||||
|
Tests to see if the elements of y are on the interior of v. The comparison is done element wise, i.e. v[i][j].interior( y[i][j] ).
|
|
||||||||||||
|
This function calculates the convex interval hull of v and y. This is done element wise, i.e. v[i][j].hull( y[i][j] ).
|
|
||||||||||||
|
This method calculates the intersection of this matrix v and y. This is done element wise, i.e. v[i][j] & y[i][j].
|
|
||||||||||||
|
This operator calculates the union of v and y. This is done element wise, i.e. v[i][j] & y[i][j].
|
|
|
This function will invert a matrix based on the elements midpoints. This function uses midpoint LU decomposition to solve for the inverse. For reasons why to use this function as opposed to inverse(), see the documentation for intervalLU().
|
|
|
This method returns true if any element is the empty interval.
|
|
|
This function returns a matrix containing point intervals of the lower bound of each element.
|
|
||||||||||||||||
|
This method calculates the LU decomposition of this matrix based on the elements' midpoint. To aid in avoiding singularity and to speed up computation, only the midpoint of the constituent intervals is used. The LU matrix and an array that represents the P matrix is generated by this function. This function is the first step to solving a system of equations. To get the actual answer call solveLU() next.
|
|
|
This function returns a matrix containing point intervals of the midpoint of each element.
|
|
|
This function takes the negation of the matrix. This function flips the sign of all the elements in the matrix.
|
|
||||||||||||
|
This function calculates the norm of matrix a.
|
|
||||||||||||
|
This operator multiplies this matrix by a vector.
|
|
||||||||||||
|
This operator multiplies the scalar by matrix a.
|
|
||||||||||||
|
This operator subtracts a scalar value from a.
|
|
||||||||||||
|
This is a convenience operator for outputing the matrix as a string. The format used to output the matris is as follows.
|
|
||||||||||||
|
This operator reads a matrix from an input stream The matrix must be formated as folows:
|
|
||||||||||||
|
This function moves rows from their original index to the index proveded in p. Each element in p contains the new index for the row at that location. For example if p = [2,1,0] it would place a[0] at a[1] and a[1] at a[0]. This means that p must have the same number of elements as a has rows.
|
|
||||||||||||||||||||||||
|
This function performs a rank one update on matrix a. This function performs the following formula.
|
|
||||||||||||||||||||
|
This function is provided to efficiently calculate an accumulate and scale formula. This function calculates the formula:
|
|
||||||||||||||||||||||||||||||||
|
This function performs multiple scaled matrix multiplication formulas. This function efficently calculates:
|
|
||||||||||||||||||||||||||||
|
This function performs scaled vector multiplication. As per the standard this function performs the following formula.
|
|
||||||||||||||||
|
This function solves a system of equations using an LU matrix.
This function solves the equation
|
|
||||||||||||
|
This function efficiently swaps two matrices. This method uses reassignes pointers, hence it runs in constant time.
|
|
|
Transpose the matrix a.
|
|
||||||||||||||||||||||||
|
This function efficently multiplies a matrix against a square triangular matrix of the same dimension. This function performs the following calculations:
|
|
|
This function returns a matrix containing point intervals of the upper bound of each element.
|
|
|
This function returns a matrix containing point intervals of the width of each element.
|
|
|
The array that stores the elements.
|
|
|
Work around, ignore it.
|
|
|
True if this object is an intermediary result.
|
|
|
The number of columns.
|
|
|
The number of rows.
|
1.4.4