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 package org.apache.commons.math.linear;
018
019
020 import org.apache.commons.math.fraction.Fraction;
021 import org.apache.commons.math.fraction.FractionConversionException;
022 import org.apache.commons.math.fraction.FractionField;
023
024
025 import junit.framework.TestCase;
026
027 /**
028 * Test cases for the {@link SparseFieldVector} class.
029 *
030 * @version $Revision: 799857 $ $Date: 2009-08-01 09:07:12 -0400 (Sat, 01 Aug 2009) $
031 */
032 public class SparseFieldVectorTest extends TestCase {
033
034 //
035 protected Fraction[][] ma1 = {{new Fraction(1), new Fraction(2), new Fraction(3)}, {new Fraction(4), new Fraction(5), new Fraction(6)}, {new Fraction(7), new Fraction(8), new Fraction(9)}};
036 protected Fraction[] vec1 = {new Fraction(1), new Fraction(2), new Fraction(3)};
037 protected Fraction[] vec2 = {new Fraction(4), new Fraction(5), new Fraction(6)};
038 protected Fraction[] vec3 = {new Fraction(7), new Fraction(8), new Fraction(9)};
039 protected Fraction[] vec4 = {new Fraction(1), new Fraction(2), new Fraction(3), new Fraction(4), new Fraction(5), new Fraction(6), new Fraction(7), new Fraction(8), new Fraction(9)};
040 protected Fraction[] vec_null = {new Fraction(0), new Fraction(0), new Fraction(0)};
041 protected Fraction[] dvec1 = {new Fraction(1), new Fraction(2), new Fraction(3), new Fraction(4), new Fraction(5), new Fraction(6), new Fraction(7), new Fraction(8),new Fraction(9)};
042 protected Fraction[][] mat1 = {{new Fraction(1), new Fraction(2), new Fraction(3)}, {new Fraction(4), new Fraction(5), new Fraction(6)},{ new Fraction(7), new Fraction(8), new Fraction(9)}};
043
044 // tolerances
045 protected double entryTolerance = 10E-16;
046 protected double normTolerance = 10E-14;
047
048 protected FractionField field = FractionField.getInstance();
049
050 public void testMapFunctions() throws FractionConversionException {
051 SparseFieldVector<Fraction> v1 = new SparseFieldVector<Fraction>(field,vec1);
052
053 //octave = v1 .+ 2.0
054 FieldVector<Fraction> v_mapAdd = v1.mapAdd(new Fraction(2));
055 Fraction[] result_mapAdd = {new Fraction(3), new Fraction(4), new Fraction(5)};
056 assertEquals("compare vectors" ,result_mapAdd,v_mapAdd.getData());
057
058 //octave = v1 .+ 2.0
059 FieldVector<Fraction> v_mapAddToSelf = v1.copy();
060 v_mapAddToSelf.mapAddToSelf(new Fraction(2));
061 Fraction[] result_mapAddToSelf = {new Fraction(3), new Fraction(4), new Fraction(5)};
062 assertEquals("compare vectors" ,result_mapAddToSelf,v_mapAddToSelf.getData());
063
064 //octave = v1 .- 2.0
065 FieldVector<Fraction> v_mapSubtract = v1.mapSubtract(new Fraction(2));
066 Fraction[] result_mapSubtract = {new Fraction(-1), new Fraction(0), new Fraction(1)};
067 assertEquals("compare vectors" ,result_mapSubtract,v_mapSubtract.getData());
068
069 //octave = v1 .- 2.0
070 FieldVector<Fraction> v_mapSubtractToSelf = v1.copy();
071 v_mapSubtractToSelf.mapSubtractToSelf(new Fraction(2));
072 Fraction[] result_mapSubtractToSelf = {new Fraction(-1), new Fraction(0), new Fraction(1)};
073 assertEquals("compare vectors" ,result_mapSubtractToSelf,v_mapSubtractToSelf.getData());
074
075 //octave = v1 .* 2.0
076 FieldVector<Fraction> v_mapMultiply = v1.mapMultiply(new Fraction(2));
077 Fraction[] result_mapMultiply = {new Fraction(2), new Fraction(4), new Fraction(6)};
078 assertEquals("compare vectors" ,result_mapMultiply,v_mapMultiply.getData());
079
080 //octave = v1 .* 2.0
081 FieldVector<Fraction> v_mapMultiplyToSelf = v1.copy();
082 v_mapMultiplyToSelf.mapMultiplyToSelf(new Fraction(2));
083 Fraction[] result_mapMultiplyToSelf = {new Fraction(2), new Fraction(4), new Fraction(6)};
084 assertEquals("compare vectors" ,result_mapMultiplyToSelf,v_mapMultiplyToSelf.getData());
085
086 //octave = v1 ./ 2.0
087 FieldVector<Fraction> v_mapDivide = v1.mapDivide(new Fraction(2));
088 Fraction[] result_mapDivide = {new Fraction(.5d), new Fraction(1), new Fraction(1.5d)};
089 assertEquals("compare vectors" ,result_mapDivide,v_mapDivide.getData());
090
091 //octave = v1 ./ 2.0
092 FieldVector<Fraction> v_mapDivideToSelf = v1.copy();
093 v_mapDivideToSelf.mapDivideToSelf(new Fraction(2));
094 Fraction[] result_mapDivideToSelf = {new Fraction(.5d), new Fraction(1), new Fraction(1.5d)};
095 assertEquals("compare vectors" ,result_mapDivideToSelf,v_mapDivideToSelf.getData());
096
097 //octave = v1 .^-1
098 FieldVector<Fraction> v_mapInv = v1.mapInv();
099 Fraction[] result_mapInv = {new Fraction(1),new Fraction(0.5d),new Fraction(3.333333333333333e-01d)};
100 assertEquals("compare vectors" ,result_mapInv,v_mapInv.getData());
101
102 //octave = v1 .^-1
103 FieldVector<Fraction> v_mapInvToSelf = v1.copy();
104 v_mapInvToSelf.mapInvToSelf();
105 Fraction[] result_mapInvToSelf = {new Fraction(1),new Fraction(0.5d),new Fraction(3.333333333333333e-01d)};
106 assertEquals("compare vectors" ,result_mapInvToSelf,v_mapInvToSelf.getData());
107
108
109 }
110
111 public void testBasicFunctions() throws FractionConversionException {
112 SparseFieldVector<Fraction> v1 = new SparseFieldVector<Fraction>(field,vec1);
113 SparseFieldVector<Fraction> v2 = new SparseFieldVector<Fraction>(field,vec2);
114
115 SparseFieldVector<Fraction> v2_t = new SparseFieldVector<Fraction>(field,vec2);
116
117 //octave = v1 + v2
118 FieldVector<Fraction> v_add = v1.add(v2);
119 Fraction[] result_add = {new Fraction(5), new Fraction(7), new Fraction(9)};
120 assertEquals("compare vect" ,v_add.getData(),result_add);
121
122 SparseFieldVector<Fraction> vt2 = new SparseFieldVector<Fraction>(field,vec2);
123 FieldVector<Fraction> v_add_i = v1.add(vt2);
124 Fraction[] result_add_i = {new Fraction(5), new Fraction(7), new Fraction(9)};
125 assertEquals("compare vect" ,v_add_i.getData(),result_add_i);
126
127 //octave = v1 - v2
128 SparseFieldVector<Fraction> v_subtract = v1.subtract(v2);
129 Fraction[] result_subtract = {new Fraction(-3), new Fraction(-3), new Fraction(-3)};
130 assertClose("compare vect" ,v_subtract.getData(),result_subtract,normTolerance);
131
132 FieldVector<Fraction> v_subtract_i = v1.subtract(vt2);
133 Fraction[] result_subtract_i = {new Fraction(-3), new Fraction(-3), new Fraction(-3)};
134 assertClose("compare vect" ,v_subtract_i.getData(),result_subtract_i,normTolerance);
135
136 // octave v1 .* v2
137 FieldVector<Fraction> v_ebeMultiply = v1.ebeMultiply(v2);
138 Fraction[] result_ebeMultiply = {new Fraction(4), new Fraction(10), new Fraction(18)};
139 assertClose("compare vect" ,v_ebeMultiply.getData(),result_ebeMultiply,normTolerance);
140
141 FieldVector<Fraction> v_ebeMultiply_2 = v1.ebeMultiply(v2_t);
142 Fraction[] result_ebeMultiply_2 = {new Fraction(4), new Fraction(10), new Fraction(18)};
143 assertClose("compare vect" ,v_ebeMultiply_2.getData(),result_ebeMultiply_2,normTolerance);
144
145 // octave v1 ./ v2
146 FieldVector<Fraction> v_ebeDivide = v1.ebeDivide(v2);
147 Fraction[] result_ebeDivide = {new Fraction(0.25d), new Fraction(0.4d), new Fraction(0.5d)};
148 assertClose("compare vect" ,v_ebeDivide.getData(),result_ebeDivide,normTolerance);
149
150 FieldVector<Fraction> v_ebeDivide_2 = v1.ebeDivide(v2_t);
151 Fraction[] result_ebeDivide_2 = {new Fraction(0.25d), new Fraction(0.4d), new Fraction(0.5d)};
152 assertClose("compare vect" ,v_ebeDivide_2.getData(),result_ebeDivide_2,normTolerance);
153
154 // octave dot(v1,v2)
155 Fraction dot = v1.dotProduct(v2);
156 assertEquals("compare val ",new Fraction(32), dot);
157
158 // octave dot(v1,v2_t)
159 Fraction dot_2 = v1.dotProduct(v2_t);
160 assertEquals("compare val ",new Fraction(32), dot_2);
161
162 FieldMatrix<Fraction> m_outerProduct = v1.outerProduct(v2);
163 assertEquals("compare val ",new Fraction(4), m_outerProduct.getEntry(0,0));
164
165 FieldMatrix<Fraction> m_outerProduct_2 = v1.outerProduct(v2_t);
166 assertEquals("compare val ",new Fraction(4), m_outerProduct_2.getEntry(0,0));
167
168 }
169
170
171 public void testMisc() {
172 SparseFieldVector<Fraction> v1 = new SparseFieldVector<Fraction>(field,vec1);
173
174 String out1 = v1.toString();
175 assertTrue("some output ", out1.length()!=0);
176 try {
177 v1.checkVectorDimensions(2);
178 fail("IllegalArgumentException expected");
179 } catch (IllegalArgumentException ex) {
180 // expected behavior
181 } catch (Exception e) {
182 fail("wrong exception caught");
183 }
184
185
186 }
187
188 public void testPredicates() {
189
190 SparseFieldVector<Fraction> v = new SparseFieldVector<Fraction>(field, new Fraction[] { new Fraction(0), new Fraction(1), new Fraction(2) });
191
192 v.setEntry(0, field.getZero());
193 assertEquals(v, new SparseFieldVector<Fraction>(field, new Fraction[] { new Fraction(0), new Fraction(1), new Fraction(2) }));
194 assertNotSame(v, new SparseFieldVector<Fraction>(field, new Fraction[] { new Fraction(0), new Fraction(1), new Fraction(2), new Fraction(3) }));
195
196 }
197
198 /** verifies that two vectors are close (sup norm) */
199 protected void assertEquals(String msg, Fraction[] m, Fraction[] n) {
200 if (m.length != n.length) {
201 fail("vectors have different lengths");
202 }
203 for (int i = 0; i < m.length; i++) {
204 assertEquals(msg + " " + i + " elements differ", m[i],n[i]);
205 }
206 }
207
208 /** verifies that two vectors are close (sup norm) */
209 protected void assertClose(String msg, Fraction[] m, Fraction[] n, double tolerance) {
210 if (m.length != n.length) {
211 fail("vectors have different lengths");
212 }
213 for (int i = 0; i < m.length; i++) {
214 assertEquals(msg + " " + i + " elements differ", m[i].doubleValue(),n[i].doubleValue(), tolerance);
215 }
216 }
217
218 }