/*
	Montre l'usage de l'évaluation déférée pour augmenter la vitesse des calculs
	sur un vecteur.

	vector a  = vector b * N + vector c * vector d
*/
#include <stdio.h>
#include <stdlib.h>
#include "getnow.h"
#include <vector>
#include <functional>

using namespace std;

namespace DEFER{
template<typename T1, typename T2>
class BASEOPER{
protected:
	const T1 &t1;
	const T2 &t2;
public:
	//using value_type = sizeof(T1)>sizeof(T2) ? typename T1::value_type : typename T2::value_type;
	using value_type = typename T1::value_type;
	BASEOPER(const T1 &_t1, const T2 &_t2)
		:t1(_t1),t2(_t2){
		if (t1.size() != t2.size()){
			fprintf (stderr,"taille invalide pour les 2 vecteurs: %zu != %zu\n",t1.size(),t2.size());
		}
	}	
	size_t size() const {
		return t1.size();
	}
};

template<typename T1, typename T2>
class OPERMULT: public BASEOPER<T1,T2>{
public:
	OPERMULT(const T1 &_t1, const T2 &_t2): BASEOPER<T1,T2>(_t1,_t2){}
	typename BASEOPER<T1,T2>::value_type operator [] (int n) const {
		return this->t1[n] * this->t2[n];
	}
	operator vector<typename BASEOPER<T1,T2>::value_type> () const{
		vector<typename BASEOPER<T1,T2>::value_type> t1;
		for (size_t i=0; i<this->size(); i++) t1.push_back((*this)[i]);
		return t1;
	}
};

template<typename T1, typename T2>
auto operator * (const T1 &t1, const T2 &t2)
{
	return OPERMULT(t1,t2);
}
template<typename T1, typename T2>
class OPERPLUS: public BASEOPER<T1,T2>{
public:
	OPERPLUS(const T1 &_t1, const T2 &_t2): BASEOPER<T1,T2>(_t1,_t2){}
	double operator [] (int n) const {
		return this->t1[n] + this->t2[n];
	}
	operator vector<double> () const{
		vector<double> t1;
		for (size_t i=0; i<this->size(); i++) t1.push_back((*this)[i]);
		return t1;
	}
};

template<typename T1, typename T2>
auto operator + (const T1 &t1, const T2 &t2)
{
	return OPERPLUS(t1,t2);
}
}

namespace DEFER2{
template<typename T1, typename T2, typename T3>
class BASEOPER{
public:
	using value_type = typename T1::value_type;
protected:
	const T1 &t1;
	const T2 &t2;
public:
	BASEOPER(const T1 &_t1, const T2 &_t2)
		:t1(_t1),t2(_t2){
		if (t1.size() != t2.size()){
			fprintf (stderr,"taille invalide pour les 2 vecteurs: %zu != %zu\n",t1.size(),t2.size());
		}
	}	
	size_t size() const {
		return t1.size();
	}
	value_type operator [] (int n) const {
		return static_cast<const T3*>(this)->func(t1[n],t2[n]);
	}
	operator vector<value_type> () const{
		vector<value_type> t1;
		for (size_t i=0; i<size(); i++) t1.push_back((*this)[i]);
		return t1;
	}
};

template<typename T1, typename T2>
class OPERMULT: public BASEOPER<T1,T2,OPERMULT<T1,T2>>{
public:
	using value_type = typename BASEOPER<T1,T2,OPERMULT<T1,T2>>::value_type;
	value_type func(value_type p1, value_type p2) const{
		return p1*p2;
	}
	OPERMULT(const T1 &_t1, const T2 &_t2): BASEOPER<T1,T2,OPERMULT<T1,T2>>(_t1,_t2){}
};

template<typename T1, typename T2>
auto operator * (const T1 &t1, const T2 &t2)
{
	return OPERMULT(t1,t2);
}
template<typename T1, typename T2>
class OPERPLUS: public BASEOPER<T1,T2,OPERPLUS<T1,T2>>{
public:
	using value_type = typename BASEOPER<T1,T2,OPERPLUS<T1,T2>>::value_type;
	value_type func(value_type p1, value_type p2) const{
		return p1+p2;
	}
	OPERPLUS(const T1 &_t1, const T2 &_t2): BASEOPER<T1,T2,OPERPLUS<T1,T2>>(_t1,_t2){}
};

template<typename T1, typename T2>
auto operator + (const T1 &t1, const T2 &t2)
{
	return OPERPLUS(t1,t2);
}
}
namespace NONDEFER{
	auto operator *(const vector<double> &t1, const vector<double> &t2)
	{
		vector<double> ret;
		for (size_t i=0; i<t1.size(); i++) ret.push_back(t1[i]*t2[i]);
		return ret;
	}
	auto operator +(const vector<double> &t1, const vector<double> &t2)
	{
		vector<double> ret;
		for (size_t i=0; i<t1.size(); i++) ret.push_back(t1[i]+t2[i]);
		return ret;
	}
}

static void test_defer(vector<double> &a, vector<double> &b, bool print)
{
	using namespace DEFER;
	auto start = getnow();
	auto r = (a+b)*(a+b);
	double somme = 0;
	for (size_t i=0; i<r.size(); i++) somme += r[i];
	showtime ("defer",start,getnow());
	printf ("somme = %lf\n",somme);
	if (print) for (size_t i=0; i<r.size(); i++) fprintf (stderr,"%lf\n",r[i]);

}
static void test_defer2(vector<double> &a, vector<double> &b, bool print)
{
	using namespace DEFER2;
	auto start = getnow();
	auto r = (a+b)*(a+b);
	double somme = 0;
	for (size_t i=0; i<r.size(); i++) somme += r[i];
	showtime ("defer2",start,getnow());
	printf ("somme = %lf\n",somme);
	if (print) for (size_t i=0; i<r.size(); i++) fprintf (stderr,"%lf\n",r[i]);

}
static void test_nondefer(vector<double> &a, vector<double> &b, bool print)
{
	using namespace NONDEFER;
	auto start = getnow();
	vector<double> r = (a+b)*(a+b);
	showtime ("nondefer",start,getnow());
	double somme = 0;
	for (size_t i=0; i<r.size(); i++) somme += r[i];
	printf ("somme = %lf\n",somme);
	if (print) for (auto n:r) fprintf (stderr,"%lf\n",n);

}

int main (int argc, char *argv[])
{
	int nb = 3;
	if (argc == 2) nb = atoi(argv[1]);
	vector<double> a;
	for (int i=1; i<=nb; i++) a.push_back(i);
	vector<double> b = a;

	for (int i=0; i<1; i++){
		test_defer(a,b,nb < 10);
		test_defer2(a,b,nb < 10);
		test_nondefer(a,b,nb < 10);
	}
	if (0){
		using namespace DEFER;
		vector<double> r = a * b;
		for (auto n:r) printf ("%lf\n",n);
		r = a + b;
		for (auto n:r) printf ("%lf\n",n);
		r = (a + b)*(a+b);
		for (auto n:r) printf ("%lf\n",n);
	}	
	if (0){
		using namespace NONDEFER;
		vector<double> r = a * b;
		for (auto n:r) printf ("%lf\n",n);
		r = a + b;
		for (auto n:r) printf ("%lf\n",n);
		r = (a + b)*(a+b);
		for (auto n:r) printf ("%lf\n",n);
	}	
	return 0;
}