matvecop.hpp

模糊聚類分析源碼。包含教學文件

/*
  
  Context       : Matrix and Vector Operation

  Author        : Frank Hoeppner, see also AUTHORS file 

  Description   : header of function module matvecop
                  
  History       : see source file

  Comment       : 
    This file was generated automatically. DO NOT EDIT.

  Copyright     : Copyright (C) 1999-2000 Frank Hoeppner

    This program 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.

    This program 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef matvecop_HEADER
#define matvecop_HEADER

/* configuration include */
#ifdef HAVE_CONFIG_H
/*
//FILETREE_IFDEF HAVE_CONFIG_H
*/
#include "config.h"
/*
//FILETREE_ENDIF
*/
#endif



/* necessary includes */
//#include "DynMatrix.hpp"
template <short ROWS,short COLS,class DATA> class DynMatrix;
#include <functional> // unary_function etc.
#include <algorithm> // min
#include <fstream.h> // i/o
#include "define.hpp"
#include "trace.hpp"
#include "stlutil.hpp" // compose
#include "primitives.hpp" // set_to etc.
#include "ustream-d.hpp" // read_white
//#define INLINE inline

/* global types and constants */



/* data interface */


/* MatVecOp interface */


/* inline implementation */


template <class M1,class M2> inline
bool 
matrix_numeric_equal 
  (
  const M1& A, 
  const M2& B
  )
  {
  invariant 
    (
    (A.rows()<=B.rows()) && (A.cols()<=B.cols()),
    "operation assumes relaxed matrix dimensions",
    SOURCELOC
    );

  int r; // row counter
  int c; // col counter
  int rs(A.rows()); // no of rows
  int cs(A.cols()); // no of cols
  num_equal<typename M1::value_type,typename M2::value_type> equal;
  
  for (r=0;r<rs;++r)
    {
    for (c=0;c<cs;++c)
      {
      if (!equal( A(r,c),B(r,c) )) return false;
      }
    }
    
  return true;
  }
template <class M1,class M2,class CMP>
struct matrix_compare
  : public binary_function<M1,M2,compare_type>
  {
  matrix_compare(const CMP& cmp) : m_cmp_op(cmp) {}
  inline compare_type operator()(const M1&,const M2&) const;
  CMP m_cmp_op;
  };

template <class M1,class M2> 
inline bool 
matrix_lexico_less 
  (
  const M1& A, 
  const M2& B
  )
  {
  default_operator_compare<typename M1::value_type,typename M2::value_type> c1;
  matrix_compare<M1,M2,
    default_operator_compare<typename M1::value_type,typename M2::value_type> > c2(c1);
  return c2(A,B)==cmp_less;
  }


template <class M1,class BF1,class M2,class BF2,class M3> inline 
void
matrix_transform // f(A,g(B,C))
  (
        M1&  A,
  const BF1& f,
  const M2&  B,
  const BF2& g,
  const M3&  C
  )
  {
  invariant 
    (
    (A.rows()<=B.rows()) && (A.cols()<=B.cols()) &&
    (A.rows()<=C.rows()) && (A.cols()<=C.cols()),
    "operation assumes relaxed matrix dimensions",
    SOURCELOC
    );
  int rs(A.rows()); // no of rows
  int cs(A.cols()); // no of cols
  for (int r=0;r<rs;++r)
    {
    for (int c=0;c<cs;++c)
      {
      f( A(r,c) , g( B(r,c), C(r,c) ) );
      }
    }
  }

template <class M1,class BF,class UF,class M2> inline 
void
matrix_transform // f(A,g(B))
  (
        M1& A,
  const BF& f,
  const UF& g,
  const M2& B
  )
  {
  invariant 
    (
    (A.rows()<=B.rows()) && (A.cols()<=B.cols()),
    "operation assumes relaxed matrix dimensions",
    SOURCELOC
    );
  int rs(A.rows()); // no of rows
  int cs(A.cols()); // no of cols
  for (int r=0;r<rs;++r)
    {
    for (int c=0;c<cs;++c)
      {
      f( A(r,c) , g( B(r,c) ) );
      }
    }
  }

template <class D,class BF1,class M1,class BF2,class M2> inline 
typename M1::value_type
matrix_transform_value // f(x,g(B,C))
  (
  const D    init,
  const BF1& f,
  const M1&  A,
  const BF2& g,
  const M2&  B
  )
  {
  invariant 
    (
    (A.rows()<=B.rows()) && (A.cols()<=B.cols()),
    "operation assumes relaxed matrix dimensions",
    SOURCELOC
    );
  int rs(A.rows()); // no of rows
  int cs(A.cols()); // no of cols
  typename M1::value_type value(init); // return value
  for (int r=0;r<rs;++r)
    {
    for (int c=0;c<cs;++c)
      {
      f( value, g( A(r,c), B(r,c) ) );
      }
    }
  return value;  
  }
template <class M1,class D> inline void 
matrix_set_scalar(M1& A, const D s)
  {
  set_to<typename M1::value_type,D> assign_op;
  int rs(A.rows()); // no of rows
  int cs(A.cols()); // no of cols
  for (int r=0;r<rs;++r)
    {
    for (int c=0;c<cs;++c)
      {
      assign_op(A(r,c),s);
      }
    }
  }
template <class M1,class D> inline void 
matrix_inc_scalar(M1& A, const D s)
  {
  incr_by<typename M1::value_type,D> incr_op;
  int rs(A.rows()); // no of rows
  int cs(A.cols()); // no of cols
  for (int r=0;r<rs;++r)
    {
    for (int c=0;c<cs;++c)
      {
      incr_op(A(r,c),s);
      }
    }
  }
template <class V> inline void
matrix_set_vector(V& A,const char* ap_text)
  {

  {
    int r(1),maxc(1),c(1),i(0);
    while (ap_text[i]!='\0') 
      { 
      if (ap_text[i]==':') { ++r; c=1; } 
      if (ap_text[i]==',') { ++c; if (c>maxc) maxc=c; }
      ++i; 
      }
    A.adjust(r,c);
    matrix_set_scalar(A,-1);
  }
/*
  {
    istrstream is(ap_text,strlen(ap_text));
    matrix_read_colon(is,A);
  }
*/
  }
template <class M1,class D> inline 
void matrix_set_vector(M1& M, const D s)
  {
  set_to<typename M1::value_type,D> assign_op;
  M.adjust(1);
  assign_op(M[0],s);
  }
template <class M1,class D> inline 
void matrix_set_vector(M1& M, const D s, const D t)
  {
  set_to<typename M1::value_type,D> assign_op;
  M.adjust(2);
  assign_op(M[0],s);
  assign_op(M[1],t);
  }
template <class M1,class D> inline 
void matrix_set_vector(M1& M, const D s, const D t, const D u)
  {
  set_to<typename M1::value_type,D> assign_op;
  M.adjust(3);
  assign_op(M(0),s);
  assign_op(M(1),t);
  assign_op(M(2),u);
  }
template <class M1,class D> inline 
void matrix_set_vector(M1& M, const D s, const D t, const D u, const D v)
  {
  set_to<typename M1::value_type,D> assign_op;
  M.adjust(4);
  assign_op(M(0),s);
  assign_op(M(1),t);
  assign_op(M(2),u);
  assign_op(M(3),v);
  }
template <class M1,class D> inline 
void matrix_set_vector(M1& M, const D s, const D t, const D u,
  const D v, const D w)
  {
  set_to<typename M1::value_type,D> assign_op;
  M.adjust(5);
  assign_op(M(0),s);
  assign_op(M(1),t);
  assign_op(M(2),u);
  assign_op(M(3),v);
  assign_op(M(4),w);
  }
template <class M1,class D> inline 
void matrix_set_track(M1& M, const D s, const D t)
  {
  set_to<typename M1::value_type,D> assign_op;
  M.adjust(2,2);
  assign_op(M(0,0),s);
  assign_op(M(1,1),t);
  }
template <class M1,class D> inline 
void matrix_set_track(M1& M, const D s, const D t, const D u)
  {
  set_to<typename M1::value_type,D> assign_op;
  M.adjust(3,3);
  assign_op(M(0,0),s);
  assign_op(M(1,1),t);
  assign_op(M(2,2),u);
  }
template <class M1,class D> inline 
void matrix_set_track(M1& M, const D s, const D t, const D u, const D v)
  {
  set_to<typename M1::value_type,D> assign_op;
  M.adjust(4,4);
  assign_op(M(0,0),s);
  assign_op(M(1,1),t);
  assign_op(M(2,2),u);
  assign_op(M(3,3),v);
  }
template <class M1,class D> inline 
void matrix_set_track(M1& M, const D s, const D t, const D u,
  const D v, const D w)
  {
  set_to<typename M1::value_type,D> assign_op;
  M.adjust(5,5);
  assign_op(M(0,0),s);
  assign_op(M(1,1),t);
  assign_op(M(2,2),u);
  assign_op(M(3,3),v);
  assign_op(M(4,4),w);
  }
template <class M1> inline 
void matrix_set_identity(M1& M)
  {
  //M.clear();
  matrix_set_scalar(M,0);
  int n( min(M.rows(),M.cols()) );
  for (int i=0;i<n;++i) M(i,i) = (typename M1::value_type)1;
  }
template <class M1> inline 
bool matrix_is_identity(const M1& M)
  {
  int rs(M.rows()); // no of rows
  int cs(M.cols()); // no of cols
  int r,c;
  typename M1::value_type one(1),zero(0);
  num_equal<typename M1::value_type,typename M1::value_type> equal;
  
  for (r=0;r<rs;++r)
    {
    for (c=0;c<cs;++c)
      {
      if (r==c) { if (!equal(M(r,c),one)) return false; }
      else      { if (!equal(M(r,c),zero)) return false; }
      }
    }

  return true;
  }

template <class M1,class M2> inline 
void matrix_set(M1& A,const M2& B)
  {
  matrix_transform
    (
    A,
    set_to<typename M1::value_type,typename M2::value_type>(),
    identity<typename M2::value_type>(),
    B
    ); 
  }
template <class M1,class M2> inline 
void matrix_copy(M1& A,const M2& B)
  {
  A=B; /* A.adjust(B.rows(),B.cols()); matrix_set(A,B); */
  }

template <class M1,class M2> inline 
void matrix_inc(M1& A,const M2& B)
  {
  matrix_transform
    (
    A,
    incr_by<typename M1::value_type,typename M2::value_type>(),
    identity<typename M2::value_type>(),
    B
    ); 
  }

template <class M1,class M2> inline 
void matrix_dec(M1& A,const M2& B)
  {
  matrix_transform
    (
    A,
    decr_by<typename M1::value_type,typename M2::value_type>(),
    identity<typename M2::value_type>(),
    B
    ); 
  }

template <class M1,class M2> inline 
void matrix_set_diff(M1& A, const M2& B, const M2& C)
  {
  matrix_transform
    (
    A,
    set_to<typename M1::value_type,typename M2::value_type>(),
    B,
    minus<typename M2::value_type>(),
    C
    ); 
  }