mirror of https://github.com/CGAL/cgal
166 lines
5.4 KiB
TeX
166 lines
5.4 KiB
TeX
\begin{ccRefConcept}{Matrix}\ccCreationVariable{M}
|
|
|
|
\ccDefinition
|
|
|
|
An instance of data type \ccc{Matrix} is a matrix of
|
|
variables of number type \ccc{NT}. The types \ccc{Matrix} and \ccc{Vector}
|
|
together realize many functions of basic linear algebra.
|
|
|
|
\ccSetOneOfTwoColumns{4cm}
|
|
|
|
\ccTypes
|
|
|
|
\ccNestedType{NT}{the ring type of the components. }
|
|
|
|
\ccNestedType{iterator}{bidirectional iterator for accessing
|
|
all components row-wise.}
|
|
|
|
\ccNestedType{row_iterator}{random access iterator for accessing row
|
|
entries.}
|
|
|
|
\ccNestedType{column_iterator}{random access iterator for accessing
|
|
column entries.}
|
|
|
|
There also constant versions of the above iterators:
|
|
\ccc{const_iterator}, \ccc{row_const_iterator}, and
|
|
\ccc{column_const_iterator}.
|
|
|
|
|
|
|
|
\ccNestedType{Identity}{a tag class for identity initialization }
|
|
|
|
\ccNestedType{Vector}{the vector type used. }
|
|
|
|
\ccSetOneOfTwoColumns{5cm}
|
|
|
|
\ccCreation
|
|
|
|
\ccConstructor{Matrix()}{creates an instance \ccc{M} of type
|
|
\ccc{Matrix}. }
|
|
|
|
\ccConstructor{Matrix(int n)}{creates an instance \ccc{M} of type
|
|
\ccc{Matrix} of dimension $n \times n$ initialized to the zero matrix.
|
|
}
|
|
|
|
\ccConstructor{Matrix(int m, int n)}{creates an instance \ccc{M} of
|
|
type \ccc{Matrix} of dimension $m \times n$ initialized to the zero
|
|
matrix. }
|
|
|
|
\ccConstructor{Matrix(std::pair<int,int> p)}{creates an instance
|
|
\ccc{M} of type \ccc{Matrix} of dimension
|
|
\ccc{p.first}$\times$\ccc{p.second} initialized to the zero matrix. }
|
|
|
|
\ccConstructor{Matrix(int n, Identity, NT x = NT(1))}{creates an
|
|
instance \ccc{M} of type \ccc{Matrix} of dimension $n \times n$
|
|
initialized to the identity matrix (times \ccc{x}). }
|
|
|
|
\ccConstructor{Matrix(int m, int n, NT x)}{creates an instance \ccc{M}
|
|
of type \ccc{Matrix} of dimension $m \times n$ initialized to the
|
|
matrix with \ccc{x} entries. }
|
|
|
|
\ccConstructor{template <class Forward_iterator>
|
|
Matrix(Forward_iterator first, Forward_iterator last)}{creates an
|
|
instance \ccc{M} of type \ccc{Matrix}. Let $S$ be the ordered set of
|
|
$n$ column-vectors of common dimension $m$ as given by the iterator
|
|
range \ccc{[first,last)}. \ccc{M} is initialized to an $m \times n$
|
|
matrix with the columns as specified by $S$. \ccPrecond
|
|
\ccc{Forward_iterator} has a value type \ccc{V} from which we require
|
|
to provide a iterator type \ccc{V::const_iterator}, to have
|
|
\ccc{V::value_type == NT}.\\ Note that \ccc{Vector} or
|
|
\ccc{std::vector<NT>} fulfill these requirements. }
|
|
|
|
\ccConstructor{Matrix(std::vector< Vector > A)}{creates an instance
|
|
\ccc{M} of type \ccc{Matrix}. Let $A$ be an array of $n$
|
|
column-vectors of common dimension $m$. \ccc{M} is initialized to an
|
|
$m \times n$ matrix with the columns as specified by $A$. }
|
|
|
|
\ccSetTwoOfThreeColumns{2.5cm}{4cm}
|
|
|
|
\ccOperations
|
|
|
|
\ccMethod{int row_dimension() ;}{returns $n$, the number of rows of
|
|
\ccc{M}. }
|
|
|
|
\ccMethod{int column_dimension() ;}{returns $m$, the number of columns
|
|
of \ccc{M}. }
|
|
|
|
\ccMethod{std::pair<int,int> dimension() ;}{returns $(m,n)$, the
|
|
dimension pair of \ccc{M}. }
|
|
|
|
\ccMethod{Vector row(int i) ;}{returns the $i$-th row of \ccc{M} (an
|
|
$m$ - vector). \ccPrecond $0 \le i \le m - 1$. }
|
|
|
|
\ccMethod{Vector column(int i) ;}{returns the $i$-th column of \ccc{M}
|
|
(an $n$ - vector). \ccPrecond $0 \le i \le n - 1$. }
|
|
|
|
\ccMethod{NT& operator()(int i, int j) ;}{returns $M_{i,j}$.
|
|
\ccPrecond $0\le i\le m-1$ and $0\le j\le n-1$.}
|
|
|
|
\ccMethod{void swap_rows(int i, int j) ;}{swaps rows $i$ and $j$.
|
|
\ccPrecond $0\le i\le m-1$ and $0\le j\le m-1$.
|
|
}
|
|
|
|
\ccMethod{void swap_columns(int i, int j) ;}{swaps columns $i$ and
|
|
$j$. \ccPrecond $0\le i\le n-1$ and $0\le j\le n-1$. }
|
|
|
|
\ccMethod{row_iterator row_begin(int i) ;}{an iterator pointing to the
|
|
first entry of the $i$th row. \ccPrecond $0\le i\le m-1$. }
|
|
|
|
\ccMethod{row_iterator row_end(int i) ;}{an iterator pointing beyond
|
|
the last entry of the $i$th row. \ccPrecond $0\le i\le m-1$. }
|
|
|
|
\ccMethod{column_iterator column_begin(int i) ;}{an iterator pointing
|
|
to the first entry of the $i$th column. \ccPrecond $0\le i\le n-1$.
|
|
}
|
|
|
|
\ccMethod{column_iterator column_end(int i) ;}{an iterator pointing
|
|
beyond the last entry of the $i$th column. \ccPrecond $0\le i\le
|
|
n-1$.}
|
|
|
|
\ccMethod{iterator begin();}{an iterator pointing to the first entry
|
|
of $M$.}
|
|
|
|
\ccMethod{terator end();}{an iterator pointing beyond the last entry
|
|
of $M$.}
|
|
|
|
The same operations exist for \ccc{row_const_iterator},
|
|
\ccc{column_const_iterator} and \ccc{const_iterator}.
|
|
|
|
|
|
\ccMethod{bool operator==(const Matrix& M1) ;}{Test for equality. }
|
|
|
|
\ccMethod{bool operator!=(const Matrix& M1) ;}{Test for inequality. }
|
|
|
|
\ccHeading{Arithmetic Operators}
|
|
|
|
\ccSetTwoOfThreeColumns{1.2cm}{2.5cm}
|
|
|
|
\newcommand{\dimeq}{\\ \ccc{M.row_dimension() == M1.row_dimension()} and\\
|
|
\ccc{M.column_dimension() == M1.column_dimension()}}
|
|
|
|
|
|
\ccMethod{Matrix operator+ (const Matrix& M1);}{ Addition. \ccPrecond
|
|
\dimeq.}
|
|
|
|
\ccMethod{Matrix operator- (const Matrix& M1);}{
|
|
Subtraction. \ccPrecond \dimeq.}
|
|
|
|
\ccMethod{Matrix operator-();}{Negation.}
|
|
|
|
\ccMethod{Matrix operator*(const Matrix& M1)
|
|
;}{Multiplication. \ccPrecond \\ \ccc{M.column_dimension() =
|
|
M1.row_dimension()}. }
|
|
|
|
\ccMethod{Vector operator*(const Vector& vec) ;}{Multiplication with
|
|
vector. \ccPrecond \\ \ccc{M.column_dimension() = vec.dimension()}. }
|
|
|
|
\ccFunction{Matrix operator*(const NT& x, const Matrix& M)
|
|
;}{Multiplication of every entry with \ccc{x}. }
|
|
|
|
\ccFunction{Matrix operator*(const Matrix& M, const NT& x)
|
|
;}{Multiplication of every entry with \ccc{x}. }
|
|
|
|
\end{ccRefConcept}
|
|
|
|
|