/***************************************************************************
 *   Copyright (C) 2006 by Nicolas PASCAL   *
 *   pascal@icare-pc12   *
 *                                                                         *
 *   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.             *
 ***************************************************************************/

#include "tools.h"
#include "statistic.h"
#include <cstdio>
#include <cmath>

using namespace std;

int main(int argc, char *argv[]) {

    /** decompose an integer in tens digits */
    unsigned int n = 1977;
    vector <unsigned short> v = MyTools::get_digits (n);
    printf ("%u -> ", n);
    MyTools::print_vec (v);

    n = 549684135;
    v = MyTools::get_digits (n);
    printf ("%u -> ", n);
    MyTools::print_vec (v);

//     typedef vector<float> Point;
//     typedef vector<Point> Line;
//
//     /*** test 2D intersection algorithm ***/
//     Point p1(2); Point p2(2); // 2 points that define the 2nd line
//     Line l1; // the 2nd line
//     Point p3(2); Point p4(2); // 2 points that define the 2nd line
//     Line l2; // the 2nd line
//     Point intersection(2); // the intersection point
//
//     // normal case -> should be (2,4)
//     p1[0]= 2.; p1[1]=6.; l1.push_back(p1);
//     p2[0]= 2.; p2[1]=1.; l1.push_back(p2);
//     p3[0]=-2.; p3[1]=4.; l2.push_back(p3);
//     p4[0]= 4.; p4[1]=4.; l2.push_back(p4);
//     if (MyTools::get_intersection(l1,l2,intersection)) //
//         cout<<"intersection between Line("<<p1[0]<<","<<p1[1]<<";"<<p2[0]<<","<<p2[1]<<") and Line("<<p3[0]<<","<<p3[1]<<";"<<p4[0]<<","<<p4[1]<<") -> ("<<intersection[0]<<","<<intersection[1]<<")"<<endl;
//     else
//         cout<<"Line("<<p1[0]<<","<<p1[1]<<";"<<p2[0]<<","<<p2[1]<<") and Line("<<p3[0]<<","<<p3[1]<<";"<<p4[0]<<","<<p4[1]<<") are parallels"<<endl;
//
//     // another normal case -> should be (1.5,2.5)
//     l1.clear();l2.clear();
//     p1[0]=-3.5;p1[1]=7.5; l1.push_back(p1);
//     p2[0]=4.5;p2[1]=-0.5; l1.push_back(p2);
//     p3[0]=-2.5;p3[1]=-1.5; l2.push_back(p3);
//     p4[0]=5.5;p4[1]=6.5; l2.push_back(p4);
//     if (MyTools::get_intersection(l1,l2,intersection)) //
//         cout<<"intersection between Line("<<p1[0]<<","<<p1[1]<<";"<<p2[0]<<","<<p2[1]<<") and Line("<<p3[0]<<","<<p3[1]<<";"<<p4[0]<<","<<p4[1]<<") -> ("<<intersection[0]<<","<<intersection[1]<<")"<<endl;
//     else
//         cout<<"Line("<<p1[0]<<","<<p1[1]<<";"<<p2[0]<<","<<p2[1]<<") and Line("<<p3[0]<<","<<p3[1]<<";"<<p4[0]<<","<<p4[1]<<") are parallels"<<endl;
//
//     // 2 parallel lines
//     l1.clear();l2.clear();
//     p1[0]=2.;p1[1]=2.; l1.push_back(p1);
//     p2[0]=1.;p2[1]=1.; l1.push_back(p2);
//     p3[0]=0.;p3[1]=1.; l2.push_back(p3);
//     p4[0]=1.;p4[1]=2.; l2.push_back(p4);
//     if (MyTools::get_intersection(l1,l2,intersection)) //
//         cout<<"intersection between Line("<<p1[0]<<","<<p1[1]<<";"<<p2[0]<<","<<p2[1]<<") and Line("<<p3[0]<<","<<p3[1]<<";"<<p4[0]<<","<<p4[1]<<") -> ("<<intersection[0]<<","<<intersection[1]<<")"<<endl;
//     else
//         cout<<"Line("<<p1[0]<<","<<p1[1]<<";"<<p2[0]<<","<<p2[1]<<") and Line("<<p3[0]<<","<<p3[1]<<";"<<p4[0]<<","<<p4[1]<<") are parallels"<<endl;

    // test find_first_of method
//     float v[]={1.5,5.8,6.,1.2,5.6,8.1};
//     int v_size=(sizeof(v)/sizeof(float));
//     float val;
//     float* pval=NULL;
// //  pval=find_first_of<float>(v+0,v+(sizeof(v)/sizeof(float)),val);
//     cout<<"In Vector "<<endl;
//     for (int i=0;i<v_size;++i)
//       cout<<v[i]<<"\t";
//     cout<<endl<<endl;
//
//     val=1.2;
//     pval=MyTools::find_first_of(v,v+v_size,val);
//     cout<<val<<"->"<<distance(v,pval)<<endl; // should be 3

//     val=8.1;
//     pval=find_first_of(v+0,v+(sizeof(v)/sizeof(float)),&val,&val+1);
//     cout<<val<<"->"<<distance(v,pval)<<endl; // should be 5
//
//     val=9.3;
//     pval=find_first_of(v+0,v+(sizeof(v)/sizeof(float)),&val,&val+1);
//     cout<<val<<"->"<<distance(v,pval)<<endl; // should be 6 ?

  /**************** TEST INTERPOLATION METHOD ****************/

   // --- on increasing sorted arrays ---

//    // using C arrays
//     float v1[]={1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
//     float val1=5.6;
//     double v2[]={1.,4.,2.,7.,8.,1.,2.,8.,0.};
//     double val2;
//    interpolate(v1,v1+9,v2,v2+9,val1,val2);
//    cout<<"intepolation of "<<val1<<" : "<<val2<<endl;
//
//    // using STL vectors
//    vector<float> v_stl_1;
//    v_stl_1.push_back(1.1);
//    v_stl_1.push_back(2.2);
//    v_stl_1.push_back(3.3);
//    v_stl_1.push_back(4.4);
//    v_stl_1.push_back(5.5);
//    v_stl_1.push_back(6.6);
//    v_stl_1.push_back(7.7);
//    v_stl_1.push_back(8.8);
//    v_stl_1.push_back(9.9);
//
//    vector<double> v_stl_2;
//    v_stl_2.push_back(1.);
//    v_stl_2.push_back(4.);
//    v_stl_2.push_back(2.);
//    v_stl_2.push_back(7.);
//    v_stl_2.push_back(8.);
//    v_stl_2.push_back(1.);
//    v_stl_2.push_back(2.);
//    v_stl_2.push_back(8.);
//    v_stl_2.push_back(0.);
//
//    interpolate(v_stl_1.begin(),v_stl_1.end(),v_stl_2.begin(),v_stl_2.end(),val1,val2);
//    cout<<"interpolation of "<<val1<<" : "<<val2<<endl;
//
//    // --- on decreasing sorted arrays ---
//    reverse(v1,v1+9);
//    reverse(v2,v2+9);
//
//    for (int i=0;i<9;++i)
//      cout<<v1[i]<<"\t";
//    cout<<endl;
//
//    // using C arrays
//    interpolate(v1,v1+9,v2,v2+9,val1,val2);
//    cout<<"intepolation of "<<val1<<" : "<<val2<<endl;

//   int myints[] = {10,10,10,10,20,20,30,30};
//   vector<int> v(myints,myints+8);
//   vector<int>::iterator low,up;
//
// low=lower_bound (v.begin(), v.end(), 15);
// cout<<low-v.begin()<<endl;
//
//     // test get_nearest_index in statistics.h method
//     cout<<"---------- ascending order ----------"<<endl;
//     float v1_ascending[]={1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
//     cout<<"v=[";
//     for (int i=0;i<9;++i)
//       cout<<v1_ascending[i]<<",";
//     cout<<"]"<<endl;
//     float val=0.2;
//     int val_idx;
//     val_idx=get_nearest_val_idx(v1_ascending,v1_ascending+9,val);
//     cout<<"Nearest value to "<<val<<" : idx "<<val_idx<<" val "<<v1_ascending[val_idx]<<endl; // should be 0
//     // test lower limit
//     val=3.4;
//     val_idx=get_nearest_val_idx(v1_ascending,v1_ascending+9,val);
//     cout<<"Nearest value to "<<val<<" : idx "<<val_idx<<" val "<<v1_ascending[val_idx]<<endl; // should be 2
//     // test upper limit
//     val=10.3;
//     val_idx=get_nearest_val_idx(v1_ascending,v1_ascending+9,val);
//     cout<<"Nearest value to "<<val<<" : idx "<<val_idx<<" val "<<v1_ascending[val_idx]<<endl; // should be 8
//
//     cout<<"---------- descending order ----------"<<endl;
//     float v1_descending[]={9.9,8.8,7.7,6.6,5.5,4.4,3.3,2.2,1.1};
//     cout<<"v=[";
//     for (int i=0;i<9;++i)
//       cout<<v1_descending[i]<<",";
//     cout<<"]"<<endl;
//     val=0.2;
//     val_idx=get_nearest_val_idx(v1_descending,v1_descending+9,val);
//     cout<<"Nearest value to "<<val<<" : idx "<<val_idx<<" val "<<v1_descending[val_idx]<<endl; // should be 0
//     // test lower limit
//     val=3.4;
//     val_idx=get_nearest_val_idx(v1_descending,v1_descending+9,val);
//     cout<<"Nearest value to "<<val<<" : idx "<<val_idx<<" val "<<v1_descending[val_idx]<<endl; // should be 2
//     // test upper limit
//     val=10.3;
//     val_idx=get_nearest_val_idx(v1_descending,v1_descending+9,val);
//     cout<<"Nearest value to "<<val<<" : idx "<<val_idx<<" val "<<v1_descending[val_idx]<<endl; // should be 8
//     return 0;

// // // //     // --- test get_abscissa function
// // // //     float v_abs_0_val [] = { };
// // // //     float v_abs_1_val [] = { 0.1 };
// // // //     float v_abs_asc [] = { 0., 1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9 };
// // // //     float v_abs_dsc [] = { 9.9,8.8,7.7,6.6,5.5,4.4,3.3,2.2,1.1, 0. };
// // // //     float * v_abs;
// // // //     int sz = 10;
// // // //     float v, interp_v;
// // // //     double abs;
// // // //     double fractpart, intpart;
// // // //     int ilow, iup, i;
// // // //
// // // //     // --- test case : empty and 1 value abscissa vector
// // // //     printf ( "--- bad abscissa vectors ---\n" );
// // // //     v_abs = v_abs_0_val;
// // // //     sz = 0;
// // // //     printf ( "v_abs = [ " );
// // // //     for ( i = 0 ; i < sz ; ++i ) {
// // // //         printf ( "%f", v_abs [ i ] );
// // // //         if ( i < ( sz - 1 ) )
// // // //             printf ( ", " );
// // // //     }
// // // //     printf ( "]\n" );
// // // //     v = 0.;
// // // //     abs = MyTools::get_abscissa ( v, v_abs, sz );
// // // //     printf ( "v=%f\tabs=%f\t\n", v, abs );
// // // //
// // // //     v_abs = v_abs_1_val;
// // // //     sz = 1;
// // // //     printf ( "v_abs = [ " );
// // // //     for ( i = 0 ; i < sz ; ++i ) {
// // // //         printf ( "%f", v_abs [ i ] );
// // // //         if ( i < ( sz - 1 ) )
// // // //             printf ( ", " );
// // // //     }
// // // //     printf ( "]\n" );
// // // //     v = 0.;
// // // //     abs = MyTools::get_abscissa ( v, v_abs, sz );
// // // //     printf ( "v=%f\tabs=%f\t\n", v, abs );
// // // //
// // // //     // --- ascending order
// // // //     sz = 10;
// // // //     printf ( "--- ascending order ---\n" );
// // // //     v_abs = v_abs_asc;
// // // //     printf ( "v_abs = [ " );
// // // //     for ( i = 0 ; i < sz ; ++i ) {
// // // //         printf ( "%f", v_abs [ i ] );
// // // //         if ( i < ( sz - 1 ) )
// // // //             printf ( ", " );
// // // //     }
// // // //     printf ( "]\n" );
// // // //
// // // //     // -> general case : val inside v_abs range
// // // //     v = 3.;
// // // //     abs = MyTools::get_abscissa ( v, v_abs, sz );
// // // //     // recompute v using float abscissa
// // // //     fractpart = modf ( abs , &intpart );
// // // //     ilow = ( int ) ( intpart );
// // // //     iup  = ilow + 1;
// // // //     interp_v  = v_abs [ ilow ] + fractpart * ( v_abs [ iup ] - v_abs [ ilow ] );
// // // //     printf ( "v=%f\tabs=%f\tinterp_v=%f\n", v, abs, interp_v );
// // // //
// // // //     // -> val outside bounds
// // // //     v = -0.1;
// // // //     abs = MyTools::get_abscissa ( v, v_abs, sz );
// // // //     // recompute v using float abscissa
// // // //     fractpart = modf ( abs , &intpart );
// // // //     ilow = ( int ) ( intpart );
// // // //     iup  = ilow + 1;
// // // //     interp_v  = v_abs [ ilow ] + fractpart * ( v_abs [ iup ] - v_abs [ ilow ] );
// // // //     printf ( "v=%f\tabs=%f\tinterp_v=%f\n", v, abs, interp_v );
// // // //
// // // //     v = 10.;
// // // //     abs = MyTools::get_abscissa ( v, v_abs, sz );
// // // //     // recompute v using float abscissa
// // // //     fractpart = modf ( abs , &intpart );
// // // //     ilow = ( int ) ( intpart );
// // // //     iup  = ilow + 1;
// // // //     interp_v  = v_abs [ ilow ] + fractpart * ( v_abs [ iup ] - v_abs [ ilow ] );
// // // //     printf ( "v=%f\tabs=%f\tinterp_v=%f\n", v, abs, interp_v );
// // // //
// // // //     // --- descending order
// // // //     printf ( "--- descending order ---\n" );
// // // //     v_abs = v_abs_dsc;
// // // //     printf ( "v_abs = [ " );
// // // //     for ( i = 0 ; i < sz ; ++i ) {
// // // //         printf ( "%f", v_abs [ i ] );
// // // //         if ( i < ( sz - 1 ) )
// // // //             printf ( ", " );
// // // //     }
// // // //     printf ( "]\n" );
// // // //
// // // //     // -> general case : val inside v_abs range
// // // //     v = 3.;
// // // //     abs = MyTools::get_abscissa ( v, v_abs, sz );
// // // //     // recompute v using float abscissa
// // // //     fractpart = modf ( abs , &intpart );
// // // //     ilow = ( int ) ( intpart );
// // // //     iup  = ilow + 1;
// // // //     interp_v  = v_abs [ ilow ] + fractpart * ( v_abs [ iup ] - v_abs [ ilow ] );
// // // //     printf ( "v=%f\tabs=%f\tinterp_v=%f\n", v, abs, interp_v );
// // // //
// // // //     // -> val outside bounds
// // // //     v = 10.;
// // // //     abs = MyTools::get_abscissa ( v, v_abs, sz );
// // // //     // recompute v using float abscissa
// // // //     fractpart = modf ( abs , &intpart );
// // // //     ilow = ( int ) ( intpart );
// // // //     iup  = ilow + 1;
// // // //     interp_v  = v_abs [ ilow ] + fractpart * ( v_abs [ iup ] - v_abs [ ilow ] );
// // // //     printf ( "v=%f\tabs=%f\tinterp_v=%f\n", v, abs, interp_v );
// // // //
// // // //     v = -0.1;
// // // //     abs = MyTools::get_abscissa ( v, v_abs, sz );
// // // //     // recompute v using float abscissa
// // // //     fractpart = modf ( abs , &intpart );
// // // //     ilow = ( int ) ( intpart );
// // // //     iup  = ilow + 1;
// // // //     interp_v  = v_abs [ ilow ] + fractpart * ( v_abs [ iup ] - v_abs [ ilow ] );
// // // //     printf ( "v=%f\tabs=%f\tinterp_v=%f\n", v, abs, interp_v );



}