matrix_math.h

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#ifndef MATRIX_MATH_H 
#define MATRIX_MATH_H 


#include <jwsc/config.h>

#include <stdlib.h>
#include <inttypes.h>

#include "jwsc/base/error.h"
#include "jwsc/math/complex.h"
#include "jwsc/vector/vector.h"
#include "jwsc/matrix/matrix.h"


#ifdef __cplusplus
namespace jwsc {
extern "C" {
#endif


void add_scalar_to_matrix_f(Matrix_f** m_out, const Matrix_f* m_in, float a);

void add_scalar_to_matrix_d(Matrix_d** m_out, const Matrix_d* m_in, double a);

void add_scalar_to_matrix_cf
(
    Matrix_cf**      m_out, 
    const Matrix_cf* m_in, 
    Complex_f        z
);

void add_scalar_to_matrix_cd
(
    Matrix_cd**      m_out, 
    const Matrix_cd* m_in, 
    Complex_d        z
);

void multiply_matrix_by_scalar_f
(
    Matrix_f**      m_out, 
    const Matrix_f* m_in, 
    float           a
);

void multiply_matrix_by_scalar_d
(
    Matrix_d**      m_out, 
    const Matrix_d* m_in, 
    double          a
);

void multiply_matrix_by_scalar_cf
(
    Matrix_cf**      m_out, 
    const Matrix_cf* m_in, 
    Complex_f        z
);

void multiply_matrix_by_scalar_cd
(
    Matrix_cd**      m_out, 
    const Matrix_cd* m_in, 
    Complex_d        z
);

Error* multiply_matrices_f
(
    Matrix_f**      m_out, 
    const Matrix_f* m_1, 
    const Matrix_f* m_2
);

Error* multiply_matrices_d
(
    Matrix_d**      m_out, 
    const Matrix_d* m_1, 
    const Matrix_d* m_2
);

Error* multiply_matrices_cf
(
    Matrix_cf**      m_out, 
    const Matrix_cf* m_1, 
    const Matrix_cf* m_2
);

Error* multiply_matrices_cd
(
    Matrix_cd**      m_out, 
    const Matrix_cd* m_1, 
    const Matrix_cd* m_2
);

Error* multiply_matrices_elt_wise_f
(
    Matrix_f**      m_out, 
    const Matrix_f* m_1, 
    const Matrix_f* m_2
);

Error* multiply_matrices_elt_wise_d
(
    Matrix_d**      m_out, 
    const Matrix_d* m_1, 
    const Matrix_d* m_2
);

Error* multiply_matrices_elt_wise_cf
(
    Matrix_cf**      m_out, 
    const Matrix_cf* m_1, 
    const Matrix_cf* m_2
);

Error* multiply_matrices_elt_wise_cd
(
    Matrix_cd**      m_out, 
    const Matrix_cd* m_1, 
    const Matrix_cd* m_2
);

void transpose_matrix_f(Matrix_f** m_out, const Matrix_f* m_in);

void transpose_matrix_d(Matrix_d** m_out, const Matrix_d* m_in);

void transpose_matrix_cf(Matrix_cf** m_out, const Matrix_cf* m_in);

void transpose_matrix_cd(Matrix_cd** m_out, const Matrix_cd* m_in);

Error* multiply_matrix_and_vector_f
(
    Vector_f**      v_out, 
    const Matrix_f* m_in, 
    const Vector_f* v_in
);

Error* multiply_matrix_and_vector_d
(
    Vector_d**      v_out, 
    const Matrix_d* m_in, 
    const Vector_d* v_in
);

Error* multiply_matrix_and_vector_cf
(
    Vector_cf**      v_out, 
    const Matrix_cf* m_in, 
    const Vector_cf* v_in
);

Error* multiply_matrix_and_vector_cd
(
    Vector_cd**      v_out, 
    const Matrix_cd* m_in, 
    const Vector_cd* v_in
);

Error* add_matrices_f
(
    Matrix_f**      m_out, 
    const Matrix_f* m_1, 
    const Matrix_f* m_2
);

Error* add_matrices_d
(
    Matrix_d**      m_out, 
    const Matrix_d* m_1, 
    const Matrix_d* m_2
);

Error* add_matrices_cf
(
    Matrix_cf**      m_out, 
    const Matrix_cf* m_1, 
    const Matrix_cf* m_2
);

Error* add_matrices_cd
(
    Matrix_cd**      m_out, 
    const Matrix_cd* m_1, 
    const Matrix_cd* m_2
);

Error* subtract_matrices_f
(
    Matrix_f**      m_out, 
    const Matrix_f* m_1, 
    const Matrix_f* m_2
);

Error* subtract_matrices_d
(
    Matrix_d**      m_out, 
    const Matrix_d* m_1, 
    const Matrix_d* m_2
);

Error* subtract_matrices_cf
(
    Matrix_cf**      m_out, 
    const Matrix_cf* m_1, 
    const Matrix_cf* m_2
);

Error* subtract_matrices_cd
(
    Matrix_cd**      m_out, 
    const Matrix_cd* m_1, 
    const Matrix_cd* m_2
);

void calc_matrix_asum_f(float* sum_out, const Matrix_f* m);

void calc_matrix_asum_d(double* sum_out, const Matrix_d* m);

void normalize_matrix_sum_f(Matrix_f** m_out, const Matrix_f* m_in);

void normalize_matrix_sum_d(Matrix_d** m_out, const Matrix_d* m_in);

void calc_frobenius_norm_f(float* norm_out, const Matrix_f* m);

void calc_frobenius_norm_d(double* norm_out, const Matrix_d* m);

Error* calc_frobenius_norm_diff_f
(
    float*          norm_out, 
    const Matrix_f* m_1,
    const Matrix_f* m_2
);

Error* calc_frobenius_norm_diff_d
(
    double*         norm_out, 
    const Matrix_d* m_1,
    const Matrix_d* m_2
);

Error* calc_frobenius_norm_abs_diff_f
(
    float*          norm_out, 
    const Matrix_f* m_1,
    const Matrix_f* m_2
);

Error* calc_frobenius_norm_abs_diff_d
(
    double*         norm_out, 
    const Matrix_d* m_1,
    const Matrix_d* m_2
);

#if defined JWSC_HAVE_LAPACK

Error* lu_decompose_matrix_f
(
    Matrix_f**      m_out, 
    Vector_i32**    pivot_out,
    const Matrix_f* m_in
);

Error* lu_decompose_matrix_d
(
    Matrix_d**      m_out, 
    Vector_i32**    pivot_out,
    const Matrix_d* m_in
);

#endif




#if defined JWSC_HAVE_LAPACK

Error* invert_matrix_f(Matrix_f** m_out, const Matrix_f* m_in);

Error* invert_matrix_d(Matrix_d** m_out, const Matrix_d* m_in);

#endif




#if defined JWSC_HAVE_LAPACK

Error* invert_lu_matrix_f
(
    Matrix_f**        m_out, 
    const Matrix_f*   m_in, 
    const Vector_i32* pivot
);

Error* invert_lu_matrix_d
(
    Matrix_d**        m_out, 
    const Matrix_d*   m_in, 
    const Vector_i32* pivot
);

#endif




#if defined JWSC_HAVE_LAPACK

Error* calc_matrix_determinant_f(float* det_out, const Matrix_f* m);

Error* calc_matrix_determinant_d(double* det_out, const Matrix_d* m);

#endif




Error* calc_lu_matrix_determinant_f
(
    float*            det_out,
    const Matrix_f*   m, 
    const Vector_i32* pivot
);

Error* calc_lu_matrix_determinant_d
(
    double*           det_out,
    const Matrix_d*   m, 
    const Vector_i32* pivot
);

#if defined JWSC_HAVE_LAPACK

Error* solve_real_symmetric_matrix_eigenproblem_f
(
    Matrix_f**      V_out,
    Vector_f**      D_out, 
    const Matrix_f* M
);

Error* solve_real_symmetric_matrix_eigenproblem_d
(
    Matrix_d**      V_out,
    Vector_d**      D_out, 
    const Matrix_d* M
);

#endif




#if defined JWSC_HAVE_LAPACK

Error* singular_value_decompose_matrix_f
(
    Matrix_f**      U_out,
    Vector_f**      S_out, 
    Matrix_f**      Vt_out,
    const Matrix_f* M
);

Error* singular_value_decompose_matrix_d
(
    Matrix_d**      U_out,
    Vector_d**      S_out, 
    Matrix_d**      Vt_out,
    const Matrix_d* M
);

#endif




#if defined JWSC_HAVE_LAPACK

Error* pseudoinvert_matrix_no_svd_f
(
    Matrix_f**      M_out,
    const Matrix_f* M_in
);

Error* pseudoinvert_matrix_no_svd_d
(
    Matrix_d**      M_out,
    const Matrix_d* M_in
);

#endif




#if defined JWSC_HAVE_LAPACK

Error* pseudoinvert_matrix_f
(
    Matrix_f**      M_out,
    const Matrix_f* M_in
);

Error* pseudoinvert_matrix_d
(
    Matrix_d**      M_out,
    const Matrix_d* M_in
);

#endif




void create_euler_rotation_matrix_f
(
    Matrix_f** m_out,
    float      phi,
    float      theta,
    float      psi
);

void create_euler_rotation_matrix_d
(
    Matrix_d** m_out,
    float      phi,
    float      theta,
    float      psi
);

Error* create_3d_rotation_matrix_1_f
(
    Matrix_f**      m_out, 
    float           phi,
    const Vector_f* v
);

Error* create_3d_rotation_matrix_1_d
(
    Matrix_d**      m_out, 
    double          phi,
    const Vector_d* v
);

Error* create_3d_rotation_matrix_2_f
(
    Matrix_f** m_out, 
    float      phi,
    float      x,
    float      y,
    float      z
);

Error* create_3d_rotation_matrix_2_d
(
    Matrix_d** m_out, 
    double     phi,
    double     x,
    double     y,
    double     z
);

Error* create_3d_homo_rotation_matrix_1_f
(
    Matrix_f**      m_out, 
    float           phi,
    const Vector_f* v
);

Error* create_3d_homo_rotation_matrix_1_d
(
    Matrix_d**      m_out, 
    double          phi,
    const Vector_d* v
);

Error* create_3d_homo_rotation_matrix_2_f
(
    Matrix_f** m_out, 
    float      phi,
    float      x,
    float      y,
    float      z
);

Error* create_3d_homo_rotation_matrix_2_d
(
    Matrix_d** m_out, 
    double     phi,
    double     x,
    double     y,
    double     z
);

Error* create_3d_scaling_matrix_1_f
(
    Matrix_f**      m_out, 
    const Vector_f* v
);

Error* create_3d_scaling_matrix_1_d
(
    Matrix_d**      m_out, 
    const Vector_d* v
);

Error* create_3d_scaling_matrix_2_f
(
    Matrix_f** m_out, 
    float      x,
    float      y,
    float      z
);

Error* create_3d_scaling_matrix_2_d
(
    Matrix_d** m_out, 
    double     x,
    double     y,
    double     z
);

Error* create_3d_homo_scaling_matrix_1_f
(
    Matrix_f**      m_out, 
    const Vector_f* v
);

Error* create_3d_homo_scaling_matrix_1_d
(
    Matrix_d**      m_out, 
    const Vector_d* v
);

Error* create_3d_homo_scaling_matrix_2_f
(
    Matrix_f** m_out, 
    float      x,
    float      y,
    float      z
);

Error* create_3d_homo_scaling_matrix_2_d
(
    Matrix_d** m_out, 
    double     x,
    double     y,
    double     z
);

Error* create_3d_homo_translation_matrix_1_f
(
    Matrix_f**      m_out, 
    const Vector_f* v
);

Error* create_3d_homo_translation_matrix_1_d
(
    Matrix_d**      m_out, 
    const Vector_d* v
);

Error* create_3d_homo_translation_matrix_2_f
(
    Matrix_f** m_out, 
    float      x,
    float      y,
    float      z
);

Error* create_3d_homo_translation_matrix_2_d
(
    Matrix_d** m_out, 
    double     x,
    double     y,
    double     z
);

#ifdef __cplusplus
}
}
#endif


#endif