vlastreams.cc

basic linear algebra classes and applications (SVD,interpolation, multivariate optimization)

// This may look like C code, but it is really -*- C++ -*-
/*
 ************************************************************************
 *
 *		  Verify streams over matrices and vectors
 *
 *
 * $Id: vlastreams.cc,v 1.1 1998/12/13 23:29:39 oleg Exp oleg $
 *
 ************************************************************************
 */

#include "LAStreams.h"
#include "builtin.h"
#include <math.h>
#include "iostream.h"
#include <float.h>

/*
 *------------------------------------------------------------------------
 *	   Test allocation functions and compatibility check
 */

static void test_LAStreams(const int rsize, const int csize)
{
  const double pattern = 4.25;
  const double incr = 0.5;
  cout << "\n---> Test LAStreams\n";
  
  Matrix m(2,rsize+1,0,csize-1);
  {
    cout << "Fill out the matrix in the natural order via an ElementAction..." 
         << endl;
    struct filler : public ElementAction
    {
      double counter;
      const double incr;
      void operation(REAL& element, const int i, const int j)
	  		{ element = (counter += incr); }
      filler(const double _init_val, const double _incr) :
      	counter(_init_val), incr(_incr) {}
    };
    m.apply(filler(pattern,incr));
    assert( of_every(m) > pattern );
    assert( !(of_every(m) == pattern+incr) );	// There is at least one element
    assert( !(m != pattern+incr) );				// == and != to pattern+incr
  }
  
  {
    cout << "Check the filling order by a direct access. "
    	    "The row index varies first!" << endl;
    ConstMatrixDA ma(m);
    double counter = pattern;
    for(register int j=ma.q_col_lwb(); j<=ma.q_col_upb(); j++)
      for(register int i=ma.q_row_lwb(); i<=ma.q_row_upb(); i++)
         assert( ma(i,j) == (counter += incr) );
    assert( counter == pattern + m.q_no_elems() * incr );
  } 
  {
    cout << "Check the filling order via ElementWiseConstAction" << endl;
    struct checker : public ElementWiseConstAction
    {
      double counter;
      double incr;
      void operator () (const REAL element) 
      	{ assert(element == (counter += incr)); }
      checker(const double _init_val, const double _incr) :
      	counter(_init_val), incr(_incr) {}
    };
    of_every(m).apply(checker(pattern,incr));
  } 
  {
    cout << "Check the filling order via AREALStreamIn" << endl;
    LAStreamIn m_str(m);
    assert( !m_str.eof() );
    assert( m_str.bof() );
    double counter = pattern;
    AREALMark mark;
    assert( !mark ); // a user-created AREALMark is always invalid...
    assert( (bool)mark == false );
    mark = m_str.tell();
    assert( (bool)mark );	// the mark becomes valid now
    assert( m_str.get_pos(mark) == rowcol(m.q_row_lwb(),m.q_col_lwb()) );
    for(register int i=0; i<m.q_no_elems(); i++)
    {
      assert( !m_str.eof() );
      assert( m_str.peek() == (counter += incr) );
      assert( m_str.get() == counter );
      assert( !m_str.bof() );
    }
    assert( m_str.eof() );
    assert( m_str.get_pos(m_str.tell_prev()) ==
    	    rowcol(m.q_row_upb(),m.q_col_upb()) );
    cout << "\trewinding the stream and checking again..." << endl;
    m_str.rewind();
    assert( !m_str.eof() );
    assert( m_str.bof() );
    assert( m_str.get() == pattern + incr );
    assert( m_str.peek() == pattern + incr + incr );
    m_str.seek(mark);
    assert( !m_str.eof() );
    assert( m_str.bof() );
    assert( m_str.peek() == pattern + incr );
    assert( m_str.peek() == pattern + incr );
    assert( m_str.get() == pattern + incr );
  } 
  
  {
    cout << "Check the filling order via AREALStreamOut" << endl;
    Matrix m_copy = m;		// Duplicate the matrix
    assert( m_copy == m );
    LAStreamOut m_str(m_copy);
    assert( !m_str.eof() );
    assert( m_str.bof() );
    double counter = pattern;
    AREALMark mark = m_str.tell();
    assert( (bool)mark );
    assert( m_str.get_pos(mark) == 
    	    rowcol(m_copy.q_row_lwb(),m_copy.q_col_lwb()) );
    while( !m_str.eof() )
    {
      m_str.peek() -= (counter += incr);
      assert( m_str.get() == 0 );
      assert( !m_str.bof() );
    }
    assert( m_str.get_pos(m_str.tell_prev()) ==
    	    rowcol(m_copy.q_row_upb(),m_copy.q_col_upb()) );
    verify_element_value(m_copy,0);
    assert( !(m_copy == m) );
    
    cout << "\tCopying the matrices via streams" << endl;
    m_str.seek(m.q_no_elems(),LAS::end);
	assert( m_str.bof() );
    for(LAStreamIn m_in(m); !m_in.eof(); )
      m_str.get() = m_in.get();
    assert( m_str.eof() );
    assert( m_copy == m );
    cout << "\tChecking various seeks" << endl;
    m_str.seek(-m.q_no_elems());
    assert( !m_str.eof() );
    assert( m_str.bof() );
    assert( m_str.peek() == pattern + incr );
    assert( m_str.peek() == pattern + incr );
    assert( m_str.get() == pattern + incr );
    assert( m_str.get() == pattern + incr+incr );
	m_str.seek(-1,LAS::cur);
    assert( m_str.get() == pattern + incr+incr );
	assert( !m_str.bof() );
	m_str.seek(m.q_no_elems()-1,LAS::beg);
    assert( m_str.peek() == pattern + m.q_no_elems()*incr );
	m_str.ignore(1);
	assert( m_str.eof() );
	m_str.seek(1,LAS::end);
    assert( m_str.get() == pattern + m.q_no_elems()*incr );
	assert( m_str.eof() );
	m_str.seek(0,LAS::beg);
    assert( m_str.peek() == pattern + incr );
	m_str.seek(m.q_no_elems(),LAS::cur);
	assert( m_str.eof() );
  } 
  cout << "\nDone\n";
}

static void test_LAStrideStreams(const int rsize, const int csize,
				 const int stride)
{
  const double pattern = 4.25;
  const double incr = 1.5;
  cout << "\n---> Test LAStrideStreams over " << rsize << 'x' << csize
  	   << " matrix with a stride of " << stride << endl;
  
  Matrix m(-1,rsize-2,2,csize+1);
  {
    cout << "Fill out the matrix in the natural order via ElementWiseAction..." 
         << endl;
    struct filler : public ElementWiseAction
    {
      double counter;
      const double incr;
      void operator () (REAL& element) { element = counter; counter += incr; }
      filler(const double _init_val, const double _incr) :
      	counter(_init_val), incr(_incr) {}
    };
    to_every(m).apply(filler(pattern,incr));
    assert( of_every(m).max_abs() == pattern + incr*(m.q_no_elems()-1) );
    assert( abs( of_every(m).sum() - 
    	         (2*pattern+incr*(m.q_no_elems()-1))/2*m.q_no_elems() )
    	         <= FLT_EPSILON );
  }

  {
    cout << "Check the filling order via LAStrideStreamIn" << endl;
    LAStrideStreamIn m_str(m,stride);
    assert( !m_str.eof() );
    assert( m_str.bof() );
    double counter = pattern;
    const double stride_incr = incr * stride;
    AREALMark mark = m_str.tell();
    assert( (bool)mark );
    assert( m_str.get_pos(mark) == 
    	    rowcol(m.q_row_lwb(),m.q_col_lwb()) );
    register int stride_counter = 0;
    while( !m_str.eof() )
    {
      assert( m_str.peek() == counter );
      assert( m_str.get() == counter );
      assert( !m_str.bof() );
      counter += stride_incr;
      stride_counter++;
    }
    cout << "\tstrides made: " << stride_counter << endl;
    assert( stride_counter == (m.q_no_elems() + stride -1) / stride );
    assert( stride != 1 || m_str.get_pos(m_str.tell_prev()) ==
    	    rowcol(m.q_row_upb(),m.q_col_upb()) );
    m_str.seek(mark);
    assert( !m_str.eof() );
    assert( m_str.bof() );
    assert( m_str.peek() == pattern );
    assert( m_str.get() == pattern );
  }
  
  {
    cout << "Doubling every " << stride << " element " << endl;
    LAStrideStreamOut m_str(m,stride);
    assert( !m_str.eof() );
    assert( m_str.bof() );
    double counter = pattern;
    const double stride_incr = incr * stride;
    AREALMark mark = m_str.tell();
    assert( (bool)mark );
    assert( m_str.get_pos(mark) == 
    	    rowcol(m.q_row_lwb(),m.q_col_lwb()) );
    while( !m_str.eof() )
    {
      assert( m_str.peek() == counter );
      m_str.get() += counter;
      assert( !m_str.bof() );
      counter += stride_incr;
    }
    cout << "\tand checking it out..." << endl;
    register int stride_counter = 0;
    LAStreamIn m_in(m);
    counter = pattern;
    for(register int i=0; !m_in.eof(); )
    {
      assert( m_in.get() == (i==0 ? stride_counter++, 2*counter : counter) );
      counter += incr;
      if( ++i == stride )
        i = 0;
    }
    cout << "\tstrides made: " << stride_counter << endl;
    assert( stride_counter == (m.q_no_elems() + stride -1) / stride );
    assert( stride != 1 || m_str.get_pos(m_str.tell_prev()) ==
    	    rowcol(m.q_row_upb(),m.q_col_upb()) );
	{
	   cout << "\tchecking it out using regular stream with ignore..." << endl;
	   register int new_stride_counter = 0;
	   LAStreamIn m_in(m);
	   counter = pattern;
	   while( !m_in.eof() )
	   {
		 assert( m_in.get() == (new_stride_counter++, 2*counter) );
		 m_in.ignore(stride-1);
		 counter += stride*incr;
	   }
	   cout << "\tstrides made: " << new_stride_counter << endl;
	   assert( new_stride_counter == stride_counter );
	}
    cout << "\tChecking various seeks" << endl;
    m_str.seek(-stride_counter);
    assert( !m_str.eof() );
    assert( m_str.bof() );
    assert( m_str.peek() == 2*pattern );
    assert( m_str.get() == 2*pattern );
	if( stride_counter == 1 )	// The stride was way too big
	{
  	  m_str.seek(-1,LAS::cur);
	  assert( m_str.get() == 2*pattern );
	}
	else
	{
  	  assert( m_str.get() == 2*(pattern + stride*incr) );
	  m_str.seek(-1,LAS::cur);
      assert( m_str.get() == 2*(pattern + stride*incr) );
	}
	assert( !m_str.bof() );
	m_str.seek(stride_counter-1,LAS::beg);
    assert( m_str.peek() == 2*(pattern + stride*(stride_counter-1)*incr) );
	m_str.ignore(1);
	assert( m_str.eof() );
	m_str.seek(1,LAS::end);
    assert( m_str.get() == 2*(pattern + stride*(stride_counter-1)*incr) );
	assert( m_str.eof() );
	m_str.seek(0,LAS::beg);
    assert( m_str.peek() == 2*pattern );
	m_str.seek(m.q_no_elems(),LAS::cur);
	assert( m_str.eof() );
  }