commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pste...@apache.org
Subject svn commit: r476930 [7/22] - in /jakarta/commons/proper/math/trunk/src/mantissa: ./ src/ src/org/ src/org/spaceroots/ src/org/spaceroots/mantissa/ src/org/spaceroots/mantissa/algebra/ src/org/spaceroots/mantissa/estimation/ src/org/spaceroots/mantissa/...
Date Sun, 19 Nov 2006 21:36:23 GMT
Propchange: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/geometry/Vector3D.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/DiagonalMatrix.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/DiagonalMatrix.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/DiagonalMatrix.java (added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/DiagonalMatrix.java Sun Nov 19 13:36:15 2006
@@ -0,0 +1,142 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// 
+//   http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.spaceroots.mantissa.linalg;
+
+import java.io.Serializable;
+
+/** This class implements diagonal matrices of linear algebra.
+
+ * @version $Id: DiagonalMatrix.java 1705 2006-09-17 19:57:39Z luc $
+ * @author L. Maisonobe
+
+ */
+
+public class DiagonalMatrix
+  extends SquareMatrix
+  implements Serializable, Cloneable {
+
+  /** Simple constructor.
+   * This constructor builds a diagonal matrix of specified order, all
+   * elements on the diagonal being ones (so this is an identity matrix).
+   * @param order order of the matrix
+   */
+  public DiagonalMatrix(int order) {
+    this(order, 1.0);
+  }
+
+  /** Simple constructor.
+   * This constructor builds a diagonal matrix of specified order and
+   * set all diagonal elements to the same value.
+   * @param order order of the matrix
+   * @param value value for the diagonal elements
+   */
+  public DiagonalMatrix(int order, double value) {
+    super(order);
+    for (int index = 0; index < order * order; index += order + 1) {
+      data[index] = value;
+    }
+  }
+
+  /** Simple constructor.
+   * Build a matrix with specified elements.
+   * @param order order of the matrix
+   * @param data table of the matrix elements (stored row after row)
+   */
+  public DiagonalMatrix(int order, double[] data) {
+    super(order, data);
+  }
+
+  /** Copy constructor.
+   * @param d diagonal matrix to copy
+   */
+  public DiagonalMatrix(DiagonalMatrix d) {
+    super(d);
+  }
+
+  public Matrix duplicate() {
+    return new DiagonalMatrix(this);
+  }
+
+  public void setElement(int i, int j, double value) {
+    if (i != j) {
+      throw new ArrayIndexOutOfBoundsException("cannot set elements"
+                                               + " out of diagonal in a"
+                                               + " diagonal matrix");
+    }
+    super.setElement(i, j, value);
+  }
+
+  public double getDeterminant(double epsilon) {
+    double determinant = data[0];
+    for (int index = columns + 1; index < columns * columns; index += columns + 1) {
+      determinant *= data[index];
+    }
+    return determinant;
+  }
+
+  public SquareMatrix getInverse(double epsilon)
+    throws SingularMatrixException {
+
+    DiagonalMatrix inv = new DiagonalMatrix (columns);
+
+    for (int index = 0; index < columns * columns; index += columns + 1) {
+      if (Math.abs(data[index]) < epsilon) {
+        throw new SingularMatrixException();
+      }
+      inv.data[index] = 1.0 / data[index];
+    }
+
+    return inv;
+
+  }
+
+  public Matrix solve(Matrix b, double epsilon)
+    throws SingularMatrixException {
+
+    Matrix result = b.duplicate();
+
+    for (int i = 0; i < columns; ++i) {
+      double diag = data[i * (columns + 1)];
+      if (Math.abs(diag) < epsilon) {
+        throw new SingularMatrixException();
+      }
+      double inv = 1.0 / diag;
+
+      NonNullRange range = result.getRangeForRow(i);
+      for (int index = i * b.columns + range.begin;
+           index < i * b.columns + range.end;
+           ++index) {
+        result.data[index] = inv * b.data[index];
+      }
+    }
+
+    return result;
+
+  }
+
+  public NonNullRange getRangeForRow(int i) {
+    return new NonNullRange(i, i + 1);
+  }
+
+  public NonNullRange getRangeForColumn(int j) {
+    return new NonNullRange(j, j + 1);
+  }
+
+  private static final long serialVersionUID = -2965166085913895323L;
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/DiagonalMatrix.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/GeneralMatrix.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/GeneralMatrix.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/GeneralMatrix.java (added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/GeneralMatrix.java Sun Nov 19 13:36:15 2006
@@ -0,0 +1,122 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// 
+//   http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.spaceroots.mantissa.linalg;
+
+import java.io.Serializable;
+
+/** This class represents matrices of the most general type.
+
+ * <p>This class is the basic implementation of matrices to use when
+ * nothing special is known about the structure of the matrix.</p>
+
+ * @version $Id: GeneralMatrix.java 1705 2006-09-17 19:57:39Z luc $
+ * @author L. Maisonobe
+
+ */
+
+public class GeneralMatrix
+  extends Matrix
+  implements Serializable {
+
+  /** Simple constructor.
+   * Build a matrix with null elements.
+   * @param rows number of rows of the matrix
+   * @param columns number of columns of the matrix
+   */
+  public GeneralMatrix(int rows, int columns) {
+    super(rows, columns);
+  }
+
+  /** Simple constructor.
+   * Build a matrix with specified elements.
+   * @param rows number of rows of the matrix
+   * @param columns number of columns of the matrix
+   * @param data table of the matrix elements (stored row after row)
+   */
+  public GeneralMatrix(int rows, int columns, double[] data) {
+    super(rows, columns, data);
+  }
+
+  /** Copy constructor.
+   * @param m matrix to copy
+   */
+  public GeneralMatrix(Matrix m) {
+    super(m);
+  }
+
+  public Matrix duplicate() {
+    return new GeneralMatrix(this);
+  }
+
+  /** Add a matrix to the instance.
+   * This method adds a matrix to the instance. It does modify the instance.
+   * @param m matrix to add
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public void selfAdd(Matrix m) {
+
+    // validity check
+    if ((rows != m.rows) || (columns != m.columns)) {
+      throw new IllegalArgumentException("cannot add a "
+                                         + m.rows + 'x' + m.columns
+                                         + " matrix to a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+
+    // addition loop
+    for (int index = 0; index < rows * columns; ++index) {
+      data[index] += m.data[index];
+    }
+
+  }
+
+  /** Substract a matrix from the instance.
+   * This method substracts a matrix from the instance. It does modify the instance.
+   * @param m matrix to substract
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public void selfSub(Matrix m) {
+
+    // validity check
+    if ((rows != m.rows) || (columns != m.columns)) {
+      throw new IllegalArgumentException("cannot substract a "
+                                         + m.rows + 'x' + m.columns
+                                         + " matrix from a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+
+    // substraction loop
+    for (int index = 0; index < rows * columns; ++index) {
+      data[index] -= m.data[index];
+    }
+
+  }
+
+  protected NonNullRange getRangeForRow(int i) {
+    return new NonNullRange(0, columns);
+  }
+
+  protected NonNullRange getRangeForColumn(int j) {
+    return new NonNullRange(0, rows);
+  }
+
+  private static final long serialVersionUID = 4350328622456299819L;
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/GeneralMatrix.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/GeneralSquareMatrix.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/GeneralSquareMatrix.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/GeneralSquareMatrix.java (added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/GeneralSquareMatrix.java Sun Nov 19 13:36:15 2006
@@ -0,0 +1,282 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// 
+//   http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.spaceroots.mantissa.linalg;
+
+import java.io.Serializable;
+
+/** This class implements general square matrices of linear algebra.
+
+ * @version $Id: GeneralSquareMatrix.java 1705 2006-09-17 19:57:39Z luc $
+ * @author L. Maisonobe
+
+ */
+
+public class GeneralSquareMatrix
+  extends SquareMatrix
+  implements Serializable, Cloneable {
+
+  /** Simple constructor.
+   * This constructor builds a square matrix of specified order, all
+   * elements beeing zeros.
+   * @param order order of the matrix
+   */
+  public GeneralSquareMatrix(int order) {
+    super(order);
+    permutations     = null;
+    evenPermutations = true;
+    lower            = null;
+    upper            = null;
+  }
+
+  /** Simple constructor.
+   * Build a matrix with specified elements.
+   * @param order order of the matrix
+   * @param data table of the matrix elements (stored row after row)
+   */
+  public GeneralSquareMatrix(int order, double[] data) {
+    super(order, data);
+    permutations     = null;
+    evenPermutations = true;
+    lower            = null;
+    upper            = null;
+  }
+
+  /** Copy constructor.
+   * @param s square matrix to copy
+   */
+  public GeneralSquareMatrix(GeneralSquareMatrix s) {
+    super(s);
+
+    if (s.permutations != null) {
+      permutations     = (int[]) s.permutations.clone();
+      evenPermutations = s.evenPermutations;
+      lower            = new LowerTriangularMatrix(s.lower);
+      upper            = new UpperTriangularMatrix(s.upper);
+    } else {
+      permutations     = null;
+      evenPermutations = true;
+      lower            = null;
+      upper            = null;
+    }
+
+  }
+
+  public Matrix duplicate() {
+    return new GeneralSquareMatrix(this);
+  }
+
+  public void setElement(int i, int j, double value) {
+    super.setElement(i, j, value);
+    permutations     = null;
+    evenPermutations = true;
+    lower            = null;
+    upper            = null;
+  }
+
+  /** Add a matrix to the instance.
+   * This method adds a matrix to the instance. It does modify the instance.
+   * @param s square matrix to add
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public void selfAdd(SquareMatrix s) {
+
+    // validity check
+    if ((rows != s.rows) || (columns != s.columns)) {
+      throw new IllegalArgumentException("cannot add a "
+                                         + s.rows + 'x' + s.columns
+                                         + " matrix to a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+
+    // addition loop
+    for (int index = 0; index < rows * columns; ++index) {
+      data[index] += s.data[index];
+    }
+
+  }
+
+  /** Substract a matrix from the instance.
+   * This method substracts a matrix from the instance. It does modify the instance.
+   * @param s square matrix to substract
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public void selfSub(SquareMatrix s) {
+
+    // validity check
+    if ((rows != s.rows) || (columns != s.columns)) {
+      throw new IllegalArgumentException("cannot substract a "
+                                         + s.rows + 'x' + s.columns
+                                         + " matrix from a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+      
+    // substraction loop
+    for (int index = 0; index < rows * columns; ++index) {
+      data[index] -= s.data[index];
+    }
+
+  }
+
+  public double getDeterminant(double epsilon) {
+    try {
+      if (permutations == null)
+        computeLUFactorization(epsilon);
+      double d = upper.getDeterminant(epsilon);
+      return evenPermutations ? d : -d;
+    } catch (SingularMatrixException e) {
+      return 0.0;
+    }
+  }
+
+  public Matrix solve(Matrix b, double epsilon)
+    throws SingularMatrixException {
+    // validity check
+    if (b.getRows() != rows) {
+      throw new IllegalArgumentException("dimension mismatch");
+    }
+
+    if (permutations == null) {
+      computeLUFactorization(epsilon);
+    }
+
+    // apply the permutations to the second member
+    double[] permData = new double[b.data.length];
+    int bCols = b.getColumns();
+    for (int i = 0; i < rows; ++i) {
+      NonNullRange range = b.getRangeForRow(permutations[i]);
+      for (int j = range.begin; j < range.end; ++j) {
+        permData[i * bCols + j] = b.data[permutations[i] * bCols + j];
+      }
+    }
+    Matrix permB = MatrixFactory.buildMatrix(b.getRows(), bCols, permData);
+
+    // solve the permuted system
+    return upper.solve(lower.solve(permB, epsilon), epsilon);
+
+  }
+
+  protected NonNullRange getRangeForRow(int i) {
+    return new NonNullRange(0, columns);
+  }
+
+  protected NonNullRange getRangeForColumn(int j) {
+    return new NonNullRange(0, rows);
+  }
+
+  private void computeLUFactorization(double epsilon)
+    throws SingularMatrixException {
+    // build a working copy of the matrix data
+    double[] work = new double[rows * columns];
+    for (int index = 0; index < work.length; ++index) {
+      work[index] = data[index];
+    }
+
+    // initialize the permutations table to identity
+    permutations = new int[rows];
+    for (int i = 0; i < rows; ++i) {
+      permutations[i] = i;
+    }
+    evenPermutations = true;
+
+    for (int k = 0; k < rows; ++k) {
+
+      // find the maximal element in the column
+      double maxElt = Math.abs(work[permutations[k] * columns + k]);
+      int    jMax   = k;
+      for (int i = k + 1; i < rows; ++i) {
+        double curElt = Math.abs(work[permutations[i] * columns + k]);
+        if (curElt > maxElt) {
+          maxElt = curElt;
+          jMax   = i;
+        }
+      }
+
+      if (maxElt < epsilon) {
+        throw new SingularMatrixException();
+      }
+
+      if (k != jMax) {
+        // do the permutation to have a large enough diagonal element
+        int tmp            = permutations[k];
+        permutations[k]    = permutations[jMax];
+        permutations[jMax] = tmp;
+        evenPermutations   = ! evenPermutations;
+      }
+
+      double inv = 1.0 / work[permutations[k] * columns + k];
+
+      // compute the contribution of the row to the triangular matrices
+      for (int i = k + 1; i < rows; ++i) {
+        double factor = inv * work[permutations[i] * columns + k];
+
+        // lower triangular matrix
+        work[permutations[i] * columns + k] = factor;
+
+        // upper triangular matrix
+        int index1 = permutations[i] * columns + k;
+        int index2 = permutations[k] * columns + k;
+        for (int j = k + 1; j < columns; ++j) {
+          work[++index1] -= factor * work[++index2];
+        }
+      }
+    }
+
+    // build the matrices
+    double[] lowerData = new double[rows * columns];
+    double[] upperData = new double[rows * columns];
+
+    int index = 0;
+    for (int i = 0; i < rows; ++i) {
+      int workIndex = permutations[i] * columns;
+      int j         = 0;
+
+      // lower part
+      while (j++ < i) {
+        lowerData[index]   = work[workIndex++];
+        upperData[index++] = 0.0;
+      }
+
+      // diagonal
+      lowerData[index]   = 1.0;
+      upperData[index++] = work[workIndex++];
+
+      // upper part
+      while (j++ < columns) {
+        lowerData[index]   = 0.0;
+        upperData[index++] = work[workIndex++];
+      }
+    }
+
+    // release the memory as soon as possible
+    work = null;
+
+    lower = new LowerTriangularMatrix(rows, lowerData);
+    upper = new UpperTriangularMatrix(rows, upperData);
+
+  }
+
+  private int[]                 permutations;
+  private boolean               evenPermutations;
+  private LowerTriangularMatrix lower;
+  private UpperTriangularMatrix upper;
+
+  private static final long serialVersionUID = -506293526695298279L;
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/GeneralSquareMatrix.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/LowerTriangularMatrix.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/LowerTriangularMatrix.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/LowerTriangularMatrix.java (added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/LowerTriangularMatrix.java Sun Nov 19 13:36:15 2006
@@ -0,0 +1,219 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// 
+//   http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.spaceroots.mantissa.linalg;
+
+import java.io.Serializable;
+
+/** This class implements lower triangular matrices of linear algebra.
+
+ * @version $Id: LowerTriangularMatrix.java 1705 2006-09-17 19:57:39Z luc $
+ * @author L. Maisonobe
+
+ */
+
+public class LowerTriangularMatrix
+  extends SquareMatrix
+  implements Serializable, Cloneable {
+
+  /** Simple constructor.
+   * This constructor builds a lower triangular matrix of specified order, all
+   * elements being zeros.
+   * @param order order of the matrix
+   */
+  public LowerTriangularMatrix(int order) {
+    super(order);
+  }
+
+  /** Simple constructor.
+   * Build a matrix with specified elements.
+   * @param order order of the matrix
+   * @param data table of the matrix elements (stored row after row)
+   */
+  public LowerTriangularMatrix(int order, double[] data) {
+    super(order, data);
+  }
+
+  /** Copy constructor.
+   * @param l lower triangular matrix to copy
+   */
+  public LowerTriangularMatrix(LowerTriangularMatrix l) {
+    super(l);
+  }
+
+  public Matrix duplicate() {
+    return new LowerTriangularMatrix(this);
+  }
+
+  public void setElement(int i, int j, double value) {
+    if (i < j) {
+      throw new ArrayIndexOutOfBoundsException("cannot set elements"
+                                               + " above diagonal of a"
+                                               + " lower triangular matrix");
+    }
+    super.setElement(i, j, value);
+  }
+
+  /** Add a matrix to the instance.
+   * This method adds a matrix to the instance. It does modify the instance.
+   * @param l lower triangular matrix to add
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public void selfAdd(LowerTriangularMatrix l) {
+
+    // validity check
+    if ((rows != l.rows) || (columns != l.columns)) {
+      throw new IllegalArgumentException("cannot add a "
+                                         + l.rows + 'x' + l.columns
+                                         + " matrix to a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+
+    // addition loop
+    for (int i = 0; i < rows; ++i) {
+      for (int index = i * columns; index < i * (columns + 1) + 1; ++index) {
+        data[index] += l.data[index];
+      }
+    }
+
+  }
+
+  /** Substract a matrix from the instance.
+   * This method substract a matrix from the instance. It does modify the instance.
+   * @param l lower triangular matrix to substract
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public void selfSub(LowerTriangularMatrix l) {
+
+    // validity check
+    if ((rows != l.rows) || (columns != l.columns)) {
+      throw new IllegalArgumentException("cannot substract a "
+                                         + l.rows + 'x' + l.columns
+                                         + " matrix from a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+
+    // substraction loop
+    for (int i = 0; i < rows; ++i) {
+      for (int index = i * columns; index < i * (columns + 1) + 1; ++index) {
+        data[index] -= l.data[index];
+      }
+    }
+
+  }
+
+  public double getDeterminant(double epsilon) {
+    double determinant = data[0];
+    for (int index = columns + 1; index < columns * columns; index += columns + 1) {
+      determinant *= data[index];
+    }
+    return determinant;
+  }
+
+  public Matrix solve(Matrix b, double epsilon)
+    throws SingularMatrixException {
+    // validity check
+    if (b.getRows () != rows) {
+      throw new IllegalArgumentException("dimension mismatch");
+    }
+
+    // prepare the data storage
+    int bRows  = b.getRows();
+    int bCols  = b.getColumns();
+
+    double[] resultData = new double[bRows * bCols];
+    int resultIndex     = 0;
+    int lowerElements   = 0;
+    int upperElements   = 0;
+    int minJ            = columns;
+    int maxJ            = 0;
+
+    // solve the linear system
+    for (int i = 0; i < rows; ++i) {
+      double diag = data[i * (columns + 1)];
+      if (Math.abs(diag) < epsilon) {
+        throw new SingularMatrixException();
+      }
+      double inv = 1.0 / diag;
+
+      NonNullRange range = b.getRangeForRow(i);
+      minJ = Math.min(minJ, range.begin);
+      maxJ = Math.max(maxJ, range.end);
+
+      int j = 0;
+      while (j < minJ) {
+        resultData[resultIndex] = 0.0;
+        ++resultIndex;
+        ++j;
+      }
+
+      // compute the possibly non null elements
+      int bIndex = i * bCols + minJ;
+      while (j < maxJ) {
+
+        // compute the current element
+        int index1 = i * columns;
+        int index2 = j;
+        double value = b.data[bIndex];
+        while (index1 < i * (columns + 1)) {
+          value -= data[index1] * resultData[index2];
+          ++index1;
+          index2 += bCols;
+        }
+        value *= inv;
+        resultData[resultIndex] = value;
+
+        // count the affected upper and lower elements
+        // (in order to deduce the shape of the resulting matrix)
+        if (j < i) {
+          ++lowerElements;
+        } else if (i < j) {
+          ++upperElements;
+        }
+
+        ++bIndex;
+        ++resultIndex;
+        ++j;
+
+      }
+
+      while (j < bCols) {
+        resultData[resultIndex] = 0.0;
+        ++resultIndex;
+        ++j;
+      }
+
+    }
+
+    return MatrixFactory.buildMatrix(bRows, bCols, resultData,
+                                     lowerElements, upperElements);
+
+  }
+
+  public NonNullRange getRangeForRow(int i) {
+    return new NonNullRange(0, i + 1);
+  }
+
+  public NonNullRange getRangeForColumn(int j) {
+    return new NonNullRange(j, rows);
+  }
+
+  private static final long serialVersionUID = 3592505328858227281L;
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/LowerTriangularMatrix.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/Matrix.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/Matrix.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/Matrix.java (added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/Matrix.java Sun Nov 19 13:36:15 2006
@@ -0,0 +1,484 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// 
+//   http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.spaceroots.mantissa.linalg;
+
+import java.io.Serializable;
+
+/** This class factor all services common to matrices.
+
+ * <p>This class is the base class of all matrix implementations, it
+ * is also the base class of the {@link SquareMatrix} class which adds
+ * methods specific to square matrices.</p>
+
+ * <p>This class both handles the storage of matrix elements and
+ * implements the classical operations on matrices (addition,
+ * substraction, multiplication, transposition). It relies on two
+ * protected methods ({@link #getRangeForRow} and {@link
+ * #getRangeForColumn}) to get tight loop bounds for matrices with
+ * known structures full of zeros. These methods should be
+ * implemented by derived classes to provide information about their
+ * specific shape to the general algorithms implemented by this
+ * abstract class.</p>
+
+ * @version $Id: Matrix.java 1705 2006-09-17 19:57:39Z luc $
+ * @author L. Maisonobe
+
+ */
+
+public abstract class Matrix
+  implements Serializable {
+  /** Simple constructor.
+   * Build a matrix with null elements.
+   * @param rows number of rows of the matrix
+   * @param columns number of columns of the matrix
+   */
+  protected Matrix(int rows, int columns) {
+    // sanity check
+    if (rows <= 0 || columns <= 0) {
+      throw new IllegalArgumentException("cannot build a matrix"
+                                         + " with negative or null dimension");
+    }
+
+    this.rows    = rows;
+    this.columns = columns;
+    data = new double[rows * columns];
+    for (int i = 0; i < data.length; ++i) {
+      data[i] = 0.0;
+    }
+
+  }
+
+  /** Simple constructor.
+   * Build a matrix with specified elements.
+   * @param rows number of rows of the matrix
+   * @param columns number of columns of the matrix
+   * @param data table of the matrix elements (stored row after row)
+   */
+  public Matrix(int rows, int columns, double[] data) {
+    // sanity check
+    if (rows <= 0 || columns <= 0) {
+      throw new IllegalArgumentException("cannot build a matrix"
+                                         + " with negative or null dimension");
+    }
+
+    this.rows    = rows;
+    this.columns = columns;
+    this.data    = data;
+
+  }
+
+  /** Copy constructor.
+   * @param m matrix to copy
+   */
+  protected Matrix(Matrix m) {
+    rows    = m.rows;
+    columns = m.columns;
+    data    = new double[rows * columns];
+    System.arraycopy(m.data, 0, data, 0, m.data.length);
+  }
+
+  /** Polymorphic copy operator.
+   * This method build a new object of the same type of the
+   * instance. It is somewhat similar to the {@link Object#clone}
+   * method, except that it has public access, it doesn't throw any
+   * specific exception and it returns a Matrix.
+   *@see Object#clone
+   */
+  public abstract Matrix duplicate();
+
+  /** Get the number of rows of the matrix.
+   * @return number of rows
+   * @see #getColumns
+   */
+  public int getRows() {
+    return rows;
+  }
+
+  /** Get the number of columns of the matrix.
+   * @return number of columns
+   * @see #getRows
+   */
+  public int getColumns() {
+    return columns;
+  }
+
+  /** Get a matrix element.
+   * @param i row index, from 0 to rows - 1
+   * @param j column index, from 0 to cols - 1
+   * @return value of the element
+   * @exception ArrayIndexOutOfBoundsException if the indices are wrong
+   * @see #setElement
+   */
+  public double getElement(int i, int j) {
+    if (i < 0 || i >= rows || j < 0 || j >= columns) {
+      throw new IllegalArgumentException("cannot get element ("
+                                         + i + ", " + j + ") from a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+    return data[i * columns + j];
+  }
+
+  /** Set a matrix element.
+   * @param i row index, from 0 to rows - 1
+   * @param j column index, from 0 to cols - 1
+   * @param value value of the element
+   * @exception ArrayIndexOutOfBoundsException if the indices are wrong
+   * @see #getElement
+   */
+  public void setElement(int i, int j, double value) {
+    if (i < 0 || i >= rows || j < 0 || j >= columns) {
+      throw new IllegalArgumentException("cannot set element ("
+                                         + i + ", " + j + ") in a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+    data[i * columns + j] = value;
+  }
+
+  /** Add a matrix to the instance.
+   * This method adds a matrix to the instance. It returns a new
+   * matrix and does not modify the instance.
+   * @param m matrix to add
+   * @return a new matrix containing the result
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public Matrix add(Matrix m) {
+
+    // validity check
+    if ((rows != m.rows) || (columns != m.columns)) {
+      throw new IllegalArgumentException("cannot add a "
+                                         + m.rows + 'x' + m.columns
+                                         + " matrix to a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+
+    double[] resultData    = new double[rows * columns];
+    int      resultIndex   = 0;
+    int      lowerElements = 0;
+    int      upperElements = 0;
+
+    // external loop through the rows
+    for (int i = 0; i < rows; ++i) {
+      // compute the indices of the internal loop
+      NonNullRange r = NonNullRange.reunion(getRangeForRow(i),
+                                            m.getRangeForRow(i));
+
+      // assign the zeros before the non null range
+      int j = 0;
+      while (j < r.begin) {
+        resultData[resultIndex] = 0.0;
+        ++resultIndex;
+        ++j;
+      }
+
+      // compute the possibly non null elements
+      while (j < r.end) {
+
+        // compute the current element
+        resultData[resultIndex] = data[resultIndex] + m.data[resultIndex];
+
+        // count the affected upper and lower elements
+        // (in order to deduce the shape of the resulting matrix)
+        if (j < i) {
+          ++lowerElements;
+        } else if (i < j) {
+          ++upperElements;
+        }
+
+        ++resultIndex;
+        ++j;
+
+      }
+
+      // assign the zeros after the non null range
+      while (j < columns) {
+        resultData[resultIndex++] = 0.0;
+        ++resultIndex;
+        ++j;
+      }
+    }
+
+    return MatrixFactory.buildMatrix(rows, columns, resultData,
+                                     lowerElements, upperElements);
+
+  }
+
+  /** Substract a matrix from the instance.
+   * This method substracts a matrix from the instance. It returns a new
+   * matrix and does not modify the instance.
+   * @param m matrix to substract
+   * @return a new matrix containing the result
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public Matrix sub(Matrix m) {
+
+    // validity check
+    if ((rows != m.rows) || (columns != m.columns)) {
+      throw new IllegalArgumentException("cannot substract a "
+                                         + m.rows + 'x' + m.columns
+                                         + " matrix from a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+
+    double[] resultData    = new double[rows * columns];
+    int      resultIndex   = 0;
+    int      lowerElements = 0;
+    int      upperElements = 0;
+
+    // external loop through the rows
+    for (int i = 0; i < rows; ++i) {
+      // compute the indices of the internal loop
+      NonNullRange r = NonNullRange.reunion(getRangeForRow(i),
+                                            m.getRangeForRow(i));
+
+      // assign the zeros before the non null range
+      int j = 0;
+      while (j < r.begin) {
+        resultData[resultIndex] = 0.0;
+        ++resultIndex;
+        ++j;
+      }
+
+      // compute the possibly non null elements
+      while (j < r.end) {
+
+        // compute the current element
+        resultData[resultIndex] = data[resultIndex] - m.data[resultIndex];
+
+        // count the affected upper and lower elements
+        // (in order to deduce the shape of the resulting matrix)
+        if (j < i) {
+          ++lowerElements;
+        } else if (i < j) {
+          ++upperElements;
+        }
+
+        ++resultIndex;
+        ++j;
+
+      }
+
+      // assign the zeros after the non null range
+      while (j < columns) {
+        resultData[resultIndex++] = 0.0;
+        ++resultIndex;
+        ++j;
+      }
+    }
+
+    return MatrixFactory.buildMatrix(rows, columns, resultData,
+                                     lowerElements, upperElements);
+
+  }
+
+  /** Multiply the instance by a matrix.
+   * This method multiplies the instance by a matrix. It returns a new
+   * matrix and does not modify the instance.
+   * @param m matrix by which to multiply
+   * @return a new matrix containing the result
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public Matrix mul(Matrix m) {
+
+    // validity check
+    if (columns != m.rows) {
+      throw new IllegalArgumentException("cannot multiply a "
+                                         + rows + 'x' + columns
+                                         + " matrix by a "
+                                         + m.rows + 'x' + m.columns
+                                         + " matrix");
+    }
+
+    double[] resultData = new double[rows * m.columns];
+    int resultIndex     = 0;
+    int lowerElements   = 0;
+    int upperElements   = 0;
+
+    for (int i = 0; i < rows; ++i) {
+      for (int j = 0; j < m.columns; ++j) {
+        double value = 0.0;
+
+        // compute the tighter possible indices of the internal loop
+        NonNullRange r = NonNullRange.intersection(getRangeForRow(i),
+                                                   m.getRangeForColumn(j));
+
+        if (r.begin < r.end) {
+          int k    = r.begin;
+          int idx  = i * columns + k;
+          int midx = k * m.columns + j;
+          while (k++ < r.end) {
+            value += data[idx++] * m.data[midx];
+            midx  += m.columns;
+          }
+
+          // count the affected upper and lower elements
+          // (in order to deduce the shape of the resulting matrix)
+          if (j < i) {
+            ++lowerElements;
+          } else if (i < j) {
+            ++upperElements;
+          }
+
+        }
+
+        // store the element value
+        resultData[resultIndex++] = value;
+
+      }
+    }
+
+    return MatrixFactory.buildMatrix(rows, m.columns, resultData,
+                                     lowerElements, upperElements);
+
+  }
+
+  /** Multiply the instance by a scalar.
+   * This method multiplies the instance by a scalar. It returns a new
+   * matrix and does not modify the instance.
+   * @param a scalar by which to multiply
+   * @return a new matrix containing the result
+   * @see #selfMul(double)
+   */
+  public Matrix mul(double a) {
+    Matrix copy = duplicate();
+    copy.selfMul(a);
+    return copy;
+  }
+
+  /** Multiply the instance by a scalar.
+   * This method multiplies the instance by a scalar.
+   * It does modify the instance.
+   * @param a scalar by which to multiply
+   * @see #mul(double)
+   */
+  public void selfMul(double a) {
+    for (int i = 0; i < rows; ++i) {
+      NonNullRange r = getRangeForRow(i);
+      for (int j = r.begin, index = i * columns + r.begin; j < r.end; ++j) {
+        data[index++] *= a;
+      }
+    }
+
+  }
+
+  /** Compute the transpose of the instance.
+   * This method transposes the instance. It returns a new
+   * matrix and does not modify the instance.
+   * @return a new matrix containing the result
+   */
+  public Matrix getTranspose() {
+
+    double[] resultData    = new double[columns * rows];
+    int      resultIndex   = 0;
+    int      upperElements = 0;
+    int      lowerElements = 0;
+
+    for (int i = 0; i < columns; ++i) {
+      // compute the indices of the internal loop
+      NonNullRange range = getRangeForColumn(i);
+
+      int j     = 0;
+      int index = i;
+
+      // assign the zeros before the non null range
+      while (j < range.begin) {
+        resultData[resultIndex++] = 0.0;
+        index += columns;
+        ++j;
+      }
+
+      // compute the possibly non null elements
+      while (j < range.end) {
+        resultData[resultIndex] = data[index];
+
+        // count the affected upper and lower elements
+        // (in order to deduce the shape of the resulting matrix)
+        if (j < i) {
+          ++lowerElements;
+        } else if (i < j) {
+          ++upperElements;
+        }
+
+        index += columns;
+        ++resultIndex;
+        ++j;
+
+      }
+
+      // assign the zeros after the non null range
+      while (j < rows) {
+        resultData[resultIndex] = 0.0;
+        ++resultIndex;
+        ++j;
+      }
+
+    }
+
+    return MatrixFactory.buildMatrix(columns, rows, resultData,
+                                     lowerElements, upperElements);
+
+  }
+
+  /** Set a range to the non null part covered by a row.
+   * @param i index of the row
+   * @return range of non nul elements in the specified row
+   * @see #getRangeForColumn
+   */
+  protected abstract NonNullRange getRangeForRow(int i);
+
+  /** Set a range to the non null part covered by a column.
+   * @param j index of the column
+   * @return range of non nul elements in the specified column
+   * @see #getRangeForRow
+   */
+  protected abstract NonNullRange getRangeForColumn(int j);
+
+  public String toString() {
+    String separator = System.getProperty("line.separator");
+
+    StringBuffer buf = new StringBuffer();
+    for (int index = 0; index < rows * columns; ++index) {
+      if (index > 0) {
+        if (index % columns == 0) {
+          buf.append(separator);
+        } else {
+          buf.append(' ');
+        }
+      }
+      buf.append(Double.toString(data[index]));
+    }
+
+    return buf.toString();
+
+  }
+
+  /** number of rows of the matrix. */
+  protected final int rows;
+
+  /** number of columns of the matrix. */
+  protected final int columns;
+
+  /** array of the matrix elements.
+   * the elements are stored in a one dimensional array, row after row
+   */
+  protected final double[] data;
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/Matrix.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/MatrixFactory.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/MatrixFactory.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/MatrixFactory.java (added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/MatrixFactory.java Sun Nov 19 13:36:15 2006
@@ -0,0 +1,86 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// 
+//   http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.spaceroots.mantissa.linalg;
+
+/** This class is a factory for the linear algebra package.
+
+ * <p>This class is devoted to building the right type of matrix
+ * according to the structure of the non null elements.</p>
+
+ * <p>This is a utility class, no instance of this class should be
+ * built, so the constructor is explicitly made private.</p>
+
+ * @version $Id: MatrixFactory.java 1705 2006-09-17 19:57:39Z luc $
+ * @author L. Maisonobe
+
+ */
+
+public class MatrixFactory {
+  /** Simple constructor.
+   * Since the class is a utility class with only static methods, the
+   * constructor is made private to prevent creating instances of this
+   * class.
+   */
+  private MatrixFactory() {
+  }
+
+  /** Build a matrix of the right subtype.
+   * Build the right subtype of matrix according to the structure of
+   * the non null elements of the instance. Note that the information
+   * provided does not allow to build instances of the {@link
+   * SymetricalMatrix} class. When the data corresponding to a
+   * symetrical matrix is given, this method can only build an
+   * instance of the {@link GeneralSquareMatrix} class.
+   * @param rows number of row of the matrix
+   * @param columns number of columns of the matrix
+   * @param data table of the matrix elements (stored row after row)
+   * @param lowerElements number of non null elements in the lower triangle
+   * @param upperElements number of non null elements in the upper triangle
+   * @return a matrix containing the instance
+   */
+  public static Matrix buildMatrix(int rows, int columns, double[] data,
+                                   int lowerElements, int upperElements) {
+    if (rows == columns) {
+      if (lowerElements == 0 && upperElements == 0) {
+        return new DiagonalMatrix(rows, data);
+      } else if (lowerElements == 0) {
+        return new UpperTriangularMatrix(rows, data);
+      } else if (upperElements == 0) {
+        return new LowerTriangularMatrix(rows, data);
+      } else {
+        return new GeneralSquareMatrix(rows, data);
+      }
+    }
+    return new GeneralMatrix(rows, columns, data);
+  }
+
+  /** Build a matrix of the right subtype.
+   * Build the right subtype of matrix according to the dimensions.
+   * @param rows number of row of the matrix
+   * @param columns number of columns of the matrix
+   * @param data table of the matrix elements (stored row after row)
+   * @return a matrix containing the instance
+   */
+  public static Matrix buildMatrix(int rows, int columns, double[] data) {
+    if (rows == columns) {
+      return new GeneralSquareMatrix(rows, data);
+    }
+    return new GeneralMatrix(rows, columns, data);
+  }
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/MatrixFactory.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/NonNullRange.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/NonNullRange.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/NonNullRange.java (added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/NonNullRange.java Sun Nov 19 13:36:15 2006
@@ -0,0 +1,103 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// 
+//   http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.spaceroots.mantissa.linalg;
+
+import java.io.Serializable;
+
+/** This class represents range of non null elements for rows or
+ * columns of matrices.
+
+ * <p>This class is used to reduce the computation loops by avoiding
+ * using elements that are known to be zeros. For full matrices, the
+ * range simply spans from 0 to the order of the matrix. For lower and
+ * upper triangular matrices, its width will depend on the index of
+ * the row or column considered. For diagonal matrices, the range is
+ * reduced to one index.</p>
+
+ * <p>The indices provided by the class correspond to the elements
+ * that are non-null only according to the <emph>structure</emph> of
+ * the matrix. The real value of the element is not
+ * considered. Consider for example the following lower triangular
+ * matrix :</p>
+
+ * <pre>
+ *   1 0 0 0
+ *   2 8 0 0
+ *   0 5 3 0
+ *   3 2 4 4
+ * </pre>
+
+ * <p>The third rows begins with zero, but this is not a consequence
+ * of the lower triangular structure, it is only a
+ * coincidence. Therefore, the range (in row/columns count)
+ * corresponding to third row will span from 0 to 2, not from 1 to 2.</p>
+
+ * @version $Id: NonNullRange.java 1705 2006-09-17 19:57:39Z luc $
+ * @author L. Maisonobe
+
+ */
+class NonNullRange
+  implements Serializable, Cloneable {
+
+  /** Index in row/column count of the first non-null element. */
+  public final int begin;
+
+  /** Index in row/column count after the last non-null element. */
+  public final int end;
+
+  /** Simple constructor.
+   * @param begin index in row/column count of the first non-null element
+   * @param end index in row/column count after the last non-null element
+   */
+  public NonNullRange(int begin, int end)
+  {
+    this.begin = begin;
+    this.end   = end;
+  }
+
+  /** Copy constructor.
+   * @param range range to copy.
+   */
+  public NonNullRange(NonNullRange range) {
+    begin = range.begin;
+    end   = range.end;
+  }
+
+  /** Build the intersection of two ranges.
+   * @param first first range to consider
+   * @param second second range to consider
+   */
+  public static NonNullRange intersection(NonNullRange first,
+                                          NonNullRange second) {
+    return new NonNullRange(Math.max(first.begin, second.begin),
+                            Math.min(first.end, second.end));
+  }
+
+  /** Build the reunion of two ranges.
+   * @param first first range to consider
+   * @param second second range to consider
+   */
+  public static NonNullRange reunion(NonNullRange first,
+                                     NonNullRange second) {
+    return new NonNullRange(Math.min(first.begin, second.begin),
+                            Math.max(first.end, second.end));
+  }
+
+  private static final long serialVersionUID = 8175301560126132666L;
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/NonNullRange.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SingularMatrixException.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SingularMatrixException.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SingularMatrixException.java (added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SingularMatrixException.java Sun Nov 19 13:36:15 2006
@@ -0,0 +1,41 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// 
+//   http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.spaceroots.mantissa.linalg;
+
+import org.spaceroots.mantissa.MantissaException;
+
+/** This class represent exceptions thrown by some matrix operations.
+
+ * @version $Id: SingularMatrixException.java 1705 2006-09-17 19:57:39Z luc $
+ * @author L. Maisonobe
+
+ */
+
+public class SingularMatrixException
+  extends MantissaException {
+
+  /** Simple constructor.
+   * Build an exception with a default message
+   */
+  public SingularMatrixException() {
+    super("singular matrix");
+  }
+
+  private static final long serialVersionUID = 7531357987468317564L;
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SingularMatrixException.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SquareMatrix.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SquareMatrix.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SquareMatrix.java (added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SquareMatrix.java Sun Nov 19 13:36:15 2006
@@ -0,0 +1,102 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// 
+//   http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.spaceroots.mantissa.linalg;
+
+import java.io.Serializable;
+
+/** This class factor all services common to square matrices of linear algebra.
+
+ * <p>This class is the base class of all square matrix
+ * implementations. It extends the {@link Matrix} class with methods
+ * specific to square matrices.</p>
+
+ * @version $Id: SquareMatrix.java 1705 2006-09-17 19:57:39Z luc $
+ * @author L. Maisonobe
+
+ */
+
+public abstract class SquareMatrix
+  extends Matrix
+  implements Serializable, Cloneable {
+  /** Simple constructor.
+   * Build a matrix with null elements.
+   * @param order order of the matrix
+   */
+  protected SquareMatrix(int order) {
+    super(order, order);
+  }
+
+  /** Simple constructor.
+   * Build a matrix with specified elements.
+   * @param order order of the matrix
+   * @param data table of the matrix elements (stored row after row)
+   */
+  protected SquareMatrix(int order, double[] data) {
+    super(order, order, data);
+  }
+
+  /** Copy constructor.
+   * @param m matrix to copy
+   */
+  protected SquareMatrix(SquareMatrix m) {
+    super(m);
+  }
+
+  /** Get the determinant of the matrix.
+   * @param epsilon threshold on matrix elements below which the
+   * matrix is considered singular (this is used by the derived
+   * classes that use a factorization to compute the determinant)
+   * @return the determinant of the matrix
+   */
+  public abstract double getDeterminant(double epsilon);
+
+  /** Invert the instance.
+   * @param epsilon threshold on matrix elements below which the
+   * matrix is considered singular
+   * @return the inverse matrix of the instance
+   * @exception SingularMatrixException if the matrix is singular
+   */
+  public SquareMatrix getInverse(double epsilon)
+    throws SingularMatrixException {
+    return solve(new DiagonalMatrix (columns), epsilon);
+  }
+
+
+  /** Solve the <tt>A.X = B</tt> equation.
+   * @param b second term of the equation
+   * @param epsilon threshold on matrix elements below which the
+   * matrix is considered singular
+   * @return a matrix X such that <tt>A.X = B</tt>, where A is the instance
+   * @exception SingularMatrixException if the matrix is singular
+   */
+  public abstract Matrix solve(Matrix b, double epsilon)
+    throws SingularMatrixException;
+
+  /** Solve the <tt>A.X = B</tt> equation.
+   * @param b second term of the equation
+   * @param epsilon threshold on matrix elements below which the
+   * matrix is considered singular
+   * @return a matrix X such that <tt>A.X = B</tt>, where A is the instance
+   * @exception SingularMatrixException if the matrix is singular
+   */
+  public SquareMatrix solve(SquareMatrix b, double epsilon)
+    throws SingularMatrixException {
+    return (SquareMatrix) solve((Matrix) b, epsilon);
+  }
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SquareMatrix.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SymetricalMatrix.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SymetricalMatrix.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SymetricalMatrix.java (added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SymetricalMatrix.java Sun Nov 19 13:36:15 2006
@@ -0,0 +1,226 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// 
+//   http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.spaceroots.mantissa.linalg;
+
+import java.io.Serializable;
+
+/** This class implements symetrical matrices of linear algebra.
+
+ * @version $Id: SymetricalMatrix.java 1705 2006-09-17 19:57:39Z luc $
+ * @author L. Maisonobe
+
+ */
+
+public class SymetricalMatrix
+  extends GeneralSquareMatrix
+  implements Serializable, Cloneable {
+
+  /** Simple constructor.
+   * This constructor builds a symetrical matrix of specified order, all
+   * elements beeing zeros.
+   * @param order order of the matrix
+   */
+  public SymetricalMatrix(int order) {
+    super(order);
+  }
+
+  /** Simple constructor.
+   * Build a matrix with specified elements.
+   * @param order order of the matrix
+   * @param data table of the matrix elements (stored row after row)
+   */
+  public SymetricalMatrix(int order, double[] data) {
+    super(order, data);
+  }
+
+  /** Copy constructor.
+   * @param s square matrix to copy
+   */
+  public SymetricalMatrix(SymetricalMatrix s) {
+    super(s);
+  }
+
+  /** Build the symetrical matrix resulting from the product w.A.At.
+   * @param w multiplicative factor (weight)
+   * @param a base vector used to compute the symetrical contribution
+   */
+  public SymetricalMatrix(double w, double[] a) {
+    super(a.length, new double[a.length * a.length]);
+
+    for (int i = 0; i < a.length; ++i) {
+      int indexU = i * (columns + 1);
+      int indexL = indexU;
+
+      double factor = w * a[i];
+      data[indexU] = factor * a[i];
+
+      for (int j = i + 1; j < columns; ++j) {
+        ++indexU;
+        indexL += columns;
+        data[indexU] = factor * a[j];
+        data[indexL] = data[indexU];
+      }
+    }
+
+  }
+
+  public Matrix duplicate() {
+    return new SymetricalMatrix(this);
+  }
+
+  /** Set a matrix element.
+   * On symetrical matrices, setting separately elements outside of
+   * the diagonal is forbidden, so this method throws an
+   * ArrayIndexOutOfBoundsException in this case. The {@link
+   * #setElementAndSymetricalElement} can be used to set both elements
+   * simultaneously.
+   * @param i row index, from 0 to rows - 1
+   * @param j column index, from 0 to cols - 1
+   * @param value value of the element
+   * @exception ArrayIndexOutOfBoundsException if the indices are wrong
+   * @see #setElementAndSymetricalElement
+   * @see Matrix#getElement
+   */
+  public void setElement(int i, int j, double value) {
+    if (i != j) {
+      throw new ArrayIndexOutOfBoundsException("cannot separately set"
+                                               + " elements out of diagonal"
+                                               + " in a symetrical matrix");
+    }
+    super.setElement(i, j, value);
+  }
+
+  /** Set both a matrix element and its symetrical element.
+   * @param i row index of first element (column index of second
+   * element), from 0 to order - 1
+   * @param j column index of first element (row index of second
+   * element), from 0 to order - 1
+   * @param value value of the elements
+   * @exception ArrayIndexOutOfBoundsException if the indices are wrong
+   * @see #setElement
+   * @see Matrix#getElement
+   */
+  public void setElementAndSymetricalElement(int i, int j, double value) {
+    super.setElement(i, j, value);
+    if (i != j) {
+      super.setElement(j, i, value);
+    }
+  }
+
+  /** Add a matrix to the instance.
+   * This method adds a matrix to the instance. It does modify the instance.
+   * @param s symetrical matrix to add
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public void selfAdd(SymetricalMatrix s) {
+
+    // validity check
+    if ((rows != s.rows) || (columns != s.columns)) {
+      throw new IllegalArgumentException("cannot add a "
+                                         + s.rows + 'x' + s.columns
+                                         + " matrix to a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+
+    // addition loop
+    for (int i = 0; i < rows; ++i) {
+      int indexU = i * (columns + 1);
+      int indexL = indexU;
+
+      data[indexU] += s.data[indexU];
+
+      for (int j = i + 1; j < columns; ++j) {
+        ++indexU;
+        indexL += columns;
+        data[indexU] += s.data[indexU];
+        data[indexL]  = data[indexU];
+      }
+    }
+
+  }
+
+  /** Substract a matrix from the instance.
+   * This method substracts a matrix from the instance. It does modify the instance.
+   * @param s symetrical matrix to substract
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public void selfSub(SymetricalMatrix s) {
+
+    // validity check
+    if ((rows != s.rows) || (columns != s.columns)) {
+      throw new IllegalArgumentException("cannot substract a "
+                                         + s.rows + 'x' + s.columns
+                                         + " matrix from a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+
+    // substraction loop
+    for (int i = 0; i < rows; ++i) {
+      int indexU = i * (columns + 1);
+      int indexL = indexU;
+
+      data[indexU] -= s.data[indexU];
+
+      for (int j = i + 1; j < columns; ++j) {
+        ++indexU;
+        indexL += columns;
+        data[indexU] -= s.data[indexU];
+        data[indexL] = data[indexU];
+      }
+    }
+
+  }
+
+  /** Add the symetrical matrix resulting from the product w.A.At to the instance.
+   * This method can be used to build progressively the matrices of
+   * least square problems. The instance is modified.
+   * @param w multiplicative factor (weight)
+   * @param a base vector used to compute the symetrical contribution
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public void selfAddWAAt(double w, double[] a) {
+    if (rows != a.length) {
+      throw new IllegalArgumentException("cannot add a "
+                                         + a.length + 'x' + a.length
+                                         + " matrix to a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+
+    for (int i = 0; i < rows; ++i) {
+      int indexU = i * (columns + 1);
+      int indexL = indexU;
+
+      double factor   = w * a[i];
+      data[indexU] += factor * a[i];
+
+      for (int j = i + 1; j < columns; ++j) {
+        ++indexU;
+        indexL += columns;
+        data[indexU] += factor * a[j];
+        data[indexL]  = data[indexU];
+      }
+    }
+
+  }
+
+  private static final long serialVersionUID = -2083829252075519221L;
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/SymetricalMatrix.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/UpperTriangularMatrix.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/UpperTriangularMatrix.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/UpperTriangularMatrix.java (added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/UpperTriangularMatrix.java Sun Nov 19 13:36:15 2006
@@ -0,0 +1,219 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// 
+//   http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.spaceroots.mantissa.linalg;
+
+import java.io.Serializable;
+
+/** This class implements upper triangular matrices of linear algebra.
+
+ * @version $Id: UpperTriangularMatrix.java 1705 2006-09-17 19:57:39Z luc $
+ * @author L. Maisonobe
+
+ */
+
+public class UpperTriangularMatrix
+  extends SquareMatrix
+  implements Serializable, Cloneable {
+
+  /** Simple constructor.
+   * This constructor builds a upper triangular matrix of specified order, all
+   * elements being zeros.
+   * @param order order of the matrix
+   */
+  public UpperTriangularMatrix(int order) {
+    super(order);
+  }
+
+  /** Simple constructor.
+   * Build a matrix with specified elements.
+   * @param order order of the matrix
+   * @param data table of the matrix elements (stored row after row)
+   */
+  public UpperTriangularMatrix(int order, double[] data) {
+    super(order, data);
+  }
+
+  /** Copy constructor.
+   * @param u upper triangular matrix to copy
+   */
+  public UpperTriangularMatrix(UpperTriangularMatrix u) {
+    super(u);
+  }
+
+  public Matrix duplicate() {
+    return new UpperTriangularMatrix(this);
+  }
+
+  public void setElement(int i, int j, double value) {
+    if (i > j) {
+      throw new ArrayIndexOutOfBoundsException("cannot set elements"
+                                               + " below diagonal of a"
+                                               + " upper triangular matrix");
+    }
+    super.setElement(i, j, value);
+  }
+
+  /** Add a matrix to the instance.
+   * This method adds a matrix to the instance. It does modify the instance.
+   * @param u upper triangular matrix to add
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public void selfAdd(UpperTriangularMatrix u) {
+
+    // validity check
+    if ((rows != u.rows) || (columns != u.columns)) {
+      throw new IllegalArgumentException("cannot add a "
+                                         + u.rows + 'x' + u.columns
+                                         + " matrix to a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+
+    // addition loop
+    for (int i = 0; i < rows; ++i) {
+      for (int index = i * (columns + 1); index < (i + 1) * columns; ++index) {
+        data[index] += u.data[index];
+      }
+    }
+
+  }
+
+  /** Substract a matrix from the instance.
+   * This method substract a matrix from the instance. It does modify the instance.
+   * @param u upper triangular matrix to substract
+   * @exception IllegalArgumentException if there is a dimension mismatch
+   */
+  public void selfSub(UpperTriangularMatrix u) {
+
+    // validity check
+    if ((rows != u.rows) || (columns != u.columns)) {
+      throw new IllegalArgumentException("cannot substract a "
+                                         + u.rows + 'x' + u.columns
+                                         + " matrix from a "
+                                         + rows + 'x' + columns
+                                         + " matrix");
+    }
+
+    // substraction loop
+    for (int i = 0; i < rows; ++i) {
+      for (int index = i * (columns + 1); index < (i + 1) * columns; ++index) {
+        data[index] -= u.data[index];
+      }
+    }
+
+  }
+
+  public double getDeterminant(double epsilon) {
+    double determinant = data[0];
+    for (int index = columns + 1; index < columns * columns; index += columns + 1) {
+      determinant *= data[index];
+    }
+    return determinant;
+  }
+
+  public Matrix solve(Matrix b, double epsilon)
+    throws SingularMatrixException {
+    // validity check
+    if (b.getRows() != rows) {
+      throw new IllegalArgumentException("dimension mismatch");
+    }
+
+    // prepare the data storage
+    int bRows  = b.getRows();
+    int bCols  = b.getColumns();
+
+    double[] resultData = new double[bRows * bCols];
+    int resultIndex     = bRows * bCols - 1;
+    int lowerElements   = 0;
+    int upperElements   = 0;
+    int minJ            = columns;
+    int maxJ            = 0;
+
+    // solve the linear system
+    for (int i = rows - 1; i >= 0; --i) {
+      double diag = data[i * (columns + 1)];
+      if (Math.abs(diag) < epsilon) {
+        throw new SingularMatrixException();
+      }
+      double inv = 1.0 / diag;
+
+      NonNullRange range = b.getRangeForRow(i);
+      minJ = Math.min(minJ, range.begin);
+      maxJ = Math.max(maxJ, range.end);
+
+      int j = bCols - 1;
+      while (j >= maxJ) {
+        resultData[resultIndex] = 0.0;
+        --resultIndex;
+        --j;
+      }
+
+      // compute the possibly non null elements
+      int bIndex = i * bCols + maxJ - 1;
+      while (j >= minJ) {
+
+        // compute the current element
+        int index1 = (i + 1) * columns - 1;
+        int index2 = (bRows - 1) * bCols + j;
+        double value = b.data[bIndex];
+        while (index1 >= i * (columns + 1)) {
+          value -= data[index1] * resultData[index2];
+          --index1;
+          index2 -= bCols;
+        }
+        value *= inv;
+        resultData[resultIndex] = value;
+
+        // count the affected upper and lower elements
+        // (in order to deduce the shape of the resulting matrix)
+        if (j < i) {
+          ++lowerElements;
+        } else if (i < j) {
+          ++upperElements;
+        }
+
+        --bIndex;
+        --resultIndex;
+        --j;
+
+      }
+
+      while (j >= 0) {
+        resultData[resultIndex] = 0.0;
+        --resultIndex;
+        --j;
+      }
+
+    }
+
+    return MatrixFactory.buildMatrix(bRows, bCols, resultData,
+                                     lowerElements, upperElements);
+
+  }
+
+  public NonNullRange getRangeForRow(int i) {
+    return new NonNullRange (i, columns);
+  }
+
+  public NonNullRange getRangeForColumn(int j) {
+    return new NonNullRange (0, j + 1);
+  }
+
+  private static final long serialVersionUID = -197266611942032237L;
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/UpperTriangularMatrix.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/design/linalg.argo
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/design/linalg.argo?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/design/linalg.argo (added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/src/org/spaceroots/mantissa/linalg/design/linalg.argo Sun Nov 19 13:36:15 2006
@@ -0,0 +1,68 @@
+<?xml version = "1.0" encoding = "ISO-8859-1" ?>
+<!DOCTYPE argo SYSTEM "argo.dtd" >
+<argo>
+  <documentation>
+    <authorname></authorname>
+    <version></version>
+    <description>
+      
+    </description>
+  </documentation>
+  
+  <searchpath href="PROJECT_DIR" />
+  <member
+    type="pgml"
+    name="linalg_classdiagram1.pgml"
+  />
+  <member
+    type="xmi"
+    name="linalg.xmi"
+  />
+  <historyfile name="" />
+  <stats>
+    <stat name="clicksInToDoPane"
+         value="0" />
+    <stat name="dblClicksInToDoPane"
+         value="0" />
+    <stat name="longestToDoList"
+         value="48" />
+    <stat name="longestAdd"
+         value="0" />
+    <stat name="longestHot"
+         value="0" />
+    <stat name="numCriticsFired"
+         value="17738" />
+    <stat name="numNotValid"
+         value="4" />
+    <stat name="numCriticsApplied"
+         value="0" />
+    <stat name="toDoPerspectivesChanged"
+         value="1" />
+    <stat name="navPerspectivesChanged"
+         value="5" />
+    <stat name="clicksInNavPane"
+         value="3" />
+    <stat name="numFinds"
+         value="1" />
+    <stat name="numJumpToRelated"
+         value="0" />
+    <stat name="numDecisionModel"
+         value="0" />
+    <stat name="numGoalsModel"
+         value="0" />
+    <stat name="numCriticBrowser"
+         value="0" />
+    <stat name="numNavConfig"
+         value="0" />
+    <stat name="numHushes"
+         value="0" />
+    <stat name="numChecks"
+         value="0" />
+    <stat name="Num_Button_Clicks"
+         value="0" />
+    <stat name="Drags_To_New"
+         value="0" />
+    <stat name="Drags_To_Existing"
+         value="0" />
+  </stats>
+</argo>



---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org


Mime
View raw message