mirror of
https://github.com/apache/commons-math.git
synced 2025-02-13 05:26:44 +00:00
MATH-512
Functionality moved to "GaussianFitter.ParameterGuesser" inner class. git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@1072199 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Gilles Sadowski
parent
44adfaeb94
commit
04bbc3fccf
@ -1,271 +0,0 @@
|
||||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one or more
|
||||
* contributor license agreements. See the NOTICE file distributed with
|
||||
* this work for additional information regarding copyright ownership.
|
||||
* The ASF licenses this file to You under the Apache License, Version 2.0
|
||||
* (the "License"); you may not use this file except in compliance with
|
||||
* the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.apache.commons.math.optimization.fitting;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
|
||||
import org.apache.commons.math.exception.util.LocalizedFormats;
|
||||
import org.apache.commons.math.exception.NumberIsTooSmallException;
|
||||
import org.apache.commons.math.exception.OutOfRangeException;
|
||||
import org.apache.commons.math.exception.ZeroException;
|
||||
import org.apache.commons.math.exception.NullArgumentException;
|
||||
|
||||
/**
|
||||
* Guesses the parameters ({@code a}, {@code b}, {@code c}, and {@code d})
|
||||
* of a {@link ParametricGaussianFunction} based on the specified observed
|
||||
* points.
|
||||
*
|
||||
* @since 2.2
|
||||
* @version $Revision$ $Date$
|
||||
*/
|
||||
public class GaussianParametersGuesser {
|
||||
|
||||
/** Observed points. */
|
||||
private final WeightedObservedPoint[] observations;
|
||||
|
||||
/** Resulting guessed parameters. */
|
||||
private double[] parameters;
|
||||
|
||||
/**
|
||||
* Constructs instance with the specified observed points.
|
||||
*
|
||||
* @param observations observed points upon which should base guess
|
||||
*/
|
||||
public GaussianParametersGuesser(WeightedObservedPoint[] observations) {
|
||||
if (observations == null) {
|
||||
throw new NullArgumentException(LocalizedFormats.INPUT_ARRAY);
|
||||
}
|
||||
if (observations.length < 3) {
|
||||
throw new NumberIsTooSmallException(observations.length, 3, true);
|
||||
}
|
||||
this.observations = observations.clone();
|
||||
}
|
||||
|
||||
/**
|
||||
* Guesses the parameters based on the observed points.
|
||||
*
|
||||
* @return guessed parameters array <code>{a, b, c, d}</code>
|
||||
*/
|
||||
public double[] guess() {
|
||||
if (parameters == null) {
|
||||
parameters = basicGuess(observations);
|
||||
}
|
||||
return parameters.clone();
|
||||
}
|
||||
|
||||
/**
|
||||
* Guesses the parameters based on the specified observed points.
|
||||
*
|
||||
* @param points observed points upon which should base guess
|
||||
*
|
||||
* @return guessed parameters array <code>{a, b, c, d}</code>
|
||||
*/
|
||||
private double[] basicGuess(WeightedObservedPoint[] points) {
|
||||
Arrays.sort(points, createWeightedObservedPointComparator());
|
||||
double[] params = new double[4];
|
||||
|
||||
int minYIdx = findMinY(points);
|
||||
params[0] = points[minYIdx].getY();
|
||||
|
||||
int maxYIdx = findMaxY(points);
|
||||
params[1] = points[maxYIdx].getY();
|
||||
params[2] = points[maxYIdx].getX();
|
||||
|
||||
double fwhmApprox;
|
||||
try {
|
||||
double halfY = params[0] + ((params[1] - params[0]) / 2.0);
|
||||
double fwhmX1 = interpolateXAtY(points, maxYIdx, -1, halfY);
|
||||
double fwhmX2 = interpolateXAtY(points, maxYIdx, +1, halfY);
|
||||
fwhmApprox = fwhmX2 - fwhmX1;
|
||||
} catch (OutOfRangeException e) {
|
||||
fwhmApprox = points[points.length - 1].getX() - points[0].getX();
|
||||
}
|
||||
params[3] = fwhmApprox / (2.0 * Math.sqrt(2.0 * Math.log(2.0)));
|
||||
|
||||
return params;
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds index of point in specified points with the smallest Y.
|
||||
*
|
||||
* @param points points to search
|
||||
*
|
||||
* @return index in specified points array
|
||||
*/
|
||||
private int findMinY(WeightedObservedPoint[] points) {
|
||||
int minYIdx = 0;
|
||||
for (int i = 1; i < points.length; i++) {
|
||||
if (points[i].getY() < points[minYIdx].getY()) {
|
||||
minYIdx = i;
|
||||
}
|
||||
}
|
||||
return minYIdx;
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds index of point in specified points with the largest Y.
|
||||
*
|
||||
* @param points points to search
|
||||
*
|
||||
* @return index in specified points array
|
||||
*/
|
||||
private int findMaxY(WeightedObservedPoint[] points) {
|
||||
int maxYIdx = 0;
|
||||
for (int i = 1; i < points.length; i++) {
|
||||
if (points[i].getY() > points[maxYIdx].getY()) {
|
||||
maxYIdx = i;
|
||||
}
|
||||
}
|
||||
return maxYIdx;
|
||||
}
|
||||
|
||||
/**
|
||||
* Interpolates using the specified points to determine X at the specified
|
||||
* Y.
|
||||
*
|
||||
* @param points points to use for interpolation
|
||||
* @param startIdx index within points from which to start search for
|
||||
* interpolation bounds points
|
||||
* @param idxStep index step for search for interpolation bounds points
|
||||
* @param y Y value for which X should be determined
|
||||
*
|
||||
* @return value of X at the specified Y
|
||||
*
|
||||
* @throws IllegalArgumentException if idxStep is 0
|
||||
* @throws OutOfRangeException if specified <code>y</code> is not within the
|
||||
* range of the specified <code>points</code>
|
||||
*/
|
||||
private double interpolateXAtY(WeightedObservedPoint[] points,
|
||||
int startIdx, int idxStep, double y) throws OutOfRangeException {
|
||||
if (idxStep == 0) {
|
||||
throw new ZeroException();
|
||||
}
|
||||
WeightedObservedPoint[] twoPoints = getInterpolationPointsForY(points, startIdx, idxStep, y);
|
||||
WeightedObservedPoint pointA = twoPoints[0];
|
||||
WeightedObservedPoint pointB = twoPoints[1];
|
||||
if (pointA.getY() == y) {
|
||||
return pointA.getX();
|
||||
}
|
||||
if (pointB.getY() == y) {
|
||||
return pointB.getX();
|
||||
}
|
||||
return pointA.getX() +
|
||||
(((y - pointA.getY()) * (pointB.getX() - pointA.getX())) / (pointB.getY() - pointA.getY()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the two bounding interpolation points from the specified points
|
||||
* suitable for determining X at the specified Y.
|
||||
*
|
||||
* @param points points to use for interpolation
|
||||
* @param startIdx index within points from which to start search for
|
||||
* interpolation bounds points
|
||||
* @param idxStep index step for search for interpolation bounds points
|
||||
* @param y Y value for which X should be determined
|
||||
*
|
||||
* @return array containing two points suitable for determining X at the
|
||||
* specified Y
|
||||
*
|
||||
* @throws IllegalArgumentException if idxStep is 0
|
||||
* @throws OutOfRangeException if specified <code>y</code> is not within the
|
||||
* range of the specified <code>points</code>
|
||||
*/
|
||||
private WeightedObservedPoint[] getInterpolationPointsForY(WeightedObservedPoint[] points,
|
||||
int startIdx, int idxStep, double y)
|
||||
throws OutOfRangeException {
|
||||
if (idxStep == 0) {
|
||||
throw new ZeroException();
|
||||
}
|
||||
for (int i = startIdx;
|
||||
(idxStep < 0) ? (i + idxStep >= 0) : (i + idxStep < points.length);
|
||||
i += idxStep) {
|
||||
if (isBetween(y, points[i].getY(), points[i + idxStep].getY())) {
|
||||
return (idxStep < 0) ?
|
||||
new WeightedObservedPoint[] { points[i + idxStep], points[i] } :
|
||||
new WeightedObservedPoint[] { points[i], points[i + idxStep] };
|
||||
}
|
||||
}
|
||||
|
||||
double minY = Double.POSITIVE_INFINITY;
|
||||
double maxY = Double.NEGATIVE_INFINITY;
|
||||
for (final WeightedObservedPoint point : points) {
|
||||
minY = Math.min(minY, point.getY());
|
||||
maxY = Math.max(maxY, point.getY());
|
||||
}
|
||||
throw new OutOfRangeException(y, minY, maxY);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines whether a value is between two other values.
|
||||
*
|
||||
* @param value value to determine whether is between <code>boundary1</code>
|
||||
* and <code>boundary2</code>
|
||||
* @param boundary1 one end of the range
|
||||
* @param boundary2 other end of the range
|
||||
*
|
||||
* @return true if <code>value</code> is between <code>boundary1</code> and
|
||||
* <code>boundary2</code> (inclusive); false otherwise
|
||||
*/
|
||||
private boolean isBetween(double value, double boundary1, double boundary2) {
|
||||
return (value >= boundary1 && value <= boundary2) ||
|
||||
(value >= boundary2 && value <= boundary1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Factory method creating <code>Comparator</code> for comparing
|
||||
* <code>WeightedObservedPoint</code> instances.
|
||||
*
|
||||
* @return new <code>Comparator</code> instance
|
||||
*/
|
||||
private Comparator<WeightedObservedPoint> createWeightedObservedPointComparator() {
|
||||
return new Comparator<WeightedObservedPoint>() {
|
||||
public int compare(WeightedObservedPoint p1, WeightedObservedPoint p2) {
|
||||
if (p1 == null && p2 == null) {
|
||||
return 0;
|
||||
}
|
||||
if (p1 == null) {
|
||||
return -1;
|
||||
}
|
||||
if (p2 == null) {
|
||||
return 1;
|
||||
}
|
||||
if (p1.getX() < p2.getX()) {
|
||||
return -1;
|
||||
}
|
||||
if (p1.getX() > p2.getX()) {
|
||||
return 1;
|
||||
}
|
||||
if (p1.getY() < p2.getY()) {
|
||||
return -1;
|
||||
}
|
||||
if (p1.getY() > p2.getY()) {
|
||||
return 1;
|
||||
}
|
||||
if (p1.getWeight() < p2.getWeight()) {
|
||||
return -1;
|
||||
}
|
||||
if (p1.getWeight() > p2.getWeight()) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user