vlastreams.cc

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

  cout << "\nDone\n";
}


		// Make sure the stream represents an Arithmetic Progression
		// [first_el,next_to_last_el) with a stride incr
static void verify_ap_stream(AREALStreamIn& stream,
			  const double first_el, const double next_to_last_el,
			  const double incr)
{
  double ideal_val = first_el;
  for(; !stream.eof(); ideal_val += incr)
  {
    const REAL stream_val = stream.get();
    if( abs(stream_val - ideal_val) >= FLT_EPSILON )
      _error("verify_ap_stream: a value taken from the stream %g is different "
	     "from the expected %g\n",stream_val,ideal_val);
  }
  if( abs(ideal_val - next_to_last_el) >= FLT_EPSILON )
    _error("verify_ap_stream: the stream ended at %g while %g was expected",
	   ideal_val,next_to_last_el);
}

static void verify_ap_stream(AREALStrideStreamIn& stream,
			  const double first_el, const double next_to_last_el,
			  const double incr)
{
  double ideal_val = first_el;
  for(; !stream.eof(); ideal_val += incr)
  {
    const REAL stream_val = stream.get();
    if( abs(stream_val - ideal_val) >= FLT_EPSILON )
      _error("verify_ap_stream: a value taken from the stream %g is different "
	     "from the expected %g\n",stream_val,ideal_val);
  }
  if( abs(ideal_val - next_to_last_el) >= FLT_EPSILON )
    _error("verify_ap_stream: the stream ended at %g while %g was expected",
	   ideal_val,next_to_last_el);
}


static void test_subranging(const int size)
{
  const double pattern = 4.25;
  const double incr = 1.5;
  cout << "\n---> Test subranging of LAStreams of a " << size
  	   << " -element vector " << endl;
  
  Vector v(-1,size-2);
  {				// Make a test pattern
    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(v).apply(filler(pattern,incr));
    assert( of_every(v) >= pattern );
  }
  
  {
    cout << "\tchecking the verify_ap_stream routine..." << endl;
    LAStreamIn str(v);
    verify_ap_stream(str,pattern,size*incr+pattern,incr);
    assert( str.eof() );
    str.rewind();
    verify_ap_stream(str,pattern,size*incr+pattern,incr);
    LAStreamOut o_str(v);
    verify_ap_stream(o_str,pattern,size*incr+pattern,incr);
    o_str.rewind(); o_str.ignore(1);
    verify_ap_stream(o_str,pattern+incr,size*incr+pattern,incr);
  }
  
  {
    LAStreamIn str(v);
    IRange range_all_total = IRange::from(-IRange::INF);
    cout << "\tchecking subranging of an LAStream by " << range_all_total << endl;
    assert( !range_all_total.q_proper() );
    assert( !range_all_total.q_empty() );
    verify_ap_stream(LAStreamIn(str,range_all_total,LAS::beg),
		     pattern,size*incr+pattern,incr);
    assert( str.bof() );
    verify_ap_stream(LAStreamIn(str,range_all_total,LAS::end),
		     pattern,size*incr+pattern,incr);
    verify_ap_stream(LAStreamIn(str,range_all_total,LAS::cur),
		     pattern,size*incr+pattern,incr);
    LAStreamOut o_str(v);
    IRange range_all1 = IRange::through(IRange::INF);
    verify_ap_stream(LAStreamIn(o_str,range_all1,LAS::cur),
		     pattern,size*incr+pattern,incr);
    assert( o_str.bof() );
    o_str.ignore(1);
    verify_ap_stream(LAStreamOut(o_str,range_all1,LAS::beg),
		     pattern,size*incr+pattern,incr);
  }
  {
    LAStreamIn str(v);
    IRange range(-size-1,size+1);
    cout << "\tchecking subranging of an LAStreamIn by " << range << endl;
    assert( range.q_proper() );
    assert( !range.q_empty() );
    verify_ap_stream(LAStreamIn(str,range,LAS::beg),
		     pattern,size*incr+pattern,incr);
    assert( str.bof() );
    str.ignore(1);
    verify_ap_stream(LAStreamIn(str,range),
		     pattern,size*incr+pattern,incr);
  }
  {
    LAStreamOut str(v);
    IRange range(0,size-1);
    cout << "\tchecking subranging of an LAStreamOut by " << range << endl;
    assert( range.q_proper() );
    assert( !range.q_empty() );
    verify_ap_stream(LAStreamIn(str,range,LAS::beg),
		     pattern,size*incr+pattern,incr);
    assert( str.bof() );
    verify_ap_stream(LAStreamOut(str,range,LAS::end),
		     pattern,pattern,incr);
    str.ignore(1);
    verify_ap_stream(LAStreamOut(str,range,LAS::cur),
		     pattern+incr,size*incr+pattern,incr);
  }
  {
    LAStreamIn str(v);
    IRange range(0,0);
    cout << "\tchecking subranging of an LAStreamIn by " << range << endl;
    assert( range.q_proper() );
    assert( !range.q_empty() );
    verify_ap_stream(LAStreamIn(str,range,LAS::beg),
		     pattern,incr+pattern,incr);
    assert( str.bof() );
    verify_ap_stream(LAStreamIn(str,range,LAS::end),
		     pattern,pattern,incr);
    str.ignore(1);
    verify_ap_stream(LAStreamIn(str,range,LAS::cur),
		     pattern+incr,2*incr+pattern,incr);
  }
  {
    LAStreamIn str(v);
    IRange range(1,1);
    cout << "\tchecking subranging of an LAStreamIn by " << range << endl;
    assert( range.q_proper() );
    assert( !range.q_empty() );
    verify_ap_stream(LAStreamIn(str,range,LAS::beg),
		     incr+pattern,2*incr+pattern,incr);
    assert( str.bof() );
    verify_ap_stream(LAStreamIn(str,range,LAS::end),
		     (size-1)*incr+pattern,size*incr+pattern,incr);
    str.ignore(1);
    verify_ap_stream(LAStreamIn(str,range,LAS::cur),
		     pattern+2*incr,3*incr+pattern,incr);
  }
  {
    LAStreamIn str(v);
    IRange range(-2,-2);
    cout << "\tchecking subranging of an LAStreamIn by " << range << endl;
    assert( range.q_proper() );
    assert( !range.q_empty() );
    str.ignore(3);
    verify_ap_stream(LAStreamIn(str,range,LAS::cur),
		     pattern+incr,2*incr+pattern,incr);
  }
  {
    LAStreamIn str(v);
    IRange range(1,0);
    cout << "\tchecking subranging of an LAStreamIn by " << range << endl;
    assert( !range.q_proper() );
    assert( range.q_empty() );
    verify_ap_stream(LAStreamIn(str,range,LAS::beg),
		     pattern,pattern,incr);
    assert( str.bof() );
    verify_ap_stream(LAStreamIn(str,range,LAS::end),
		     (size-1)*incr+pattern,size*incr+pattern,incr);
    str.ignore(size-1);
    verify_ap_stream(LAStreamIn(str,range,LAS::cur),
		     pattern,pattern,incr);
  }
  {
    Vector v1 = v;
    assert( v1 == v );
    IRange range(1,2);
    cout << "\tchecking modifying via a subranged LAStreamOut by " << range << endl;
    assert( range.q_proper() );
    assert( !range.q_empty() );
    LAStreamOut str1(v1);
    LAStreamOut str2(str1,range,LAS::beg);
    str2.get() += 1;
    str2.get() += 1;
    assert( str2.eof() );
    verify_ap_stream(LAStreamIn(str1,range),
		     pattern+incr+1,3*incr+1+pattern,incr);
    v1(v1.q_lwb()+1) -= 1;
    v1(v1.q_lwb()+2) -= 1;
    assert( v1 == v );
    verify_ap_stream(str1,
		     pattern,size*incr+pattern,incr);
  }
  cout << "\nDone\n";
}

static void test_LAStride_subranging(const int size, const int stride)
{
  const double pattern = 4.25;
  const double incr = 1.5;
  const int nsteps = (size+stride-1)/stride;
  cout << "\n---> Test subranging of LAStrideStream of a " << size
  	   << " -element vector with a stride of " << stride << endl;
  
  Vector v(2,size+1);
  {				// Make a test pattern
    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(v).apply(filler(pattern,incr));
    assert( of_every(v) >= pattern );
  }
  
  {
    LAStrideStreamIn str(v,stride);
    IRange range_all_total = IRange::from(-IRange::INF);
    cout << "\tchecking subranging of an LAStrideStream by " << range_all_total << endl;
    assert( !range_all_total.q_proper() );
    assert( !range_all_total.q_empty() );
    verify_ap_stream(LAStrideStreamIn(str,range_all_total,LAS::beg),
		     pattern,nsteps*stride*incr+pattern,incr*stride);
    assert( str.bof() );
    verify_ap_stream(LAStrideStreamIn(str,range_all_total,LAS::end),
		     pattern,nsteps*stride*incr+pattern,incr*stride);
    verify_ap_stream(LAStrideStreamIn(str,range_all_total,LAS::cur),
		     pattern,nsteps*stride*incr+pattern,incr*stride);
    LAStrideStreamOut o_str(v,stride);
    IRange range_all1 = IRange::through(IRange::INF);
    verify_ap_stream(LAStrideStreamIn(o_str,range_all1,LAS::cur),
		     pattern,nsteps*stride*incr+pattern,incr*stride);
    assert( o_str.bof() );
    o_str.ignore(1);
    verify_ap_stream(LAStrideStreamOut(o_str,range_all1,LAS::beg),
		     pattern,nsteps*stride*incr+pattern,incr*stride);
  }
  {
    LAStrideStreamIn str(v,stride);
    IRange range(-size-1,size+1);
    cout << "\tchecking subranging of an LAStrideStreamIn by " << range << endl;
    assert( range.q_proper() );
    assert( !range.q_empty() );
    verify_ap_stream(LAStrideStreamIn(str,range,LAS::beg),
		     pattern,nsteps*stride*incr+pattern,incr*stride);
    assert( str.bof() );
    str.ignore(1);
    verify_ap_stream(LAStrideStreamIn(str,range),
		     pattern,nsteps*stride*incr+pattern,incr*stride);
  }
  {
    LAStrideStreamOut str(v,stride);
    IRange range(0,nsteps-1);
    cout << "\tchecking subranging of an LAStrideStreamOut by " << range << endl;
    assert( range.q_proper() );
    assert( !range.q_empty() );
    verify_ap_stream(LAStrideStreamIn(str,range,LAS::beg),
		     pattern,nsteps*incr*stride+pattern,incr*stride);
    assert( str.bof() );
    //verify_ap_stream(LAStrideStreamOut(str,range,LAS::end),
    //		     pattern,pattern,incr*stride);
    str.ignore(1);
    if( !str.eof() )
      verify_ap_stream(LAStrideStreamOut(str,range,LAS::cur),
		     pattern+incr*stride,nsteps*incr*stride+pattern,incr*stride);
  }
  {
    LAStrideStreamIn str(v,stride);
    IRange range(0,0);
    cout << "\tchecking subranging of an LAStrideStreamIn by " << range << endl;
    assert( range.q_proper() );
    assert( !range.q_empty() );
    verify_ap_stream(LAStrideStreamIn(str,range,LAS::beg),
		     pattern,incr*stride+pattern,incr*stride);
    assert( str.bof() );
    //verify_ap_stream(LAStrideStreamIn(str,range,LAS::end),
    //		     pattern,pattern,incr*stride);
    str.ignore(1);
    if( !str.eof() )
      verify_ap_stream(LAStrideStreamIn(str,range,LAS::cur),
		     pattern+incr*stride,2*incr*stride+pattern,incr*stride);
  }
  if( nsteps > 1 )
  {
    LAStrideStreamIn str(v,stride);
    IRange range(1,1);
    cout << "\tchecking subranging of an LAStrideStreamIn by " << range << endl;
    assert( range.q_proper() );
    assert( !range.q_empty() );