Tensors
Tensors may be primary or secondary, single or multiple, and have a numeric type and an order, more precisely a shape of some order.
Primary tensors are those not depending of others. They include constants, primary variables and dummy variables. Secondary tensors depend upon others.
Single tensors hold one value, meanwhile multiple tensors hold several values, the number of which being a single natural scalar named the numericity.
The numeric type may be one of natural, integer, or decimal. Naturals are mainly used for indices, while integers arise in differences for ordering of naturals. Decimals stand for reals and are calculated through floating-point arithmetics. The library uses 64 bits (C++ double), and 80 bits for some evaluation of constants. In the future, the floating-point policy will be more customizable.
Tensors may be scalars (order=0), vectors (order=1), matrices (order=2), or of any order. The shape is the list of its dimensions and is given through natural scalars whose numericity follows that of the tensor, unless they are uniform, that is, the same for all held values. Hence, a multiple tensor has an common order but the dimensions may vary.
Single scalars first
Here is a constant scalar of value 1.
auto i1 = Natural1(1);
_eval_ << i1;
( 1 )
Here are three ways to build the scalar 2:
auto i2 = Natural1(2);
auto i2m = 2*i1;
auto i2s = i1+i1;
std::cout << "Are scalars equal? " << i2m==i2 << ' ' << i2s==i2 << '\n';
Are scalars equal? 1 1
The result says that the scalar objects are the same, which is stronger than saying that they evaluate to the same value.
This means ì2m and i2s resume in primary tensors even though their construction is that of secondary ones.
Now here is a variable scalar corresponding to a single container:
auto dataA = NaturalData1("A");//! the container
auto iA = scalar1(dataA) //! the scalar
dataA.set_value(10); //! setting the value in the container
_eval_ << iA; //! evaluate the tensor
( 10 )
If we modify the container value, the scalar remains the same but evaluate to the new value:
dataA.set_value(11); _eval_ << iA;
( 11 )
Let’s build a secondary tensor based on ìA:
auto iA1 = iA+1;
_eval_ << iA1;
( 12 )
Simplifications may occur:
auto iA2m = 2*iA;
auto iA2s = iA+iA;
std::cout << "Are scalars equal? " << iA2m==iA2s << " " << (iA1-i1)==Natural1(1) << '\n';
_eval_ << iA2m;
Are scalars equal? 1 1
( 22 )
Loop tensors
auto bounds = NaturalRange("range1",{0,9});
auto iLoop1 = dummy_index1(bounds); // Nat1
auto iLoop2 = dummy_index1("range2",20);// Nat1
_eval_ << iLoop1;
0 ( 0 )
1 ( 1 )
2 ( 2 )
3 ( 3 )
...
7 ( 7 )
8 ( 8 )
9 ( 9 )
_eval_ << iLoop2;
0 ( 0 )
1 ( 1 )
2 ( 2 )
...
18 ( 18 )
19 ( 19 )
Multiple scalar
A tensor may hold several values, as in this constant scalar:
auto j2 = NatN {0,3,4,9};
_eval_ << num(j2); //! numericity of j2 is the number of values it holds
_eval_ << j2;
( 4 )
( 0 3 4 9 )
or this variable scalar corresponding to a multiple container:
auto dataAA = NaturalDataN("AA",5); //! a container holding 5 natural values initialized with 0
auto jA = scalarN(dataAA);
_eval_ << jA;
( 0 0 0 0 0 )
dataAA.set_value(2,10); _eval_ << jA;
( 0 0 10 0 0 )
dataAA.set_value(3,11); _eval_ << jA;
( 0 0 10 11 0 )
Unrolling by a number n returns n consecutive values starting at n times the base value: unroll(3,Natural1(2)),
where 3 is the unroll number and 2 the base, gives:
( 6 7 8 )
The base may be multiple as in unroll(Natural1(3),{0,2):, which evaluates as:
( 0 1 2 6 7 8 )
The common way to get the first 7 naturals is unroll(Natural1(7)):
( 0 1 2 3 4 5 6 )
Let’s build some secondary tensors:
auto jA2m = 2*jA;
auto jA2s = jA+jA;
auto jA1 = jA+1;
std::cout << "test " << jA2m==jA2s << " " << (jA1-jA).has_only_value(1) << '\n';
_eval_ << jA;
_eval_ << jA1;
_eval_ << jA2m;
test 1 1
( 0 0 10 11 0 )
( 1 1 11 12 1 )
( 0 0 20 22 0 )
Thus it is possible to combine single and multiple tensors in operations applying value after value,
in which case the single tensors are considered as uniform. Note that jA1-jA is not equal to Natural1(1) but to repeat(Natural1(1),5).
Now in a loop:
_eval_ << jA + dummy_index1("",4);
0 ( 0 0 10 11 0 )
1 ( 1 1 11 12 1 )
2 ( 2 2 12 13 2 )
3 ( 3 3 13 14 3 )
From a multiple tensor, we can get the sum of its values:
_eval_ << innersum(jA);
( 21 )
or we may choose to get different innersums:
auto nSizes = NaturalN{2,3};
_eval_ << innersums(nSizes,jA); //! correct: innersum(nSizes) is equal to num(jA)
( 0 21 )
The first resulting value of is the sum of the first 2 values of jA, the second is the sum of the next three ones.
Range control
Having a 5-value tensor jA:
auto dataAA = NaturalDataN("AA",{5,10,15,20,25}); //! a container holding 5 natural values initialized with {5,10,15,20,25}
auto jA = scalarN(dataAA);
_eval_ << jA;
( 5 10 15 20 25 )
we may deduce a single one corresponding to the 3rd value:
auto iA3 = jA[3];
_eval_ << iA3;
( 20 )
It is possible to adress the n-th value through a variable or dummy index, if the index has a range that is compatible with the number of values held by the tensor:
auto dataI = NaturalData1("I");
auto iI = scalarN(dataI);
auto iAI = jA[iI]; //! run-time error: iI is not bounded
auto dataI = NaturalData1("I",{0,10});
auto iI = scalarN(dataI);
auto iAI = jA[iI]; //! run-time error: max(iI) >= 5
The current value of iI (0-initialized) has no relevancy, because iA1 must be valid for all values taken by dataI.
auto dataI = NaturalData1("I",{0,3});
auto iI = scalarN(dataI);
auto iAI = jA[iI]; //! correct: max(iI) < 5
// dataI.set_value(10); //! run-time error: dataI has range [0,3]
dataI.set_value(2);
_eval_ << iAI;
( 15 )
Note that simplifications occur:
auto j0123456 = unroll(Natural(7),0);
auto dataI = NaturalData1("I",{0,6});
auto iI = scalarN(dataI);
assert(j0123456 == NaturalN{0,1,2,3,4,5,6});
assert(j0123456[iI] == iI);
auto xyz = many({x,y,z}); // values are stacked
auto i = NaturalN(...); // assuming maxOf(i) < 3
assert(xyz[i] == select(i,{x,y,z})); // true if x, y and z are single
A decimal example with derivation
The previous considerations remain valid for decimal types. Here is an example of derivation and simplification:
auto dataX = DecimalData1("x");
auto x = scalar1(dataX);
std::cout << "test " << derivate(sin(x),x)==cos(x) << '\n';
std::cout << "test " << (pow(cos(x),2)+pow(sin(x),2))==Decimal1(1.) << '\n';
test 1
test 1
Vectors and matrices
auto s1 = ScalarN { 0,2,5,7 };
auto s2 = ScalarN { 0,2,5,7, 12,13,0,3 };
auto v1 = repack(s1,2); //! the s1 values are repacked to make two vectors of dimension 2
auto m1 = repack(s1,2,2); //! the s1 values are repacked to make one matrix of shape[2,2]
auto m2 = repack(s2,2,2); //! the s2 values are repacked to make two matrices of shape[2,2]
auto id = Tensor::identity_matrix(2);// Matrix1
if (dot(id,v1)==v1) os << "correct\n";
_eval_ << v1;
correct
[ 0] [ 5]
[ 2] [ 7]
Accessing components is done via method ._. Simplifications occur:
auto x = ScalarN(...);
auto y = ScalarN(...);
auto z = ScalarN(...);
assert(vector(x,y,z)._(0)==x);
assert(vector(x,y,z)._(1)==y);
assert(vector(x,y,z)._(2)==z);
auto i = NaturalN(...); // assuming maxOf(i) < 3
assert(vector(x,y,z)._(i) == select(i,{x,y,z}));
_eval_ << m1;
_eval_ << id;
_eval_ << m1-m1;
[ 0 5 ]
[ 2 7 ]
[ 1 0 ]
[ 0 1 ]
[ 0 0 ]
[ 0 0 ]
auto m2tm2 = m2*transpose(m2); // MatrixN
if (m2tm2==transpose(m2tm2)) os << "correct\n";
if (det(m2tm2)==pow(det(m2),2)) os << "correct\n";
_eval_ << m2*transpose(m2);
correct
correct
[ 25 35 ] [ 144 156 ]
[ 35 53 ] [ 156 178 ]
_eval_ << det(id);
_eval_ << repeat(id,5);
_eval_ << innersum(repeat(id,5));
_eval_ << innersums({2,3},repeat(id,5));
( 1 )
[ 1 0 ] [ 1 0 ] [ 1 0 ] [ 1 0 ] [ 1 0 ]
[ 0 1 ] [ 0 1 ] [ 0 1 ] [ 0 1 ] [ 0 1 ]
[ 5 0 ]
[ 0 5 ]
[ 2 0 ] [ 3 0 ]
[ 0 2 ] [ 0 3 ]