Commit 91912478 authored by Alvarez, Gonzalo's avatar Alvarez, Gonzalo
Browse files

vector indentation

parent 6a25c6e9

src/Vector.h

+128 −125
Original line number Diff line number Diff line
@@ -36,7 +36,7 @@ Please see full open source license included in file LICENSE. 
namespace std {



template<typename T1,typename T2>

inline std::istream& operator>>(std::istream& is,std::pair<T1,T2>& v)

istream& operator>>(istream& is,pair<T1,T2>& v)

{

	is>>v.first;

	is>>v.second;
@@ -44,7 +44,7 @@ inline std::istream& operator>>(std::istream& is,std::pair<T1,T2>& v) 
}



template<typename X,typename A>

inline X operator*(const std::vector<X,A>& v,const std::vector<X,A>& w)

X operator*(const vector<X,A>& v,const vector<X,A>& w)

{

	X result=0;

	for (SizeType i=0;i<v.size();i++) result += v[i]*conj(w[i]);
@@ -52,7 +52,7 @@ inline X operator*(const std::vector<X,A>& v,const std::vector<X,A>& w) 
}



template<typename A>

inline bool operator==(const std::vector<SizeType,A>& v, const std::vector<SizeType,A>& w)

bool operator==(const vector<SizeType,A>& v, const vector<SizeType,A>& w)

{

	if (v.size() != w.size()) return false;

	for (SizeType i = 0; i < v.size(); ++i)
@@ -62,10 +62,10 @@ inline bool operator==(const std::vector<SizeType,A>& v, const std::vector<SizeT 
}



template<typename T1,typename T2,typename A,typename AA>

inline std::vector<T2,A> operator*(const std::vector<std::vector<T1,A>,AA>& v1,

                                 const std::vector<T2,A>& v2)

vector<T2,A> operator*(const vector<vector<T1,A>,AA>& v1,

                       const vector<T2,A>& v2)

{

	std::vector<T2,A> v3(v2.size());

	vector<T2,A> v3(v2.size());

	for (SizeType i=0;i<v3.size();i++) {

		v3[i] = 0;

		for (SizeType j=0;i<v2.size();j++)
@@ -75,82 +75,85 @@ inline std::vector<T2,A> operator*(const std::vector<std::vector<T1,A>,AA>& v1, 
}



template<typename T1,typename T2,typename A>

inline std::vector<T2,A> operator*(const T1& v1,const std::vector<T2,A>& v2)

vector<T2,A> operator*(const T1& v1,const vector<T2,A>& v2)

{

	std::vector<T2,A> v3(v2.size());

	vector<T2,A> v3(v2.size());

	for (SizeType i=0;i<v3.size();i++) v3[i] = v1 * v2[i];

	return v3;

}



template<typename T1,typename T2,typename A>

inline std::vector<T2,A> operator*(const std::vector<T2,A>& v2,const T1& v1)

vector<T2,A> operator*(const vector<T2,A>& v2,const T1& v1)

{

	return v1*v2;

}



template<typename T,typename A>

std::vector<T,A> conj(std::vector<T,A>& v)

vector<T,A> conj(vector<T,A>& v)

{

	std::vector<T,A> w(v.size());

	for (SizeType i=0;i<v.size();i++) w[i]=std::conj(v[i]);

	vector<T,A> w(v.size());

	for (SizeType i=0;i<v.size();i++) w[i]=conj(v[i]);

	return w;

}



template<typename T,typename A>

T scalarProduct(const std::vector<T,A>& v1, const std::vector<T,A>& v2)

T scalarProduct(const vector<T,A>& v1, const vector<T,A>& v2)

{

	T result = 0.0;

	for (SizeType i=0; i < v2.size(); i++)

		result += std::conj(v1[i]) * v2[i];

		result += conj(v1[i]) * v2[i];

	return result;

}



template<typename FieldType,typename A>

inline std::vector<FieldType,A> operator+=(std::vector<FieldType,A>& v,const std::vector<FieldType,A>& w)

vector<FieldType,A> operator+=(vector<FieldType,A>& v,

                               const vector<FieldType,A>& w)

{

	for (SizeType i=0;i<w.size();i++) v[i] += w[i];

	return v;

}



template<typename FieldType,typename A>

inline std::vector<FieldType,A> operator-=(std::vector<FieldType,A>& v,const std::vector<FieldType,A>& w)

vector<FieldType,A> operator-=(vector<FieldType,A>& v,const vector<FieldType,A>& w)

{

	for (SizeType i=0;i<w.size();i++) v[i] -= w[i];

	return v;

}



template<typename T1,typename T2,typename A>

inline std::vector<T1,A> operator*=(std::vector<T1,A>& v,const T2& t2)

vector<T1,A> operator*=(vector<T1,A>& v,

                        const T2& t2)

{

	for (SizeType i=0;i<v.size();i++) v[i] *= t2;

	return v;

}



template<typename T1,typename T2,typename A>

inline std::vector<T1,A> operator/=(std::vector<T1,A>& v,const T2& t2)

vector<T1,A> operator/=(vector<T1,A>& v,

                        const T2& t2)

{

	for (SizeType i=0;i<v.size();i++) v[i] /= t2;

	return v;

}



template<typename T1,typename T2,typename A1,typename A2>

inline std::vector<T1,A1> operator+(const std::vector<T1,A1>& v1,const std::vector<T2,A2>& v2)

vector<T1,A1> operator+(const vector<T1,A1>& v1,const vector<T2,A2>& v2)

{

	std::vector<T1,A1> v3(v1.size());

	vector<T1,A1> v3(v1.size());

	for (SizeType i=0;i<v1.size();i++) v3[i] = v1[i] + v2[i];

	return v3;

}



template<typename T1,typename T2,typename A>

inline std::vector<T1,A> operator-(const std::vector<T1,A>& v1,const std::vector<T2,A>& v2)

vector<T1,A> operator-(const vector<T1,A>& v1,const vector<T2,A>& v2)

{

	std::vector<T1,A> v3(v1.size());

	vector<T1,A> v3(v1.size());

	for (SizeType i=0;i<v1.size();i++) v3[i] = v1[i] - v2[i];

	return v3;

}



template<class X,typename A>

std::ostream &operator<<(std::ostream &s,const std::vector<X,A>& v)

ostream &operator<<(ostream &s,const vector<X,A>& v)

{

	s<<v.size()<<"\n";

	for (SizeType i=0;i<v.size();i++) s<<v[i]<<"\n";
@@ -158,8 +161,8 @@ std::ostream &operator<<(std::ostream &s,const std::vector<X,A>& v) 
}



template<typename X,typename Y,typename A>

std::ostream &operator<<(std::ostream &s,

                         const std::vector<std::pair<X,Y>,A>& v)

ostream &operator<<(ostream &s,

                    const vector<pair<X,Y>,A>& v)

{

	s<<v.size()<<"\n";

	for (SizeType i=0;i<v.size();i++) s<<v[i].first<<" "<<v[i].second<<"\n";
@@ -167,7 +170,7 @@ std::ostream &operator<<(std::ostream &s, 
}



template<typename FieldType,typename A>

inline std::istream& operator>>(std::istream& is,std::vector<FieldType,A>& v)

istream& operator>>(istream& is,vector<FieldType,A>& v)

{

	int xsize = 0;

	is>>xsize;