001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     * 
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     * 
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    
018    package org.apache.commons.math.linear;
019    
020    import java.text.NumberFormat;
021    import java.text.ParseException;
022    import java.text.ParsePosition;
023    import java.util.Locale;
024    
025    import junit.framework.TestCase;
026    
027    import org.apache.commons.math.util.CompositeFormat;
028    
029    public abstract class RealVectorFormatAbstractTest extends TestCase {
030     
031        RealVectorFormat realVectorFormat = null;
032        RealVectorFormat realVectorFormatSquare = null;
033    
034        protected abstract Locale getLocale();
035    
036        protected abstract char getDecimalCharacter();
037    
038        @Override
039        public void setUp() throws Exception {
040            realVectorFormat = RealVectorFormat.getInstance(getLocale());
041            final NumberFormat nf = NumberFormat.getInstance(getLocale());
042            nf.setMaximumFractionDigits(2);
043            realVectorFormatSquare = new RealVectorFormat("[", "]", " : ", nf);
044        }
045       
046        public void testSimpleNoDecimals() {
047            ArrayRealVector c = new ArrayRealVector(new double[] {1, 1, 1});
048            String expected = "{1; 1; 1}";
049            String actual = realVectorFormat.format(c); 
050            assertEquals(expected, actual);
051        }
052    
053        public void testSimpleWithDecimals() {
054            ArrayRealVector c = new ArrayRealVector(new double[] {1.23, 1.43, 1.63});
055            String expected =
056                "{1"    + getDecimalCharacter() +
057                "23; 1" + getDecimalCharacter() +
058                "43; 1" + getDecimalCharacter() +
059                "63}";
060            String actual = realVectorFormat.format(c); 
061            assertEquals(expected, actual);
062        }
063    
064        public void testSimpleWithDecimalsTrunc() {
065            ArrayRealVector c = new ArrayRealVector(new double[] {1.2323, 1.4343, 1.6333});
066            String expected =
067                "{1"    + getDecimalCharacter() +
068                "23; 1" + getDecimalCharacter() +
069                "43; 1" + getDecimalCharacter() +
070                "63}";
071            String actual = realVectorFormat.format(c); 
072            assertEquals(expected, actual);
073        }
074    
075        public void testNegativeX() {
076            ArrayRealVector c = new ArrayRealVector(new double[] {-1.2323, 1.4343, 1.6333});
077            String expected =
078                "{-1"    + getDecimalCharacter() +
079                "23; 1" + getDecimalCharacter() +
080                "43; 1" + getDecimalCharacter() +
081                "63}";
082            String actual = realVectorFormat.format(c); 
083            assertEquals(expected, actual);
084        }
085    
086        public void testNegativeY() {
087            ArrayRealVector c = new ArrayRealVector(new double[] {1.2323, -1.4343, 1.6333});
088            String expected =
089                "{1"    + getDecimalCharacter() +
090                "23; -1" + getDecimalCharacter() +
091                "43; 1" + getDecimalCharacter() +
092                "63}";
093            String actual = realVectorFormat.format(c); 
094            assertEquals(expected, actual);
095        }
096    
097        public void testNegativeZ() {
098            ArrayRealVector c = new ArrayRealVector(new double[] {1.2323, 1.4343, -1.6333});
099            String expected =
100                "{1"    + getDecimalCharacter() +
101                "23; 1" + getDecimalCharacter() +
102                "43; -1" + getDecimalCharacter() +
103                "63}";
104            String actual = realVectorFormat.format(c); 
105            assertEquals(expected, actual);
106        }
107    
108        public void testNonDefaultSetting() {
109            ArrayRealVector c = new ArrayRealVector(new double[] {1, 1, 1});
110            String expected = "[1 : 1 : 1]";
111            String actual = realVectorFormatSquare.format(c); 
112            assertEquals(expected, actual);
113        }
114        
115        public void testStaticFormatRealVectorImpl() {
116            Locale defaultLocal = Locale.getDefault();
117            Locale.setDefault(getLocale());
118            
119            ArrayRealVector c = new ArrayRealVector(new double[] {232.222, -342.33, 432.444});
120            String expected =
121                "{232"    + getDecimalCharacter() +
122                "22; -342" + getDecimalCharacter() +
123                "33; 432" + getDecimalCharacter() +
124                "44}";
125            String actual = RealVectorFormat.formatRealVector(c); 
126            assertEquals(expected, actual);
127            
128            Locale.setDefault(defaultLocal);
129        }
130    
131        public void testNan() {
132            ArrayRealVector c = new ArrayRealVector(new double[] {Double.NaN, Double.NaN, Double.NaN});
133            String expected = "{(NaN); (NaN); (NaN)}";
134            String actual = realVectorFormat.format(c); 
135            assertEquals(expected, actual);
136        }
137    
138        public void testPositiveInfinity() {
139            ArrayRealVector c = new ArrayRealVector(new double[] {
140                    Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY
141            });
142            String expected = "{(Infinity); (Infinity); (Infinity)}";
143            String actual = realVectorFormat.format(c); 
144            assertEquals(expected, actual);
145        }
146    
147        public void tesNegativeInfinity() {
148            ArrayRealVector c = new ArrayRealVector(new double[] {
149                    Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY
150            });
151            String expected = "{(-Infinity); (-Infinity); (-Infinity)}";
152            String actual = realVectorFormat.format(c); 
153            assertEquals(expected, actual);
154        }
155    
156        public void testParseSimpleNoDecimals() {
157            String source = "{1; 1; 1}";
158            ArrayRealVector expected = new ArrayRealVector(new double[] {1, 1, 1});
159            try {
160                ArrayRealVector actual = (ArrayRealVector) realVectorFormat.parseObject(source); 
161                assertEquals(expected, actual);
162            } catch (ParseException ex) {
163                fail(ex.getMessage());
164            }
165        }
166    
167        public void testParseIgnoredWhitespace() {
168            ArrayRealVector expected = new ArrayRealVector(new double[] {1, 1, 1});
169            ParsePosition pos1 = new ParsePosition(0);
170            String source1 = "{1;1;1}";
171            assertEquals(expected, realVectorFormat.parseObject(source1, pos1));
172            assertEquals(source1.length(), pos1.getIndex());
173            ParsePosition pos2 = new ParsePosition(0);
174            String source2 = " { 1 ; 1 ; 1 } ";
175            assertEquals(expected, realVectorFormat.parseObject(source2, pos2));
176            assertEquals(source2.length() - 1, pos2.getIndex());
177        }
178    
179        public void testParseSimpleWithDecimals() {
180            String source =
181                "{1" + getDecimalCharacter() +
182                "23; 1" + getDecimalCharacter() +
183                "43; 1" + getDecimalCharacter() +
184                "63}";
185            ArrayRealVector expected = new ArrayRealVector(new double[] {1.23, 1.43, 1.63});
186            try {
187                ArrayRealVector actual = (ArrayRealVector) realVectorFormat.parseObject(source); 
188                assertEquals(expected, actual);
189            } catch (ParseException ex) {
190                fail(ex.getMessage());
191            }
192        }
193    
194        public void testParseSimpleWithDecimalsTrunc() {
195            String source =
196                "{1" + getDecimalCharacter() +
197                "2323; 1" + getDecimalCharacter() +
198                "4343; 1" + getDecimalCharacter() +
199                "6333}";
200            ArrayRealVector expected = new ArrayRealVector(new double[] {1.2323, 1.4343, 1.6333});
201            try {
202                ArrayRealVector actual = (ArrayRealVector) realVectorFormat.parseObject(source); 
203                assertEquals(expected, actual);
204            } catch (ParseException ex) {
205                fail(ex.getMessage());
206            }
207        }
208    
209        public void testParseNegativeX() {
210            String source =
211                "{-1" + getDecimalCharacter() +
212                "2323; 1" + getDecimalCharacter() +
213                "4343; 1" + getDecimalCharacter() +
214                "6333}";
215            ArrayRealVector expected = new ArrayRealVector(new double[] {-1.2323, 1.4343, 1.6333});
216            try {
217                ArrayRealVector actual = (ArrayRealVector) realVectorFormat.parseObject(source); 
218                assertEquals(expected, actual);
219            } catch (ParseException ex) {
220                fail(ex.getMessage());
221            }
222        }
223    
224        public void testParseNegativeY() {
225            String source =
226                "{1" + getDecimalCharacter() +
227                "2323; -1" + getDecimalCharacter() +
228                "4343; 1" + getDecimalCharacter() +
229                "6333}";
230            ArrayRealVector expected = new ArrayRealVector(new double[] {1.2323, -1.4343, 1.6333});
231            try {
232                ArrayRealVector actual = (ArrayRealVector) realVectorFormat.parseObject(source); 
233                assertEquals(expected, actual);
234            } catch (ParseException ex) {
235                fail(ex.getMessage());
236            }
237        }
238    
239        public void testParseNegativeZ() {
240            String source =
241                "{1" + getDecimalCharacter() +
242                "2323; 1" + getDecimalCharacter() +
243                "4343; -1" + getDecimalCharacter() +
244                "6333}";
245            ArrayRealVector expected = new ArrayRealVector(new double[] {1.2323, 1.4343, -1.6333});
246            try {
247                ArrayRealVector actual = (ArrayRealVector) realVectorFormat.parseObject(source); 
248                assertEquals(expected, actual);
249            } catch (ParseException ex) {
250                fail(ex.getMessage());
251            }
252        }
253    
254        public void testParseNegativeAll() {
255            String source =
256                "{-1" + getDecimalCharacter() +
257                "2323; -1" + getDecimalCharacter() +
258                "4343; -1" + getDecimalCharacter() +
259                "6333}";
260            ArrayRealVector expected = new ArrayRealVector(new double[] {-1.2323, -1.4343, -1.6333});
261            try {
262                ArrayRealVector actual = (ArrayRealVector) realVectorFormat.parseObject(source); 
263                assertEquals(expected, actual);
264            } catch (ParseException ex) {
265                fail(ex.getMessage());
266            }
267        }
268    
269        public void testParseZeroX() {
270            String source =
271                "{0" + getDecimalCharacter() +
272                "0; -1" + getDecimalCharacter() +
273                "4343; 1" + getDecimalCharacter() +
274                "6333}";
275            ArrayRealVector expected = new ArrayRealVector(new double[] {0.0, -1.4343, 1.6333});
276            try {
277                ArrayRealVector actual = (ArrayRealVector) realVectorFormat.parseObject(source); 
278                assertEquals(expected, actual);
279            } catch (ParseException ex) {
280                fail(ex.getMessage());
281            }
282        }
283    
284        public void testParseNonDefaultSetting() {
285            String source =
286                "[1" + getDecimalCharacter() +
287                "2323 : 1" + getDecimalCharacter() +
288                "4343 : 1" + getDecimalCharacter() +
289                "6333]";
290            ArrayRealVector expected = new ArrayRealVector(new double[] {1.2323, 1.4343, 1.6333});
291            try {
292                ArrayRealVector actual = (ArrayRealVector) realVectorFormatSquare.parseObject(source); 
293                assertEquals(expected, actual);
294            } catch (ParseException ex) {
295                fail(ex.getMessage());
296            }
297        }
298        
299        public void testParseNan() {
300            String source = "{(NaN); (NaN); (NaN)}";
301            try {
302                ArrayRealVector actual = (ArrayRealVector) realVectorFormat.parseObject(source); 
303                assertEquals(new ArrayRealVector(new double[] {Double.NaN, Double.NaN, Double.NaN}), actual);
304            } catch (ParseException ex) {
305                fail(ex.getMessage());
306            }
307        }
308    
309        public void testParsePositiveInfinity() {
310            String source = "{(Infinity); (Infinity); (Infinity)}";
311            try {
312                ArrayRealVector actual = (ArrayRealVector)realVectorFormat.parseObject(source); 
313                assertEquals(new ArrayRealVector(new double[] {
314                        Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY
315                }), actual);
316            } catch (ParseException ex) {
317                fail(ex.getMessage());
318            }
319        }
320    
321        public void testParseNegativeInfinity() {
322            String source = "{(-Infinity); (-Infinity); (-Infinity)}";
323            try {
324                ArrayRealVector actual = (ArrayRealVector)realVectorFormat.parseObject(source); 
325                assertEquals(new ArrayRealVector(new double[] {
326                        Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY
327                }), actual);
328            } catch (ParseException ex) {
329                fail(ex.getMessage());
330            }
331        }
332    
333        public void testParseNoComponents() {
334            try {
335                realVectorFormat.parseObject("{ }");
336            } catch (ParseException pe) {
337                // expected behavior
338            } catch (Exception e) {
339                fail("wrong exception caught");
340            }
341        }
342    
343        public void testParseManyComponents() throws ParseException {
344            ArrayRealVector parsed =
345                (ArrayRealVector) realVectorFormat.parseObject("{0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0}");
346            assertEquals(24, parsed.getDimension());
347        }
348    
349        public void testConstructorSingleFormat() {
350            NumberFormat nf = NumberFormat.getInstance();
351            RealVectorFormat cf = new RealVectorFormat(nf);
352            assertNotNull(cf);
353            assertEquals(nf, cf.getFormat());
354        }
355        
356        public void testFormatObject() {
357            try {
358                CompositeFormat cf = new RealVectorFormat();
359                Object object = new Object();
360                cf.format(object);
361                fail();
362            } catch (IllegalArgumentException ex) {
363                // success
364            }
365        }
366    
367        public void testForgottenPrefix() {
368            ParsePosition pos = new ParsePosition(0);
369            assertNull(new RealVectorFormat().parse("1; 1; 1}", pos));
370            assertEquals(0, pos.getErrorIndex());
371        }
372    
373        public void testForgottenSeparator() {
374            ParsePosition pos = new ParsePosition(0);
375            assertNull(new RealVectorFormat().parse("{1; 1 1}", pos));
376            assertEquals(6, pos.getErrorIndex());
377        }
378    
379        public void testForgottenSuffix() {
380            ParsePosition pos = new ParsePosition(0);
381            assertNull(new RealVectorFormat().parse("{1; 1; 1 ", pos));
382            assertEquals(8, pos.getErrorIndex());
383        }
384    
385    }