public idx <T> transpose(int[] p)
{
idx <T> r = new idx <T>(srgptr, spec.getoffset());
spec.transpose_into(ref r.spec, p);
return(r);
}
public idx <T> unfold(int d, intg k, intg s)
{
idx <T> r = new idx <T>(srgptr, spec.getoffset());
spec.unfold_into(ref r.spec, d, k, s);
return(r);
}
public idx <T> narrow(int d, intg s, intg o)
{
idx <T> r = new idx <T>(srgptr, spec.getoffset());
spec.narrow_into(ref r.spec, d, s, o);
return(r);
}
public static void idx_m2squdotm2acc(idx <T> i1, idx <T> i2, idx <T> o)
{
loops.idx_checkorder3(i1, 2, i2, 2, o, 0);
#warning idx_checkdim2(i1, 0, i2.dim(0), i1, 1, i2.dim(1));
intg imax = i1.dim(0), jmax = i2.dim(1);
intg c1_m0 = i1.mod(0), c2_m0 = i2.mod(0);
intg c1_m1 = i1.mod(1), c2_m1 = i2.mod(1);
eptr <T> c1_0, c2_0, d1, c1, c2;
c1_0 = i1.idx_ptr();
c2_0 = i2.idx_ptr();
d1 = o.idx_ptr();
c1 = c1_0;
c2 = c2_0;
T f = d1.item;
for (int i = 0; i < imax; ++i)
{
c1.index = c1_0.index;
c2.index = c2_0.index;
for (int j = 0; j < jmax; ++j)
{
T ff = Dot(Dot(c1.item, c1.item), c2.item);
f = Add <T>(ff, f);
c1.index += c1_m1;
c2.index += c2_m1;
}
c1_0.index += c1_m0;
c2_0.index += c2_m0;
}
d1.item = f;
}
public static void idx_compatibility_error3 <T, T2, T3>(idx <T> idx1, idx <T2> idx2, idx <T3> idx3, string errmsg)
where T : struct
where T2 : struct
where T3 : struct
{
Global.eblerror(idx1 + " , " + idx2 + " and " + idx3 + " are incompatible: " + errmsg);
}
public static bool save_matrix <T>(idx <T> m, FILE fp) where T : struct
{
int v;
v = get_magic <T>();
if (fp.fwrite(v) != 1)
{
return(false);
}
v = m.order();
if (fp.fwrite(v) != 1)
{
return(false);
}
for (int i = 0; (i < m.order()) || (i < 3); ++i)
{
if (i < m.order())
{
v = m.dim(i);
}
else
{
v = 1;
}
if (fp.fwrite(v) != 1)
{
return(false);
}
}
loops.idx_aloop1(m, (i) => fp.fwrite(i.item));
return(true);
}
public static void idx_checkorder1 <T>(idx <T> src0, int o0) where T : struct
{
if ((src0).order() != o0)
{
Global.eblerror(src0 + " does not have order " + o0);
}
}
public static void idx_m1extm1(idx <T> i1, idx <T> i2, idx <T> o1)
{
eptr <T> c2, d1, c1, c2_0, d1_0;
intg c2_m0 = i2.mod(0), d1_m1 = o1.mod(1);
intg c1_m0 = i1.mod(0), d1_m0 = o1.mod(0);
intg j, jmax = o1.dim(1);
intg i, imax = o1.dim(0);
c1 = i1.idx_ptr();
c2_0 = i2.idx_ptr();
d1_0 = o1.idx_ptr();
for (i = 0; i < imax; i++)
{
d1 = d1_0;
c2 = c2_0;
for (j = 0; j < jmax; j++)
{
d1.item = Dot(c1.item, c2.item);
d1.index += d1_m1;
c2.index += c2_m0;
}
d1_0.index += d1_m0;
c1.index += c1_m0;
}
}
public idx <T> select(int d, intg i)
{
idx <T> r = new idx <T>(srgptr, spec.getoffset());
spec.select_into(ref r.spec, d, i);
return(r);
}
public static T idx_sumacc(idx <T> m, idx <T> acc)
{
var sum = Add <T>(acc.get(), idx_sum(m));
acc.set((T)Global.B(sum));
return(sum);
}
public static idx <T> idx_copy(idx <T> m)
{
idx <T> dst = new idx <T>(m.get_idxdim());
idx_copy <T>(m, dst);
return(dst);
}
public static T idx_sum(idx <T> m)
{
T V = (T)Global.B(0.0);
i.idx_aloop1(m, (m1) => V = Add <T>(V, m1.item));
return(V);
}
public static void CHECK_CONTIGUOUS1 <T>(idx <T> m1) where T : struct
{
if (!(m1).contiguousp())
{
Global.eblerror("expected contiguous tensor " + m1);
}
}
static public void read_cast_matrix <T, T2>(ref FILE fp, ref idx <T2> Out) where T : struct where T2 : struct
{
idx <T> m = new idx <T>(Out.get_idxdim());
read_matrix_body(ref fp, ref m);
idxops <T> .idx_copy <T2>(m, Out);
}
public static void idx_aloop1_on <T>(idxiter <T> itr0, idx <T> src0, Action <eptr <T> > act) //Action<eptr<T>, idx<T>> act
where T : struct
{
for (itr0.init(src0); itr0.notdone(); itr0.next())
{
act.Invoke(itr0.data);
}
}
public static void idx_copy <T2>(idx <T> m, idx <T2> dst) where T2 : struct
{
if (m.order() == 0 && dst.order() == 0)
{
dst.set((T2)Global.B(m.get())); return;
}
i.idx_aloop2(m, dst, (m1, d1) => d1.item = (T2)Global.B(m1.item));
}
public static void idx_copy(idx <T> m, idx <T> dst)
{
if (m.order() == 0 && dst.order() == 0)
{
dst.set(m.get()); return;
}
i.idx_aloop2(m, dst, (m1, d1) => d1.item = m1.item);
}
public static void idx_m4dotm2(idx <T> i1, idx <T> i2, idx <T> o1)
{
loops.idx_checkorder3(i1, 4, i2, 2, o1, 2); // check for compatible orders
if ((i1.dim(0) != o1.dim(0)) || (i1.dim(1) != o1.dim(1)) ||
(i1.dim(2) != i2.dim(0)) || (i1.dim(3) != i2.dim(1)))
{
loops.idx_compatibility_error3(i1, i2, o1, "incompatible dimensions");
}
eptr <T> c1, c1_2;
eptr <T> c2, c2_0;
eptr <T> c1_0, c1_1;
eptr <T> ker;
intg c1_m2 = (i1).mod(2), c2_m0 = (i2).mod(0);
intg c1_m3 = (i1).mod(3), c2_m1 = (i2).mod(1);
intg k, l, kmax = (i2).dim(0), lmax = (i2).dim(1);
eptr <T> d1_0, d1;
T f;
intg c1_m0 = (i1).mod(0), d1_m0 = (o1).mod(0);
intg c1_m1 = (i1).mod(1), d1_m1 = (o1).mod(1);
intg i, j, imax = (o1).dim(0), jmax = (o1).dim(1);
c1_0 = i1.idx_ptr();
ker = i2.idx_ptr();
d1_0 = o1.idx_ptr();
c1_1 = c1_0;
d1 = d1_0;
c1_2 = c1_1;
c2_0 = ker;
for (i = 0; i < imax; i++)
{
c1_1.index = c1_0.index;
d1.index = d1_0.index;
for (j = 0; j < jmax; j++)
{
f = default(T);
c1_2.index = c1_1.index;
c2_0.index = ker.index;
for (k = 0; k < kmax; k++)
{
c1 = c1_2;
c2 = c2_0;
for (l = 0; l < lmax; l++)
{
f = Add(Dot(c1.item, c2.item), f);
c1.index += c1_m3;
c2.index += c2_m1;
}
c1_2.index += c1_m2;
c2_0.index += c2_m0;
}
d1.item = f;
d1.index += d1_m1;
c1_1.index += c1_m1;
}
d1_0.index += d1_m0;
c1_0.index += c1_m0;
}
}
public static void idx_checknelems2_all <T, T2>(idx <T> src0, idx <T2> src1)
where T : struct
where T2 : struct
{
if ((src0).nelements() != (src1).nelements())
{
Global.eblerror(src0 + " and " + src1 +
" should have the same number of elements");
}
}
public static void idx_eloop1 <T>(idx <T> src0, Action <idxlooper <T>, idx <T> > act)
where T : struct
{
idxlooper <T> dst0 = new idxlooper <T>(src0, src0.order() - 1);
for (; dst0.notdone(); dst0.next())
{
act.Invoke(dst0, src0);
}
}
public idx <T> view_as_order(int n)
{
if (n < 0)
{
throw new Exception("view_as_order: input dimension must be positive");
return(this);
}
if (n == spec.ndim)
{
return(this);
}
else
{
if ((n == 1) && (spec.ndim == 1))
{
// the order is already 1, do nothing and return current idx.
return(new idx <T>(this));
}
else if (n == 1)
{
// the order is not 1, check that data is contiguous and return
// a 1D idx.
loops.CHECK_CONTIGUOUS1(this);
idx <T> r = new idx <T>(getstorage(), 0, spec.nelements());
return(r);
}
else if (n > spec.ndim)
{
intg[] ldim = new intg[n];
intg[] lmod = new intg[n];
ldim = spec.dim;
lmod = spec.mod;
for (int i = spec.ndim; i < n; ++i)
{
ldim[i] = 1;
lmod[i] = 1;
}
idx <T> r = new idx <T>(getstorage(), spec.getoffset(), n, ldim, lmod);
if (!(ldim == null))
{
ldim = null;
}
if ((lmod == null))
{
lmod = null;
}
return(r);
}
else
{
throw new Exception("view_as_order is not defined when n < current order");
return(new idx <T>(this));
}
}
}
public static void TestReader()
{
//idxdim d = idxIO.get_matrix_dims(@"F:\Datasets\DSCompile\net00000.mat");
//Global.Print(d.ToString());
FILE fp = new FILE(@"F:\Datasets\DSCompile\net00000.mat");
idx <double> dubs = idxIO.load_matrix <double>(ref fp, null);
Global.Print(dubs.ToString());
}
public static void idx_aloop2 <T, T2>(idx <T> src0, idx <T2> src1, Action <eptr <T>, eptr <T2> > act)
where T : struct
where T2 : struct
{
var itr0 = new idxiter <T>();
var itr1 = new idxiter <T2>();
for (itr0.init(src0), itr1.init(src1); itr0.notdone(); itr0.next(), itr1.next())
{
act.Invoke(itr0.data, itr1.data);
}
}
public static void idx_eloop2 <T, T2>(idx <T> src0, idx <T2> src1, Action <idxlooper <T>, idx <T>, idxlooper <T2>, idx <T2> > act)
where T : struct
where T2 : struct
{
idxlooper <T> dst0 = new idxlooper <T>(src0, src0.order() - 1);
idxlooper <T2> dst1 = new idxlooper <T2>(src1, src1.order() - 1);
for (; dst0.notdone(); dst0.next(), dst1.next())
{
act.Invoke(dst0, src0, dst1, src1);
}
}
public static bool CheckEqual(idx <T> a, idx <T> b)
{
//if (a.spec.dim != b.spec.dim) { return false; }
if (a.spec.ndim != b.spec.ndim)
{
return(false);
}
if (a.spec.mod != b.spec.mod)
{
return(false);
}
return(true);
}
public static void idx_checkorder2 <T, T2>(idx <T> src0, int o0, idx <T2> src1, int o1)
where T : struct
where T2 : struct
{
if ((src0).order() != o0)
{
Global.eblerror(src0 + " does not have order " + o0);
}
if ((src1).order() != o1)
{
Global.eblerror(src1 + " does not have order " + o1);
}
}
public idxlooper(idx <T> m, int ld)
{
if (m.order() == 0)
{
Global.eblerror("cannot loop on idx with order 0. idx is: " + m);
}
i = 0;
dimd = m.spec.dim[ld];
modd = m.spec.mod[ld];
m.spec.select_into(ref spec, ld, i);
this.srgptr = m.srgptr.Addreference();
item = new eptr <T>(srgptr, spec.getoffset());
}
public static void CHECK_CONTIGUOUS2 <T, T2>(idx <T> m1, idx <T2> m2)
where T : struct
where T2 : struct
{
if (!(m1).contiguousp())
{
Global.eblerror("expected contiguous tensor " + m1);
}
if (!(m2).contiguousp())
{
Global.eblerror("expected contiguous tensor " + m2);
}
}
public static void Testm2dotm1()
{
idx <T> d2 = new idx <T>(2, 5);
idx <T> d1 = new idx <T>(5);
idx <T> o = new idx <T>(2);
idxops <T> .idx_fill(d2, 2.0);
idxops <T> .idx_fill(d1, 1.0);
idxops <T> .idx_m2dotm1(d2, d1, o);
loops.idx_bloop1(o, (lop, o1) => Global.Print(o.get()));
}
public static void idx_cloop3 <T, T2, T3>(idx <T> src0, idx <T2> src1, idx <T3> src2, Action <idxlooper <T>, idxlooper <T2>, idxlooper <T3> > act)
where T : struct
where T2 : struct
where T3 : struct
{
idxlooper <T> dst0 = new idxlooper <T>(src0, 0);
idxlooper <T2> dst1 = new idxlooper <T2>(src1, 0);
idxlooper <T3> dst2 = new idxlooper <T3>(src2, 0);
for (; dst0.notdone(); dst0.next(), dst1.next(), dst2.next())
{
act.Invoke(dst0, dst1, dst2);
}
}
