spline_test.cxx

Go to the documentation of this file.

#include <cxxtls/spline.h>
#include <iostream>
#include <vector>

using namespace std;
using namespace cxxtls;


template<typename X>
struct doubler
{
  X operator() (typename spline<X,X>::sample_t const &r) const
  {
    return (r.second * 2);
  }
};

template<class X, class Y, class Z>
ostream &operator<< (ostream &cout, spline<X,Y,Z> const &sf)
{
  typedef typename spline<X,Y,Z>::const_iterator const_iterator;

  const_iterator l = sf.begin(), g = sf.end();

  while(l != g)
  {
    cout << "(" << l->first << "," << l->second << ")";
    ++l;
  }

  return cout;
}

template<class T>
ostream& operator<< (ostream& cout, set<T> const &s)
{
  typename set<T>::const_iterator l = s.begin(), g = s.end();

  while(l != g)
  {
    T const &r = *l++;
    
    cout << r;

    if( l != g )
      cout << ", ";

  }

  return cout;
}

int main()
{
  typedef spline<float,float>          Function;
  typedef Function::sample_t           sample_t;
  typedef Function::const_iterator     const_iterator;

  Function sf;

  sf.add_sample( sample_t(1,1) );
  sf.add_sample( sample_t(2,2) );
  sf.add_sample( sample_t(3,3) );

  cout << "Original Data: " << sf << std::endl;

  sf.apply(doubler<float>());

  cout << "After doubling: " << sf << std::endl;

  std::set<float> domain;  sf.domain(&domain);

  cout << "Sampled X's:  " << domain << std::endl;

  {
    Function t;

    for(float x = 0; x < 5; x += .5)
    {
      sample_t tmp(x, sf.interpolate_step(x));

      t.add_sample(tmp);
    }

    cout << "Interpolating stepwise[0-4.5 by .5]: " << t << std::endl;

  }

  {
    cout << "Floor and Ceil: ";

    for(float x = 0; x < 5; x += .5)
    {
      const_iterator f = sf.floor(x);
      const_iterator l = sf.ceil(x);

      float a;
      float b;

      if(f == sf.end())
       a = sf.front().first;
      else
       a = f->first;

      if(l == sf.end())
        b = sf.back().first;
      else
        b = l->first;

      cout << x << "[" << a << "-" << b << "],";


    }

    cout << std::endl;

  }


  {
    spline<float,float> t;

    for(float x = 0; x < 5; x += .5)
    {
      sample_t tmp(x, sf.interpolate_line(x));

      t.add_sample(tmp);
    }

    cout << "Interpolating linearly[0-4.5 by .5]:\n   " << t << std::endl;

  }


  {
    static std::pair<int,int> samples[] =
    {
      std::pair<int,int>(1,5),
      std::pair<int,int>(2,10),
      std::pair<int,int>(3,8)
    };

    Function func(samples, samples+3, &Function::interpolate_line);

    cout << "construct from array test:\n  ";

    for(float f = 0; f < 5; f += 1)
    {
      cout << "(" << f << ", " << func(f) << ")";

    }

    cout << std::endl;

    static std::pair<int,int> samples_2[] =
    {
      std::pair<int,int>(4,7),
      std::pair<int,int>(5,6),
      std::pair<int,int>(6,5)
    };

    func.include(samples_2, samples_2+3);

    cout << "including more points gives:\n  " << func << std::endl;

    spline<int,int> sint;  
    sint.add_sample(spline<int,int>::sample_t(7,3));
    sint.add_sample(spline<int,int>::sample_t(8,1));

    func.include(sint);

    cout << "including another spline:\n  " << func << std::endl;

    spline<int,double> id(func,&spline<int,double>::interpolate_line);

    cout << "copy constructor templates:\n  " << id << std::endl;

    spline<int,double> id2(id);

    cout << "real copy constructor:\n  " << id2 << std::endl;

    spline<int,double> id3;

    id3 = id2;

    cout << "operator= gives:\n  " << id3 << std::endl;


  }

  {
    typedef spline<int,int>     one_t;

    one_t one(&one_t::interpolate_line);  
      one.add_sample( one_t::sample_t(1,1) );
      one.add_sample( one_t::sample_t(3,4) );
      one.add_sample( one_t::sample_t(5,8) );

    one_t two(&one_t::interpolate_line);
      two.add_sample( one_t::sample_t(2,2) );
      two.add_sample( one_t::sample_t(4,4) );
      two.add_sample( one_t::sample_t(6,6) );

    one += two;

    cout << "Adding (1,1)(3,4)(5,8) with (2,2)(4,4)(6,6) gives:\n" 
         << "  " 
         << one 
         << endl;

  }

  {
    typedef spline<int,int>     one_t;

    one_t one(&one_t::interpolate_line);  
      one.add_sample( one_t::sample_t(1,4) );
      one.add_sample( one_t::sample_t(3,8) );
      one.add_sample( one_t::sample_t(5,12) );

    one_t two(&one_t::interpolate_line);
      two.add_sample( one_t::sample_t(0,2) );
      two.add_sample( one_t::sample_t(6,2) );

    one /= two;

    cout << "Dividing (1,4)(3,8)(5,12) by (0,2)(6,2) gives:\n"
         << "  " 
         << one 
         << endl;

  }

  {
    typedef spline<int,int>     one_t;

    one_t one(&one_t::interpolate_line);  
      one.add_sample( one_t::sample_t(1,4) );
      one.add_sample( one_t::sample_t(3,8) );
      one.add_sample( one_t::sample_t(5,12) );

    
    vector< pair<int,int> > tmp(10);

    one.evaluate(0,1, tmp.begin(), tmp.end());

    int i;

    cout << "10 steps of the evaluate function give:\n  ";

    for(i=0; i < 10; ++i)
      cout << "(" << tmp[i].first << "," << tmp[i].second << ")";

    cout << endl;

  }

  {
    typedef spline<double,double>     one_t;
    
    one_t one(&one_t::interpolate_cubic);  
      one.add_sample( one_t::sample_t(1,4) );
      one.add_sample( one_t::sample_t(3,8) );
      one.add_sample( one_t::sample_t(5,12) );

    
    vector< pair<double,double> > tmp(10);

    one.evaluate(0,1, tmp.begin(), tmp.end());

    int i;

    cout << "10 steps of the cubic evaluate function give:\n  ";

    for(i=0; i < 10; ++i)
      cout << "(" << tmp[i].first << "," << tmp[i].second << ")";

    cout << endl;
  }


  return 0;
}