/*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvAdd
 //    Purpose:    Adds one array to another
 //    Context:
 //    Parameters:
 //      srcA - first source array
 //      srcB - second source array
 //      dst  - destination array: dst = srcA + srcB
 //      mask - optional mask
 //    Returns:
 //F*/
 OPENCVAPI  void  cvAdd( const CvArr* srcA, const CvArr* srcB, CvArr* dst,
                         const CvArr* mask CV_DEFAULT(0));

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvAddS
 //    Purpose:    Adds array to scalar
 //    Context:
 //    Parameters:
 //      src  - source array
 //      value - added scalar
 //      dst  - destination array: dst = src + value
 //      mask - optional mask
 //    Returns:
 //F*/
 OPENCVAPI  void  cvAddS( const CvArr* src, CvScalar value, CvArr* dst,
                          const CvArr* mask CV_DEFAULT(0));

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvSub
 //    Purpose:    Subtracts one array from another
 //    Context:
 //    Parameters:
 //      srcA - first source array
 //      srcB - second source array 
 //      dst  - destination array: dst = srcA - srcB
 //    Returns:
 //F*/
 OPENCVAPI  void  cvSub( const CvArr* srcA, const CvArr* srcB, CvArr* dst,
                         const CvArr* mask CV_DEFAULT(0));

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvSubS
 //    Purpose:    Subtracts a scalar value from array
 //    Context:
 //    Parameters:
 //      src - source array
 //      value - subtracted scalar
 //      dst  - destination array: dst = src - value
 //      mask - optional mask
 //    Returns:
 //F*/
 CV_INLINE  void  cvSubS( const CvArr* src, CvScalar value, CvArr* dst,
                          const CvArr* mask CV_DEFAULT(0));
 CV_INLINE  void  cvSubS( const CvArr* src, CvScalar value, CvArr* dst,
                          const CvArr* mask )
 {
     cvAddS( src, cvScalar( -value.val[0], -value.val[1], -value.val[2], -value.val[3]),
             dst, mask );
 }

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvSubRS
 //    Purpose:    Subtracts a scalar value from array
 //    Context:
 //    Parameters:
 //      src - source array
 //      value - scalar to subtract from
 //      dst  - destination array: dst = value - src
 //      mask - optional mask
 //    Returns:
 //F*/
 OPENCVAPI  void  cvSubRS( const CvArr* src, CvScalar value, CvArr* dst,
                           const CvArr* mask CV_DEFAULT(0));

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvMul
 //    Purpose:    Multiplies two arrays
 //    Context:
 //    Parameters:
 //      src1 - first source array
 //      src2 - second source array
 //      dst  - destination array: dst(x,y) = srcA(x,y) * srcB(x,y)
 //      scale- scale factor
 //    Returns:
 //F*/
 OPENCVAPI  void  cvMul( const CvArr* srcA, const CvArr* srcB, CvArr* dst, double scale);

 /* dst(idx) = lower(idx) <= src(idx) < upper(idx) */
 OPENCVAPI void cvInRange( const CvArr* src, const CvArr* lower,
                           const CvArr* upper, CvArr* dst );

 /* dst(idx) = lower <= src(idx) < upper */
 OPENCVAPI void cvInRangeS( const CvArr* src, CvScalar lower,
                            CvScalar upper, CvArr* dst );

 /* dst(idx) = src1(idx) & src2(idx) */
 OPENCVAPI void cvAnd( const CvArr* src1, const CvArr* src2,
                       CvArr* dst, const CvArr* mask CV_DEFAULT(0));

 /* dst(idx) = src(idx) & value */
 OPENCVAPI void cvAndS( const CvArr* src, CvScalar value,
                        CvArr* dst, const CvArr* mask CV_DEFAULT(0));

 /* dst(idx) = src1(idx) | src2(idx) */
 OPENCVAPI void cvOr( const CvArr* src1, const CvArr* src2,
                      CvArr* dst, const CvArr* mask CV_DEFAULT(0));

 /* dst(idx) = src(idx) | value */
 OPENCVAPI void cvOrS( const CvArr* src, CvScalar value,
                       CvArr* dst, const CvArr* mask CV_DEFAULT(0));

 /* dst(idx) = src1(idx) ^ src2(idx) */
 OPENCVAPI void cvXor( const CvArr* src1, const CvArr* src2,
                       CvArr* dst, const CvArr* mask CV_DEFAULT(0));

 /* dst(idx) = src(idx) ^ value */
 OPENCVAPI void cvXorS( const CvArr* src, CvScalar value,
                        CvArr* dst, const CvArr* mask CV_DEFAULT(0));

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvScaleAdd
 //    Purpose:    Multiplies all array elements by a scalar value and
 //                adds another scalar to the scaled array
 //    Context:
 //    Parameters:
 //      src - source array
 //      scale - scale factor
 //      delta - shift value
 //      dst - destination array
 //    Returns:
 //    Notes:
 //F*/
 OPENCVAPI  void  cvScaleAdd( const CvArr* src1, CvScalar scale,
                              const CvArr* src2, CvArr* dst );

 #define cvMulAddS cvScaleAdd

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvDotProduct
 //    Purpose:    Evaluates dot product of two vectors
 //    Context:
 //    Parameters:
 //      srcA - first source array
 //      srcB - second source array
 //
 //    Returns:
 //      Dot product of srcA and srcB:  sum(srcA(i,j)*srcB(i,j))
 //                                     i,j
 //F*/
 OPENCVAPI  double  cvDotProduct( const CvArr* srcA, const CvArr* srcB );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvCrossProduct
 //    Purpose:    Evaluates cross product of two 3d vectors
 //    Context:
 //    Parameters: srcA - first source vector
 //                srcB - second source vector
 //                dst  - destination vector
 //    Returns:
 //
 //F*/
 OPENCVAPI  void  cvCrossProduct( const CvArr* srcA, const CvArr* srcB, CvArr* dst );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvMatMulAdd
 //    Purpose:    Evaluates product of two matrices and
 //                adds the third matrix to the product
 //    Context:
 //    Parameters:
 //      srcA - first source matrix
 //      srcB - second source matrix
 //      srcC - added matrix
 //      dst  - destination matrix
 //    Returns:
 //
 //F*/
 OPENCVAPI  void  cvMatMulAdd( const CvArr* srcA, const CvArr* srcB,
                               const CvArr* srcC, CvArr* dst );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvMatMulAddS
 //    Purpose:    Performs matrix transformation for every vector of the source array
 //    Context:
 //    Parameters:
 //      srcr - source array
 //      dst  - destination array
 //      transform - transformation matrix
 //      shiftvec - optional shift (may be encoded in the matrix as well)
 //    Returns:
 //
 //F*/
 OPENCVAPI  void  cvMatMulAddS( const CvArr* src, CvArr* dst,
                                const CvArr* transform,
                                const CvArr* shiftvec CV_DEFAULT(0));

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvMulTransposed
 //    Purpose:    Evaluates product of matix by itself transposed
 //    Context:
 //    Parameters:
 //      srcarr - the source matrix
 //      dstarr - the destination matrix
 //      order - determines the order of multiplication
 //              if order = 0, function evaluates A*At
 //              if order = 1, function evaluates At*A
 //    Returns:
 //    Notes:
 //F*/
 OPENCVAPI void cvMulTransposed( const CvArr* srcarr,
                                 CvArr* dstarr, int order );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvTranspose
 //    Purpose:    Transposes matrix
 //    Context:
 //    Parameters:
 //      src - source matrix
 //      dst - destination matrix
 //    Returns:
 //    Notes:
 //      square matrices can be transposed in-place.
 //F*/
 OPENCVAPI  void  cvTranspose( const CvArr* src, CvArr* dst );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvFlip
 //    Purpose:    Mirrors the matrix around vertical or horizontal axis
 //    Context:
 //    Parameters:
 //      src - source matrix
 //      dst - destination matrix
 //      flipAxis - 0: horizontal axis
 //                 1: vertical axis
 //                -1: both axis
 //    Returns:
 //    Notes:
 //F*/
 OPENCVAPI  void  cvFlip( const CvArr* src, CvArr* dst, int flip_mode );

 #define cvMirror cvFlip

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvInvert
 //    Purpose:    Inverts Matrix using LU decomposition
 //    Context:
 //    Parameters:
 //      src - source matrix
 //      dst - destination matrix
 //    Returns:
 //      1 if the matrix inverted and 0 if it is a singular (or very close to it)
 //    Notes:
 //F*/
 OPENCVAPI  int  cvInvert( const CvArr* src, CvArr* dst );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvSolve
 //    Purpose:    Solves linear system Ax = b using LU decomposition
 //    Context:
 //    Parameters:
 //      A - the matrix
 //      b - the "right side" of the system
 //      x - destination array (solution of the system)
 //    Returns:
 //      1 if the system is solved and 0 if the matrix is a singular (or very close to it)
 //    Notes:
 //F*/
 OPENCVAPI  int  cvSolve( const CvArr* A, const CvArr* b, CvArr* x );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvDet
 //    Purpose:    Calculates determinant of the matrix
 //    Context:
 //    Parameters:
 //      mat - source matrix
 //    Returns:
 //      Matrix determinant
 //    Notes:
 //F*/
 OPENCVAPI  double cvDet( const CvArr* mat );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvTrace
 //    Purpose:    Calculates trace of the matrix (sum of elements on the main diagonal) 
 //    Context:
 //    Parameters:
 //      mat - source matrix
 //    Returns:
 //      Matrix determinant
 //    Notes:
 //F*/
 OPENCVAPI  CvScalar cvTrace( const CvArr* mat );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvSVD
 //    Purpose:    Calculates Singular Value Decomposition for the input matrix: 
 //       A = U W V',   U & V are orthogonal, W is diagonal matrix that can be
 //                     either real matrix (the same size as A) or a vector of
 //                     size min(A->rows,A->cols).
 //       U & V are optional,
 //       flags:  0th bit, reset to 0, means that A is copyied before processing,
 //                        otherwise it is modified during the processing, which is
 //                        faster.
 //               1st bit, reset to 0, means that U is returned normal, otherwise it
 //                        is returned transposed, which is faster.
 //               2nd bit, reset to 0, means that V is returned normal, otherwise it
 //                        is returned transposed, which is faster.
 //F*/
 OPENCVAPI  void   cvSVD( CvArr* A, CvArr* W CV_DEFAULT(0),
                          CvArr* U CV_DEFAULT(0),
                          CvArr* V CV_DEFAULT(0),
                          int flag CV_DEFAULT(0));

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvPseudoInv
 //    Purpose:    Calculates inverse or pseudo-inverse matrix for the input matrix.
 //       if A is (m x n) matrix, B will be (n x m) matrix, such that
 //       AB = I(m x m), BA = I(n x n).
 //
 //    Return value:
 //       The function returns condition number or DBL_MAX if the matrix is signular.
 //F*/
 OPENCVAPI  double  cvPseudoInverse( CvArr* A, CvArr* B);

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvEigenVV
 //    Purpose:    Finds eigenvalues & eigenvectors of a symmetric matrix:
 //    Context:
 //    Parameters:
 //      src - source symmetric matrix,
 //      evects - matrix of its eigenvectors
 //               (i-th row is an i-th eigenvector),
 //      evals - vector of its eigenvalues
 //              (i-th element is an i-th eigenvalue),
 //      eps - accuracy of diagonalization.
 //    Returns:
 //    Notes:
 //F*/
 OPENCVAPI  void  cvEigenVV( CvArr* src, CvArr* evects, CvArr* evals, double eps );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvSetZero
 //    Purpose:    Clears all the matrix elements (sets them to 0)
 //    Context:
 //    Parameters: mat  - matrix
 //    Returns:
 //    Notes:
 //F*/
 OPENCVAPI  void  cvSetZero( CvArr* mat );

 #define cvZero  cvSetZero

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvSetIdentity
 //    Purpose:    Fills identity matrix
 //    Context:
 //    Parameters:
 //      mat - matrix
 //    Returns:
 //    Notes:
 //F*/
 OPENCVAPI  void  cvSetIdentity( CvArr* mat );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvMahalanobis
 //    Purpose:    Calculates Mahalanobis(weighted) distance.
 //    Context:
 //    Parameters:
 //      srcA - first source vector
 //      srcB - second source vector
 //      matr - covariance matrix
 //    Returns:
 //      Mahalanobis distance
 //    Notes:
 //F*/
 OPENCVAPI  double  cvMahalanobis( const CvArr* srcA, const CvArr* srcB, CvArr* mat );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:       cvPerspectiveTransform
 //    Purpose:    Applies perspective transform to the array of vectors
 //    Context:
 //    Parameters: mat - matrix
 //                src - source array
 //                dst - destination array
 //    Returns:
 //    Notes:
 //F*/
 OPENCVAPI  void  cvPerspectiveTransform( const CvArr* src, CvArr* dst, const CvArr* mat );