//============================================================================
// Name        : conversionV2.cpp
// Author      : Lucas Freitas
// Version     :
// Copyright   : All rights reserved
// Description : Hello World in C, Ansi-style
//============================================================================

#include <stdio.h>
#include <stdlib.h>
#include "Domain/SimplexPoint.h"
#include "Domain/SimploidPoint.h"
#include "Domain/AffineTransformation.h"
#include "Index/MultiIdx.h"
#include "Index/MatrixIdx.h"
#include "MathFunction/Bernstein.h"


int main(int argc, const char* argv[]) {
	
	//std::vector<Index::MatrixIdx*> v;
	//std::vector<Index::MatrixIdx*>::iterator iter;
		
	std::vector<Index::MultiIdx*> v2;
	std::vector<Index::MultiIdx*>::iterator iter2;
		
	Index::MultiIdx* i;
	FILE *fp ;
		char filename[100];
		int type[2];
		type[0]=1;
		type[1]=1;
		Index::MultiIdx* g;
		
		double *dv1,*dv2,*dv3;
		dv1 = new double[3];
		dv1[0]= 0.5;
		dv1[1]= 0.5;
		dv1[2]= 0.0;

		dv2 = new double[3];
		dv2[0]= 0.0;
		dv2[1]= 0.5;
		dv2[2]= 0.5;

		dv3 = new double[3];
		dv3[0]= 0.5;
		dv3[1]= 0.0;
		dv3[2]= 0.5;

		Domain::SimplexPoint* spx1 = Domain::SimplexPoint::fromDoubleVector(dv1,2);
		//spx1->print(stderr);

		Domain::SimplexPoint* spx2 = Domain::SimplexPoint::fromDoubleVector(dv2,2);
		//spx2->print(stderr);

		Domain::SimplexPoint* spx3 = Domain::SimplexPoint::fromDoubleVector(dv3,2);
		//spx3->print(stderr);
		

		
		std::vector<Domain::SimplexPoint*> v;
		std::vector<Domain::SimplexPoint*>::iterator iter;
		
		Domain::AffineTransformation *T;
		Domain::SimplexPoint** spxvec;
		spxvec = new Domain::SimplexPoint*[3];
		spxvec[0] = spx1;
		spxvec[1] = spx2;
		spxvec[2] = spx3;
		
		
		//T = Domain::AffineTransformation::getIdentity(2,2);
		//T->v->coord[0] = 
		
		//T = Domain::AffineTransformation::getFromImage(spxvec,3);
		T = Domain::AffineTransformation::getExample2();
		//T->print(stderr);

		//(T->AffineTransformation::transform(new SimplexPoint(2)))->print(stderr);
		
		
		
		v2 = Index::MultiIdx::getMultiIdxSet(3,3);
		fp = fopen("/tmp/t","w");
		
		for(iter2=v2.begin();iter2!= v2.end();iter2++)
		{
			//i = (*iter2);
			//i = new Index::MultiIdx(3);
			//i->idx[0] = 1;
			//i->idx[1] = 1;
			//i->idx[2] = 1;
			
			//g = new Index::MultiIdx(2);
			//g->idx[0] = 2;
			//g->idx[1] = 3;
			
			
			//sprintf(filename,"dataPiece_%d,%d",i->idx[0],i->idx[1]);
		
			//fp = fopen(filename,"w");
			
			//fprintf(stderr,"%d--\n",i->factorial());
			
			Domain::SimplexPoint::datafp = fp;
			
			//v = SimploidPoint::SimploidPoint::domainPoints(2,type,100);
			
			//v = Domain::SimplexPoint::domainPoints(2,100);
			
			//v = Index::MatrixIdx::MatrixIdx::getAllIndexes(i,g);
					
			
			//for(iter=v.begin();iter!= v.end();iter++)
			{
				//(*iter)->print(stderr);
				//(*iter)->print(stderr);
				//((TensorPoint*)(*iter))->printPlot(TensorPoint::Bernstein(g,i,((TensorPoint*)(*iter))));
				
				//((TensorPoint*)(*iter))->printPlot(TensorPoint::TensorPoint::BernsteinUsingSimplicial(g,i,((TensorPoint*)(*iter))));
				
				
				//fprintf(stderr,"%g\n",(SimplexPoint::BernesteinDegElev(3,i,5,(*iter)) - 
						//SimplexPoint::Bernestein(3,i,(*iter))));
				
				//spx1 = (*iter);
				//spx1 = T->transform((*iter));
				//spx1->printPlot(MathFunction::Bernstein::Bernstein::evalSimplicial(3,i,(spx1)));
				
				//spx1->printPlot(MathFunction::Bernstein::Bernstein::evalSimplicialUsingTensorV2(3,(*iter2),(spx1)));
				//MathFunction::Bernstein::Bernstein::eqTensor2Simplicial(3,(*iter2))->print(stderr);
				//break;
				//T->print(stderr);
				
				//spx1->printPlot(MathFunction::Bernstein::evalSimplicialUsingSimplicial(3,i,T,(*iter)));
				
				
				//(*iter)->printPlot(SimplexPoint::SimplexPoint::SimplexPoint::BernsteinUsingTensor(3,i,(*iter)));
			}
		}
			
			
		//fprintf(stderr,"\nend\n");
	
	
	puts("Hello World!!!");
	return EXIT_SUCCESS;
}