Example usage for org.apache.commons.math3.analysis.integration BaseAbstractUnivariateIntegrator DEFAULT_ABSOLUTE_ACCURACY

Introduction

In this page you can find the example usage for org.apache.commons.math3.analysis.integration BaseAbstractUnivariateIntegrator DEFAULT_ABSOLUTE_ACCURACY.

Prototype

double DEFAULT_ABSOLUTE_ACCURACY

To view the source code for org.apache.commons.math3.analysis.integration BaseAbstractUnivariateIntegrator DEFAULT_ABSOLUTE_ACCURACY.

Click Source Link

Document

Default absolute accuracy.

Usage

From source file:uk.ac.diamond.scisoft.ncd.core.DegreeOfOrientation.java

public Object[] process(Serializable buffer, Serializable axis, final int[] dimensions) {

    double[] parentaxis = (double[]) ConvertUtils.convert(axis, double[].class);
    float[] parentdata = (float[]) ConvertUtils.convert(buffer, float[].class);

    int size = dimensions[dimensions.length - 1];
    double[] myaxis = new double[size];
    double[] mydata = new double[size];
    double[] cos2data = new double[size];
    double[] sin2data = new double[size];
    double[] sincosdata = new double[size];

    for (int i = 0; i < parentaxis.length; i++) {
        myaxis[i] = Math.toRadians(parentaxis[i]);
        mydata[i] = parentdata[i];/*www  . j  ava 2s . c o m*/
        float cos2alpha = (float) Math.cos(2.0 * myaxis[i]);
        float sin2alpha = (float) Math.sin(2.0 * myaxis[i]);
        cos2data[i] = (1.0f + cos2alpha) * parentdata[i] / 2.0;
        sin2data[i] = (1.0f - cos2alpha) * parentdata[i] / 2.0;
        sincosdata[i] = sin2alpha * parentdata[i] / 2.0;
    }

    UnivariateInterpolator interpolator = new SplineInterpolator();
    UnivariateFunction function = interpolator.interpolate(myaxis, mydata);
    UnivariateFunction cos2Function = interpolator.interpolate(myaxis, cos2data);
    UnivariateFunction sin2Function = interpolator.interpolate(myaxis, sin2data);
    UnivariateFunction sincosFunction = interpolator.interpolate(myaxis, sincosdata);

    UnivariateIntegrator integrator = new IterativeLegendreGaussIntegrator(15,
            BaseAbstractUnivariateIntegrator.DEFAULT_RELATIVE_ACCURACY,
            BaseAbstractUnivariateIntegrator.DEFAULT_ABSOLUTE_ACCURACY);

    try {
        float cos2mean = (float) integrator.integrate(INTEGRATION_POINTS, cos2Function, myaxis[0],
                myaxis[myaxis.length - 1]);
        float sin2mean = (float) integrator.integrate(INTEGRATION_POINTS, sin2Function, myaxis[0],
                myaxis[myaxis.length - 1]);
        float sincosmean = (float) integrator.integrate(INTEGRATION_POINTS, sincosFunction, myaxis[0],
                myaxis[myaxis.length - 1]);
        float norm = (float) integrator.integrate(INTEGRATION_POINTS, function, myaxis[0],
                myaxis[myaxis.length - 1]);

        cos2mean /= norm;
        sin2mean /= norm;
        sincosmean /= norm;

        float result = (float) Math.sqrt(Math.pow(cos2mean - sin2mean, 2) - 4.0 * sincosmean * sincosmean);
        double angle = MathUtils.normalizeAngle(Math.atan2(2.0 * sincosmean, cos2mean - sin2mean) / 2.0,
                Math.PI);

        Object[] output = new Object[] { new float[] { result }, new float[] { (float) Math.toDegrees(angle) },
                new float[] { (float) (result * Math.cos(angle)), (float) (result * Math.sin(angle)) }, };

        return output;

    } catch (TooManyEvaluationsException e) {
        return new Object[] { new float[] { Float.NaN }, new double[] { Double.NaN } };
    } catch (MaxCountExceededException e) {
        return new Object[] { new float[] { Float.NaN }, new double[] { Double.NaN } };
    }
}

---

From source file:uk.ac.diamond.scisoft.ncd.core.SaxsInvariant.java

public Object[] process(Serializable buffer, Serializable errors, Serializable axis, final int[] dimensions) {

    double[] parentaxis = (double[]) ConvertUtils.convert(axis, double[].class);
    float[] parentdata = (float[]) ConvertUtils.convert(buffer, float[].class);
    double[] parenterrors = (double[]) ConvertUtils.convert(errors, double[].class);

    int shift = (parentaxis[0] > 0 ? 1 : 0);
    int size = dimensions[dimensions.length - 1] + shift;
    double[] myaxis = new double[size];
    double[] mydata = new double[size];
    double[] myerrors = new double[size];

    if (shift > 0) {
        myaxis[0] = 0.0;/*from   w ww.j  a  v  a 2 s .c  o  m*/
        mydata[0] = 0.0;
        myerrors[0] = 0.0;
    }

    for (int i = 0; i < parentaxis.length; i++) {
        myaxis[i + shift] = parentaxis[i];
        mydata[i + shift] = parentdata[i] * parentaxis[i] * parentaxis[i];
        myerrors[i + shift] = parenterrors[i] * Math.pow(parentaxis[i], 4);
    }

    UnivariateInterpolator interpolator = new SplineInterpolator();
    UnivariateFunction function = interpolator.interpolate(myaxis, mydata);

    UnivariateIntegrator integrator = new IterativeLegendreGaussIntegrator(15,
            BaseAbstractUnivariateIntegrator.DEFAULT_RELATIVE_ACCURACY,
            BaseAbstractUnivariateIntegrator.DEFAULT_ABSOLUTE_ACCURACY);

    try {
        float result = (float) integrator.integrate(INTEGRATION_POINTS, function, 0.0,
                myaxis[myaxis.length - 1]);

        IDataset data = new FloatDataset(parentdata, dimensions);
        IDataset qaxis = new DoubleDataset(parentaxis, dimensions);
        PorodPlotData porodPlotData = (PorodPlotData) SaxsAnalysisPlotType.POROD_PLOT.getSaxsPlotDataObject();
        SimpleRegression regression = porodPlotData.getPorodPlotParameters(data.squeeze(), qaxis.squeeze());
        Amount<Dimensionless> c4 = porodPlotData.getC4(regression);

        result += (float) (c4.getEstimatedValue() / myaxis[myaxis.length - 1]);

        double error = 0.0;
        for (int i = 0; i < myaxis.length; i++) {
            int idx1 = Math.max(0, i - 1);
            int idx2 = Math.min(myaxis.length - 1, i + 1);
            error += Math.pow((myaxis[idx2] - myaxis[idx1]), 2) * myerrors[i] / 4.0;
        }
        error += Math.pow(c4.getAbsoluteError() / myaxis[myaxis.length - 1], 2);

        return new Object[] { new float[] { result }, new double[] { error } };
    } catch (TooManyEvaluationsException e) {
        return new Object[] { new float[] { Float.NaN }, new double[] { Double.NaN } };
    } catch (MaxCountExceededException e) {
        return new Object[] { new float[] { Float.NaN }, new double[] { Double.NaN } };
    }
}

---