/*
*   Class   BoxCox
*
*   USAGE:  Box-Cox Transformation
*
*   WRITTEN BY: Dr Michael Thomas Flanagan
*
*   DATE:       July - August 2008
*   AMENDED:    2-12 September 2008, 15-19 December 2010, 
*               2-5 January 2011, 20 January 2011, 7 December 2011
*
*   DOCUMENTATION:
*   See Michael Thomas Flanagan's Java library on-line web page:
*   http://www.ee.ucl.ac.uk/~mflanaga/java/BoxCox.html
*   http://www.ee.ucl.ac.uk/~mflanaga/java/
*
*   Copyright (c) 2008 - 2011  Michael Thomas Flanagan
*
*   PERMISSION TO COPY:
*
* Permission to use, copy and modify this software and its documentation for NON-COMMERCIAL purposes is granted, without fee,
* provided that an acknowledgement to the author, Dr Michael Thomas Flanagan at www.ee.ucl.ac.uk/~mflanaga, appears in all copies
* and associated documentation or publications.
*
* Redistributions of the source code of this source code, or parts of the source codes, must retain the above copyright notice, this list of conditions
* and the following disclaimer and requires written permission from the Michael Thomas Flanagan:
*
* Redistribution in binary form of all or parts of this class must reproduce the above copyright notice, this list of conditions and
* the following disclaimer in the documentation and/or other materials provided with the distribution and requires written permission from the Michael Thomas Flanagan:
*
* Dr Michael Thomas Flanagan makes no representations about the suitability or fitness of the software for any or for a particular purpose.
* Dr Michael Thomas Flanagan shall not be liable for any damages suffered as a result of using, modifying or distributing this software
* or its derivatives.
*
***************************************************************************************/

package flanagan.analysis;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import java.text.*;

import flanagan.analysis.Stat;
import flanagan.analysis.Regression;
import flanagan.math.ArrayMaths;
import flanagan.math.Maximization;
import flanagan.math.MaximizationFunction;
import flanagan.math.Fmath;
import flanagan.math.Conv;
import flanagan.plot.*;
import flanagan.io.FileOutput;


public class BoxCox{

    private double[] originalData = null;                           // original data to be analysed as Gaussian
    private double[] sortedOriginalData = null;                     // ordered original data
    private double[] standardizedOriginalData = null;               // standardized original data
    private Stat sod = null;                                        // Stat instance of the standardizedOriginalData
    private double[] shiftedStandardizedOriginalData = null;        // data shifted to ensure all points are positive
    private int[] originalIndices = null;                           // original indices before data are ordered into ascending order
    private int nData = 0;                                          // number of data points

    private double originalRange = 0.0;                             // original data range
    private double originalMinimum = 0.0;                           // original data minimum
    private double originalMaximum = 0.0;                           // original data maximum
    private double originalMean = 0.0;                              // original data mean
    private double originalMedian = 0.0;                            // original original data median
    private double originalStandardDeviation = 0.0;                 // original data standard deviation
    private double originalVariance = 0.0;                          // original data variance
    private double originalMomentSkewness = 0.0;                    // original data moment skewness
    private double originalMedianSkewness = 0.0;                    // original data median skewness
    private double originalQuartileSkewness = 0.0;                  // original data quartile skewness
    private double originalExcessKurtosis = 0.0;                    // original data excess kurtosis

    private double standardizedOriginalRange = 0.0;                 // standardized original data range
    private double standardizedOriginalMinimum = 0.0;               // standardized original data minimum
    private double standardizedOriginalMaximum = 0.0;               // standardized original data maximum
    private double standardizedOriginalMean = 0.0;                  // standardized original original data mean
    private double standardizedOriginalMedian = 0.0;                  // standardized original original data median
    private double standardizedOriginalStandardDeviation = 1.0;     // standardized original data standard deviation
    private double standardizedOriginalVariance = 1.0;              // standardized original data variance
    private double standardizedOriginalMomentSkewness = 0.0;        // standardized original data moment skewness
    private double standardizedOriginalMedianSkewness = 0.0;        // standardized original data median skewness
    private double standardizedOriginalQuartileSkewness = 0.0;      // standardized original data quartile skewness
    private double standardizedOriginalExcessKurtosis = 0.0;        // standardized original data excess kurtosis

    private double originalSampleR = 0.0;                           // Probabilty plot correlation coefficient for the original data
    private double originalIntercept = 0.0;                         // Probabilty plot intercept for the original data
    private double originalGradient = 0.0;                          // Probabilty plot gradient for the original data
    private double originalInterceptError = 0.0;                    // Estimated error of the probabilty plot intercept for the original data
    private double originalGradientError = 0.0;                     // Estimated error of the probabilty plot gradient for the original data

    private boolean initializationDone = false;                     // = true when initialization of`the data is complete

    private double[] transformedData = null;                        // Box-Cox transformed data
    private double[] standardizedTransformedData = null;            // standardized  Box-Cox transformed data
    private double[] scaledTransformedData = null;                  // Box-Cox transformed data scaled to original mean and standard deviation
    private double[] sortedScaledTransformedData = null;            // Box-Cox transformed data scaled to original mean and standard deviation sorted into ascending order

    private double transformedRange = 0.0;                          // scaled transformed data range
    private double transformedMinimum = 0.0;                        // scaled transformed data minimum
    private double transformedMaximum = 0.0;                        // scaled transformed data maximum
    private double transformedMean = 0.0;                           // scaled transformed data mean
    private double transformedStandardDeviation = 0.0;              // scaled transformed data standard deviation
    private double transformedMedian = 0.0;                         // scaled transformed data median
    private double transformedVariance = 0.0;                       // scaled transformed data variance
    private double transformedMomentSkewness = 0.0;                 // scaled transformed data moment skewness
    private double transformedMedianSkewness = 0.0;                 // scaled transformed data median skewness
    private double transformedQuartileSkewness = 0.0;               // scaled transformed data quartile skewness
    private double transformedExcessKurtosis = 0.0;                 // scaled transformed data excess kurtosis

    private double standardizedTransformedRange = 0.0;              // standardized transformed data range
    private double standardizedTransformedMinimum = 0.0;            // standardized transformed data minimum
    private double standardizedTransformedMaximum = 0.0;            // standardized transformed data maximum
    private double standardizedTransformedMean = 0.0;               // standardized transformed data mean
    private double standardizedTransformedMedian = 0.0;             // standardized transformed data median
    private double standardizedTransformedStandardDeviation = 1.0;  // standardized transformed data standard deviation
    private double standardizedTransformedVariance = 1.0;           // standardized transformed data variance
    private double standardizedTransformedMomentSkewness = 0.0;     // standardized transformed data moment skewness
    private double standardizedTransformedMedianSkewness = 0.0;     // standardized transformed data median skewness
    private double standardizedTransformedQuartileSkewness = 0.0;   // standardized transformed data quartile skewness
    private double standardizedTransformedExcessKurtosis = 0.0;     // standardized transformed data excess kurtosis

    private double[] inverseData = null;                            // inverse transformed data
    private double lambdaThree = 0.0;                               // shift, if needed, to allow inverse transform

    private double lambdaOne = 0.0;                                 // Box-Cox lambdaOne
    private double lambdaTwo = 0.0;                                 // Box-Cox lambdaTwo

    private double transformedSampleR = 0.0;                        // Probabilty plot correlation coefficient for the transformed data
    private double transformedIntercept = 0.0;                      // Probabilty plot intercept for the transformed data
    private double transformedGradient = 0.0;                       // Probabilty plot gradient for the transformed data
    private double transformedInterceptError = 0.0;                 // Estimated error of the probabilty plot intercept for the transformed data
    private double transformedGradientError = 0.0;                  // Estimated error of the probabilty plot gradient for the transformed data

    private double[] uniformOrderMedians = null;                    // uniform order statistic medians
    private double[] gaussianOrderMedians = null;                   // Gaussian order statistic medians

    private boolean transformDone = false;                          // = true when Box-Cox transform performed
    private boolean inverseDone = false;                            // = true when Box-Cox inverse transform performed



    // CONSTRUCTORS
    public BoxCox(double[] originalData){
        this.sod = new Stat(originalData);
    }

    public BoxCox(float[] originalData){
        this.sod = new Stat(originalData);
    }

    public BoxCox(int[] originalData){
        this.sod = new Stat(originalData);
    }

    public BoxCox(long[] originalData){
        this.sod = new Stat(originalData);
    }

    public BoxCox(short[] originalData){
        this.sod = new Stat(originalData);
    }

    public BoxCox(byte[] originalData){
        this.sod = new Stat(originalData);
    }

    public BoxCox(BigDecimal[] originalData){
        this.sod = new Stat(originalData);
    }

    public BoxCox(BigInteger[] originalData){
        this.sod = new Stat(originalData);
    }

    public BoxCox(Stat originalData){
        this.sod = originalData;
    }

    public BoxCox(ArrayMaths amoriginalData){
        double[] ama = amoriginalData.array();
        this.sod = new Stat(ama);
    }

    public BoxCox(ArrayList originalData){
        this.sod = new Stat(originalData);
    }

    public BoxCox(Vector originalData){
        this.sod = new Stat(originalData);
    }

    // set denominator of variances to n
    public void setDenominatorToN(){
        Stat.setStaticDenominatorToN();
    }

    // Initialise original data arrays
    private void initialize(){

        // store entered data as instance variable
        this.originalData = this.sod.array_as_double();

        // Calculate original data statistics
        this.originalMinimum = this.sod.minimum();
        this.originalMaximum = this.sod.maximum();
        this.originalMedian = this.sod.median();
        if(this.originalMinimum==this.originalMaximum)throw new IllegalArgumentException("A Box-Cox transformation cannot be performed on a data array of identical values");
        this.originalRange = this.originalMaximum - this.originalMinimum;
        this.originalMean = this.sod.mean();
        this.originalStandardDeviation = this.sod.standardDeviation();
        this.originalVariance = this.sod.variance();
        this.originalMomentSkewness = this.sod.momentSkewness();
        this.originalMedianSkewness = this.sod.medianSkewness();
        this.originalQuartileSkewness = this.sod.quartileSkewness();
        this.originalExcessKurtosis = this.sod.excessKurtosis();

        // Store original data sorted into ascending order
        ArrayMaths sorted = this.sod.sort();
        this.sortedOriginalData = sorted.array();
        this.originalIndices = sorted.originalIndices();

        // Standardize and store standardized data
        this.standardizedOriginalData = this.sod.standardize();

        // Calculate standardized original data statistics
        this.standardizedOriginalMinimum = this.sod.minimum();
        this.standardizedOriginalMaximum = this.sod.maximum();
        this.standardizedOriginalMedian = this.sod.median();
        this.standardizedOriginalRange = this.standardizedOriginalMaximum - this.standardizedOriginalMinimum;
        this.standardizedOriginalMean = 0.0;
        this.standardizedOriginalStandardDeviation = 1.0;
        this.standardizedOriginalVariance = 1.0;
        this.standardizedOriginalMomentSkewness = this.sod.momentSkewness();
        this.standardizedOriginalMedianSkewness = this.sod.medianSkewness();
        this.standardizedOriginalQuartileSkewness = this.sod.quartileSkewness();
        this.standardizedOriginalExcessKurtosis = this.sod.excessKurtosis();

        // Numbet of data points
        this.nData = this.originalData.length;

        //  Calculate uniform order statistic medians
        this.uniformOrderMedians = Stat.uniformOrderStatisticMedians(this.nData);

        // Calculate Gaussian N[0,1] order statistic medians
        this.gaussianOrderMedians = Stat.gaussianOrderStatisticMedians(this.nData);

        // calculate the correlation coefficient of the probability plot for the untransformed data
        Regression reg = new Regression(this.gaussianOrderMedians, ((new ArrayMaths(this.standardizedOriginalData)).sort().array()));
        reg.linear();
        this.originalSampleR = reg.getSampleR();
        double[] coeff = reg.getBestEstimates();
        this.originalIntercept = coeff[0];
        this.originalGradient = coeff[1];
        coeff = reg.getBestEstimatesErrors();
        this.originalInterceptError = coeff[0];
        this.originalGradientError = coeff[1];

        this.initializationDone = true;
    }

    // BOX-COX TRANSFORMATION
    private double[] transform(){

        // initialize arrays and analyse original data
        if(!this.initializationDone)this.initialize();

        // Shift data to ensure all values are greater than zero
        this.lambdaTwo = 0.1*this.standardizedOriginalRange - this.standardizedOriginalMinimum;
        ArrayMaths st1 = this.sod.plus(this.lambdaTwo);
        this.shiftedStandardizedOriginalData = st1.getArray_as_double();

        // Create an instance of the BoxCoxFunction for Maximization
        BoxCoxFunction bcf = new BoxCoxFunction();
        bcf.shiftedData = this.shiftedStandardizedOriginalData;
        bcf.nData = this.nData;
        bcf.yTransform = new double[this.nData];
        bcf.gaussianOrderMedians = this.gaussianOrderMedians;

        // Create an instance of Maximization
        Maximization max = new Maximization();

        // Initial estimate of lambdaOne
        double[] start = {1.0};

        // Initial step size in maximization search
        double[] step = {0.3};

        // Tolerance for maximization search termination
        double maxzTol = 1e-9;

        // Maximiztaion of the Gaussian probabilty plot correlation coefficient varying lambdaOne
        max.nelderMead(bcf, start, step, maxzTol);

        // coeff[0] = value of lambdaOne for a maximum Gaussian probabilty plot correlation coefficient
        double[] coeff = max.getParamValues();
        double lambda1 = coeff[0];

        //maximum Gaussian probabilty plot correlation coefficient
        double sampleR1 = max.getMaximum();

        // Repeat maximization starting equidistant from the final value of lambdaOne on the opposite side from the starting estimate
        start[0] = lambda1 - (start[0] - lambda1);
        max.nelderMead(bcf, start, step, maxzTol);
        coeff = max.getParamValues();
        this.lambdaOne = coeff[0];
        this.transformedSampleR =  max.getMaximum();

        // Choose solution with the largest Gaussian probabilty plot correlation coefficient
        if(sampleR1>this.transformedSampleR){
            this.transformedSampleR = sampleR1;
            this.lambdaOne = lambda1;
        }

        // Store transformed data
        this.transformedData = new double[this.nData];
        if(this.lambdaOne==0.0){
            for(int i=0; i 
 

Ads help maintain this website.