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 / GVector.class (.txt) < prev    next >
Encoding:
Java Class File  |  2002-06-19  |  9.2 KB  |  626 lines
  1. package javax.vecmath;
  2.  
  3. import java.io.Serializable;
  4.  
  5. public class GVector implements Serializable, Cloneable {
  6.    private int length;
  7.    double[] values;
  8.    static final long serialVersionUID = 1398850036893875112L;
  9.  
  10.    public GVector(int var1) {
  11.       this.length = var1;
  12.       this.values = new double[var1];
  13.  
  14.       for(int var2 = 0; var2 < var1; ++var2) {
  15.          this.values[var2] = (double)0.0F;
  16.       }
  17.  
  18.    }
  19.  
  20.    public GVector(double[] var1) {
  21.       this.length = var1.length;
  22.       this.values = new double[var1.length];
  23.  
  24.       for(int var2 = 0; var2 < this.length; ++var2) {
  25.          this.values[var2] = var1[var2];
  26.       }
  27.  
  28.    }
  29.  
  30.    public GVector(GVector var1) {
  31.       this.values = new double[var1.length];
  32.       this.length = var1.length;
  33.  
  34.       for(int var2 = 0; var2 < this.length; ++var2) {
  35.          this.values[var2] = var1.values[var2];
  36.       }
  37.  
  38.    }
  39.  
  40.    public GVector(Tuple2f var1) {
  41.       this.values = new double[2];
  42.       this.values[0] = (double)var1.x;
  43.       this.values[1] = (double)var1.y;
  44.       this.length = 2;
  45.    }
  46.  
  47.    public GVector(Tuple3f var1) {
  48.       this.values = new double[3];
  49.       this.values[0] = (double)var1.x;
  50.       this.values[1] = (double)var1.y;
  51.       this.values[2] = (double)var1.z;
  52.       this.length = 3;
  53.    }
  54.  
  55.    public GVector(Tuple3d var1) {
  56.       this.values = new double[3];
  57.       this.values[0] = var1.x;
  58.       this.values[1] = var1.y;
  59.       this.values[2] = var1.z;
  60.       this.length = 3;
  61.    }
  62.  
  63.    public GVector(Tuple4f var1) {
  64.       this.values = new double[4];
  65.       this.values[0] = (double)var1.x;
  66.       this.values[1] = (double)var1.y;
  67.       this.values[2] = (double)var1.z;
  68.       this.values[3] = (double)var1.w;
  69.       this.length = 4;
  70.    }
  71.  
  72.    public GVector(Tuple4d var1) {
  73.       this.values = new double[4];
  74.       this.values[0] = var1.x;
  75.       this.values[1] = var1.y;
  76.       this.values[2] = var1.z;
  77.       this.values[3] = var1.w;
  78.       this.length = 4;
  79.    }
  80.  
  81.    public GVector(double[] var1, int var2) {
  82.       this.length = var2;
  83.       this.values = new double[var2];
  84.  
  85.       for(int var3 = 0; var3 < var2; ++var3) {
  86.          this.values[var3] = var1[var3];
  87.       }
  88.  
  89.    }
  90.  
  91.    public final double norm() {
  92.       double var1 = (double)0.0F;
  93.  
  94.       for(int var3 = 0; var3 < this.length; ++var3) {
  95.          var1 += this.values[var3] * this.values[var3];
  96.       }
  97.  
  98.       return Math.sqrt(var1);
  99.    }
  100.  
  101.    public final double normSquared() {
  102.       double var1 = (double)0.0F;
  103.  
  104.       for(int var3 = 0; var3 < this.length; ++var3) {
  105.          var1 += this.values[var3] * this.values[var3];
  106.       }
  107.  
  108.       return var1;
  109.    }
  110.  
  111.    public final void normalize(GVector var1) {
  112.       double var2 = (double)0.0F;
  113.       if (this.length != var1.length) {
  114.          throw new MismatchedSizeException(VecMathI18N.getString("GVector0"));
  115.       } else {
  116.          for(int var4 = 0; var4 < this.length; ++var4) {
  117.             var2 += var1.values[var4] * var1.values[var4];
  118.          }
  119.  
  120.          double var5 = (double)1.0F / Math.sqrt(var2);
  121.  
  122.          for(int var7 = 0; var7 < this.length; ++var7) {
  123.             this.values[var7] = var1.values[var7] * var5;
  124.          }
  125.  
  126.       }
  127.    }
  128.  
  129.    public final void normalize() {
  130.       double var1 = (double)0.0F;
  131.  
  132.       for(int var3 = 0; var3 < this.length; ++var3) {
  133.          var1 += this.values[var3] * this.values[var3];
  134.       }
  135.  
  136.       double var4 = (double)1.0F / Math.sqrt(var1);
  137.  
  138.       for(int var6 = 0; var6 < this.length; ++var6) {
  139.          this.values[var6] *= var4;
  140.       }
  141.  
  142.    }
  143.  
  144.    public final void scale(double var1, GVector var3) {
  145.       if (this.length != var3.length) {
  146.          throw new MismatchedSizeException(VecMathI18N.getString("GVector1"));
  147.       } else {
  148.          for(int var4 = 0; var4 < this.length; ++var4) {
  149.             this.values[var4] = var3.values[var4] * var1;
  150.          }
  151.  
  152.       }
  153.    }
  154.  
  155.    public final void scale(double var1) {
  156.       for(int var3 = 0; var3 < this.length; ++var3) {
  157.          this.values[var3] *= var1;
  158.       }
  159.  
  160.    }
  161.  
  162.    public final void scaleAdd(double var1, GVector var3, GVector var4) {
  163.       if (var4.length != var3.length) {
  164.          throw new MismatchedSizeException(VecMathI18N.getString("GVector2"));
  165.       } else if (this.length != var3.length) {
  166.          throw new MismatchedSizeException(VecMathI18N.getString("GVector3"));
  167.       } else {
  168.          for(int var5 = 0; var5 < this.length; ++var5) {
  169.             this.values[var5] = var3.values[var5] * var1 + var4.values[var5];
  170.          }
  171.  
  172.       }
  173.    }
  174.  
  175.    public final void add(GVector var1) {
  176.       if (this.length != var1.length) {
  177.          throw new MismatchedSizeException(VecMathI18N.getString("GVector4"));
  178.       } else {
  179.          for(int var2 = 0; var2 < this.length; ++var2) {
  180.             double[] var10000 = this.values;
  181.             var10000[var2] += var1.values[var2];
  182.          }
  183.  
  184.       }
  185.    }
  186.  
  187.    public final void add(GVector var1, GVector var2) {
  188.       if (var1.length != var2.length) {
  189.          throw new MismatchedSizeException(VecMathI18N.getString("GVector5"));
  190.       } else if (this.length != var1.length) {
  191.          throw new MismatchedSizeException(VecMathI18N.getString("GVector6"));
  192.       } else {
  193.          for(int var3 = 0; var3 < this.length; ++var3) {
  194.             this.values[var3] = var1.values[var3] + var2.values[var3];
  195.          }
  196.  
  197.       }
  198.    }
  199.  
  200.    public final void sub(GVector var1) {
  201.       if (this.length != var1.length) {
  202.          throw new MismatchedSizeException(VecMathI18N.getString("GVector7"));
  203.       } else {
  204.          for(int var2 = 0; var2 < this.length; ++var2) {
  205.             double[] var10000 = this.values;
  206.             var10000[var2] -= var1.values[var2];
  207.          }
  208.  
  209.       }
  210.    }
  211.  
  212.    public final void sub(GVector var1, GVector var2) {
  213.       if (var1.length != var2.length) {
  214.          throw new MismatchedSizeException(VecMathI18N.getString("GVector8"));
  215.       } else if (this.length != var1.length) {
  216.          throw new MismatchedSizeException(VecMathI18N.getString("GVector9"));
  217.       } else {
  218.          for(int var3 = 0; var3 < this.length; ++var3) {
  219.             this.values[var3] = var1.values[var3] - var2.values[var3];
  220.          }
  221.  
  222.       }
  223.    }
  224.  
  225.    public final void mul(GMatrix var1, GVector var2) {
  226.       if (var1.getNumCol() != var2.length) {
  227.          throw new MismatchedSizeException(VecMathI18N.getString("GVector10"));
  228.       } else if (this.length != var1.getNumRow()) {
  229.          throw new MismatchedSizeException(VecMathI18N.getString("GVector11"));
  230.       } else {
  231.          double[] var3;
  232.          if (var2 != this) {
  233.             var3 = var2.values;
  234.          } else {
  235.             var3 = (double[])this.values.clone();
  236.          }
  237.  
  238.          for(int var4 = this.length - 1; var4 >= 0; --var4) {
  239.             this.values[var4] = (double)0.0F;
  240.  
  241.             for(int var5 = var2.length - 1; var5 >= 0; --var5) {
  242.                double[] var10000 = this.values;
  243.                var10000[var4] += var1.values[var4][var5] * var3[var5];
  244.             }
  245.          }
  246.  
  247.       }
  248.    }
  249.  
  250.    public final void mul(GVector var1, GMatrix var2) {
  251.       if (var2.getNumRow() != var1.length) {
  252.          throw new MismatchedSizeException(VecMathI18N.getString("GVector12"));
  253.       } else if (this.length != var2.getNumCol()) {
  254.          throw new MismatchedSizeException(VecMathI18N.getString("GVector13"));
  255.       } else {
  256.          double[] var3;
  257.          if (var1 != this) {
  258.             var3 = var1.values;
  259.          } else {
  260.             var3 = (double[])this.values.clone();
  261.          }
  262.  
  263.          for(int var4 = this.length - 1; var4 >= 0; --var4) {
  264.             this.values[var4] = (double)0.0F;
  265.  
  266.             for(int var5 = var1.length - 1; var5 >= 0; --var5) {
  267.                double[] var10000 = this.values;
  268.                var10000[var4] += var2.values[var5][var4] * var3[var5];
  269.             }
  270.          }
  271.  
  272.       }
  273.    }
  274.  
  275.    public final void negate() {
  276.       for(int var1 = this.length - 1; var1 >= 0; --var1) {
  277.          double[] var10000 = this.values;
  278.          var10000[var1] *= (double)-1.0F;
  279.       }
  280.  
  281.    }
  282.  
  283.    public final void zero() {
  284.       for(int var1 = 0; var1 < this.length; ++var1) {
  285.          this.values[var1] = (double)0.0F;
  286.       }
  287.  
  288.    }
  289.  
  290.    public final void setSize(int var1) {
  291.       double[] var2 = new double[var1];
  292.       int var4;
  293.       if (this.length < var1) {
  294.          var4 = this.length;
  295.       } else {
  296.          var4 = var1;
  297.       }
  298.  
  299.       for(int var3 = 0; var3 < var4; ++var3) {
  300.          var2[var3] = this.values[var3];
  301.       }
  302.  
  303.       this.length = var1;
  304.       this.values = var2;
  305.    }
  306.  
  307.    public final void set(double[] var1) {
  308.       for(int var2 = this.length - 1; var2 >= 0; --var2) {
  309.          this.values[var2] = var1[var2];
  310.       }
  311.  
  312.    }
  313.  
  314.    public final void set(GVector var1) {
  315.       if (this.length < var1.length) {
  316.          this.length = var1.length;
  317.          this.values = new double[this.length];
  318.  
  319.          for(int var2 = 0; var2 < this.length; ++var2) {
  320.             this.values[var2] = var1.values[var2];
  321.          }
  322.       } else {
  323.          for(int var3 = 0; var3 < var1.length; ++var3) {
  324.             this.values[var3] = var1.values[var3];
  325.          }
  326.  
  327.          for(int var4 = var1.length; var4 < this.length; ++var4) {
  328.             this.values[var4] = (double)0.0F;
  329.          }
  330.       }
  331.  
  332.    }
  333.  
  334.    public final void set(Tuple2f var1) {
  335.       if (this.length < 2) {
  336.          this.length = 2;
  337.          this.values = new double[2];
  338.       }
  339.  
  340.       this.values[0] = (double)var1.x;
  341.       this.values[1] = (double)var1.y;
  342.  
  343.       for(int var2 = 2; var2 < this.length; ++var2) {
  344.          this.values[var2] = (double)0.0F;
  345.       }
  346.  
  347.    }
  348.  
  349.    public final void set(Tuple3f var1) {
  350.       if (this.length < 3) {
  351.          this.length = 3;
  352.          this.values = new double[3];
  353.       }
  354.  
  355.       this.values[0] = (double)var1.x;
  356.       this.values[1] = (double)var1.y;
  357.       this.values[2] = (double)var1.z;
  358.  
  359.       for(int var2 = 3; var2 < this.length; ++var2) {
  360.          this.values[var2] = (double)0.0F;
  361.       }
  362.  
  363.    }
  364.  
  365.    public final void set(Tuple3d var1) {
  366.       if (this.length < 3) {
  367.          this.length = 3;
  368.          this.values = new double[3];
  369.       }
  370.  
  371.       this.values[0] = var1.x;
  372.       this.values[1] = var1.y;
  373.       this.values[2] = var1.z;
  374.  
  375.       for(int var2 = 3; var2 < this.length; ++var2) {
  376.          this.values[var2] = (double)0.0F;
  377.       }
  378.  
  379.    }
  380.  
  381.    public final void set(Tuple4f var1) {
  382.       if (this.length < 4) {
  383.          this.length = 4;
  384.          this.values = new double[4];
  385.       }
  386.  
  387.       this.values[0] = (double)var1.x;
  388.       this.values[1] = (double)var1.y;
  389.       this.values[2] = (double)var1.z;
  390.       this.values[3] = (double)var1.w;
  391.  
  392.       for(int var2 = 4; var2 < this.length; ++var2) {
  393.          this.values[var2] = (double)0.0F;
  394.       }
  395.  
  396.    }
  397.  
  398.    public final void set(Tuple4d var1) {
  399.       if (this.length < 4) {
  400.          this.length = 4;
  401.          this.values = new double[4];
  402.       }
  403.  
  404.       this.values[0] = var1.x;
  405.       this.values[1] = var1.y;
  406.       this.values[2] = var1.z;
  407.       this.values[3] = var1.w;
  408.  
  409.       for(int var2 = 4; var2 < this.length; ++var2) {
  410.          this.values[var2] = (double)0.0F;
  411.       }
  412.  
  413.    }
  414.  
  415.    public final int getSize() {
  416.       return this.values.length;
  417.    }
  418.  
  419.    public final double getElement(int var1) {
  420.       return this.values[var1];
  421.    }
  422.  
  423.    public final void setElement(int var1, double var2) {
  424.       this.values[var1] = var2;
  425.    }
  426.  
  427.    public String toString() {
  428.       StringBuffer var1 = new StringBuffer(this.length * 8);
  429.  
  430.       for(int var2 = 0; var2 < this.length; ++var2) {
  431.          var1.append(this.values[var2]).append(" ");
  432.       }
  433.  
  434.       return var1.toString();
  435.    }
  436.  
  437.    public int hashCode() {
  438.       long var1 = 1L;
  439.  
  440.       for(int var3 = 0; var3 < this.length; ++var3) {
  441.          var1 = 31L * var1 + Double.doubleToLongBits(this.values[var3]);
  442.       }
  443.  
  444.       return (int)(var1 ^ var1 >> 32);
  445.    }
  446.  
  447.    public boolean equals(GVector var1) {
  448.       try {
  449.          if (this.length != var1.length) {
  450.             return false;
  451.          } else {
  452.             for(int var2 = 0; var2 < this.length; ++var2) {
  453.                if (this.values[var2] != var1.values[var2]) {
  454.                   return false;
  455.                }
  456.             }
  457.  
  458.             return true;
  459.          }
  460.       } catch (NullPointerException var3) {
  461.          return false;
  462.       }
  463.    }
  464.  
  465.    public boolean equals(Object var1) {
  466.       try {
  467.          GVector var2 = (GVector)var1;
  468.          if (this.length != var2.length) {
  469.             return false;
  470.          } else {
  471.             for(int var3 = 0; var3 < this.length; ++var3) {
  472.                if (this.values[var3] != var2.values[var3]) {
  473.                   return false;
  474.                }
  475.             }
  476.  
  477.             return true;
  478.          }
  479.       } catch (ClassCastException var4) {
  480.          return false;
  481.       } catch (NullPointerException var5) {
  482.          return false;
  483.       }
  484.    }
  485.  
  486.    public boolean epsilonEquals(GVector var1, double var2) {
  487.       if (this.length != var1.length) {
  488.          return false;
  489.       } else {
  490.          for(int var6 = 0; var6 < this.length; ++var6) {
  491.             double var4 = this.values[var6] - var1.values[var6];
  492.             if ((var4 < (double)0.0F ? -var4 : var4) > var2) {
  493.                return false;
  494.             }
  495.          }
  496.  
  497.          return true;
  498.       }
  499.    }
  500.  
  501.    public final double dot(GVector var1) {
  502.       if (this.length != var1.length) {
  503.          throw new MismatchedSizeException(VecMathI18N.getString("GVector14"));
  504.       } else {
  505.          double var2 = (double)0.0F;
  506.  
  507.          for(int var4 = 0; var4 < this.length; ++var4) {
  508.             var2 += this.values[var4] * var1.values[var4];
  509.          }
  510.  
  511.          return var2;
  512.       }
  513.    }
  514.  
  515.    public final void SVDBackSolve(GMatrix var1, GMatrix var2, GMatrix var3, GVector var4) {
  516.       if (var1.nRow == var4.getSize() && var1.nRow == var1.nCol && var1.nRow == var2.nRow) {
  517.          if (var2.nCol == this.values.length && var2.nCol == var3.nCol && var2.nCol == var3.nRow) {
  518.             GMatrix var5 = new GMatrix(var1.nRow, var2.nCol);
  519.             var5.mul(var1, var3);
  520.             var5.mulTransposeRight(var1, var2);
  521.             var5.invert();
  522.             this.mul(var5, var4);
  523.          } else {
  524.             throw new MismatchedSizeException(VecMathI18N.getString("GVector23"));
  525.          }
  526.       } else {
  527.          throw new MismatchedSizeException(VecMathI18N.getString("GVector15"));
  528.       }
  529.    }
  530.  
  531.    public final void LUDBackSolve(GMatrix var1, GVector var2, GVector var3) {
  532.       int var4 = var1.nRow * var1.nCol;
  533.       double[] var5 = new double[var4];
  534.       double[] var6 = new double[var4];
  535.       int[] var7 = new int[var2.getSize()];
  536.       if (var1.nRow != var2.getSize()) {
  537.          throw new MismatchedSizeException(VecMathI18N.getString("GVector16"));
  538.       } else if (var1.nRow != var3.getSize()) {
  539.          throw new MismatchedSizeException(VecMathI18N.getString("GVector24"));
  540.       } else if (var1.nRow != var1.nCol) {
  541.          throw new MismatchedSizeException(VecMathI18N.getString("GVector25"));
  542.       } else {
  543.          for(int var8 = 0; var8 < var1.nRow; ++var8) {
  544.             for(int var9 = 0; var9 < var1.nCol; ++var9) {
  545.                var5[var8 * var1.nCol + var9] = var1.values[var8][var9];
  546.             }
  547.          }
  548.  
  549.          for(int var10 = 0; var10 < var4; ++var10) {
  550.             var6[var10] = (double)0.0F;
  551.          }
  552.  
  553.          for(int var11 = 0; var11 < var1.nRow; ++var11) {
  554.             var6[var11 * var1.nCol] = var2.values[var11];
  555.          }
  556.  
  557.          for(int var12 = 0; var12 < var1.nCol; ++var12) {
  558.             var7[var12] = (int)var3.values[var12];
  559.          }
  560.  
  561.          GMatrix.luBacksubstitution(var1.nRow, var5, var7, var6);
  562.  
  563.          for(int var13 = 0; var13 < var1.nRow; ++var13) {
  564.             this.values[var13] = var6[var13 * var1.nCol];
  565.          }
  566.  
  567.       }
  568.    }
  569.  
  570.    public final double angle(GVector var1) {
  571.       return Math.acos(this.dot(var1) / (this.norm() * var1.norm()));
  572.    }
  573.  
  574.    /** @deprecated */
  575.    public final void interpolate(GVector var1, GVector var2, float var3) {
  576.       this.interpolate(var1, var2, (double)var3);
  577.    }
  578.  
  579.    /** @deprecated */
  580.    public final void interpolate(GVector var1, float var2) {
  581.       this.interpolate(var1, (double)var2);
  582.    }
  583.  
  584.    public final void interpolate(GVector var1, GVector var2, double var3) {
  585.       if (var2.length != var1.length) {
  586.          throw new MismatchedSizeException(VecMathI18N.getString("GVector20"));
  587.       } else if (this.length != var1.length) {
  588.          throw new MismatchedSizeException(VecMathI18N.getString("GVector21"));
  589.       } else {
  590.          for(int var5 = 0; var5 < this.length; ++var5) {
  591.             this.values[var5] = ((double)1.0F - var3) * var1.values[var5] + var3 * var2.values[var5];
  592.          }
  593.  
  594.       }
  595.    }
  596.  
  597.    public final void interpolate(GVector var1, double var2) {
  598.       if (var1.length != this.length) {
  599.          throw new MismatchedSizeException(VecMathI18N.getString("GVector22"));
  600.       } else {
  601.          for(int var4 = 0; var4 < this.length; ++var4) {
  602.             this.values[var4] = ((double)1.0F - var2) * this.values[var4] + var2 * var1.values[var4];
  603.          }
  604.  
  605.       }
  606.    }
  607.  
  608.    public Object clone() {
  609.       GVector var1 = null;
  610.  
  611.       try {
  612.          var1 = (GVector)super.clone();
  613.       } catch (CloneNotSupportedException var3) {
  614.          throw new InternalError();
  615.       }
  616.  
  617.       var1.values = new double[this.length];
  618.  
  619.       for(int var2 = 0; var2 < this.length; ++var2) {
  620.          var1.values[var2] = this.values[var2];
  621.       }
  622.  
  623.       return var1;
  624.    }
  625. }
  626.