matf_square.h

Go to the documentation of this file.

/* This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef _GAN_MATF_SQUARE_H
#define _GAN_MATF_SQUARE_H

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <gandalf/common/misc_defs.h>
#include <gandalf/linalg/linalg_defs.h>

#ifdef __cplusplus
extern "C" {
#endif

/* forward declaration of square matrix structure */
struct Gan_SquMatrix_f;

typedef struct Gan_SquMatrixFFuncs
{
   Gan_Bool (*set_el) ( struct Gan_SquMatrix_f *A, unsigned i, unsigned j,
                        float value );
   float (*get_el) ( const struct Gan_SquMatrix_f *A, unsigned i, unsigned j );
   Gan_Bool (*inc_el) ( struct Gan_SquMatrix_f *A, unsigned i, unsigned j,
                        float value );
   Gan_Bool (*dec_el) ( struct Gan_SquMatrix_f *A, unsigned i, unsigned j,
                        float value );
   Gan_Bool (*fprint) ( FILE *fp, const struct Gan_SquMatrix_f *A,
                        const char *prefix, unsigned indent, const char *fmt );
   struct Gan_SquMatrix_f *(*copy) ( const struct Gan_SquMatrix_f *A,
                                     struct Gan_SquMatrix_f *B );
   struct Gan_SquMatrix_f *(*scale) ( struct Gan_SquMatrix_f *A, float a,
                                      struct Gan_SquMatrix_f *B );
   struct Gan_SquMatrix_f *(*add) (
       struct Gan_SquMatrix_f *A, Gan_TposeFlag A_tr,
       struct Gan_SquMatrix_f *B, Gan_TposeFlag B_tr,
       struct Gan_SquMatrix_f *C );
   struct Gan_SquMatrix_f *(*sub) (
       struct Gan_SquMatrix_f *A, Gan_TposeFlag A_tr,
       struct Gan_SquMatrix_f *B, Gan_TposeFlag B_tr,
       struct Gan_SquMatrix_f *C );
   struct Gan_Vector_f *(*multv) (
       const struct Gan_SquMatrix_f *A, Gan_TposeFlag A_tr, Gan_InvertFlag A_inv,
       struct Gan_Vector_f *x, struct Gan_Vector_f *y );
   struct Gan_Matrix_f *(*rmult) (
       const struct Gan_SquMatrix_f *A, Gan_TposeFlag A_tr, Gan_InvertFlag A_inv,
       struct Gan_Matrix_f *B, Gan_TposeFlag B_tr, struct Gan_Matrix_f *C );
   struct Gan_Matrix_f *(*lmult) (
       const struct Gan_SquMatrix_f *A, Gan_TposeFlag A_tr, Gan_InvertFlag A_inv,
       struct Gan_Matrix_f *B, Gan_TposeFlag B_tr, struct Gan_Matrix_f *C );
   struct Gan_SquMatrix_f *(*rmult_squ) (
       struct Gan_SquMatrix_f *A, Gan_TposeFlag A_tr, Gan_InvertFlag A_inv,
       struct Gan_SquMatrix_f *B, Gan_TposeFlag B_tr, Gan_InvertFlag B_inv,
       struct Gan_SquMatrix_f *C );
   struct Gan_SquMatrix_f *(*lrmult) (
       const struct Gan_SquMatrix_f *A, const struct Gan_Matrix_f *B, Gan_TposeFlag B_tr,
       struct Gan_Matrix_f *C, struct Gan_SquMatrix_f *D );
   struct Gan_SquMatrix_f *(*invert) ( struct Gan_SquMatrix_f *A,
                                       struct Gan_SquMatrix_f *B );
   struct Gan_SquMatrix_f *(*cholesky) ( struct Gan_SquMatrix_f *S,
                                         struct Gan_SquMatrix_f *L,
                                         int *error_code );
   float (*sumsqr) ( const struct Gan_SquMatrix_f *A );
   float (*Fnorm)  ( const struct Gan_SquMatrix_f *A );
   struct Gan_Matrix_f *(*matrix) ( const struct Gan_SquMatrix_f *A,
                                    struct Gan_Matrix_f *B );
} Gan_SquMatrixFFuncs;

typedef struct Gan_SquMatrix_f
{
   /* type of square matrix, i.e. symmetric, triangular etc. */
   Gan_SquMatrixType type;

   /* row and column sizes of matrix */
   unsigned long size;

   /* data array containing matrix elements */
   float *data;

   /* allocated size of matrix (number of float's) */
   size_t data_size;

   /* pointer to structure containing type-specific functions */
   Gan_SquMatrixFFuncs *funcs;

   /* flag indicating whether matrix data was dynamically allocated */
   Gan_Bool data_alloc;

   /* flag indicating whether matrix structure was dynamically allocated */
   Gan_Bool struct_alloc;
} Gan_SquMatrix_f;

#define GAN_SQUMATRIXF_STRUCT_DEFINED

#include <gandalf/linalg/vecf_gen.h>
#include <gandalf/linalg/matf_gen.h>

 Gan_SquMatrix_f *gan_squmatf_alloc ( Gan_SquMatrixType type,
                                     unsigned long size );

 Gan_SquMatrix_f *gan_squmatf_form ( Gan_SquMatrix_f *A, Gan_SquMatrixType type,
                                    unsigned long size );

 Gan_SquMatrix_f *
 gan_squmatf_form_data ( Gan_SquMatrix_f *A,
                         Gan_SquMatrixType type, unsigned long size,
                         float *data, size_t data_size );

 Gan_Bool gan_squmatf_set_el ( Gan_SquMatrix_f *A, unsigned row, unsigned col,
                              float value );

 float gan_squmatf_get_el ( const Gan_SquMatrix_f *A, unsigned row, unsigned col );

 Gan_Bool gan_squmatf_inc_el ( Gan_SquMatrix_f *A, unsigned row, unsigned col,
                              float value );

 Gan_Bool gan_squmatf_dec_el ( Gan_SquMatrix_f *A, unsigned row, unsigned col,
                              float value );

 Gan_Bool gan_squmatf_fprint ( FILE *fp, const Gan_SquMatrix_f *A,
                              const char *prefix, int indent,
                              const char *fmt );

 Gan_Bool gan_squmatf_print ( const Gan_SquMatrix_f *A,
                             const char *prefix, int indent, const char *fmt );

 Gan_SquMatrix_f *
 gan_squmatf_fill_const_s ( Gan_SquMatrixType type,
                            unsigned long size, float value );

 Gan_SquMatrix_f *
 gan_squmatf_fill_zero_q ( Gan_SquMatrix_f *A, Gan_SquMatrixType type,
                           unsigned long size );

 Gan_SquMatrix_f *
 gan_squmatf_fill_zero_s ( Gan_SquMatrixType type, unsigned long size );

 Gan_SquMatrix_f *gan_squmatf_copy_q ( const Gan_SquMatrix_f *A, Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_copy_s ( const Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatf_scale_q ( Gan_SquMatrix_f *A, float a,
                                       Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_scale_s ( Gan_SquMatrix_f *A, float a );

 Gan_SquMatrix_f *gan_squmatf_scale_i ( Gan_SquMatrix_f *A, float a );

 Gan_SquMatrix_f *gan_squmatf_divide_q ( Gan_SquMatrix_f *A, float a,
                                        Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_divide_s ( Gan_SquMatrix_f *A, float a );

 Gan_SquMatrix_f *gan_squmatf_divide_i ( Gan_SquMatrix_f *A, float a );

 Gan_SquMatrix_f *gan_squmatf_negate_q ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_negate_s ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatf_negate_i ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatf_add_q ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B,
                                     Gan_SquMatrix_f *C );

 Gan_SquMatrix_f *gan_squmatf_add_s ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_add_i1 ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_add_i2 ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_increment ( Gan_SquMatrix_f *A,
                                         Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_addT_q ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B,
                                      Gan_SquMatrix_f *C );

 Gan_SquMatrix_f *gan_squmatf_addT_s ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_incrementT ( Gan_SquMatrix_f *A,
                                          Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_sub_q ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B,
                                     Gan_SquMatrix_f *C );

 Gan_SquMatrix_f *gan_squmatf_sub_s ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_sub_i1 ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_sub_i2 ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_decrement ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_subT_q ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B,
                                      Gan_SquMatrix_f *C );

 Gan_SquMatrix_f *gan_squmatf_subT_s ( Gan_SquMatrix_f *A,
                                      Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_decrementT ( Gan_SquMatrix_f *A,
                                          Gan_SquMatrix_f *B );

 Gan_Vector_f *gan_squmatf_multv_q ( const Gan_SquMatrix_f *A, Gan_Vector_f *x,
                                    Gan_Vector_f *y );

 Gan_Vector_f *gan_squmatf_multv_s ( const Gan_SquMatrix_f *A, Gan_Vector_f *x );

 Gan_Vector_f *gan_squmatf_multv_i ( const Gan_SquMatrix_f *A, Gan_Vector_f *x );

 Gan_Vector_f *gan_squmatTf_multv_q ( const Gan_SquMatrix_f *A, Gan_Vector_f *x,
                                     Gan_Vector_f *y );

 Gan_Vector_f *gan_squmatTf_multv_s ( const Gan_SquMatrix_f *A, Gan_Vector_f *x );

 Gan_Vector_f *gan_squmatTf_multv_i ( const Gan_SquMatrix_f *A, Gan_Vector_f *x );

 Gan_Vector_f *gan_squmatIf_multv_q ( const Gan_SquMatrix_f *A, Gan_Vector_f *x,
                                     Gan_Vector_f *y );

 Gan_Vector_f *gan_squmatIf_multv_s ( const Gan_SquMatrix_f *A, Gan_Vector_f *x );

 Gan_Vector_f *gan_squmatIf_multv_i ( const Gan_SquMatrix_f *A, Gan_Vector_f *x );

 Gan_Vector_f *gan_squmatITf_multv_q ( const Gan_SquMatrix_f *A, Gan_Vector_f *x,
                                      Gan_Vector_f *y );

 Gan_Vector_f *gan_squmatITf_multv_s ( const Gan_SquMatrix_f *A, Gan_Vector_f *x );

 Gan_Vector_f *gan_squmatITf_multv_i ( const Gan_SquMatrix_f *A, Gan_Vector_f *x );

 Gan_Matrix_f *gan_squmatf_rmult_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                    Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatf_rmult_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatf_rmult_i ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatf_rmultT_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                     Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatf_rmultT_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatTf_rmult_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                     Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatTf_rmult_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatTf_rmult_i ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatTf_rmultT_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                      Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatTf_rmultT_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatIf_rmult_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                     Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatIf_rmult_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatIf_rmult_i ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatIf_rmultT_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                      Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatIf_rmultT_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatITf_rmult_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                      Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatITf_rmult_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatITf_rmult_i ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatITf_rmultT_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                       Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatITf_rmultT_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatf_lmult_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                    Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatf_lmult_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatf_lmult_i ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatf_lmultT_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                     Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatf_lmultT_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatTf_lmult_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                     Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatTf_lmult_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatTf_lmult_i ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatTf_lmultT_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                      Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatTf_lmultT_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatIf_lmult_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                     Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatIf_lmult_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatIf_lmult_i ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatIf_lmultT_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                      Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatIf_lmultT_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatITf_lmult_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                      Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatITf_lmult_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatITf_lmult_i ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_squmatITf_lmultT_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B,
                                       Gan_Matrix_f *C );

 Gan_Matrix_f *gan_squmatITf_lmultT_s ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_srmultT_squ_q ( Gan_SquMatrix_f *A,
                                             Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_srmultT_squ_s ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatf_srmultT_squ_i ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatTf_srmult_squ_q ( Gan_SquMatrix_f *A,
                                             Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatTf_srmult_squ_s ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatTf_srmult_squ_i ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatIf_srmultIT_squ_q ( Gan_SquMatrix_f *A,
                                               Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatIf_srmultIT_squ_s ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatIf_srmultIT_squ_i ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatITf_srmultI_squ_q ( Gan_SquMatrix_f *A,
                                               Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatITf_srmultI_squ_s ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatITf_srmultI_squ_i ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_symmatf_lrmult_q ( Gan_SquMatrix_f *A, const Gan_Matrix_f *B,
                                        const Gan_Matrix_f *C, Gan_SquMatrix_f *D );

 Gan_SquMatrix_f *gan_symmatf_lrmult_s ( Gan_SquMatrix_f *A, const Gan_Matrix_f *B,
                                        const Gan_Matrix_f *C );

 Gan_SquMatrix_f *gan_symmatf_lrmultT_q ( Gan_SquMatrix_f *A, const Gan_Matrix_f *B,
                                         const Gan_Matrix_f *C, Gan_SquMatrix_f *D );

 Gan_SquMatrix_f *gan_symmatf_lrmultT_s ( Gan_SquMatrix_f *A, const Gan_Matrix_f *B,
                                         const Gan_Matrix_f *C );

 Gan_SquMatrix_f *gan_squmatf_invert_q ( Gan_SquMatrix_f *A, Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_invert_s ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatf_invert_i ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatf_cholesky_q ( Gan_SquMatrix_f *A,
                                          Gan_SquMatrix_f *L );

 Gan_SquMatrix_f *gan_squmatf_cholesky_s ( Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatf_cholesky_i ( Gan_SquMatrix_f *A );

 float gan_squmatf_sumsqr ( Gan_SquMatrix_f *A );

 float gan_squmatf_Fnorm ( Gan_SquMatrix_f *A );

 Gan_Matrix_f *gan_matf_from_squmatf_q ( const Gan_SquMatrix_f *A, Gan_Matrix_f *B );

 Gan_Matrix_f *gan_matf_from_squmatf_s ( const Gan_SquMatrix_f *A );

 Gan_Bool gan_squmatf_same_type ( const Gan_SquMatrix_f *A, const Gan_SquMatrix_f *B );

 Gan_Bool gan_squmatf_same_size ( const Gan_SquMatrix_f *A, const Gan_SquMatrix_f *B );

 Gan_Bool gan_squmatf_same_type_size ( const Gan_SquMatrix_f *A, const Gan_SquMatrix_f *B );

 Gan_SquMatrix_f *gan_squmatf_set_type ( Gan_SquMatrix_f *A,
                                        Gan_SquMatrixType type );

 Gan_SquMatrix_f *gan_squmatf_set_size ( Gan_SquMatrix_f *A,
                                        unsigned long size );

 Gan_Bool gan_squmatf_test_size ( const Gan_Matrix_f *A, unsigned long size );

 Gan_Bool gan_squmatf_symmetric_type ( const Gan_SquMatrix_f *A );

 Gan_Bool gan_squmatf_diagonal_type ( const Gan_SquMatrix_f *A );

 Gan_Bool gan_squmatf_symmetric ( const Gan_SquMatrix_f *A );

 Gan_Bool gan_squmatf_diagonal ( const Gan_SquMatrix_f *A );

 Gan_SquMatrix_f *gan_squmatf_fscanf_s ( FILE *fp,
                                        const char *prefix, int prefix_len );

 Gan_SquMatrix_f *gan_squmatf_fread_s ( FILE *fp, gan_uint32 *magic_number );

 void gan_squmatf_free ( Gan_SquMatrix_f *A );
 void gan_squmatf_free_va ( Gan_SquMatrix_f *A, ... );
 Gan_SquMatrix_f *gan_squmatf_set_type_size ( Gan_SquMatrix_f *A,
                                             Gan_SquMatrixType type,
                                             unsigned long size );
 Gan_SquMatrix_f *gan_squmatf_fill_vap ( Gan_SquMatrix_f *A,
                                        Gan_SquMatrixType type,
                                        unsigned long size, va_list *aptr );
 Gan_SquMatrix_f *gan_squmatf_fill_const_q ( Gan_SquMatrix_f *A,
                                            Gan_SquMatrixType type,
                                            unsigned long size, float value );
 size_t gan_squmatf_data_size ( Gan_SquMatrixType type, unsigned long size );
 Gan_SquMatrix_f *gan_squmatf_fscanf_q ( FILE *fp, Gan_SquMatrix_f *A,
                                        char *prefix, int prefix_len );
 Gan_Bool gan_squmatf_fwrite ( FILE *fp, const Gan_SquMatrix_f *A,
                              gan_uint32 magic_number );
 Gan_SquMatrix_f *gan_squmatf_fread_q ( FILE *fp, Gan_SquMatrix_f *A,
                                       gan_uint32 *magic_number );

/* not user functions */
 Gan_SquMatrix_f *gan_squmatf_form_gen ( Gan_SquMatrix_f *A,
                                        Gan_SquMatrixType type,
                                        unsigned long size,
                                        float *data, size_t data_size );
 void gan_squmatf_free_func ( Gan_SquMatrix_f *A );
#ifndef NDEBUG
 void gan_squmatf_db ( const Gan_SquMatrix_f *A ); /* for use in a debugger */
#endif

#ifdef __cplusplus
}
#endif

#endif /* #ifndef _GAN_MATF_SQUARE_H */

---