commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From l..@apache.org
Subject svn commit: r680026 - in /commons/proper/math/branches/MATH_2_0/src: java/org/apache/commons/math/complex/ComplexFormat.java java/org/apache/commons/math/util/CompositeFormat.java test/org/apache/commons/math/complex/ComplexFormatAbstractTest.java
Date Sat, 26 Jul 2008 18:28:45 GMT
Author: luc
Date: Sat Jul 26 11:28:45 2008
New Revision: 680026

URL: http://svn.apache.org/viewvc?rev=680026&view=rev
Log:
extracted a CompositeFormat base class from ComplexFormat

Added:
    commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/util/CompositeFormat.java
  (with props)
Modified:
    commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/complex/ComplexFormat.java
    commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/complex/ComplexFormatAbstractTest.java

Modified: commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/complex/ComplexFormat.java
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/complex/ComplexFormat.java?rev=680026&r1=680025&r2=680026&view=diff
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/complex/ComplexFormat.java
(original)
+++ commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/complex/ComplexFormat.java
Sat Jul 26 11:28:45 2008
@@ -17,28 +17,28 @@
 
 package org.apache.commons.math.complex;
 
-import java.io.Serializable;
 import java.text.FieldPosition;
-import java.text.Format;
 import java.text.NumberFormat;
 import java.text.ParseException;
 import java.text.ParsePosition;
 import java.util.Locale;
 
+import org.apache.commons.math.util.CompositeFormat;
+
 /**
  * Formats a Complex number in cartesian format "Re(c) + Im(c)i".  'i' can
- * be replaced with 'j', and the number format for both real and imaginary parts
- * can be configured.
+ * be replaced with 'j' (or anything else), and the number format for both real
+ * and imaginary parts can be configured.
  *
  * @author Apache Software Foundation
  * @version $Revision$ $Date$
  */
-public class ComplexFormat extends Format implements Serializable {
+public class ComplexFormat extends CompositeFormat {
     
     /** Serializable version identifier */
-    private static final long serialVersionUID = -6337346779577272306L;
-    
-    /** The default imaginary character. */
+    private static final long serialVersionUID = -3343698360149467646L;
+
+     /** The default imaginary character. */
     private static final String DEFAULT_IMAGINARY_CHARACTER = "i";
     
     /** The notation used to signify the imaginary part of the complex number. */
@@ -73,8 +73,7 @@
      * @param realFormat the custom format for the real part.
      * @param imaginaryFormat the custom format for the imaginary part.
      */
-    public ComplexFormat(NumberFormat realFormat,
-            NumberFormat imaginaryFormat) {
+    public ComplexFormat(NumberFormat realFormat, NumberFormat imaginaryFormat) {
         this(DEFAULT_IMAGINARY_CHARACTER, realFormat, imaginaryFormat);
     }
     
@@ -114,14 +113,23 @@
     }
 
     /**
-     * This static method calls formatComplex() on a default instance of
+     * Get the set of locales for which complex formats are available.
+     * <p>This is the same set as the {@link NumberFormat} set.</p> 
+     * @return available complex format locales.
+     */
+    public static Locale[] getAvailableLocales() {
+        return NumberFormat.getAvailableLocales();
+    }
+
+    /**
+     * This static method calls {@link #format(Object)} on a default instance of
      * ComplexFormat.
      *
      * @param c Complex object to format
      * @return A formatted number in the form "Re(c) + Im(c)i"
      */
-    public static String formatComplex( Complex c ) {
-        return getInstance().format( c );
+    public static String formatComplex(Complex c) {
+        return getInstance().format(c);
     }
     
     /**
@@ -182,75 +190,13 @@
             ret = format( new Complex(((Number)obj).doubleValue(), 0.0),
                 toAppendTo, pos);
         } else { 
-            throw new IllegalArgumentException(
-                "Cannot format given Object as a Date");
+            throw new IllegalArgumentException("Cannot format given Object as a Complex");
         }
         
         return ret;
     }
 
     /**
-     * Formats a double value to produce a string.  In general, the value is
-     * formatted using the formatting rules of <code>format</code>.  There are
-     * three exceptions to this:
-     * <ol>
-     * <li>NaN is formatted as '(NaN)'</li>
-     * <li>Positive infinity is formatted as '(Infinity)'</li>
-     * <li>Negative infinity is formatted as '(-Infinity)'</li>
-     * </ol>
-     *
-     * @param value the double to format.
-     * @param format the format used.
-     * @param toAppendTo where the text is to be appended
-     * @param pos On input: an alignment field, if desired. On output: the
-     *            offsets of the alignment field
-     * @return the value passed in as toAppendTo.
-     */
-    private StringBuffer formatDouble(double value, NumberFormat format,
-            StringBuffer toAppendTo, FieldPosition pos) {
-        if( Double.isNaN(value) || Double.isInfinite(value) ) {
-            toAppendTo.append('(');
-            toAppendTo.append(value);
-            toAppendTo.append(')');
-        } else {
-            format.format(value, toAppendTo, pos);
-        }
-        return toAppendTo;
-    }
-    
-    /**
-     * Get the set of locales for which complex formats are available.  This
-     * is the same set as the {@link NumberFormat} set. 
-     * @return available complex format locales.
-     */
-    public static Locale[] getAvailableLocales() {
-        return NumberFormat.getAvailableLocales();
-    }
-    
-    /**
-     * Create a default number format.  The default number format is based on
-     * {@link NumberFormat#getInstance()} with the only customizing is the
-     * maximum number of fraction digits, which is set to 2.  
-     * @return the default number format.
-     */
-    private static NumberFormat getDefaultNumberFormat() {
-        return getDefaultNumberFormat(Locale.getDefault());
-    }
-    
-    /**
-     * Create a default number format.  The default number format is based on
-     * {@link NumberFormat#getInstance(java.util.Locale)} with the only
-     * customizing is the maximum number of fraction digits, which is set to 2.  
-     * @param locale the specific locale used by the format.
-     * @return the default number format specific to the given locale.
-     */
-    private static NumberFormat getDefaultNumberFormat(Locale locale) {
-        NumberFormat nf = NumberFormat.getInstance(locale);
-        nf.setMaximumFractionDigits(2);
-        return nf;
-    }
-    
-    /**
      * Access the imaginaryCharacter.
      * @return the imaginaryCharacter.
      */
@@ -270,7 +216,7 @@
      * Returns the default complex format for the current locale.
      * @return the default complex format.
      */
-    public static ComplexFormat getInstance() {
+    public static CompositeFormat getInstance() {
         return getInstance(Locale.getDefault());
     }
     
@@ -305,7 +251,7 @@
         Complex result = parse(source, parsePosition);
         if (parsePosition.getIndex() == 0) {
             throw new ParseException("Unparseable complex number: \"" + source +
-                "\"", parsePosition.getErrorIndex());
+                                     "\"", parsePosition.getErrorIndex());
         }
         return result;
     }
@@ -328,7 +274,6 @@
         if (re == null) {
             // invalid real number
             // set index back to initial, error index should already be set
-            // character examined.
             pos.setIndex(initialIndex);
             return null;
         }
@@ -365,129 +310,19 @@
         if (im == null) {
             // invalid imaginary number
             // set index back to initial, error index should already be set
-            // character examined.
             pos.setIndex(initialIndex);
             return null;
         }
 
         // parse imaginary character
-        int n = getImaginaryCharacter().length();
-        startIndex = pos.getIndex();
-        int endIndex = startIndex + n;
-        if ((startIndex >= source.length()) ||
-            (endIndex > source.length()) ||
-            source.substring(startIndex, endIndex).compareTo(
-            getImaginaryCharacter()) != 0) {
-            // set index back to initial, error index should be the start index
-            // character examined.
-            pos.setIndex(initialIndex);
-            pos.setErrorIndex(startIndex);
+        if (!parseFixedstring(source, getImaginaryCharacter(), pos)) {
             return null;
         }
-        pos.setIndex(endIndex);
 
         return new Complex(re.doubleValue(), im.doubleValue() * sign);
-    }
-     
-    /**
-     * Parses <code>source</code> until a non-whitespace character is found.
-     *
-     * @param source the string to parse
-     * @param pos input/ouput parsing parameter.  On output, <code>pos</code>
-     *        holds the index of the next non-whitespace character.
-     */
-    private void parseAndIgnoreWhitespace(String source, ParsePosition pos) {
-        parseNextCharacter(source, pos);
-        pos.setIndex(pos.getIndex() - 1);
-    }
 
-    /**
-     * Parses <code>source</code> until a non-whitespace character is found.
-     *
-     * @param source the string to parse
-     * @param pos input/ouput parsing parameter.
-     * @return the first non-whitespace character.
-     */
-    private char parseNextCharacter(String source, ParsePosition pos) {
-         int index = pos.getIndex();
-         int n = source.length();
-         char ret = 0;
-
-         if (index < n) {
-             char c;
-             do {
-                 c = source.charAt(index++);
-             } while (Character.isWhitespace(c) && index < n);
-             pos.setIndex(index);
-         
-             if (index < n) {
-                 ret = c;
-             }
-         }
-         
-         return ret;
-    }
-    
-    /**
-     * Parses <code>source</code> for a special double values.  These values
-     * include Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY.
-     *
-     * @param source the string to parse
-     * @param value the special value to parse.
-     * @param pos input/ouput parsing parameter.
-     * @return the special number.
-     */
-    private Number parseNumber(String source, double value, ParsePosition pos) {
-        Number ret = null;
-        
-        StringBuffer sb = new StringBuffer();
-        sb.append('(');
-        sb.append(value);
-        sb.append(')');
-        
-        int n = sb.length();
-        int startIndex = pos.getIndex();
-        int endIndex = startIndex + n;
-        if (endIndex < source.length()) {
-            if (source.substring(startIndex, endIndex).compareTo(sb.toString()) == 0) {
-                ret = Double.valueOf(value);
-                pos.setIndex(endIndex);
-            }
-        }
-        
-        return ret;
     }
-    
-    /**
-     * Parses <code>source</code> for a number.  This method can parse normal,
-     * numeric values as well as special values.  These special values include
-     * Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY.
-     *
-     * @param source the string to parse
-     * @param format the number format used to parse normal, numeric values.
-     * @param pos input/ouput parsing parameter.
-     * @return the parsed number.
-     */
-    private Number parseNumber(String source, NumberFormat format, ParsePosition pos) {
-        int startIndex = pos.getIndex();
-        Number number = format.parse(source, pos);
-        int endIndex = pos.getIndex();
-        
-        // check for error parsing number
-        if (startIndex == endIndex) {
-            // try parsing special numbers
-            double[] special = {Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY};
-            for (int i = 0; i < special.length; ++i) {
-                number = parseNumber(source, special[i], pos);
-                if (number != null) {
-                    break;
-                }
-            }
-        }
-        
-        return number;
-    }
-
+     
     /**
      * Parses a string to produce a object.
      *
@@ -499,6 +334,7 @@
     public Object parseObject(String source, ParsePosition pos) {
         return parse(source, pos);
     }
+
     /**
      * Modify the imaginaryCharacter.
      * @param imaginaryCharacter The new imaginaryCharacter value.
@@ -540,4 +376,5 @@
         }
         this.realFormat = realFormat;
     }
+
 }

Added: commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/util/CompositeFormat.java
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/util/CompositeFormat.java?rev=680026&view=auto
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/util/CompositeFormat.java
(added)
+++ commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/util/CompositeFormat.java
Sat Jul 26 11:28:45 2008
@@ -0,0 +1,218 @@
+/*
+ * 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.apache.commons.math.util;
+
+import java.text.FieldPosition;
+import java.text.Format;
+import java.text.NumberFormat;
+import java.text.ParsePosition;
+import java.util.Locale;
+
+/**
+ * Base class for formatters of composite objects (complex numbers, vectors ...).
+ *
+ * @author Apache Software Foundation
+ * @version $Revision$ $Date$
+ */
+public abstract class CompositeFormat extends Format {
+
+    /**
+     * Create a default number format.  The default number format is based on
+     * {@link NumberFormat#getInstance()} with the only customizing is the
+     * maximum number of fraction digits, which is set to 2.  
+     * @return the default number format.
+     */
+    protected static NumberFormat getDefaultNumberFormat() {
+        return getDefaultNumberFormat(Locale.getDefault());
+    }
+
+    /**
+     * Create a default number format.  The default number format is based on
+     * {@link NumberFormat#getInstance(java.util.Locale)} with the only
+     * customizing is the maximum number of fraction digits, which is set to 2.  
+     * @param locale the specific locale used by the format.
+     * @return the default number format specific to the given locale.
+     */
+    protected static NumberFormat getDefaultNumberFormat(final Locale locale) {
+        final NumberFormat nf = NumberFormat.getInstance(locale);
+        nf.setMaximumFractionDigits(2);
+        return nf;
+    }
+
+    /**
+     * Parses <code>source</code> until a non-whitespace character is found.
+     *
+     * @param source the string to parse
+     * @param pos input/ouput parsing parameter.  On output, <code>pos</code>
+     *        holds the index of the next non-whitespace character.
+     */
+    protected void parseAndIgnoreWhitespace(final String source,
+                                            final ParsePosition pos) {
+        parseNextCharacter(source, pos);
+        pos.setIndex(pos.getIndex() - 1);
+    }
+
+    /**
+     * Parses <code>source</code> until a non-whitespace character is found.
+     *
+     * @param source the string to parse
+     * @param pos input/ouput parsing parameter.
+     * @return the first non-whitespace character.
+     */
+    protected char parseNextCharacter(final String source,
+                                      final ParsePosition pos) {
+         int index = pos.getIndex();
+         final int n = source.length();
+         char ret = 0;
+    
+         if (index < n) {
+             char c;
+             do {
+                 c = source.charAt(index++);
+             } while (Character.isWhitespace(c) && index < n);
+             pos.setIndex(index);
+         
+             if (index < n) {
+                 ret = c;
+             }
+         }
+         
+         return ret;
+    }
+
+    /**
+     * Parses <code>source</code> for a special double values.  These values
+     * include Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY.
+     *
+     * @param source the string to parse
+     * @param value the special value to parse.
+     * @param pos input/ouput parsing parameter.
+     * @return the special number.
+     */
+    private Number parseNumber(final String source, final double value,
+                               final ParsePosition pos) {
+        Number ret = null;
+        
+        StringBuffer sb = new StringBuffer();
+        sb.append('(');
+        sb.append(value);
+        sb.append(')');
+        
+        final int n = sb.length();
+        final int startIndex = pos.getIndex();
+        final int endIndex = startIndex + n;
+        if (endIndex < source.length()) {
+            if (source.substring(startIndex, endIndex).compareTo(sb.toString()) == 0) {
+                ret = Double.valueOf(value);
+                pos.setIndex(endIndex);
+            }
+        }
+        
+        return ret;
+    }
+
+    /**
+     * Parses <code>source</code> for a number.  This method can parse normal,
+     * numeric values as well as special values.  These special values include
+     * Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY.
+     *
+     * @param source the string to parse
+     * @param format the number format used to parse normal, numeric values.
+     * @param pos input/ouput parsing parameter.
+     * @return the parsed number.
+     */
+    protected Number parseNumber(final String source, final NumberFormat format,
+                                 final ParsePosition pos) {
+        final int startIndex = pos.getIndex();
+        Number number = format.parse(source, pos);
+        final int endIndex = pos.getIndex();
+        
+        // check for error parsing number
+        if (startIndex == endIndex) {
+            // try parsing special numbers
+            final double[] special = {
+                Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY
+            };
+            for (int i = 0; i < special.length; ++i) {
+                number = parseNumber(source, special[i], pos);
+                if (number != null) {
+                    break;
+                }
+            }
+        }
+        
+        return number;
+    }
+
+    /**
+     * Parse <code>source</code> for an expected fixed string.
+     * @param source the string to parse
+     * @param expected expected string
+     * @param pos input/ouput parsing parameter.
+     * @return true if the expected string was there
+     */
+    protected boolean parseFixedstring(final String source, final String expected,
+                                       final ParsePosition pos) {
+
+        final int startIndex = pos.getIndex();
+        final int endIndex = startIndex + expected.length();
+        if ((startIndex >= source.length()) ||
+            (endIndex > source.length()) ||
+            (source.substring(startIndex, endIndex).compareTo(expected) != 0)) {
+            // set index back to start, error index should be the start index
+            pos.setIndex(startIndex);
+            pos.setErrorIndex(startIndex);
+            return false;
+        }
+
+        // the string was here
+        pos.setIndex(endIndex);
+        return true;
+
+    }
+
+    /**
+     * Formats a double value to produce a string.  In general, the value is
+     * formatted using the formatting rules of <code>format</code>.  There are
+     * three exceptions to this:
+     * <ol>
+     * <li>NaN is formatted as '(NaN)'</li>
+     * <li>Positive infinity is formatted as '(Infinity)'</li>
+     * <li>Negative infinity is formatted as '(-Infinity)'</li>
+     * </ol>
+     *
+     * @param value the double to format.
+     * @param format the format used.
+     * @param toAppendTo where the text is to be appended
+     * @param pos On input: an alignment field, if desired. On output: the
+     *            offsets of the alignment field
+     * @return the value passed in as toAppendTo.
+     */
+    protected StringBuffer formatDouble(final double value, final NumberFormat format,
+                                        final StringBuffer toAppendTo,
+                                        final FieldPosition pos) {
+        if( Double.isNaN(value) || Double.isInfinite(value) ) {
+            toAppendTo.append('(');
+            toAppendTo.append(value);
+            toAppendTo.append(')');
+        } else {
+            format.format(value, toAppendTo, pos);
+        }
+        return toAppendTo;
+    }
+
+}
\ No newline at end of file

Propchange: commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/util/CompositeFormat.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/util/CompositeFormat.java
------------------------------------------------------------------------------
    svn:keywords = Author Date Id Revision

Modified: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/complex/ComplexFormatAbstractTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/complex/ComplexFormatAbstractTest.java?rev=680026&r1=680025&r2=680026&view=diff
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/complex/ComplexFormatAbstractTest.java
(original)
+++ commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/complex/ComplexFormatAbstractTest.java
Sat Jul 26 11:28:45 2008
@@ -22,11 +22,13 @@
 import java.text.ParsePosition;
 import java.util.Locale;
 
+import org.apache.commons.math.util.CompositeFormat;
+
 import junit.framework.TestCase;
 
 public abstract class ComplexFormatAbstractTest extends TestCase {
  
-    ComplexFormat complexFormat = null;
+    CompositeFormat complexFormat = null;
     ComplexFormat complexFormatJ = null;
 
     protected abstract Locale getLocale();
@@ -333,7 +335,7 @@
     }
     
     public void testFormatNumber() {
-        ComplexFormat cf = ComplexFormat.getInstance(getLocale());
+        CompositeFormat cf = ComplexFormat.getInstance(getLocale());
         Double pi = Double.valueOf(Math.PI);
         String text = cf.format(pi);
         assertEquals("3" + getDecimalCharacter() + "14", text);
@@ -341,7 +343,7 @@
     
     public void testFormatObject() {
         try {
-            ComplexFormat cf = new ComplexFormat();
+            CompositeFormat cf = new ComplexFormat();
             Object object = new Object();
             cf.format(object);
             fail();



Mime
View raw message