API tools faq
paste
gullinbursti

xtending AS3 Maxtrix Operations

gullinbursti
May 15th, 2011
781
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
ActionScript 3 16.15 KB | None | 0 0
raw download clone embed print report
  1. package cc.gullinbursti.math.algebra {
  2.    
  3.     //] includes [!]>
  4.     //]=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~.
  5.     import cc.gullinbursti.lang.Arrays;
  6.     import cc.gullinbursti.lang.Numbers;
  7.    
  8.     import flash.geom.Matrix;
  9.     import flash.geom.Point;
  10.  
  11.     //]~=~=~=~=~=~=~=~=~=~=~=~=~=~[]~=~=~=~=~=~=~=~=~=~=~=~=~=~[
  12.    
  13.     // <[!] class delaration [!]>
  14.     public class Matrices extends BasicAlgebra {
  15.     //~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~~*~._
  16.         //TODO: define & implement some matrix operations [http://mathworld.wolfram.com/topics/MatrixTypes.html]
  17.         // orthogonal matrix
  18.         // hat matrix
  19.         // random matrix [http://en.wikipedia.org/wiki/Random_matrix]
  20.         // permutation matrix [http://en.wikipedia.org/wiki/Permutation_matrix]
  21.         // triangular matrix [http://en.wikipedia.org/wiki/Triangular_matrix]
  22.        
  23.         // derterminant [http://planetmath.org/encyclopedia/Determinant2.html]
  24.         // trace [http://planetmath.org/encyclopedia/Trace.html]
  25.         // eigenvalue [http://en.wikipedia.org/wiki/Eigenvalues_and_eigenvectors] [http://planetmath.org/encyclopedia/SpectralValue.html]
  26.         // matrix exponential [http://planetmath.org/encyclopedia/MatrixExponential.html]
  27.        
  28.        
  29.         public function Matrices() {/* …\(^_^)/… */}
  30.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  31.        
  32.         //]~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=[>
  33.         //]~=~=~=~=~=~=~=~=~=[>
  34.        
  35.         // http://en.wikipedia.org/wiki/Dual_number
  36.         public static function dualNumber(val:int):Matrix {
  37.         //~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~~*~._
  38.             //TODO: implement the matrix dual # operation
  39.            
  40.             return (new  Matrix());
  41.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  42.        
  43.         /*
  44.         public static function cofactors(mtx:Array):Array {
  45.         //~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~~*~._
  46.            
  47.             var i:int;
  48.             var j:int;
  49.             var mult:int;
  50.             var size:int = mtx.length;
  51.             var factor_arr:Array = new Array();
  52.             var col_arr:Array = new Array();
  53.             var coeff_arr:Array = new Array();
  54.             var minor_arr:Array = new Array();
  55.            
  56.             for (i=0; i<size; i++)
  57.                 factor_arr.push(mtx[i][0]);
  58.            
  59.            
  60.             for (j=1; j<size; j++) {
  61.                 col_arr = [];
  62.                
  63.                 for (i=1; i<size; i++) {
  64.                     col_arr.push(mtx[j][i]);
  65.                 }
  66.                
  67.                 coeff_arr.push(col_arr);
  68.                 minor_arr.push(expMinor(factor_arr[i], cof_arr));
  69.                
  70.             }
  71.            
  72.             for (i=0; i<size; i++) {
  73.                 if (i % 2 == 0)
  74.                     mult = 1;
  75.                 else
  76.                     mult = -1;
  77.             }
  78.            
  79.            
  80.             return (cof_arr);
  81.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  82.         */
  83.         private static function expMinor(factor:Number, coeff_arr:Array):Number {
  84.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  85.            
  86.             /**
  87.              * 4×⎡1 3⎤ = 4((1×0) - (2×3))
  88.              *   ⎣2 0⎦
  89.              **/
  90.            
  91.             // only perform on a 2×2 matrix
  92.             if (coeff_arr.length == 2 && (coeff_arr[0] as Array).length == 2)
  93.                 return (factor * ((coeff_arr[0][0] * coeff_arr[1][1]) - (coeff_arr[1][0] * coeff_arr[0][1])));
  94.            
  95.             // return 0
  96.             return (0);
  97.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  98.        
  99.         public static function genIdenty(dim:Point):Array {
  100.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  101.            
  102.             var ident_arr:Array = new Array();
  103.             var factor_arr:Array = new Array();
  104.            
  105.             for (var j:int=0; j<dim.y; j++) {
  106.                 factor_arr = [];
  107.                
  108.                 for (var i:int=0; i<dim.x; i++)
  109.                     factor_arr.push(int(i == j));
  110.                
  111.                 ident_arr.push(factor_arr);
  112.             }
  113.            
  114.            
  115.             return (ident_arr);
  116.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  117.        
  118.        
  119.         public static function genIdempotent(mtx:Array):Array {
  120.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  121.            
  122.             /**
  123.              *  An idempotent matrix multiplied by itself, yields itself:
  124.              *
  125.              * ⎡0 0 0⎤
  126.              * ⎢0 0 0⎢ ×
  127.              * ⎣0 0 0⎦
  128.              **/
  129.            
  130.             return ([]);
  131.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  132.        
  133.        
  134.         public function genTranspose(mtx:Array):Array {
  135.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  136.            
  137.             /**
  138.              * ⎡1 3⎤  ⎡1 2 4⎤
  139.              * ⎢2 0⎢  ⎣3 0 7⎦
  140.              * ⎣4 7⎦
  141.              **/
  142.            
  143.             var i:int;
  144.             var j:int;
  145.             var cnt:int = 0;
  146.            
  147.             var tmp_arr:Array = new Array();
  148.             var factor_arr:Array = new Array();
  149.             var trans_arr:Array = new Array();
  150.            
  151.            
  152.             for (i=0; i<(mtx[0] as Array).length; i++) {
  153.                 for (j=0; j<mtx.length; j++) {
  154.                     tmp_arr.push(mtx[j][i]);
  155.                 }
  156.             }
  157.            
  158.             for (j=0; j<mtx.length; j++) {
  159.                 factor_arr = [];
  160.                
  161.                 for (i=0; i<(mtx[0] as Array).length; i++)
  162.                     factor_arr.push(tmp_arr[cnt++]);
  163.                    
  164.                 trans_arr.push(factor_arr);
  165.             }
  166.                
  167.            
  168.             return (trans_arr)
  169.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  170.        
  171.        
  172.         /**
  173.          * Constructs an <code>Array</code> representation of a matrix, all filled w/ zeroes.
  174.          * @param dim The w/h of the matrix.
  175.          * @return A list w × h elements consisting of zero values.
  176.          *
  177.          */    
  178.         public static function genZeroMatrix(dim:Point):Array {
  179.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  180.            
  181.             /**
  182.              * ⎡0 0 0⎤
  183.              * ⎢0 0 0⎢
  184.              * ⎣0 0 0⎦
  185.              **/
  186.            
  187.             // array rep of the matrix
  188.             var zero_arr:Array = new Array();
  189.             var factor_arr:Array = new Array();
  190.            
  191.             // loop thru rows x cols, and push zero into each element
  192.             for (var j:int=0; j<dim.y; j++) {
  193.                 factor_arr = [];
  194.                
  195.                 for (var i:int=0; i<dim.x; i++)
  196.                     factor_arr.push(0);
  197.                
  198.                 zero_arr.push(factor_arr);
  199.             }
  200.            
  201.             // send it back
  202.             return (zero_arr);
  203.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  204.        
  205.        
  206.         /**
  207.          * Constructs a the additive identity (zero) matrix represented by an <code>Array</code>.
  208.          * @param dim The w/h of the matrix.
  209.          * @return A list w × h elements as the identity.
  210.          *
  211.          */    
  212.         public static function additiveIdent(dim:Point):Array {
  213.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  214.            
  215.             /**
  216.              * Additive identity of a matrix states:
  217.              *
  218.              *  ⎡1 2 1⎤   ⎡0 0 0⎤   ⎡0 0 0⎤
  219.              *  ⎢1 1 4⎢ + ⎢0 0 0⎢ = ⎢0 0 0⎢
  220.              *  ⎣2 0 3⎦   ⎣0 0 0⎦   ⎣0 0 0⎦
  221.              *
  222.  
  223.              **/
  224.            
  225.             // use the zero matrix generator
  226.             return (genZeroMatrix(dim));
  227.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  228.        
  229.        
  230.         public function isBinary(mtx:Array):Boolean {
  231.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  232.            
  233.             for (var j:int=0; j<mtx.length; j++) {
  234.                 for (var i:int=0; i<(mtx[0] as Array).length; i++) {
  235.                     if (mtx[j][i] != 0 || mtx[j][i] != 1)
  236.                         return (false);
  237.                 }
  238.             }
  239.            
  240.             return (true)
  241.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  242.        
  243.        
  244.         public function isDiagnal(mtx:Array):Boolean {
  245.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  246.            
  247.             for (var j:int=0; j<mtx.length; j++) {
  248.                 for (var i:int=0; i<(mtx[0] as Array).length; i++) {
  249.                     if (i != j && mtx[j][i] != 0)
  250.                         return (false);
  251.                 }
  252.             }
  253.            
  254.             return (true)
  255.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  256.        
  257.        
  258.         /**
  259.          * Generates the identity matrix represented as an <code>Array</code> for a given dimension.
  260.          * @param mtx The square matrix as 2 dimensional list to create identity for.
  261.          * @return A list of
  262.          *
  263.          */    
  264.         public static function invert(mtx:Array):Array {
  265.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  266.            
  267.             // return empty array if it's not square
  268.             if (mtx.length != (mtx[0] as Array).length)
  269.                 return ([]);
  270.            
  271.             // loop iterators
  272.             var i:int;
  273.             var j:int;
  274.             //var cnt:int = 0;
  275.             var piv:int = 0;
  276.            
  277.             // dimension
  278.             var size:int = mtx.length;
  279.             var row_arr:Array = new Array();
  280.            
  281.             // identity
  282.             var ident_arr:Array = genIdenty(new Point(size, size));
  283.            
  284.             // return array
  285.             var invert_arr:Array = genZeroMatrix(new Point(size * 2, size));
  286.            
  287.            
  288.             // build augmented matrix
  289.             for (j=0; j<size; j++) {
  290.                 for (i=0; i<size*2; i++) {
  291.                    
  292.                     // src
  293.                     if (i < size)
  294.                         invert_arr[j][i] = mtx[j][i];
  295.                    
  296.                     // ident
  297.                     else
  298.                         invert_arr[j][i] = ident_arr[j][i - size];
  299.                 }
  300.             }
  301.            
  302.            
  303.             while (piv < size) {
  304.                 row_arr = [];
  305.                
  306.                 for (i=0; i<size; i++) {
  307.                     if (i != piv)
  308.                         row_arr.push(invert_arr[i]);
  309.                 }
  310.                
  311.                 //trace ("invert_arr["+piv+"]["+piv+"]:"+invert_arr[piv][piv]);
  312.                 if (invert_arr[piv][piv] != 1)
  313.                     reduce(invert_arr[piv], invert_arr[piv][piv]);
  314.                 //trace ("invert_arr["+piv+"]: "+invert_arr[piv]);
  315.                
  316.                 invert_arr = pivot(piv, invert_arr[piv], row_arr);
  317.                 piv++;
  318.             }
  319.            
  320.            
  321.             for (j=0; j<size; j++) {
  322.                 for (i=0; i<size; i++)
  323.                     (invert_arr[j] as Array).shift();
  324.             }
  325.            
  326.             return (invert_arr);
  327.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  328.        
  329.        
  330.         public static function adjoint(mtx:Array):Array {
  331.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  332.            
  333.             /**
  334.              * + - +
  335.              * - + -
  336.              * + - +
  337.              */
  338.            
  339.            
  340.             return (mtx);
  341.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  342.        
  343.        
  344.         public static function determinant(mtx:Array):Number {
  345.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  346.            
  347.             /**
  348.              *
  349.              *
  350.              *
  351.              */
  352.            
  353.             var i:int;
  354.             var j:int;
  355.            
  356.             var size:int = mtx.length;
  357.             var fact:Number = 0;
  358.             var mult:int = 1;
  359.             var discrim:Number = 0;
  360.            
  361.             var factor_arr:Array = new Array();
  362.             var row_arr:Array = new Array();
  363.             var sub_arr:Array = new Array();
  364.             var cof_arr:Array = new Array();
  365.            
  366.             for (var q:int=0; q<size; q++) {
  367.                 factor_arr.push(mtx[q][0]);
  368.                
  369.                 if (q % 2 == 0)
  370.                     mult = 1;
  371.                    
  372.                 else
  373.                     mult = -1;
  374.                
  375.                 sub_arr = [];
  376.                 for (j=1; j<size; j++) {
  377.                     row_arr = [];
  378.                    
  379.                     for (i=1; i<size; i++)
  380.                         row_arr.push(mtx[j][i])
  381.                            
  382.                     sub_arr.push(row_arr);
  383.                 }
  384.                
  385.                 discrim += multiplyByFactor(sub_arr, factor_arr[q]);
  386.                
  387.                 cof_arr.push(sub_arr);
  388.             }
  389.            
  390.             for (q=0; q<size; q++) {
  391.                 if (q % 2 == 0)
  392.                     mult = 1;
  393.                
  394.                 else
  395.                     mult = -1;
  396.             }
  397.            
  398.             return (discrim);
  399.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  400.        
  401.        
  402.         public static function multiply(mtx1_arr:Array, mtx2_arr:Array):Array {
  403.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  404.            
  405.             var i:int;
  406.             var j:int;
  407.             var q:int;
  408.             var r:int;
  409.            
  410.             var prod_arr:Array = new Array();
  411.            
  412.             var rows:int = mtx1_arr.length;
  413.             var cols:int = (mtx2_arr[0] as Array).length;
  414.            
  415.            
  416.             if ((mtx1_arr[i] as Array).length != mtx2_arr.length)
  417.                 return ([]);
  418.            
  419.            
  420.             // prime
  421.             for (i=0; i<rows; i++) {
  422.                
  423.                 var factor_arr:Array = new Array();
  424.                 for (j=0; j<cols; j++)
  425.                     factor_arr.push(0);
  426.                
  427.                 prod_arr.push(factor_arr);
  428.             }
  429.            
  430.             // loop thru each col in matrix 2
  431.             for (i=0; i<rows; i++) {
  432.                
  433.                 // loop thru each row in matrix 1
  434.                 for (j=0; j<cols; j++) {
  435.                    
  436.                    
  437.                     var val:Number = 0;
  438.                    
  439.                     // loop thru each col in matrix 1
  440.                     for (q=0; q<(mtx1_arr[i] as Array).length; q++)
  441.                         val += mtx1_arr[i][q] * mtx2_arr[q][j];
  442.                    
  443.                     prod_arr[i][j] = val;
  444.                 }
  445.             }
  446.            
  447.            
  448.             return (prod_arr);
  449.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  450.        
  451.        
  452.        
  453.         public static function add(mtx1:Array, mtx2:Array):Array {
  454.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  455.            
  456.            
  457.             /**
  458.              * ⎡1 3⎤   ⎡1 2⎤   ⎡(1+1) (3+2)⎤
  459.              * ⎢2 0⎢ + ⎢4 3⎢ = ⎢(2+4) (0+3)⎢
  460.              * ⎣4 7⎦   ⎣0 1⎦   ⎣(4+0) (7+1)⎦
  461.              **/
  462.            
  463.            
  464.             var sum_arr:Array = new Array();
  465.             var factor_arr:Array = new Array();
  466.            
  467.            
  468.             for(var i:int=0; i<mtx1.length; i++)
  469.                 sum_arr.push(mtx1[i] + mtx2[i]);
  470.            
  471.            
  472.             return (sum_arr);
  473.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  474.        
  475.            
  476.         public static function multiplyByFactor(mtx_arr:Array, factor:Number):Array {
  477.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  478.            
  479.             var factor_arr:Array = new Array();
  480.             var prod_arr:Array = new Array();
  481.            
  482.             for (var j:int=0; j<mtx_arr.length; j++) {
  483.                     factor_arr = [];
  484.                
  485.                 if (mtx_arr[0] as Array) {
  486.                     for (var i:int=0; i<(mtx_arr[0] as Array).length; i++) {
  487.                         if (mtx_arr[j][i] == 0)
  488.                             factor_arr.push(0);
  489.                    
  490.                         else
  491.                             factor_arr.push(factor * mtx_arr[j][i]);
  492.                     }
  493.                
  494.                     prod_arr.push(factor_arr);
  495.                
  496.                 } else {
  497.                     if (mtx_arr[j] == 0)
  498.                         prod_arr.push(0);
  499.                            
  500.                     else
  501.                         prod_arr.push(factor * mtx_arr[j]);
  502.                 }
  503.             }
  504.            
  505.             return (prod_arr);
  506.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  507.        
  508.        
  509.         public static function concat(dim:Point, mtx1:Array, mtx2:Array):Array {
  510.         //]~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~._
  511.             var concat_arr:Array = new Array();
  512.            
  513.             var col:int = 0;
  514.             var row:int = 0;
  515.            
  516.             for (var i:int=0; i<(dim.x * dim.y); i++) {
  517.                 col = i % dim.x;
  518.                 row = i / dim.x;
  519.                
  520.                 concat_arr.push((mtx1[row*dim.x] * mtx2[col]) + (mtx1[(row*dim.x)+1] * mtx2[dim.x+col]) + (mtx1[(row*dim.x)+2] * mtx2[(dim.x*2)+col]));
  521.             }
  522.            
  523.            
  524.             /*
  525.             concat_arr[0] = (mtx1[0] * mtx2[0]) + (mtx1[1] * mtx2[5]) + (mtx1[2] * mtx2[10]);
  526.             concat_arr[1] = (mtx1[0] * mtx2[1]) + (mtx1[1] * mtx2[6]) + (mtx1[2] * mtx2[11]);
  527.             concat_arr[2] = (mtx1[0] * mtx2[2]) + (mtx1[1] * mtx2[7]) + (mtx1[2] * mtx2[12]);
  528.             concat_arr[3] = (mtx1[0] * mtx2[3]) + (mtx1[1] * mtx2[8]) + (mtx1[2] * mtx2[13]);
  529.             concat_arr[4] = (mtx1[0] * mtx2[4]) + (mtx1[1] * mtx2[9]) + (mtx1[2] * mtx2[14]);
  530.                
  531.             concat_arr[5] = (mtx1[5] * mtx2[0]) + (mtx1[6] * mtx2[5]) + (mtx1[7] * mtx2[10]);
  532.             concat_arr[6] = (mtx1[5] * mtx2[1]) + (mtx1[6] * mtx2[6]) + (mtx1[7] * mtx2[11]);
  533.             concat_arr[7] = (mtx1[5] * mtx2[2]) + (mtx1[6] * mtx2[7]) + (mtx1[7] * mtx2[12]);
  534.             concat_arr[8] = (mtx1[5] * mtx2[3]) + (mtx1[6] * mtx2[8]) + (mtx1[7] * mtx2[13]);
  535.             concat_arr[9] = (mtx1[5] * mtx2[4]) + (mtx1[6] * mtx2[9]) + (mtx1[7] * mtx2[14]);
  536.                
  537.             concat_arr[10] = (mtx1[10] * mtx2[0]) + (mtx1[11] * mtx2[5]) + (mtx1[12] * mtx2[10]);
  538.             concat_arr[11] = (mtx1[10] * mtx2[1]) + (mtx1[11] * mtx2[6]) + (mtx1[12] * mtx2[11]);
  539.             concat_arr[12] = (mtx1[10] * mtx2[2]) + (mtx1[11] * mtx2[7]) + (mtx1[12] * mtx2[12]);
  540.             concat_arr[13] = (mtx1[10] * mtx2[3]) + (mtx1[11] * mtx2[8]) + (mtx1[12] * mtx2[13]);
  541.             concat_arr[14] = (mtx1[10] * mtx2[4]) + (mtx1[11] * mtx2[9]) + (mtx1[12] * mtx2[14]);
  542.                
  543.             concat_arr[15] = (mtx1[15] * mtx2[0]) + (mtx1[16] * mtx2[5]) + (mtx1[17] * mtx2[10]);
  544.             concat_arr[16] = (mtx1[15] * mtx2[1]) + (mtx1[16] * mtx2[6]) + (mtx1[17] * mtx2[11]);
  545.             concat_arr[17] = (mtx1[15] * mtx2[2]) + (mtx1[16] * mtx2[7]) + (mtx1[17] * mtx2[12]);
  546.             concat_arr[18] = (mtx1[15] * mtx2[3]) + (mtx1[16] * mtx2[8]) + (mtx1[17] * mtx2[13]);
  547.             concat_arr[19] = (mtx1[15] * mtx2[4]) + (mtx1[16] * mtx2[9]) + (mtx1[17] * mtx2[14]);
  548.             */
  549.            
  550.             return (concat_arr);
  551.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  552.        
  553.        
  554.        
  555.         private static function pivot(pos:int, piv_row:Array, rows:Array):Array {
  556.         //~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~~*~._
  557.             //trace ("\n\npivoting @["+pos+"]:\n\tpiv_row:["+piv_row+"]\n\trows:["+rows+"]\n");
  558.            
  559.             var i:int;
  560.             var j:int;
  561.             var cnt:int = -1;
  562.             var coeff:Number;
  563.             var col:Number;
  564.            
  565.             var row_arr:Array = new Array();
  566.             var piv_arr:Array = new Array();
  567.            
  568.            
  569.             /*trace ("piv_row["+pos+"]:"+piv_row[pos]);
  570.             if (piv_row[pos] != 1)
  571.                 reduce(piv_row, piv_row[pos]);
  572.             trace ("piv_row[]: "+piv_row);*/
  573.            
  574.             //
  575.             for (j=0; j<=rows.length; j++) {
  576.                 row_arr = [];
  577.                
  578.                 if (j != pos)
  579.                     cnt++;
  580.                
  581.                 for (i=0; i<piv_row.length; i++) {
  582.                    
  583.                     if (j != pos) {
  584.                         coeff = rows[cnt][pos];
  585.                        
  586.                         //trace ("rows["+cnt+"]["+i+"]: "+rows[cnt][i]);
  587.                         //trace ("coeff: "+coeff);
  588.                         //trace ("piv_row["+i+"]: "+piv_row[i]);
  589.                        
  590.                         col = rows[cnt][i] - (coeff * piv_row[i]);
  591.                        
  592.                     } else
  593.                         col = piv_row[i];
  594.                    
  595.                     //trace ("col["+i+"]: "+col);
  596.                     row_arr.push(col);
  597.                 }
  598.  
  599.                 //trace (j+") row_arr[]: "+row_arr);
  600.                 //trace ("[=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=]\n");
  601.                    
  602.                 piv_arr.push(row_arr);
  603.             }
  604.            
  605.             return (piv_arr);
  606.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  607.        
  608.        
  609.        
  610.         private static function reduce(row:Array, factor:Number):void {
  611.         //~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~*~~~*~._
  612.            
  613.             for (var i:int=0; i<row.length; i++) {
  614.                 row[i] *= Number(Numbers.reciprocal(factor).toFixed(4));
  615.             }
  616.         }//]~*~~*~~*~~*~~*~~*~~*~~*~~·¯
  617.     }
  618. }
Advertisement
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!