├── .gitignore
├── LICENSE
├── README.md
├── pom.xml
└── src
    ├── main
        └── java
        │   └── org
        │       └── orangepalantir
        │           ├── filters
        │               └── SavitzyGolayFilter.java
        │           └── leastsquares
        │               ├── Fitter.java
        │               ├── Function.java
        │               ├── examples
        │                   └── ParabolaExample.java
        │               ├── fitters
        │                   ├── LinearFitter.java
        │                   ├── MarquardtFitter.java
        │                   └── NonLinearSolver.java
        │               └── functions
        │                   ├── ExponentialFunction.java
        │                   └── LinearFunction.java
    └── test
        └── java
            └── org
                └── orangepalantir
                    └── leastsquares
                        └── fitters
                            ├── LinearFitterTest.java
                            ├── NonLinearSolverTest.java
                            └── NonLinearTrigonometricSolver.java


/.gitignore:
--------------------------------------------------------------------------------
 1 | # IntelliJ
 2 | .idea/
 3 | *.iws
 4 | *.iml
 5 | *.ipr
 6 | *.ips
 7 | .idea/
 8 | 
 9 | 
10 | # Eclipse
11 | .settings/
12 | .metadata/
13 | .classpath
14 | .project
15 | 
16 | # Generated
17 | target/
18 | javadoc/
19 | bin/
20 | log/
21 | 
22 | # Misc.
23 | .DS_Store
24 | *.bak
25 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 odinsbane
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | least-squares-in-java
 2 | =====================
 3 | 
 4 | Java Least Squares fitting library.
 5 | -----------------------------------
 6 | 
 7 | This is a small least squares fitting library made in java.
 8 | It was originally used in the development of an image analysis tool 
 9 | SpeckleTrackerJ. http://athena.physics.lehigh.edu/speckletrackerj/ It uses
10 | methods described in "Numerical Recipes in C", Second Edition (1992).
11 | 
12 | The outline of using this library is you have a set of data that you
13 | would like fit a function to. Define the Function, how it evaluates
14 | the input and paramters. Create a Fitter (three types currently) initialized
15 | to the function. Set the fitter with the data and make an initial guess of the
16 | parameters. Tell the fitter to find the best set of parameters which minimizes the
17 | sum of squares of error.
18 | 
19 | Example
20 | -------
21 | 
22 | Lets say we have some data.
23 | 
24 |     double[][] xs = {
25 |         {0}, {1}, {2}, {3}, {4}, {5}
26 |     };
27 |     double[] z = {1.1, 0.9, 1.0, 1.35, 1.82, 2.5};
28 | 
29 | And we want to fit a quadratic function f(x) = A*x*x + B*x + C. The parameters are A, B, C and the
30 | input is x. So we have 3 parameters and 1 input.
31 | 
32 |     Function fun = new Function(){
33 |         @Override
34 |         public double evaluate(double[] values, double[] parameters) {
35 |             double A = parameters[0];
36 |             double B = parameters[1];
37 |             double C = parameters[2];
38 |             double x = values[0];
39 |             return A*x*x + B*x + C;
40 |         }
41 |         @Override
42 |         public int getNParameters() {
43 |             return 3;
44 |         }
45 | 
46 |         @Override
47 |         public int getNInputs() {
48 |             return 1;
49 |         }
50 |     };
51 | 
52 | The next step is to create a fitter.
53 | 
54 |     Fitter fit = new LinearFitter(fun);
55 | 
56 | Set the data, and make a guess at the initial parameters.
57 | 
58 |     fit.setData(xs, zs);
59 |     fit.setParameters(new double[]{0,0,0});
60 | 
61 |     fit.fitData();
62 | 
63 | The results can be obtained by using getParameters.
64 | 
65 |     System.out.println(Arrays.toString(fit.getParameters()));
66 |     #[0.10000000000000023, -0.20000000000000123, 1.000000000000001]
67 | 
68 | This example is included in the examples package.
69 | 
70 | 
71 | Fitter implementations
72 | ----------------------
73 | 
74 | LinearFitter: for use with equations that are linearly dependent on the input parameters. Standard
75 | linear regression where derivatives are taken by setting all of the parameters to zero, except for the
76 |  one of interest.
77 | 
78 |  NonLinearSolver: Similar to the LinearSolver, except it will run multiple iterations, there is a damping
79 |   factor, and the derivatives are calculated by taken by varying the parameters a small amount from the
80 |   previous guess.
81 | 
82 |  MarquardtFitter: Similar to the NonLinearSolver except the damping is adaptive.
83 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
  1 | 
  2 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3 | 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4 | 	<modelVersion>4.0.0</modelVersion>
  5 | 
  6 | 	<groupId>org.orangepalantir</groupId>
  7 | 	<artifactId>leastsquares</artifactId>
  8 | 	<version>1.0.1-SNAPSHOT</version>
  9 | 	<packaging>jar</packaging>
 10 | 
 11 | 	<name>Least squares in java.</name>
 12 | 	<url>https://github.com/odinsbane/least-squares-in-java</url>
 13 |     <description>A small library for using least squres fitting in java. Build using the JAMA
 14 | 	matrix library</description>
 15 | 	<licenses>
 16 | 		<license>
 17 | 			<name>The MIT License (MIT)</name>
 18 | 			<url>https://opensource.org/licenses/MIT</url>
 19 | 			<distribution>repo</distribution>
 20 | 		</license>
 21 | 	</licenses>
 22 |     <developers>
 23 |         <developer>
 24 |             <id>odinsbane</id>
 25 |             <name>Matthew Smith</name>
 26 |             <email>melkor@orangepalantir.org</email>
 27 |             <url>https://orangepalantir.org</url>
 28 |             <organization>UCL LMCB</organization>
 29 |             <organizationUrl>http://ucl.ac.uk/lmcb</organizationUrl>
 30 |             <roles>
 31 |                 <role>lead</role>
 32 |                 <role>developer</role>
 33 |                 <role>debugger</role>
 34 |                 <role>reviewer</role>
 35 |                 <role>support</role>
 36 |                 <role>maintainer</role>
 37 |             </roles>
 38 |             <timezone>+1</timezone>
 39 |         </developer>
 40 |     </developers>
 41 |     <scm>
 42 |         <connection>scm:git:git://github.com/odinsbane/least-squares-in-java</connection>
 43 |         <developerConnection>scm:git:git@github.com/odinsbane/least-squares-in-java</developerConnection>
 44 |         <tag>HEAD</tag>
 45 |         <url>https://github.com/odinsbane/least-squares-in-java</url>
 46 |     </scm>
 47 | 	<dependencies>
 48 | 		<dependency>
 49 | 			<groupId>junit</groupId>
 50 | 			<artifactId>junit</artifactId>
 51 | 			<version>4.8.2</version>
 52 | 			<scope>test</scope>
 53 | 		</dependency>
 54 | 		<dependency>
 55 | 			<groupId>gov.nist.math</groupId>
 56 | 			<artifactId>jama</artifactId>
 57 | 			<version>1.0.3</version>
 58 | 			<scope>compile</scope>
 59 | 		</dependency>
 60 | 	</dependencies>
 61 | 
 62 | 	<build>
 63 | 		<plugins>
 64 | 			<!-- Ensure compilation is done under Java 6 in all environments -->
 65 | 			<plugin>
 66 | 				<groupId>org.apache.maven.plugins</groupId>
 67 | 				<artifactId>maven-compiler-plugin</artifactId>
 68 | 				<version>3.5.1</version>
 69 | 				<configuration>
 70 | 					<source>1.6</source>
 71 | 					<target>1.6</target>
 72 | 					<showDeprecation>true</showDeprecation>
 73 | 					<showWarnings>true</showWarnings>
 74 | 				</configuration>
 75 | 			</plugin>
 76 | 			<!-- Generates a source code JAR during package -->
 77 | 			<plugin>
 78 | 				<groupId>org.apache.maven.plugins</groupId>
 79 | 				<artifactId>maven-source-plugin</artifactId>
 80 | 				<version>3.0.0</version>
 81 | 				<executions>
 82 | 					<execution>
 83 | 						<id>attach-sources</id>
 84 | 						<goals>
 85 | 							<goal>jar</goal>
 86 | 						</goals>
 87 | 					</execution>
 88 | 				</executions>
 89 | 			</plugin>
 90 | 			<!-- Generates JavaDocs during package -->
 91 | 			<plugin>
 92 | 				<groupId>org.apache.maven.plugins</groupId>
 93 | 				<artifactId>maven-javadoc-plugin</artifactId>
 94 | 				<version>2.10.3</version>
 95 | 				<executions>
 96 | 					<execution>
 97 | 						<id>attach-javadocs</id>
 98 | 						<goals>
 99 | 							<goal>jar</goal>
100 | 						</goals>
101 | 						<configuration>
102 | 							<additionalparam>-Xdoclint:none</additionalparam>
103 | 						</configuration>
104 | 					</execution>
105 | 				</executions>
106 | 			</plugin>
107 | 		</plugins>
108 | 	</build>
109 | </project>
110 | 


--------------------------------------------------------------------------------
/src/main/java/org/orangepalantir/filters/SavitzyGolayFilter.java:
--------------------------------------------------------------------------------
  1 | package org.orangepalantir.filters;
  2 | import Jama.LUDecomposition;
  3 | import Jama.Matrix;
  4 | 
  5 | /** Class implements the Savitzy-Golay filter.  The algorithm is based on
  6 |  * the algorithm used in 
  7 |  *
  8 |  * Numerical Methods in C: The art of scientific computing second edition
  9 |  *
 10 |  * This filter is used for smoothing data.  The current implementation is
 11 |  * a 1-d approach and a symmetric 2-d approach.
 12 |  *
 13 |  *
 14 |  *     @Author: Matthew B. Smith
 15 |  *     @Url: http://orangepalantir.org
 16 |  *     @Version: 0.8
 17 |  *     @Date: 2/10/2010
 18 |  *
 19 |  **/
 20 | public class SavitzyGolayFilter{
 21 |     double[] coefficients;
 22 |     int LEFT, RIGHT, ORDER;
 23 |     /**
 24 |      * Prepares the filter coefficients
 25 |      *
 26 |      * @param left number of places to the left of the origion
 27 |      * @param right number of places to the right of the origion
 28 |      * @param order of polynomial used to fit data
 29 |      * */
 30 |     public SavitzyGolayFilter(int left, int right, int order){
 31 | 
 32 |         coefficients = SavitzkyGolayCoefficients(left,right,order);
 33 |         LEFT = left;
 34 |         RIGHT = right;
 35 |         ORDER = order;
 36 |     }
 37 | 
 38 |     /**
 39 |      * Prepares the filter coefficients
 40 |      *
 41 |      * @param left number of places to the left of the origion
 42 |      * @param right number of places to the right of the origion
 43 |      * @param order of polynomial used to fit data
 44 |      * @param derivative use a SavitzkyGolayFilter to calculate the derivative or order.
 45 |      * */
 46 |     public SavitzyGolayFilter(int left, int right, int order, int derivative){
 47 | 
 48 |         coefficients = SavitzkyGolayCoefficients(left,right,order, derivative);
 49 |         LEFT = left;
 50 |         RIGHT = right;
 51 |         ORDER = order;
 52 |     }
 53 | 
 54 | 
 55 |     /**
 56 |      * filters the data by assuming the ends are reflected.
 57 |      *
 58 |      * @param data the array that is going to be filtered.
 59 |      * */
 60 |     public double[] filterData(double[] data){
 61 |         int pts = data.length;
 62 |         double[] ret_value = new double[pts];
 63 | 
 64 |         int j;
 65 |         //reflected
 66 |         for(j = 0; j<LEFT; j++)
 67 |             ret_value[j] = rFilter(data, coefficients, j, LEFT);
 68 | 
 69 | 
 70 |         //normal
 71 |         for(j = LEFT; j<pts - RIGHT; j++)
 72 |             ret_value[j] = filter(data, coefficients, j, LEFT);
 73 | 
 74 | 
 75 |         //reflected
 76 |         for(j = pts - RIGHT; j<pts; j++)
 77 |             ret_value[j] = rFilter(data, coefficients, j, LEFT);
 78 | 
 79 |         return ret_value;
 80 |     }
 81 |     /**
 82 |      * filters the data by assuming the ends are reflected.
 83 |      *
 84 |      * @param data
 85 |      * */
 86 |     public float[] filterData(float[] data){
 87 |         int pts = data.length;
 88 |         float[] ret_value = new float[pts];
 89 | 
 90 |         int j;
 91 |         //reflected
 92 |         for(j = 0; j<LEFT; j++)
 93 |             ret_value[j] = (float)rFilter(data, coefficients, j, LEFT);
 94 | 
 95 | 
 96 |         //normal
 97 |         for(j = LEFT; j<pts - RIGHT; j++)
 98 |             ret_value[j] = filter(data, coefficients, j, LEFT);
 99 | 
100 | 
101 |         //reflected
102 |         for(j = pts - RIGHT; j<pts; j++)
103 |             ret_value[j] = (float)rFilter(data, coefficients, j, LEFT);
104 | 
105 |         return ret_value;
106 |     }
107 | 
108 |     /**
109 |      *  Calculates one point in the data, similar to one step of a
110 |      *  convolution.
111 |      *
112 |      * @param o - data that will be convolved
113 |      * @param mask - kernel
114 |      * @param start - position of the 'middle point' on the data
115 |      * @param middle - postion of the center of the kernel on the kernel
116 |      *
117 |      * */
118 |     public float filter(float[] o, double[] mask, int start, int middle){
119 |         float out = 0;
120 |         for(int i = 0; i<mask.length; i++)
121 |             out += (float)mask[i]*o[start - middle + i];
122 | 
123 |         return out;
124 | 
125 |     }
126 | 
127 |     /**
128 |      *  Calculates one point in the data, similar to one step of a
129 |      *  convolution.
130 |      *
131 |      * @param o - data that will be convolved
132 |      * @param mask - kernel
133 |      * @param start - position of the 'middle point' on the data
134 |      * @param middle - postion of the center of the kernel on the kernel
135 |      *
136 |      * */
137 |     public double filter(double[] o, double[] mask, int start, int middle){
138 |         double out = 0;
139 |         for(int i = 0; i<mask.length; i++)
140 |             out += mask[i]*o[start - middle + i];
141 | 
142 |         return out;
143 | 
144 |     }
145 | 
146 |     /**
147 |      *  Calculates one point in the data, similar to one step of a
148 |      *  convolution.  This one will wrap the ends of the mask.  Something
149 |      *  like a convolution with reflected boundary conditions.
150 |      *
151 |      * @param o - data that will be convolved
152 |      * @param mask - kernel
153 |      * @param start - position of the 'middle point' on the data
154 |      * @param middle - postion of the center of the kernel on the kernel
155 |      *
156 |      * */
157 |     public double rFilter(double[] o, double[] mask, int start, int middle){
158 |         double out = 0;
159 |         int dex;
160 |         for(int i = 0; i<mask.length; i++){
161 |             dex = Math.abs(start - middle + 1 +i);
162 |             dex = (dex<o.length)?dex: 2*o.length - dex - 1;
163 |             out += mask[i]*o[dex];
164 |         }
165 | 
166 |         return out;
167 | 
168 |     }
169 | 
170 |     /**
171 |      *  Calculates one point in the data, similar to one step of a
172 |      *  convolution.  This one will wrap the ends of the mask.  Something
173 |      *  like a convolution with reflected boundary conditions.
174 |      *
175 |      * @param o - data that will be convolved
176 |      * @param mask - kernel
177 |      * @param start - position of the 'middle point' on the data
178 |      * @param middle - postion of the center of the kernel on the kernel
179 |      *
180 |      * */
181 |     public float rFilter(float[] o, double[] mask, int start, int middle){
182 |         double out = 0;
183 |         int dex;
184 |         for(int i = 0; i<mask.length; i++){
185 |             dex = Math.abs(start - middle + 1 +i);
186 |             dex = (dex<o.length)?dex: 2*o.length - dex - 1;
187 |             out += mask[i]*o[dex];
188 |         }
189 | 
190 |         return (float)out;
191 | 
192 |     }
193 | 
194 |     /**
195 |      *
196 |      *   Creates the array of coefficients for using a least squares polynomial fit
197 |      *   of the data.  Due to the fact the points are equally spaced
198 |      *   and the polynomial least squares is linear in the coefficients,
199 |      *   a set of coefficients can be used for every element.
200 |      *
201 |      *   @param nl - spaces to the left
202 |      *   @param nr - spaces to the right
203 |      *   @param order - the order of the polynomial being used, not that nl+nr+1 must be more than the order of the polynomial
204 |      *   @return a 'time kernel' for convolving in time.
205 |      * */
206 | 
207 | 
208 |     public static double[] SavitzkyGolayCoefficients(int nl, int nr, int order){
209 |         if( nl + nr + 1<= order)
210 |             throw new java.lang.IllegalArgumentException(" The order of polynomial cannot exceed the number of points being used." +
211 |                     "If they are equal the input equals the output.");
212 |         int N = nr + nl + 1;
213 |         double[] ret_values = new double[N];
214 |         double[] xvalues = new double[N];
215 |         for(int i = 0; i<N; i++){
216 | 
217 |             xvalues[i] = -nl + i;
218 | 
219 |         }
220 | 
221 |         int counts = 2*order+1;
222 |         double[] moments = new double[counts];
223 |         for(int i = 0; i<counts; i++){
224 |             for(int j = 0; j<N; j++){
225 | 
226 |                 moments[i] += Math.pow(xvalues[j],i);
227 | 
228 |             }
229 | 
230 |             moments[i] = moments[i]/N;
231 |         }
232 | 
233 | 
234 | 
235 |         double[][] matrix = new double[order+1][order+1];
236 | 
237 |         for(int i = 0; i<order+1; i++){
238 |             for(int j = 0; j<order+1; j++){
239 |                 matrix[i][j] = moments[counts - i - j - 1];
240 |             }
241 |             System.out.println("");
242 |         }
243 | 
244 |         Matrix A = new Matrix(matrix);
245 | 
246 |         LUDecomposition lu = A.lu();
247 | 
248 |         Matrix x = new Matrix(new double[order+1],order+1);
249 |         Matrix y;
250 |         double[] polynomial;
251 | 
252 |         for(int i = 0; i<N; i++){
253 | 
254 |             for(int j = 0; j<order+1; j++)
255 |                 x.set( j , 0, Math.pow(xvalues[i],order - j));
256 | 
257 |             y = lu.solve(x);
258 | 
259 |             polynomial = y.getColumnPackedCopy();
260 |             ret_values[i] = evaluatePolynomial(polynomial, xvalues[nl])/N;
261 |         }
262 | 
263 | 
264 |         return ret_values;
265 | 
266 |     }
267 | 
268 |     /**
269 |      *
270 |      *   Creates the array of coefficients for using a least squares polynomial fit
271 |      *   of the data.  Due to the fact the points are equally spaced
272 |      *   and the polynomial least squares is linear in the coefficients,
273 |      *   a set of coefficients can be used for every element.
274 |      *
275 |      *   @param nl - spaces to the left
276 |      *   @param nr - spaces to the right
277 |      *   @param order - the order of the polynomial being used, not that nl+nr+1 must be more than the order of the polynomial
278 |      *   @param derivative - returns a set of derivative coefficients
279 |      * */
280 | 
281 | 
282 |     public static double[] SavitzkyGolayCoefficients(int nl, int nr, int order, int derivative){
283 |         if( nl + nr + 1<= order)
284 |             throw new java.lang.IllegalArgumentException(" The order of polynomial cannot exceed the number of points being used." +
285 |                     "If they are equal the input equals the output.");
286 |         int N = nr + nl + 1;
287 |         double[] ret_values = new double[N];
288 |         double[] xvalues = new double[N];
289 |         for(int i = 0; i<N; i++){
290 | 
291 |             xvalues[i] = -nl + i;
292 | 
293 |         }
294 | 
295 |         int counts = 2*order+1;
296 |         double[] moments = new double[counts];
297 |         for(int i = 0; i<counts; i++){
298 |             for(int j = 0; j<N; j++){
299 | 
300 |                 moments[i] += Math.pow(xvalues[j],i);
301 | 
302 |             }
303 | 
304 |             moments[i] = moments[i]/N;
305 |         }
306 | 
307 | 
308 | 
309 |         double[][] matrix = new double[order+1][order+1];
310 | 
311 |         for(int i = 0; i<order+1; i++){
312 |             for(int j = 0; j<order+1; j++){
313 |                 matrix[i][j] = moments[counts - i - j - 1];
314 |             }
315 |             System.out.println("");
316 |         }
317 | 
318 |         Matrix A = new Matrix(matrix);
319 | 
320 |         LUDecomposition lu = A.lu();
321 | 
322 |         Matrix x = new Matrix(new double[order+1],order+1);
323 |         Matrix y;
324 |         double[] polynomial;
325 | 
326 |         for(int i = 0; i<N; i++){
327 | 
328 |             for(int j = 0; j<order+1; j++)
329 |                 x.set( j , 0, Math.pow(xvalues[i],order - j));
330 | 
331 |             y = lu.solve(x);
332 | 
333 |             polynomial = y.getColumnPackedCopy();
334 |             ret_values[i] = evaluatePolynomial(polynomial, xvalues[nl], derivative)/N;
335 |         }
336 | 
337 | 
338 |         return ret_values;
339 | 
340 |     }
341 |     /**
342 |      * Creates a 2-d Kernel for using a savitzky-golay filter in 2-d.
343 |      * It fits a 2-d polynomial to the data set if the order was 2.
344 |      *
345 |      * f(x) = a*x**2 + b*x + c*x*y + d*y + e*y**2 + f
346 |      *
347 |      * It is solved by least squares fiting '1' functions to polynomials
348 |      * to 2-d polynomials, then these 1 functions can be summed as a linear
349 |      * sum to create a 2d kernel.
350 |      *
351 |      * The kernel is a symmetric square kernel
352 |      *
353 |      *
354 |      * @param size is the halfwidth of the kernel.
355 |      * @param order is the order of polynomial being fit.
356 |      * */
357 |     public static double[][] getKernel(int size, int order){
358 |         int N = 2*size+1;
359 |         double[][] xyvalues = new double[N][2];
360 | 
361 |         for(int i = 0; i<N; i++){
362 |             xyvalues[i][0] = i - size;
363 |             xyvalues[i][1] = i - size;
364 |         }
365 |         int M = 0;
366 |         for(int i = 1; i<=order+1; i++)
367 |             M += i;
368 | 
369 |         double[][] matrix = new double[M][M];
370 |         int pqdex = 0;
371 |         int mndex = 0;
372 |         //the coefficients for a_(pq) for the _XX_ equation
373 |         for(int p = 0; p<=order; p++){
374 |             for(int q = 0; q <= (order - p); q++){
375 | 
376 |                 mndex = 0;
377 |                 for(int m = 0; m<=order; m++){
378 |                     for(int n = 0; n<=order-m; n++){
379 | 
380 |                         double sum = 0;
381 |                         for(int i = 0; i<N; i++){
382 |                             for(int j = 0; j<N; j++){
383 |                                 sum += Math.pow(xyvalues[i][0], p + m)*Math.pow(xyvalues[j][1], q + n);
384 | 
385 |                             }
386 | 
387 |                         }
388 | 
389 |                         matrix[pqdex][mndex] = sum;
390 |                         mndex++;
391 |                     }
392 |                 }
393 |                 pqdex++;
394 |             }
395 |         }
396 | 
397 |         Matrix mat = new Matrix(matrix);
398 |         LUDecomposition lud = mat.lu();
399 | 
400 | 
401 |         //now we want to solve all of the different functions to get our kernel
402 |         double[][] kernel = new double[N][N];
403 |         for(int i = 0; i<N; i++){
404 |             for(int j = 0; j<N; j++){
405 | 
406 |                 double[] equals = new double[M];
407 | 
408 |                 int xp = 0;
409 |                 int yp = 0;
410 | 
411 |                 for(int k = 0; k<M; k++){
412 | 
413 |                     equals[k] = Math.pow(xyvalues[i][0], xp)*Math.pow(xyvalues[j][1],yp);
414 |                     yp++;
415 |                     if(yp>order - xp){
416 | 
417 |                         yp = 0;
418 |                         xp++;
419 | 
420 |                     }
421 |                 }
422 | 
423 | 
424 | 
425 |                 Matrix rs = new Matrix(equals, M);
426 |                 Matrix ls = lud.solve(rs);
427 | 
428 | 
429 |                 //evaluate 2-d function;
430 |                 double sum = 0;
431 | 
432 |                 xp = 0;
433 |                 yp = 0;
434 | 
435 |                 for(int k = 0; k<M; k++){
436 | 
437 |                     sum += ls.get(k,0)*Math.pow(xyvalues[size][0], xp)*Math.pow(xyvalues[size][1],yp);
438 | 
439 | 
440 |                     yp++;
441 |                     if(yp>order - xp){
442 | 
443 |                         yp = 0;
444 |                         xp++;
445 | 
446 |                     }
447 |                 }
448 | 
449 |                 kernel[j][i] = sum;
450 |             }
451 | 
452 |         }
453 | 
454 |         return kernel;
455 |     }
456 | 
457 |     /**
458 |      *      Evaluates a polynomial where:
459 |      *      p(x) = poly[0] * x**m + poly[1] * x**(m-1) + ... + poly[m]
460 |      *
461 |      *  @param poly - double array representation of a polynomial
462 |      *  @param x - the variable that will be evaluated.
463 |      **/
464 |     public static double evaluatePolynomial(double[] poly, double x){
465 | 
466 |         double val = 0;
467 |         int m = poly.length;
468 |         for(int j = 0; j<m; j++){
469 |             val += Math.pow(x,m-j-1)*poly[j];
470 |         }
471 |         return val;
472 |     }
473 | 
474 |     /**
475 |      *      Evaluates derivative of polynomial where with:
476 |      *      p(x) = poly[0] * x**m + poly[1] * x**(m-1) + ... + poly[m]
477 |      *
478 |      *  @param poly - double array representation of a polynomial
479 |      *  @param x - the variable that will be evaluated.
480 |      *  @param order - the order of the derivative. (n in description)
481 |      *  @return m*(m-1)*...(m - n)*poly[0]*x**(m-n) + (m-1)*...(m - n - 1)*poly[1] * x**(m-2) ... + n!*poly[m - n]
482 |      **/
483 |     public static double evaluatePolynomial(double[] poly, double x, int order){
484 | 
485 |         double val = 0;
486 |         int m = poly.length;
487 |         for(int j = 0; j<m-order; j++){
488 |             int pow = m - j - 1; //original power before derivatives
489 |             val += Math.pow(x,pow - order)*poly[j]*pfact(pow,order);
490 |         }
491 |         return val;
492 |     }
493 | 
494 |     /**
495 |      * Partial factorial,
496 |      * @param m power of x
497 |      * @param n number of derivatives
498 |      *
499 |      * @return m*(m-1)*...(m - n)
500 |      */
501 |     public static double pfact(int m, int n){
502 |         int p = 1;
503 |         for(int i = 0; i<n; i++){
504 |             p*=(m - i);
505 |         }
506 |         return p;
507 |     }
508 | }
509 | 
510 | 


--------------------------------------------------------------------------------
/src/main/java/org/orangepalantir/leastsquares/Fitter.java:
--------------------------------------------------------------------------------
 1 | package org.orangepalantir.leastsquares;
 2 | 
 3 | public interface Fitter {
 4 |     
 5 |     public void setData(double[][] xvalues, double[] zvalues);
 6 |     public void setParameters(double[] parameters);
 7 |     public double[] getParameters();
 8 |     public double[] getUncertainty();
 9 |     public void fitData();
10 |     public double calculateErrors();
11 | }
12 | 


--------------------------------------------------------------------------------
/src/main/java/org/orangepalantir/leastsquares/Function.java:
--------------------------------------------------------------------------------
 1 | package org.orangepalantir.leastsquares;
 2 | 
 3 | public interface Function{
 4 |     /**
 5 |      *      Returns the functions evaluated at the specific parameter set
 6 |      * @return needs to evaluate the function
 7 |      * */
 8 |     public double evaluate(double[] values, double[] parameters);
 9 |     public int getNParameters();
10 |     public int getNInputs();
11 |     
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/src/main/java/org/orangepalantir/leastsquares/examples/ParabolaExample.java:
--------------------------------------------------------------------------------
 1 | package org.orangepalantir.leastsquares.examples;
 2 | 
 3 | import org.orangepalantir.leastsquares.Fitter;
 4 | import org.orangepalantir.leastsquares.Function;
 5 | import org.orangepalantir.leastsquares.fitters.LinearFitter;
 6 | 
 7 | import java.util.Arrays;
 8 | 
 9 | /**
10 |  * Created by msmith on 3/7/16.
11 |  */
12 | public class ParabolaExample {
13 | 
14 |     public static void main(String[] args){
15 |         double[][] xs = {
16 |                 {0}, {1}, {2}, {3}, {4}, {5}
17 |         };
18 |         double[] zs = {1.0, 0.9, 1.0, 1.3, 1.8, 2.5};
19 | 
20 |         Function fun = new Function(){
21 |             @Override
22 |             public double evaluate(double[] values, double[] parameters) {
23 |                 double A = parameters[0];
24 |                 double B = parameters[1];
25 |                 double C = parameters[2];
26 |                 double x = values[0];
27 |                 return A*x*x + B*x + C;
28 |             }
29 |             @Override
30 |             public int getNParameters() {
31 |                 return 3;
32 |             }
33 | 
34 |             @Override
35 |             public int getNInputs() {
36 |                 return 1;
37 |             }
38 |         };
39 | 
40 |         Fitter fit = new LinearFitter(fun);
41 |         fit.setData(xs, zs);
42 |         fit.setParameters(new double[]{0,0,0});
43 | 
44 |         fit.fitData();
45 | 
46 |         System.out.println(Arrays.toString(fit.getParameters()));
47 |     }
48 | 
49 | }
50 | 


--------------------------------------------------------------------------------
/src/main/java/org/orangepalantir/leastsquares/fitters/LinearFitter.java:
--------------------------------------------------------------------------------
  1 | package org.orangepalantir.leastsquares.fitters;
  2 | 
  3 | import org.orangepalantir.leastsquares.Fitter;
  4 | import Jama.Matrix;
  5 | import org.orangepalantir.leastsquares.Function;
  6 | 
  7 | /**
  8 |  * for solving linear least squares fit of f(x:A) = z with sets of x,z data points.
  9 |   * derivatives are evaluated numerically and the function is assumed to be linear in A.
 10 |   * Then a linear least squares fit is performed.
 11 |  * */
 12 | public class LinearFitter implements Fitter {
 13 |     private final double[] working;
 14 | 
 15 |     double[][] X;    //values
 16 |     double[]   A,    //Parameter Set
 17 |                Z;    //output vaues
 18 | 
 19 |     Function FUNCTION;
 20 |     double[] ERROR;
 21 | 
 22 |     double[][] DERIVATIVES;
 23 |     double[] BETA;
 24 |     double[][] ALPHA;
 25 |     double DELTA = 0.000001;   //used for calculating derivatives
 26 | 
 27 |     public LinearFitter(Function funct){
 28 |         FUNCTION=funct;
 29 |         working = new double[funct.getNParameters()];
 30 |     }
 31 | 
 32 | 
 33 |     /**
 34 |      *      Sets the values of of the original data points that are going to be fit.
 35 |      * */
 36 |     public void setData(double[][] xvalues, double[] zvalues){
 37 | 
 38 |         if(xvalues.length != zvalues.length)
 39 |             throw new IllegalArgumentException("there must be 1 z value for each set of x values");
 40 |         else if(xvalues[0].length != FUNCTION.getNInputs())
 41 |             throw new IllegalArgumentException("The length of parameters is longer that the parameters accepted by the function");
 42 |         X = xvalues;
 43 |         Z = zvalues;
 44 | 
 45 |     }
 46 | 
 47 |     /**
 48 |      *
 49 |      * */
 50 |     public void setParameters(double[] parameters){
 51 |         if(parameters.length != FUNCTION.getNParameters())
 52 |             throw new IllegalArgumentException("the number of parameters must equal the required number for the function: " + FUNCTION.getNParameters());
 53 |         A = new double[parameters.length];
 54 |         System.arraycopy(parameters,0,A,0,parameters.length);
 55 |     }
 56 | 
 57 |      /**
 58 |       *     returns the cumulative error for current values
 59 |       **/
 60 |     public double calculateErrors(){
 61 |         double new_error = 0;
 62 |         for(int i = 0; i<Z.length; i++){
 63 | 
 64 |             double v = FUNCTION.evaluate(X[i],A);
 65 |             ERROR[i] = Z[i] - v;
 66 |             new_error += Math.pow(ERROR[i],2);
 67 |         }
 68 |         return new_error;
 69 | 
 70 |     }
 71 | 
 72 |     /**
 73 |      *  Given a set of parameters, and inputs, calculates the derivative
 74 |      *  of the k'th parameter
 75 |      *  d/d a_k (F)
 76 |      *
 77 |      *  The function is linear in parameters eg:
 78 |      *  f(x) = params[0]* f0(x) + params[1]*f1(x) + ...
 79 |      *
 80 |      *  So the derivative k is fk(x) or the function evaluated when all of the parameters
 81 |      *  are zero except for the k'th parameter which is 1.
 82 |      *
 83 |      *
 84 |      * @param k - index of the parameter that the derivative is being taken of
 85 |      * @param x - set of values to use.
 86 |      * @return derivative of function
 87 |      **/
 88 |     public double calculateDerivative(int k, double[] x){
 89 |         for(int i = 0; i<FUNCTION.getNParameters(); i++){
 90 |             working[i] = i==k?1:0;
 91 |         }
 92 |         return FUNCTION.evaluate(x, working);
 93 | 
 94 |     }
 95 | 
 96 |     /**
 97 |      *  Creates an array of derivatives since each one is used 3x's
 98 |      **/
 99 |     public void calculateDerivatives(){
100 |         for(int j = 0; j<A.length; j++){
101 |             for(int i = 0; i<Z.length; i++){
102 |                 DERIVATIVES[i][j] = calculateDerivative(j, X[i]);
103 |             }
104 |         }
105 |     }
106 | 
107 | 
108 |     public void createBetaMatrix(){
109 |         BETA = new double[A.length];
110 | 
111 |         for(int k = 0; k<BETA.length; k++){
112 |             for(int i = 0; i<X.length; i++){
113 | 
114 |                 BETA[k] += ERROR[i]*DERIVATIVES[i][k];
115 | 
116 |             }
117 |         }
118 | 
119 |     }
120 | 
121 |     public void createAlphaMatrix(){
122 |         ALPHA = new double[A.length][A.length];
123 | 
124 |         int n = A.length;
125 |         for(int k = 0; k<n; k++){
126 |             for(int l = 0; l<n; l++){
127 | 
128 |                     for(int i = 0; i<X.length; i++)
129 |                         ALPHA[l][k] += DERIVATIVES[i][k] * DERIVATIVES[i][l];
130 | 
131 |             }
132 | 
133 |         }
134 | 
135 | 
136 | 
137 |     }
138 | 
139 |     /**
140 |      *  Takes the current error, and the current parameter set and calculates the
141 |      *  changes, then returns the maximum changed value
142 |      * */
143 |     public void iterateValues(){
144 |         calculateErrors();
145 |         calculateDerivatives();
146 | 
147 |         createBetaMatrix();
148 |         createAlphaMatrix();
149 | 
150 |         Matrix alpha_matrix = new Matrix(ALPHA);
151 |         Matrix beta = new Matrix(BETA, BETA.length);
152 |         
153 |         Matrix out = alpha_matrix.solve(beta);
154 | 
155 |         double[][] delta_a = out.getArray();
156 | 
157 |         for(int i = 0; i<A.length; i++)
158 |             A[i] += delta_a[i][0];
159 | 
160 |     }
161 | 
162 |     public void printMatrix(){
163 |         for(int i = 0; i<ALPHA.length; i++){
164 |             for(int j = 0; j<ALPHA[0].length; j++){
165 |                 System.out.print(ALPHA[i][j] + "\t");
166 | 
167 |             }
168 | 
169 |             System.out.println("| " + BETA[i] );
170 |         }
171 |     }
172 | 
173 |     public void initializeWorkspace(){
174 |         ERROR = new double[Z.length];
175 |         DERIVATIVES = new double[Z.length][A.length];
176 |     }
177 | 
178 |     /**
179 |      *  Main routine, call this and the Parameters are iterated one time because
180 |      *  the equations are assumed to be linear in parameter space.
181 |      * */
182 |     public void fitData(){
183 |         initializeWorkspace();
184 | 
185 |         try{
186 |           iterateValues();
187 |         } catch(Exception exc){
188 |             printMatrix();
189 |             exc.printStackTrace();
190 |             throw new RuntimeException(exc);
191 |          }
192 | 
193 |     }
194 | 
195 | 
196 |     /**
197 |      *      Gets the current set of parameters values.
198 |      * */
199 |     public double[] getParameters(){
200 |         return A;
201 |     }
202 | 
203 |     /**
204 |      * Get an uncertainty value, similar to the way gnuplot does it.
205 |      * Essentially the diagonals of the covariance matrix.
206 |      * @return array of length of the parameters.
207 |      */
208 |     @Override
209 |     public double[] getUncertainty() {
210 | 
211 |         Matrix a_matrix = new Matrix(ALPHA);
212 |         Matrix b = a_matrix.inverse();
213 | 
214 |         double[] residuals = new double[A.length];
215 |         double error = calculateErrors()/Z.length;
216 | 
217 |         for(int i = 0; i<A.length; i++){
218 |             residuals[i] = Math.sqrt(b.get(i,i)*error);
219 |         }
220 |         return residuals;
221 |     }
222 | 
223 |     /**
224 |      *
225 |      */
226 |     public double[][] getCovarianceMatrix(){
227 |         Matrix a_matrix = new Matrix(ALPHA);
228 |         Matrix b = a_matrix.inverse();
229 | 
230 |         double error = calculateErrors()/Z.length;
231 |         double[][] ret = new double[A.length][A.length];
232 | 
233 |         for(int i = 0; i<A.length; i++){
234 |             for(int j = 0; j<A.length; j++){
235 |                 ret[i][j] = b.get(i,j)*error;
236 |             }
237 |         }
238 |         return ret;
239 |     }
240 | }


--------------------------------------------------------------------------------
/src/main/java/org/orangepalantir/leastsquares/fitters/MarquardtFitter.java:
--------------------------------------------------------------------------------
  1 | package org.orangepalantir.leastsquares.fitters;
  2 | 
  3 | import org.orangepalantir.leastsquares.Fitter;
  4 | 
  5 | import Jama.Matrix;
  6 | import org.orangepalantir.leastsquares.Function;
  7 | 
  8 | public class MarquardtFitter implements Fitter {
  9 |     /**
 10 |      * for solving non-linear least squares fit of f(x:A) = z with sets of x,z data points.
 11 |      * */
 12 |     double[][] X;    //values
 13 |     double[]   A,    //Parameter Set
 14 |                Z;    //output vaues
 15 | 
 16 |     Function FUNCTION;
 17 |     double[] ERROR;
 18 | 
 19 |     double[][] DERIVATIVES;
 20 |     double[][] ALPHA_PRIME;
 21 |     double[] LAMBDA;
 22 |     double[] BETA;
 23 | 
 24 |     double DELTA = 0.000001;   //used for calculating derivatives
 25 |     double MINERROR = 1e-9; //for evaluating
 26 |     double MINCHANGE = 1e-3;    //minimumchanges
 27 | 
 28 |     public int ITERATIONS = 0;
 29 |     public MarquardtFitter(Function funct){
 30 | 
 31 |         FUNCTION=funct;
 32 | 
 33 |     }
 34 |     /**
 35 |      *      Sets the values of of the original data points that are going to be fit.
 36 |      * */
 37 |     public void setData(double[][] xvalues, double[] zvalues){
 38 | 
 39 |         if(xvalues.length != zvalues.length)
 40 |             throw new IllegalArgumentException("there must be 1 z value for each set of x values");
 41 |         else if(xvalues[0].length != FUNCTION.getNInputs())
 42 |             throw new IllegalArgumentException("The length of parameters is longer that the parameters accepted by the function");
 43 |         X = xvalues;
 44 |         Z = zvalues;
 45 | 
 46 |     }
 47 | 
 48 |     /**
 49 |      *
 50 |      * */
 51 |     public void setParameters(double[] parameters){
 52 |         if(parameters.length != FUNCTION.getNParameters())
 53 |             throw new IllegalArgumentException("the number of parameters must equal the required number for the function: " + FUNCTION.getNParameters());
 54 |         A = new double[parameters.length];
 55 |         System.arraycopy(parameters,0,A,0,parameters.length);
 56 |     }
 57 |     /**
 58 |       *     returns the cumulative error for current values
 59 |       **/
 60 |     public double calculateErrors(){
 61 |         double new_error = 0;
 62 |         for(int i = 0; i<Z.length; i++){
 63 | 
 64 |             double v = FUNCTION.evaluate(X[i],A);
 65 |             ERROR[i] = Z[i] - v;
 66 |             new_error += Math.pow(ERROR[i],2);
 67 |         }
 68 |         return new_error;
 69 | 
 70 |     }
 71 | 
 72 |     /**
 73 |      *  Given a set of parameters, and inputs, calculates the derivative
 74 |      *  of the k'th parameter
 75 |      *  d/d a_k (F)
 76 |      *
 77 |      * @param k - index of the parameter that the derivative is being taken of
 78 |      * @param params - array that will be used to calculate derivatives, note params will be modified.
 79 |      * @param x - set of values to use.
 80 |      * @return derivative of function
 81 |      **/
 82 |     public double calculateDerivative(int k, double[] params, double[] x){
 83 |         double b, a;
 84 | 
 85 |         params[k] -= DELTA;
 86 |         b = FUNCTION.evaluate(x, params);
 87 |         params[k] += 2*DELTA;
 88 |         a = FUNCTION.evaluate(x, params);
 89 |         params[k] -= DELTA;
 90 |         return (a - b)/(2*DELTA);
 91 | 
 92 |     }
 93 | 
 94 |     /**
 95 |      *  Creates an array of derivatives since each one is used 3x's
 96 |      **/
 97 |     public void calculateDerivatives(){
 98 |         double[] working = new double[A.length];
 99 |         System.arraycopy(A,0,working,0,A.length);
100 |         for(int j = 0; j<A.length; j++){
101 | 
102 |             for(int i = 0; i<Z.length; i++){
103 |                 DERIVATIVES[i][j] = calculateDerivative(j, working, X[i]);
104 |             }
105 |         }
106 | 
107 | 
108 |     }
109 | 
110 |     /**
111 |      *
112 |      *  NOT USED.
113 |      *  Given a set of parameters, and inputs, calculates the
114 |      *  second derivatives
115 |      *  d^2/d a_l d a_k (F)
116 |      *
117 |      * @param k - index of the parameter that the derivative is being taken of
118 |      * @param params - array that will be used to calculate derivatives, note params will be modified.
119 |      * @param x - set of values to use.
120 |      **/
121 |     public double calculateSecondDerivative(int l, int k, double[] params, double[] x){
122 |         double b, a;
123 | 
124 |         params[l] -= DELTA;
125 |         b = calculateDerivative(k, params, x);
126 | 
127 |         params[l] += 2*DELTA;
128 |         a = calculateDerivative(k, params, x);
129 | 
130 | 
131 |         params[l] -= DELTA;
132 |         return (a - b)/(2*DELTA);
133 | 
134 |     }
135 | 
136 |     public void createBetaMatrix(){
137 |         BETA = new double[A.length];
138 |         double[] working = new double[A.length];
139 |         System.arraycopy(A,0,working,0,A.length);
140 | 
141 |         for(int k = 0; k<BETA.length; k++){
142 |             for(int i = 0; i<X.length; i++){
143 | 
144 |                 BETA[k] += ERROR[i]*DERIVATIVES[i][k];
145 | 
146 |             }
147 |         }
148 | 
149 |     }
150 | 
151 |     public void createAlphaPrimeMatrix(){
152 |         ALPHA_PRIME = new double[A.length][A.length];
153 | 
154 |         int n = A.length;
155 |         for(int k = 0; k<n; k++){
156 |             for(int l = 0; l<n; l++){
157 | 
158 |                     for(int i = 0; i<X.length; i++)
159 |                         ALPHA_PRIME[l][k] += DERIVATIVES[i][k] * DERIVATIVES[i][l];
160 | 
161 |                     if(k==l)
162 |                         ALPHA_PRIME[l][k] = ALPHA_PRIME[l][k]*(1 + LAMBDA[k]);
163 | 
164 |             }
165 | 
166 |         }
167 | 
168 | 
169 | 
170 |     }
171 | 
172 |     /**
173 |      *  Takes the current error, and the current parameter set and calculates the
174 |      *  changes, then returns the maximum changed value
175 |      * */
176 |     public void iterateValues(){
177 | 
178 |         calculateDerivatives();
179 | 
180 |         createBetaMatrix();
181 |         createAlphaPrimeMatrix();
182 | 
183 |         Matrix alpha_matrix = new Matrix(ALPHA_PRIME);
184 |         Matrix beta = new Matrix(BETA, BETA.length);
185 | 
186 |         Matrix out = alpha_matrix.solve(beta);
187 | 
188 |         double[][] delta_a = out.getArray();
189 | 
190 |         for(int i = 0; i<A.length; i++)
191 |             A[i] += delta_a[i][0];
192 | 
193 | 
194 | 
195 | 
196 |     }
197 | 
198 | 
199 | 
200 |     public void initializeWorkspace(){
201 |         ERROR = new double[Z.length];
202 |         DERIVATIVES = new double[Z.length][A.length];
203 |         LAMBDA = new double[A.length];
204 |         for(int i = 0; i<A.length; i++)
205 |             LAMBDA[i] = 0.01;
206 |     }
207 | 
208 |     /**
209 |      *  Main routine, call this and the Parameters are iterated until it is finished.
210 |      * */
211 |     public void fitData(){
212 |         initializeWorkspace();
213 |         double error = calculateErrors();
214 |         double nerror, value;
215 |         double[] acopy = new double[A.length];
216 | 
217 |         int i;
218 |         for(i = 0; i<10000; i++){
219 | 
220 |             try{
221 |                 System.arraycopy(A,0,acopy,0,A.length);
222 |                 iterateValues();
223 | 
224 |             } catch(Exception exc){
225 |                 System.out.println("Broke after " + i + " iterations");
226 |                 printMatrix();
227 |                 //printMatrix();
228 |                 throw new RuntimeException(exc);
229 |             }
230 | 
231 |             nerror = calculateErrors();
232 | 
233 |             value = error - nerror;
234 | 
235 | 
236 |             if(value<0){
237 | 
238 |                 //reject changes
239 |                 System.arraycopy(acopy, 0, A, 0, acopy.length);
240 |                 updateLambda(value);
241 |                 nerror = calculateErrors();
242 |             } else{
243 | 
244 | 
245 |                 if(value<0.0001){
246 |                     ITERATIONS = i;
247 |                     break;
248 |                 }
249 |             }
250 | 
251 |             error = nerror;
252 |         }
253 | 
254 | 
255 |     }
256 | 
257 |     public void updateLambda(double value){
258 | 
259 |         if(value<0){
260 |             for(int i = 0; i<LAMBDA.length; i++)
261 |                 LAMBDA[i] = LAMBDA[i]*10;
262 | 
263 | 
264 |         } else {
265 | 
266 |             for(int i = 0; i<LAMBDA.length; i++)
267 |                 LAMBDA[i] = LAMBDA[i]*0.1;
268 | 
269 |         }
270 | 
271 | 
272 |     }
273 |     /**
274 |      *      Gets the current set of parameters values.
275 |      * */
276 |     public double[] getParameters(){
277 |         return A;
278 |     }
279 | 
280 |     @Override
281 |     public double[] getUncertainty() {
282 |         return new double[0];
283 |     }
284 | 
285 |     /**
286 |      * for stack traces
287 |      */
288 |     public String printMatrix(){
289 |         String message = "";
290 |         for(int i = 0; i<ALPHA_PRIME.length; i++){
291 |             for(int j = 0; j<ALPHA_PRIME[0].length; j++){
292 |                 message += ALPHA_PRIME[i][j] + "\t";
293 | 
294 |             }
295 | 
296 |             message += "| " + BETA[i] + "\n";
297 |         }
298 |         return message;
299 |     }
300 | 
301 | }


--------------------------------------------------------------------------------
/src/main/java/org/orangepalantir/leastsquares/fitters/NonLinearSolver.java:
--------------------------------------------------------------------------------
  1 | package org.orangepalantir.leastsquares.fitters;
  2 | 
  3 | import org.orangepalantir.leastsquares.Function;
  4 | import org.orangepalantir.leastsquares.Fitter;
  5 | import Jama.LUDecomposition;
  6 | import Jama.Matrix;
  7 | 
  8 | public class NonLinearSolver implements Fitter {
  9 |     /**
 10 |      * Ignores second derivatives, not very good.
 11 |      * for solving non-linear least squares fit of f(x:A) = z with sets of x,z data points.
 12 |      * */
 13 |     double[][] X;    //values
 14 |     double[]   A,    //Parameter Set
 15 |                Z;    //output vaues
 16 |     
 17 |     Function FUNCTION;
 18 |     double[] ERROR;
 19 |     double[][] DERIVATIVES;
 20 | 
 21 |     double DELTA = 0.000001;   //used for calculating derivatives 
 22 |     double MIN_ERROR = 1e-6; //for evaluating
 23 |     double MIN_CHANGE = 1e-6;    //minimumchanges
 24 |     double STEP = 0.1;
 25 |     double MAX_ITERATIONS = 10000;
 26 |     public NonLinearSolver(Function funct){
 27 |         
 28 |         FUNCTION=funct;
 29 |         
 30 |     }
 31 |     /**
 32 |      *      Sets the values of of the original data points that are going to be fit.
 33 |      * */
 34 |     public void setData(double[][] xvalues, double[] zvalues){
 35 |         
 36 |         if(xvalues.length != zvalues.length)
 37 |             throw new IllegalArgumentException("there must be 1 z value for each set of x values");
 38 |         else if(xvalues[0].length != FUNCTION.getNInputs())
 39 |             throw new IllegalArgumentException("The length of parameters is longer that the parameters accepted by the function");
 40 |         X = xvalues;
 41 |         Z = zvalues;
 42 |         
 43 |     }
 44 |     
 45 |     /**
 46 |      * 
 47 |      * */
 48 |     public void setParameters(double[] parameters){
 49 |         if(parameters.length != FUNCTION.getNParameters())
 50 |             throw new IllegalArgumentException("the number of parameters must equal the required number for the function: " + FUNCTION.getNParameters());
 51 |         A = new double[parameters.length];
 52 |         System.arraycopy(parameters,0,A,0,parameters.length);
 53 |     }
 54 |     /**
 55 |       *     returns the cumulative error for current values
 56 |       **/ 
 57 |     public double calculateErrors(){
 58 |         double new_error = 0;
 59 |         for(int i = 0; i<Z.length; i++){
 60 |             
 61 |             double v = FUNCTION.evaluate(X[i],A);
 62 |             ERROR[i] = Z[i] - v;
 63 |             new_error += Math.pow(ERROR[i],2);
 64 |         }
 65 |         return new_error;
 66 |         
 67 |     }
 68 |     
 69 |     public void calculateDerivatives(){
 70 |         double[] abefore = new double[A.length];
 71 |         double[] aafter = new double[A.length];
 72 |         System.arraycopy(A,0,abefore,0,A.length);
 73 |         System.arraycopy(A,0,aafter,0,A.length);
 74 |         for(int j = 0; j<A.length; j++){
 75 |             aafter[j] += DELTA;
 76 |             abefore[j] -= DELTA;
 77 |             
 78 |             if(j>0){
 79 |                 aafter[j-1] = A[j-1];
 80 |                 abefore[j-1] = A[j-1];
 81 |             }
 82 |                 
 83 |             for(int i = 0; i<Z.length; i++){
 84 |                 DERIVATIVES[i][j] = (FUNCTION.evaluate(X[i],aafter) - FUNCTION.evaluate(X[i],abefore))/(2*DELTA);
 85 |             }
 86 |         }
 87 |     }
 88 |     
 89 |     
 90 |     /**
 91 |      *  Takes the current error, and the current parameter set and calculates the
 92 |      *  changes, then returns the maximum changed value
 93 |      * */
 94 |     public double iterateValues(){
 95 |         double[][] matrix = new double[A.length][A.length];
 96 |         double[] right = new double[A.length];
 97 |         for(int i = 0; i<A.length; i++){
 98 |             for(int k = 0; k<Z.length;k++){
 99 |                     right[i] += ERROR[k]*DERIVATIVES[k][i];
100 |                     for(int l=0; l<A.length; l++){
101 |                         matrix[i][l] += DERIVATIVES[k][i]*DERIVATIVES[k][l];
102 |                     }
103 |             }
104 |                 
105 |         }
106 |         
107 |         
108 |         
109 |         Matrix coeff = new Matrix(matrix);
110 |         Matrix sols = new Matrix(right,A.length);
111 |         /*
112 |         for(int i = 0; i<matrix.length; i++){
113 |             for(int j=0; j<matrix[0].length; j++){
114 |                 System.out.print(matrix[i][j] + "\t");
115 |             }
116 |             System.out.println("|\t" + right[i]);
117 |         }
118 |         */
119 |         LUDecomposition adecom = coeff.lu();
120 | 
121 |         Matrix out = adecom.solve(sols);
122 |         
123 |         double[][] values = out.getArray();
124 |         
125 |         double max_change = Math.abs(values[0][0]);
126 |         for(int i = 0; i<A.length; i++){
127 |             max_change = max_change>Math.abs(values[i][0])?max_change:Math.abs(values[i][0]);
128 |             A[i] += values[i][0]*STEP;
129 |         }
130 | 
131 |         return max_change;
132 |         
133 |         
134 |     }
135 |     public void iterateValuesB(){
136 |         Matrix system = new Matrix(DERIVATIVES);
137 |         Matrix params = new Matrix(ERROR,ERROR.length);
138 |         //params = params.times(-1.);
139 |         Matrix out = system.solve(params);
140 |         
141 |         double[][] values = out.getArray();
142 | 
143 |         for(int i = 0; i<A.length; i++){
144 |             A[i] += values[i][0]*0.001;
145 |         }
146 | 
147 |     }
148 |     
149 |     
150 |     public void initializeWorkspace(){
151 |         ERROR = new double[Z.length];
152 |         DERIVATIVES = new double[Z.length][A.length];
153 |     }
154 |     
155 |     /**
156 |      *  Main routine, call this and the Parameters are iterated until it is finished.
157 |      * */
158 |     public void fitData(){
159 |         initializeWorkspace();
160 |         int i;
161 |         double changes = 0;
162 |         double last_error = Double.MAX_VALUE;
163 |         for(i = 0; i<MAX_ITERATIONS; i++){
164 | 
165 |             double e = calculateErrors();
166 |             if(e< MIN_ERROR){
167 |                 break;
168 |             }
169 |             if(e>last_error){
170 |                 System.err.println("Error increased: consider smaller step size.");
171 |                 break;
172 |             }
173 |             last_error = e;
174 |             calculateDerivatives();
175 |             try{
176 |                 changes = iterateValues();
177 |                 if(changes< MIN_CHANGE)
178 |                     break;
179 |             } catch(Exception exc){
180 |                 throw new RuntimeException(exc);
181 |             }
182 |         }
183 |         if(i==MAX_ITERATIONS){
184 |             System.err.println("Warning: Maximum iteration reached.");
185 |         }
186 | 
187 |         
188 |     }
189 |     /**
190 |      *      Gets the current set of parameters values.
191 |      * */
192 |     public double[] getParameters(){
193 |         return A;
194 |     }
195 | 
196 |     @Override
197 |     public double[] getUncertainty() {
198 |         return new double[0];
199 |     }
200 | 
201 |     public void setStepSize(double step){
202 |         STEP = step;
203 |     }
204 | 
205 |     public void setMinError(double error){
206 |         MIN_ERROR = error;
207 |     }
208 | 
209 |     /**
210 |      * When the parameters change less than the change parameter the program will stop iterating
211 |      *
212 |      * @param change
213 |      */
214 |     public void setMinChange(double change){
215 |         MIN_CHANGE = change;
216 |     }
217 | 
218 | }
219 | 


--------------------------------------------------------------------------------
/src/main/java/org/orangepalantir/leastsquares/functions/ExponentialFunction.java:
--------------------------------------------------------------------------------
 1 | package org.orangepalantir.leastsquares.functions;
 2 | 
 3 | import org.orangepalantir.leastsquares.Function;
 4 | 
 5 | /**
 6 |  *
 7 |  * Created by msmith on 2/26/14.
 8 |  */
 9 | public class ExponentialFunction implements Function {
10 |     @Override
11 |     public double evaluate(double[] values, double[] parameters) {
12 |         return parameters[0] + parameters[1]*Math.exp(parameters[2]*values[0]);
13 |     }
14 | 
15 |     @Override
16 |     public int getNParameters() {
17 |         return 3;
18 |     }
19 | 
20 |     @Override
21 |     public int getNInputs() {
22 |         return 1;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/main/java/org/orangepalantir/leastsquares/functions/LinearFunction.java:
--------------------------------------------------------------------------------
 1 | package org.orangepalantir.leastsquares.functions;
 2 | 
 3 | import org.orangepalantir.leastsquares.Function;
 4 | 
 5 | /**
 6 |  * Generic linear function, with an offset.
 7 |  *
 8 |  * A + B x1 + C x2 + D x3 ...
 9 |  *
10 |  * Where the number of inputs, x's is indicated in the constructor and
11 |  * the number of parameters is the number of terms plus 1.
12 |  *
13 |  * Created by msmith on 2/26/14.
14 |  */
15 | public class LinearFunction implements Function {
16 |     int terms;
17 |     public LinearFunction(int terms){
18 |         this.terms = terms;
19 |     }
20 |     @Override
21 |     public double evaluate(double[] values, double[] parameters) {
22 |         double sum = parameters[0];
23 |         for(int i = 0; i<values.length; i++){
24 |             sum += parameters[i+1]*values[i];
25 |         }
26 |         return sum;
27 |     }
28 | 
29 |     @Override
30 |     public int getNParameters() {
31 |         return terms + 1;
32 |     }
33 | 
34 |     @Override
35 |     public int getNInputs() {
36 |         return terms;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/test/java/org/orangepalantir/leastsquares/fitters/LinearFitterTest.java:
--------------------------------------------------------------------------------
 1 | package org.orangepalantir.leastsquares.fitters;
 2 | 
 3 | import org.junit.Test;
 4 | import org.junit.Assert;
 5 | import org.orangepalantir.leastsquares.functions.LinearFunction;
 6 | 
 7 | /**
 8 |  *
 9 |  *
10 |  * Created by msmith on 2/26/14.
11 |  */
12 | public class LinearFitterTest {
13 |     @Test
14 |     public void testLinearFitter(){
15 |         int N = 100;
16 |         double[] z = new double[N];
17 |         double[][] x = new double[N][2];
18 |         for(int i = 0; i<N; i++){
19 |             double v = 0.1*(N/2 - i);
20 |             z[i] = 1 - 2* v + v*v;
21 |             x[i][0] = v;
22 |             x[i][1] = v*v;
23 |         }
24 |         LinearFitter fit = new LinearFitter(new LinearFunction(2));
25 |         fit.setData(x, z);
26 |         fit.setParameters(new double[]{1,1,1});
27 |         fit.fitData();
28 |         double[] output = fit.getParameters();
29 | 
30 |         Assert.assertEquals(1.0, output[0], 1.0e-15);
31 |         Assert.assertEquals(-2.0, output[1], 1.0e-14);
32 |         Assert.assertEquals(1.0, output[2], 1.0e-14);
33 | 
34 |     }
35 | 
36 | }


--------------------------------------------------------------------------------
/src/test/java/org/orangepalantir/leastsquares/fitters/NonLinearSolverTest.java:
--------------------------------------------------------------------------------
 1 | package org.orangepalantir.leastsquares.fitters;
 2 | 
 3 | import org.junit.Assert;
 4 | import org.junit.Test;
 5 | import org.orangepalantir.leastsquares.Fitter;
 6 | import org.orangepalantir.leastsquares.Function;
 7 | import org.orangepalantir.leastsquares.functions.ExponentialFunction;
 8 | 
 9 | import java.util.Arrays;
10 | 
11 | /**
12 |  * Created by msmith on 2/26/14.
13 |  */
14 | public class NonLinearSolverTest {
15 |     @Test
16 |     public void testExponentialFunction(){
17 |         int N = 100;
18 |         double[] z = new double[N];
19 |         double[][] x = new double[N][1];
20 |         for(int i = 0; i<N; i++){
21 |             x[i][0] = 0.1*i;
22 |             z[i] = Math.exp(-x[i][0] / 2.0);
23 |         }
24 |         Function exponential = new ExponentialFunction();
25 |         NonLinearSolver non_linear = new NonLinearSolver(exponential);
26 |         non_linear.setData(x,z);
27 | 
28 |         // it kinda takes a good guess.
29 |         non_linear.setParameters(new double[]{1,1,-1});
30 | 
31 |         //coarse fit.
32 |         non_linear.fitData();
33 | 
34 |         //improving results.
35 |         non_linear.setMinChange(1e-32);
36 |         non_linear.setMinError(1e-32);
37 |         non_linear.setStepSize(1.0);
38 | 
39 |         non_linear.fitData();
40 |         double[] results = non_linear.getParameters();
41 | 
42 |         System.out.println(Arrays.toString(results));
43 |         Assert.assertEquals(0, results[0], 1e-16);
44 |         Assert.assertEquals(1, results[1], 1e-16);
45 |         Assert.assertEquals(-0.5, results[2], 1e-16);
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/test/java/org/orangepalantir/leastsquares/fitters/NonLinearTrigonometricSolver.java:
--------------------------------------------------------------------------------
 1 | package org.orangepalantir.leastsquares.fitters;
 2 | 
 3 | import org.junit.Assert;
 4 | import org.junit.Test;
 5 | import org.orangepalantir.leastsquares.Function;
 6 | 
 7 | public class NonLinearTrigonometricSolver {
 8 | 
 9 |   // Solves the following non-linear set of equations:
10 | 
11 |   //  a - e + bcosθ1 + csinθ1 +  d * sin(θ1 + θ2) ) = z
12 | 
13 |   //  ( bsinθ1 + ccosθ1 + d * cos(θ1 + θ2) ) * sinθ0 = x
14 | 
15 |   //  ( bsinθ1 + ccosθ1 + d * cos(θ1 + θ2) ) * cosθ0 = y
16 | 
17 |   // given x, y, z, solve for θ0, θ1, θ2
18 | 
19 |   static final double a = 125;
20 |   static final double b = 143;
21 |   static final double c = 50;
22 |   static final double d = 142;
23 |   static final double e = 96;
24 | 
25 |   static final double x = 0;
26 |   static final double y = 192;
27 |   static final double z = 172;
28 | 
29 |   @Test
30 |   public void testNonLinearTrigonometricSolver() {
31 | 
32 |     double[][] xs = { { -1 }, { 0 }, { 1 } };
33 | 
34 |     double[] zs = { z, x, y };
35 | 
36 |     double r = Math.sqrt(x * x + y * y);
37 |     final double sinTheta0 = x / r;
38 |     final double cosTheta0 = y / r;
39 | 
40 |     Function f = new Function() {
41 | 
42 |       @Override
43 |       public double evaluate(double[] values, double[] parameters) {
44 | 
45 |         double t1 = parameters[0];
46 |         double t2 = parameters[1];
47 |         if (values[0] == -1) {
48 |           return a - e + b * Math.cos(t1) + c * Math.sin(t1) + d * Math.sin(t2 + t1);
49 | 
50 |         } else if (values[0] == 0) {
51 |           return (b * Math.sin(t1) + c * Math.cos(t1) + d * Math.cos(t2 + t1)) * sinTheta0;
52 |         } else {
53 |           return (b * Math.sin(t1) + c * Math.cos(t1) + d * Math.cos(t2 + t1)) * cosTheta0;
54 |         }
55 |       }
56 | 
57 |       @Override
58 |       public int getNParameters() {
59 | 
60 |         return 2;
61 |       }
62 | 
63 |       @Override
64 |       public int getNInputs() {
65 | 
66 |         return 1;
67 |       }
68 |     };
69 | 
70 |     NonLinearSolver fit = new NonLinearSolver(f);
71 |     fit.setData(xs, zs);
72 |     double[] params = { 0, 0 };
73 |     fit.setParameters(params);
74 | 
75 |     fit.fitData();
76 |     // improving results.
77 |     fit.setMinChange(1e-32);
78 |     fit.setMinError(1e-32);
79 |     fit.setStepSize(0.5);
80 | 
81 |     fit.fitData();
82 | 
83 |     double t1 = fit.getParameters()[0];
84 |     double t2 = fit.getParameters()[1];
85 |     double arg = y / (b * Math.sin(t1) + c * Math.cos(t1) + d * Math.cos(t2 + t1));
86 |     // System.out.println(" " + arg);
87 |     double theta0 = Math.acos(arg) * Math.signum(x);
88 |     System.out.println(Math.toDegrees(theta0));
89 |     System.out.println(Math.toDegrees(fit.getParameters()[0]));
90 |     System.out.println(Math.toDegrees(fit.getParameters()[1]));
91 | 
92 |     Assert.assertEquals(0, Math.toDegrees(theta0), 1e-16);
93 |     Assert.assertEquals(0, Math.toDegrees(fit.getParameters()[0]), 1e-16);
94 |     Assert.assertEquals(0, Math.toDegrees(fit.getParameters()[1]), 1e-16);
95 | 
96 |   }
97 | }


--------------------------------------------------------------------------------