@q $Id: stack_container.cweb 1835 2008-05-19 01:54:48Z kamenik $ @>
@q Copyright 2004, Ondra Kamenik @>

@ Start of {\tt stack\_container.cpp} file.

@c
#include "stack_container.h"
#include "pyramid_prod2.h"
#include "ps_tensor.h"

double FoldedStackContainer::fill_threshold = 0.00005;
double UnfoldedStackContainer::fill_threshold = 0.00005;
@<|FoldedStackContainer::multAndAdd| sparse code@>;
@<|FoldedStackContainer::multAndAdd| dense code@>;
@<|WorkerFoldMAADense::operator()()| code@>;
@<|WorkerFoldMAADense| constructor code@>;
@<|FoldedStackContainer::multAndAddSparse1| code@>;
@<|WorkerFoldMAASparse1::operator()()| code@>;
@<|WorkerFoldMAASparse1| constructor code@>;
@<|FoldedStackContainer::multAndAddSparse2| code@>;
@<|WorkerFoldMAASparse2::operator()()| code@>;
@<|WorkerFoldMAASparse2| constructor code@>;
@<|FoldedStackContainer::multAndAddSparse3| code@>;
@<|FoldedStackContainer::multAndAddSparse4| code@>;
@<|WorkerFoldMAASparse4::operator()()| code@>;
@<|WorkerFoldMAASparse4| constructor code@>;
@<|FoldedStackContainer::multAndAddStacks| dense code@>;
@<|FoldedStackContainer::multAndAddStacks| sparse code@>;
@#
@<|UnfoldedStackContainer::multAndAdd| sparse code@>;
@<|UnfoldedStackContainer::multAndAdd| dense code@>;
@<|WorkerUnfoldMAADense::operator()()| code@>;
@<|WorkerUnfoldMAADense| constructor code@>;
@<|UnfoldedStackContainer::multAndAddSparse1| code@>;
@<|WorkerUnfoldMAASparse1::operator()()| code@>;
@<|WorkerUnfoldMAASparse1| constructor code@>;
@<|UnfoldedStackContainer::multAndAddSparse2| code@>;
@<|WorkerUnfoldMAASparse2::operator()()| code@>;
@<|WorkerUnfoldMAASparse2| constructor code@>;
@<|UnfoldedStackContainer::multAndAddStacks| code@>;


@ Here we multiply the sparse tensor with the
|FoldedStackContainer|. We have four implementations,
|multAndAddSparse1|, |multAndAddSparse2|, |multAndAddSparse3|, and
|multAndAddSparse4|.  The third is not threaded yet and I expect that
it is certainly the slowest. The |multAndAddSparse4| exploits the
sparsity, however, it seems to be still worse than |multAndAddSparse2|
even for really sparse matrices. On the other hand, it can be more
efficient than |multAndAddSparse2| for large problems, since it does
not need that much of memory and can avoid much swapping. Very
preliminary examination shows that |multAndAddSparse2| is the best in
terms of time.

@s FSSparseTensor int
@s IrregTensorHeader int
@s IrregTensor int

@<|FoldedStackContainer::multAndAdd| sparse code@>=
void FoldedStackContainer::multAndAdd(const FSSparseTensor& t,
									  FGSTensor& out) const
{
	TL_RAISE_IF(t.nvar() != getAllSize(),
				"Wrong number of variables of tensor for FoldedStackContainer::multAndAdd");
	multAndAddSparse2(t, out);
}

@ Here we perform the Faa Di Bruno step for a given dimension |dim|, and for
the dense fully symmetric tensor which is scattered in the container
of general symmetric tensors. The implementation is pretty the same as
|@<|UnfoldedStackContainer::multAndAdd| dense code@>|.

@<|FoldedStackContainer::multAndAdd| dense code@>=
void FoldedStackContainer::multAndAdd(int dim, const FGSContainer& c, FGSTensor& out) const
{
	TL_RAISE_IF(c.num() != numStacks(),
				"Wrong symmetry length of container for FoldedStackContainer::multAndAdd");

	THREAD_GROUP@, gr;
	SymmetrySet ss(dim, c.num());
	for (symiterator si(ss); !si.isEnd(); ++si) {
		if (c.check(*si)) {
			THREAD* worker = new WorkerFoldMAADense(*this, *si, c, out);
			gr.insert(worker);
		}
	}
	gr.run();
}

@ This is analogous to |@<|WorkerUnfoldMAADense::operator()()|
code@>|.

@<|WorkerFoldMAADense::operator()()| code@>=
void WorkerFoldMAADense::operator()()
{
	Permutation iden(dense_cont.num());
	IntSequence coor(sym, iden.getMap());
	const FGSTensor* g = dense_cont.get(sym);
	cont.multAndAddStacks(coor, *g, out, &out);
}

@ 
@<|WorkerFoldMAADense| constructor code@>=
WorkerFoldMAADense::WorkerFoldMAADense(const FoldedStackContainer& container, 
									   const Symmetry& s,
									   const FGSContainer& dcontainer,
									   FGSTensor& outten)
	: cont(container), sym(s), dense_cont(dcontainer), out(outten)
{}

@ This is analogous to |@<|UnfoldedStackContainer::multAndAddSparse1|
code@>|.
@<|FoldedStackContainer::multAndAddSparse1| code@>=
void FoldedStackContainer::multAndAddSparse1(const FSSparseTensor& t,
											 FGSTensor& out) const
{
	THREAD_GROUP@, gr;
	UFSTensor dummy(0, numStacks(), t.dimen());
	for (Tensor::index ui = dummy.begin(); ui != dummy.end(); ++ui) {
		THREAD* worker = new WorkerFoldMAASparse1(*this, t, out, ui.getCoor());
		gr.insert(worker);
	}
	gr.run();
}

@ This is analogous to |@<|WorkerUnfoldMAASparse1::operator()()| code@>|.
The only difference is that instead of |UPSTensor| as a
result of multiplication of unfolded tensor and tensors from
containers, we have |FPSTensor| with partially folded permuted
symmetry.

todo: make slice vertically narrowed according to the fill of t,
vertically narrow out accordingly.

@<|WorkerFoldMAASparse1::operator()()| code@>=
void WorkerFoldMAASparse1::operator()()
{
	const EquivalenceSet& eset = ebundle.get(out.dimen());
	const PermutationSet& pset = tls.pbundle->get(t.dimen());
	Permutation iden(t.dimen());

	UPSTensor slice(t, cont.getStackSizes(), coor,
					PerTensorDimens(cont.getStackSizes(), coor));
	for (int iper = 0; iper < pset.getNum(); iper++) {
		const Permutation& per = pset.get(iper);
		IntSequence percoor(coor.size());
		per.apply(coor, percoor);
		for (EquivalenceSet::const_iterator it = eset.begin();
			 it != eset.end(); ++it) {
			if ((*it).numClasses() == t.dimen()) {
				StackProduct<FGSTensor> sp(cont, *it, out.getSym());
				if (! sp.isZero(percoor)) {
					KronProdStack<FGSTensor> kp(sp, percoor);
					kp.optimizeOrder();
					const Permutation& oper = kp.getPer();
					if (Permutation(oper, per) == iden) {
						FPSTensor fps(out.getDims(), *it, slice, kp);
						{
							SYNCHRO@, syn(&out, "WorkerUnfoldMAASparse1");
							fps.addTo(out);
						}
					}
				}
			}
		}
	}
}

@ 
@<|WorkerFoldMAASparse1| constructor code@>=
WorkerFoldMAASparse1::WorkerFoldMAASparse1(const FoldedStackContainer& container,
										   const FSSparseTensor& ten,
										   FGSTensor& outten, const IntSequence& c)
	: cont(container), t(ten), out(outten), coor(c), ebundle(*(tls.ebundle)) @+{}


@ Here is the second implementation of sparse folded |multAndAdd|. It
is pretty similar to implementation of
|@<|UnfoldedStackContainer::multAndAddSparse2| code@>|. We make a
dense folded |slice|, and then call folded |multAndAddStacks|, which
multiplies all the combinations compatible with the slice.

@<|FoldedStackContainer::multAndAddSparse2| code@>=
void FoldedStackContainer::multAndAddSparse2(const FSSparseTensor& t,
											 FGSTensor& out) const
{
	THREAD_GROUP@, gr;
	FFSTensor dummy_f(0, numStacks(), t.dimen());
	for (Tensor::index fi = dummy_f.begin(); fi != dummy_f.end(); ++fi) {
		THREAD* worker = new WorkerFoldMAASparse2(*this, t, out, fi.getCoor());
		gr.insert(worker);
	}
	gr.run();
}

@ Here we make a sparse slice first and then call |multAndAddStacks|
if the slice is not empty. If the slice is really sparse, we call
sparse version of |multAndAddStacks|. What means ``really sparse'' is
given by |fill_threshold|. It is not tuned yet, a practice shows that
it must be a really low number, since sparse |multAndAddStacks| is
much slower than the dense version.
 
Further, we take only nonzero rows of the slice, and accordingly of
the out tensor. We jump over zero initial rows and drop zero tailing
rows.

@<|WorkerFoldMAASparse2::operator()()| code@>=
void WorkerFoldMAASparse2::operator()()
{
	GSSparseTensor slice(t, cont.getStackSizes(), coor,
						 TensorDimens(cont.getStackSizes(), coor));
	if (slice.getNumNonZero()) {
		if (slice.getUnfoldIndexFillFactor() > FoldedStackContainer::fill_threshold) {
			FGSTensor dense_slice(slice);
			int r1 = slice.getFirstNonZeroRow();
			int r2 = slice.getLastNonZeroRow();
			FGSTensor dense_slice1(r1, r2-r1+1, dense_slice);
			FGSTensor out1(r1, r2-r1+1, out);
			cont.multAndAddStacks(coor, dense_slice1, out1, &out);
		} else
			cont.multAndAddStacks(coor, slice, out, &out);
	}
}

@ 
@<|WorkerFoldMAASparse2| constructor code@>=
WorkerFoldMAASparse2::WorkerFoldMAASparse2(const FoldedStackContainer& container,
										   const FSSparseTensor& ten,
										   FGSTensor& outten, const IntSequence& c)
	: cont(container), t(ten), out(outten), coor(c)
{}


@ Here is the third implementation of the sparse folded
|multAndAdd|. It is column-wise implementation, and thus is not a good
candidate for the best performer.

We go through all columns from the output. For each column we
calculate folded |sumcol| which is a sum of all appropriate columns
for all suitable equivalences. So we go through all suitable
equivalences, for each we construct a |StackProduct| object and
construct |IrregTensor| for a corresponding column of $z$. The
|IrregTensor| is an abstraction for Kronecker multiplication of
stacked columns of the two containers without zeros. Then the column
is added to |sumcol|. Finally, the |sumcol| is multiplied by the
sparse tensor.

@<|FoldedStackContainer::multAndAddSparse3| code@>=
void FoldedStackContainer::multAndAddSparse3(const FSSparseTensor& t,
											 FGSTensor& out) const
{
	const EquivalenceSet& eset = ebundle.get(out.dimen());
	for (Tensor::index run = out.begin(); run != out.end(); ++run) {
		Vector outcol(out, *run);
		FRSingleTensor sumcol(t.nvar(), t.dimen());
		sumcol.zeros();
		for (EquivalenceSet::const_iterator it = eset.begin();
			 it != eset.end(); ++it) {
			if ((*it).numClasses() == t.dimen()) {
				StackProduct<FGSTensor> sp(*this, *it, out.getSym());
				IrregTensorHeader header(sp, run.getCoor());
				IrregTensor irten(header);
				irten.addTo(sumcol);
			}
		}
		t.multColumnAndAdd(sumcol, outcol);
	}
}

@ Here is the fourth implementation of sparse
|FoldedStackContainer::multAndAdd|. It is almost equivalent to
|multAndAddSparse2| with the exception that the |FPSTensor| as a
result of a product of a slice and Kronecker product of the stack
derivatives is calculated in the sparse fashion. For further details, see
|@<|FoldedStackContainer::multAndAddStacks| sparse code@>| and
|@<|FPSTensor| sparse constructor@>|.
 
@<|FoldedStackContainer::multAndAddSparse4| code@>=
void FoldedStackContainer::multAndAddSparse4(const FSSparseTensor& t, FGSTensor& out) const
{
	THREAD_GROUP@, gr;
	FFSTensor dummy_f(0, numStacks(), t.dimen());
	for (Tensor::index fi = dummy_f.begin(); fi != dummy_f.end(); ++fi) {
		THREAD* worker = new WorkerFoldMAASparse4(*this, t, out, fi.getCoor());
		gr.insert(worker);
	}
	gr.run();
}

@ The |WorkerFoldMAASparse4| is the same as |WorkerFoldMAASparse2|
with the exception that we call a sparse version of
|multAndAddStacks|.

@<|WorkerFoldMAASparse4::operator()()| code@>=
void WorkerFoldMAASparse4::operator()()
{
	GSSparseTensor slice(t, cont.getStackSizes(), coor,
						 TensorDimens(cont.getStackSizes(), coor)); 
	if (slice.getNumNonZero())
		cont.multAndAddStacks(coor, slice, out, &out);
}

@ 
@<|WorkerFoldMAASparse4| constructor code@>=
WorkerFoldMAASparse4::WorkerFoldMAASparse4(const FoldedStackContainer& container,
										   const FSSparseTensor& ten,
										   FGSTensor& outten, const IntSequence& c)
	: cont(container), t(ten), out(outten), coor(c)
{}


@ This is almost the same as
|@<|UnfoldedStackContainer::multAndAddStacks| code@>|. The only
difference is that we do not construct a |UPSTensor| from
|KronProdStack|, but we construct partially folded permuted
symmetry |FPSTensor|. Note that the tensor |g| must be unfolded
in order to be able to multiply with unfolded rows of Kronecker
product. However, columns of such a product are partially
folded giving a rise to the |FPSTensor|.

@<|FoldedStackContainer::multAndAddStacks| dense code@>=
void FoldedStackContainer::multAndAddStacks(const IntSequence& coor,
											const FGSTensor& g,
											FGSTensor& out, const void* ad) const
{
	const EquivalenceSet& eset = ebundle.get(out.dimen());

	UGSTensor ug(g);
	UFSTensor dummy_u(0, numStacks(), g.dimen());
	for (Tensor::index ui = dummy_u.begin(); ui != dummy_u.end(); ++ui) {
		IntSequence tmp(ui.getCoor());
		tmp.sort();
		if (tmp == coor) {
			Permutation sort_per(ui.getCoor());
			sort_per.inverse();
			for (EquivalenceSet::const_iterator it = eset.begin();
				 it != eset.end(); ++it) {
				if ((*it).numClasses() == g.dimen()) {
					StackProduct<FGSTensor> sp(*this, *it, sort_per, out.getSym());
					if (! sp.isZero(coor)) {
						KronProdStack<FGSTensor> kp(sp, coor);
						if (ug.getSym().isFull())
							kp.optimizeOrder();
						FPSTensor fps(out.getDims(), *it, sort_per, ug, kp);
						{
							SYNCHRO@, syn(ad, "multAndAddStacks");
							fps.addTo(out);
						}
					}
				}
			}
		}
	}
}

@ This is almost the same as
|@<|FoldedStackContainer::multAndAddStacks| dense code@>|. The only
difference is that the Kronecker product of the stacks is multiplied
with sparse slice |GSSparseTensor| (not dense slice |FGSTensor|). The
multiplication is done in |@<|FPSTensor| sparse constructor@>|.

@<|FoldedStackContainer::multAndAddStacks| sparse code@>=
void FoldedStackContainer::multAndAddStacks(const IntSequence& coor,
											const GSSparseTensor& g,
											FGSTensor& out, const void* ad) const
{
	const EquivalenceSet& eset = ebundle.get(out.dimen());
	UFSTensor dummy_u(0, numStacks(), g.dimen());
	for (Tensor::index ui = dummy_u.begin(); ui != dummy_u.end(); ++ui) {
		IntSequence tmp(ui.getCoor());
		tmp.sort();
		if (tmp == coor) {
			Permutation sort_per(ui.getCoor());
			sort_per.inverse();
			for (EquivalenceSet::const_iterator it = eset.begin();
				 it != eset.end(); ++it) {
				if ((*it).numClasses() == g.dimen()) {
					StackProduct<FGSTensor> sp(*this, *it, sort_per, out.getSym());
					if (! sp.isZero(coor)) {
						KronProdStack<FGSTensor> kp(sp, coor);
						FPSTensor fps(out.getDims(), *it, sort_per, g, kp);
						{
							SYNCHRO@, syn(ad, "multAndAddStacks");
							fps.addTo(out);
						}
					}
				}
			}
		}
	}
}

@ Here we simply call either |multAndAddSparse1| or
|multAndAddSparse2|. The first one allows for optimization of
Kronecker products, so it seems to be more efficient.

@<|UnfoldedStackContainer::multAndAdd| sparse code@>=
void UnfoldedStackContainer::multAndAdd(const FSSparseTensor& t,
										UGSTensor& out) const
{
	TL_RAISE_IF(t.nvar() != getAllSize(),
				"Wrong number of variables of tensor for UnfoldedStackContainer::multAndAdd");
	multAndAddSparse2(t, out);
}

@ Here we implement the formula for stacks for fully symmetric tensor
scattered in a number of general symmetry tensors contained in a given
container. The implementations is pretty the same as in
|multAndAddSparse2| but we do not do the slices of sparse tensor, but
only a lookup to the container.

This means that we do not iterate through a dummy folded tensor to
obtain folded coordinates of stacks, rather we iterate through all
symmetries contained in the container and the coordinates of stacks
are obtained as unfolded identity sequence via the symmetry. The
reason of doing this is that we are unable to calculate symmetry from
stack coordinates as easily as stack coordinates from the symmetry.

@<|UnfoldedStackContainer::multAndAdd| dense code@>=
void UnfoldedStackContainer::multAndAdd(int dim, const UGSContainer& c,
										UGSTensor& out) const
{
	TL_RAISE_IF(c.num() != numStacks(),
				"Wrong symmetry length of container for UnfoldedStackContainer::multAndAdd");

	THREAD_GROUP@, gr;
	SymmetrySet ss(dim, c.num());
	for (symiterator si(ss); !si.isEnd(); ++si) {
		if (c.check(*si)) {
			THREAD* worker = new WorkerUnfoldMAADense(*this, *si, c, out);
			gr.insert(worker);
		}
	}
	gr.run();
}

@ 
@<|WorkerUnfoldMAADense::operator()()| code@>=
void WorkerUnfoldMAADense::operator()()
{
	Permutation iden(dense_cont.num());
	IntSequence coor(sym, iden.getMap());
	const UGSTensor* g = dense_cont.get(sym);
	cont.multAndAddStacks(coor, *g, out, &out);
}

@ 
@<|WorkerUnfoldMAADense| constructor code@>=
WorkerUnfoldMAADense::WorkerUnfoldMAADense(const UnfoldedStackContainer& container,
										   const Symmetry& s,
										   const UGSContainer& dcontainer,
										   UGSTensor& outten)
	: cont(container), sym(s), dense_cont(dcontainer), out(outten)@+ {}


@ Here we implement the formula for unfolded tensors. If, for instance,
a coordinate $z$ of a tensor $\left[f_{z^2}\right]$ is partitioned as
$z=[a, b]$, then we perform the following:
$$
\eqalign{
\left[f_{z^2}\right]\left(\sum_c\left[\matrix{a_{c(x)}\cr b_{c(y)}}\right]
\otimes\left[\matrix{a_{c(y)}\cr b_{c(y)}}\right]\right)=&
\left[f_{aa}\right]\left(\sum_ca_{c(x)}\otimes a_{c(y)}\right)+
\left[f_{ab}\right]\left(\sum_ca_{c(x)}\otimes b_{c(y)}\right)+\cr
&\left[f_{ba}\right]\left(\sum_cb_{c(x)}\otimes a_{c(y)}\right)+
 \left[f_{bb}\right]\left(\sum_cb_{c(x)}\otimes b_{c(y)}\right)\cr
}
$$
This is exactly what happens here. The code is clear. It goes through
all combinations of stacks, and each thread is responsible for
operation for the slice corresponding to the combination of the stacks.

@<|UnfoldedStackContainer::multAndAddSparse1| code@>=
void UnfoldedStackContainer::multAndAddSparse1(const FSSparseTensor& t,
											   UGSTensor& out) const
{
	THREAD_GROUP@, gr;
	UFSTensor dummy(0, numStacks(), t.dimen());
	for (Tensor::index ui = dummy.begin(); ui != dummy.end(); ++ui) {
		THREAD* worker = new WorkerUnfoldMAASparse1(*this, t, out, ui.getCoor());
		gr.insert(worker);
	}
	gr.run();
}

@ This does a step of |@<|UnfoldedStackContainer::multAndAddSparse1| code@>| for
a given coordinates. First it makes the slice of the given stack coordinates.
Then it multiplies everything what should be multiplied with the slice.
That is it goes through all equivalences, creates |StackProduct|, then
|KronProdStack|, which is added to |out|. So far everything is clear.

However, we want to use optimized |KronProdAllOptim| to minimize
a number of flops and memory needed in the Kronecker product. So we go
through all permutations |per|, permute the coordinates to get
|percoor|, go through all equivalences, and make |KronProdStack| and
optimize it. The result of optimization is a permutation |oper|. Now,
we multiply the Kronecker product with the slice, only if the slice
has the same ordering of coordinates as the Kronecker product
|KronProdStack|. However, it is not perfectly true. Since we go
through {\bf all} permutations |per|, there might be two different
permutations leading to the same ordering in |KronProdStack| and thus
the same ordering in the optimized |KronProdStack|. The two cases
would be counted twice, which is wrong. That is why we do not
condition on $\hbox{coor}\circ\hbox{oper}\circ\hbox{per} =
\hbox{coor}$, but we condition on
$\hbox{oper}\circ\hbox{per}=\hbox{id}$. In this way, we rule out
permutations |per| leading to the same ordering of stacks when
applied on |coor|.

todo: vertically narrow slice and out according to the fill in t.

@<|WorkerUnfoldMAASparse1::operator()()| code@>=
void WorkerUnfoldMAASparse1::operator()()
{
	const EquivalenceSet& eset = ebundle.get(out.dimen());
	const PermutationSet& pset = tls.pbundle->get(t.dimen());
	Permutation iden(t.dimen());

	UPSTensor slice(t, cont.getStackSizes(), coor,
					PerTensorDimens(cont.getStackSizes(), coor));
	for (int iper = 0; iper < pset.getNum(); iper++) {
		const Permutation& per = pset.get(iper);
		IntSequence percoor(coor.size());
		per.apply(coor, percoor);
		for (EquivalenceSet::const_iterator it = eset.begin();
			 it != eset.end(); ++it) {
			if ((*it).numClasses() == t.dimen()) {
				StackProduct<UGSTensor> sp(cont, *it, out.getSym());
				if (! sp.isZero(percoor)) {
					KronProdStack<UGSTensor> kp(sp, percoor);
					kp.optimizeOrder();
					const Permutation& oper = kp.getPer();
					if (Permutation(oper, per) == iden) {
						UPSTensor ups(out.getDims(), *it, slice, kp);
						{
							SYNCHRO@, syn(&out, "WorkerUnfoldMAASparse1");
							ups.addTo(out);
						}
					}
				}
			}
		}
	}
}

@ 
@<|WorkerUnfoldMAASparse1| constructor code@>=
WorkerUnfoldMAASparse1::WorkerUnfoldMAASparse1(const UnfoldedStackContainer& container,
											   const FSSparseTensor& ten,
											   UGSTensor& outten, const IntSequence& c)
	: cont(container), t(ten), out(outten), coor(c), ebundle(*(tls.ebundle)) @+{}


@ In here we implement the formula by a bit different way. We use the
fact, using notation of |@<|UnfoldedStackContainer::multAndAddSparse2|
code@>|, that
$$
\left[f_{ba}\right]\left(\sum_cb_{c(x)}\otimes a_{c(y)}\right)=
\left[f_{ab}\right]\left(\sum_ca_{c(y)}\otimes b_{c(b)}\right)\cdot P
$$
where $P$ is a suitable permutation of columns. The permutation
corresponds to (in this example) a swap of $a$ and $b$. An advantage
of this approach is that we do not need |UPSTensor| for $f_{ba}$, and
thus we decrease the number of needed slices.

So we go through all folded indices of stack coordinates, then for
each such index |fi| we make a slice and call |multAndAddStacks|. This
goes through all corresponding unfolded indices to perform the
formula. Each unsorted (unfold) index implies a sorting permutation
|sort_per| which must be used to permute stacks in |StackProduct|, and
permute equivalence classes when |UPSTensor| is formed. In this way
the column permutation $P$ from the formula is factored to the
permutation of |UPSTensor|.
 
@<|UnfoldedStackContainer::multAndAddSparse2| code@>=
void UnfoldedStackContainer::multAndAddSparse2(const FSSparseTensor& t,
											   UGSTensor& out) const
{
	THREAD_GROUP@, gr;
	FFSTensor dummy_f(0, numStacks(), t.dimen());
	for (Tensor::index fi = dummy_f.begin(); fi != dummy_f.end(); ++fi) {
		THREAD* worker = new WorkerUnfoldMAASparse2(*this, t, out, fi.getCoor());
		gr.insert(worker);
	}
	gr.run();
}

@ This does a step of |@<|UnfoldedStackContainer::multAndAddSparse2| code@>| for
a given coordinates.

todo: implement |multAndAddStacks| for sparse slice as
|@<|FoldedStackContainer::multAndAddStacks| sparse code@>| and do this method as
|@<|WorkerFoldMAASparse2::operator()()| code@>|.

@<|WorkerUnfoldMAASparse2::operator()()| code@>=
void WorkerUnfoldMAASparse2::operator()()
{
	GSSparseTensor slice(t, cont.getStackSizes(), coor,
						 TensorDimens(cont.getStackSizes(), coor));
	if (slice.getNumNonZero()) {
		FGSTensor fslice(slice);
		UGSTensor dense_slice(fslice);
		int r1 = slice.getFirstNonZeroRow();
		int r2 = slice.getLastNonZeroRow();
		UGSTensor dense_slice1(r1, r2-r1+1, dense_slice);
		UGSTensor out1(r1, r2-r1+1, out);
		
		cont.multAndAddStacks(coor, dense_slice1, out1, &out);
	}
}

@ 
@<|WorkerUnfoldMAASparse2| constructor code@>=
WorkerUnfoldMAASparse2::WorkerUnfoldMAASparse2(const UnfoldedStackContainer& container,
											   const FSSparseTensor& ten,
											   UGSTensor& outten, const IntSequence& c)
	: cont(container), t(ten), out(outten), coor(c) @+{}


@ For a given unfolded coordinates of stacks |fi|, and appropriate
tensor $g$, whose symmetry is a symmetry of |fi|, the method
contributes to |out| all tensors in unfolded stack formula involving
stacks chosen by |fi|.

We go through all |ui| coordinates which yield |fi| after sorting. We
construct a permutation |sort_per| which sorts |ui| to |fi|. We go
through all appropriate equivalences, and construct |StackProduct|
from equivalence classes permuted by |sort_per|, then |UPSTensor| with
implied permutation of columns by the permuted equivalence by
|sort_per|. The |UPSTensor| is then added to |out|.

We cannot use here the optimized |KronProdStack|, since the symmetry
of |UGSTensor& g| prescribes the ordering of the stacks. However, if
|g| is fully symmetric, we can do the optimization harmlessly.

@<|UnfoldedStackContainer::multAndAddStacks| code@>=
void UnfoldedStackContainer::multAndAddStacks(const IntSequence& fi,
											  const UGSTensor& g,
											  UGSTensor& out, const void* ad) const
{
	const EquivalenceSet& eset = ebundle.get(out.dimen());

	UFSTensor dummy_u(0, numStacks(), g.dimen());
	for (Tensor::index ui = dummy_u.begin(); ui != dummy_u.end(); ++ui) {
		IntSequence tmp(ui.getCoor());
		tmp.sort();
		if (tmp == fi) {
			Permutation sort_per(ui.getCoor());
			sort_per.inverse();
			for (EquivalenceSet::const_iterator it = eset.begin();
				 it != eset.end(); ++it) {
				if ((*it).numClasses() == g.dimen()) {
					StackProduct<UGSTensor> sp(*this, *it, sort_per, out.getSym());
					if (! sp.isZero(fi)) {
						KronProdStack<UGSTensor> kp(sp, fi);
						if (g.getSym().isFull())
							kp.optimizeOrder();
						UPSTensor ups(out.getDims(), *it, sort_per, g, kp);
						{
							SYNCHRO@, syn(ad, "multAndAddStacks");
							ups.addTo(out);
						}
					}
				}
			}
		}
	}
}

@ End of {\tt stack\_container.cpp} file.
