Matrix, Array, and Variable Math

Variable v1;                 // Create a Variable with a value of 0

Variable v2 = 5;             // Create a Variable with a value of 5

Variable v3 = Spacecraft1.A; // Create a Variable with the value of a Spacecraft's semi-major axis

Array a1;                           // Creates an Array with 10 elements

Array a2(3);                       // Creates an Array with 3 elements

Array a3[6];                       // Creates an Array with 6 elements

Array a4 = Spacecraft1.Position;   // Creates an Array with 3 elements and initializes it with the values of a Spacecraft's position

Matrix m1;                   // Creates a 0x0 Matrix

Matrix m2[3, 3];             // Creates a 3x3 Matrix

Matrix m3(1, 5);             // Creates a 1x5 Matrix

Matrix m4 = Spacecraft1.MOI; // Creates a 3x3 Matrix and initializes it with the values of a Spacecraft's moment of inertia

List<List<List<Variable>>> ThreeDNumericalData;

v1 = abs(Spacecraft1.I);     // Assign a Variable to the absolute value of a Spacecraft's inclination

// Assign an Array with specified numbers

a1 = {0, 1, 2, 3, 4};    

// Assign an Array using a Spacecraft's velocity.  This will grow or shrink the Array so that it has 3 elements if necessary      

a2 = Spacecraft1.Velocity;      

// Assign an Array by concatenating together numbers, Variables, and Arrays

a3 = {v1, a1, a2, 5, 6, 7};      

// Assign an Array by randomly shuffling its values

a3.Shuffle();  

// Assign values to a subset of elements in an Array.  The sizes of the Arrays on the right- and left-hand sides must match.

a3[0:2] = Spacecraft1.Position;

a3[3:5] = Spacecraft1.Velocity;

// Assign a Matrix with specified numbers

m1 = [ 2,  4,  6;

      1,  3,  5;

      0,  4,  8 ];

// Fill a Matrix with random numbers between +5 and -5

m2.FillRandom(-5, 5);

// Assign a Matrix using a Spacecraft's covariance

m3 = Spacecraft1.OD.Covariance.Matrix;

// Assign values to a subset of elements in an Matrix.  The sizes of the Matrices on the right- and left-hand sides must match.

m2[0:1, 1:2] = [ 9, 9;

                9, 9 ];

// Create a 3x3 matrix by concatenating together numbers, Arrays, Variables, and Vectors

Variable var = 5;

Array arr = {2, 4, 6};

Vector vec;

vec.Element = {7, 9, 1};

Matrix m5 = [ 0,   arr;

             var, vec ];

// Create a column matrix by concatenating together two Arrays (Spacecraft.Position and Spacecraft.Velocity) and transposing the result

Matrix m6 = [Spacecraft1.Position, Spacecraft1.Velocity].Transpose();

// Create a 3x3 matrix by concatenating together a 3x3 Matrix, a virtual column Matrix, numbers, and a row Matrix

Matrix m7;

m7.Fill(1, 3, 3);

Matrix m8 = [ 0, 0, 0, 0 ];

Matrix m9 = [ m7, [5; 5; 5];

              1,  2, 3, 4 ;

                  m8     ];

StringArray sa1;

String s1 = "x";

String s2 = "y";

// Assign a StringArray with specified numbers

sa1 = {"a", "b", "c", "d", "e"};    

// Assign a StringArray using another StringArray.  This will grow or shrink the StringArray if necessary.

sa1 = sa1.Reverse();

// Assign a StringArray by concatenating together quoted text, String objects, and StringArrays

sa1 = {sa1, "f", "g", "h", s1};      

// Assign values to a subset of elements in a StringArray.  The sizes of the StringArrays on the right- and left-hand sides must match.

sa1[1:2] = {s2, "z"};

Report v1; // Report the Variable

Report v1.ToString();     // Report the Variable as a string representation based on the magnitude of the value

Report v1.ToString("%i"); // Report the Variable as a string representation of an integer value

Report v1.ToString("%e"); // Report the Variable as a string representation of a scientific notation value

Report v1.ToString("%f"); // Report the Variable as a string representation of a floating point value

Report a3;     // Report full Array

Report a3[0];   // Report first element

Report a3[2:5]; // Report elements from index 2 to index 5

Report a3[5:2]; // Report elements from index 2 to index 5 in reverse order

Report a3[:4]; // Report all elements from the beginning to index 4

Report a3[4:]; // Report all elements from index 4 to the end

Report a3.ToStringArray();     // Report the Array as a string representation based on the magnitude of the values

Report a3.ToStringArray("%i"); // Report the Array as a string representation of the integer values

Report a3.ToStringArray("%e"); // Report the Array as a string representation of the scientific notation values

Report a3.ToStringArray("%f"); // Report the Array as a string representation of the floating point values

Report a3.GetUniqueElements;   // Report unique elements from the Array in the order in which they first appeared

Report m9;           // Report full Matrix

Report m9[0, :];     // Report first row

Report m9[:, 0];     // Report first column

Report m9[0, 2:0];   // Report elements 0-2 of the first row in reverse order

Report m9[0:1, 0:1]; // Report top-left 2x2 elements

Report m9[:1, 0];   // Report all elements from the beginning to index 1 of the first column

Report m9[1:, 0];   // Report all elements from index 1 to the end of the first column

ReportInterface ri;              

Report a3[0]              to ri; // Report the first element to a file

Report a3[2:5]            to ri; // Report elements from index 2 to index 5 to a file

Report a3[5:2]            to ri; // Report elements from index 2 to index 5 in reverse order to a file

Report a3[:4]             to ri; // Report all elements from the beginning to index 4 to a file

Report a3[4:]             to ri; // Report all elements from index 4 to the end to a file

Report a3.Format("%1.3e") to ri; // Report all elements of the array and format them (Scientific notation)

ReportInterface ri;

Report m9                 to ri; // Report full Matrix to a file

Report m9[0, :]           to ri; // Report first row to a file

Report m9[:, 0]           to ri; // Report first column to a file

Report m9[0, 2:0]         to ri; // Report elements 0-2 of the first row in reverse order to a file

Report m9.Format("%1.1e") to ri; // Report all the whole matrix and format it (Scientific notation)

// Convert an Array to a row Matrix

mat = arr.ToRowMatrix();

mat = [arr];

// Convert an Array to a column Matrix

mat = arr.ToColumnMatrix();

mat = [arr].Transpose();

// Convert an Array to a diagonal Matrix

mat = arr.ToDiagonalMatrix();

// Convert an Array to a 3-column, row-major Matrix

mat = arr.ToRowMajorMatrix(3);

// Convert an Array to a 3-row, column-major Matrix

mat = arr.ToColumnMajorMatrix(3);

// Convert a Matrix to an Array, treating the the Matrix as row-major

arr = mat.ToArrayRowMajor();

arr = {mat};

// Convert a Matrix to an Array, treating the the Matrix as column-major

arr = mat.ToArrayColumnMajor();

// Convert a Vector to an Array

arr = vec.Element;

arr = {vec};

// Convert a Vector to a Matrix

mat = [vec.Element];

mat = [vec];

// Convert an Array to a Vector

vec.Element = arr;

// Convert a Matrix to a Vector

vec.Element = {mat};

// Convert a CoordinateSystem to a Matrix

mat = [cs];

// Househoulder QR [Requirements : None]

mat = matrix1.Solve(matrix2, 0)

// Partial Pivot LU [Requirements : Calling Matrix must be square and invertible]

mat = matrix1.Solve(matrix2, 1)

// Full Pivot LU [Requires : Calling Matrix must be square; Useful when calling Matrix is not full rank]

mat = matrix1.Solve(matrix2, 2)

// Column Pivot Householder QR [Requirements : None; Useful when calling Matrix is not full rank]

mat = matrix1.Solve(matrix2, 3)

// Full Pivot Householder QR [Requirements : None; Useful when calling Matrix is full rank]

mat = matrix1.Solve(matrix2, 4)

// LLT [Requirements : Calling Matrix must be positive definite]

mat = matrix1.Solve(matrix2, 5)

// LDLT [Requirements : Calling Matrix must be positive or negative semi-definite]

mat = matrix1.Solve(matrix2, 6)

// Jacobi SVD [Requirements : None]

mat = matrix1.Solve(matrix2, 7)