﻿Tensor.Fill(3, 2, 4)
Tensor.Fill(true, 2, 4)

Tensor.Fill("Hi", -5)
Tensor.Fill(1.5r4, 1_000_000_000_000_000)

Tensor.Fill("Hi", 5 - 7)
Tensor.Fill(1.5r4, 1 shl 50)

Tensor.From([1, 2, 3])
Tensor.From(Range(10))

Tensor.From(Range(12), 2, 3, 2) // Precise type
Tensor.From(Range(12), 3, 2, 2)
Tensor.From(Range(12), 2 * 2, 3) // Loose type

Tensor.From(Range(12), 3, -3, 2)
Tensor.From(Range(12), 3, 0x1_0000_0000, 2)

Tensor.Fill(3, 0)
Tensor.Fill(3, 0, 1)
Tensor.Fill(3, 1, 0)

Tensor.From(Range(12), 0)
Tensor.From(Range(12), 0, 1)
Tensor.From(Range(12), 1, 0)

Tensor.From([1,2,3], -3, 10)

// Too large.
// Tensor.From(Range(12), 1 shl 50)
// Tensor.Fill(3, 0x7FFFFFFFFFFFFFFF)

:: {g:g*, o:o*, s:s*, b:b*, qb:b?*, d:d*, qd:d?*, n:n*, qn:n?*, r8:r8*, qr8:r8?*, r4:r4*, qr4:r4?*, i:i*, qi:i?*, i8:i8*, qi8:i8?*, i4:i4*, qi4:i4?*, i2:i2*, qi2:i2?*, i1:i1*, qi1:i1?*, u8:u8*, qu8:u8?*, u4:u4*, qu4:u4?*, u2:u2*, qu2:u2?*, u1:u1*, qu1:u1?*, R:{A:s,B:b}*, QR:{A:s,B:b}?*, x:i8, y:i4, xs:i8*, ys:i4* }
Tensor.From(i8)
Tensor.From(i8, 3)
Tensor.From(i8, x, x)
Tensor.From(i8, x, y)
Tensor.From(i8, 3.0)

Tensor.From(g, 3, 4)
Tensor.From(s, 3, 4)
Tensor.From(b, 3, 4)
Tensor.From(qb, 3, 4)
Tensor.From(d, 3, 4)
Tensor.From(qd, 3, 4)
Tensor.From(n, 3, 4)
Tensor.From(qn, 3, 4)
Tensor.From(r8, 3, 4)
Tensor.From(qr8, 3, 4)
Tensor.From(r4, 3, 4)
Tensor.From(qr4, 3, 4)
Tensor.From(i, 3, 4)
Tensor.From(qi, 3, 4)
Tensor.From(i8, 3, 4)
Tensor.From(qi8, 3, 4)
Tensor.From(i4, 3, 4)
Tensor.From(qi4, 3, 4)
Tensor.From(i2, 3, 4)
Tensor.From(qi2, 3, 4)
Tensor.From(i1, 3, 4)
Tensor.From(qi1, 3, 4)
Tensor.From(u8, 3, 4)
Tensor.From(qu8, 3, 4)
Tensor.From(u4, 3, 4)
Tensor.From(qu4, 3, 4)
Tensor.From(u2, 3, 4)
Tensor.From(qu2, 3, 4)
Tensor.From(u1, 3, 4)
Tensor.From(qu1, 3, 4)
Tensor.From(R, 3, 4)
Tensor.From(QR, 3, 4)

// Lifting
Tensor.From(i8, [3, 5], [4, 6])
Tensor.From(i8, xs, xs)

Tensor.Fill(i8)
Tensor.Fill(i8, 3)
Tensor.Fill(i8, x, x)
Tensor.Fill(i8, x, y)
Tensor.Fill(i8, xs, xs)
Tensor.Fill(i8, xs, ys)

Tensor.Fill(g, 3, 4)
Tensor.Fill(s, 3, 4)
Tensor.Fill(b, 3, 4)
Tensor.Fill(qb, 3, 4)
Tensor.Fill(d, 3, 4)
Tensor.Fill(qd, 3, 4)
Tensor.Fill(n, 3, 4)
Tensor.Fill(qn, 3, 4)
Tensor.Fill(r8, 3, 4)
Tensor.Fill(qr8, 3, 4)
Tensor.Fill(r4, 3, 4)
Tensor.Fill(qr4, 3, 4)
Tensor.Fill(i, 3, 4)
Tensor.Fill(qi, 3, 4)
Tensor.Fill(i8, 3, 4)
Tensor.Fill(qi8, 3, 4)
Tensor.Fill(i4, 3, 4)
Tensor.Fill(qi4, 3, 4)
Tensor.Fill(i2, 3, 4)
Tensor.Fill(qi2, 3, 4)
Tensor.Fill(i1, 3, 4)
Tensor.Fill(qi1, 3, 4)
Tensor.Fill(u8, 3, 4)
Tensor.Fill(qu8, 3, 4)
Tensor.Fill(u4, 3, 4)
Tensor.Fill(qu4, 3, 4)
Tensor.Fill(u2, 3, 4)
Tensor.Fill(qu2, 3, 4)
Tensor.Fill(u1, 3, 4)
Tensor.Fill(qu1, 3, 4)
Tensor.Fill(R, 3, 4)
Tensor.Fill(QR, 3, 4)

:: {g:g, o:o, s:s, b:b, qb:b?, d:d, qd:d?, n:n, qn:n?, r8:r8, qr8:r8?, r4:r4, qr4:r4?, i:i, qi:i?, i8:i8, qi8:i8?, i4:i4, qi4:i4?, i2:i2, qi2:i2?, i1:i1, qi1:i1?, u8:u8, qu8:u8?, u4:u4, qu4:u4?, u2:u2, qu2:u2?, u1:u1, qu1:u1?, R:{A:s,B:b}, QR:{A:s,B:b}?, x:i8, y:i4 }
Tensor.Fill(i8)
Tensor.Fill(i8, 3)
Tensor.Fill(i8, x, x)
Tensor.Fill(i8, x, y)
Tensor.Fill(i8, 3.0)

Tensor.Fill(g, 3, 4)
Tensor.Fill(s, 3, 4)
Tensor.Fill(b, 3, 4)
Tensor.Fill(qb, 3, 4)
Tensor.Fill(d, 3, 4)
Tensor.Fill(qd, 3, 4)
Tensor.Fill(n, 3, 4)
Tensor.Fill(qn, 3, 4)
Tensor.Fill(r8, 3, 4)
Tensor.Fill(qr8, 3, 4)
Tensor.Fill(r4, 3, 4)
Tensor.Fill(qr4, 3, 4)
Tensor.Fill(i, 3, 4)
Tensor.Fill(qi, 3, 4)
Tensor.Fill(i8, 3, 4)
Tensor.Fill(qi8, 3, 4)
Tensor.Fill(i4, 3, 4)
Tensor.Fill(qi4, 3, 4)
Tensor.Fill(i2, 3, 4)
Tensor.Fill(qi2, 3, 4)
Tensor.Fill(i1, 3, 4)
Tensor.Fill(qi1, 3, 4)
Tensor.Fill(u8, 3, 4)
Tensor.Fill(qu8, 3, 4)
Tensor.Fill(u4, 3, 4)
Tensor.Fill(qu4, 3, 4)
Tensor.Fill(u2, 3, 4)
Tensor.Fill(qu2, 3, 4)
Tensor.Fill(u1, 3, 4)
Tensor.Fill(qu1, 3, 4)
Tensor.Fill(R, 3, 4)
Tensor.Fill(QR, 3, 4)

// Errors
Tensor.From(i8)
Tensor.From(i8, 3)
Tensor.From(i8, x, x)
Tensor.From(i8, x, y)

Tensor.From(g, 3, 4)
Tensor.From(s, 3, 4)
Tensor.From(b, 3, 4)
Tensor.From(qb, 3, 4)
Tensor.From(d, 3, 4)
Tensor.From(qd, 3, 4)
Tensor.From(n, 3, 4)
Tensor.From(qn, 3, 4)
Tensor.From(r8, 3, 4)
Tensor.From(qr8, 3, 4)
Tensor.From(r4, 3, 4)
Tensor.From(qr4, 3, 4)
Tensor.From(i, 3, 4)
Tensor.From(qi, 3, 4)
Tensor.From(i8, 3, 4)
Tensor.From(qi8, 3, 4)
Tensor.From(i4, 3, 4)
Tensor.From(qi4, 3, 4)
Tensor.From(i2, 3, 4)
Tensor.From(qi2, 3, 4)
Tensor.From(i1, 3, 4)
Tensor.From(qi1, 3, 4)
Tensor.From(u8, 3, 4)
Tensor.From(qu8, 3, 4)
Tensor.From(u4, 3, 4)
Tensor.From(qu4, 3, 4)
Tensor.From(u2, 3, 4)
Tensor.From(qu2, 3, 4)
Tensor.From(u1, 3, 4)
Tensor.From(qu1, 3, 4)
Tensor.From(R, 3, 4)
Tensor.From(QR, 3, 4)

:: { T:i8[*,3], Ts:i8[*,3]*, QT:i8[*,3]?, QTs:i8[*,3]?*, U:i8[4,3,2], Us:i8[4,3,2]*, QU:i8[4,3,2]?, QUs:i8[4,3,2]?*, R:{A:i4}, Rs:{A:i4}*, QR:{A:i4}?, QRs:{A:i4}?*, s:s, r:{}, ss:s* }

T.Rank
T->Rank()
T->Tensor.Rank()
Ts.Rank
Ts->Rank()
Ts->Tensor.Rank()
QT.Rank
QT->Rank()
QT->Tensor.Rank()
QTs.Rank
QTs->Rank()
QTs->Tensor.Rank()

U.Rank
U->Rank()
U->Tensor.Rank()
Us.Rank
Us->Rank()
Us->Tensor.Rank()
QU.Rank
QU->Rank()
QU->Tensor.Rank()
QUs.Rank
QUs->Rank()
QUs->Tensor.Rank()

// Errors
R.Rank
R->Rank()
R->Tensor.Rank()
Rs.Rank
Rs->Rank()
Rs->Tensor.Rank()
QR.Rank
QR->Rank()
QR->Tensor.Rank()
QRs.Rank
QRs->Rank()
QRs->Tensor.Rank()

T.Shape
T->Shape()
T->Tensor.Shape()
Ts.Shape
Ts->Shape()
Ts->Tensor.Shape()
QT.Shape
QT->Shape()
QT->Tensor.Shape()
QTs.Shape
QTs->Shape()
QTs->Tensor.Shape()

U.Shape
U->Shape()
U->Tensor.Shape()
Us.Shape
Us->Shape()
Us->Tensor.Shape()
QU.Shape
QU->Shape()
QU->Tensor.Shape()
QUs.Shape
QUs->Shape()
QUs->Tensor.Shape()

// Errors
R.Shape
R->Shape()
R->Tensor.Shape()
Rs.Shape
Rs->Shape()
Rs->Tensor.Shape()
QR.Shape
QR->Shape()
QR->Tensor.Shape()
QRs.Shape
QRs->Shape()
QRs->Tensor.Shape()

T.Values
T->Values()
T->Tensor.Values()
Ts.Values
Ts->Values()
Ts->Tensor.Values()
QT.Values
QT->Values()
QT->Tensor.Values()
QTs.Values
QTs->Values()
QTs->Tensor.Values()

U.Values
U->Values()
U->Tensor.Values()
Us.Values
Us->Values()
Us->Tensor.Values()
QU.Values
QU->Values()
QU->Tensor.Values()
QUs.Values
QUs->Values()
QUs->Tensor.Values()

Tensor.Values(Null(T))

T->Reshape(4, 7, 8)
T->Tensor.Reshape(4, 7, 8)
Ts->Reshape(4, 7, 8)
Ts->Tensor.Reshape(4, 7, 8)
QT->Reshape(4, 7, 8)
QT->Tensor.Reshape(4, 7, 8)
QTs->Reshape(4, 7, 8)
QTs->Tensor.Reshape(4, 7, 8)

U->Reshape(4, 7, 8)
U->Tensor.Reshape(4, 7, 8)
Us->Reshape(4, 7, 8)
Us->Tensor.Reshape(4, 7, 8)
QU->Reshape(4, 7, 8)
QU->Tensor.Reshape(4, 7, 8)
QUs->Reshape(4, 7, 8)
QUs->Tensor.Reshape(4, 7, 8)

T->Reshape()
T->Reshape(4)
T->Reshape(4, 7)
T->Reshape(4, 7, 8)->Reshape()
T->Reshape()->Reshape(4, 7, 8)
T->Reshape(-1)
T->Reshape(-1, -2)

// Errors
R->Reshape(4, 7, 8)
R->Tensor.Reshape(4, 7, 8)
Rs->Reshape(4, 7, 8)
Rs->Tensor.Reshape(4, 7, 8)
QR->Reshape(4, 7, 8)
QR->Tensor.Reshape(4, 7, 8)
QRs->Reshape(4, 7, 8)
QRs->Tensor.Reshape(4, 7, 8)

T->Reshape(s)
T->Reshape(ss)
T->Reshape(r)
T->Reshape(4.0)

:: {g:g[4,3], o:o[4,3], s:s[4,3], b:b[4,3], qb:b?[4,3], d:d[4,3], qd:d?[4,3], n:n[4,3], qn:n?[4,3], r8:r8[4,3], qr8:r8?[4,3], r4:r4[4,3], qr4:r4?[4,3], i:i[4,3], qi:i?[4,3], i8:i8[4,3], qi8:i8?[4,3], i4:i4[4,3], qi4:i4?[4,3], i2:i2[4,3], qi2:i2?[4,3], i1:i1[4,3], qi1:i1?[4,3], u8:u8[4,3], qu8:u8?[4,3], u4:u4[4,3], qu4:u4?[4,3], u2:u2[4,3], qu2:u2?[4,3], u1:u1[4,3], qu1:u1?[4,3], R:{A:s,B:b}[4,3], QR:{A:s,B:b}?[4,3], x:i4, y:i4 }
Tensor.Transpose(g)
Tensor.Transpose(s)
Tensor.Transpose(b)
Tensor.Transpose(qb)
Tensor.Transpose(d)
Tensor.Transpose(qd)
Tensor.Transpose(n)
Tensor.Transpose(qn)
Tensor.Transpose(r8)
Tensor.Transpose(qr8)
Tensor.Transpose(r4)
Tensor.Transpose(qr4)
Tensor.Transpose(i)
Tensor.Transpose(qi)
Tensor.Transpose(i8)
Tensor.Transpose(qi8)
Tensor.Transpose(i4)
Tensor.Transpose(qi4)
Tensor.Transpose(i2)
Tensor.Transpose(qi2)
Tensor.Transpose(i1)
Tensor.Transpose(qi1)
Tensor.Transpose(u8)
Tensor.Transpose(qu8)
Tensor.Transpose(u4)
Tensor.Transpose(qu4)
Tensor.Transpose(u2)
Tensor.Transpose(qu2)
Tensor.Transpose(u1)
Tensor.Transpose(qu1)
Tensor.Transpose(R)
Tensor.Transpose(QR)

Tensor.Transpose(g, 0, 1)
Tensor.Transpose(s, 0, 1)
Tensor.Transpose(i8, 0, 1)
Tensor.Transpose(r8, 0, 1)

Tensor.Transpose(i8, x)
Tensor.Transpose(i8, x, y)
Tensor.Transpose(i8, x, 1)
Tensor.Transpose(i8, 2, -2)
Tensor.Transpose(i8, 0, 0)
Tensor.Transpose(i8, [], "")

Tensor.Transpose(i8, 1i2, 0i1)
Tensor.Transpose(i8, 1ia, 0ia)
Tensor.Transpose(i8, 1+0, 0+0)

Tensor.ExpandDims(g, 0)
Tensor.ExpandDims(s, 0)
Tensor.ExpandDims(b, 0)
Tensor.ExpandDims(qb, 0)
Tensor.ExpandDims(d, 0)
Tensor.ExpandDims(qd, 0)
Tensor.ExpandDims(n, 0)
Tensor.ExpandDims(qn, 0)
Tensor.ExpandDims(r8, 0)
Tensor.ExpandDims(qr8, 0)
Tensor.ExpandDims(r4, 0)
Tensor.ExpandDims(qr4, 0)
Tensor.ExpandDims(i, 0)
Tensor.ExpandDims(qi, 0)
Tensor.ExpandDims(i8, 0)
Tensor.ExpandDims(qi8, 0)
Tensor.ExpandDims(i4, 0)
Tensor.ExpandDims(qi4, 0)
Tensor.ExpandDims(i2, 0)
Tensor.ExpandDims(qi2, 0)
Tensor.ExpandDims(i1, 0)
Tensor.ExpandDims(qi1, 0)
Tensor.ExpandDims(u8, 0)
Tensor.ExpandDims(qu8, 0)
Tensor.ExpandDims(u4, 0)
Tensor.ExpandDims(qu4, 0)
Tensor.ExpandDims(u2, 0)
Tensor.ExpandDims(qu2, 0)
Tensor.ExpandDims(u1, 0)
Tensor.ExpandDims(qu1, 0)
Tensor.ExpandDims(R, 0)
Tensor.ExpandDims(QR, 0)

Tensor.ExpandDims(g, 0, 3)
Tensor.ExpandDims(s, 0, 3)
Tensor.ExpandDims(i8, 0, 3)
Tensor.ExpandDims(r8, 0, 3)

Tensor.ExpandDims(i8, x)
Tensor.ExpandDims(i8, x, y)
Tensor.ExpandDims(i8, x, 1)
Tensor.ExpandDims(i8, 4, -2)
Tensor.ExpandDims(i8, 3, "")
Tensor.ExpandDims(i8, 0, 0)
Tensor.ExpandDims(i8, [], "")

Tensor.ExpandDims(i8, 1i2, 0i1)
Tensor.ExpandDims(i8, 1ia, 0ia)
Tensor.ExpandDims(i8, 1+0, 0+0)

:: { T:i8[*,3], Ts:i8[*,3]*, QT:i8[*,3]?, QTs:i8[*,3]?*, U:i8[4,3,2], Us:i8[4,3,2]*, QU:i8[4,3,2]?, QUs:i8[4,3,2]?*, R:{A:i4}, Rs:{A:i4}*, QR:{A:i4}?, QRs:{A:i4}?*, s:s, r:{}, ss:s* }

T->Transpose()
Ts->Transpose()
QT->Transpose()
U->Transpose()
QU->Transpose()
QUs->Transpose()

T->Transpose(1,0)
Ts->Transpose(1,0)
QT->Transpose(1,0)
U->Transpose(2,1,0)
QU->Transpose(2,1,0)
QUs->Transpose(2,1,0)

T->ExpandDims(0)
Ts->ExpandDims(0)
QT->ExpandDims(0)
U->ExpandDims(0)
QU->ExpandDims(0)
QUs->ExpandDims(0)

// Errors
T.Transpose
Ts.Transpose
QT.Transpose
U.Transpose
QU.Transpose
QUs.Transpose
R->Transpose()
R->Tensor.Transpose()
Rs->Transpose()
Rs->Tensor.Transpose()
QR->Transpose()
QR->Tensor.Transpose()
QRs->Transpose()
QRs->Tensor.Transpose()

:: { T0:i8[], T1:i8[2], T2:i8[2,3], T3:i8[2,3,4], T4:i8[2,3,4,5] }
T0->Transpose()
T1->Transpose()
T2->Transpose()
T3->Transpose()
T4->Transpose()

T0->Transpose(0)

T1->Transpose(0)
T1->Transpose(1)
T1->Transpose(0,1)

T2->Transpose(0,1)
T2->Transpose(1,0)
T2->Transpose(2,0,1)

T3->Transpose(0,1,2)
T3->Transpose(2,0,1)
T3->Transpose(0,2,1)
T3->Transpose(0,3,1,2)

T4->Transpose(0,1,2,3)
T4->Transpose(2,0,3,1)
T4->Transpose(0,3,2,1)
T4->Transpose(0,3,1,2)
T4->Transpose(3,0,2,1)
T4->Transpose(3,0,2,1,4)
T4->Transpose(3,1,4)

T0->ExpandDims(0)
T0->ExpandDims(1)
T0->ExpandDims(1,0)

T1->ExpandDims(0)
T1->ExpandDims(0,2)

T2->ExpandDims(0)
T2->ExpandDims(2)
T2->ExpandDims(0,3)
T2->ExpandDims(1,3)
T2->ExpandDims(2,3)
T2->ExpandDims(5,2,0,4)
T2->ExpandDims(5,0,7,4)

T3->ExpandDims(0)
T3->ExpandDims(3)
T3->ExpandDims(0,4)
T3->ExpandDims(1,4)
T3->ExpandDims(2,3)
T3->ExpandDims(5,2,0,4)
T3->ExpandDims(5,0,8,4)

T4->ExpandDims(0)
T4->ExpandDims(4)
T4->ExpandDims(0,5)
T4->ExpandDims(1,5)
T4->ExpandDims(2,3)
T4->ExpandDims(7,3,1,0,4,9,10)
T4->ExpandDims(5,0,8,4)
