home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &… the Search for Life CD 3 / 0_CD-ROM.iso / install / jre1_3 / lib / ext / vecmath.jar / javax / vecmath / GMatrix.class (.txt) < prev    next >
Encoding:
Java Class File  |  2002-06-19  |  27.3 KB  |  2,142 lines
  1. package javax.vecmath;
  2.  
  3. import java.io.Serializable;
  4.  
  5. public class GMatrix implements Serializable, Cloneable {
  6.    static final long serialVersionUID = 2777097312029690941L;
  7.    private static final boolean debug = false;
  8.    int nRow;
  9.    int nCol;
  10.    double[][] values;
  11.    private static final double EPS = 1.0E-10;
  12.  
  13.    public GMatrix(int var1, int var2) {
  14.       this.values = new double[var1][var2];
  15.       this.nRow = var1;
  16.       this.nCol = var2;
  17.  
  18.       for(int var3 = 0; var3 < var1; ++var3) {
  19.          for(int var4 = 0; var4 < var2; ++var4) {
  20.             this.values[var3][var4] = (double)0.0F;
  21.          }
  22.       }
  23.  
  24.       int var5;
  25.       if (var1 < var2) {
  26.          var5 = var1;
  27.       } else {
  28.          var5 = var2;
  29.       }
  30.  
  31.       for(int var6 = 0; var6 < var5; ++var6) {
  32.          this.values[var6][var6] = (double)1.0F;
  33.       }
  34.  
  35.    }
  36.  
  37.    public GMatrix(int var1, int var2, double[] var3) {
  38.       this.values = new double[var1][var2];
  39.       this.nRow = var1;
  40.       this.nCol = var2;
  41.  
  42.       for(int var4 = 0; var4 < var1; ++var4) {
  43.          for(int var5 = 0; var5 < var2; ++var5) {
  44.             this.values[var4][var5] = var3[var4 * var2 + var5];
  45.          }
  46.       }
  47.  
  48.    }
  49.  
  50.    public GMatrix(GMatrix var1) {
  51.       this.nRow = var1.nRow;
  52.       this.nCol = var1.nCol;
  53.       this.values = new double[this.nRow][this.nCol];
  54.  
  55.       for(int var2 = 0; var2 < this.nRow; ++var2) {
  56.          for(int var3 = 0; var3 < this.nCol; ++var3) {
  57.             this.values[var2][var3] = var1.values[var2][var3];
  58.          }
  59.       }
  60.  
  61.    }
  62.  
  63.    public final void mul(GMatrix var1) {
  64.       if (this.nCol == var1.nRow && this.nCol == var1.nCol) {
  65.          double[][] var5 = new double[this.nRow][this.nCol];
  66.  
  67.          for(int var2 = 0; var2 < this.nRow; ++var2) {
  68.             for(int var3 = 0; var3 < this.nCol; ++var3) {
  69.                var5[var2][var3] = (double)0.0F;
  70.  
  71.                for(int var4 = 0; var4 < this.nCol; ++var4) {
  72.                   var5[var2][var3] += this.values[var2][var4] * var1.values[var4][var3];
  73.                }
  74.             }
  75.          }
  76.  
  77.          this.values = var5;
  78.       } else {
  79.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix0"));
  80.       }
  81.    }
  82.  
  83.    public final void mul(GMatrix var1, GMatrix var2) {
  84.       if (var1.nCol == var2.nRow && this.nRow == var1.nRow && this.nCol == var2.nCol) {
  85.          double[][] var6 = new double[this.nRow][this.nCol];
  86.  
  87.          for(int var3 = 0; var3 < var1.nRow; ++var3) {
  88.             for(int var4 = 0; var4 < var2.nCol; ++var4) {
  89.                var6[var3][var4] = (double)0.0F;
  90.  
  91.                for(int var5 = 0; var5 < var1.nCol; ++var5) {
  92.                   var6[var3][var4] += var1.values[var3][var5] * var2.values[var5][var4];
  93.                }
  94.             }
  95.          }
  96.  
  97.          this.values = var6;
  98.       } else {
  99.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix1"));
  100.       }
  101.    }
  102.  
  103.    public final void mul(GVector var1, GVector var2) {
  104.       if (this.nRow < var1.getSize()) {
  105.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix2"));
  106.       } else if (this.nCol < var2.getSize()) {
  107.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix3"));
  108.       } else {
  109.          for(int var3 = 0; var3 < var1.getSize(); ++var3) {
  110.             for(int var4 = 0; var4 < var2.getSize(); ++var4) {
  111.                this.values[var3][var4] = var1.values[var3] * var2.values[var4];
  112.             }
  113.          }
  114.  
  115.       }
  116.    }
  117.  
  118.    public final void add(GMatrix var1) {
  119.       if (this.nRow != var1.nRow) {
  120.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix4"));
  121.       } else if (this.nCol != var1.nCol) {
  122.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix5"));
  123.       } else {
  124.          for(int var2 = 0; var2 < this.nRow; ++var2) {
  125.             for(int var3 = 0; var3 < this.nCol; ++var3) {
  126.                this.values[var2][var3] += var1.values[var2][var3];
  127.             }
  128.          }
  129.  
  130.       }
  131.    }
  132.  
  133.    public final void add(GMatrix var1, GMatrix var2) {
  134.       if (var2.nRow != var1.nRow) {
  135.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix6"));
  136.       } else if (var2.nCol != var1.nCol) {
  137.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix7"));
  138.       } else if (this.nCol == var1.nCol && this.nRow == var1.nRow) {
  139.          for(int var3 = 0; var3 < this.nRow; ++var3) {
  140.             for(int var4 = 0; var4 < this.nCol; ++var4) {
  141.                this.values[var3][var4] = var1.values[var3][var4] + var2.values[var3][var4];
  142.             }
  143.          }
  144.  
  145.       } else {
  146.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix8"));
  147.       }
  148.    }
  149.  
  150.    public final void sub(GMatrix var1) {
  151.       if (this.nRow != var1.nRow) {
  152.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix9"));
  153.       } else if (this.nCol != var1.nCol) {
  154.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix28"));
  155.       } else {
  156.          for(int var2 = 0; var2 < this.nRow; ++var2) {
  157.             for(int var3 = 0; var3 < this.nCol; ++var3) {
  158.                this.values[var2][var3] -= var1.values[var2][var3];
  159.             }
  160.          }
  161.  
  162.       }
  163.    }
  164.  
  165.    public final void sub(GMatrix var1, GMatrix var2) {
  166.       if (var2.nRow != var1.nRow) {
  167.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix10"));
  168.       } else if (var2.nCol != var1.nCol) {
  169.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix11"));
  170.       } else if (this.nRow == var1.nRow && this.nCol == var1.nCol) {
  171.          for(int var3 = 0; var3 < this.nRow; ++var3) {
  172.             for(int var4 = 0; var4 < this.nCol; ++var4) {
  173.                this.values[var3][var4] = var1.values[var3][var4] - var2.values[var3][var4];
  174.             }
  175.          }
  176.  
  177.       } else {
  178.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix12"));
  179.       }
  180.    }
  181.  
  182.    public final void negate() {
  183.       for(int var1 = 0; var1 < this.nRow; ++var1) {
  184.          for(int var2 = 0; var2 < this.nCol; ++var2) {
  185.             this.values[var1][var2] = -this.values[var1][var2];
  186.          }
  187.       }
  188.  
  189.    }
  190.  
  191.    public final void negate(GMatrix var1) {
  192.       if (this.nRow == var1.nRow && this.nCol == var1.nCol) {
  193.          for(int var2 = 0; var2 < this.nRow; ++var2) {
  194.             for(int var3 = 0; var3 < this.nCol; ++var3) {
  195.                this.values[var2][var3] = -var1.values[var2][var3];
  196.             }
  197.          }
  198.  
  199.       } else {
  200.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix13"));
  201.       }
  202.    }
  203.  
  204.    public final void setIdentity() {
  205.       for(int var1 = 0; var1 < this.nRow; ++var1) {
  206.          for(int var2 = 0; var2 < this.nCol; ++var2) {
  207.             this.values[var1][var2] = (double)0.0F;
  208.          }
  209.       }
  210.  
  211.       int var3;
  212.       if (this.nRow < this.nCol) {
  213.          var3 = this.nRow;
  214.       } else {
  215.          var3 = this.nCol;
  216.       }
  217.  
  218.       for(int var4 = 0; var4 < var3; ++var4) {
  219.          this.values[var4][var4] = (double)1.0F;
  220.       }
  221.  
  222.    }
  223.  
  224.    public final void setZero() {
  225.       for(int var1 = 0; var1 < this.nRow; ++var1) {
  226.          for(int var2 = 0; var2 < this.nCol; ++var2) {
  227.             this.values[var1][var2] = (double)0.0F;
  228.          }
  229.       }
  230.  
  231.    }
  232.  
  233.    public final void identityMinus() {
  234.       for(int var1 = 0; var1 < this.nRow; ++var1) {
  235.          for(int var2 = 0; var2 < this.nCol; ++var2) {
  236.             this.values[var1][var2] = -this.values[var1][var2];
  237.          }
  238.       }
  239.  
  240.       int var3;
  241.       if (this.nRow < this.nCol) {
  242.          var3 = this.nRow;
  243.       } else {
  244.          var3 = this.nCol;
  245.       }
  246.  
  247.       for(int var4 = 0; var4 < var3; ++var4) {
  248.          int var10002 = this.values[var4][var4]++;
  249.       }
  250.  
  251.    }
  252.  
  253.    public final void invert() {
  254.       this.invertGeneral(this);
  255.    }
  256.  
  257.    public final void invert(GMatrix var1) {
  258.       this.invertGeneral(var1);
  259.    }
  260.  
  261.    public final void copySubMatrix(int var1, int var2, int var3, int var4, int var5, int var6, GMatrix var7) {
  262.       if (this != var7) {
  263.          for(int var8 = 0; var8 < var3; ++var8) {
  264.             for(int var9 = 0; var9 < var4; ++var9) {
  265.                var7.values[var5 + var8][var6 + var9] = this.values[var1 + var8][var2 + var9];
  266.             }
  267.          }
  268.       } else {
  269.          double[][] var10 = new double[var3][var4];
  270.  
  271.          for(int var11 = 0; var11 < var3; ++var11) {
  272.             for(int var13 = 0; var13 < var4; ++var13) {
  273.                var10[var11][var13] = this.values[var1 + var11][var2 + var13];
  274.             }
  275.          }
  276.  
  277.          for(int var12 = 0; var12 < var3; ++var12) {
  278.             for(int var14 = 0; var14 < var4; ++var14) {
  279.                var7.values[var5 + var12][var6 + var14] = var10[var12][var14];
  280.             }
  281.          }
  282.       }
  283.  
  284.    }
  285.  
  286.    public final void setSize(int var1, int var2) {
  287.       double[][] var3 = new double[var1][var2];
  288.       int var6;
  289.       if (this.nRow < var1) {
  290.          var6 = this.nRow;
  291.       } else {
  292.          var6 = var1;
  293.       }
  294.  
  295.       int var7;
  296.       if (this.nCol < var2) {
  297.          var7 = this.nCol;
  298.       } else {
  299.          var7 = var2;
  300.       }
  301.  
  302.       for(int var4 = 0; var4 < var6; ++var4) {
  303.          for(int var5 = 0; var5 < var7; ++var5) {
  304.             var3[var4][var5] = this.values[var4][var5];
  305.          }
  306.       }
  307.  
  308.       this.nRow = var1;
  309.       this.nCol = var2;
  310.       this.values = var3;
  311.    }
  312.  
  313.    public final void set(double[] var1) {
  314.       for(int var2 = 0; var2 < this.nRow; ++var2) {
  315.          for(int var3 = 0; var3 < this.nCol; ++var3) {
  316.             this.values[var2][var3] = var1[this.nCol * var2 + var3];
  317.          }
  318.       }
  319.  
  320.    }
  321.  
  322.    public final void set(Matrix3f var1) {
  323.       if (this.nCol < 3 || this.nRow < 3) {
  324.          this.nCol = 3;
  325.          this.nRow = 3;
  326.          this.values = new double[this.nRow][this.nCol];
  327.       }
  328.  
  329.       this.values[0][0] = (double)var1.m00;
  330.       this.values[0][1] = (double)var1.m01;
  331.       this.values[0][2] = (double)var1.m02;
  332.       this.values[1][0] = (double)var1.m10;
  333.       this.values[1][1] = (double)var1.m11;
  334.       this.values[1][2] = (double)var1.m12;
  335.       this.values[2][0] = (double)var1.m20;
  336.       this.values[2][1] = (double)var1.m21;
  337.       this.values[2][2] = (double)var1.m22;
  338.  
  339.       for(int var2 = 3; var2 < this.nRow; ++var2) {
  340.          for(int var3 = 3; var3 < this.nCol; ++var3) {
  341.             this.values[var2][var3] = (double)0.0F;
  342.          }
  343.       }
  344.  
  345.    }
  346.  
  347.    public final void set(Matrix3d var1) {
  348.       if (this.nRow < 3 || this.nCol < 3) {
  349.          this.values = new double[3][3];
  350.          this.nRow = 3;
  351.          this.nCol = 3;
  352.       }
  353.  
  354.       this.values[0][0] = var1.m00;
  355.       this.values[0][1] = var1.m01;
  356.       this.values[0][2] = var1.m02;
  357.       this.values[1][0] = var1.m10;
  358.       this.values[1][1] = var1.m11;
  359.       this.values[1][2] = var1.m12;
  360.       this.values[2][0] = var1.m20;
  361.       this.values[2][1] = var1.m21;
  362.       this.values[2][2] = var1.m22;
  363.  
  364.       for(int var2 = 3; var2 < this.nRow; ++var2) {
  365.          for(int var3 = 3; var3 < this.nCol; ++var3) {
  366.             this.values[var2][var3] = (double)0.0F;
  367.          }
  368.       }
  369.  
  370.    }
  371.  
  372.    public final void set(Matrix4f var1) {
  373.       if (this.nRow < 4 || this.nCol < 4) {
  374.          this.values = new double[4][4];
  375.          this.nRow = 4;
  376.          this.nCol = 4;
  377.       }
  378.  
  379.       this.values[0][0] = (double)var1.m00;
  380.       this.values[0][1] = (double)var1.m01;
  381.       this.values[0][2] = (double)var1.m02;
  382.       this.values[0][3] = (double)var1.m03;
  383.       this.values[1][0] = (double)var1.m10;
  384.       this.values[1][1] = (double)var1.m11;
  385.       this.values[1][2] = (double)var1.m12;
  386.       this.values[1][3] = (double)var1.m13;
  387.       this.values[2][0] = (double)var1.m20;
  388.       this.values[2][1] = (double)var1.m21;
  389.       this.values[2][2] = (double)var1.m22;
  390.       this.values[2][3] = (double)var1.m23;
  391.       this.values[3][0] = (double)var1.m30;
  392.       this.values[3][1] = (double)var1.m31;
  393.       this.values[3][2] = (double)var1.m32;
  394.       this.values[3][3] = (double)var1.m33;
  395.  
  396.       for(int var2 = 4; var2 < this.nRow; ++var2) {
  397.          for(int var3 = 4; var3 < this.nCol; ++var3) {
  398.             this.values[var2][var3] = (double)0.0F;
  399.          }
  400.       }
  401.  
  402.    }
  403.  
  404.    public final void set(Matrix4d var1) {
  405.       if (this.nRow < 4 || this.nCol < 4) {
  406.          this.values = new double[4][4];
  407.          this.nRow = 4;
  408.          this.nCol = 4;
  409.       }
  410.  
  411.       this.values[0][0] = var1.m00;
  412.       this.values[0][1] = var1.m01;
  413.       this.values[0][2] = var1.m02;
  414.       this.values[0][3] = var1.m03;
  415.       this.values[1][0] = var1.m10;
  416.       this.values[1][1] = var1.m11;
  417.       this.values[1][2] = var1.m12;
  418.       this.values[1][3] = var1.m13;
  419.       this.values[2][0] = var1.m20;
  420.       this.values[2][1] = var1.m21;
  421.       this.values[2][2] = var1.m22;
  422.       this.values[2][3] = var1.m23;
  423.       this.values[3][0] = var1.m30;
  424.       this.values[3][1] = var1.m31;
  425.       this.values[3][2] = var1.m32;
  426.       this.values[3][3] = var1.m33;
  427.  
  428.       for(int var2 = 4; var2 < this.nRow; ++var2) {
  429.          for(int var3 = 4; var3 < this.nCol; ++var3) {
  430.             this.values[var2][var3] = (double)0.0F;
  431.          }
  432.       }
  433.  
  434.    }
  435.  
  436.    public final void set(GMatrix var1) {
  437.       if (this.nRow < var1.nRow || this.nCol < var1.nCol) {
  438.          this.nRow = var1.nRow;
  439.          this.nCol = var1.nCol;
  440.          this.values = new double[this.nRow][this.nCol];
  441.       }
  442.  
  443.       for(int var2 = 0; var2 < Math.min(this.nRow, var1.nRow); ++var2) {
  444.          for(int var3 = 0; var3 < Math.min(this.nCol, var1.nCol); ++var3) {
  445.             this.values[var2][var3] = var1.values[var2][var3];
  446.          }
  447.       }
  448.  
  449.       for(int var4 = var1.nRow; var4 < this.nRow; ++var4) {
  450.          for(int var5 = var1.nCol; var5 < this.nCol; ++var5) {
  451.             this.values[var4][var5] = (double)0.0F;
  452.          }
  453.       }
  454.  
  455.    }
  456.  
  457.    public final int getNumRow() {
  458.       return this.nRow;
  459.    }
  460.  
  461.    public final int getNumCol() {
  462.       return this.nCol;
  463.    }
  464.  
  465.    public final double getElement(int var1, int var2) {
  466.       return this.values[var1][var2];
  467.    }
  468.  
  469.    public final void setElement(int var1, int var2, double var3) {
  470.       this.values[var1][var2] = var3;
  471.    }
  472.  
  473.    public final void getRow(int var1, double[] var2) {
  474.       for(int var3 = 0; var3 < this.nCol; ++var3) {
  475.          var2[var3] = this.values[var1][var3];
  476.       }
  477.  
  478.    }
  479.  
  480.    public final void getRow(int var1, GVector var2) {
  481.       if (var2.getSize() < this.nCol) {
  482.          var2.setSize(this.nCol);
  483.       }
  484.  
  485.       for(int var3 = 0; var3 < this.nCol; ++var3) {
  486.          var2.values[var3] = this.values[var1][var3];
  487.       }
  488.  
  489.    }
  490.  
  491.    public final void getColumn(int var1, double[] var2) {
  492.       for(int var3 = 0; var3 < this.nRow; ++var3) {
  493.          var2[var3] = this.values[var3][var1];
  494.       }
  495.  
  496.    }
  497.  
  498.    public final void getColumn(int var1, GVector var2) {
  499.       if (var2.getSize() < this.nRow) {
  500.          var2.setSize(this.nRow);
  501.       }
  502.  
  503.       for(int var3 = 0; var3 < this.nRow; ++var3) {
  504.          var2.values[var3] = this.values[var3][var1];
  505.       }
  506.  
  507.    }
  508.  
  509.    public final void get(Matrix3d var1) {
  510.       if (this.nRow >= 3 && this.nCol >= 3) {
  511.          var1.m00 = this.values[0][0];
  512.          var1.m01 = this.values[0][1];
  513.          var1.m02 = this.values[0][2];
  514.          var1.m10 = this.values[1][0];
  515.          var1.m11 = this.values[1][1];
  516.          var1.m12 = this.values[1][2];
  517.          var1.m20 = this.values[2][0];
  518.          var1.m21 = this.values[2][1];
  519.          var1.m22 = this.values[2][2];
  520.       } else {
  521.          var1.setZero();
  522.          if (this.nCol > 0) {
  523.             if (this.nRow > 0) {
  524.                var1.m00 = this.values[0][0];
  525.                if (this.nRow > 1) {
  526.                   var1.m10 = this.values[1][0];
  527.                   if (this.nRow > 2) {
  528.                      var1.m20 = this.values[2][0];
  529.                   }
  530.                }
  531.             }
  532.  
  533.             if (this.nCol > 1) {
  534.                if (this.nRow > 0) {
  535.                   var1.m01 = this.values[0][1];
  536.                   if (this.nRow > 1) {
  537.                      var1.m11 = this.values[1][1];
  538.                      if (this.nRow > 2) {
  539.                         var1.m21 = this.values[2][1];
  540.                      }
  541.                   }
  542.                }
  543.  
  544.                if (this.nCol > 2 && this.nRow > 0) {
  545.                   var1.m02 = this.values[0][2];
  546.                   if (this.nRow > 1) {
  547.                      var1.m12 = this.values[1][2];
  548.                      if (this.nRow > 2) {
  549.                         var1.m22 = this.values[2][2];
  550.                      }
  551.                   }
  552.                }
  553.             }
  554.          }
  555.       }
  556.  
  557.    }
  558.  
  559.    public final void get(Matrix3f var1) {
  560.       if (this.nRow >= 3 && this.nCol >= 3) {
  561.          var1.m00 = (float)this.values[0][0];
  562.          var1.m01 = (float)this.values[0][1];
  563.          var1.m02 = (float)this.values[0][2];
  564.          var1.m10 = (float)this.values[1][0];
  565.          var1.m11 = (float)this.values[1][1];
  566.          var1.m12 = (float)this.values[1][2];
  567.          var1.m20 = (float)this.values[2][0];
  568.          var1.m21 = (float)this.values[2][1];
  569.          var1.m22 = (float)this.values[2][2];
  570.       } else {
  571.          var1.setZero();
  572.          if (this.nCol > 0) {
  573.             if (this.nRow > 0) {
  574.                var1.m00 = (float)this.values[0][0];
  575.                if (this.nRow > 1) {
  576.                   var1.m10 = (float)this.values[1][0];
  577.                   if (this.nRow > 2) {
  578.                      var1.m20 = (float)this.values[2][0];
  579.                   }
  580.                }
  581.             }
  582.  
  583.             if (this.nCol > 1) {
  584.                if (this.nRow > 0) {
  585.                   var1.m01 = (float)this.values[0][1];
  586.                   if (this.nRow > 1) {
  587.                      var1.m11 = (float)this.values[1][1];
  588.                      if (this.nRow > 2) {
  589.                         var1.m21 = (float)this.values[2][1];
  590.                      }
  591.                   }
  592.                }
  593.  
  594.                if (this.nCol > 2 && this.nRow > 0) {
  595.                   var1.m02 = (float)this.values[0][2];
  596.                   if (this.nRow > 1) {
  597.                      var1.m12 = (float)this.values[1][2];
  598.                      if (this.nRow > 2) {
  599.                         var1.m22 = (float)this.values[2][2];
  600.                      }
  601.                   }
  602.                }
  603.             }
  604.          }
  605.       }
  606.  
  607.    }
  608.  
  609.    public final void get(Matrix4d var1) {
  610.       if (this.nRow >= 4 && this.nCol >= 4) {
  611.          var1.m00 = this.values[0][0];
  612.          var1.m01 = this.values[0][1];
  613.          var1.m02 = this.values[0][2];
  614.          var1.m03 = this.values[0][3];
  615.          var1.m10 = this.values[1][0];
  616.          var1.m11 = this.values[1][1];
  617.          var1.m12 = this.values[1][2];
  618.          var1.m13 = this.values[1][3];
  619.          var1.m20 = this.values[2][0];
  620.          var1.m21 = this.values[2][1];
  621.          var1.m22 = this.values[2][2];
  622.          var1.m23 = this.values[2][3];
  623.          var1.m30 = this.values[3][0];
  624.          var1.m31 = this.values[3][1];
  625.          var1.m32 = this.values[3][2];
  626.          var1.m33 = this.values[3][3];
  627.       } else {
  628.          var1.setZero();
  629.          if (this.nCol > 0) {
  630.             if (this.nRow > 0) {
  631.                var1.m00 = this.values[0][0];
  632.                if (this.nRow > 1) {
  633.                   var1.m10 = this.values[1][0];
  634.                   if (this.nRow > 2) {
  635.                      var1.m20 = this.values[2][0];
  636.                      if (this.nRow > 3) {
  637.                         var1.m30 = this.values[3][0];
  638.                      }
  639.                   }
  640.                }
  641.             }
  642.  
  643.             if (this.nCol > 1) {
  644.                if (this.nRow > 0) {
  645.                   var1.m01 = this.values[0][1];
  646.                   if (this.nRow > 1) {
  647.                      var1.m11 = this.values[1][1];
  648.                      if (this.nRow > 2) {
  649.                         var1.m21 = this.values[2][1];
  650.                         if (this.nRow > 3) {
  651.                            var1.m31 = this.values[3][1];
  652.                         }
  653.                      }
  654.                   }
  655.                }
  656.  
  657.                if (this.nCol > 2) {
  658.                   if (this.nRow > 0) {
  659.                      var1.m02 = this.values[0][2];
  660.                      if (this.nRow > 1) {
  661.                         var1.m12 = this.values[1][2];
  662.                         if (this.nRow > 2) {
  663.                            var1.m22 = this.values[2][2];
  664.                            if (this.nRow > 3) {
  665.                               var1.m32 = this.values[3][2];
  666.                            }
  667.                         }
  668.                      }
  669.                   }
  670.  
  671.                   if (this.nCol > 3 && this.nRow > 0) {
  672.                      var1.m03 = this.values[0][3];
  673.                      if (this.nRow > 1) {
  674.                         var1.m13 = this.values[1][3];
  675.                         if (this.nRow > 2) {
  676.                            var1.m23 = this.values[2][3];
  677.                            if (this.nRow > 3) {
  678.                               var1.m33 = this.values[3][3];
  679.                            }
  680.                         }
  681.                      }
  682.                   }
  683.                }
  684.             }
  685.          }
  686.       }
  687.  
  688.    }
  689.  
  690.    public final void get(Matrix4f var1) {
  691.       if (this.nRow >= 4 && this.nCol >= 4) {
  692.          var1.m00 = (float)this.values[0][0];
  693.          var1.m01 = (float)this.values[0][1];
  694.          var1.m02 = (float)this.values[0][2];
  695.          var1.m03 = (float)this.values[0][3];
  696.          var1.m10 = (float)this.values[1][0];
  697.          var1.m11 = (float)this.values[1][1];
  698.          var1.m12 = (float)this.values[1][2];
  699.          var1.m13 = (float)this.values[1][3];
  700.          var1.m20 = (float)this.values[2][0];
  701.          var1.m21 = (float)this.values[2][1];
  702.          var1.m22 = (float)this.values[2][2];
  703.          var1.m23 = (float)this.values[2][3];
  704.          var1.m30 = (float)this.values[3][0];
  705.          var1.m31 = (float)this.values[3][1];
  706.          var1.m32 = (float)this.values[3][2];
  707.          var1.m33 = (float)this.values[3][3];
  708.       } else {
  709.          var1.setZero();
  710.          if (this.nCol > 0) {
  711.             if (this.nRow > 0) {
  712.                var1.m00 = (float)this.values[0][0];
  713.                if (this.nRow > 1) {
  714.                   var1.m10 = (float)this.values[1][0];
  715.                   if (this.nRow > 2) {
  716.                      var1.m20 = (float)this.values[2][0];
  717.                      if (this.nRow > 3) {
  718.                         var1.m30 = (float)this.values[3][0];
  719.                      }
  720.                   }
  721.                }
  722.             }
  723.  
  724.             if (this.nCol > 1) {
  725.                if (this.nRow > 0) {
  726.                   var1.m01 = (float)this.values[0][1];
  727.                   if (this.nRow > 1) {
  728.                      var1.m11 = (float)this.values[1][1];
  729.                      if (this.nRow > 2) {
  730.                         var1.m21 = (float)this.values[2][1];
  731.                         if (this.nRow > 3) {
  732.                            var1.m31 = (float)this.values[3][1];
  733.                         }
  734.                      }
  735.                   }
  736.                }
  737.  
  738.                if (this.nCol > 2) {
  739.                   if (this.nRow > 0) {
  740.                      var1.m02 = (float)this.values[0][2];
  741.                      if (this.nRow > 1) {
  742.                         var1.m12 = (float)this.values[1][2];
  743.                         if (this.nRow > 2) {
  744.                            var1.m22 = (float)this.values[2][2];
  745.                            if (this.nRow > 3) {
  746.                               var1.m32 = (float)this.values[3][2];
  747.                            }
  748.                         }
  749.                      }
  750.                   }
  751.  
  752.                   if (this.nCol > 3 && this.nRow > 0) {
  753.                      var1.m03 = (float)this.values[0][3];
  754.                      if (this.nRow > 1) {
  755.                         var1.m13 = (float)this.values[1][3];
  756.                         if (this.nRow > 2) {
  757.                            var1.m23 = (float)this.values[2][3];
  758.                            if (this.nRow > 3) {
  759.                               var1.m33 = (float)this.values[3][3];
  760.                            }
  761.                         }
  762.                      }
  763.                   }
  764.                }
  765.             }
  766.          }
  767.       }
  768.  
  769.    }
  770.  
  771.    public final void get(GMatrix var1) {
  772.       int var4;
  773.       if (this.nCol < var1.nCol) {
  774.          var4 = this.nCol;
  775.       } else {
  776.          var4 = var1.nCol;
  777.       }
  778.  
  779.       int var5;
  780.       if (this.nRow < var1.nRow) {
  781.          var5 = this.nRow;
  782.       } else {
  783.          var5 = var1.nRow;
  784.       }
  785.  
  786.       for(int var2 = 0; var2 < var5; ++var2) {
  787.          for(int var3 = 0; var3 < var4; ++var3) {
  788.             var1.values[var2][var3] = this.values[var2][var3];
  789.          }
  790.       }
  791.  
  792.       for(int var6 = var5; var6 < var1.nRow; ++var6) {
  793.          for(int var8 = 0; var8 < var1.nCol; ++var8) {
  794.             var1.values[var6][var8] = (double)0.0F;
  795.          }
  796.       }
  797.  
  798.       for(int var9 = var4; var9 < var1.nCol; ++var9) {
  799.          for(int var7 = 0; var7 < var5; ++var7) {
  800.             var1.values[var7][var9] = (double)0.0F;
  801.          }
  802.       }
  803.  
  804.    }
  805.  
  806.    public final void setRow(int var1, double[] var2) {
  807.       for(int var3 = 0; var3 < this.nCol; ++var3) {
  808.          this.values[var1][var3] = var2[var3];
  809.       }
  810.  
  811.    }
  812.  
  813.    public final void setRow(int var1, GVector var2) {
  814.       for(int var3 = 0; var3 < this.nCol; ++var3) {
  815.          this.values[var1][var3] = var2.values[var3];
  816.       }
  817.  
  818.    }
  819.  
  820.    public final void setColumn(int var1, double[] var2) {
  821.       for(int var3 = 0; var3 < this.nRow; ++var3) {
  822.          this.values[var3][var1] = var2[var3];
  823.       }
  824.  
  825.    }
  826.  
  827.    public final void setColumn(int var1, GVector var2) {
  828.       for(int var3 = 0; var3 < this.nRow; ++var3) {
  829.          this.values[var3][var1] = var2.values[var3];
  830.       }
  831.  
  832.    }
  833.  
  834.    public final void mulTransposeBoth(GMatrix var1, GMatrix var2) {
  835.       if (var1.nRow == var2.nCol && this.nRow == var1.nCol && this.nCol == var2.nRow) {
  836.          if (var1 != this && var2 != this) {
  837.             for(int var7 = 0; var7 < this.nRow; ++var7) {
  838.                for(int var8 = 0; var8 < this.nCol; ++var8) {
  839.                   this.values[var7][var8] = (double)0.0F;
  840.  
  841.                   for(int var9 = 0; var9 < var1.nRow; ++var9) {
  842.                      double[] var10000 = this.values[var7];
  843.                      var10000[var8] += var1.values[var9][var7] * var2.values[var8][var9];
  844.                   }
  845.                }
  846.             }
  847.          } else {
  848.             double[][] var6 = new double[this.nRow][this.nCol];
  849.  
  850.             for(int var3 = 0; var3 < this.nRow; ++var3) {
  851.                for(int var4 = 0; var4 < this.nCol; ++var4) {
  852.                   var6[var3][var4] = (double)0.0F;
  853.  
  854.                   for(int var5 = 0; var5 < var1.nRow; ++var5) {
  855.                      var6[var3][var4] += var1.values[var5][var3] * var2.values[var4][var5];
  856.                   }
  857.                }
  858.             }
  859.  
  860.             this.values = var6;
  861.          }
  862.  
  863.       } else {
  864.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix14"));
  865.       }
  866.    }
  867.  
  868.    public final void mulTransposeRight(GMatrix var1, GMatrix var2) {
  869.       if (var1.nCol == var2.nCol && this.nCol == var2.nRow && this.nRow == var1.nRow) {
  870.          if (var1 != this && var2 != this) {
  871.             for(int var7 = 0; var7 < this.nRow; ++var7) {
  872.                for(int var8 = 0; var8 < this.nCol; ++var8) {
  873.                   this.values[var7][var8] = (double)0.0F;
  874.  
  875.                   for(int var9 = 0; var9 < var1.nCol; ++var9) {
  876.                      double[] var10000 = this.values[var7];
  877.                      var10000[var8] += var1.values[var7][var9] * var2.values[var8][var9];
  878.                   }
  879.                }
  880.             }
  881.          } else {
  882.             double[][] var6 = new double[this.nRow][this.nCol];
  883.  
  884.             for(int var3 = 0; var3 < this.nRow; ++var3) {
  885.                for(int var4 = 0; var4 < this.nCol; ++var4) {
  886.                   var6[var3][var4] = (double)0.0F;
  887.  
  888.                   for(int var5 = 0; var5 < var1.nCol; ++var5) {
  889.                      var6[var3][var4] += var1.values[var3][var5] * var2.values[var4][var5];
  890.                   }
  891.                }
  892.             }
  893.  
  894.             this.values = var6;
  895.          }
  896.  
  897.       } else {
  898.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix15"));
  899.       }
  900.    }
  901.  
  902.    public final void mulTransposeLeft(GMatrix var1, GMatrix var2) {
  903.       if (var1.nRow == var2.nRow && this.nCol == var2.nCol && this.nRow == var1.nCol) {
  904.          if (var1 != this && var2 != this) {
  905.             for(int var7 = 0; var7 < this.nRow; ++var7) {
  906.                for(int var8 = 0; var8 < this.nCol; ++var8) {
  907.                   this.values[var7][var8] = (double)0.0F;
  908.  
  909.                   for(int var9 = 0; var9 < var1.nRow; ++var9) {
  910.                      double[] var10000 = this.values[var7];
  911.                      var10000[var8] += var1.values[var9][var7] * var2.values[var9][var8];
  912.                   }
  913.                }
  914.             }
  915.          } else {
  916.             double[][] var6 = new double[this.nRow][this.nCol];
  917.  
  918.             for(int var3 = 0; var3 < this.nRow; ++var3) {
  919.                for(int var4 = 0; var4 < this.nCol; ++var4) {
  920.                   var6[var3][var4] = (double)0.0F;
  921.  
  922.                   for(int var5 = 0; var5 < var1.nRow; ++var5) {
  923.                      var6[var3][var4] += var1.values[var5][var3] * var2.values[var5][var4];
  924.                   }
  925.                }
  926.             }
  927.  
  928.             this.values = var6;
  929.          }
  930.  
  931.       } else {
  932.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix16"));
  933.       }
  934.    }
  935.  
  936.    public final void transpose() {
  937.       if (this.nRow != this.nCol) {
  938.          int var1 = this.nRow;
  939.          this.nRow = this.nCol;
  940.          this.nCol = var1;
  941.          double[][] var3 = new double[this.nRow][this.nCol];
  942.  
  943.          for(int var5 = 0; var5 < this.nRow; ++var5) {
  944.             for(int var2 = 0; var2 < this.nCol; ++var2) {
  945.                var3[var5][var2] = this.values[var2][var5];
  946.             }
  947.          }
  948.  
  949.          this.values = var3;
  950.       } else {
  951.          for(int var6 = 0; var6 < this.nRow; ++var6) {
  952.             for(int var7 = 0; var7 < var6; ++var7) {
  953.                double var8 = this.values[var6][var7];
  954.                this.values[var6][var7] = this.values[var7][var6];
  955.                this.values[var7][var6] = var8;
  956.             }
  957.          }
  958.       }
  959.  
  960.    }
  961.  
  962.    public final void transpose(GMatrix var1) {
  963.       if (this.nRow == var1.nCol && this.nCol == var1.nRow) {
  964.          if (var1 != this) {
  965.             for(int var2 = 0; var2 < this.nRow; ++var2) {
  966.                for(int var3 = 0; var3 < this.nCol; ++var3) {
  967.                   this.values[var2][var3] = var1.values[var3][var2];
  968.                }
  969.             }
  970.          } else {
  971.             this.transpose();
  972.          }
  973.  
  974.       } else {
  975.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix17"));
  976.       }
  977.    }
  978.  
  979.    public String toString() {
  980.       StringBuffer var1 = new StringBuffer(this.nRow * this.nCol * 8);
  981.  
  982.       for(int var2 = 0; var2 < this.nRow; ++var2) {
  983.          for(int var3 = 0; var3 < this.nCol; ++var3) {
  984.             var1.append(this.values[var2][var3]).append(" ");
  985.          }
  986.  
  987.          var1.append("\n");
  988.       }
  989.  
  990.       return var1.toString();
  991.    }
  992.  
  993.    private static void checkMatrix(GMatrix var0) {
  994.       for(int var1 = 0; var1 < var0.nRow; ++var1) {
  995.          for(int var2 = 0; var2 < var0.nCol; ++var2) {
  996.             if (Math.abs(var0.values[var1][var2]) < 1.0E-10) {
  997.                System.out.print(" 0.0     ");
  998.             } else {
  999.                System.out.print(" " + var0.values[var1][var2]);
  1000.             }
  1001.          }
  1002.  
  1003.          System.out.print("\n");
  1004.       }
  1005.  
  1006.    }
  1007.  
  1008.    public int hashCode() {
  1009.       long var1 = 1L;
  1010.       var1 = 31L * var1 + (long)this.nRow;
  1011.       var1 = 31L * var1 + (long)this.nCol;
  1012.  
  1013.       for(int var3 = 0; var3 < this.nRow; ++var3) {
  1014.          for(int var4 = 0; var4 < this.nCol; ++var4) {
  1015.             var1 = 31L * var1 + Double.doubleToLongBits(this.values[var3][var4]);
  1016.          }
  1017.       }
  1018.  
  1019.       return (int)(var1 ^ var1 >> 32);
  1020.    }
  1021.  
  1022.    public boolean equals(GMatrix var1) {
  1023.       try {
  1024.          if (this.nRow == var1.nRow && this.nCol == var1.nCol) {
  1025.             for(int var2 = 0; var2 < this.nRow; ++var2) {
  1026.                for(int var3 = 0; var3 < this.nCol; ++var3) {
  1027.                   if (this.values[var2][var3] != var1.values[var2][var3]) {
  1028.                      return false;
  1029.                   }
  1030.                }
  1031.             }
  1032.  
  1033.             return true;
  1034.          } else {
  1035.             return false;
  1036.          }
  1037.       } catch (NullPointerException var4) {
  1038.          return false;
  1039.       }
  1040.    }
  1041.  
  1042.    public boolean equals(Object var1) {
  1043.       try {
  1044.          GMatrix var2 = (GMatrix)var1;
  1045.          if (this.nRow == var2.nRow && this.nCol == var2.nCol) {
  1046.             for(int var3 = 0; var3 < this.nRow; ++var3) {
  1047.                for(int var4 = 0; var4 < this.nCol; ++var4) {
  1048.                   if (this.values[var3][var4] != var2.values[var3][var4]) {
  1049.                      return false;
  1050.                   }
  1051.                }
  1052.             }
  1053.  
  1054.             return true;
  1055.          } else {
  1056.             return false;
  1057.          }
  1058.       } catch (ClassCastException var5) {
  1059.          return false;
  1060.       } catch (NullPointerException var6) {
  1061.          return false;
  1062.       }
  1063.    }
  1064.  
  1065.    /** @deprecated */
  1066.    public boolean epsilonEquals(GMatrix var1, float var2) {
  1067.       return this.epsilonEquals(var1, (double)var2);
  1068.    }
  1069.  
  1070.    public boolean epsilonEquals(GMatrix var1, double var2) {
  1071.       if (this.nRow == var1.nRow && this.nCol == var1.nCol) {
  1072.          for(int var4 = 0; var4 < this.nRow; ++var4) {
  1073.             for(int var5 = 0; var5 < this.nCol; ++var5) {
  1074.                double var6 = this.values[var4][var5] - var1.values[var4][var5];
  1075.                if ((var6 < (double)0.0F ? -var6 : var6) > var2) {
  1076.                   return false;
  1077.                }
  1078.             }
  1079.          }
  1080.  
  1081.          return true;
  1082.       } else {
  1083.          return false;
  1084.       }
  1085.    }
  1086.  
  1087.    public final double trace() {
  1088.       int var2;
  1089.       if (this.nRow < this.nCol) {
  1090.          var2 = this.nRow;
  1091.       } else {
  1092.          var2 = this.nCol;
  1093.       }
  1094.  
  1095.       double var3 = (double)0.0F;
  1096.  
  1097.       for(int var1 = 0; var1 < var2; ++var1) {
  1098.          var3 += this.values[var1][var1];
  1099.       }
  1100.  
  1101.       return var3;
  1102.    }
  1103.  
  1104.    public final int SVD(GMatrix var1, GMatrix var2, GMatrix var3) {
  1105.       if (this.nCol == var3.nCol && this.nCol == var3.nRow) {
  1106.          if (this.nRow == var1.nRow && this.nRow == var1.nCol) {
  1107.             if (this.nRow == var2.nRow && this.nCol == var2.nCol) {
  1108.                if (this.nRow == 2 && this.nCol == 2 && this.values[1][0] == (double)0.0F) {
  1109.                   var1.setIdentity();
  1110.                   var3.setIdentity();
  1111.                   if (this.values[0][1] == (double)0.0F) {
  1112.                      return 2;
  1113.                   } else {
  1114.                      double[] var4 = new double[1];
  1115.                      double[] var5 = new double[1];
  1116.                      double[] var6 = new double[1];
  1117.                      double[] var7 = new double[1];
  1118.                      double[] var8 = new double[]{this.values[0][0], this.values[1][1]};
  1119.                      compute_2X2(this.values[0][0], this.values[0][1], this.values[1][1], var8, var4, var6, var5, var7, 0);
  1120.                      update_u(0, var1, var6, var4);
  1121.                      update_v(0, var3, var7, var5);
  1122.                      return 2;
  1123.                   }
  1124.                } else {
  1125.                   return computeSVD(this, var1, var2, var3);
  1126.                }
  1127.             } else {
  1128.                throw new MismatchedSizeException(VecMathI18N.getString("GMatrix26"));
  1129.             }
  1130.          } else {
  1131.             throw new MismatchedSizeException(VecMathI18N.getString("GMatrix25"));
  1132.          }
  1133.       } else {
  1134.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix18"));
  1135.       }
  1136.    }
  1137.  
  1138.    public final int LUD(GMatrix var1, GVector var2) {
  1139.       int var3 = var1.nRow * var1.nCol;
  1140.       double[] var4 = new double[var3];
  1141.       int[] var5 = new int[1];
  1142.       int[] var6 = new int[var1.nRow];
  1143.       if (this.nRow != this.nCol) {
  1144.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix19"));
  1145.       } else if (this.nRow != var1.nRow) {
  1146.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix27"));
  1147.       } else if (this.nCol != var1.nCol) {
  1148.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix27"));
  1149.       } else if (var1.nRow != var2.getSize()) {
  1150.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix20"));
  1151.       } else {
  1152.          for(int var7 = 0; var7 < this.nRow; ++var7) {
  1153.             for(int var8 = 0; var8 < this.nCol; ++var8) {
  1154.                var4[var7 * this.nCol + var8] = this.values[var7][var8];
  1155.             }
  1156.          }
  1157.  
  1158.          if (!luDecomposition(var1.nRow, var4, var6, var5)) {
  1159.             throw new SingularMatrixException(VecMathI18N.getString("GMatrix21"));
  1160.          } else {
  1161.             for(int var9 = 0; var9 < this.nRow; ++var9) {
  1162.                for(int var11 = 0; var11 < this.nCol; ++var11) {
  1163.                   var1.values[var9][var11] = var4[var9 * this.nCol + var11];
  1164.                }
  1165.             }
  1166.  
  1167.             for(int var10 = 0; var10 < var1.nRow; ++var10) {
  1168.                var2.values[var10] = (double)var6[var10];
  1169.             }
  1170.  
  1171.             return var5[0];
  1172.          }
  1173.       }
  1174.    }
  1175.  
  1176.    public final void setScale(double var1) {
  1177.       int var5;
  1178.       if (this.nRow < this.nCol) {
  1179.          var5 = this.nRow;
  1180.       } else {
  1181.          var5 = this.nCol;
  1182.       }
  1183.  
  1184.       for(int var3 = 0; var3 < this.nRow; ++var3) {
  1185.          for(int var4 = 0; var4 < this.nCol; ++var4) {
  1186.             this.values[var3][var4] = (double)0.0F;
  1187.          }
  1188.       }
  1189.  
  1190.       for(int var6 = 0; var6 < var5; ++var6) {
  1191.          this.values[var6][var6] = var1;
  1192.       }
  1193.  
  1194.    }
  1195.  
  1196.    final void invertGeneral(GMatrix var1) {
  1197.       int var2 = var1.nRow * var1.nCol;
  1198.       double[] var3 = new double[var2];
  1199.       double[] var4 = new double[var2];
  1200.       int[] var5 = new int[var1.nRow];
  1201.       int[] var6 = new int[1];
  1202.       if (var1.nRow != var1.nCol) {
  1203.          throw new MismatchedSizeException(VecMathI18N.getString("GMatrix22"));
  1204.       } else {
  1205.          for(int var7 = 0; var7 < this.nRow; ++var7) {
  1206.             for(int var8 = 0; var8 < this.nCol; ++var8) {
  1207.                var3[var7 * this.nCol + var8] = var1.values[var7][var8];
  1208.             }
  1209.          }
  1210.  
  1211.          if (!luDecomposition(var1.nRow, var3, var5, var6)) {
  1212.             throw new SingularMatrixException(VecMathI18N.getString("GMatrix21"));
  1213.          } else {
  1214.             for(int var9 = 0; var9 < var2; ++var9) {
  1215.                var4[var9] = (double)0.0F;
  1216.             }
  1217.  
  1218.             for(int var10 = 0; var10 < this.nCol; ++var10) {
  1219.                var4[var10 + var10 * this.nCol] = (double)1.0F;
  1220.             }
  1221.  
  1222.             luBacksubstitution(var1.nRow, var3, var5, var4);
  1223.  
  1224.             for(int var11 = 0; var11 < this.nRow; ++var11) {
  1225.                for(int var12 = 0; var12 < this.nCol; ++var12) {
  1226.                   this.values[var11][var12] = var4[var11 * this.nCol + var12];
  1227.                }
  1228.             }
  1229.  
  1230.          }
  1231.       }
  1232.    }
  1233.  
  1234.    static boolean luDecomposition(int var0, double[] var1, int[] var2, int[] var3) {
  1235.       double[] var4 = new double[var0];
  1236.       int var7 = 0;
  1237.       int var8 = 0;
  1238.       var3[0] = 1;
  1239.  
  1240.       double var10;
  1241.       for(int var5 = var0; var5-- != 0; var4[var8++] = (double)1.0F / var10) {
  1242.          var10 = (double)0.0F;
  1243.          int var6 = var0;
  1244.  
  1245.          while(var6-- != 0) {
  1246.             double var12 = var1[var7++];
  1247.             var12 = Math.abs(var12);
  1248.             if (var12 > var10) {
  1249.                var10 = var12;
  1250.             }
  1251.          }
  1252.  
  1253.          if (var10 == (double)0.0F) {
  1254.             return false;
  1255.          }
  1256.       }
  1257.  
  1258.       byte var9 = 0;
  1259.  
  1260.       for(int var24 = 0; var24 < var0; ++var24) {
  1261.          for(int var21 = 0; var21 < var24; ++var21) {
  1262.             int var16 = var9 + var0 * var21 + var24;
  1263.             double var19 = var1[var16];
  1264.             int var15 = var21;
  1265.             int var17 = var9 + var0 * var21;
  1266.  
  1267.             for(int var18 = var9 + var24; var15-- != 0; var18 += var0) {
  1268.                var19 -= var1[var17] * var1[var18];
  1269.                ++var17;
  1270.             }
  1271.  
  1272.             var1[var16] = var19;
  1273.          }
  1274.  
  1275.          var10 = (double)0.0F;
  1276.          int var14 = -1;
  1277.  
  1278.          for(int var22 = var24; var22 < var0; ++var22) {
  1279.             int var32 = var9 + var0 * var22 + var24;
  1280.             double var38 = var1[var32];
  1281.             int var30 = var24;
  1282.             int var34 = var9 + var0 * var22;
  1283.  
  1284.             for(int var36 = var9 + var24; var30-- != 0; var36 += var0) {
  1285.                var38 -= var1[var34] * var1[var36];
  1286.                ++var34;
  1287.             }
  1288.  
  1289.             var1[var32] = var38;
  1290.             double var27;
  1291.             if ((var27 = var4[var22] * Math.abs(var38)) >= var10) {
  1292.                var10 = var27;
  1293.                var14 = var22;
  1294.             }
  1295.          }
  1296.  
  1297.          if (var14 < 0) {
  1298.             throw new RuntimeException(VecMathI18N.getString("GMatrix24"));
  1299.          }
  1300.  
  1301.          if (var24 != var14) {
  1302.             int var31 = var0;
  1303.             int var35 = var9 + var0 * var14;
  1304.  
  1305.             double var28;
  1306.             for(int var37 = var9 + var0 * var24; var31-- != 0; var1[var37++] = var28) {
  1307.                var28 = var1[var35];
  1308.                var1[var35++] = var1[var37];
  1309.             }
  1310.  
  1311.             var4[var14] = var4[var24];
  1312.             var3[0] = -var3[0];
  1313.          }
  1314.  
  1315.          var2[var24] = var14;
  1316.          if (var1[var9 + var0 * var24 + var24] == (double)0.0F) {
  1317.             return false;
  1318.          }
  1319.  
  1320.          if (var24 != var0 - 1) {
  1321.             double var29 = (double)1.0F / var1[var9 + var0 * var24 + var24];
  1322.             int var33 = var9 + var0 * (var24 + 1) + var24;
  1323.  
  1324.             for(int var23 = var0 - 1 - var24; var23-- != 0; var33 += var0) {
  1325.                var1[var33] *= var29;
  1326.             }
  1327.          }
  1328.       }
  1329.  
  1330.       return true;
  1331.    }
  1332.  
  1333.    static void luBacksubstitution(int var0, double[] var1, int[] var2, double[] var3) {
  1334.       byte var9 = 0;
  1335.  
  1336.       for(int var8 = 0; var8 < var0; ++var8) {
  1337.          int var10 = var8;
  1338.          int var5 = -1;
  1339.  
  1340.          for(int var4 = 0; var4 < var0; ++var4) {
  1341.             int var6 = var2[var9 + var4];
  1342.             double var15 = var3[var10 + var0 * var6];
  1343.             var3[var10 + var0 * var6] = var3[var10 + var0 * var4];
  1344.             if (var5 >= 0) {
  1345.                int var11 = var4 * var0;
  1346.  
  1347.                for(int var7 = var5; var7 <= var4 - 1; ++var7) {
  1348.                   var15 -= var1[var11 + var7] * var3[var10 + var0 * var7];
  1349.                }
  1350.             } else if (var15 != (double)0.0F) {
  1351.                var5 = var4;
  1352.             }
  1353.  
  1354.             var3[var10 + var0 * var4] = var15;
  1355.          }
  1356.  
  1357.          for(int var17 = 0; var17 < var0; ++var17) {
  1358.             int var12 = var0 - 1 - var17;
  1359.             int var19 = var0 * var12;
  1360.             double var13 = (double)0.0F;
  1361.  
  1362.             for(int var18 = 1; var18 <= var17; ++var18) {
  1363.                var13 += var1[var19 + var0 - var18] * var3[var10 + var0 * (var0 - var18)];
  1364.             }
  1365.  
  1366.             var3[var10 + var0 * var12] = (var3[var10 + var0 * var12] - var13) / var1[var19 + var12];
  1367.          }
  1368.       }
  1369.  
  1370.    }
  1371.  
  1372.    static int computeSVD(GMatrix var0, GMatrix var1, GMatrix var2, GMatrix var3) {
  1373.       GMatrix var27 = new GMatrix(var0.nRow, var0.nCol);
  1374.       GMatrix var28 = new GMatrix(var0.nRow, var0.nCol);
  1375.       GMatrix var29 = new GMatrix(var0.nRow, var0.nCol);
  1376.       GMatrix var30 = new GMatrix(var0);
  1377.       int var24;
  1378.       int var25;
  1379.       if (var30.nRow >= var30.nCol) {
  1380.          var25 = var30.nCol;
  1381.          var24 = var30.nCol - 1;
  1382.       } else {
  1383.          var25 = var30.nRow;
  1384.          var24 = var30.nRow;
  1385.       }
  1386.  
  1387.       int var26;
  1388.       if (var30.nRow > var30.nCol) {
  1389.          var26 = var30.nRow;
  1390.       } else {
  1391.          var26 = var30.nCol;
  1392.       }
  1393.  
  1394.       double[] var31 = new double[var26];
  1395.       double[] var32 = new double[var25];
  1396.       double[] var33 = new double[var24];
  1397.       int var11 = 0;
  1398.       var1.setIdentity();
  1399.       var3.setIdentity();
  1400.       int var7 = var30.nRow;
  1401.       int var8 = var30.nCol;
  1402.  
  1403.       for(int var9 = 0; var9 < var25; ++var9) {
  1404.          if (var7 > 1) {
  1405.             double var18 = (double)0.0F;
  1406.  
  1407.             for(int var4 = 0; var4 < var7; ++var4) {
  1408.                var18 += var30.values[var4 + var9][var9] * var30.values[var4 + var9][var9];
  1409.             }
  1410.  
  1411.             var18 = Math.sqrt(var18);
  1412.             if (var30.values[var9][var9] == (double)0.0F) {
  1413.                var31[0] = var18;
  1414.             } else {
  1415.                var31[0] = var30.values[var9][var9] + d_sign(var18, var30.values[var9][var9]);
  1416.             }
  1417.  
  1418.             for(int var38 = 1; var38 < var7; ++var38) {
  1419.                var31[var38] = var30.values[var9 + var38][var9];
  1420.             }
  1421.  
  1422.             double var20 = (double)0.0F;
  1423.  
  1424.             for(int var39 = 0; var39 < var7; ++var39) {
  1425.                var20 += var31[var39] * var31[var39];
  1426.             }
  1427.  
  1428.             var20 = (double)2.0F / var20;
  1429.  
  1430.             for(int var5 = var9; var5 < var30.nRow; ++var5) {
  1431.                for(int var6 = var9; var6 < var30.nRow; ++var6) {
  1432.                   var28.values[var5][var6] = -var20 * var31[var5 - var9] * var31[var6 - var9];
  1433.                }
  1434.             }
  1435.  
  1436.             for(int var40 = var9; var40 < var30.nRow; ++var40) {
  1437.                int var10002 = var28.values[var40][var40]++;
  1438.             }
  1439.  
  1440.             double var22 = (double)0.0F;
  1441.  
  1442.             for(int var41 = var9; var41 < var30.nRow; ++var41) {
  1443.                var22 += var28.values[var9][var41] * var30.values[var41][var9];
  1444.             }
  1445.  
  1446.             var30.values[var9][var9] = var22;
  1447.  
  1448.             for(int var53 = var9; var53 < var30.nRow; ++var53) {
  1449.                for(int var62 = var9 + 1; var62 < var30.nCol; ++var62) {
  1450.                   var27.values[var53][var62] = (double)0.0F;
  1451.  
  1452.                   for(int var42 = var9; var42 < var30.nCol; ++var42) {
  1453.                      double[] var10000 = var27.values[var53];
  1454.                      var10000[var62] += var28.values[var53][var42] * var30.values[var42][var62];
  1455.                   }
  1456.                }
  1457.             }
  1458.  
  1459.             for(int var54 = var9; var54 < var30.nRow; ++var54) {
  1460.                for(int var63 = var9 + 1; var63 < var30.nCol; ++var63) {
  1461.                   var30.values[var54][var63] = var27.values[var54][var63];
  1462.                }
  1463.             }
  1464.  
  1465.             for(int var55 = var9; var55 < var30.nRow; ++var55) {
  1466.                for(int var64 = 0; var64 < var30.nCol; ++var64) {
  1467.                   var27.values[var55][var64] = (double)0.0F;
  1468.  
  1469.                   for(int var43 = var9; var43 < var30.nCol; ++var43) {
  1470.                      double[] var79 = var27.values[var55];
  1471.                      var79[var64] += var28.values[var55][var43] * var1.values[var43][var64];
  1472.                   }
  1473.                }
  1474.             }
  1475.  
  1476.             for(int var56 = var9; var56 < var30.nRow; ++var56) {
  1477.                for(int var65 = 0; var65 < var30.nCol; ++var65) {
  1478.                   var1.values[var56][var65] = var27.values[var56][var65];
  1479.                }
  1480.             }
  1481.  
  1482.             --var7;
  1483.          }
  1484.  
  1485.          if (var8 > 2) {
  1486.             double var73 = (double)0.0F;
  1487.  
  1488.             for(int var44 = 1; var44 < var8; ++var44) {
  1489.                var73 += var30.values[var9][var9 + var44] * var30.values[var9][var9 + var44];
  1490.             }
  1491.  
  1492.             var73 = Math.sqrt(var73);
  1493.             if (var30.values[var9][var9 + 1] == (double)0.0F) {
  1494.                var31[0] = var73;
  1495.             } else {
  1496.                var31[0] = var30.values[var9][var9 + 1] + d_sign(var73, var30.values[var9][var9 + 1]);
  1497.             }
  1498.  
  1499.             for(int var45 = 1; var45 < var8 - 1; ++var45) {
  1500.                var31[var45] = var30.values[var9][var9 + var45 + 1];
  1501.             }
  1502.  
  1503.             double var76 = (double)0.0F;
  1504.  
  1505.             for(int var46 = 0; var46 < var8 - 1; ++var46) {
  1506.                var76 += var31[var46] * var31[var46];
  1507.             }
  1508.  
  1509.             var76 = (double)2.0F / var76;
  1510.  
  1511.             for(int var57 = var9 + 1; var57 < var8; ++var57) {
  1512.                for(int var66 = var9 + 1; var66 < var30.nCol; ++var66) {
  1513.                   var29.values[var57][var66] = -var76 * var31[var57 - var9 - 1] * var31[var66 - var9 - 1];
  1514.                }
  1515.             }
  1516.  
  1517.             for(int var47 = var9 + 1; var47 < var30.nCol; ++var47) {
  1518.                int var82 = var29.values[var47][var47]++;
  1519.             }
  1520.  
  1521.             double var78 = (double)0.0F;
  1522.  
  1523.             for(int var48 = var9; var48 < var30.nCol; ++var48) {
  1524.                var78 += var29.values[var48][var9 + 1] * var30.values[var9][var48];
  1525.             }
  1526.  
  1527.             var30.values[var9][var9 + 1] = var78;
  1528.  
  1529.             for(int var58 = var9 + 1; var58 < var30.nRow; ++var58) {
  1530.                for(int var67 = var9 + 1; var67 < var30.nCol; ++var67) {
  1531.                   var27.values[var58][var67] = (double)0.0F;
  1532.  
  1533.                   for(int var49 = var9 + 1; var49 < var30.nCol; ++var49) {
  1534.                      double[] var80 = var27.values[var58];
  1535.                      var80[var67] += var29.values[var49][var67] * var30.values[var58][var49];
  1536.                   }
  1537.                }
  1538.             }
  1539.  
  1540.             for(int var59 = var9 + 1; var59 < var30.nRow; ++var59) {
  1541.                for(int var68 = var9 + 1; var68 < var30.nCol; ++var68) {
  1542.                   var30.values[var59][var68] = var27.values[var59][var68];
  1543.                }
  1544.             }
  1545.  
  1546.             for(int var60 = 0; var60 < var30.nRow; ++var60) {
  1547.                for(int var69 = var9 + 1; var69 < var30.nCol; ++var69) {
  1548.                   var27.values[var60][var69] = (double)0.0F;
  1549.  
  1550.                   for(int var50 = var9 + 1; var50 < var30.nCol; ++var50) {
  1551.                      double[] var81 = var27.values[var60];
  1552.                      var81[var69] += var29.values[var50][var69] * var3.values[var60][var50];
  1553.                   }
  1554.                }
  1555.             }
  1556.  
  1557.             for(int var61 = 0; var61 < var30.nRow; ++var61) {
  1558.                for(int var70 = var9 + 1; var70 < var30.nCol; ++var70) {
  1559.                   var3.values[var61][var70] = var27.values[var61][var70];
  1560.                }
  1561.             }
  1562.  
  1563.             --var8;
  1564.          }
  1565.       }
  1566.  
  1567.       for(int var51 = 0; var51 < var25; ++var51) {
  1568.          var32[var51] = var30.values[var51][var51];
  1569.       }
  1570.  
  1571.       for(int var52 = 0; var52 < var24; ++var52) {
  1572.          var33[var52] = var30.values[var52][var52 + 1];
  1573.       }
  1574.  
  1575.       if (var30.nRow == 2 && var30.nCol == 2) {
  1576.          double[] var34 = new double[1];
  1577.          double[] var35 = new double[1];
  1578.          double[] var36 = new double[1];
  1579.          double[] var37 = new double[1];
  1580.          compute_2X2(var32[0], var33[0], var32[1], var32, var36, var34, var37, var35, 0);
  1581.          update_u(0, var1, var34, var36);
  1582.          update_v(0, var3, var35, var37);
  1583.          return 2;
  1584.       } else {
  1585.          compute_qr(0, var33.length - 1, var32, var33, var1, var3);
  1586.          var11 = var32.length;
  1587.          return var11;
  1588.       }
  1589.    }
  1590.  
  1591.    static void compute_qr(int var0, int var1, double[] var2, double[] var3, GMatrix var4, GMatrix var5) {
  1592.       double[] var24 = new double[1];
  1593.       double[] var25 = new double[1];
  1594.       double[] var26 = new double[1];
  1595.       double[] var27 = new double[1];
  1596.       new GMatrix(var4.nCol, var5.nRow);
  1597.       double var32 = (double)1.0F;
  1598.       double var34 = (double)-1.0F;
  1599.       boolean var11 = false;
  1600.       double var20 = (double)0.0F;
  1601.       double var22 = (double)0.0F;
  1602.  
  1603.       for(int var8 = 0; var8 < 2 && !var11; ++var8) {
  1604.          int var6;
  1605.          for(var6 = var0; var6 <= var1; ++var6) {
  1606.             if (var6 == var0) {
  1607.                int var10;
  1608.                if (var3.length == var2.length) {
  1609.                   var10 = var1;
  1610.                } else {
  1611.                   var10 = var1 + 1;
  1612.                }
  1613.  
  1614.                double var12 = compute_shift(var2[var10 - 1], var3[var1], var2[var10]);
  1615.                var20 = (Math.abs(var2[var6]) - var12) * (d_sign(var32, var2[var6]) + var12 / var2[var6]);
  1616.                var22 = var3[var6];
  1617.             }
  1618.  
  1619.             double var14 = compute_rot(var20, var22, var27, var25);
  1620.             if (var6 != var0) {
  1621.                var3[var6 - 1] = var14;
  1622.             }
  1623.  
  1624.             var20 = var25[0] * var2[var6] + var27[0] * var3[var6];
  1625.             var3[var6] = var25[0] * var3[var6] - var27[0] * var2[var6];
  1626.             var22 = var27[0] * var2[var6 + 1];
  1627.             var2[var6 + 1] = var25[0] * var2[var6 + 1];
  1628.             update_v(var6, var5, var25, var27);
  1629.             var14 = compute_rot(var20, var22, var26, var24);
  1630.             var2[var6] = var14;
  1631.             var20 = var24[0] * var3[var6] + var26[0] * var2[var6 + 1];
  1632.             var2[var6 + 1] = var24[0] * var2[var6 + 1] - var26[0] * var3[var6];
  1633.             if (var6 < var1) {
  1634.                var22 = var26[0] * var3[var6 + 1];
  1635.                var3[var6 + 1] = var24[0] * var3[var6 + 1];
  1636.             }
  1637.  
  1638.             update_u(var6, var4, var24, var26);
  1639.          }
  1640.  
  1641.          if (var2.length == var3.length) {
  1642.             compute_rot(var20, var22, var27, var25);
  1643.             var20 = var25[0] * var2[var6] + var27[0] * var3[var6];
  1644.             var3[var6] = var25[0] * var3[var6] - var27[0] * var2[var6];
  1645.             var2[var6 + 1] = var25[0] * var2[var6 + 1];
  1646.             update_v(var6, var5, var25, var27);
  1647.          }
  1648.  
  1649.          while(var1 - var0 > 1 && Math.abs(var3[var1]) < 4.89E-15) {
  1650.             --var1;
  1651.          }
  1652.  
  1653.          for(int var9 = var1 - 2; var9 > var0; --var9) {
  1654.             if (Math.abs(var3[var9]) < 4.89E-15) {
  1655.                compute_qr(var9 + 1, var1, var2, var3, var4, var5);
  1656.  
  1657.                for(var1 = var9 - 1; var1 - var0 > 1 && Math.abs(var3[var1]) < 4.89E-15; --var1) {
  1658.                }
  1659.             }
  1660.          }
  1661.  
  1662.          if (var1 - var0 <= 1 && Math.abs(var3[var0 + 1]) < 4.89E-15) {
  1663.             var11 = true;
  1664.          }
  1665.       }
  1666.  
  1667.       if (Math.abs(var3[1]) < 4.89E-15) {
  1668.          compute_2X2(var2[var0], var3[var0], var2[var0 + 1], var2, var26, var24, var27, var25, 0);
  1669.          var3[var0] = (double)0.0F;
  1670.          var3[var0 + 1] = (double)0.0F;
  1671.       }
  1672.  
  1673.       update_u(var0, var4, var24, var26);
  1674.       update_v(var0, var5, var25, var27);
  1675.    }
  1676.  
  1677.    private static void print_se(double[] var0, double[] var1) {
  1678.       System.out.println("\ns =" + var0[0] + " " + var0[1] + " " + var0[2]);
  1679.       System.out.println("e =" + var1[0] + " " + var1[1]);
  1680.    }
  1681.  
  1682.    private static void update_v(int var0, GMatrix var1, double[] var2, double[] var3) {
  1683.       for(int var4 = 0; var4 < var1.nRow; ++var4) {
  1684.          double var5 = var1.values[var4][var0];
  1685.          var1.values[var4][var0] = var2[0] * var5 + var3[0] * var1.values[var4][var0 + 1];
  1686.          var1.values[var4][var0 + 1] = -var3[0] * var5 + var2[0] * var1.values[var4][var0 + 1];
  1687.       }
  1688.  
  1689.    }
  1690.  
  1691.    private static void chase_up(double[] var0, double[] var1, int var2, GMatrix var3) {
  1692.       double[] var10 = new double[1];
  1693.       double[] var11 = new double[1];
  1694.       GMatrix var13 = new GMatrix(var3.nRow, var3.nCol);
  1695.       GMatrix var14 = new GMatrix(var3.nRow, var3.nCol);
  1696.       double var4 = var1[var2];
  1697.       double var6 = var0[var2];
  1698.  
  1699.       int var12;
  1700.       for(var12 = var2; var12 > 0; --var12) {
  1701.          double var8 = compute_rot(var4, var6, var11, var10);
  1702.          var4 = -var1[var12 - 1] * var11[0];
  1703.          var6 = var0[var12 - 1];
  1704.          var0[var12] = var8;
  1705.          var1[var12 - 1] *= var10[0];
  1706.          update_v_split(var12, var2 + 1, var3, var10, var11, var13, var14);
  1707.       }
  1708.  
  1709.       var0[var12 + 1] = compute_rot(var4, var6, var11, var10);
  1710.       update_v_split(var12, var2 + 1, var3, var10, var11, var13, var14);
  1711.    }
  1712.  
  1713.    private static void chase_across(double[] var0, double[] var1, int var2, GMatrix var3) {
  1714.       double[] var10 = new double[1];
  1715.       double[] var11 = new double[1];
  1716.       GMatrix var13 = new GMatrix(var3.nRow, var3.nCol);
  1717.       GMatrix var14 = new GMatrix(var3.nRow, var3.nCol);
  1718.       double var6 = var1[var2];
  1719.       double var4 = var0[var2 + 1];
  1720.  
  1721.       int var12;
  1722.       for(var12 = var2; var12 < var3.nCol - 2; ++var12) {
  1723.          double var8 = compute_rot(var4, var6, var11, var10);
  1724.          var6 = -var1[var12 + 1] * var11[0];
  1725.          var4 = var0[var12 + 2];
  1726.          var0[var12 + 1] = var8;
  1727.          var1[var12 + 1] *= var10[0];
  1728.          update_u_split(var2, var12 + 1, var3, var10, var11, var13, var14);
  1729.       }
  1730.  
  1731.       var0[var12 + 1] = compute_rot(var4, var6, var11, var10);
  1732.       update_u_split(var2, var12 + 1, var3, var10, var11, var13, var14);
  1733.    }
  1734.  
  1735.    private static void update_v_split(int var0, int var1, GMatrix var2, double[] var3, double[] var4, GMatrix var5, GMatrix var6) {
  1736.       for(int var7 = 0; var7 < var2.nRow; ++var7) {
  1737.          double var8 = var2.values[var7][var0];
  1738.          var2.values[var7][var0] = var3[0] * var8 - var4[0] * var2.values[var7][var1];
  1739.          var2.values[var7][var1] = var4[0] * var8 + var3[0] * var2.values[var7][var1];
  1740.       }
  1741.  
  1742.       System.out.println("topr    =" + var0);
  1743.       System.out.println("bottomr =" + var1);
  1744.       System.out.println("cosr =" + var3[0]);
  1745.       System.out.println("sinr =" + var4[0]);
  1746.       System.out.println("\nm =");
  1747.       checkMatrix(var6);
  1748.       System.out.println("\nv =");
  1749.       checkMatrix(var5);
  1750.       var6.mul(var6, var5);
  1751.       System.out.println("\nt*m =");
  1752.       checkMatrix(var6);
  1753.    }
  1754.  
  1755.    private static void update_u_split(int var0, int var1, GMatrix var2, double[] var3, double[] var4, GMatrix var5, GMatrix var6) {
  1756.       for(int var7 = 0; var7 < var2.nCol; ++var7) {
  1757.          double var8 = var2.values[var0][var7];
  1758.          var2.values[var0][var7] = var3[0] * var8 - var4[0] * var2.values[var1][var7];
  1759.          var2.values[var1][var7] = var4[0] * var8 + var3[0] * var2.values[var1][var7];
  1760.       }
  1761.  
  1762.       System.out.println("\nm=");
  1763.       checkMatrix(var6);
  1764.       System.out.println("\nu=");
  1765.       checkMatrix(var5);
  1766.       var6.mul(var5, var6);
  1767.       System.out.println("\nt*m=");
  1768.       checkMatrix(var6);
  1769.    }
  1770.  
  1771.    private static void update_u(int var0, GMatrix var1, double[] var2, double[] var3) {
  1772.       for(int var4 = 0; var4 < var1.nCol; ++var4) {
  1773.          double var5 = var1.values[var0][var4];
  1774.          var1.values[var0][var4] = var2[0] * var5 + var3[0] * var1.values[var0 + 1][var4];
  1775.          var1.values[var0 + 1][var4] = -var3[0] * var5 + var2[0] * var1.values[var0 + 1][var4];
  1776.       }
  1777.  
  1778.    }
  1779.  
  1780.    private static void print_m(GMatrix var0, GMatrix var1, GMatrix var2) {
  1781.       GMatrix var3 = new GMatrix(var0.nCol, var0.nRow);
  1782.       var3.mul(var1, var3);
  1783.       var3.mul(var3, var2);
  1784.       System.out.println("\n m = \n" + toString(var3));
  1785.    }
  1786.  
  1787.    private static String toString(GMatrix var0) {
  1788.       StringBuffer var1 = new StringBuffer(var0.nRow * var0.nCol * 8);
  1789.  
  1790.       for(int var2 = 0; var2 < var0.nRow; ++var2) {
  1791.          for(int var3 = 0; var3 < var0.nCol; ++var3) {
  1792.             if (Math.abs(var0.values[var2][var3]) < 1.0E-9) {
  1793.                var1.append("0.0000 ");
  1794.             } else {
  1795.                var1.append(var0.values[var2][var3]).append(" ");
  1796.             }
  1797.          }
  1798.  
  1799.          var1.append("\n");
  1800.       }
  1801.  
  1802.       return var1.toString();
  1803.    }
  1804.  
  1805.    private static void print_svd(double[] var0, double[] var1, GMatrix var2, GMatrix var3) {
  1806.       GMatrix var5 = new GMatrix(var2.nCol, var3.nRow);
  1807.       System.out.println(" \ns = ");
  1808.  
  1809.       for(int var4 = 0; var4 < var0.length; ++var4) {
  1810.          System.out.println(" " + var0[var4]);
  1811.       }
  1812.  
  1813.       System.out.println(" \ne = ");
  1814.  
  1815.       for(int var6 = 0; var6 < var1.length; ++var6) {
  1816.          System.out.println(" " + var1[var6]);
  1817.       }
  1818.  
  1819.       System.out.println(" \nu  = \n" + var2.toString());
  1820.       System.out.println(" \nv  = \n" + var3.toString());
  1821.       var5.setIdentity();
  1822.  
  1823.       for(int var7 = 0; var7 < var0.length; ++var7) {
  1824.          var5.values[var7][var7] = var0[var7];
  1825.       }
  1826.  
  1827.       for(int var8 = 0; var8 < var1.length; ++var8) {
  1828.          var5.values[var8][var8 + 1] = var1[var8];
  1829.       }
  1830.  
  1831.       System.out.println(" \nm  = \n" + var5.toString());
  1832.       var5.mulTransposeLeft(var2, var5);
  1833.       var5.mulTransposeRight(var5, var3);
  1834.       System.out.println(" \n u.transpose*m*v.transpose  = \n" + var5.toString());
  1835.    }
  1836.  
  1837.    static double max(double var0, double var2) {
  1838.       return var0 > var2 ? var0 : var2;
  1839.    }
  1840.  
  1841.    static double min(double var0, double var2) {
  1842.       return var0 < var2 ? var0 : var2;
  1843.    }
  1844.  
  1845.    static double compute_shift(double var0, double var2, double var4) {
  1846.       double var16 = Math.abs(var0);
  1847.       double var18 = Math.abs(var2);
  1848.       double var20 = Math.abs(var4);
  1849.       double var10 = min(var16, var20);
  1850.       double var12 = max(var16, var20);
  1851.       double var28;
  1852.       if (var10 == (double)0.0F) {
  1853.          var28 = (double)0.0F;
  1854.          if (var12 != (double)0.0F) {
  1855.             double var6 = min(var12, var18) / max(var12, var18);
  1856.          }
  1857.       } else if (var18 < var12) {
  1858.          double var22 = var10 / var12 + (double)1.0F;
  1859.          double var24 = (var12 - var10) / var12;
  1860.          double var30 = var18 / var12;
  1861.          double var26 = var30 * var30;
  1862.          double var14 = (double)2.0F / (Math.sqrt(var22 * var22 + var26) + Math.sqrt(var24 * var24 + var26));
  1863.          var28 = var10 * var14;
  1864.       } else {
  1865.          double var35 = var12 / var18;
  1866.          if (var35 == (double)0.0F) {
  1867.             var28 = var10 * var12 / var18;
  1868.          } else {
  1869.             double var33 = var10 / var12 + (double)1.0F;
  1870.             double var34 = (var12 - var10) / var12;
  1871.             double var31 = var33 * var35;
  1872.             double var8 = var34 * var35;
  1873.             double var32 = (double)1.0F / (Math.sqrt(var31 * var31 + (double)1.0F) + Math.sqrt(var8 * var8 + (double)1.0F));
  1874.             var28 = var10 * var32 * var35;
  1875.             var28 += var28;
  1876.          }
  1877.       }
  1878.  
  1879.       return var28;
  1880.    }
  1881.  
  1882.    static int compute_2X2(double var0, double var2, double var4, double[] var6, double[] var7, double[] var8, double[] var9, double[] var10, int var11) {
  1883.       double var12 = (double)2.0F;
  1884.       double var14 = (double)1.0F;
  1885.       double var65 = var6[0];
  1886.       double var63 = var6[1];
  1887.       double var55 = (double)0.0F;
  1888.       double var57 = (double)0.0F;
  1889.       double var59 = (double)0.0F;
  1890.       double var61 = (double)0.0F;
  1891.       double var36 = (double)0.0F;
  1892.       double var44 = var0;
  1893.       double var38 = Math.abs(var0);
  1894.       double var48 = var4;
  1895.       double var42 = Math.abs(var4);
  1896.       byte var18 = 1;
  1897.       boolean var21;
  1898.       if (var42 > var38) {
  1899.          var21 = true;
  1900.       } else {
  1901.          var21 = false;
  1902.       }
  1903.  
  1904.       if (var21) {
  1905.          var18 = 3;
  1906.          var44 = var4;
  1907.          var48 = var0;
  1908.          double var19 = var38;
  1909.          var38 = var42;
  1910.          var42 = var19;
  1911.       }
  1912.  
  1913.       double var40 = Math.abs(var2);
  1914.       if (var40 == (double)0.0F) {
  1915.          var6[1] = var42;
  1916.          var6[0] = var38;
  1917.          var55 = (double)1.0F;
  1918.          var57 = (double)1.0F;
  1919.          var59 = (double)0.0F;
  1920.          var61 = (double)0.0F;
  1921.       } else {
  1922.          boolean var52 = true;
  1923.          if (var40 > var38) {
  1924.             var18 = 2;
  1925.             if (var38 / var40 < 1.0E-10) {
  1926.                var52 = false;
  1927.                var65 = var40;
  1928.                if (var42 > (double)1.0F) {
  1929.                   var63 = var38 / (var40 / var42);
  1930.                } else {
  1931.                   var63 = var38 / var40 * var42;
  1932.                }
  1933.  
  1934.                var55 = (double)1.0F;
  1935.                var59 = var48 / var2;
  1936.                var61 = (double)1.0F;
  1937.                var57 = var44 / var2;
  1938.             }
  1939.          }
  1940.  
  1941.          if (var52) {
  1942.             double var24 = var38 - var42;
  1943.             double var26;
  1944.             if (var24 == var38) {
  1945.                var26 = (double)1.0F;
  1946.             } else {
  1947.                var26 = var24 / var38;
  1948.             }
  1949.  
  1950.             double var28 = var2 / var44;
  1951.             double var34 = (double)2.0F - var26;
  1952.             double var50 = var28 * var28;
  1953.             double var53 = var34 * var34;
  1954.             double var32 = Math.sqrt(var53 + var50);
  1955.             double var30;
  1956.             if (var26 == (double)0.0F) {
  1957.                var30 = Math.abs(var28);
  1958.             } else {
  1959.                var30 = Math.sqrt(var26 * var26 + var50);
  1960.             }
  1961.  
  1962.             double var22 = (var32 + var30) * (double)0.5F;
  1963.             if (var40 > var38) {
  1964.                var18 = 2;
  1965.                if (var38 / var40 < 1.0E-10) {
  1966.                   var52 = false;
  1967.                   var65 = var40;
  1968.                   if (var42 > (double)1.0F) {
  1969.                      var63 = var38 / (var40 / var42);
  1970.                   } else {
  1971.                      var63 = var38 / var40 * var42;
  1972.                   }
  1973.  
  1974.                   var55 = (double)1.0F;
  1975.                   var59 = var48 / var2;
  1976.                   var61 = (double)1.0F;
  1977.                   var57 = var44 / var2;
  1978.                }
  1979.             }
  1980.  
  1981.             if (var52) {
  1982.                var24 = var38 - var42;
  1983.                if (var24 == var38) {
  1984.                   var26 = (double)1.0F;
  1985.                } else {
  1986.                   var26 = var24 / var38;
  1987.                }
  1988.  
  1989.                var28 = var2 / var44;
  1990.                var34 = (double)2.0F - var26;
  1991.                var50 = var28 * var28;
  1992.                var53 = var34 * var34;
  1993.                var32 = Math.sqrt(var53 + var50);
  1994.                if (var26 == (double)0.0F) {
  1995.                   var30 = Math.abs(var28);
  1996.                } else {
  1997.                   var30 = Math.sqrt(var26 * var26 + var50);
  1998.                }
  1999.  
  2000.                var22 = (var32 + var30) * (double)0.5F;
  2001.                var63 = var42 / var22;
  2002.                var65 = var38 * var22;
  2003.                if (var50 == (double)0.0F) {
  2004.                   if (var26 == (double)0.0F) {
  2005.                      var34 = d_sign(var12, var44) * d_sign(var14, var2);
  2006.                   } else {
  2007.                      var34 = var2 / d_sign(var24, var44) + var28 / var34;
  2008.                   }
  2009.                } else {
  2010.                   var34 = (var28 / (var32 + var34) + var28 / (var30 + var26)) * (var22 + (double)1.0F);
  2011.                }
  2012.  
  2013.                var26 = Math.sqrt(var34 * var34 + (double)4.0F);
  2014.                var57 = (double)2.0F / var26;
  2015.                var61 = var34 / var26;
  2016.                var55 = (var57 + var61 * var28) / var22;
  2017.                var59 = var48 / var44 * var61 / var22;
  2018.             }
  2019.          }
  2020.  
  2021.          if (var21) {
  2022.             var8[0] = var61;
  2023.             var7[0] = var57;
  2024.             var10[0] = var59;
  2025.             var9[0] = var55;
  2026.          } else {
  2027.             var8[0] = var55;
  2028.             var7[0] = var59;
  2029.             var10[0] = var57;
  2030.             var9[0] = var61;
  2031.          }
  2032.  
  2033.          if (var18 == 1) {
  2034.             var36 = d_sign(var14, var10[0]) * d_sign(var14, var8[0]) * d_sign(var14, var0);
  2035.          }
  2036.  
  2037.          if (var18 == 2) {
  2038.             var36 = d_sign(var14, var9[0]) * d_sign(var14, var8[0]) * d_sign(var14, var2);
  2039.          }
  2040.  
  2041.          if (var18 == 3) {
  2042.             var36 = d_sign(var14, var9[0]) * d_sign(var14, var7[0]) * d_sign(var14, var4);
  2043.          }
  2044.  
  2045.          var6[var11] = d_sign(var65, var36);
  2046.          double var16 = var36 * d_sign(var14, var0) * d_sign(var14, var4);
  2047.          var6[var11 + 1] = d_sign(var63, var16);
  2048.       }
  2049.  
  2050.       return 0;
  2051.    }
  2052.  
  2053.    static double compute_rot(double var0, double var2, double[] var4, double[] var5) {
  2054.       double var11;
  2055.       double var13;
  2056.       double var23;
  2057.       if (var2 == (double)0.0F) {
  2058.          var11 = (double)1.0F;
  2059.          var13 = (double)0.0F;
  2060.          var23 = var0;
  2061.       } else if (var0 == (double)0.0F) {
  2062.          var11 = (double)0.0F;
  2063.          var13 = (double)1.0F;
  2064.          var23 = var2;
  2065.       } else {
  2066.          double var19 = var0;
  2067.          double var21 = var2;
  2068.          double var16 = max(Math.abs(var0), Math.abs(var2));
  2069.          if (var16 >= 4.994797680505588E145) {
  2070.             int var30;
  2071.             for(var30 = 0; var16 >= 4.994797680505588E145; var16 = max(Math.abs(var19), Math.abs(var21))) {
  2072.                ++var30;
  2073.                var19 *= 2.002083095183101E-146;
  2074.                var21 *= 2.002083095183101E-146;
  2075.             }
  2076.  
  2077.             var23 = Math.sqrt(var19 * var19 + var21 * var21);
  2078.             var11 = var19 / var23;
  2079.             var13 = var21 / var23;
  2080.  
  2081.             for(int var29 = 1; var29 <= var30; ++var29) {
  2082.                var23 *= 4.994797680505588E145;
  2083.             }
  2084.          } else if (!(var16 <= 2.002083095183101E-146)) {
  2085.             var23 = Math.sqrt(var0 * var0 + var2 * var2);
  2086.             var11 = var0 / var23;
  2087.             var13 = var2 / var23;
  2088.          } else {
  2089.             int var18;
  2090.             for(var18 = 0; var16 <= 2.002083095183101E-146; var16 = max(Math.abs(var19), Math.abs(var21))) {
  2091.                ++var18;
  2092.                var19 *= 4.994797680505588E145;
  2093.                var21 *= 4.994797680505588E145;
  2094.             }
  2095.  
  2096.             var23 = Math.sqrt(var19 * var19 + var21 * var21);
  2097.             var11 = var19 / var23;
  2098.             var13 = var21 / var23;
  2099.  
  2100.             for(int var15 = 1; var15 <= var18; ++var15) {
  2101.                var23 *= 2.002083095183101E-146;
  2102.             }
  2103.          }
  2104.  
  2105.          if (Math.abs(var0) > Math.abs(var2) && var11 < (double)0.0F) {
  2106.             var11 = -var11;
  2107.             var13 = -var13;
  2108.             var23 = -var23;
  2109.          }
  2110.       }
  2111.  
  2112.       var4[0] = var13;
  2113.       var5[0] = var11;
  2114.       return var23;
  2115.    }
  2116.  
  2117.    static double d_sign(double var0, double var2) {
  2118.       double var4 = var0 >= (double)0.0F ? var0 : -var0;
  2119.       return var2 >= (double)0.0F ? var4 : -var4;
  2120.    }
  2121.  
  2122.    public Object clone() {
  2123.       GMatrix var1 = null;
  2124.  
  2125.       try {
  2126.          var1 = (GMatrix)super.clone();
  2127.       } catch (CloneNotSupportedException var4) {
  2128.          throw new InternalError();
  2129.       }
  2130.  
  2131.       var1.values = new double[this.nRow][this.nCol];
  2132.  
  2133.       for(int var2 = 0; var2 < this.nRow; ++var2) {
  2134.          for(int var3 = 0; var3 < this.nCol; ++var3) {
  2135.             var1.values[var2][var3] = this.values[var2][var3];
  2136.          }
  2137.       }
  2138.  
  2139.       return var1;
  2140.    }
  2141. }
  2142.