vm_m3math.h

#ifndef vm_m3math_h_INCLUDED
#define vm_m3math_h_INCLUDED

// File:   vm_m3math.h
// Author: Terry Gaetz

/* --8<--8<--8<--8<--
 *
 * Copyright (C) 2006 Smithsonian Astrophysical Observatory
 *
 * This file is part of vm_math.cvs
 *
 * vm_math.cvs is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * vm_math.cvs 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the 
 *       Free Software Foundation, Inc. 
 *       51 Franklin Street, Fifth Floor
 *       Boston, MA  02110-1301, USA
 *
 * -->8-->8-->8-->8-- */

/****************************************************************************
 * Description: collection of methods for vm_M3Math
 *
 * History
 *--------
 * 0.0.0 1998-Jan-30  tjg  original version
 */

#include <vm_math/vm_vmath.h>  // vm_VMath<T,N>
#include <cstring>             // memcpy strlen
#include <cmath>               // sqrt fabs
#include <iostream>            // ostream, <<
#include <cstdio>              // FILE*

//########################################################################
// vm_M3Math<T_fp>
//########################################################################

template <class T_fp>
class vm_M3Math
  : public vm_VMath<T_fp,9>
{
private:

  enum ENelts_     { ENelts     = 9 };
  enum EColStride_ { EColStride = 3 };
  enum ERows_      { ERow0 = 0, ERow1 = 3, ERow2 = 6 };

public:

  // typedef typename T_fp value_type;
  typedef T_fp value_type;


  static int at( int i, int j );

  inline static void init_by_row( T_fp       m[],
                                  T_fp const row0[], 
                                  T_fp const row1[], 
                                  T_fp const row2[] );

  inline static void init_by_col( T_fp       m[],
                                  T_fp const col0[], 
                                  T_fp const col1[], 
                                  T_fp const col2[] );

  inline static void dyad_product( T_fp m[], T_fp const v1[], T_fp const v2[] );

  inline static void inject_row( T_fp       m[],
                                 T_fp const row[], int whichrow );
    //
    //: copy the supplied vector into row whichrow of m.

  inline static void inject_col( T_fp       m[],
                                 T_fp const col[], int whichcol );

  inline static void extract_row( T_fp const m[],
                                  T_fp       row[], int whichrow );

  inline static void extract_col( T_fp const m[],
                                  T_fp       col[], int whichcol );
  // ---------------------------------------------------------------------

  inline static void mvmult( T_fp res[], T_fp const m[], T_fp const v[] );

  inline static void mtvmult( T_fp res[], T_fp const m[], T_fp const v[] );
  // ---------------------------------------------------------------------

  inline static void mmult( T_fp mres[], T_fp const m1[], T_fp const m2[] );
  // ---------------------------------------------------------------------
  inline static std::ostream&
  print_on( std::ostream& os, T_fp const m[], 
            char const prefix[] = "", char const postfix[] = "" );

  inline static void
  cprint_on( FILE* of, T_fp const m[], 
             char const prefix[] = "", char const postfix[] = "" );
};

//########################################################################
//########################################################################
//
//    #    #    #  #          #    #    #  ######   ####
//    #    ##   #  #          #    ##   #  #       #
//    #    # #  #  #          #    # #  #  #####    ####
//    #    #  # #  #          #    #  # #  #            #
//    #    #   ##  #          #    #   ##  #       #    #
//    #    #    #  ######     #    #    #  ######   ####
//
//########################################################################
//########################################################################

//-------------------------------------------------------------------------
// index calculation

template <class T_fp>
inline int vm_M3Math<T_fp>::
at( int i, int j )
{ return i * EColStride + j; }

//-------------------------------------------------------------------------
// initialize matrix by row or by column

template <class T_fp>
inline void vm_M3Math<T_fp>::
init_by_row( T_fp       m[],
             T_fp const row0[],
             T_fp const row1[],
             T_fp const row2[] )
{ memcpy( &m[ERow0], row0, 3 * sizeof(T_fp) );
  memcpy( &m[ERow1], row1, 3 * sizeof(T_fp) );
  memcpy( &m[ERow2], row2, 3 * sizeof(T_fp) ); }

template <class T_fp>
inline void vm_M3Math<T_fp>::
init_by_col( T_fp       m[],
             T_fp const col0[],
             T_fp const col1[],
             T_fp const col2[] )
{ m[0] = col0[0];   m[3] = col0[1];   m[6] = col0[2];
  m[1] = col1[0];   m[4] = col1[1];   m[7] = col1[2];
  m[2] = col2[0];   m[5] = col2[1];   m[8] = col2[2]; }

//-------------------------------------------------------------------------
// copy vector to given row or column of m

template <class T_fp>
inline void vm_M3Math<T_fp>::
inject_row( T_fp       m[],
            T_fp const row[], int whichrow )
{ memcpy( &m[whichrow*EColStride], row, 3 * sizeof(T_fp) ); }

template <class T_fp>
inline void vm_M3Math<T_fp>::
inject_col( T_fp       m[],
            T_fp const col[], int whichcol )
{ 
  double* pm = &m[whichcol];
  *pm = *col++;   pm += EColStride;
  *pm = *col++;   pm += EColStride;
  *pm = *col;
}

//-------------------------------------------------------------------------
// copy a given row or column of m to a vector

template <class T_fp>
inline void vm_M3Math<T_fp>::
extract_row( T_fp const m[],
             T_fp       row[], int whichrow )
{ memcpy( row, &m[whichrow*EColStride], 3 * sizeof(T_fp) ); }

template <class T_fp>
inline void vm_M3Math<T_fp>::
extract_col( T_fp const m[],
             T_fp       col[], int whichcol )
{ 
  double const* pm = &m[whichcol];
  *col = *pm;  pm += EColStride;  ++col;
  *col = *pm;  pm += EColStride;  ++col;
  *col = *pm;
}

//-------------------------------------------------------------------------
// initialize a matrix to a dyadic product of vectors

template <class T_fp>
inline void vm_M3Math<T_fp>::
dyad_product( T_fp m[], T_fp const v1[], T_fp const v2[] )
{
  m[0] = v1[0] * v2[0];   m[1] = v1[0] * v2[1];   m[2] = v1[0] * v2[2];
  m[3] = v1[1] * v2[0];   m[4] = v1[1] * v2[1];   m[5] = v1[1] * v2[2];
  m[6] = v1[2] * v2[0];   m[7] = v1[2] * v2[1];   m[8] = v1[2] * v2[2];
}

//-------------------------------------------------------------------------
// matrix-vector operations.

template <class T_fp>
inline void vm_M3Math<T_fp>::
mvmult( T_fp res[], T_fp const m[], T_fp const v[] )
{
  res[0] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2];
  res[1] = m[3] * v[0] + m[4] * v[1] + m[5] * v[2];
  res[2] = m[6] * v[0] + m[7] * v[1] + m[8] * v[2];
}

template <class T_fp>
inline void vm_M3Math<T_fp>::
mtvmult( T_fp res[], T_fp const m[], T_fp const v[] )
{
  res[0] = m[0] * v[0] + m[3] * v[1] + m[6] * v[2];
  res[1] = m[1] * v[0] + m[4] * v[1] + m[7] * v[2];
  res[2] = m[2] * v[0] + m[5] * v[1] + m[8] * v[2];
}

template <class T_fp>
inline void vm_M3Math<T_fp>::
mmult( T_fp mres[], T_fp const m1[], T_fp const m2[] )
{
  mres[0] = m1[0] * m2[0]  +  m1[1] * m2[3]  +  m1[2] * m2[6];
  mres[1] = m1[0] * m2[1]  +  m1[1] * m2[4]  +  m1[2] * m2[7];
  mres[2] = m1[0] * m2[2]  +  m1[1] * m2[5]  +  m1[2] * m2[8];

  mres[3] = m1[3] * m2[0]  +  m1[4] * m2[3]  +  m1[5] * m2[6];
  mres[4] = m1[3] * m2[1]  +  m1[4] * m2[4]  +  m1[5] * m2[7];
  mres[5] = m1[3] * m2[2]  +  m1[4] * m2[5]  +  m1[5] * m2[8];

  mres[6] = m1[6] * m2[0]  +  m1[7] * m2[3]  +  m1[8] * m2[6];
  mres[7] = m1[6] * m2[1]  +  m1[7] * m2[4]  +  m1[8] * m2[7];
  mres[8] = m1[6] * m2[2]  +  m1[7] * m2[5]  +  m1[8] * m2[8];
}

template <class T_fp>
inline std::ostream& vm_M3Math<T_fp>::
print_on( std::ostream& os, T_fp const m[], 
          char const prefix[], char const postfix[] )
{
  if ( std::strlen(prefix) ) { os << prefix; }
  os << m[0] << " " << m[1] << " " << m[2] << "\n"
     << m[3] << " " << m[4] << " " << m[5] << "\n"
     << m[6] << " " << m[7] << " " << m[8] << "\n";
  if ( std::strlen(postfix) ) { os << postfix; }
  return os;
}

template <class T_fp>
inline void vm_M3Math<T_fp>::
cprint_on( FILE* of, T_fp const m[], 
           char const prefix[], char const postfix[] )
{
  if ( std::strlen(prefix) ) { std::fprintf(of, "%s", prefix); }
  std::fprintf(of, "%.18e %.18e %.18e\n", m[0], m[1], m[2]);
  std::fprintf(of, "%.18e %.18e %.18e\n", m[3], m[4], m[5]);
  std::fprintf(of, "%.18e %.18e %.18e\n", m[6], m[7], m[8]);
  if ( std::strlen(postfix) ) { std::fprintf(of, "%s", postfix); }
}

#endif  /* vm_m3math.h */