| /* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */ | |
| /* ==================================================================== | |
| * Copyright (c) 1997-2000 Carnegie Mellon University. All rights | |
| * reserved. | |
| * | |
| * Redistribution and use in source and binary forms, with or without | |
| * modification, are permitted provided that the following conditions | |
| * are met: | |
| * | |
| * 1. Redistributions of source code must retain the above copyright | |
| * notice, this list of conditions and the following disclaimer. | |
| * | |
| * 2. Redistributions in binary form must reproduce the above copyright | |
| * notice, this list of conditions and the following disclaimer in | |
| * the documentation and/or other materials provided with the | |
| * distribution. | |
| * | |
| * This work was supported in part by funding from the Defense Advanced | |
| * Research Projects Agency and the National Science Foundation of the | |
| * United States of America, and the CMU Sphinx Speech Consortium. | |
| * | |
| * THIS SOFTWARE IS PROVIDED BY CARNEGIE MELLON UNIVERSITY ``AS IS'' AND | |
| * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, | |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY | |
| * NOR ITS EMPLOYEES BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| * | |
| * ==================================================================== | |
| * | |
| */ | |
| /********************************************************************* | |
| * | |
| * File: matrix.h | |
| * | |
| * Description: Matrix and linear algebra functions | |
| * | |
| * Author: | |
| * | |
| *********************************************************************/ | |
| /** \file matrix.h | |
| * \brief Matrix and linear algebra functions. | |
| * | |
| * This file contains some basic matrix and linear algebra operations. | |
| * In general these operate on positive definite matrices ONLY, | |
| * because all matrices we're likely to encounter are either | |
| * covariance matrices or are derived from them, and therefore a | |
| * non-positive-definite matrix indicates some kind of pathological | |
| * condition. | |
| */ | |
| extern "C" { | |
| /* Fool Emacs. */ | |
| } | |
| /** | |
| * Norm an array | |
| * @param arr array | |
| * @param d1 dimension | |
| * @param d2 dimension | |
| * @param d3 dimension | |
| **/ | |
| void norm_3d(float32 ***arr, uint32 d1, uint32 d2, uint32 d3); | |
| /** | |
| * Floor 3-d array | |
| * @param out output array | |
| * @param in input array | |
| * @param d1 dimension | |
| * @param d2 dimension | |
| * @param d3 dimension | |
| **/ | |
| void accum_3d(float32 ***out, float32 ***in, uint32 d1, uint32 d2, uint32 d3); | |
| /** Ensures that non-zero values x such that -band < x < band, band > 0 are set to -band if x < 0 and band if x > 0. | |
| * @param v array | |
| * @param d1 array size | |
| * @param band band value | |
| */ | |
| void band_nz_1d(float32 *v, uint32 d1, float32 band); | |
| /** | |
| * Floor 3-d array | |
| * @param m array | |
| * @param d1 dimension | |
| * @param d2 dimension | |
| * @param d3 dimension | |
| * @param floor floor value | |
| **/ | |
| void floor_nz_3d(float32 ***m, uint32 d1, uint32 d2, uint32 d3, float32 floor); | |
| /** | |
| * Floor 1-d array | |
| * @param v array | |
| * @param d1 dimension | |
| * @param floor floor value | |
| **/ | |
| void floor_nz_1d(float32 *v, uint32 d1, float32 floor); | |
| /** | |
| * Calculate the determinant of a positive definite matrix. | |
| * @param a The input matrix, must be positive definite. | |
| * @param len The dimension of the input matrix. | |
| * @return The determinant of the input matrix, or -1.0 if the matrix is | |
| * not positive definite. | |
| * | |
| * \note These can be vanishingly small hence the float64 return type. | |
| * Also note that only the upper triangular portion of a is | |
| * considered, therefore the check for positive-definiteness is not | |
| * reliable. | |
| **/ | |
| float64 determinant(float32 **a, int32 len); | |
| /** | |
| * Invert (if possible) a positive definite matrix with QR | |
| * algorithm. | |
| * | |
| * @param out_ainv The inverse of a will be stored here. | |
| * @param a The input matrix, must be positive definite. | |
| * @param len The dimension of the input matrix. | |
| * @return 0 for success or -1 for a non-positive-definite matrix. | |
| * | |
| * \note Only the upper triangular portion of a is considered, | |
| * therefore the check for positive-definiteness is not reliable. | |
| * | |
| * \note The inversion can be done in-place, so you can use the same matrix | |
| * if you do not need to keep a. | |
| **/ | |
| int32 invert(float32 **out_ainv, float32 **a, int32 len); | |
| /** | |
| * Solve (if possible) a positive-definite system of linear equations AX=B for X. | |
| * @param a The A matrix on the left-hand side of the equation, must be positive-definite. | |
| * @param b The B vector on the right-hand side of the equation. | |
| * @param out_x The X vector will be stored here. | |
| * @param n The dimension of the A matrix (n by n) and the B and X vectors. | |
| * @return 0 for success or -1 for a non-positive-definite matrix. | |
| * | |
| * \note Only the upper triangular portion of a is considered, | |
| * therefore the check for positive-definiteness is not reliable. | |
| **/ | |
| int32 solve(float32 **a, float32 *b, | |
| float32 *out_x, int32 n); | |
| /** | |
| * Calculate the outer product of two vectors. | |
| * @param out_a A (pre-allocated) len x len array. The outer product | |
| * will be stored here. | |
| * @param x A vector of length len. | |
| * @param y A vector of length len. | |
| * @param len The length of the input vectors. | |
| **/ | |
| void outerproduct(float32 **out_a, float32 *x, float32 *y, int32 len); | |
| /** | |
| * Multiply C=AB where A and B are symmetric matrices. | |
| * @param out_c The output matrix C. | |
| * @param a The input matrix A. | |
| * @param b The input matrix B. | |
| * @param n Dimensionality of A and B. | |
| **/ | |
| void matrixmultiply(float32 **out_c, /* = */ | |
| float32 **a, /* * */ float32 **b, | |
| int32 n); | |
| /** | |
| * Multiply a symmetric matrix by a constant in-place. | |
| * @param inout_a The matrix to multiply. | |
| * @param x The constant to multiply it by. | |
| * @param n dimension of a. | |
| **/ | |
| void scalarmultiply(float32 **inout_a, float32 x, int32 n); | |
| /** | |
| * Add A += B. | |
| * @param inout_a The A matrix to add. | |
| * @param b The B matrix to add to A. | |
| * @param n dimension of a and b. | |
| **/ | |
| void matrixadd(float32 **inout_a, float32 **b, int32 n); | |
| { /* Fool indent. */ | |
| } | |