#include <TensorArray.H>
#include <iostream>
#include <iterator>
#include <algorithm>
#include <Vector.H>
#include <xstl.H>
#include <Vector.H>
#include <xmath.H>
#include <xstl.H>
using namespace xchen;
using namespace std;
typedef TensorArray<float, 1> MyFloatArray1D;
typedef TensorArray<float, 2> MyFloatArray2D;
typedef TensorArray<float, 3> MyFloatArray3D;
typedef TensorArray<float, 5> MyFloatArray5D;
template<typename T, int dims>
void generic_array_operation(TensorArray<T,dims>& _array)
{
TensorArray<T,dims>& array(_array);
generate(array.Begin(), array.End(), iota<T>(0));
array.Insert(0, 0);
array.PopFront();
array.Insert(0, array.GetSize(0));
array.PopBack();
cout << "\n\n=================== Test Generic Algo on TensorArray =============================\n\n";
cout << "\n_______________________ Array is __________________________\n"; array.PrintShape(); cout << array << endl;
cout << "______________________ All the following test output min(3, sz at that dir) elements in each row ___________________\n\n";
for(int d=0; d<dims; d++)
{
typename TensorArray<T,dims>::row_iterator r_itr = array.RowIterate(d, d, 0, std::min(3, array.GetSize(d)));
cout << "as row iteration, reverse order in each row of direction " << d << "\n";
for(r_itr.Reset(); !r_itr.PastEnd(); ++r_itr)
{
copy(r_itr.Rbegin(), r_itr.Rend(), ostream_iterator<T>(cout," ")); cout << endl;
}
cout << "as row iteration, normal order in each row of direction " << d << "\n";
for(r_itr.Reset(); !r_itr.PastEnd(); ++r_itr)
{
copy(r_itr.Begin(), r_itr.End(), ostream_iterator<T>(cout," ")); cout << endl;
}
cout << "as row iteration, normal order in each row of direction "<< d << ", only even rows\n";
for(r_itr.Reset(); !r_itr.PastEnd(); r_itr += 2)
{
copy(r_itr.Begin(), r_itr.End(), ostream_iterator<T>(cout," ")); cout << endl;
}
cout << "as row iteration, normal order in each row of direction " << d << ", only odd rows\n";
for(r_itr.Reset(), ++r_itr; !r_itr.PastEnd(); r_itr += 2)
{
copy(r_itr.Begin(), r_itr.End(), ostream_iterator<T>(cout," ")); cout << endl;
}
}
for(int d=0; d<dims; d++)
{
typename TensorArray<T,dims>::row_riterator r_itr = array.RowReverseIterate(d, d, 0, std::min(3, array.GetSize(d)));
cout << "as row reverse iteration, reverse order in each row of direction " << d << "\n";
for(r_itr.Reset(); !r_itr.PastEnd(); ++r_itr)
{
copy(r_itr.Rbegin(), r_itr.Rend(), ostream_iterator<T>(cout," ")); cout << endl;
}
cout << "as row reverse iteration, normal order in each row of direction " << d << "\n";
for(r_itr.Reset(); !r_itr.PastEnd(); ++r_itr)
{
copy(r_itr.Begin(), r_itr.End(), ostream_iterator<T>(cout," ")); cout << endl;
}
cout << "as row reverse iteration, normal order in each row of direction "<< d << ", only even rows\n";
for(r_itr.Reset(); !r_itr.PastEnd(); r_itr += 2)
{
copy(r_itr.Begin(), r_itr.End(), ostream_iterator<T>(cout," ")); cout << endl;
}
cout << "as row reverse iteration, normal order in each row of direction " << d << ", only odd rows\n";
for(r_itr.Reset(), ++r_itr; !r_itr.PastEnd(); r_itr += 2)
{
copy(r_itr.Begin(), r_itr.End(), ostream_iterator<T>(cout," ")); cout << endl;
}
}
TensorArray<T,dims> array1(array);
array1.InsertMiddlePoints();
cout << "_______ after InsertMiddlePoint() ___________\n";
array1.PrintShape(); cout << array1 << endl;
TensorArray<T,dims> array2(array);
array2.Averaging();
cout << "\n\n___________after avergagiong ____________\n";
array2.PrintShape(); cout << array2 << endl;
}
void tst5DIdxOperatorAndSliceIterator()
{
int val = 0;
cout << "\n=================== Array5D: test index operator =============================\n";
MyFloatArray5D ia5_0(1,3,3,3,3);
for(int i=0; i<1; i++)
for(int j=0; j<3; j++)
for(int k=0; k<3; k++)
for(int l=0; l<3; l++)
for(int m=0; m<3; m++)
ia5_0[i][j][k][l][m] = val++;
cout << "ia5_0[0][0][1][0][2] is " << ia5_0[0][0][1][0][2] << endl;
cout << "ia5_0[iE5(2,0,1,0,0) is " << ia5_0[iE5(2,0,1,0,0)] << endl;
MyFloatArray5D ia5_1(1,3,3,3,3);
MyFloatArray5D ia5_2(1,3,3,3,3);
MyFloatArray5D ia5_3(1,3,3,3,3);
transform(ia5_0.Begin(), ia5_0.End(), ia5_1.Begin(), negate<float>());
for(int i=0; i<1; i++)
{
for(int j=0; j<3; j++)
{
for(int k=0; k<3; k++)
{
for(int l=0; l<3; l++)
{
for(int m=0; m<3; m++)
cout << ia5_1[i][j][k][l][m] << " ";
cout << endl;
}
cout << endl;
}
cout << endl;
}
cout << endl;
}
TensorArray<float, 5>::slc_iterator
itr0 = ia5_0.SliceIterate(), itr1 = ia5_1.SliceIterate(), itr2 = ia5_2.SliceIterate(), itr3 = ia5_3.SliceIterate();
for(; !itr0.PastEnd(); ++itr0, ++itr1, ++itr2, ++itr3)
{
transform(itr0.Begin(), itr0.End(), itr1.Begin(), itr2.Begin(), AffineCombine<float>(.2));
}
cout << "ia5_0 is \n" << ia5_0 << endl;
cout << "ia5_1 is \n" << ia5_1 << endl;
cout << "ia5_2 is \n" << ia5_2 << endl;
cout << "ia5_3 is \n" << ia5_3 << endl;
}
void IdxAssign(int loop)
{
MyFloatArray3D ia3(100,100,1000);
for(int l=0; l<loop; l++)
{
int val = 0;
for(int i=0; i<100; i++)
for(int j=0; j<100; j++)
for(int k=0; k<1000; k++)
ia3[i][j][k] = val++;
}
}
void ItrAssign(int loop)
{
MyFloatArray3D ia3(100,100,1000);
for(int l=0; l<loop; l++)
{
int val = 0;
MyFloatArray3D::row_iterator r_itr = ia3.RowIterate(0);
while( !r_itr.PastEnd() )
{
for( MyFloatArray3D::element_iterator e_itr = r_itr.Begin();
e_itr != r_itr.End(); ++e_itr )
{
(*e_itr) = val++;
}
++r_itr;
}
}
}
int main()
{
MyFloatArray1D a1(8);
MyFloatArray2D a2(2,3);
a2 =
0,1,2,
3,4,5;
cout << a2 << endl;
a2.CopyExtendAtDirection(1,1,4);
a2.CopyExtendAtDirection(0,1,2);
cout << a2 << endl;
a2.Clear();
a2.Resize(3,4);
MyFloatArray3D a3(2,3,4);
cout << "a3 is \n" << a3 << endl;
generic_array_operation(a1);
generic_array_operation(a2);
generic_array_operation(a3);
tst5DIdxOperatorAndSliceIterator();
return 0;
}
