From 53025f5e31b644742df2e7666152cffb404e9154 Mon Sep 17 00:00:00 2001 From: Peng Xiao Date: Tue, 2 Dec 2014 18:00:39 -0500 Subject: [PATCH] no message --- .../BoxPlotExample/BoxPlotExample.pde | 109 + .../BoxPlotExample/data/warpbreaks.txt | 1 + .../CastingFinding_andMore.pde | 95 + .../ComparingTwoDatasets.pde | 180 + .../ComparingTwoDatasets/data/FRESHMAN15.csv | 1 + .../data/Helvetica-12.vlw | Bin 0 -> 9186 bytes .../data/Helvetica-22.vlw | Bin 0 -> 20303 bytes .../CorrelationAndCovariance.pde | 121 + .../CorrelationMatrix.png | Bin 0 -> 64529 bytes .../CorrelationAndCovariance/data/GARBAGE.csv | 1 + .../examples/LinearAlgebra/LinearAlgebra.pde | 184 + .../examples/LinearAlgebra/data/BEARS.csv | 1 + .../LinearCorrelation/LinearCorrelation.pde | 121 + .../LinearCorrelation/LinearModelPlot.pde | 149 + .../examples/LinearCorrelation/data/Trees.txt | 32 + .../MultiDimensionalScaling/HeatMap.pde | 60 + .../MultiDimensionalScaling.pde | 126 + .../MultiDimensionalScaling/data/BEARS.csv | 1 + .../OneWayAnovaExample/OneWayAnovaExample.pde | 111 + .../OneWayAnovaExample/data/3Stooges.csv | 1 + drawing/papaya/examples/Ranking/Ranking.pde | 44 + .../ScatterPlotExample_simple_.pde | 75 + .../SortingUsingIndices.pde | 42 + .../examples/UniqueExample/UniqueExample.pde | 149 + .../examples/UniqueExample/data/GARBAGE.csv | 1 + .../UsingTheProbabilityDistributions.pde | 88 + .../autoCorrelationExample.pde | 95 + drawing/papaya/library.properties | 8 + drawing/papaya/library/papaya.jar | Bin 0 -> 71233 bytes .../papaya/reference/allclasses-frame.html | 109 + .../papaya/reference/allclasses-noframe.html | 109 + drawing/papaya/reference/constant-values.html | 277 ++ drawing/papaya/reference/deprecated-list.html | 147 + drawing/papaya/reference/help-doc.html | 214 ++ drawing/papaya/reference/index-all.html | 2076 +++++++++++ drawing/papaya/reference/index.html | 70 + drawing/papaya/reference/overview-tree.html | 168 + drawing/papaya/reference/package-list | 1 + drawing/papaya/reference/papaya/BoxPlot.html | 498 +++ drawing/papaya/reference/papaya/Cast.html | 576 +++ .../reference/papaya/Comparison.TTest.html | 318 ++ .../papaya/reference/papaya/Comparison.html | 374 ++ .../papaya/Correlation.Significance.html | 309 ++ .../papaya/Correlation.Weighted.html | 335 ++ .../papaya/reference/papaya/Correlation.html | 548 +++ .../reference/papaya/CorrelationPlot.html | 363 ++ .../reference/papaya/Descriptive.Mean.html | 429 +++ .../reference/papaya/Descriptive.Pooled.html | 333 ++ .../reference/papaya/Descriptive.Sum.html | 438 +++ .../papaya/Descriptive.Weighted.html | 307 ++ .../papaya/reference/papaya/Descriptive.html | 1412 ++++++++ drawing/papaya/reference/papaya/Distance.html | 492 +++ .../papaya/reference/papaya/Eigenvalue.html | 358 ++ drawing/papaya/reference/papaya/Find.html | 3151 +++++++++++++++++ .../papaya/reference/papaya/Frequency.html | 502 +++ drawing/papaya/reference/papaya/Gamma.html | 449 +++ drawing/papaya/reference/papaya/LU.html | 449 +++ .../reference/papaya/Linear.BoxCox.html | 285 ++ .../reference/papaya/Linear.Significance.html | 302 ++ .../reference/papaya/Linear.StdErr.html | 299 ++ drawing/papaya/reference/papaya/Linear.html | 433 +++ drawing/papaya/reference/papaya/MDS.html | 253 ++ drawing/papaya/reference/papaya/Mat.html | 2622 ++++++++++++++ drawing/papaya/reference/papaya/NaNs.html | 447 +++ .../reference/papaya/Normality.Dago.html | 373 ++ .../papaya/reference/papaya/Normality.html | 289 ++ .../papaya/reference/papaya/OneWayAnova.html | 441 +++ .../reference/papaya/PapayaConstants.html | 602 ++++ .../papaya/reference/papaya/Polynomial.html | 347 ++ .../papaya/reference/papaya/Probability.html | 1262 +++++++ drawing/papaya/reference/papaya/QR.html | 398 +++ drawing/papaya/reference/papaya/Rank.html | 464 +++ drawing/papaya/reference/papaya/SVD.html | 417 +++ .../papaya/reference/papaya/ScatterPlot.html | 609 ++++ drawing/papaya/reference/papaya/Sorting.html | 521 +++ drawing/papaya/reference/papaya/SubPlot.html | 793 +++++ drawing/papaya/reference/papaya/Unique.html | 338 ++ drawing/papaya/reference/papaya/Visuals.html | 1404 ++++++++ .../reference/papaya/package-frame.html | 119 + .../reference/papaya/package-summary.html | 344 ++ .../papaya/reference/papaya/package-tree.html | 166 + .../papaya/reference/resources/inherit.gif | Bin 0 -> 57 bytes drawing/papaya/reference/stylesheet.css | 115 + drawing/papaya/src/papaya/BoxPlot.java | 166 + drawing/papaya/src/papaya/Cast.java | 259 ++ drawing/papaya/src/papaya/Check.java | 68 + drawing/papaya/src/papaya/Comparison.java | 291 ++ drawing/papaya/src/papaya/Correlation.java | 546 +++ .../papaya/src/papaya/CorrelationPlot.java | 161 + drawing/papaya/src/papaya/Descriptive.java | 1628 +++++++++ drawing/papaya/src/papaya/Distance.java | 400 +++ drawing/papaya/src/papaya/Eigenvalue.java | 991 ++++++ drawing/papaya/src/papaya/Find.java | 1945 ++++++++++ drawing/papaya/src/papaya/Frequency.java | 195 + drawing/papaya/src/papaya/Gamma.java | 741 ++++ drawing/papaya/src/papaya/LU.java | 410 +++ drawing/papaya/src/papaya/Linear.java | 300 ++ drawing/papaya/src/papaya/MDS.java | 149 + drawing/papaya/src/papaya/Mat.java | 1511 ++++++++ drawing/papaya/src/papaya/NaNs.java | 288 ++ drawing/papaya/src/papaya/Normality.java | 282 ++ drawing/papaya/src/papaya/OneWayAnova.java | 196 + .../papaya/src/papaya/PapayaConstants.java | 94 + drawing/papaya/src/papaya/Polynomial.java | 129 + drawing/papaya/src/papaya/Probability.java | 978 +++++ drawing/papaya/src/papaya/QR.java | 296 ++ drawing/papaya/src/papaya/Rank.java | 618 ++++ drawing/papaya/src/papaya/SVD.java | 597 ++++ drawing/papaya/src/papaya/ScatterPlot.java | 205 ++ drawing/papaya/src/papaya/Sorting.java | 817 +++++ drawing/papaya/src/papaya/SubPlot.java | 192 + drawing/papaya/src/papaya/Unique.java | 103 + drawing/papaya/src/papaya/Visuals.java | 588 +++ 113 files changed, 45395 insertions(+) create mode 100644 drawing/papaya/examples/BoxPlotExample/BoxPlotExample.pde create mode 100644 drawing/papaya/examples/BoxPlotExample/data/warpbreaks.txt create mode 100644 drawing/papaya/examples/CastingFinding_andMore/CastingFinding_andMore.pde create mode 100644 drawing/papaya/examples/ComparingTwoDatasets/ComparingTwoDatasets.pde create mode 100644 drawing/papaya/examples/ComparingTwoDatasets/data/FRESHMAN15.csv create mode 100644 drawing/papaya/examples/ComparingTwoDatasets/data/Helvetica-12.vlw create mode 100644 drawing/papaya/examples/ComparingTwoDatasets/data/Helvetica-22.vlw create mode 100644 drawing/papaya/examples/CorrelationAndCovariance/CorrelationAndCovariance.pde create mode 100644 drawing/papaya/examples/CorrelationAndCovariance/CorrelationMatrix.png create mode 100644 drawing/papaya/examples/CorrelationAndCovariance/data/GARBAGE.csv create mode 100644 drawing/papaya/examples/LinearAlgebra/LinearAlgebra.pde create mode 100644 drawing/papaya/examples/LinearAlgebra/data/BEARS.csv create mode 100644 drawing/papaya/examples/LinearCorrelation/LinearCorrelation.pde create mode 100644 drawing/papaya/examples/LinearCorrelation/LinearModelPlot.pde create mode 100644 drawing/papaya/examples/LinearCorrelation/data/Trees.txt create mode 100644 drawing/papaya/examples/MultiDimensionalScaling/HeatMap.pde create mode 100644 drawing/papaya/examples/MultiDimensionalScaling/MultiDimensionalScaling.pde create mode 100644 drawing/papaya/examples/MultiDimensionalScaling/data/BEARS.csv create mode 100644 drawing/papaya/examples/OneWayAnovaExample/OneWayAnovaExample.pde create mode 100644 drawing/papaya/examples/OneWayAnovaExample/data/3Stooges.csv create mode 100644 drawing/papaya/examples/Ranking/Ranking.pde create mode 100644 drawing/papaya/examples/ScatterPlotExample_simple_/ScatterPlotExample_simple_.pde create mode 100644 drawing/papaya/examples/SortingUsingIndices/SortingUsingIndices.pde create mode 100644 drawing/papaya/examples/UniqueExample/UniqueExample.pde create mode 100644 drawing/papaya/examples/UniqueExample/data/GARBAGE.csv create mode 100644 drawing/papaya/examples/UsingTheProbabilityDistributions/UsingTheProbabilityDistributions.pde create mode 100644 drawing/papaya/examples/autoCorrelationExample/autoCorrelationExample.pde create mode 100644 drawing/papaya/library.properties create mode 100644 drawing/papaya/library/papaya.jar create mode 100644 drawing/papaya/reference/allclasses-frame.html create mode 100644 drawing/papaya/reference/allclasses-noframe.html create mode 100644 drawing/papaya/reference/constant-values.html create mode 100644 drawing/papaya/reference/deprecated-list.html create mode 100644 drawing/papaya/reference/help-doc.html create mode 100644 drawing/papaya/reference/index-all.html create mode 100644 drawing/papaya/reference/index.html create mode 100644 drawing/papaya/reference/overview-tree.html create mode 100644 drawing/papaya/reference/package-list create mode 100644 drawing/papaya/reference/papaya/BoxPlot.html create mode 100644 drawing/papaya/reference/papaya/Cast.html create mode 100644 drawing/papaya/reference/papaya/Comparison.TTest.html create mode 100644 drawing/papaya/reference/papaya/Comparison.html create mode 100644 drawing/papaya/reference/papaya/Correlation.Significance.html create mode 100644 drawing/papaya/reference/papaya/Correlation.Weighted.html create mode 100644 drawing/papaya/reference/papaya/Correlation.html create mode 100644 drawing/papaya/reference/papaya/CorrelationPlot.html create mode 100644 drawing/papaya/reference/papaya/Descriptive.Mean.html create mode 100644 drawing/papaya/reference/papaya/Descriptive.Pooled.html create mode 100644 drawing/papaya/reference/papaya/Descriptive.Sum.html create mode 100644 drawing/papaya/reference/papaya/Descriptive.Weighted.html create mode 100644 drawing/papaya/reference/papaya/Descriptive.html create mode 100644 drawing/papaya/reference/papaya/Distance.html create mode 100644 drawing/papaya/reference/papaya/Eigenvalue.html create mode 100644 drawing/papaya/reference/papaya/Find.html create mode 100644 drawing/papaya/reference/papaya/Frequency.html create mode 100644 drawing/papaya/reference/papaya/Gamma.html create mode 100644 drawing/papaya/reference/papaya/LU.html create mode 100644 drawing/papaya/reference/papaya/Linear.BoxCox.html create mode 100644 drawing/papaya/reference/papaya/Linear.Significance.html create mode 100644 drawing/papaya/reference/papaya/Linear.StdErr.html create mode 100644 drawing/papaya/reference/papaya/Linear.html create mode 100644 drawing/papaya/reference/papaya/MDS.html create mode 100644 drawing/papaya/reference/papaya/Mat.html create mode 100644 drawing/papaya/reference/papaya/NaNs.html create mode 100644 drawing/papaya/reference/papaya/Normality.Dago.html create mode 100644 drawing/papaya/reference/papaya/Normality.html create mode 100644 drawing/papaya/reference/papaya/OneWayAnova.html create mode 100644 drawing/papaya/reference/papaya/PapayaConstants.html create mode 100644 drawing/papaya/reference/papaya/Polynomial.html create mode 100644 drawing/papaya/reference/papaya/Probability.html create mode 100644 drawing/papaya/reference/papaya/QR.html create mode 100644 drawing/papaya/reference/papaya/Rank.html create mode 100644 drawing/papaya/reference/papaya/SVD.html create mode 100644 drawing/papaya/reference/papaya/ScatterPlot.html create mode 100644 drawing/papaya/reference/papaya/Sorting.html create mode 100644 drawing/papaya/reference/papaya/SubPlot.html create mode 100644 drawing/papaya/reference/papaya/Unique.html create mode 100644 drawing/papaya/reference/papaya/Visuals.html create mode 100644 drawing/papaya/reference/papaya/package-frame.html create mode 100644 drawing/papaya/reference/papaya/package-summary.html create mode 100644 drawing/papaya/reference/papaya/package-tree.html create mode 100644 drawing/papaya/reference/resources/inherit.gif create mode 100644 drawing/papaya/reference/stylesheet.css create mode 100644 drawing/papaya/src/papaya/BoxPlot.java create mode 100644 drawing/papaya/src/papaya/Cast.java create mode 100644 drawing/papaya/src/papaya/Check.java create mode 100644 drawing/papaya/src/papaya/Comparison.java create mode 100644 drawing/papaya/src/papaya/Correlation.java create mode 100644 drawing/papaya/src/papaya/CorrelationPlot.java create mode 100644 drawing/papaya/src/papaya/Descriptive.java create mode 100644 drawing/papaya/src/papaya/Distance.java create mode 100644 drawing/papaya/src/papaya/Eigenvalue.java create mode 100644 drawing/papaya/src/papaya/Find.java create mode 100644 drawing/papaya/src/papaya/Frequency.java create mode 100644 drawing/papaya/src/papaya/Gamma.java create mode 100644 drawing/papaya/src/papaya/LU.java create mode 100644 drawing/papaya/src/papaya/Linear.java create mode 100644 drawing/papaya/src/papaya/MDS.java create mode 100644 drawing/papaya/src/papaya/Mat.java create mode 100644 drawing/papaya/src/papaya/NaNs.java create mode 100644 drawing/papaya/src/papaya/Normality.java create mode 100644 drawing/papaya/src/papaya/OneWayAnova.java create mode 100644 drawing/papaya/src/papaya/PapayaConstants.java create mode 100644 drawing/papaya/src/papaya/Polynomial.java create mode 100644 drawing/papaya/src/papaya/Probability.java create mode 100644 drawing/papaya/src/papaya/QR.java create mode 100644 drawing/papaya/src/papaya/Rank.java create mode 100644 drawing/papaya/src/papaya/SVD.java create mode 100644 drawing/papaya/src/papaya/ScatterPlot.java create mode 100644 drawing/papaya/src/papaya/Sorting.java create mode 100644 drawing/papaya/src/papaya/SubPlot.java create mode 100644 drawing/papaya/src/papaya/Unique.java create mode 100644 drawing/papaya/src/papaya/Visuals.java diff --git a/drawing/papaya/examples/BoxPlotExample/BoxPlotExample.pde b/drawing/papaya/examples/BoxPlotExample/BoxPlotExample.pde new file mode 100644 index 0000000..01ffa54 --- /dev/null +++ b/drawing/papaya/examples/BoxPlotExample/BoxPlotExample.pde @@ -0,0 +1,109 @@ +/* + Sketch demonstrating how to plot box plots using the BoxPlot class. + Author: Adila Faruk + */ + +// import the library +import papaya.*; +//import papaya.BoxPlot; +// --------------------- Sketch-wide variables ---------------------- +BoxPlot[] boxPlot = new BoxPlot[2]; +PFont titleFont, mediumFont, smallFont; + +float[] breaks; +int[] tension; +int minBreaks, maxBreaks; +float[][] fiveNumSummary; + +// boxplot labels +String[] xLabels = new String[] { + "L","M","H" +}; + + +// ----------------------------------- +void setup() { + size(630, 500); + smooth(); + noLoop(); + + titleFont = createFont("Helvetica", 22, true); + smallFont = createFont("Helvetica", 11, true); + mediumFont = createFont("Helvetica", 14, true); + // Read in the data + // This data set gives the number of warp breaks per loom, + // where a loom corresponds to a fixed length of yarn. + // breaks: number of breaks in wool + // tension: tension (L,M,H). + String lines[] = loadStrings("warpbreaks.txt"); + + int ln = lines.length-1; + breaks = new float[ln]; + tension = new int[ln]; + + for (int i=0; iVKD&{z(6pY+03R82Hk<6VHw2gfhWJ} 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 Owfy*7n@@fA1OE&2i5Uq1 literal 0 HcmV?d00001 diff --git a/drawing/papaya/examples/CorrelationAndCovariance/CorrelationAndCovariance.pde b/drawing/papaya/examples/CorrelationAndCovariance/CorrelationAndCovariance.pde new file mode 100644 index 0000000..413c37a --- /dev/null +++ b/drawing/papaya/examples/CorrelationAndCovariance/CorrelationAndCovariance.pde @@ -0,0 +1,121 @@ +/* +Example showing how to use some of the methods in the Correlation class. + The dataset consists of Garbage collected from a number of different households. + To load the file into R, use something similar to + garbage<-read.csv("/Users/adilapapaya/Desktop/Downloads/TrioloDatasets/GARBAGE.csv",header=TRUE,sep=",") + Adila Faruk, 2012. + */ + +// import the library +import papaya.*; + +String[] columnTitles; +int numColumns, numObs; // number of columns, and number of observations for each column +float[][] data;// data by household size +float[][] indivTrash; // data normalized by the household size. +CorrelationPlot cPlot; //Initialize the correlation plot + +void setup() { + size(500, 500); + noLoop(); + + parseData("GARBAGE.csv"); + int numDecimals =4; + // get the covariance matrix and print the results to screen + float[][] covMatrix = Correlation.cov(data, true); + println("\n\nCovariance Matrix"); + Mat.print(covMatrix,columnTitles,columnTitles,numDecimals); + + // get the correlation matrix and print the results to screen + float[][] corrMatrix = Correlation.linear(data, true); + println("\n\nCorrelation Matrix"); + Mat.print(corrMatrix,columnTitles,columnTitles,numDecimals); + + // get the spearman correlation matrix + float[][] spearmanCorrMatrix =Correlation.spearman(data, true); + println("\n\nSpearman Correlation Matrix"); + Mat.print(spearmanCorrMatrix,columnTitles,columnTitles,numDecimals); + + + /* For a weighted analysis, lets make the weight[i] = 1/householdsize[i]. + (i.e. look at things on an individual basis).*/ + float[] HHSize = Mat.column(data,0); + float[] weights = Mat.inverse(HHSize,0); // if HHSize[i]==0, weights[i] = 0; + + // get the weighted covariance matrix, + float[][] weightedCovMatrix = Correlation.Weighted.cov(data, weights, true); + println("\n\nWeighted Covariance Matrix"); + Mat.print(weightedCovMatrix,columnTitles,columnTitles,numDecimals); + + + // get the weighted correlation matrix + float[][] weightedCorrMatrix =Correlation.Weighted.corr(data, weights, true); + println("\n\nWeighted Correlation Matrix"); + Mat.print(weightedCorrMatrix,columnTitles,columnTitles,numDecimals); + println(); + + noLoop(); +} + +// Drawing -------------------------------------------------- +float xLeft = 40, yTop = 40, xWidth = 420, yHeight = 420; +color steelblue = 0xff1f77b4; +color orange = 0xffff7f0e; +color backgroundColor = color(250); +// font +PFont titleFont = createFont("Helvetica", 15, true); +PFont smallFont = createFont("Helvetica", 12, true); +PFont tinyFont = createFont("Helvetica", 9, true); + +// Display all the data. The top left displays the raw data, the +// bottom right displays data normalized by household size. +// Interesting to see if the data distribution matches the correlation coefficients given in the +// corr and weighted correlation matrices. +void draw(){ + background(0); + cPlot = new CorrelationPlot(this, xLeft,yTop,xWidth,yHeight); + // draws the border & writes the labels. do this BEFORE drawing the data or you'll + // cover it up. + textFont(smallFont); // setting up the font prior to plotting. + cPlot.drawBorderAndLabels(columnTitles, backgroundColor); + // Labeling -------------------------- + + textFont(titleFont); fill(240); textAlign(RIGHT,BOTTOM); + text("Household Trash", xLeft + xWidth, yTop -5); + textAlign(LEFT,TOP); + text("Household Trash Normalized by Household Size",xLeft, yTop + yHeight + 5); + + // draw the correlation plot + // syntax: drawPlot(data, topRight(0) or bottomLeft(1), color of the dots, backgroundcolor; + // raw data + cPlot.drawPlot(data,0,steelblue); + // data normalized by household size + cPlot.drawPlot(indivTrash,1,orange); + + saveFrame("CorrelationMatrix.png"); +} + +// parses the input file and organize the data +public void parseData(String fileName){ + // HHSIZE METAL PAPER PLAS GLASS FOOD YARD, TEXT OTHER TOTAL + String[] s= loadStrings(fileName); + columnTitles = splitTokens(s[0], ","); + numObs = s.length-1; + numColumns = columnTitles.length; + data = new float[numObs][ numColumns]; + indivTrash = new float[numObs][ numColumns]; // excludes the hhsize column + // read in the rest of the data + for (int i=0; iHPcbyZ3#) zFZY2lnjYO<_0_7iYSx@{MW`srpdk|@LqS2I$;nEoK|w*^{QEJolVu7PL&)Ec`CAJB zG3q}9_M?E_cSPUJ#!{F+fBsCsYAEFWaIsWt=6EUkel5DQvs0{;{q_E3(eIU@ODT&F zE7#HS`R;6QZ;zj!-^l0or*Ya4g4NW~(b3@GV7uGdQ}_F`DD>wIpL+v8zjx<@iQm6} zBlT1!R1<TUuHyb381r_s1cze0XZ#c%2v={LIN&pO
vd6dmBxb#No@(S9Aww$Uj+yKCyt;w?6{c$q z1lk|Z1in06rljBtNs$<_w+s&qWQqEb`L{dm{h66jdr@Tt4C5(q($mwQcixkA{pw0{ z-=EACH5)?3#b|suQuZsW{9m)=1`A-fz#d*cj?(59X1%f`bu_pl6e46n{;s7b)~sr=+B;loeDiDP%!5GFNnuFdN&23{cI*g)88>OtYMr zgv9SEDHriREG+DNtzDa><$c)i1)<@MQM*d)@pU&z*}u%C|JRo&Ku}av)VLi31H($K z8A3kwjrrE&+1Xi-m7O;n;Qi^On$@T)x_h?z{W14_83d|eZF%2g^}{ks7jR|R#}E}2 zt$@8?q@lK(pVqRaQG#R@vGitD|9+S6t7l%#Zt>=(F;Yt$F?VE7c7yHVbXQjwWcN%h zAVCL2`-{rR4Bt|EKA$zu18I;xH(uiPtSv7;f?A#Xszu)}<4#UaZsCBn`H<-B&|NH4 z>WjWT?7*SmW473o$2OUAIzsmS^cpnyUtCm9G5j8ajLCjjTkAF3uTA>BIkWS1-OR{; z0LO_ul^A8BD{J-5jf*!t`gZ7#*&-ySJZ?$#h0w&62jsjCmm@XrnwlESWP8}Z z91@SC=v1c|-4}f*-&3ZwNa4YdCu?i(eNF9t*&B=^;I&)1f#fgZ;oajwu2HAwPqyZ~ zJg60L?%NG*$r-J34mE&W*we+?`Ff1C8

ERM{6B8yhB@fcO2m`&|%>frbWW`quq^ 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 $5mI157FGV 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 literal 0 HcmV?d00001 diff --git a/drawing/papaya/examples/CorrelationAndCovariance/data/GARBAGE.csv b/drawing/papaya/examples/CorrelationAndCovariance/data/GARBAGE.csv new file mode 100644 index 0000000..e409b5b --- /dev/null +++ b/drawing/papaya/examples/CorrelationAndCovariance/data/GARBAGE.csv @@ -0,0 +1 @@ +HHSize,Metal,Paper,Plastic,Glass,Food,Yard,Text,Other,Total 2,1.09,2.41,0.27,0.86,1.04,0.38,0.05,4.66,10.76 3,1.04,7.57,1.41,3.46,3.68,0,0.46,2.34,19.96 3,2.57,9.55,2.19,4.52,4.43,0.24,0.5,3.6,27.6 6,3.02,8.82,2.83,4.92,2.98,0.63,2.26,12.65,38.11 4,1.5,8.72,2.19,6.31,6.3,0.15,0.55,2.18,27.9 2,2.1,6.96,1.81,2.49,1.46,4.58,0.36,2.14,21.9 1,1.93,6.83,0.85,0.51,8.82,0.07,0.6,2.22,21.83 5,3.57,11.42,3.05,5.81,9.62,4.76,0.21,10.83,49.27 6,2.32,16.08,3.42,1.96,4.41,0.13,0.81,4.14,33.27 4,1.89,6.38,2.1,17.67,2.73,3.86,0.66,0.25,35.54 4,3.26,13.05,2.93,3.21,9.31,0.7,0.37,11.61,44.44 7,3.99,11.36,2.44,4.94,3.59,13.45,4.25,1.15,45.17 3,2.04,15.09,2.17,3.1,5.36,0.74,0.42,4.15,33.07 5,0.99,2.8,1.41,1.39,1.47,0.82,0.44,1.03,10.35 6,2.96,6.44,2,5.21,7.06,6.14,0.2,14.43,44.44 2,1.5,5.86,0.93,2.03,2.52,1.37,0.27,9.65,24.13 4,2.43,11.08,2.97,1.74,1.75,14.7,0.39,2.54,37.6 4,2.97,12.43,2.04,3.99,5.64,0.22,2.47,9.2,38.96 3,1.42,6.05,0.65,6.26,1.93,0,0.86,0,17.17 3,3.6,13.61,2.13,3.52,6.46,0,0.96,1.32,31.6 2,4.48,6.98,0.63,2.01,6.72,2,0.11,0.18,23.11 2,1.36,14.33,1.53,2.21,5.76,0.58,0.17,1.62,27.56 4,2.11,13.31,4.69,0.25,9.72,0.02,0.46,0.4,30.96 1,0.41,0.27,0.15,0.09,0.16,0,0,0,1.08 4,2.02,6.67,1.45,6.85,5.52,0,0.68,0.03,23.22 6,3.27,17.65,2.68,2.33,11.92,0.83,0.28,4.03,42.99 11,4.95,12.73,3.53,5.45,4.68,0,0.67,19.89,51.9 3,1,9.83,1.49,2.04,4.76,0.42,0.54,0.12,20.2 4,1.55,16.39,2.31,4.98,7.85,2.04,0.2,1.48,36.8 3,1.41,6.33,0.92,3.54,2.9,3.85,0.03,0.04,19.02 2,1.05,9.19,0.89,1.06,2.87,0.33,0.01,0.03,15.43 2,1.31,9.41,0.8,2.7,5.09,0.64,0.05,0.71,20.71 2,2.5,9.45,0.72,1.14,3.17,0,0.02,0.01,17.01 4,2.35,12.32,2.66,12.24,2.4,7.87,4.73,0.78,45.35 6,3.69,20.12,4.37,5.67,13.2,0,1.15,1.17,49.37 2,3.61,7.72,0.92,2.43,2.07,0.68,0.63,0,18.06 2,1.49,6.16,1.4,4.02,4,0.3,0.04,0,17.41 2,1.36,7.98,1.45,6.45,4.27,0.02,0.12,2.02,23.67 2,1.73,9.64,1.68,1.89,1.87,0.01,1.73,0.58,19.13 2,0.94,8.08,1.53,1.78,8.13,0.36,0.12,0.05,20.99 3,1.33,10.99,1.44,2.93,3.51,0,0.39,0.59,21.18 3,2.62,13.11,1.44,1.82,4.21,4.73,0.64,0.49,29.06 2,1.25,3.26,1.36,2.89,3.34,2.69,0,0.16,14.95 2,0.26,1.65,0.38,0.99,0.77,0.34,0.04,0,4.43 3,4.41,10,1.74,1.93,1.14,0.92,0.08,4.6,24.82 6,3.22,8.96,2.35,3.61,1.45,0,0.09,1.12,20.8 4,1.86,9.46,2.3,2.53,6.54,0,0.65,2.45,25.79 4,1.76,5.88,1.14,3.76,0.92,1.12,0,0.04,14.62 3,2.83,8.26,2.88,1.32,5.14,5.6,0.35,2.03,28.41 3,2.74,12.45,2.13,2.64,4.59,1.07,0.41,1.14,27.17 10,4.63,10.58,5.28,12.33,2.94,0.12,2.94,15.65,54.47 3,1.7,5.87,1.48,1.79,1.42,0,0.27,0.59,13.12 6,3.29,8.78,3.36,3.99,10.44,0.9,1.71,13.3,45.77 5,1.22,11.03,2.83,4.44,3,4.3,1.95,6.02,34.79 4,3.2,12.29,2.87,9.25,5.91,1.32,1.87,0.55,37.26 7,3.09,20.58,2.96,4.02,16.81,0.47,1.52,2.13,51.58 5,2.58,12.56,1.61,1.38,5.01,0,0.21,1.46,24.81 4,1.67,9.92,1.58,1.59,9.96,0.13,0.2,1.13,26.18 2,0.85,3.45,1.15,0.85,3.89,0,0.02,1.04,11.25 4,1.52,9.09,1.28,8.87,4.83,0,0.95,1.61,28.15 2,1.37,3.69,0.58,3.64,1.78,0.08,0,0,11.14 2,1.32,2.61,0.74,3.03,3.37,0.17,0,0.46,11.7 \ No newline at end of file diff --git a/drawing/papaya/examples/LinearAlgebra/LinearAlgebra.pde b/drawing/papaya/examples/LinearAlgebra/LinearAlgebra.pde new file mode 100644 index 0000000..03ab1a9 --- /dev/null +++ b/drawing/papaya/examples/LinearAlgebra/LinearAlgebra.pde @@ -0,0 +1,184 @@ +/* + Example showing how to apply some of the matrix decomposition methods. + The dataset consists of Bear Measurements (why not, right?). + the matrix analyzed is the covariance matrix which is both square and symmetric. + Feel free to switch things up with a non-square matrix, or an asymmetric one. + + To load the file into R, use something along the lines of + garbage<-read.csv("/Users/adilapapaya/Desktop/Downloads/TrioloDatasets/BEARS.csv",header=TRUE,sep=",") + Adila Faruk, 2012. + */ + +// import the library +import papaya.*; + +String[] columnTitles; +int numColumns, numObs, numM, numF; // number of columns, and number of observations for each column +float[][] data, dataM, dataF;// bear data +CorrelationPlot cPlot; //Initialize the correlation plot + +void setup() { + size(500, 500); + noLoop(); + + parseData("BEARS.csv"); + int numDecimals =4; + // get the covariance matrix. we'll use this as the core matrix + // in the matrix decompositions methods to follow. + float[][] covMatrix = Correlation.cov(data, true); + println("\n\nCovariance Matrix"); + Mat.print(covMatrix,columnTitles,columnTitles,numDecimals); + + // now the fun starts. :) + + // 1. Eigenvalues --------------------------------------------------- + //------------------------------------------------------------------- + Eigenvalue eigen = new Eigenvalue(covMatrix); + // cast the eigenvector matrix to a float array for printing to screen + float[][] V = Cast.doubleToFloat(eigen.getV()); + println("\nEigenvector Matrix"); + Mat.print(V,numDecimals); + float[][] D = Cast.doubleToFloat(eigen.getD()); + println("\nBlock Diagonal Eigenvalue Matrix."); + Mat.print(D,numDecimals); + // check if covMatrix*v = lambda*v, where v is an eigenvector. + float[] v = Mat.column(V,0); float lambda = D[0][0]; + float[] cv = Mat.multiply(covMatrix,v); float[] lambdav = Mat.multiply(v,lambda); + println("\nCovarianceMatrix * v - Lambda * v"); + Mat.print(Mat.subtract(cv,lambdav),4); + + // 2. SVD Decomposition --------------------------------------------- + //------------------------------------------------------------------- + SVD svd = new SVD(covMatrix); + // covMatrix = U * S * transpose(V) + int rank = svd.rank(); + float cond = (float)svd.cond(); + println("\nSVD Decomposition:\nRank is "+rank+", Condition Number is "+cond); + float[][] U = Cast.doubleToFloat(svd.getU()); + println("\nU"); + Mat.print(U,numDecimals); + float[][] S = Cast.doubleToFloat(svd.getS()); + println("\nS"); + Mat.print(S,numDecimals); + float[][] VTrans = Mat.transpose( Cast.doubleToFloat(svd.getV()) ); + println("\nTranspose(V)"); + Mat.print(VTrans,numDecimals); + println("\nNotice that, since the input matrix is symmetric, U = V via the Spectral Decomposition Theorem. :)"); + + // 3. LU Decomposition --------------------------------------------- + //------------------------------------------------------------------- + LU lu = new LU(covMatrix); + // covMatrix * pivotArray = L*U + float det = (float)lu.det(); + println("\nLU Decomposition:\nDeterminant is "+det +" (=the product of singular values or eigenvalues)" ); + float[][] L = Cast.doubleToFloat(lu.getL()); + println("\nL"); + Mat.print(L,numDecimals); + U = Cast.doubleToFloat(lu.getU()); + println("\nU"); + Mat.print(U,numDecimals); + + // 4. QR Decomposition --------------------------------------------- + //------------------------------------------------------------------ + QR qr = new QR(covMatrix); + // covMatrix = Q*R + println("\nQR Decomposition"); + float[][] Q = Cast.doubleToFloat(qr.getQ()); + println("\nQ"); + Mat.print(Q,numDecimals); + float[][] R = Cast.doubleToFloat(qr.getR()); + println("\nR"); + Mat.print(R,numDecimals); + + // Solving a system of linear equations -------------------- + // Using QR: Least squares solution of A*X = B + // where A and B both have the same number of rows + + float[][] A = new float[][]{{1,5,9},{2,4,6},{1,6,3}}; + float[][] B = new float[][]{{2,3,-1},{9,3,1},{3,2,8}}; + //float[] B = new float[]{2,9,-1}; // if you want to try the case where B is an array + float[][] X = Cast.doubleToFloat( new QR(A).solve(B) ); + println("\nQR Least squares solution X, to A*X = B"); + Mat.print(X,numDecimals); + //Mat.print(Mat.multiply(A,X),numDecimals); // should equal B + + + // Using LU: Best for solving square matrices so we take just the upper 2x2 part of x + X = Cast.doubleToFloat( new LU(A).solve(B) ); + println("\nLU solution X, to A*X = B"); + Mat.print(X,numDecimals); + //Mat.print(Mat.multiply(A,X),numDecimals); // should equal B +} + +// Drawing -------------------------------------------------- +float xLeft = 40, yTop = 40, xWidth = 420, yHeight = 420; +color b =color(50,80,250,150); // blue +color g=color(50,200,100,200); // green +color backgroundColor = color(250); +// font +PFont titleFont = createFont("Helvetica", 15, true); +PFont smallFont = createFont("Helvetica", 12, true); +PFont tinyFont = createFont("Helvetica", 9, true); +String[] sex = {"Female Bears","Male Bears"}; +// Display all the data. The top left displays the raw data, the +// bottom right displays data normalized by household size. +// Interesting to see if the data distribution matches the correlation coefficients given in the +// corr and weighted correlation matrices. +void draw(){ + background(255); + cPlot = new CorrelationPlot(this, xLeft,yTop,xWidth,yHeight); + // draws the border & writes the labels. do this BEFORE drawing the data or you'll + // cover it up. + textFont(smallFont); fill(240);// setting up the font prior to plotting. + cPlot.drawBorderAndLabels(columnTitles, backgroundColor); + // Labeling -------------------------- + + textFont(titleFont); fill(100); textAlign(RIGHT,BOTTOM); + text("All Bears", xLeft + xWidth, yTop -5); + textAlign(LEFT,TOP); + text(sex[sexIndex%2],xLeft, yTop + yHeight + 5); + + // draw the correlation plot + // syntax: drawPlot(data, topRight(0) or bottomLeft(1), color of the dots, backgroundcolor; + // raw data + cPlot.drawPlot(data,0,b); + // data normalized by household size + if(sexIndex%2==0) cPlot.drawPlot(dataF,1,g); + else cPlot.drawPlot(dataM,1,g); +} + +// parses the input file and organize the data + +public void parseData(String fileName){ + // SEX AGE HEADLEN HEADWTH NECK LENGTH CHEST WEIGHT + String[] s= loadStrings(fileName); + columnTitles = splitTokens(s[0], ","); + columnTitles = subset(columnTitles,1,columnTitles.length-1); // remove the column containing the sex + numObs = s.length-1; + numM = 35; numF = numObs - numM; + numColumns = columnTitles.length; + data = new float[numObs][numColumns]; + dataM = new float[numM][numColumns]; + dataF = new float[numF][numColumns]; +// indivTrash = new float[numObs][ numColumns]; // excludes the hhsize column + // read in the rest of the data + for (int i=0; ix vs y data and the best-fit linear + * line for that data. + * @author Adila Faruk + */ +public class LinearModelPlot extends Visuals { + private PApplet myParent; + boolean drawRectangle = true, drawAxes = true; + + public float leftBound = 40, rightBound=20; + public float topBound = 20, bottomBound=20; + + float minX, minY, maxX, maxY; // plot min/max + float minXDat, minYDat, maxXDat, maxYDat; // data min/max + boolean dataExtremesHaveBeenSet = false; + + // best fit line + int sColor = color(200, 100, 100); // stroke color for the best fit line + float sWeight = 1; // stroke weight for the best fit line + boolean writeLineEquation = true; + + /**Constructor */ + public LinearModelPlot(PApplet _theParent, float _plotLeft, float _plotTop, float _plotWidth, float _plotHeight) { + super(_theParent, _plotLeft, _plotTop, _plotWidth, _plotHeight); + myParent = _theParent; + bgColor = super.bgColor; + } + + /* Set the minimum/maximum values on the x and y axis to nice numbers. + E.g. 60 instead of 63.183628, 90 instead of 87.1, etc. */ + public void setDataExtremes(float _minXDat, float _maxXDat, float _minYDat, float _maxYDat) { + minXDat = _minXDat; + maxXDat = _maxXDat; + minYDat = _minYDat; + maxYDat = _maxYDat; + dataExtremesHaveBeenSet = true; + } + + /* Plots the scatter plot of the data. + x,y the x-y dataset of interest. + _fColor the color of the ellipses corresponding to each x-y pair + */ + public void drawXY( float[] x, float[] y, int _fColor) { + if (drawRectangle) { + drawRect(plotLeft-leftBound, plotTop-topBound, plotWidth+leftBound+rightBound, plotHeight+topBound+bottomBound, bgColor); + } + if (drawAxes) { + drawAxes(50, .5f); + } + // Check if the data extemes have been set. + if (!dataExtremesHaveBeenSet) { + throw new IllegalStateException("Set the data extremes first."); + } + + // map the data. + float[] xDatMapped = Mat.map(x, minXDat, maxXDat, plotLeft, plotLeft+plotWidth); + float[] yDatMapped = Mat.map(y, minYDat, maxYDat, plotTop+plotHeight, plotTop); + minX = Descriptive.min(xDatMapped); + maxX = Descriptive.max(xDatMapped); + minY = Descriptive.min(yDatMapped); + maxY = Descriptive.max(yDatMapped); + myParent.fill(_fColor); + myParent.noStroke(); + myParent.smooth(); + for (int i=0; ix1,y1 to x2,y2. + * + * The multiplier c ( 0 <= c<= 0.5 ) is chosen such that + * the points (x1,y1) and (x2,y2) are in the rectangle with corners + * + * (meanX-c*rangeX/2, meanY+c*rangeY/2) (meanX+c*rangeX/2, meanY+c*rangeY/2) + * + * (meanX-c*rangeX/2, meanY-c*rangeY/2) (meanX+c*rangeX/2, meanY-c*rangeY/2) + * + * where + * rangeX = _maxX - _minX + * and + * rangeY = _maxY - _minY. + * This is done in the most inefficient way possible in the universe... :) + * @param coeff, the slope and intercept where coeff[0] = slope, coeff[1] = intercept + * @param meanVals = float[]{mean(x),mean(y)}} + * @param multiplier corresponds to c above and is the multiplier to use when plotting + * the line. A smaller c value results in a longer line. The default it set to .15, and will be used if a + * value of c<= 0 or c >=.50 is entered. + */ + public void drawBestFitLine(float[] coeff, float[] meanVals, float multiplier) { + // Check if the data extemes have been set. + if (!dataExtremesHaveBeenSet) { + throw new IllegalStateException("Set the data extremes first."); + } + + float meanX = meanVals[0]; + float meanY = meanVals[1]; + float x1, y1, x2, y2; + float slope = coeff[0]; + float intercept = coeff[1]; + float mult; + if (multiplier<0 || multiplier>=.5) { + mult = .15f; + } + else mult = 1-multiplier; + + x1 = (meanX+mult*(minXDat-meanX)); + y1= slope*(x1)+intercept; + x2 = (meanX+mult*(maxXDat-meanX)); + y2= slope*(x2)+intercept; + if (slope!=0) { + // if the intercept b is less than the minimum y value + // update the left-most point + if (y1meanY+mult*(maxYDat-meanY)) { + y2 = meanY+mult*(maxYDat-meanY); + x2 = (y2-intercept)/slope; + } + } + + // map to the plot parameters + float[] xFit = Mat.map(new float[] {x1, x2}, minXDat, maxXDat, minX, maxX); + float[] yFit = Mat.map(new float[] {y1, y2}, minYDat, maxYDat, maxY, minY); + // draw the line + line(xFit[0], yFit[0], xFit[1], yFit[1], sColor, sWeight); + + // draw an ellipse at the mean value. + meanX = Mat.map(meanX, minXDat, maxXDat, minX, maxX); + meanY = Mat.map(meanY, minYDat, maxYDat, maxY, minY); + myParent.fill(sColor); + myParent.noStroke(); + myParent.ellipse(meanX, meanY, 6, 6); + + if (writeLineEquation) { + if (yFit[1] same-age bears are more similar. + + // NOTE: + // You can also use the MDS.classical scaling method to find the x-y configuration + // of points which capture most of the variation in the distances. + // Since the input distance matrix is euclidean, + // the output coordinates are exactly the first p principal coordinate components. + // Set p = 2 to plot the results in a plane. + /* + float[][] cmdscale = MDS.classical(euclidean, 2,false); + x = new float[cmdscale.length]; y = new float[cmdscale.length]; + x = Mat.column(cmdscale,0); y = Mat.column(cmdscale,1); + //and then plot x vs y // + */ + + // Labeling -------------------------- + textFont(titleFont); + fill(50,90,200); + textAlign(LEFT,BOTTOM); smooth(); + text("Euclidian Distance Metrics Between Bears." , xLeft, yTop-40); + textAlign(LEFT, TOP); + textFont(smallFont); + text("Darker colors indicate closer distances showing bears which are more 'similar'.\n"+ + "(Try sorting the csv file by something other than weight to see if you can find other patterns.)", + xLeft,yTop-35); +} + +// parses the input file and organize the data +public void parseData(String fileName) { + // SEX AGE HEADLEN HEADWTH NECK LENGTH CHEST WEIGHT + String[] s= loadStrings(fileName); + columnTitles = splitTokens(s[0], ","); + columnTitles = subset(columnTitles, 1, columnTitles.length-1); // remove the column containing the sex + numObs = s.length-1; + numM = 35; + numF = numObs - numM; + numColumns = columnTitles.length; + data = new float[numObs][numColumns]; + age = new float[numObs]; + // read in the rest of the data + for (int i=0; iBD = new ArrayList(); // brain damage + ArrayListSI = new ArrayList(); // stupidity index + for(int i=0; i<3; i++){ + BD.add(stooge[i].bDamage); + SI.add(stooge[i].sIndex); + } + // cast the ArrayList to the "Collection" interface. + OneWayAnova anovaBD = new OneWayAnova((Collection)BD); + OneWayAnova anovaSI = new OneWayAnova((Collection)SI); + println("p-value for testing the null hypothesis of no difference in brain damage: "+ anovaBD.pValue()); + println("p-value for testing the null hypothesis of no difference in stupidity index: "+ anovaSI.pValue()); +} + + +// Drawing -------------------------------------------------- +float xLeft = 40, yTop = 40, xWidth = 420, yHeight = 420; +color b =color(50,80,250,150); // blue +color g= color(50,200,100,200); // green +color r= color(200,100,100,200); // red +int[] stoogeColor = new int[]{r,g,b}; +color backgroundColor = color(250); +// font +PFont titleFont = createFont("Helvetica", 15, true); +PFont smallFont = createFont("Helvetica", 12, true); + +void draw(){ + background(255); + ScatterPlot s = new ScatterPlot(this,xLeft,yTop,xWidth,yHeight); + s.setDataExtremes(0,70,0,70); + s.drawRectangle=false; + smooth(); + for(int i=0; i<3; i++){ + s.drawScatterPlot(stooge[i].bDamage,stooge[i].sIndex,0,stoogeColor[i]); + } + textFont(smallFont); fill(100); + text("Leaving the labeling in your hands...",50,60); +} + +// create a "stooge" class to store the brain damage and stupidity index, by stooge. + +public class Stooge{ + float[] bDamage, sIndex; + String name; + int ln; // number of observations in that group + + // get the data from idxStart(inclusive) to idxEnd + public Stooge(String name, float[][] data, int iStart,int ln){ + this.ln = ln; + this.name = name; + this.bDamage = new float[ln]; this.sIndex = new float[ln]; + for(int i=0; i cutoff){ + fill(50); textFont(tinyFont); textAlign(LEFT,CENTER); + text(nfc(value,1)+" kg", xPos + 3, pct); + fill(high); + } + else { + fill(low); + } + ellipse(xPos,pct,4,4); + } + } + + // Labeling. Messy. Feel free to ignore. + String[] xLabels = new String[uSize]; + for(int i=0; i0){ + currentTrash--; + redraw(); + } + } +} + +// parses the input file +public void parseData(String fileName){ + // HHSIZE METAL PAPER PLAS GLASS FOOD YARD, TEXT OTHER TOTAL + String[] s= loadStrings(fileName); + columnTitles = splitTokens(s[0], ","); + numObs = s.length-1; + numColumns = columnTitles.length; + data = new float[numObs][ numColumns]; + indivTrash = new float[numObs][ numColumns-1]; // excludes the hhsize column + pctTotal = new float[numObs][numColumns-1]; // excludes the hhsize column + // read in the rest of the data + for (int i=0; ihynfM2Mq)UBrmQeOfRhI5x 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

Js7xql+t}F4`rSoR#tkNd@V_$=sBi)ksHWk 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 literal 0 HcmV?d00001 diff --git a/drawing/papaya/reference/allclasses-frame.html b/drawing/papaya/reference/allclasses-frame.html new file mode 100644 index 0000000..5089b69 --- /dev/null +++ b/drawing/papaya/reference/allclasses-frame.html @@ -0,0 +1,109 @@ + + + + + + +All Classes (Javadocs: papaya) + + + + + + + + + + + +All Classes +
+ + + + + +
BoxPlot +
+Cast +
+Comparison +
+Comparison.TTest +
+Correlation +
+Correlation.Significance +
+Correlation.Weighted +
+CorrelationPlot +
+Descriptive +
+Descriptive.Mean +
+Descriptive.Pooled +
+Descriptive.Sum +
+Descriptive.Weighted +
+Distance +
+Eigenvalue +
+Find +
+Frequency +
+Gamma +
+Linear +
+Linear.BoxCox +
+Linear.Significance +
+Linear.StdErr +
+LU +
+Mat +
+MDS +
+NaNs +
+Normality +
+Normality.Dago +
+OneWayAnova +
+PapayaConstants +
+Polynomial +
+Probability +
+QR +
+Rank +
+ScatterPlot +
+Sorting +
+SubPlot +
+SVD +
+Unique +
+Visuals +
+
+ + + diff --git a/drawing/papaya/reference/allclasses-noframe.html b/drawing/papaya/reference/allclasses-noframe.html new file mode 100644 index 0000000..b5c60eb --- /dev/null +++ b/drawing/papaya/reference/allclasses-noframe.html @@ -0,0 +1,109 @@ + + + + + + +All Classes (Javadocs: papaya) + + + + + + + + + + + +All Classes +
+ + + + + +
BoxPlot +
+Cast +
+Comparison +
+Comparison.TTest +
+Correlation +
+Correlation.Significance +
+Correlation.Weighted +
+CorrelationPlot +
+Descriptive +
+Descriptive.Mean +
+Descriptive.Pooled +
+Descriptive.Sum +
+Descriptive.Weighted +
+Distance +
+Eigenvalue +
+Find +
+Frequency +
+Gamma +
+Linear +
+Linear.BoxCox +
+Linear.Significance +
+Linear.StdErr +
+LU +
+Mat +
+MDS +
+NaNs +
+Normality +
+Normality.Dago +
+OneWayAnova +
+PapayaConstants +
+Polynomial +
+Probability +
+QR +
+Rank +
+ScatterPlot +
+Sorting +
+SubPlot +
+SVD +
+Unique +
+Visuals +
+
+ + + diff --git a/drawing/papaya/reference/constant-values.html b/drawing/papaya/reference/constant-values.html new file mode 100644 index 0000000..8585797 --- /dev/null +++ b/drawing/papaya/reference/constant-values.html @@ -0,0 +1,277 @@ + + + + + + +Constant Field Values (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package  Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV  + NEXT + FRAMES   + NO FRAMES   +  + + + +
+ + + +
+
+

+Constant Field Values

+
+
+Contents + + + + + + +
+papaya.*
+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
papaya.PapayaConstants
+public static final intBASELINE0
+public static final doublebig4.503599627370496E15
+public static final doublebiginv2.220446049250313E-16
+public static final intBOTTOM102
+public static final intCENTER3
+public static final intCORNER0
+public static final StringFONTNAME"Helvetica"
+public static final intINDEX_NOT_FOUND-1
+public static final intLEFT37
+public static final doubleLOGPI1.1447298858494002
+public static final doubleMACHEP1.1102230246251565E-16
+public static final doubleMAXGAM171.6243769563027
+public static final doubleMAXLOG709.782712893384
+public static final doubleMINLOG-745.1332191019412
+public static final intRIGHT39
+public static final doubleSQRTH0.7071067811865476
+public static final doubleSQTPI2.5066282746310007
+public static final intTOP101
+ +

+ +

+

+ + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package  Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV  + NEXT + FRAMES   + NO FRAMES   +  + + + +
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/deprecated-list.html b/drawing/papaya/reference/deprecated-list.html new file mode 100644 index 0000000..32cbfde --- /dev/null +++ b/drawing/papaya/reference/deprecated-list.html @@ -0,0 +1,147 @@ + + + + + + +Deprecated List (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package  Class  Tree   Deprecated  Index  Help 
+		 + +
+ PREV  + NEXT + FRAMES   + NO FRAMES   +  + + + +
+ + + +
+
+

+Deprecated API

+
+
+Contents
    +
+ +
+ + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package  Class  Tree   Deprecated  Index  Help 
+		 + +
+ PREV  + NEXT + FRAMES   + NO FRAMES   +  + + + +
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/help-doc.html b/drawing/papaya/reference/help-doc.html new file mode 100644 index 0000000..77f1c9e --- /dev/null +++ b/drawing/papaya/reference/help-doc.html @@ -0,0 +1,214 @@ + + + + + + +API Help (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package  Class  Tree  Deprecated  Index   Help 
+		 + +
+ PREV  + NEXT + FRAMES   + NO FRAMES   +  + + + +
+ + + +
+
+

+How This API Document Is Organized

+
+This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.

+Package

+
+ +

+Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain four categories:

    +
  • Interfaces (italic)
  • Classes
  • Enums
  • Exceptions
  • Errors
  • Annotation Types
+
+

+Class/Interface

+
+ +

+Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:

    +
  • Class inheritance diagram
  • Direct Subclasses
  • All Known Subinterfaces
  • All Known Implementing Classes
  • Class/interface declaration
  • Class/interface description +

    +

  • Nested Class Summary
  • Field Summary
  • Constructor Summary
  • Method Summary +

    +

  • Field Detail
  • Constructor Detail
  • Method Detail
+Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
+ +

+Annotation Type

+
+ +

+Each annotation type has its own separate page with the following sections:

    +
  • Annotation Type declaration
  • Annotation Type description
  • Required Element Summary
  • Optional Element Summary
  • Element Detail
+
+ +

+Enum

+
+ +

+Each enum has its own separate page with the following sections:

    +
  • Enum declaration
  • Enum description
  • Enum Constant Summary
  • Enum Constant Detail
+
+

+Tree (Class Hierarchy)

+
+There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
    +
  • When viewing the Overview page, clicking on "Tree" displays the hierarchy for all packages.
  • When viewing a particular package, class or interface page, clicking "Tree" displays the hierarchy for only that package.
+
+

+Deprecated API

+
+The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
+

+Index

+
+The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
+

+Prev/Next

+These links take you to the next or previous class, interface, package, or related page.

+Frames/No Frames

+These links show and hide the HTML frames. All pages are available with or without frames. +

+

+Serialized Form

+Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description. +

+

+Constant Field Values

+The Constant Field Values page lists the static final fields and their values. +

+ + +This help file applies to API documentation generated using the standard doclet. + +
+

+ + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package  Class  Tree  Deprecated  Index   Help 
+		 + +
+ PREV  + NEXT + FRAMES   + NO FRAMES   +  + + + +
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/index-all.html b/drawing/papaya/reference/index-all.html new file mode 100644 index 0000000..a4e4669 --- /dev/null +++ b/drawing/papaya/reference/index-all.html @@ -0,0 +1,2076 @@ + + + + + + +Index (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package  Class  Tree  Deprecated   Index  Help 
+		 + +
+ PREV  + NEXT + FRAMES   + NO FRAMES   +  + + + +
+ + + +A B C D E F G H I K L M N O P Q R S T U V W X Y Z
+

+A

+
+
abs(float[]) - +Static method in class papaya.Mat +
Return absolute values of an array +
abs(int[]) - +Static method in class papaya.Mat +
Return absolute values of an array +
arithmetic(float[]) - +Static method in class papaya.Descriptive.Mean +
Returns the arithmetic mean of a data sequence; + That is Sum( data[i] ) / data.length . +
arrayListToFloat(ArrayList<Float>) - +Static method in class papaya.Cast +
function for casting ArrayList to float[] +
arrayListToInt(ArrayList<Integer>) - +Static method in class papaya.Cast +
function for casting ArrayList to int[] +
asConnectedLines - +Variable in class papaya.ScatterPlot +
  +
asEllipses - +Variable in class papaya.ScatterPlot +
  +
asRectangles - +Variable in class papaya.ScatterPlot +
  +
auto(float[], int, float, float) - +Static method in class papaya.Correlation +
Computes the sample autocorrelation by removing the sample mean from the input series, + then normalizing the sequence by the sample variance. +
autoLag1(float[], float) - +Static method in class papaya.Correlation +
Returns the lag-1 autocorrelation of a dataset; + Note that this method uses computations different from + auto(data, 1, mean, variance). +
+
+

+B

+
+
BASELINE - +Static variable in interface papaya.PapayaConstants +
  +
bestFit(float[], float[]) - +Static method in class papaya.Linear +
Returns the slope and y-intercept of the best fit linear line + z = slope*x + intercept by minimizing the sum of least squares + between z and the y. +
bestFit(float[], float[], float) - +Static method in class papaya.Linear +
Returns the slope of the best fit linear line for the prescribed y-intercept. +
beta(double, double) - +Static method in class papaya.Gamma +
Returns the beta function of the arguments. +
betacdf(double, double, double) - +Static method in class papaya.Probability +
Returns the area from zero to x under the beta density + function. +
betacdfComplemented(double, double, double) - +Static method in class papaya.Probability +
Returns the area under the right hand tail (from x to + infinity) of the beta density function. +
betainv(double, double, double) - +Static method in class papaya.Probability +
Returns the inverse of the beta cumulative distribution function. +
bgColor - +Variable in class papaya.Visuals +
Specifies the plot background color +
big - +Static variable in interface papaya.PapayaConstants +
  +
biginv - +Static variable in interface papaya.PapayaConstants +
  +
binomcdf(double, int, int) - +Static method in class papaya.Probability +
Returns the sum of the terms 0 through k of the Binomial + probability density. +
binomcdfComplemented(double, int, int) - +Static method in class papaya.Probability +
Returns the sum of the terms k+1 through n of the Binomial + probability density. +
binominv(double, int, int) - +Static method in class papaya.Probability +
Finds the event probability p such that the sum of the + terms 0 through k of the Binomial probability density + is equal to the given cumulative probability y. +
BOTTOM - +Static variable in interface papaya.PapayaConstants +
  +
bottomBound - +Variable in class papaya.BoxPlot +
Specifies the space on the bottom, between the plot area and the bounding + rectangle. +
bottomBound - +Variable in class papaya.ScatterPlot +
Specifies the space on the bottom, between the plot area and the bounding + rectangle. +
bottomBound - +Variable in class papaya.SubPlot +
Specifies the space on the bottom, between the plot area and the bounding + rectangle. +
BoxPlot - Class in papaya
BoxPlot class
BoxPlot(PApplet, float, float, float, float) - +Constructor for class papaya.BoxPlot +
  +
+
+

+C

+
+
Cast - Class in papaya
Static Class for casting Object arrays to their corresponding primitive type.
ceilToNearest(float, int) - +Static method in class papaya.Mat +
Function for ceiling a number to the closest interval. +
CENTER - +Static variable in interface papaya.PapayaConstants +
  +
chebychev(float[][]) - +Static method in class papaya.Distance +
Computes the Chebychev distance matrix between pairs of objects + in the m-by-n data matrix X. +
chi2(float[]) - +Static method in class papaya.Normality.Dago +
Computes and returns an array containing the test statistic chi2, or the + "omnibus" test statistic, and the significance, or "p-value" of this test statistic. +
chi2cdf(double, double) - +Static method in class papaya.Probability +
Returns the area under the left hand tail (from 0 to x) + of the Chi square probability density function with + v degrees of freedom. +
chi2cdfComplemented(double, double) - +Static method in class papaya.Probability +
Returns the area under the right hand tail (from x to + infinity) of the Chi square probability density function + with v degrees of freedom. +
cityblock(float[][]) - +Static method in class papaya.Distance +
Computes the cityblock (or Manhattan) distance matrix between pairs of objects + in the m-by-n data matrix X. +
classical(float[][], int, boolean) - +Static method in class papaya.MDS +
Performs classical (metric) multidimensional scaling, on an input matrix of Distances (computed + using e.g. +
column(float[][], int, int) - +Static method in class papaya.Mat +
Function to get columns of a 2-D matrix. +
column(float[][], int) - +Static method in class papaya.Mat +
Function to get one column of a 2D matrix +
column(int[][], int) - +Static method in class papaya.Mat +
  +
columnMean(float[][]) - +Static method in class papaya.Descriptive.Mean +
Returns an array containing the arithmetic mean of each column + of the input matrix. +
compare(int, int) - +Static method in class papaya.Mat +
Returns -1 if a is less than b, or 1 if a is greater than b, or 0. +
compare(float, float) - +Static method in class papaya.Mat +
Returns -1 if a is less than b, or 1 if a is greater than b, or 0. +
Comparison - Class in papaya
Contains a number of methods for comparing more than one dataset + against each other.
Comparison() - +Constructor for class papaya.Comparison +
Makes this class non instantiable, but still let's others inherit from it. +
Comparison.TTest - Class in papaya
Methods related to comparing two populations.
compCumFrequency() - +Method in class papaya.Frequency +
Computes the cumulative frequency of the data. +
compRelCumFrequency() - +Method in class papaya.Frequency +
Computes the cumulative relative frequency of the data. +
compRelCumFrequencyPct() - +Method in class papaya.Frequency +
Computes the cumulative frequency of the data as a percentage. +
compRelFrequency() - +Method in class papaya.Frequency +
Computes the fraction of the total data that's in each bin. +
compRelFrequencyPct() - +Method in class papaya.Frequency +
Computes the percents of the total data that's in each bin. +
concat(float[], float[]) - +Static method in class papaya.Mat +
Concatenates two arrays a and b into a new array + c such that c = {a,b}. +
concat(int[], int[]) - +Static method in class papaya.Mat +
  +
cond() - +Method in class papaya.SVD +
Two norm condition number +
constant(float, int) - +Static method in class papaya.Mat +
Returns an array with of length size with + each element equal to the specified constValue. +
constant(int, int) - +Static method in class papaya.Mat +
Returns an array with of length size with + each element equal to the specified constValue. +
contains(Object[], Object) - +Static method in class papaya.Find +
Checks if the object is in the given array. +
contains(long[], long) - +Static method in class papaya.Find +
Checks if the value is in the given array. +
contains(int[], int) - +Static method in class papaya.Find +
Checks if the value is in the given array. +
contains(short[], short) - +Static method in class papaya.Find +
Checks if the value is in the given array. +
contains(char[], char) - +Static method in class papaya.Find +
Checks if the value is in the given array. +
contains(byte[], byte) - +Static method in class papaya.Find +
Checks if the value is in the given array. +
contains(double[], double) - +Static method in class papaya.Find +
Checks if the value is in the given array. +
contains(double[], double, double) - +Static method in class papaya.Find +
Checks if a value falling within the given tolerance is in the + given array. +
contains(float[], float) - +Static method in class papaya.Find +
Checks if the value is in the given array. +
containsNaNs(double[]) - +Static method in class papaya.NaNs +
Checks for presence of NaNs in the data array. +
containsNaNs(float[]) - +Static method in class papaya.NaNs +
Checks for presence of NaNs in the data array. +
copy(float[][]) - +Static method in class papaya.Mat +
Make a deep copy of a matrix +
copyThenSort(float[]) - +Static method in class papaya.Mat +
Sorts and returns a copy of the input array in ascending order +
CORNER - +Static variable in interface papaya.PapayaConstants +
  +
corr(float[][], float[], boolean) - +Static method in class papaya.Correlation.Weighted +
Returns the weighted linear correlation matrix C. +
corr(float[], float[], float[], boolean) - +Static method in class papaya.Correlation.Weighted +
Returns the weighted linear correlation of two data sequences. +
Correlation - Class in papaya
Contains utilities related to computing covariances, as well as linear and rank correlation.
correlation(float[][]) - +Static method in class papaya.Distance +
Computes the correlation distance matrix between pairs of objects + in the m-by-n data matrix X. +
correlation(float[], float[], float[]) - +Static method in class papaya.Linear.BoxCox +
Performs the box-cox transformation on y for a sequence of λ + and returns the array of linear correlation coefficients + between the x and the box-cox transformed y. +
Correlation.Significance - Class in papaya
Contains methods used to compute the significance, or pvalue of the input correlations.
Correlation.Weighted - Class in papaya
Contains methods related to computing the correlation and covariance of weighted + datasets.
CorrelationPlot - Class in papaya
Takes in a matrix and plots the data in each of the columns versus + each other.
CorrelationPlot(PApplet, float, float, float, float) - +Constructor for class papaya.CorrelationPlot +
Setup the plot dimensions +
cosine(float[][]) - +Static method in class papaya.Distance +
Computes the cosine distance matrix between pairs of objects + in the m-by-n data matrix X. +
cov(float[], float[], boolean) - +Static method in class papaya.Correlation +
Returns the covariance of two data sequences data1 and data2, + each of length N. +
cov(float[][], boolean) - +Static method in class papaya.Correlation +
Returns the covariance matrix of P data sequences, each of length N. +
cov(float[], float[], float[], boolean) - +Static method in class papaya.Correlation.Weighted +
Returns the weighted covariance between two data sequences. +
cov(float[][], float[], boolean) - +Static method in class papaya.Correlation.Weighted +
Returns the weighted covariance matrix with element S_JK specifying the weighted + covariance between column J and column K of the input matrix. +
cross(float[], float[]) - +Static method in class papaya.Mat +
vector cross product: c = a (cross) b +
+
+

+D

+
+
Descriptive - Class in papaya
Basic descriptive statistics class for exploratory data analysis.
Descriptive.Mean - Class in papaya
Contains methods for computing the arithmetic, geometric, harmonic, trimmed, and winsorized + means (among others).
Descriptive.Pooled - Class in papaya
Class for computing the pooled mean and variance of data sequences
Descriptive.Sum - Class in papaya
Methods for computing various different sums of datasets such as sum of inversions, + logs, products, power deviations, squares, etc.
Descriptive.Weighted - Class in papaya
Contains methods related to weighted datasets.
det() - +Method in class papaya.LU +
Determinant +
det(float[][]) - +Static method in class papaya.Mat +
returns the determinant of the square input matrix. +
dfbg() - +Method in class papaya.OneWayAnova +
Returns the degrees of freedom between groups. +
dfwg() - +Method in class papaya.OneWayAnova +
Returns the degrees of freedom within each group. +
Distance - Class in papaya
Contains methods for computing various "distance" metrics for multidimensional scaling.
divide(float[], float) - +Static method in class papaya.Mat +
Divides all elements of input array by value. +
divide(float[], float[]) - +Static method in class papaya.Mat +
Element by element division such that z[i] = x[i]/y[i]. +
divide(float[][], float) - +Static method in class papaya.Mat +
Divides each element of the input matrix A by the input value +
dotDivide(float[][], float[][]) - +Static method in class papaya.Mat +
Element by element matrix division such that C_ij = A_ij/B_ij. +
dotMultiply(float[][], float[][]) - +Static method in class papaya.Mat +
Element by element matrix multiplication such that C_ij = A_ij*B_ij. +
dotProduct(float[], float[]) - +Static method in class papaya.Mat +
dot product of two arrays such that z = sum(a_i*b_i) +
doubleToFloat(double[][]) - +Static method in class papaya.Cast +
function for casting double[][] to float[][] +
doubleToFloat(double[]) - +Static method in class papaya.Cast +
function for casting double[] to float[] +
drawAxes - +Variable in class papaya.BoxPlot +
Specifies whether to draw the axes +
drawAxes - +Variable in class papaya.ScatterPlot +
Specifies whether to draw the axes +
drawAxes - +Variable in class papaya.SubPlot +
Specifies whether to draw the axes +
drawAxes(int, float) - +Method in class papaya.Visuals +
Draws the plot axes using a line with color _sColor, and weight _sWeight +
drawBorderAndLabels(String[], int) - +Method in class papaya.CorrelationPlot +
Draw the bordering lines and write the labels. +
drawBoxPlot(String[], float, int) - +Method in class papaya.BoxPlot +
Plot the box plots. +
drawPlot(float[][], int, int) - +Method in class papaya.CorrelationPlot +
Plots the scatter plot of each of the columns of the input data matrix vs. +
drawRect() - +Method in class papaya.Visuals +
Draw the plot background rectangle using the default plot + dimensions and background color. +
drawRect(float, float, float, float, int) - +Method in class papaya.Visuals +
Draws the plot background rectangle using the input dimensions and + background color. +
drawRectangle - +Variable in class papaya.BoxPlot +
Specifies whether to draw the bounding rectangle around the plot. +
drawRectangle - +Variable in class papaya.ScatterPlot +
Specifies whether to draw the bounding rectangle around the plot. +
drawRectangle() - +Method in class papaya.ScatterPlot +
Draws a rectangle around the plot. +
drawRectangle - +Variable in class papaya.SubPlot +
Specifies whether to draw the bounding rectangle around the plot. +
drawScatterPlot(float[], float[], float, int) - +Method in class papaya.ScatterPlot +
Parent function to plot scatter plot of the data. +
drawScatterPlot(float[], float[], int, int, int) - +Method in class papaya.SubPlot +
Draws the scatterplot for subplot(xnum,ynum) by calling ScatterPlot.drawScatterPlot(float[], float[], float, int). +
durbinWatson(float[]) - +Static method in class papaya.Correlation.Significance +
The Durbin-Watson statistic is a test statistic used to detect the presence + of autocorrelation (Correlation.auto(float[], int, float, float)) + in the residuals (prediction errors) from a regression analysis. +
+
+

+E

+
+
Eigenvalue - Class in papaya
Eigenvalues and eigenvectors of a real matrix.
Eigenvalue(float[][]) - +Constructor for class papaya.Eigenvalue +
Check for symmetry, then construct the eigenvalue decomposition. +
eliminate(double[]) - +Static method in class papaya.NaNs +
Eliminate the NaNs from the input array. +
eliminate(float[]) - +Static method in class papaya.NaNs +
Eliminate the NaNs from the input array. +
equalVar(float[], float[]) - +Static method in class papaya.Comparison.TTest +
Returns the t-statistic and p-value for checking whether the means + between the two datasets are different under the assumption that both + datasets have equal variances. +
erf(double) - +Static method in class papaya.Probability +
Returns the error function of the normal distribution. +
erfComplemented(double) - +Static method in class papaya.Probability +
Returns the complementary Error function of the normal distribution; formerly named erfc. +
etasqrd() - +Method in class papaya.OneWayAnova +
Computes eta^2: a measure of the strength of the curvilinear relationship + between the independent and dependent variable. +
euclidean(float[][]) - +Static method in class papaya.Distance +
Computes the Euclidean distance between pairs of objects + in the m-by-n data matrix X. +
+
+

+F

+
+
F() - +Method in class papaya.OneWayAnova +
Returns the test statistic F. +
fcdf(double, int, int) - +Static method in class papaya.Probability +
Returns the area from zero to x under the F density + function (also known as Snedcor's density or the + variance ratio density); formerly named fdtr. +
fcdfComplemented(double, int, int) - +Static method in class papaya.Probability +
Returns the area from x to infinity under the F density + function (also known as Snedcor's density or the + variance ratio density); formerly named fdtrc. +
Find - Class in papaya
Static class for finding indices in an array corresponding to a given value/object.
finv(double, int, int) - +Static method in class papaya.Probability +
Finds the F density argument x such that the integral + from 0 to x of the F density is equal to p; formerly named fdtri. +
floatToDouble(float[][]) - +Static method in class papaya.Cast +
function for casting float[][] to double[][] +
floatToDouble(float[]) - +Static method in class papaya.Cast +
function for casting float[] to double[] +
floatToPVector(float[], float[], float[]) - +Static method in class papaya.Cast +
Returns a PVector array with the x, y, and z coordinates set to the input values + (technically not a cast, but a reorganization). +
floatToPVector(float[], float[]) - +Static method in class papaya.Cast +
Returns a PVector array with the x, and coordinates set to the input values, and the z coordinates + set to zero. +
floorToNearest(float, int) - +Static method in class papaya.Mat +
Function for flooring a number to the closest interval. +
FONTNAME - +Static variable in interface papaya.PapayaConstants +
Default font used. +
frequencies(float[], ArrayList<Float>, ArrayList<Integer>) - +Static method in class papaya.Descriptive +
Computes the frequency (number of occurances, count) of each distinct value in the given sorted data. +
frequencies - +Variable in class papaya.Unique +
ArrayList containing the frequencies of the corresponding unique value +
Frequency - Class in papaya
Class for getting the frequency distribution, cumulative frequency distribution, and other + distribution-related parameters of a given array of floats or ints.
Frequency(float[], float, float, float) - +Constructor for class papaya.Frequency +
Initialize the class by setting the minimum value, maximum value, and the bin width. +
Frequency(int[], int, int, int) - +Constructor for class papaya.Frequency +
Initialize the class by setting the minimum value, maximum value, and the bin width. +
+
+

+G

+
+
Gamma - Class in papaya
Gamma and Beta functions.
gamma(double) - +Static method in class papaya.Gamma +
Returns the Gamma function of the argument, Γ(x) +
gammacdf(double, double, double) - +Static method in class papaya.Probability +
Returns the integral from zero to x of the gamma probability + density function. +
gammacdfComplemented(double, double, double) - +Static method in class papaya.Probability +
Returns the integral from x to infinity of the gamma + probability density function: +
geometric(int, float) - +Static method in class papaya.Descriptive.Mean +
Returns the geometric mean of a data sequence. +
geometric(float[]) - +Static method in class papaya.Descriptive.Mean +
Returns the geometric mean of a data sequence. +
getBottom() - +Method in class papaya.Visuals +
  +
getD() - +Method in class papaya.Eigenvalue +
Return the block diagonal eigenvalue matrix +
getData() - +Method in class papaya.BoxPlot +
  +
getFloatPivot() - +Method in class papaya.LU +
Return pivot permutation vector as a one-dimensional float array +
getFrequency() - +Method in class papaya.Frequency +
Returns the pre-computed frequency array. +
getH() - +Method in class papaya.QR +
Return the Householder vectors +
getHeight() - +Method in class papaya.Visuals +
  +
getImagEigenvalues() - +Method in class papaya.Eigenvalue +
Return the imaginary parts of the eigenvalues +
getL() - +Method in class papaya.LU +
Return lower triangular factor, L. +
getLeft() - +Method in class papaya.Visuals +
  +
getLength() - +Method in class papaya.Frequency +
returns the length of the dataset. +
getNaNPositions(double[]) - +Static method in class papaya.NaNs +
Returns an array list of indexes where data[i] is NaN. +
getNaNPositions(float[]) - +Static method in class papaya.NaNs +
Returns an array list of indexes where data[i] is NaN. +
getNumBins() - +Method in class papaya.Frequency +
Returns the number of bins. +
getPivot() - +Method in class papaya.LU +
Return pivot permutation vector +
getQ() - +Method in class papaya.QR +
Generate and return the (economy-sized) orthogonal factor +
getR() - +Method in class papaya.QR +
Return the upper triangular factor +
getRealEigenvalues() - +Method in class papaya.Eigenvalue +
Return the real parts of the eigenvalues +
getRight() - +Method in class papaya.Visuals +
  +
getS() - +Method in class papaya.SVD +
Return the diagonal matrix of singular values +
getSingularValues() - +Method in class papaya.SVD +
Return the one-dimensional array of singular values +
getTop() - +Method in class papaya.Visuals +
  +
getU() - +Method in class papaya.LU +
Return upper triangular factor, U +
getU() - +Method in class papaya.SVD +
Return the left singular vectors +
getV() - +Method in class papaya.Eigenvalue +
Return the eigenvector matrix with each column corresponding to + an eigenvector of the input matrix. +
getV() - +Method in class papaya.SVD +
Return the right singular vectors +
getWidth() - +Method in class papaya.Visuals +
  +
GRAY - +Static variable in interface papaya.PapayaConstants +
  +
+
+

+H

+
+
harmonic(int, float) - +Static method in class papaya.Descriptive.Mean +
Returns the harmonic mean of a data sequence. +
harmonic(float[]) - +Static method in class papaya.Descriptive.Mean +
Returns the harmonic mean of a data sequence as Sum( 1.0 / data[i]). +
horizLine(float, float, float, int, float) - +Method in class papaya.Visuals +
draws a horizonal line with color _sColor, and weight _sWeight +
+
+

+I

+
+
identity(int) - +Static method in class papaya.Mat +
returns the identity matrix of the specified dimension +
idx - +Variable in class papaya.Unique +
Class containing the integer arrays that hold the indices of each unique value. +
incompleteBeta(double, double, double) - +Static method in class papaya.Gamma +
Returns the Incomplete Beta Function evaluated from zero to xx; formerly named ibeta. +
incompleteBetaInverse(double, double, double) - +Static method in class papaya.Gamma +
Returns the inverse of the incomplete Beta integral. +
incompleteGamma(double, double) - +Static method in class papaya.Gamma +
Returns the Incomplete Gamma function; formerly named igamma. +
incompleteGammaComplement(double, double) - +Static method in class papaya.Gamma +
Returns the Complemented Incomplete Gamma function; formerly named igamc. +
INDEX_NOT_FOUND - +Static variable in interface papaya.PapayaConstants +
Index to return if a given value/object is not found in the Cast function. +
indexOf(Object[], Object) - +Static method in class papaya.Find +
Finds the index of the given object in the array. +
indexOf(Object[], Object, int) - +Static method in class papaya.Find +
Finds the index of the given object in the array starting at the given index. +
indexOf(long[], long) - +Static method in class papaya.Find +
Finds the index of the given value in the array. +
indexOf(long[], long, int) - +Static method in class papaya.Find +
Finds the index of the given value in the array starting at the given index. +
indexOf(int[], int) - +Static method in class papaya.Find +
Finds the index of the given value in the array. +
indexOf(int[], int, int) - +Static method in class papaya.Find +
Finds the index of the given value in the array starting at the given index. +
indexOf(short[], short) - +Static method in class papaya.Find +
Finds the index of the given value in the array. +
indexOf(short[], short, int) - +Static method in class papaya.Find +
Finds the index of the given value in the array starting at the given index. +
indexOf(char[], char) - +Static method in class papaya.Find +
Finds the index of the given value in the array. +
indexOf(char[], char, int) - +Static method in class papaya.Find +
Finds the index of the given value in the array starting at the given index. +
indexOf(byte[], byte) - +Static method in class papaya.Find +
Finds the index of the given value in the array. +
indexOf(byte[], byte, int) - +Static method in class papaya.Find +
Finds the index of the given value in the array starting at the given index. +
indexOf(double[], double) - +Static method in class papaya.Find +
Finds the index of the given value in the array. +
indexOf(double[], double, double) - +Static method in class papaya.Find +
Finds the index of the given value within a given tolerance in the array. +
indexOf(double[], double, int) - +Static method in class papaya.Find +
Finds the index of the given value in the array starting at the given index. +
indexOf(double[], double, int, double) - +Static method in class papaya.Find +
Finds the index of the given value in the array starting at the given index. +
indexOf(float[], float) - +Static method in class papaya.Find +
Finds the index of the given value in the array. +
indexOf(float[], float, int) - +Static method in class papaya.Find +
Finds the index of the given value in the array starting at the given index. +
indexOf(boolean[], boolean) - +Static method in class papaya.Find +
Finds the index of the given value in the array. +
indexOf(boolean[], boolean, int) - +Static method in class papaya.Find +
Finds the index of the given value in the array starting at the given index. +
indices(float[], boolean) - +Static method in class papaya.Sorting +
Gets the array of indices that can be used to sort the array in ascending or + descending order. +
indices(double[], boolean) - +Static method in class papaya.Sorting +
  +
indices(int[], boolean) - +Static method in class papaya.Sorting +
  +
indices(float[], int, int, boolean) - +Static method in class papaya.Sorting +
Gets the array of indices that can be used to sort the section of the + input array going from fromIndex(inclusive) to toIndex(exclusive) + in ascending or descending order. +
indices(double[], int, int, boolean) - +Static method in class papaya.Sorting +
  +
indices(int[], int, int, boolean) - +Static method in class papaya.Sorting +
  +
INDICES_NOT_FOUND - +Static variable in interface papaya.PapayaConstants +
Index array to return if a given value/object is not found in the Cast function. +
indicesGreaterThan(int[], int) - +Static method in class papaya.Find +
  +
indicesGreaterThan(float[], float) - +Static method in class papaya.Find +
  +
indicesGreaterThanOrEqualTo(int[], int) - +Static method in class papaya.Find +
  +
indicesGreaterThanOrEqualTo(float[], float) - +Static method in class papaya.Find +
  +
indicesLessThan(int[], int) - +Static method in class papaya.Find +
  +
indicesLessThan(float[], float) - +Static method in class papaya.Find +
  +
indicesLessThanOrEqualTo(int[], int) - +Static method in class papaya.Find +
  +
indicesLessThanOrEqualTo(float[], float) - +Static method in class papaya.Find +
  +
indicesWith(Object[], Object) - +Static method in class papaya.Find +
Finds the indices containing the specified object in the array. +
indicesWith(Object[], Object, int) - +Static method in class papaya.Find +
Finds the indices containing the specified object in the array. +
indicesWith(long[], long) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(long[], long, int) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(int[], int) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(int[], int, int) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(short[], short) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(short[], short, int) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(char[], char) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(char[], char, int) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(byte[], byte) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(byte[], byte, int) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(double[], double) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(double[], double, int) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(float[], float) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(float[], float, int) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(boolean[], boolean) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWith(boolean[], boolean, int) - +Static method in class papaya.Find +
Finds the indices containing the specified value in the array. +
indicesWithin(int[], float, float) - +Static method in class papaya.Find +
Finds the indices for the array elements within the min and max value (inclusive). +
indicesWithin(float[], float, float) - +Static method in class papaya.Find +
Finds the indices for the array elements within the min and max value (inclusive). +
intercept(float, float, int) - +Static method in class papaya.Linear.Significance +
Returns the p-value, or significance, of the computed intercept under the null-hypothesis + of intercept = 0 (two-tailed test). +
intercept(float[], float) - +Static method in class papaya.Linear.StdErr +
Returns the standard error of the computed slope given x and the + standard error in the residuals. +
inverse(float[], float) - +Static method in class papaya.Mat +
Returns the array z[i] = 1/x[i]; If x[i] is zero, it sets z[i] + to the specified replaceZeroWith value instead. +
inverse(float[][]) - +Static method in class papaya.Mat +
Matrix inverse if A is square, pseudoinverse otherwise +
inversions(float[], int, int) - +Static method in class papaya.Descriptive.Sum +
Returns the sum of inversions of a data sequence, + which is Sum( 1.0 / data[i]). +
isConstant(float[]) - +Static method in class papaya.Mat +
  +
isFullRank() - +Method in class papaya.QR +
Is the matrix full rank? +
isNonsingular() - +Method in class papaya.LU +
Is the matrix nonsingular? +
+
+

+K

+
+
keySetToFloat(HashMap) - +Static method in class papaya.Cast +
Function for casting hashMap keySet to float[] +
keySetToInt(HashMap) - +Static method in class papaya.Cast +
Function for casting hashMap keySet to float[] +
keySetToString(HashMap) - +Static method in class papaya.Cast +
Function for casting hashMap keySet to String[] +
kurtosis(float, float) - +Static method in class papaya.Descriptive +
Returns the kurtosis (aka excess) of a data sequence. +
kurtosis(float[], float, float) - +Static method in class papaya.Descriptive +
Returns the kurtosis (aka excess) of a data sequence, which is + -3 + moment(data,4,mean) / standardDeviation4. +
kurtosis(float[]) - +Static method in class papaya.Normality.Dago +
Computes and returns an array containing the test statistic zb2associated with + b2 and the significance, or "p-value" of the kurtosis test statistic zb2, assuming a + two-tailed null hypothesis as well as . +
+
+

+L

+
+
lastIndexOf(Object[], Object) - +Static method in class papaya.Find +
Finds the last index of the given object within the array. +
lastIndexOf(Object[], Object, int) - +Static method in class papaya.Find +
Finds the last index of the given object in the array starting at the given index. +
lastIndexOf(long[], long) - +Static method in class papaya.Find +
Finds the last index of the given value within the array. +
lastIndexOf(long[], long, int) - +Static method in class papaya.Find +
Finds the last index of the given value in the array starting at the given index. +
lastIndexOf(int[], int) - +Static method in class papaya.Find +
Finds the last index of the given value within the array. +
lastIndexOf(int[], int, int) - +Static method in class papaya.Find +
Finds the last index of the given value in the array starting at the given index. +
lastIndexOf(short[], short) - +Static method in class papaya.Find +
Finds the last index of the given value within the array. +
lastIndexOf(short[], short, int) - +Static method in class papaya.Find +
Finds the last index of the given value in the array starting at the given index. +
lastIndexOf(char[], char) - +Static method in class papaya.Find +
Finds the last index of the given value within the array. +
lastIndexOf(char[], char, int) - +Static method in class papaya.Find +
Finds the last index of the given value in the array starting at the given index. +
lastIndexOf(byte[], byte) - +Static method in class papaya.Find +
Finds the last index of the given value within the array. +
lastIndexOf(byte[], byte, int) - +Static method in class papaya.Find +
Finds the last index of the given value in the array starting at the given index. +
lastIndexOf(double[], double) - +Static method in class papaya.Find +
Finds the last index of the given value within the array. +
lastIndexOf(double[], double, double) - +Static method in class papaya.Find +
Finds the last index of the given value within a given tolerance in the array. +
lastIndexOf(double[], double, int) - +Static method in class papaya.Find +
Finds the last index of the given value in the array starting at the given index. +
lastIndexOf(double[], double, int, double) - +Static method in class papaya.Find +
Finds the last index of the given value in the array starting at the given index. +
lastIndexOf(float[], float) - +Static method in class papaya.Find +
Finds the last index of the given value within the array. +
lastIndexOf(float[], float, int) - +Static method in class papaya.Find +
Finds the last index of the given value in the array starting at the given index. +
lastIndexOf(boolean[], boolean) - +Static method in class papaya.Find +
Finds the last index of the given value within the array. +
lastIndexOf(boolean[], boolean, int) - +Static method in class papaya.Find +
Finds the last index of the given value in the array starting at the given index. +
LEFT - +Static variable in interface papaya.PapayaConstants +
  +
leftBound - +Variable in class papaya.BoxPlot +
Specifies the space on the left between the plot area, and the + bounding rectangle. +
leftBound - +Variable in class papaya.ScatterPlot +
Specifies the space on the left between the plot area, and the + bounding rectangle. +
leftBound - +Variable in class papaya.SubPlot +
Specifies the space on the left between the plot area, and the + bounding rectangle. +
legendHoriz(String, int[], String[]) - +Method in class papaya.SubPlot +
Draws a legend going to the right with the first element situated at (x,y). +
legendHoriz(float, float, int[], String[]) - +Method in class papaya.Visuals +
Draws a legend going to the right with the first element situated at (x,y). +
legendVert(float, float, int[], String[]) - +Method in class papaya.SubPlot +
Draws a legend going downwards with the first element situated at (x,y). +
legendVert(float, float, int[], String[]) - +Method in class papaya.Visuals +
Draws a legend going downwards with the first element situated at (x,y). +
line(float, float, float, float, int, float) - +Method in class papaya.Visuals +
Draws a straight line going from (x[0],y[0]) to (x[1],y[1]) + with color _sColor, and weight _sWeight +
linear(float[][], boolean) - +Static method in class papaya.Correlation +
Returns the (Pearson Product Moment) correlation matrix between multiple columns of a matrix + with each column corresponding to a dataset, and each row an observation. +
linear(float[], float[], boolean) - +Static method in class papaya.Correlation +
Returns the (Pearson Product Moment) linear correlation of two data sequences. +
linear(float, int) - +Static method in class papaya.Correlation.Significance +
Returns the p-value, or significance level of the linear correlation r + between two datasets under the null hypothesis of no correlation. +
Linear - Class in papaya
Contains methods related to determining the linear linear + relationship between two datasets (of equal arrays) such as the + best-fit linear line parameters, box-cox transformations, etc.
Linear() - +Constructor for class papaya.Linear +
  +
Linear.BoxCox - Class in papaya
Contains methods related to the Box-Cox transformation of a data set; useful in + determining the best transformation that will yield the best method for converting + a monotonic, non-linear relationship between x and y into + a linear one.
Linear.Significance - Class in papaya
Contains methods used to compute the significance, or pvalue of the input correlations.
Linear.Significance() - +Constructor for class papaya.Linear.Significance +
  +
Linear.StdErr - Class in papaya
Contains methods related to computing the standard errors of the residuals, slope and intercept + associated with the best-fit linear line.
linspace(int, int) - +Static method in class papaya.Mat +
Returns the array of (end-start+1) points going from + start (inclusive) to end (inclusive): + y[0] = start; y[1] = start+1; ... +
linspace(int, int, int) - +Static method in class papaya.Mat +
  +
linspace(float, float, float) - +Static method in class papaya.Mat +
  +
log(float[]) - +Static method in class papaya.Mat +
Returns an array with each element equal to the natural logarithm (the base-e logarithm) + the corresponding input array. +
log10(float[]) - +Static method in class papaya.Mat +
Returns an array with each element equal to the log 10 value (base 10 logarithm) + of the corresponding input array. +
logGamma(double) - +Static method in class papaya.Gamma +
Returns the natural logarithm of the gamma function; formerly named lgamma. +
LOGPI - +Static variable in interface papaya.PapayaConstants +
  +
logs(float[], int, int) - +Static method in class papaya.Descriptive.Sum +
Returns the sum of logarithms of a data sequence, which is Sum( Log(data[i]). +
logToBase(float[], float) - +Static method in class papaya.Mat +
Returns an array with each element equal to the log A value + of the corresponding input array. +
LU - Class in papaya
LU Decomposition.
LU(float[][]) - +Constructor for class papaya.LU +
Constructor. +
+
+

+M

+
+
MACHEP - +Static variable in interface papaya.PapayaConstants +
machine constants +
mag(float[]) - +Static method in class papaya.Mat +
Returns the magnitude of the input array = sqrt(x1^2 + x2^2 + ... +
mahalanobis(float[][]) - +Static method in class papaya.Distance +
Computes the Mahalanobis distance matrix of the m-by-n input matrix X. +
mannWhitney(float[], float[]) - +Static method in class papaya.Comparison +
Computes and returns the MannWhitney (or Wilcoxon Rank Sum) test statistic, U and p-value for + assessing whether one of two samples of independent observations tends to have + larger values than the other. +
map(float, float, float, float, float) - +Static method in class papaya.Mat +
Convenience function to map a variable from one coordinate space to another. +
map(float[], float, float) - +Static method in class papaya.Mat +
Similar to map([] value, valueArrayMinimum, valueArrayMaximum, from, to) +
map(float[], float, float, float, float) - +Static method in class papaya.Mat +
Function for mapping an input array of floats for plotting + Extends processing "map" function to accomodate + arrays. +
mapXData(float[]) - +Method in class papaya.Visuals +
Maps the x-data from the range min(data) to max(data) to + the plotLeft and plotLeft+plotWidth. +
mapXData(float[], float, float) - +Method in class papaya.Visuals +
Maps the x-data from the range minXDat to maxXDat to + the plotLeft and plotRight. +
mapYData(float[]) - +Method in class papaya.Visuals +
Maps the y-data from the range min(data) to max(data) to + the plotBottom and plotTop. +
mapYData(float[], float, float) - +Method in class papaya.Visuals +
Maps the y-data from the range minYDat to maxYDat to + the plotBottom and plotTop. +
Mat - Class in papaya
Static class for performing some basic matrix operations.
max(int, int) - +Static method in class papaya.Descriptive +
  +
max(float, float) - +Static method in class papaya.Descriptive +
  +
max(double, double) - +Static method in class papaya.Descriptive +
  +
max(double[]) - +Static method in class papaya.Descriptive +
Returns the largest member of a data sequence. +
max(float[]) - +Static method in class papaya.Descriptive +
Returns the largest member of a data sequence. +
max(int[]) - +Static method in class papaya.Descriptive +
Returns the largest member of a data sequence. +
max(float[][]) - +Static method in class papaya.Descriptive +
Returns the largest member of a matrix. +
max(int[][]) - +Static method in class papaya.Descriptive +
Returns the largest member of a matrix. +
MAXGAM - +Static variable in interface papaya.PapayaConstants +
  +
MAXLOG - +Static variable in interface papaya.PapayaConstants +
  +
MDS - Class in papaya
Contains methods for performing but classical and non-classical multidimensional scaling.
mean(float[]) - +Static method in class papaya.Descriptive +
Returns the arithmetic mean of a data sequence; + That is Sum( data[i] ) / data.length . +
mean(float, int, float, int) - +Static method in class papaya.Descriptive.Pooled +
Returns the pooled mean of two data sequences. +
mean(float[], int[]) - +Static method in class papaya.Descriptive.Pooled +
Returns the pooled mean of a k data sequences. +
mean(float[], float[]) - +Static method in class papaya.Descriptive.Weighted +
Returns the weighted mean of a data sequence. +
meanDeviation(float[], float) - +Static method in class papaya.Descriptive +
Returns the mean deviation of a dataset. +
median(float[], boolean) - +Static method in class papaya.Descriptive +
Returns the median of a data sequence. +
min(int, int) - +Static method in class papaya.Descriptive +
  +
min(float, float) - +Static method in class papaya.Descriptive +
  +
min(double, double) - +Static method in class papaya.Descriptive +
  +
min(double[]) - +Static method in class papaya.Descriptive +
Returns the smallest member of a data sequence. +
min(float[]) - +Static method in class papaya.Descriptive +
Returns the smallest member of a data sequence. +
min(float[][]) - +Static method in class papaya.Descriptive +
Returns the smallest member of a matrix. +
min(int[]) - +Static method in class papaya.Descriptive +
Returns the smallest member of a data sequence. +
min(int[][]) - +Static method in class papaya.Descriptive +
Returns the smallest member of a matrix. +
minkowski(float[][], int) - +Static method in class papaya.Distance +
Returns the Minkowski distance matrix of the m-by-n input matrix X. +
MINLOG - +Static variable in interface papaya.PapayaConstants +
  +
mod(float[]) - +Static method in class papaya.Descriptive +
Returns the array containing the elements that appear the most in a given dataset. +
moment(float[], int, float) - +Static method in class papaya.Descriptive +
Returns the moment of k-th order with constant c of a data sequence, + which is Sum( (data[i]-c)k ) / data.size(). +
multiply(float[][], float[][]) - +Static method in class papaya.Mat +
Multiplies two matrices A and B returning C = A*B + where C_ij = Sum(k=1 to n) A_ik*B_kj. +
multiply(float[][], float[]) - +Static method in class papaya.Mat +
Multiplies the matrix A with the vector x returning A*x = y + where y_j= Sum(k=j to n) A_ij*x_j. +
multiply(float[][], float) - +Static method in class papaya.Mat +
Multiplies the matrix A with the scalar a returning a*A = B + where B_ij = a*A_ij. +
multiply(float[], float[]) - +Static method in class papaya.Mat +
Multiplies two arrays and returns the multiplied array. +
multiply(float[], float) - +Static method in class papaya.Mat +
Multiplies each element of an array by a number, and returns the multiplied array. +
+
+

+N

+
+
NaNs - Class in papaya
Contains various methods for dealing with NaNs in your data.
nbinomcdf(double, int, int) - +Static method in class papaya.Probability +
Returns the sum of the terms 0 through k of the Negative Binomial Distribution. +
nbinomcdfComplemented(double, int, int) - +Static method in class papaya.Probability +
Returns the sum of the terms k+1 to infinity of the Negative + Binomial distribution. +
norm1(float[][]) - +Static method in class papaya.Mat +
Returns the norm1 of the input matrix, equal to the + maximum absolute column sum of the matrix. +
norm2(float[][]) - +Static method in class papaya.Mat +
Returns the norm2 (or maximum singular value) of the input matrix. +
norm2(float[]) - +Static method in class papaya.Mat +
Returns the norm2 or magnitude of an array. +
norm2() - +Method in class papaya.SVD +
Two norm +
Normality - Class in papaya
Contains various utilities for checking if the dataset comes from a normal distribution.
Normality.Dago - Class in papaya
Methods for computing the skewnewss, kurtosis, and D'Agostino-Peasrson K^2 "omnibus" test-statistics (that + combine the former two), and accompanying significance (or p-values) + for testing the underlying population normality.
normalizeToMinMax(float[]) - +Static method in class papaya.Mat +
Returns an array with elements consisting of the data + normalized to the specified min/max; new data goes from 0 to 1. +
normalizeToSum(float[]) - +Static method in class papaya.Mat +
Returns an array with elements given by z[i] = data[i] / sum(data); +
normalProbability(float[]) - +Static method in class papaya.Normality +
Return the Normal order statistic medians (N) necessary to produce a Q-Q plot + for a normal distribution (or normal probability plot). +
normcdf(double) - +Static method in class papaya.Probability +
Returns the area under the Normal (Gaussian) probability density + function, integrated from minus infinity to x (assumes mean is zero, variance is one). +
normcdf(double, double, double) - +Static method in class papaya.Probability +
Returns the area under the Normal (Gaussian) probability density + function, integrated from minus infinity to x when the + data has not been standardized (i.e. +
normF(float[][]) - +Static method in class papaya.Mat +
/** Returns the Frobenius norm of the input matrix; + sqrt of sum of squares of all elements. +
normInf(float[][]) - +Static method in class papaya.Mat +
Returns the Infinity norm of the input matrix, equal to the + maximum row sum. +
norminv(double) - +Static method in class papaya.Probability +
Returns the value, x, for which the area under the + Normal (Gaussian) probability density function (integrated from + minus infinity to x) is equal to the argument y + (assumes mean is zero, variance is one); formerly named ndtri. +
numGreaterThan(int[], int) - +Static method in class papaya.Find +
Finds the number of elements strictly greater than the specified value. +
numGreaterThan(float[], float) - +Static method in class papaya.Find +
Finds the number of elements strictly greater than the specified value. +
numGreaterThanOrEqualTo(int[], int) - +Static method in class papaya.Find +
Finds the number of elements greater than or equal to the specified value. +
numGreaterThanOrEqualTo(float[], float) - +Static method in class papaya.Find +
Finds the number of elements greater than or equal to the specified value. +
numLessThan(int[], int) - +Static method in class papaya.Find +
Finds the number of elements strictly less than the specified value. +
numLessThan(float[], float) - +Static method in class papaya.Find +
Finds the number of elements strictly less than the specified value. +
numLessThanOrEqualTo(int[], int) - +Static method in class papaya.Find +
Finds the number of elements less than or equal to the specified value. +
numLessThanOrEqualTo(float[], float) - +Static method in class papaya.Find +
Finds the number of elements less than or equal to the specified value. +
numRepeats(Object[], Object) - +Static method in class papaya.Find +
Finds the number of times a given value/object is present in an array. +
numRepeats(long[], long) - +Static method in class papaya.Find +
Finds the number of times a given value/object is present in an array. +
numRepeats(int[], int) - +Static method in class papaya.Find +
Finds the number of times a given value/object is present in an array. +
numRepeats(short[], short) - +Static method in class papaya.Find +
Finds the number of times a given value/object is present in an array. +
numRepeats(char[], char) - +Static method in class papaya.Find +
Finds the number of times a given value/object is present in an array. +
numRepeats(byte[], byte) - +Static method in class papaya.Find +
Finds the number of times a given value/object is present in an array. +
numRepeats(double[], double) - +Static method in class papaya.Find +
Finds the number of times a given value/object is present in an array. +
numRepeats(float[], float) - +Static method in class papaya.Find +
Finds the number of times a given value/object is present in an array. +
numRepeats(boolean[], boolean) - +Static method in class papaya.Find +
Finds the number of times a given value/object is present in an array. +
+
+

+O

+
+
OneWayAnova - Class in papaya
Computes the one-way ANOVA p-value to test the equality of two or more sample + means by analyzing the sample variances using the test statistic + F = variance between samples / variance within samples.
OneWayAnova(Collection<float[]>) - +Constructor for class papaya.OneWayAnova +
Performs an Analysis of Variance (ANOVA) for a collection of float arrays. +
outliers(float[], float, float, boolean) - +Static method in class papaya.Descriptive +
Returns the array containing all elements in the dataset that are less than + or equal to the lowerLimit + and more than or equal to the upperLimit +
+
+

+P

+
+
paired(float[], float[]) - +Static method in class papaya.Comparison.TTest +
Returns the t-statistic and p-value for checking a pair of dependent samples. +
papaya - package papaya
 
PapayaConstants - Interface in papaya
PapayaConstants stores some of the constants used in plotting.
poissoncdf(double, int) - +Static method in class papaya.Probability +
Returns the sum of the first k terms of the Poisson distribution. +
poissoncdfComplemented(int, double) - +Static method in class papaya.Probability +
Returns the sum of the terms k+1 to Infinity of the Poisson distribution. +
Polynomial - Class in papaya
Static Class for casting one variable type to another.
polyval(double, double[]) - +Static method in class papaya.Polynomial +
y = polyval(x,coeff) returns the value of a polynomial of degree n evaluated at x. +
polyval(double[], double[]) - +Static method in class papaya.Polynomial +
y = polyval(x,coeff) returns the array values of a polynomial of degree n evaluated at + each element of x. +
polyval(float, float[]) - +Static method in class papaya.Polynomial +
y = polyval(x,coeff) returns the value of a polynomial of degree n evaluated at x. +
polyval(float[], float[]) - +Static method in class papaya.Polynomial +
y = polyval(x,coeff) returns the value of a polynomial of degree n evaluated at x. +
populate(double[], int[]) - +Static method in class papaya.Mat +
Returns an array with each element corresponding to fullDataset[indices[i]]. +
populate(float[], int[]) - +Static method in class papaya.Mat +
Returns an array with each element corresponding to fullDataset[indices[i]]. +
populate(int[], int[]) - +Static method in class papaya.Mat +
Returns an array with each element corresponding to fullDataset[indices[i]]. +
populate(String[], int[]) - +Static method in class papaya.Mat +
Returns an array with each element corresponding to fullDataset[indices[i]]. +
powerDeviations(float[], int, float) - +Static method in class papaya.Descriptive.Sum +
Returns Sum( (data[i]-c)k ); + optimized for common parameters like c == 0.0 and/or k == -2 .. +
powerDeviations(float[], int, float, int, int) - +Static method in class papaya.Descriptive.Sum +
Returns Sum( (data[i]-c)k ) for all i = from .. +
powers(float[], int) - +Static method in class papaya.Descriptive.Sum +
Returns the sum of powers of a data sequence, which is Sum ( data[i]k ). +
print(double[], int) - +Static method in class papaya.Mat +
Print the array to the screen in a single line. +
print(double[][], int) - +Static method in class papaya.Mat +
Print the matrix to the screen with each row of the + matrix taking up one line. +
print(double[][], String[], String[], int) - +Static method in class papaya.Mat +
Print the matrix to the screen with the columns and rows labeled according to the + input strings. +
print(float[], int) - +Static method in class papaya.Mat +
Print the array to the screen in a single line. +
print(float[][], int) - +Static method in class papaya.Mat +
Print the matrix to the screen with each row of the + matrix taking up one line. +
print(float[][], String[], String[], int) - +Static method in class papaya.Mat +
Print the matrix to the screen with the columns and rows labeled according to the + input strings. +
print(int[], int) - +Static method in class papaya.Mat +
Print the array to the screen in a single line. +
print(int[][], int) - +Static method in class papaya.Mat +
Print the matrix to the screen with each row of the + matrix taking up one line. +
print(int[][], String[], String[], int) - +Static method in class papaya.Mat +
Print the matrix to the screen with the columns and rows labeled according to the + input strings. +
Probability - Class in papaya
Cumulative distribution functions and corresponding inverses of certain probability distributions.
product(int, float) - +Static method in class papaya.Descriptive +
Returns the product, which is Prod( data[i] ). +
product(float[]) - +Static method in class papaya.Descriptive +
Returns the product of a data sequence, which is Prod( data[i] ). +
products(float[], float[]) - +Static method in class papaya.Descriptive.Sum +
Returns the sum of the product of two data arrays, Sum( x[i] * y[i]). +
pValue() - +Method in class papaya.OneWayAnova +
Returns the significance, or "p-value" of the test statistic OneWayAnova.F(). +
pValues(float[]) - +Static method in class papaya.Normality.Dago +
Returns an array containing the three significance, or p-values, for testing normality. +
+
+

+Q

+
+
QR - Class in papaya
QR Decomposition.
QR(float[][]) - +Constructor for class papaya.QR +
QR Decomposition, computed by Householder reflections. +
quantile(float[], float) - +Static method in class papaya.Descriptive +
Returns the phi-quantile; that is, an element elem + for which holds that phi percent of data elements are less than + elem. +
quantileInverse(float[], float) - +Static method in class papaya.Descriptive +
Returns how many percent of the elements contained in the receiver are <= element. +
quantiles(float[], float[]) - +Static method in class papaya.Descriptive +
Returns the quantiles of the specified percentages. +
quartiles(float[], boolean) - +Static method in class papaya.Descriptive +
Returns the quartiles of the input data array (not necessarily sorted). +
+
+

+R

+
+
rank(float[][]) - +Static method in class papaya.Mat +
Returns the effective numerical rank (obtained from SVD) + of the input matrix. +
Rank - Class in papaya
Ranking based on the natural ordering on floats for a sequence of data that may also + contain NaNs.
rank(int[], int, int) - +Static method in class papaya.Rank +
Rank an array containing NaN values using the natural ordering on Floats, with + NaN values handled according to nanStrategy and ties + resolved using tiesStrategy. +
rank(float[], int, int) - +Static method in class papaya.Rank +
Rank an array containing NaN values using the natural ordering on Floats, with + NaN values handled according to nanStrategy and ties + resolved using tiesStrategy. +
rank(int[], int) - +Static method in class papaya.Rank +
Rank an array (with no NaNs) using the natural ordering on Floats with ties + resolved using tiesStrategy. +
rank(float[], int) - +Static method in class papaya.Rank +
Rank an array (with no NaNs) using the natural ordering on Floats with ties + resolved using tiesStrategy. +
rank() - +Method in class papaya.SVD +
Effective numerical matrix rank +
rankInterpolated(float[], float) - +Static method in class papaya.Descriptive +
Returns the linearly interpolated number of elements in an array that + are ≤ a given element. +
replace(float[][], float, float) - +Static method in class papaya.Mat +
Returns a new matrix B equal to A, except that all elements in A which are equal to oldValue with + the newValue. +
replace(float[], float, float) - +Static method in class papaya.Mat +
Returns a new array data2 which is similar to data, except that all elements in data + which are equal to oldValue are replaced with + the newValue. +
replaceNewWith(double[], double) - +Static method in class papaya.NaNs +
Returns a new array with NaN elements in the original data set replaced with the value + specified by newNaN. +
replaceNewWith(float[], float) - +Static method in class papaya.NaNs +
Returns a new array with NaN elements in the original data set replaced with the value + specified by newNaN. +
replaceOriginalWith(double[], double) - +Static method in class papaya.NaNs +
Modifies the original data array by replacing the NaN elements in the data set with the value + specified by newNaN. +
replaceOriginalWith(float[], float) - +Static method in class papaya.NaNs +
Modifies the original data array by replacing the NaN elements in the data set with the value + specified by newNaN. +
reshape(float[][], int, int) - +Static method in class papaya.Mat +
Reshapes a matrix into the new specified dimensions. +
residual(float[], int) - +Static method in class papaya.Linear.StdErr +
Returns the standard error of the residuals given the degrees of freedom. +
residuals(float[], float[], float, float) - +Static method in class papaya.Linear +
Compute and return the array of residuals given by + Delta_i = z_i - y_i, + where + z_i = (slope*x_i + intercept) is the best fit linear line. +
residuals(float[], float[]) - +Static method in class papaya.Linear +
Compute and return the array of residuals given by + Delta_i = z_i - y_i, + where + z_i = (slope*x_i + intercept) is the best fit linear line. +
reverse(double[]) - +Static method in class papaya.Mat +
reverses the order of the elements in an array. +
reverse(float[]) - +Static method in class papaya.Mat +
reverses the order of the elements in an array. +
reverse(int[]) - +Static method in class papaya.Mat +
reverses the order of the elements in an array. +
RIGHT - +Static variable in interface papaya.PapayaConstants +
  +
rightBound - +Variable in class papaya.BoxPlot +
Specifies the space on the right betweent the plot area, and the + bounding rectangle. +
rightBound - +Variable in class papaya.ScatterPlot +
Specifies the space on the right betweent the plot area, and the + bounding rectangle. +
rightBound - +Variable in class papaya.SubPlot +
Specifies the space on the right betweent the plot area, and the + bounding rectangle. +
rms(int, double) - +Static method in class papaya.Descriptive +
Returns the RMS (Root-Mean-Square) of a data sequence. +
rms(float, float) - +Static method in class papaya.Descriptive.Weighted +
Returns the weighted RMS (Root-Mean-Square) of a data sequence. +
roundToDecimalPlace(float, int) - +Static method in class papaya.Mat +
Function for rounding to a given decimal place. +
rowMean(float[][]) - +Static method in class papaya.Descriptive.Mean +
Returns an array containing the arithmetic mean of each row of the input matrix. +
+
+

+S

+
+
s - +Variable in class papaya.SubPlot +
  +
ScatterPlot - Class in papaya
A simple class to plot x vs y data as a + scatter plot.
ScatterPlot(PApplet, float, float, float, float) - +Constructor for class papaya.ScatterPlot +
  +
setBackgroundColor(int) - +Method in class papaya.Visuals +
  +
setData(float[][], float, float) - +Method in class papaya.BoxPlot +
Sets the data to be plotted. +
setDataExtremes(float, float, float, float) - +Method in class papaya.ScatterPlot +
Set the minimum/maximum values on the x and y axis to nice numbers. +
setDataExtremes(float, float, float, float, int, int) - +Method in class papaya.SubPlot +
Sets the data extremes for subplot(xnum,ynum) by calling ScatterPlot.setDataExtremes(float, float, float, float) +
setHeight(float) - +Method in class papaya.Visuals +
  +
setLeft(float) - +Method in class papaya.Visuals +
  +
setToFloat(Set<Float>) - +Static method in class papaya.Cast +
Function for casting a Set to float[] +
setToInt(Set<Integer>) - +Static method in class papaya.Cast +
Function for casting a Set to float[] +
setTop(float) - +Method in class papaya.Visuals +
  +
setToString(Set<String>) - +Static method in class papaya.Cast +
Function for casting a Set to String array. +
setupFont(String, int, int, int) - +Method in class papaya.Visuals +
function for setting the font up for writing the labels +
setupFont(String, int, int, int, int) - +Method in class papaya.Visuals +
overload setupFont function that takes in font color +
setWidth(float) - +Method in class papaya.Visuals +
  +
seuclidean(float[][]) - +Static method in class papaya.Distance +
Computes the standardized Euclidean distance between pairs of objects + in the m-by-n data matrix X by standardizing X first prior to computing + the distances. +
signTest(float[], float[]) - +Static method in class papaya.Comparison +
Performs the sign test on an input array and returns the test statistic used to + test the hypothesis that there is "no difference in medians" + between the continuous distributions of two random variables X and Y. +
skew(float, float) - +Static method in class papaya.Descriptive +
Returns the skew of a data sequence when the 3rd moment has already been computed. +
skew(float[], float, float) - +Static method in class papaya.Descriptive +
Returns the skew of a data sequence, which is moment(data,3,mean) / standardDeviation3. +
skew(float[]) - +Static method in class papaya.Normality.Dago +
Computes and returns an array containing the test statistic zb1associated with sqrt(b1) and + the significance, or "p-value" of the skew test statistic zb1, assuming a + two-tailed null hypothesis as well as . +
skewSymmetric(float[][]) - +Static method in class papaya.Mat +
Returns the skew symmetric part of the input matrix ((A-A')/2). +
slope(float, float, int) - +Static method in class papaya.Linear.Significance +
Returns the p-value, or significance, of the computed slope under the null-hypothesis + of slope = 0 (two-tailed test). +
slope(float[], float) - +Static method in class papaya.Linear.StdErr +
Returns the standard error of the computed slope given x and the + standard error in the residuals. +
solve(float[], boolean) - +Method in class papaya.LU +
Solve A*x = b for x +
solve(float[][]) - +Method in class papaya.LU +
Solve A*X = B +
solve(float[]) - +Method in class papaya.QR +
Least squares solution of A*X = b +
solve(float[][]) - +Method in class papaya.QR +
Least squares solution of A*X = B +
Sorting - Class in papaya
Class for getting the array of indices that can be used to sort the array in ascending or + descending order.
spearman(float, int) - +Static method in class papaya.Correlation.Significance +
Returns the p-value, or significance level of the Spearman rank-correlation rho + between two datasets under the null hypothesis of no correlation. +
spearman(float[][], boolean) - +Static method in class papaya.Correlation +
Computes Spearman's rank-correlation, or rho, between multiple columns of a matrix + with each column corresponding to a dataset, and each row an observation. +
spearman(float[], float[], boolean) - +Static method in class papaya.Correlation +
Computes Spearman's rank-correlation, or rho. +
spearman(float[][]) - +Static method in class papaya.Distance +
Computes the Spearman distance matrix of the m-by-n input matrix X. +
split(float[], float[]) - +Static method in class papaya.Mat +
Splits (partitions) an array into sublists such that each sublist contains the elements with a given range. +
SQRTH - +Static variable in interface papaya.PapayaConstants +
  +
SQTPI - +Static variable in interface papaya.PapayaConstants +
  +
squaredDeviations(int, float) - +Static method in class papaya.Descriptive.Sum +
Returns the sum of squared mean deviation of of a data sequence. +
squares(float[]) - +Static method in class papaya.Descriptive.Sum +
Returns the sum of squares of a data sequence. +
ssbg() - +Method in class papaya.OneWayAnova +
Returns the sum of squared deviates between each group. +
sswg() - +Method in class papaya.OneWayAnova +
Returns the sum of squared deviates of the data within each group. +
std(float[], boolean) - +Static method in class papaya.Descriptive +
Returns the standard deviation of a dataset. +
std(float[][], boolean) - +Static method in class papaya.Descriptive +
Returns an array with each element of the array corresponding to + the standard deviations of each column of the input + matrix. +
stdUnbiased(int, float) - +Static method in class papaya.Descriptive +
Returns the unbiased sample standard deviation assuming the sample is normally distributed. +
STROKEWEIGHT - +Static variable in interface papaya.PapayaConstants +
  +
subMatrix(float[][], int, int, int, int) - +Static method in class papaya.Mat +
Get a (2D) submatrix of a (2D) matrix (a copy, not a pointer). +
subMatrix(float[][], int[], int, int) - +Static method in class papaya.Mat +
Function to get a (2D) submatrix of a (2D) matrix (a copy, not a pointer). +
subMatrix(float[][], int, int, int[]) - +Static method in class papaya.Mat +
Function to get a (2D) submatrix of a (2D) matrix (a copy, not a pointer). +
subMatrix(float[][], int[], int[]) - +Static method in class papaya.Mat +
Function to get a (2D) submatrix of a (2D) matrix (a copy, not a pointer). +
subMatrix(int[][], int[], int[]) - +Static method in class papaya.Mat +
  +
SubPlot - Class in papaya
Convenient class for drawing multiple scatter plots.
SubPlot(PApplet, float, float, float, float, int, int) - +Constructor for class papaya.SubPlot +
Creates numX*numY plots, each of with xWidth, and height yHeight. +
subtract(float[], float[]) - +Static method in class papaya.Mat +
Returns the array z = x-y where each element of z[i] = x[i] - y[i] +
subtract(float[][], float[][]) - +Static method in class papaya.Mat +
Returns the matrix z = x-y where each element of z[i][j] = x[i][j] - y[i][j] +
sum(float[]) - +Static method in class papaya.Descriptive.Sum +
Returns the simple sum of a data sequence. +
sum(float[]) - +Static method in class papaya.Mat +
Returns the sum of a data sequence. +
sum(float[], float[]) - +Static method in class papaya.Mat +
Returns the sum of two data sequences. +
sum(float[], float) - +Static method in class papaya.Mat +
Sum of an array with a number. +
sum(int[]) - +Static method in class papaya.Mat +
Returns the sum of a data sequence. +
sum(int[], int[]) - +Static method in class papaya.Mat +
Returns the sum of two data sequences. +
sum(int[], int) - +Static method in class papaya.Mat +
Sum of an array with a number. +
sum(float[][], float[][]) - +Static method in class papaya.Mat +
Returns the matrix z = x+y where each element of z[i][j] = x[i][j] + y[i][j] +
SVD - Class in papaya
Singular Value Decomposition.
SVD(float[][]) - +Constructor for class papaya.SVD +
Construct the singular value decomposition. +
swap(float[], int, int) - +Static method in class papaya.Mat +
Swap function that swaps the values in an array +
swap(int[], int, int) - +Static method in class papaya.Mat +
Swap function that swaps the values in an array (overload function) +
symmetric(float[][]) - +Static method in class papaya.Mat +
Returns the symmetric part of the input matrix ((A+A')/2). +
+
+

+T

+
+
tcdf(double, double) - +Static method in class papaya.Probability +
Returns the integral from minus infinity to t of the Student-t + distribution with k > 0 degrees of freedom. +
TEXTSIZE - +Static variable in interface papaya.PapayaConstants +
  +
tinv(double, double) - +Static method in class papaya.Probability +
Returns the value, t, for which the area under the + Student-t probability density function (integrated from + minus infinity to t) is equal to p. +
TOP - +Static variable in interface papaya.PapayaConstants +
  +
topBound - +Variable in class papaya.BoxPlot +
Specifies the space on the top, between the plot area and the bounding + rectangle. +
topBound - +Variable in class papaya.ScatterPlot +
Specifies the space on the top, between the plot area and the bounding + rectangle. +
topBound - +Variable in class papaya.SubPlot +
Specifies the space on the top, between the plot area and the bounding + rectangle. +
trace(float[][]) - +Static method in class papaya.Mat +
Returns the matrix trace or sum of the diagonal elements. +
transform(float[], float) - +Static method in class papaya.Linear.BoxCox +
Performs the box-cox transformation, returning the transformed data. +
transpose(float[][]) - +Static method in class papaya.Mat +
Returns the transpose of the input matrix. +
transpose(int[][]) - +Static method in class papaya.Mat +
  +
trimmed(float[], float, int, int) - +Static method in class papaya.Descriptive.Mean +
Returns the trimmed arithmetic mean of a sorted data sequence. +
tukeyFiveNum(float[]) - +Static method in class papaya.Descriptive +
Return the tukey five number summary of a dataset consisting of the minimum, maximum, + and three quartile values. +
twoArrays(float[], float[], int, int, boolean) - +Static method in class papaya.Sorting +
Sorts the input x and y arrays according to + x and going from fromIndex(inclusive) to toIndex(exclusive) + in ascending or descending order. +
twoArrays(double[], double[], int, int, boolean) - +Static method in class papaya.Sorting +
  +
twoArrays(int[], int[], int, int, boolean) - +Static method in class papaya.Sorting +
  +
+
+

+U

+
+
unequalVar(float[], float[]) - +Static method in class papaya.Comparison.TTest +
Returns the t-statistic and p-value for checking whether the means + between the two datasets are different under the assumption that both + datasets have unequal variances. +
Unique - Class in papaya
Class for getting and storing an unsorted array's unique elements, + the indices of these elements, and the number of times the elements occur.
Unique(float[], boolean) - +Constructor for class papaya.Unique +
Class for storing the unique values in an unsorted data array. +
uniqueElems(int[]) - +Static method in class papaya.Find +
Find the unique elements in a int array (uses HashSets) +
uniqueElems(float[]) - +Static method in class papaya.Find +
Find the unique elements in a float array (uses HashSets) +
+
+

+V

+
+
values - +Variable in class papaya.Unique +
ArrayList containing the unique values +
var(float, int, float, int, boolean) - +Static method in class papaya.Descriptive.Pooled +
Returns the pooled variance of two data sequences. +
var(float[], int[], boolean) - +Static method in class papaya.Descriptive.Pooled +
Returns the pooled variance of k data sequences. +
var(float[], boolean) - +Static method in class papaya.Descriptive +
Returns the variance of a dataset, V. +
var(float[][], boolean) - +Static method in class papaya.Descriptive +
Returns an array containing the variance of each column of the input matrix X. +
var(float[], float[], boolean) - +Static method in class papaya.Descriptive.Weighted +
Returns the weighted variance of a data sequence of length N + There are (unfortunately) many different definitions of the unbiased weighted variance. +
vectorToFloat(Vector<Float>) - +Static method in class papaya.Cast +
function for casting Vector to float[] +
vectorToInt(Vector<Integer>) - +Static method in class papaya.Cast +
function for casting Vector to int[] +
vertLine(float, float, float, int, float) - +Method in class papaya.Visuals +
draws a vertical line with color _sColor, and weight _sWeight +
Visuals - Class in papaya
Visuals is the parent class behind most of the other plotting classes.
Visuals(PApplet, float, float, float, float) - +Constructor for class papaya.Visuals +
The parent class behind the other plotting classes. +
+
+

+W

+
+
winsorized(float[], float, int, int) - +Static method in class papaya.Descriptive.Mean +
Returns the winsorized mean of a sorted data sequence. +
within(float, float, float) - +Static method in class papaya.Mat +
Checks to see if a number is in the range specified by [min,max]. +
within(float[], float, float) - +Static method in class papaya.Mat +
returns an array containing all numbers within the min and max (inclusive). +
writeLabels(PFont, String[], float[], float[]) - +Method in class papaya.Visuals +
  +
writeLabels(PFont, String, float, float) - +Method in class papaya.Visuals +
  +
writeLabels(PFont, float, float, float) - +Method in class papaya.Visuals +
  +
writeLabels(float, float, float) - +Method in class papaya.Visuals +
  +
writeLabels(String, float, float) - +Method in class papaya.Visuals +
  +
writeTitle(PFont, String, int, int) - +Method in class papaya.SubPlot +
Writes the title for subplot(xnum,ynum). +
writeTitle(String, int, int) - +Method in class papaya.SubPlot +
Writes the title for subplot(xnum,ynum). +
writeTitle(String, PFont) - +Method in class papaya.Visuals +
titles the plot given the String _title and the PFont +
+
+

+X

+
+
xLabels(int, int, int) - +Method in class papaya.SubPlot +
Writes the x labels for subplot(xnum,ynum). +
xLabels(float, float, float, float, int) - +Method in class papaya.Visuals +
Write the x-axis labels. +
xLabels(float, float, String[]) - +Method in class papaya.Visuals +
Write the x-axis labels. +
xLefts - +Variable in class papaya.SubPlot +
  +
xSpacing - +Variable in class papaya.SubPlot +
  +
xTicks(float, float, int, int) - +Method in class papaya.Visuals +
Draws the x-axis tickmarks. +
xW - +Variable in class papaya.SubPlot +
  +
XYLabels - +Variable in class papaya.ScatterPlot +
  +
XYTicks - +Variable in class papaya.ScatterPlot +
  +
+
+

+Y

+
+
yH - +Variable in class papaya.SubPlot +
  +
yLabels(int, int, int) - +Method in class papaya.SubPlot +
Writes the y labels for subplot(xnum,ynum). +
yLabels(float, float, float, float, int) - +Method in class papaya.Visuals +
Write the y-axis labels. +
yLabels(float, float, String[]) - +Method in class papaya.Visuals +
Write the y-axis labels. +
YLines(int) - +Method in class papaya.Visuals +
Draws horizontal y-lines on the plot +
ySpacing - +Variable in class papaya.SubPlot +
  +
yTicks(float, float, int, int) - +Method in class papaya.Visuals +
Draws the y-axis tickmarks. +
yTops - +Variable in class papaya.SubPlot +
  +
+
+

+Z

+
+
zScore(float, float, float) - +Static method in class papaya.Descriptive +
  +
zScore(float[], float, float) - +Static method in class papaya.Descriptive +
Returns the array of z-scores for a given data array. +
zScore(float[][], float[], float[]) - +Static method in class papaya.Descriptive +
Computes the standardized version of the input matrix. +
+
+A B C D E F G H I K L M N O P Q R S T U V W X Y Z + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package  Class  Tree  Deprecated   Index  Help 
+		 + +
+ PREV  + NEXT + FRAMES   + NO FRAMES   +  + + + +
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/index.html b/drawing/papaya/reference/index.html new file mode 100644 index 0000000..c231207 --- /dev/null +++ b/drawing/papaya/reference/index.html @@ -0,0 +1,70 @@ + + + + + + +Javadocs: papaya + + + + + + + + +<H2> +Frame Alert</H2> + +<P> +This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client. +<BR> +Link to<A HREF="papaya/package-summary.html">Non-frame version.</A> + + + diff --git a/drawing/papaya/reference/overview-tree.html b/drawing/papaya/reference/overview-tree.html new file mode 100644 index 0000000..5ffd83c --- /dev/null +++ b/drawing/papaya/reference/overview-tree.html @@ -0,0 +1,168 @@ + + + + + + +Class Hierarchy (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package  Class   Tree  Deprecated  Index  Help 
+		 + +
+ PREV  + NEXT + FRAMES   + NO FRAMES   +  + + + +
+ + + +
+
+

+Hierarchy For All Packages

+
+
+
Package Hierarchies:
papaya
+
+

+Class Hierarchy +

+ +

+Interface Hierarchy +

+ +
+ + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package  Class   Tree  Deprecated  Index  Help 
+		 + +
+ PREV  + NEXT + FRAMES   + NO FRAMES   +  + + + +
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/package-list b/drawing/papaya/reference/package-list new file mode 100644 index 0000000..cc8ed38 --- /dev/null +++ b/drawing/papaya/reference/package-list @@ -0,0 +1 @@ +papaya diff --git a/drawing/papaya/reference/papaya/BoxPlot.html b/drawing/papaya/reference/papaya/BoxPlot.html new file mode 100644 index 0000000..a49302b --- /dev/null +++ b/drawing/papaya/reference/papaya/BoxPlot.html @@ -0,0 +1,498 @@ + + + + + + +BoxPlot (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class BoxPlot

+
+java.lang.Object
+  extended by papaya.Visuals
+      extended by papaya.BoxPlot
+
+
+
All Implemented Interfaces:
PapayaConstants
+
+
+
+
public class BoxPlot
extends Visuals
+ + +

+BoxPlot class +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Field Summary
+ floatbottomBound + +
+          Specifies the space on the bottom, between the plot area and the bounding + rectangle.
+ booleandrawAxes + +
+          Specifies whether to draw the axes
+ booleandrawRectangle + +
+          Specifies whether to draw the bounding rectangle around the plot.
+ floatleftBound + +
+          Specifies the space on the left between the plot area, and the + bounding rectangle.
+ floatrightBound + +
+          Specifies the space on the right betweent the plot area, and the + bounding rectangle.
+ floattopBound + +
+          Specifies the space on the top, between the plot area and the bounding + rectangle.
+  + + + + + + + +
Fields inherited from class papaya.Visuals
bgColor
+  + + + + + + + +
Fields inherited from interface papaya.PapayaConstants
BASELINE, big, biginv, BOTTOM, CENTER, CORNER, FONTNAME, GRAY, INDEX_NOT_FOUND, INDICES_NOT_FOUND, LEFT, LOGPI, MACHEP, MAXGAM, MAXLOG, MINLOG, RIGHT, SQRTH, SQTPI, STROKEWEIGHT, TEXTSIZE, TOP
+  + + + + + + + + + + +
+Constructor Summary
BoxPlot(PApplet _theParent, + float _plotLeft, + float _plotTop, + float _plotWidth, + float _plotHeight) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddrawBoxPlot(String[] _labels, + float _sWeight, + int _fColor) + +
+          Plot the box plots.
+ float[][]getData() + +
+           
+ voidsetData(float[][] _fiveNumArr, + float _minVal, + float _maxVal) + +
+          Sets the data to be plotted.
+  + + + + + + + +
Methods inherited from class papaya.Visuals
drawAxes, drawRect, drawRect, getBottom, getHeight, getLeft, getRight, getTop, getWidth, horizLine, legendHoriz, legendVert, line, mapXData, mapXData, mapYData, mapYData, setBackgroundColor, setHeight, setLeft, setTop, setupFont, setupFont, setWidth, vertLine, writeLabels, writeLabels, writeLabels, writeLabels, writeLabels, writeTitle, xLabels, xLabels, xTicks, yLabels, yLabels, YLines, yTicks
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Field Detail
+ +

+drawRectangle

+
+public boolean drawRectangle
+
+
Specifies whether to draw the bounding rectangle around the plot. +

+

+
+
+
+ +

+drawAxes

+
+public boolean drawAxes
+
+
Specifies whether to draw the axes +

+

+
+
+
+ +

+leftBound

+
+public float leftBound
+
+
Specifies the space on the left between the plot area, and the + bounding rectangle. That is, the left-most point of + the rectangle is given by plotLeft-leftBound. +

+

+
+
+
+ +

+rightBound

+
+public float rightBound
+
+
Specifies the space on the right betweent the plot area, and the + bounding rectangle. That is, the right-most point of + the rectangle is given by plotLeft+plotWidth+rightBound. +

+

+
+
+
+ +

+topBound

+
+public float topBound
+
+
Specifies the space on the top, between the plot area and the bounding + rectangle. That is, the top-most point of the rectangle is given by + plotTop - topBound. +

+

+
+
+
+ +

+bottomBound

+
+public float bottomBound
+
+
Specifies the space on the bottom, between the plot area and the bounding + rectangle. That is, the bottom-most point of the rectangle is given by + plotTop + plotHeight + bottomBound. +

+

+
+
+ + + + + + + + +
+Constructor Detail
+ +

+BoxPlot

+
+public BoxPlot(PApplet _theParent,
+               float _plotLeft,
+               float _plotTop,
+               float _plotWidth,
+               float _plotHeight)
+
+
+ + + + + + + + +
+Method Detail
+ +

+setData

+
+public void setData(float[][] _fiveNumArr,
+                    float _minVal,
+                    float _maxVal)
+
+
Sets the data to be plotted. +

+

+
Parameters:
_fiveNumArr - array of five number box plot summaries + with each row corresponding to a given data set. See Descriptive.tukeyFiveNum(float[]) for more info.
_minVal - the minimum value to show in the plot
_maxVal - the maximum value to show in the plot
+
+
+
+ +

+getData

+
+public float[][] getData()
+
+
+ +
Returns:
the tukey five number array
+
+
+
+ +

+drawBoxPlot

+
+public void drawBoxPlot(String[] _labels,
+                        float _sWeight,
+                        int _fColor)
+
+
Plot the box plots. +

+

+
Parameters:
_labels - labels for the box plot
_sWeight - the stroke weight to use for the lines.
_fColor - the fill color for the boxplots
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Cast.html b/drawing/papaya/reference/papaya/Cast.html new file mode 100644 index 0000000..1eca94c --- /dev/null +++ b/drawing/papaya/reference/papaya/Cast.html @@ -0,0 +1,576 @@ + + + + + + +Cast (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Cast

+
+java.lang.Object
+  extended by papaya.Cast
+
+
+
+
public final class Cast
extends Object
+ + +

+Static Class for casting Object arrays to their corresponding primitive type. + Similar to the toArray(T[] a) method specified in the java Collections + interface, but for float[] and int[] arrays (as opposed to Float[] and Integer[]). +

+ +

+

+ +

+

+
Author:
+
Nur Adila Faruk Senan
+
+
+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static float[]arrayListToFloat(ArrayList<Float> _inputDat) + +
+          function for casting ArrayList to float[]
+static int[]arrayListToInt(ArrayList<Integer> _inputDat) + +
+          function for casting ArrayList to int[]
+static float[]doubleToFloat(double[] _inputDat) + +
+          function for casting double[] to float[]
+static float[][]doubleToFloat(double[][] _inputDat) + +
+          function for casting double[][] to float[][]
+static double[]floatToDouble(float[] _inputDat) + +
+          function for casting float[] to double[]
+static double[][]floatToDouble(float[][] _inputDat) + +
+          function for casting float[][] to double[][]
+static PVector[]floatToPVector(float[] x, + float[] y) + +
+          Returns a PVector array with the x, and coordinates set to the input values, and the z coordinates + set to zero.
+static PVector[]floatToPVector(float[] x, + float[] y, + float[] z) + +
+          Returns a PVector array with the x, y, and z coordinates set to the input values + (technically not a cast, but a reorganization).
+static float[]keySetToFloat(HashMap _hMap) + +
+          Function for casting hashMap keySet to float[]
+static int[]keySetToInt(HashMap _hMap) + +
+          Function for casting hashMap keySet to float[]
+static String[]keySetToString(HashMap _hMap) + +
+          Function for casting hashMap keySet to String[]
+static float[]setToFloat(Set<Float> theSet) + +
+          Function for casting a Set to float[]
+static int[]setToInt(Set<Integer> theSet) + +
+          Function for casting a Set to float[]
+static String[]setToString(Set<String> theSet) + +
+          Function for casting a Set to String array.
+static float[]vectorToFloat(Vector<Float> _inputDat) + +
+          function for casting Vector to float[]
+static int[]vectorToInt(Vector<Integer> _inputDat) + +
+          function for casting Vector to int[]
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+arrayListToInt

+
+public static int[] arrayListToInt(ArrayList<Integer> _inputDat)
+
+
function for casting ArrayList to int[] +

+

+
Parameters:
_inputDat - ArrayList array that needs to be cast to int[] +
Returns:
the resulting int[] array
+
+
+
+ +

+arrayListToFloat

+
+public static float[] arrayListToFloat(ArrayList<Float> _inputDat)
+
+
function for casting ArrayList to float[] +

+

+
Parameters:
_inputDat - ArrayList array that needs to be cast to float[] +
Returns:
the resulting float[] array
+
+
+
+ +

+floatToDouble

+
+public static double[][] floatToDouble(float[][] _inputDat)
+
+
function for casting float[][] to double[][] +

+

+
Parameters:
_inputDat - float[][] 2d array +
Returns:
deep copy of _inputDat with each element cast to a double
+
+
+
+ +

+floatToDouble

+
+public static double[] floatToDouble(float[] _inputDat)
+
+
function for casting float[] to double[] +

+

+
Parameters:
_inputDat - float[] array +
Returns:
deep copy of _inputDat with each element cast to a double
+
+
+
+ +

+doubleToFloat

+
+public static float[][] doubleToFloat(double[][] _inputDat)
+
+
function for casting double[][] to float[][] +

+

+
Parameters:
_inputDat - double[][] 2d array +
Returns:
deep copy of _inputDat with each element cast to a float
+
+
+
+ +

+doubleToFloat

+
+public static float[] doubleToFloat(double[] _inputDat)
+
+
function for casting double[] to float[] +

+

+
Parameters:
_inputDat - double[] array +
Returns:
deep copy of _inputDat with each element cast to a float
+
+
+
+ +

+keySetToString

+
+public static String[] keySetToString(HashMap _hMap)
+
+
Function for casting hashMap keySet to String[] +

+

+
Parameters:
_hMap - input HashMap +
Returns:
Hashmap.keySet() cast to String[] + Use only for the case where the HashMap Keys are Strings
+
+
+
+ +

+keySetToInt

+
+public static int[] keySetToInt(HashMap _hMap)
+
+
Function for casting hashMap keySet to float[] +

+

+
Parameters:
_hMap - input HashMap +
Returns:
Hashmap.keySet() cast to float[] + Use only for the case where the HashMap Keys are floats
+
+
+
+ +

+keySetToFloat

+
+public static float[] keySetToFloat(HashMap _hMap)
+
+
Function for casting hashMap keySet to float[] +

+

+
Parameters:
_hMap - input HashMap +
Returns:
Hashmap.keySet() cast to float[] + Use only for the case where the HashMap Keys are floats
+
+
+
+ +

+setToInt

+
+public static int[] setToInt(Set<Integer> theSet)
+
+
Function for casting a Set to float[] +

+

+
+
+
+
+ +

+setToFloat

+
+public static float[] setToFloat(Set<Float> theSet)
+
+
Function for casting a Set to float[] +

+

+
+
+
+
+ +

+setToString

+
+public static String[] setToString(Set<String> theSet)
+
+
Function for casting a Set to String array. This is really just one line of code, but it's + much easier to have it as an external function rather than having to remember it +

+

+
+
+
+
+ +

+vectorToInt

+
+public static int[] vectorToInt(Vector<Integer> _inputDat)
+
+
function for casting Vector to int[] +

+

+
Parameters:
_inputDat - Vector array that needs to be cast to int[] +
Returns:
the resulting int[] array
+
+
+
+ +

+vectorToFloat

+
+public static float[] vectorToFloat(Vector<Float> _inputDat)
+
+
function for casting Vector to float[] +

+

+
Parameters:
_inputDat - Vector array that needs to be cast to float[] +
Returns:
the resulting float[] array
+
+
+
+ +

+floatToPVector

+
+public static PVector[] floatToPVector(float[] x,
+                                       float[] y,
+                                       float[] z)
+
+
Returns a PVector array with the x, y, and z coordinates set to the input values + (technically not a cast, but a reorganization). +

+

+
+
+
+
+ +

+floatToPVector

+
+public static PVector[] floatToPVector(float[] x,
+                                       float[] y)
+
+
Returns a PVector array with the x, and coordinates set to the input values, and the z coordinates + set to zero. + (technically not a cast, but a reorganization). +

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Comparison.TTest.html b/drawing/papaya/reference/papaya/Comparison.TTest.html new file mode 100644 index 0000000..06849d9 --- /dev/null +++ b/drawing/papaya/reference/papaya/Comparison.TTest.html @@ -0,0 +1,318 @@ + + + + + + +Comparison.TTest (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Comparison.TTest

+
+java.lang.Object
+  extended by papaya.Comparison.TTest
+
+
+
Enclosing class:
Comparison
+
+
+
+
public static class Comparison.TTest
extends Object
+ + +

+Methods related to comparing two populations. Each method returns an array with the + first element containing the t-statistic, and the second corresponding to the + p-value, or significance, of rejecting the null hypothesis. +

+ Tests can be:

    +
  • One-sample or two-sample
    • +
  • One-sided or two-sided
    • +
  • Paired or unpaired (for two-sample tests)
    • +
  • Homoscedastic (equal variance assumption) or heteroscedastic + (for two sample tests)
    • +
  • Fixed significance level (boolean-valued) or returning p-values. +

+

+ Test statistics are available for all tests. Methods including "Test" in + in their names perform tests, all other methods return t-statistics. Among + the "Test" methods, double-valued methods return p-values; + boolean-valued methods perform fixed significance level tests. + Significance levels are always specified as numbers between 0 and 0.5 + (e.g. tests at the 95% level use alpha=0.05).

+

+ + Note: Inspired by the + stats.inference.TTest class available in the Apache Commons math library. +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static float[]equalVar(float[] data1, + float[] data2) + +
+          Returns the t-statistic and p-value for checking whether the means + between the two datasets are different under the assumption that both + datasets have equal variances.
+static float[]paired(float[] before, + float[] after) + +
+          Returns the t-statistic and p-value for checking a pair of dependent samples.
+static float[]unequalVar(float[] data1, + float[] data2) + +
+          Returns the t-statistic and p-value for checking whether the means + between the two datasets are different under the assumption that both + datasets have unequal variances.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+equalVar

+
+public static float[] equalVar(float[] data1,
+                               float[] data2)
+
+
Returns the t-statistic and p-value for checking whether the means + between the two datasets are different under the assumption that both + datasets have equal variances. The p-value corresponds to the + null hypothesis of no-difference (i.e. two-tailed). +

+

+ +
Returns:
an array with the first element = t and the second element = p.
+
+
+
+ +

+unequalVar

+
+public static float[] unequalVar(float[] data1,
+                                 float[] data2)
+
+
Returns the t-statistic and p-value for checking whether the means + between the two datasets are different under the assumption that both + datasets have unequal variances. The p-value corresponds to the + null hypothesis of no-difference (i.e. two-tailed). + This is also known as Welch's t-test. +

+

+ +
Returns:
an array with the first element = t and the second element = p.
+
+
+
+ +

+paired

+
+public static float[] paired(float[] before,
+                             float[] after)
+
+
Returns the t-statistic and p-value for checking a pair of dependent samples. + That is, when there is only one sample that has been tested twice + (repeated measures) or when there are two samples that have been + matched or "paired". The p-value corresponds to the + null hypothesis of no-difference in both measurements (i.e. two-tailed). +

Both datasets have to have equal lengths. +

+

+
Parameters:
before - the dataset before treatment/measurement.
after - the dataset after treatment/measurement. +
Returns:
an array with the first element = t and the second element = p.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Comparison.html b/drawing/papaya/reference/papaya/Comparison.html new file mode 100644 index 0000000..19e56e6 --- /dev/null +++ b/drawing/papaya/reference/papaya/Comparison.html @@ -0,0 +1,374 @@ + + + + + + +Comparison (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Comparison

+
+java.lang.Object
+  extended by papaya.Comparison
+
+
+
All Implemented Interfaces:
PapayaConstants
+
+
+
+
public class Comparison
extends Object
implements PapayaConstants
+ + +

+Contains a number of methods for comparing more than one dataset + against each other. Rank-based methods and are powerful in the sense that they do not rely + on the data assuming a normal distribution. +

+ +

+

+ +

+ + + + + + + + + + + +
+Nested Class Summary
+static classComparison.TTest + +
+          Methods related to comparing two populations.
+  + + + + + + +
+Field Summary
+  + + + + + + + +
Fields inherited from interface papaya.PapayaConstants
BASELINE, big, biginv, BOTTOM, CENTER, CORNER, FONTNAME, GRAY, INDEX_NOT_FOUND, INDICES_NOT_FOUND, LEFT, LOGPI, MACHEP, MAXGAM, MAXLOG, MINLOG, RIGHT, SQRTH, SQTPI, STROKEWEIGHT, TEXTSIZE, TOP
+  + + + + + + + + + + +
+Constructor Summary
Comparison() + +
+          Makes this class non instantiable, but still let's others inherit from it.
+  + + + + + + + + + + + + + + + +
+Method Summary
+static float[]mannWhitney(float[] data1, + float[] data2) + +
+          Computes and returns the MannWhitney (or Wilcoxon Rank Sum) test statistic, U and p-value for + assessing whether one of two samples of independent observations tends to have + larger values than the other.
+static floatsignTest(float[] x, + float[] y) + +
+          Performs the sign test on an input array and returns the test statistic used to + test the hypothesis that there is "no difference in medians" + between the continuous distributions of two random variables X and Y.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+Comparison

+
+public Comparison()
+
+
Makes this class non instantiable, but still let's others inherit from it. +

+

+ + + + + + + + +
+Method Detail
+ +

+mannWhitney

+
+public static float[] mannWhitney(float[] data1,
+                                  float[] data2)
+
+
Computes and returns the MannWhitney (or Wilcoxon Rank Sum) test statistic, U and p-value for + assessing whether one of two samples of independent observations tends to have + larger values than the other. That is, + 
U = min(U1,U2)
+ where + 
+ U1 = Sum(Ranks1)  - n1*(n1+1)/2,   
+ U2 = Sum(Ranks2) - n2*(n2+1)/2.
+
+ and the significance, or p-value is computed assuming + a two-tailed null-hypothesis that both samples are similar. +

+

+
+
+
+
Parameters:
data1 - the first dataset
data2 - the second dataset +
Returns:
a 2 element array with first element corresponding to the test statistic, and second + equal to the p-value or significance. +
Throws: +
IllegalArgumentException - if either of the sample sizes is less than 8 (the normal approximation + is no longer valid in that case. Best to consult a table instead).
+
+
+
+ +

+signTest

+
+public static float signTest(float[] x,
+                             float[] y)
+
+
Performs the sign test on an input array and returns the test statistic used to + test the hypothesis that there is "no difference in medians" + between the continuous distributions of two random variables X and Y. It is used in + the situation when we can draw paired samples from X and Y and is a convenient method + as it makes very few assumptions about the nature of the distributions under test. +

+

To elaborate, the null hypothesis H0 states that given a random pair of measurements (X[i], Y[i]), + X[i] and Y[i] are equally likely to be larger than the other. + Now, let n be the number of pairs for which Y[i] ≠ X[i] and w + be the number of pairs for which Y[i] - X[i] > 0. + Assuming that H0 is true, then W follows a binomial distribution W ~ b(n, 0.5). + + This method returns the sum of the terms 0 through w of the Binomial + probability density. + 

 
+ Sum_(j=0 to w)  [ (n!)/(j!*(n-j)! ]  *  [ p^j * (1-p)^(n-j) ]
+ from 0 to the test-statistic, or
+ 

+ p = Probability.binomcdf(.5,w,n).
+ 

+ For n > 100, the normal distribution cdf is returned instead.
+ If this is less than the critical value, then we can reject the null hypothesis that there
+ is no difference between the samples X and Y.
+

+

+

+

+

+
Parameters:
x - data set containing 1st observation sequence
y - data set containing 2nd observation sequence
+
Returns:
the significance, or p-value, assuming a two-tailed null hypothesis (i.e. no difference)

+

+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Correlation.Significance.html b/drawing/papaya/reference/papaya/Correlation.Significance.html new file mode 100644 index 0000000..41d6f38 --- /dev/null +++ b/drawing/papaya/reference/papaya/Correlation.Significance.html @@ -0,0 +1,309 @@ + + + + + + +Correlation.Significance (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Correlation.Significance

+
+java.lang.Object
+  extended by papaya.Correlation.Significance
+
+
+
Enclosing class:
Correlation
+
+
+
+
public static class Correlation.Significance
extends Object
+ + +

+Contains methods used to compute the significance, or pvalue of the input correlations. + The significance is computed using the normal of student-t approximations and hence are + not to be used for small datasets(i.e. size<20). +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static floatdurbinWatson(float[] data) + +
+          The Durbin-Watson statistic is a test statistic used to detect the presence + of autocorrelation (Correlation.auto(float[], int, float, float)) + in the residuals (prediction errors) from a regression analysis.
+static floatlinear(float r, + int size) + +
+          Returns the p-value, or significance level of the linear correlation r + between two datasets under the null hypothesis of no correlation.
+static floatspearman(float rho, + int size) + +
+          Returns the p-value, or significance level of the Spearman rank-correlation rho + between two datasets under the null hypothesis of no correlation.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+durbinWatson

+
+public static float durbinWatson(float[] data)
+
+
The Durbin-Watson statistic is a test statistic used to detect the presence + of autocorrelation (Correlation.auto(float[], int, float, float)) + in the residuals (prediction errors) from a regression analysis. +

+ If e_t is the residual associated with the observation at time t, + and there are T observations, then the test statistic, d is +

+ 
+ d =   Sum_{from t=2 to T} ( e_t - e_{t-1} )^2    /   Sum_{from t=1 to T} ( e_t )^2
+
+

+

+ +
Returns:
d the Durbin Watson test statistic
+
+
+
+ +

+linear

+
+public static float linear(float r,
+                           int size)
+
+
Returns the p-value, or significance level of the linear correlation r + between two datasets under the null hypothesis of no correlation. + That is, H_0: ρ=0 (No linear correlation; Two-tailed test). The p-value is + computed by transforming the correlation to create a t-statistic + having n-2 degrees of freedom: + 
 t = r * sqrt( (n-2)/(1-r^2) ),
+ where n is the size of the corresponding datasets. +

+

+
Parameters:
r - the linear correlation coefficient
size - the size of the corresponding datasets (i.e. number of rows/observations). +
Throws: +
IllegalArgumentException - if the size is less than 20. Below this, + the student-T approximation is inaccurate.
+
+
+
+ +

+spearman

+
+public static float spearman(float rho,
+                             int size)
+
+
Returns the p-value, or significance level of the Spearman rank-correlation rho + between two datasets under the null hypothesis of no correlation. + That is, H_0: ρ_0=0 (No linear correlation; Two-tailed test). + The p-value is computed by transforming the correlation to create a t-statistic + having n-2 degrees of freedom: + 
 t = rho * sqrt( (n-2)/(1-rho^2) ),
+ where n is the size of the corresponding datasets. +

+

+
Parameters:
rho - the Spearman-correlation coefficient
size - the size of the corresponding datasets (i.e. number of rows/observations). +
Throws: +
IllegalArgumentException - if the size is less than 20. Below this, + the student-T approximation is inaccurate.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Correlation.Weighted.html b/drawing/papaya/reference/papaya/Correlation.Weighted.html new file mode 100644 index 0000000..f83d791 --- /dev/null +++ b/drawing/papaya/reference/papaya/Correlation.Weighted.html @@ -0,0 +1,335 @@ + + + + + + +Correlation.Weighted (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Correlation.Weighted

+
+java.lang.Object
+  extended by papaya.Correlation.Weighted
+
+
+
Enclosing class:
Correlation
+
+
+
+
public static class Correlation.Weighted
extends Object
+ + +

+Contains methods related to computing the correlation and covariance of weighted + datasets. +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static float[][]corr(float[][] data, + float[] weights, + boolean unbiased) + +
+          Returns the weighted linear correlation matrix C.
+static floatcorr(float[] data1, + float[] data2, + float[] weights, + boolean unbiased) + +
+          Returns the weighted linear correlation of two data sequences.
+static float[][]cov(float[][] data, + float[] weights, + boolean unbiased) + +
+          Returns the weighted covariance matrix with element S_JK specifying the weighted + covariance between column J and column K of the input matrix.
+static floatcov(float[] data1, + float[] data2, + float[] weights, + boolean unbiased) + +
+          Returns the weighted covariance between two data sequences.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+corr

+
+public static float[][] corr(float[][] data,
+                             float[] weights,
+                             boolean unbiased)
+
+
Returns the weighted linear correlation matrix C. + If S is an estimate of the weighted covariance matrix, then element JK of the + weighted correlation matrix C is then given by + 
+ C_JK = S_JK / sqrt(S_JJ,unbiasedValue)*sqrt(S_KK,unbiasedValue).
+
+ See Correlation.cov(float[][],boolean). +

+

+
Parameters:
data - input matrix each column corresponding to a sample, each row an observation.
weights - the weights to use.
unbiased - set to true to return the unbiased weighted correlation matrix, false to return the biased version.
+
+
+
+ +

+corr

+
+public static float corr(float[] data1,
+                         float[] data2,
+                         float[] weights,
+                         boolean unbiased)
+
+
Returns the weighted linear correlation of two data sequences. +

+

+
Parameters:
unbiased - set to true to return the unbiased weighted correlation, false to return the biased version.
+
+
+
+ +

+cov

+
+public static float cov(float[] data1,
+                        float[] data2,
+                        float[] weights,
+                        boolean unbiased)
+
+
Returns the weighted covariance between two data sequences. +

+

+
Parameters:
unbiased - set to true to return the unbiased weighted covariance, false to return the biased version.
+
+
+
+ +

+cov

+
+public static float[][] cov(float[][] data,
+                            float[] weights,
+                            boolean unbiased)
+
+
Returns the weighted covariance matrix with element S_JK specifying the weighted + covariance between column J and column K of the input matrix. +

+ The formula used to compute element S_JK of the unbiased covariance matrix is: + 

+ S_JK = biasCorrection * Sum ( w[i] * ( dataJ[i] - mu_w(dataJ) )*( dataK[i] - mu_w(dataK) ) ) / Sum (w[i])
+
+ where mu_w corresponds to the weighted mean of the dataset + and the biasCorrection term above is + 
+ biasCorrection = ( Sum(w[i]) )^2  / ( ( Sum(w[i]) )^2 - Sum( w[i]^2 )  ).
+
+ The elements of the biased covariance matrix are computed sans the bias Correction factor. +

+ Reference: + Covariance of weighted samples, wikipedia.org. +

+

+
Parameters:
data - input matrix each column corresponding to a sample, each row an observation.
weights - the weights to use.
unbiased - set to true to return the unbiased weighted covariance matrix, false to return the biased version.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Correlation.html b/drawing/papaya/reference/papaya/Correlation.html new file mode 100644 index 0000000..aea74a8 --- /dev/null +++ b/drawing/papaya/reference/papaya/Correlation.html @@ -0,0 +1,548 @@ + + + + + + +Correlation (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Correlation

+
+java.lang.Object
+  extended by papaya.Correlation
+
+
+
All Implemented Interfaces:
PapayaConstants
+
+
+
+
public final class Correlation
extends Object
implements PapayaConstants
+ + +

+Contains utilities related to computing covariances, as well as linear and rank correlation. + Methods relating to computing +

    +
  • normal correlations and covariances (biased or unbiased) are in the main class. +
  • weighted correlation and covariances are in the Correlation.Weighted subclass. +
  • significance of the correlations (i.e. p-values) are in the Correlation.Significance subclass. +
+ Whatever it is, remember that correlation does not always imply causation. +

+ +

+

+ +

+ + + + + + + + + + + + + + + +
+Nested Class Summary
+static classCorrelation.Significance + +
+          Contains methods used to compute the significance, or pvalue of the input correlations.
+static classCorrelation.Weighted + +
+          Contains methods related to computing the correlation and covariance of weighted + datasets.
+  + + + + + + +
+Field Summary
+  + + + + + + + +
Fields inherited from interface papaya.PapayaConstants
BASELINE, big, biginv, BOTTOM, CENTER, CORNER, FONTNAME, GRAY, INDEX_NOT_FOUND, INDICES_NOT_FOUND, LEFT, LOGPI, MACHEP, MAXGAM, MAXLOG, MINLOG, RIGHT, SQRTH, SQTPI, STROKEWEIGHT, TEXTSIZE, TOP
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static floatauto(float[] data, + int lag, + float mean, + float variance) + +
+          Computes the sample autocorrelation by removing the sample mean from the input series, + then normalizing the sequence by the sample variance.
+static floatautoLag1(float[] data, + float mean) + +
+          Returns the lag-1 autocorrelation of a dataset; + Note that this method uses computations different from + auto(data, 1, mean, variance).
+static float[][]cov(float[][] data, + boolean unbiased) + +
+          Returns the covariance matrix of P data sequences, each of length N.
+static floatcov(float[] data1, + float[] data2, + boolean unbiased) + +
+          Returns the covariance of two data sequences data1 and data2, + each of length N.
+static float[][]linear(float[][] data, + boolean unbiased) + +
+          Returns the (Pearson Product Moment) correlation matrix between multiple columns of a matrix + with each column corresponding to a dataset, and each row an observation.
+static floatlinear(float[] data1, + float[] data2, + boolean unbiased) + +
+          Returns the (Pearson Product Moment) linear correlation of two data sequences.
+static float[][]spearman(float[][] data, + boolean unbiased) + +
+          Computes Spearman's rank-correlation, or rho, between multiple columns of a matrix + with each column corresponding to a dataset, and each row an observation.
+static floatspearman(float[] x, + float[] y, + boolean unbiased) + +
+          Computes Spearman's rank-correlation, or rho.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+auto

+
+public static float auto(float[] data,
+                         int lag,
+                         float mean,
+                         float variance)
+
+
Computes the sample autocorrelation by removing the sample mean from the input series, + then normalizing the sequence by the sample variance. That is, it returns + 
+ R(lag) = E[ (X[t] - mu) * ( X[t+lag] - mu ) ] / variance(X).   
+ where 
+ E[ (X[t] - mu) * ( X[t+lag] - mu ) ]  = 1/size(X) * Sum_(i=0 to size-lag)( (X[t]-mu)*X[t+lag]-mu) ). 
+
+ Reference: Box, G. E. P., G. M. Jenkins, and G. C. Reinsel. + Time Series Analysis: Forecasting and Control. 3rd ed. + Upper Saddle River, NJ: Prentice-Hall, 1994. +

+

+

+
+
+
+
Parameters:
data - the array of data
lag - the lag value. Has to be smaller than the data sequence length
mean - the data mean
variance - the data variance +
Returns:
the autocorrelation value
+
+
+
+ +

+autoLag1

+
+public static float autoLag1(float[] data,
+                             float mean)
+
+
Returns the lag-1 autocorrelation of a dataset; + Note that this method uses computations different from + auto(data, 1, mean, variance). +

+

+
+
+
+
+
+
+
+ +

+linear

+
+public static float[][] linear(float[][] data,
+                               boolean unbiased)
+
+
Returns the (Pearson Product Moment) correlation matrix between multiple columns of a matrix + with each column corresponding to a dataset, and each row an observation. + That is, given P columns, data1, data2, ... , dataP, + each of length n, it computes and returns the P-by-P correlation + matrix, C with each element CJK given by + 
+ CJK = CKJ = corr(dataJ,dataK,unbiasedValue).
+
+

+

+
+
+
+
Parameters:
data - The input data. Each column corresponds to a dataset; + each row corresponds to an observation
unbiased - set to true to return the unbiased correlation, + false to return the biased version. +
Returns:
the correlation matrix (symmetric, by definition)
+
+
+
+ +

+linear

+
+public static float linear(float[] data1,
+                           float[] data2,
+                           boolean unbiased)
+
+
Returns the (Pearson Product Moment) linear correlation of two data sequences. + It is related to the cov(float[], float[], boolean) function via + 
+ corr = cov(x,y,unbiasedValue)/sqrt( cov(x,x, unbiasedValue)*cov(y,y,unbiasedValue) )
+
+

+

+
+
+
+
Parameters:
unbiased - set to true to return the unbiased correlation, + false to return the biased version.
+
+
+
+ +

+spearman

+
+public static float[][] spearman(float[][] data,
+                                 boolean unbiased)
+
+
Computes Spearman's rank-correlation, or rho, between multiple columns of a matrix + with each column corresponding to a dataset, and each row an observation. + That is, each pair of columns are first converted to ranks rXJ, rXK + and the correlation between the ranks computed using the Pearson correlation coefficient + formula. +

+

+
+
+
+
Parameters:
unbiased - set to true to return the unbiased correlation, + false to return the biased version.
+
+
+
+ +

+spearman

+
+public static float spearman(float[] x,
+                             float[] y,
+                             boolean unbiased)
+
+
Computes Spearman's rank-correlation, or rho. + That is, the raw dataset Xi,Yi are first converted to ranks rXi, rYi + and the correlation between the ranks computed using the Pearson correlation coefficient + formula. +

+

+
+
+
+
Parameters:
unbiased - set to true to return the unbiased correlation, + false to return the biased version.
+
+
+
+ +

+cov

+
+public static float cov(float[] data1,
+                        float[] data2,
+                        boolean unbiased)
+
+
Returns the covariance of two data sequences data1 and data2, + each of length N. That is, + 
 
+ cov(data1, data2) = E(  (data1[i] - mean(data1))* (data2[i] - mean(data2)) ),
+
+ where E is the mathematical expectation. +

+ cov(x,y,true) normalizes by N - 1, if N > 1, where N is the number of observations. + This makes cov(x,y,true) the best unbiased estimate of the covariance matrix if the + observations are from a normal distribution. For N = 1, cov(x,y,true) normalizes by N. +

+ cov(x,y,false) normalizes by N and produces the second moment matrix of the observations + about their mean. +

+

+
+
+
+
Parameters:
data1 - x
data2 - y
unbiased - set to true to return the unbiased covariance (division by N-1), + false to return the biased version (division by N).
+
+
+
+ +

+cov

+
+public static float[][] cov(float[][] data,
+                            boolean unbiased)
+
+
Returns the covariance matrix of P data sequences, each of length N. + That is, given P columns, data1, data2, ... , dataP, + each of length n, it computes and returns the P-by-P covariance + matrix, S with each element SJK given by + 
+ SJK = SKJ = cov(dataJ,dataK,bias).       
+
+ + cov(data,true) normalizes by N - 1, if N > 1, where N is the number of observations + (or the number of rows in the input matrix). + This makes cov(data,true) the best unbiased estimate of the covariance matrix if the + observations are from a normal distribution. For N = 1, cov(data) normalizes by N. + +

+ cov(data,false) normalizes by N and produces the second moment matrix of the observations + about their mean. +

+

+
+
+
+
Parameters:
data - Each column corresponds to a dataset; each row corresponds to an observation
unbiased - set to true to return the unbiased covariance matrix, false to return the biased version.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/CorrelationPlot.html b/drawing/papaya/reference/papaya/CorrelationPlot.html new file mode 100644 index 0000000..de786bf --- /dev/null +++ b/drawing/papaya/reference/papaya/CorrelationPlot.html @@ -0,0 +1,363 @@ + + + + + + +CorrelationPlot (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class CorrelationPlot

+
+java.lang.Object
+  extended by papaya.Visuals
+      extended by papaya.CorrelationPlot
+
+
+
All Implemented Interfaces:
PapayaConstants
+
+
+
+
public class CorrelationPlot
extends Visuals
+ + +

+Takes in a matrix and plots the data in each of the columns versus + each other. Each of the columns are normalized to their minimum and maximum values which + can be a little misleading. For example, say you are looking at columns specifying the weight + of different panda bears over 100 days. + Panda bear A (Ling-Ling)'s weight varies from 650 to 970 pounds + (she's an emotional eater), while panda bear B (Thomas)'s weight varies from 512 to 516 pounds + (he's not a big fan of bamboo; also kind of metrosexual). The correlation plot will not show you + this difference in magnitudes or ranges! + There are many ways of addressing that, and all of them involve you writing your + own code. :) +

If you absolutely insist on using this despite the warning above, then the (somewhat messy) hack + around it is to pad each column of your data with 2 additional rows containing the + minimum and maximum that you want to abide by. Just make sure it doesn't muck everything + else up though! +

+ +

+

+ +

+ + + + + + + +
+Field Summary
+  + + + + + + + +
Fields inherited from class papaya.Visuals
bgColor
+  + + + + + + + +
Fields inherited from interface papaya.PapayaConstants
BASELINE, big, biginv, BOTTOM, CENTER, CORNER, FONTNAME, GRAY, INDEX_NOT_FOUND, INDICES_NOT_FOUND, LEFT, LOGPI, MACHEP, MAXGAM, MAXLOG, MINLOG, RIGHT, SQRTH, SQTPI, STROKEWEIGHT, TEXTSIZE, TOP
+  + + + + + + + + + + +
+Constructor Summary
CorrelationPlot(PApplet _theParent, + float _plotLeft, + float _plotTop, + float _plotWidth, + float _plotHeight) + +
+          Setup the plot dimensions
+  + + + + + + + + + + + + + + + +
+Method Summary
+ voiddrawBorderAndLabels(String[] categories, + int bgColor) + +
+          Draw the bordering lines and write the labels.
+ voiddrawPlot(float[][] data, + int pos, + int fColor) + +
+          Plots the scatter plot of each of the columns of the input data matrix vs.
+  + + + + + + + +
Methods inherited from class papaya.Visuals
drawAxes, drawRect, drawRect, getBottom, getHeight, getLeft, getRight, getTop, getWidth, horizLine, legendHoriz, legendVert, line, mapXData, mapXData, mapYData, mapYData, setBackgroundColor, setHeight, setLeft, setTop, setupFont, setupFont, setWidth, vertLine, writeLabels, writeLabels, writeLabels, writeLabels, writeLabels, writeTitle, xLabels, xLabels, xTicks, yLabels, yLabels, YLines, yTicks
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+CorrelationPlot

+
+public CorrelationPlot(PApplet _theParent,
+                       float _plotLeft,
+                       float _plotTop,
+                       float _plotWidth,
+                       float _plotHeight)
+
+
Setup the plot dimensions +

+

+ + + + + + + + +
+Method Detail
+ +

+drawPlot

+
+public void drawPlot(float[][] data,
+                     int pos,
+                     int fColor)
+
+
Plots the scatter plot of each of the columns of the input data matrix vs. the + other columns. Each of the columns are normalized to their minimum and maximum values which + can be a little misleading. For example, say you are looking at columns specifying the weight + of different panda bears over 100 days. + Panda bear A (Ling-Ling)'s weight varies from 450 to 670 pounds + (she's an emotional eater), while panda bear B (Thomas)'s weight varies from 512 to 516 pounds + (he's not a big fan of bamboo). The correlation plot will not show you this difference + since both could follow the same sort of distribution. + + There are many ways of addressing that, and all of them involve you writing your + own code. :) +

If you absolutely insist on using this despite the warning above, then the (very messy) hack + around it is to pad each column of your data with 2 additional rows containing the + minimum and maximum that you want to abide by. Just make sure it doesn't muck everything + else up though! +

+

+
Parameters:
data - the data array with each column corresponding to a dataset
pos - 0 for top right plots, 1 for bottom left plots
fColor - the fill color for the dots on the plot.
+
+
+
+ +

+drawBorderAndLabels

+
+public void drawBorderAndLabels(String[] categories,
+                                int bgColor)
+
+
Draw the bordering lines and write the labels. +

+

+
Parameters:
categories - the labels along the diagonal
bgColor - background rectangle color
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Descriptive.Mean.html b/drawing/papaya/reference/papaya/Descriptive.Mean.html new file mode 100644 index 0000000..4d702c4 --- /dev/null +++ b/drawing/papaya/reference/papaya/Descriptive.Mean.html @@ -0,0 +1,429 @@ + + + + + + +Descriptive.Mean (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Descriptive.Mean

+
+java.lang.Object
+  extended by papaya.Descriptive.Mean
+
+
+
Enclosing class:
Descriptive
+
+
+
+
public static class Descriptive.Mean
extends Object
+ + +

+Contains methods for computing the arithmetic, geometric, harmonic, trimmed, and winsorized + means (among others). +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static floatarithmetic(float[] data) + +
+          Returns the arithmetic mean of a data sequence; + That is Sum( data[i] ) / data.length .
+static float[]columnMean(float[][] data) + +
+          Returns an array containing the arithmetic mean of each column + of the input matrix.
+static floatgeometric(float[] data) + +
+          Returns the geometric mean of a data sequence.
+static floatgeometric(int size, + float sumOfLogarithms) + +
+          Returns the geometric mean of a data sequence.
+static floatharmonic(float[] data) + +
+          Returns the harmonic mean of a data sequence as Sum( 1.0 / data[i]).
+static floatharmonic(int size, + float sumOfInversions) + +
+          Returns the harmonic mean of a data sequence.
+static float[]rowMean(float[][] data) + +
+          Returns an array containing the arithmetic mean of each row of the input matrix.
+static floattrimmed(float[] sortedData, + float mean, + int left, + int right) + +
+          Returns the trimmed arithmetic mean of a sorted data sequence.
+static floatwinsorized(float[] sortedData, + float mean, + int left, + int right) + +
+          Returns the winsorized mean of a sorted data sequence.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+columnMean

+
+public static float[] columnMean(float[][] data)
+
+
Returns an array containing the arithmetic mean of each column + of the input matrix. +

+

+
+
+
+
+ +

+rowMean

+
+public static float[] rowMean(float[][] data)
+
+
Returns an array containing the arithmetic mean of each row of the input matrix. +

+

+
+
+
+
+ +

+arithmetic

+
+public static float arithmetic(float[] data)
+
+
Returns the arithmetic mean of a data sequence; + That is Sum( data[i] ) / data.length . +

+

+
+
+
+
+ +

+geometric

+
+public static float geometric(int size,
+                              float sumOfLogarithms)
+
+
Returns the geometric mean of a data sequence. + Note that for a geometric mean to be meaningful, the minimum of the data sequence must not be less or equal to zero. +
+ The geometric mean is given by pow( Product( data[i] ), 1/size) + which is equivalent to Math.exp( Sum( Log(data[i]) ) / size). +

+ The latter version is used here is the former easily results in overflows. +

+

+
+
+
+
+ +

+geometric

+
+public static float geometric(float[] data)
+
+
Returns the geometric mean of a data sequence. + Note that for a geometric mean to be meaningful, the minimum of the data sequence must not be less or equal to zero. +
+ The geometric mean is given by pow( Product( data[i] ), 1/data.size()). + This method tries to avoid overflows at the expense of an equivalent but somewhat slow definition: + geometricMean = Math.exp( Sum( Log(data[i]) ) / size). +

+

+
+
+
+
+ +

+harmonic

+
+public static float harmonic(int size,
+                             float sumOfInversions)
+
+
Returns the harmonic mean of a data sequence. +

+

+
Parameters:
size - the number of elements in the data sequence.
sumOfInversions - Sum( 1.0 / data[i]).
+
+
+
+ +

+harmonic

+
+public static float harmonic(float[] data)
+
+
Returns the harmonic mean of a data sequence as Sum( 1.0 / data[i]). +

+

+
Parameters:
data - array
+
+
+
+ +

+trimmed

+
+public static float trimmed(float[] sortedData,
+                            float mean,
+                            int left,
+                            int right)
+
+
Returns the trimmed arithmetic mean of a sorted data sequence. +

+

+
Parameters:
sortedData - the data sequence; must be sorted ascending.
mean - the mean of the (full) sorted data sequence.
left - the number of leading elements to trim.
right - the number of trailing elements to trim.
+
+
+
+ +

+winsorized

+
+public static float winsorized(float[] sortedData,
+                               float mean,
+                               int left,
+                               int right)
+
+
Returns the winsorized mean of a sorted data sequence. +

+

+
Parameters:
sortedData - the data sequence; must be sorted ascending.
mean - the mean of the (full) sorted data sequence.
left - the number of leading elements to trim.
right - the number of trailing elements to trim.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Descriptive.Pooled.html b/drawing/papaya/reference/papaya/Descriptive.Pooled.html new file mode 100644 index 0000000..1712a93 --- /dev/null +++ b/drawing/papaya/reference/papaya/Descriptive.Pooled.html @@ -0,0 +1,333 @@ + + + + + + +Descriptive.Pooled (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Descriptive.Pooled

+
+java.lang.Object
+  extended by papaya.Descriptive.Pooled
+
+
+
Enclosing class:
Descriptive
+
+
+
+
public static class Descriptive.Pooled
extends Object
+ + +

+Class for computing the pooled mean and variance of data sequences +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static floatmean(float[] means, + int[] sizes) + +
+          Returns the pooled mean of a k data sequences.
+static floatmean(float mean1, + int size1, + float mean2, + int size2) + +
+          Returns the pooled mean of two data sequences.
+static floatvar(float[] variances, + int[] sizes, + boolean unbiased) + +
+          Returns the pooled variance of k data sequences.
+static floatvar(float variance1, + int size1, + float variance2, + int size2, + boolean unbiased) + +
+          Returns the pooled variance of two data sequences.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+mean

+
+public static float mean(float mean1,
+                         int size1,
+                         float mean2,
+                         int size2)
+
+
Returns the pooled mean of two data sequences. + That is (size1 * mean1 + size2 * mean2) / (size1 + size2). +

+

+

+
Parameters:
size1 - the number of elements in data sequence 1.
mean1 - the mean of data sequence 1.
size2 - the number of elements in data sequence 2.
mean2 - the mean of data sequence 2.
+
+
+
+ +

+mean

+
+public static float mean(float[] means,
+                         int[] sizes)
+
+
Returns the pooled mean of a k data sequences. + That is (size1 * mean1 + size2 * mean1 + ... + sizek * meank) / (size1 + size2 + ... + sizek). +

+

+

+
+
+
+
+ +

+var

+
+public static float var(float variance1,
+                        int size1,
+                        float variance2,
+                        int size2,
+                        boolean unbiased)
+
+
Returns the pooled variance of two data sequences. The unbiased estimate of the + pooled variance is computed as + 
+ unbiasedPooledVar = Sum( (size_i -1)*variance_i ) / Sum( (size_i-1) ),
+
+ while the biased pooled variance is computed using + 
+ biasedPooledVar = Sum( (size_i)*variance_i ) / Sum(size_i),
+ 
+ For more than 2 datasets, use var(float[],int[],boolean).
+

+

+
Parameters:
size1 - the number of elements in data sequence 1.
variance1 - the variance of data sequence 1.
size2 - the number of elements in data sequence 2.
variance2 - the variance of data sequence 2.
unbiased - set to true to return the unbiased pooled variance,
+ false to return the biased version.

+

+
+
+ +

+var

+
+public static float var(float[] variances,
+                        int[] sizes,
+                        boolean unbiased)
+
+
Returns the pooled variance of k data sequences. The unbiased estimate of the + pooled variance is computed as + 
+ unbiasedPooledVar = Sum( (sizes[i] -1)*variances[i] ) / Sum( (sizes[i]-1) ),
+
+ while the biased pooled variance is computed using + 
+ biasedPooledVar = Sum( (sizes[i])*variances[i] ) / Sum(sizes[i]),
+

+

+

+

+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Descriptive.Sum.html b/drawing/papaya/reference/papaya/Descriptive.Sum.html new file mode 100644 index 0000000..e068514 --- /dev/null +++ b/drawing/papaya/reference/papaya/Descriptive.Sum.html @@ -0,0 +1,438 @@ + + + + + + +Descriptive.Sum (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Descriptive.Sum

+
+java.lang.Object
+  extended by papaya.Descriptive.Sum
+
+
+
Enclosing class:
Descriptive
+
+
+
+
public static class Descriptive.Sum
extends Object
+ + +

+Methods for computing various different sums of datasets such as sum of inversions, + logs, products, power deviations, squares, etc. +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static doubleinversions(float[] data, + int from, + int to) + +
+          Returns the sum of inversions of a data sequence, + which is Sum( 1.0 / data[i]).
+static doublelogs(float[] data, + int from, + int to) + +
+          Returns the sum of logarithms of a data sequence, which is Sum( Log(data[i]).
+static doublepowerDeviations(float[] data, + int k, + float c) + +
+          Returns Sum( (data[i]-c)k ); + optimized for common parameters like c == 0.0 and/or k == -2 ..
+static doublepowerDeviations(float[] data, + int k, + float c, + int from, + int to) + +
+          Returns Sum( (data[i]-c)k ) for all i = from ..
+static doublepowers(float[] data, + int k) + +
+          Returns the sum of powers of a data sequence, which is Sum ( data[i]k ).
+static doubleproducts(float[] data1, + float[] data2) + +
+          Returns the sum of the product of two data arrays, Sum( x[i] * y[i]).
+static floatsquaredDeviations(int size, + float variance) + +
+          Returns the sum of squared mean deviation of of a data sequence.
+static doublesquares(float[] data) + +
+          Returns the sum of squares of a data sequence.
+static floatsum(float[] data) + +
+          Returns the simple sum of a data sequence.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+inversions

+
+public static double inversions(float[] data,
+                                int from,
+                                int to)
+
+
Returns the sum of inversions of a data sequence, + which is Sum( 1.0 / data[i]). +

+

+
Parameters:
data - the data sequence.
from - the index of the first data element (inclusive).
to - the index of the last data element (inclusive).
+
+
+
+ +

+logs

+
+public static double logs(float[] data,
+                          int from,
+                          int to)
+
+
Returns the sum of logarithms of a data sequence, which is Sum( Log(data[i]). +

+

+
Parameters:
data - the data sequence.
from - the index of the first data element (inclusive).
to - the index of the last data element (inclusive).
+
+
+
+ +

+products

+
+public static double products(float[] data1,
+                              float[] data2)
+
+
Returns the sum of the product of two data arrays, Sum( x[i] * y[i]). +

+

+
Parameters:
data1 - the first data sequence.
data2 - the second data sequence +
Returns:
the sum of the product of the two data sequences.
+
+
+
+ +

+powerDeviations

+
+public static double powerDeviations(float[] data,
+                                     int k,
+                                     float c)
+
+
Returns Sum( (data[i]-c)k ); + optimized for common parameters like c == 0.0 and/or k == -2 .. 4. +

+

+
+
+
+
+ +

+powerDeviations

+
+public static double powerDeviations(float[] data,
+                                     int k,
+                                     float c,
+                                     int from,
+                                     int to)
+
+
Returns Sum( (data[i]-c)k ) for all i = from .. to; + optimized for common parameters like c == 0.0 and/or k == -2 .. 5. + Note that no checks are made for divisions by zero (important for + k = -2 and k = -1), so think twice before using this + if the data has elements = 0. +

+

+
+
+
+
+ +

+powers

+
+public static double powers(float[] data,
+                            int k)
+
+
Returns the sum of powers of a data sequence, which is Sum ( data[i]k ). +

+

+
+
+
+
+ +

+squaredDeviations

+
+public static float squaredDeviations(int size,
+                                      float variance)
+
+
Returns the sum of squared mean deviation of of a data sequence. + That is variance * (size-1) == Sum( (data[i] - mean)^2 ). +

+

+
Parameters:
size - the number of elements of the data sequence.
variance - the variance of the data sequence.
+
+
+
+ +

+squares

+
+public static double squares(float[] data)
+
+
Returns the sum of squares of a data sequence. + That is Sum ( data[i]*data[i] ). +

+

+
+
+
+
+ +

+sum

+
+public static float sum(float[] data)
+
+
Returns the simple sum of a data sequence. + That is Sum( data[i] ). +

+

+
See Also:
Mat.sum(float[]), +Mat.sum(float[], float[]), +Mat.sum(float[],float)
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Descriptive.Weighted.html b/drawing/papaya/reference/papaya/Descriptive.Weighted.html new file mode 100644 index 0000000..72e00ce --- /dev/null +++ b/drawing/papaya/reference/papaya/Descriptive.Weighted.html @@ -0,0 +1,307 @@ + + + + + + +Descriptive.Weighted (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Descriptive.Weighted

+
+java.lang.Object
+  extended by papaya.Descriptive.Weighted
+
+
+
Enclosing class:
Descriptive
+
+
+
+
public static class Descriptive.Weighted
extends Object
+ + +

+Contains methods related to weighted datasets. +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static floatmean(float[] data, + float[] weights) + +
+          Returns the weighted mean of a data sequence.
+static floatrms(float sumOfProducts, + float sumOfSquaredProducts) + +
+          Returns the weighted RMS (Root-Mean-Square) of a data sequence.
+static floatvar(float[] data, + float[] weights, + boolean unbiased) + +
+          Returns the weighted variance of a data sequence of length N + There are (unfortunately) many different definitions of the unbiased weighted variance.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+mean

+
+public static float mean(float[] data,
+                         float[] weights)
+
+
Returns the weighted mean of a data sequence. Used when the values in a set of + data do not share equal importance. + That is Sum (data[i] * weights[i]) / Sum ( weights[i] ). +

+

+
+
+
+
+ +

+rms

+
+public static float rms(float sumOfProducts,
+                        float sumOfSquaredProducts)
+
+
Returns the weighted RMS (Root-Mean-Square) of a data sequence. + That is Sum( data[i] * data[i] * weights[i]) / Sum( data[i] * weights[i] ), + or in other words sumOfProducts / sumOfSquaredProducts. +

+

+
Parameters:
sumOfProducts - == Sum( data[i] * weights[i] ).
sumOfSquaredProducts - == Sum( data[i] * data[i] * weights[i] ).
+
+
+
+ +

+var

+
+public static float var(float[] data,
+                        float[] weights,
+                        boolean unbiased)
+
+
Returns the weighted variance of a data sequence of length N + There are (unfortunately) many different definitions of the unbiased weighted variance. + Here, we use the following formula + 
+ weighted.var(x,w,unbiased=true) = biasCorrection * Sum ( w[i] * (x[i] - mu_w)^2  ) / Sum(w[i]).
+
+ where mu_w corresponds to the weighted mean and the biasCorrection + term + 
+ biasCorrection = ( Sum(w[i]) )^2  / ( ( Sum(w[i]) )^2 - Sum( w[i]^2 )  ).
+
+ corrects for the bias in the variance. + weighted.var(x,w,unbiased=false) computes the biased weighted variance and is given by the formula above, + but without the correction factor. + +

The formula above agrees with that presented in + + the NIST Information Technology Laboratory page. + The algorithm used, is a one-pass formula credited to + "D. H. D. West (1979). Communications of the ACM, 22, 9, 532-535: + Updating Mean and Variance Estimates: An Improved Method", and spelled out under the +
+ weighted incremental algorithm section of the link. +

+

+
Parameters:
unbiased - set to true to return the unbiased variance (division by (N-1)), false to return the biased value (division by N). +
Returns:
the weighted variance.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Descriptive.html b/drawing/papaya/reference/papaya/Descriptive.html new file mode 100644 index 0000000..3d79788 --- /dev/null +++ b/drawing/papaya/reference/papaya/Descriptive.html @@ -0,0 +1,1412 @@ + + + + + + +Descriptive (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Descriptive

+
+java.lang.Object
+  extended by papaya.Descriptive
+
+
+
+
public class Descriptive
extends Object
+ + +

+Basic descriptive statistics class for exploratory data analysis. + Methods for computing Correlations and Covariances are in the Correlation + class. Where appropriate, methods with similar functions are grouped into + static subclasses. For example, the Descriptive.Sum class contains the following + methods: +

+ while the Descriptive.Mean class has the + + utilities. +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + + + + +
+Nested Class Summary
+static classDescriptive.Mean + +
+          Contains methods for computing the arithmetic, geometric, harmonic, trimmed, and winsorized + means (among others).
+static classDescriptive.Pooled + +
+          Class for computing the pooled mean and variance of data sequences
+static classDescriptive.Sum + +
+          Methods for computing various different sums of datasets such as sum of inversions, + logs, products, power deviations, squares, etc.
+static classDescriptive.Weighted + +
+          Contains methods related to weighted datasets.
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static voidfrequencies(float[] sortedData, + ArrayList<Float> distinctValues, + ArrayList<Integer> frequencies) + +
+          Computes the frequency (number of occurances, count) of each distinct value in the given sorted data.
+static floatkurtosis(float[] data, + float mean, + float standardDeviation) + +
+          Returns the kurtosis (aka excess) of a data sequence, which is + -3 + moment(data,4,mean) / standardDeviation4.
+static floatkurtosis(float moment4, + float standardDeviation) + +
+          Returns the kurtosis (aka excess) of a data sequence.
+static doublemax(double[] data) + +
+          Returns the largest member of a data sequence.
+static doublemax(double a, + double b) + +
+           
+static floatmax(float[] data) + +
+          Returns the largest member of a data sequence.
+static floatmax(float[][] data) + +
+          Returns the largest member of a matrix.
+static floatmax(float a, + float b) + +
+           
+static intmax(int[] data) + +
+          Returns the largest member of a data sequence.
+static intmax(int[][] data) + +
+          Returns the largest member of a matrix.
+static intmax(int a, + int b) + +
+           
+static floatmean(float[] data) + +
+          Returns the arithmetic mean of a data sequence; + That is Sum( data[i] ) / data.length .
+static floatmeanDeviation(float[] data, + float mean) + +
+          Returns the mean deviation of a dataset.
+static floatmedian(float[] data, + boolean isSorted) + +
+          Returns the median of a data sequence.
+static doublemin(double[] data) + +
+          Returns the smallest member of a data sequence.
+static doublemin(double a, + double b) + +
+           
+static floatmin(float[] data) + +
+          Returns the smallest member of a data sequence.
+static floatmin(float[][] data) + +
+          Returns the smallest member of a matrix.
+static floatmin(float a, + float b) + +
+           
+static intmin(int[] data) + +
+          Returns the smallest member of a data sequence.
+static intmin(int[][] data) + +
+          Returns the smallest member of a matrix.
+static intmin(int a, + int b) + +
+           
+static float[]mod(float[] data) + +
+          Returns the array containing the elements that appear the most in a given dataset.
+static floatmoment(float[] data, + int k, + float c) + +
+          Returns the moment of k-th order with constant c of a data sequence, + which is Sum( (data[i]-c)k ) / data.size().
+static float[]outliers(float[] data, + float lowerLimit, + float upperLimit, + boolean isSorted) + +
+          Returns the array containing all elements in the dataset that are less than + or equal to the lowerLimit + and more than or equal to the upperLimit
+static floatproduct(float[] data) + +
+          Returns the product of a data sequence, which is Prod( data[i] ).
+static floatproduct(int size, + float sumOfLogarithms) + +
+          Returns the product, which is Prod( data[i] ).
+static floatquantile(float[] sortedData, + float phi) + +
+          Returns the phi-quantile; that is, an element elem + for which holds that phi percent of data elements are less than + elem.
+static floatquantileInverse(float[] sortedList, + float element) + +
+          Returns how many percent of the elements contained in the receiver are <= element.
+static float[]quantiles(float[] sortedData, + float[] percentages) + +
+          Returns the quantiles of the specified percentages.
+static float[]quartiles(float[] data, + boolean isSorted) + +
+          Returns the quartiles of the input data array (not necessarily sorted).
+static floatrankInterpolated(float[] sortedList, + float element) + +
+          Returns the linearly interpolated number of elements in an array that + are ≤ a given element.
+static floatrms(int size, + double sumOfSquares) + +
+          Returns the RMS (Root-Mean-Square) of a data sequence.
+static floatskew(float[] data, + float mean, + float standardDeviation) + +
+          Returns the skew of a data sequence, which is moment(data,3,mean) / standardDeviation3.
+static floatskew(float moment3, + float standardDeviation) + +
+          Returns the skew of a data sequence when the 3rd moment has already been computed.
+static float[]std(float[][] data, + boolean unbiased) + +
+          Returns an array with each element of the array corresponding to + the standard deviations of each column of the input + matrix.
+static floatstd(float[] data, + boolean unbiased) + +
+          Returns the standard deviation of a dataset.
+static floatstdUnbiased(int size, + float sampleVariance) + +
+          Returns the unbiased sample standard deviation assuming the sample is normally distributed.
+static float[]tukeyFiveNum(float[] data) + +
+          Return the tukey five number summary of a dataset consisting of the minimum, maximum, + and three quartile values.
+static float[]var(float[][] data, + boolean unbiased) + +
+          Returns an array containing the variance of each column of the input matrix X.
+static floatvar(float[] data, + boolean unbiased) + +
+          Returns the variance of a dataset, V.
+static float[][]zScore(float[][] X, + float[] means, + float[] standardDeviations) + +
+          Computes the standardized version of the input matrix.
+static float[]zScore(float[] x, + float mean, + float standardDeviation) + +
+          Returns the array of z-scores for a given data array.
+static floatzScore(float x, + float mean, + float standardDeviation) + +
+           
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+frequencies

+
+public static void frequencies(float[] sortedData,
+                               ArrayList<Float> distinctValues,
+                               ArrayList<Integer> frequencies)
+
+
Computes the frequency (number of occurances, count) of each distinct value in the given sorted data. + After this call, both distinctValues and frequencies have a new size (which is equal for both), + which is the number of distinct values in the sorted data. +

+ Distinct values are filled into distinctValues, starting at index 0. + The frequency of each distinct value is filled into frequencies, starting at index 0. + As a result, the smallest distinct value (and its frequency) can be found at index 0, + the second smallest distinct value (and its frequency) at index 1, ..., + the largest distinct value (and its frequency) at index distinctValues.size()-1. +

+ Example: +
+ sortedData = (5,6,6,7,8,8) --> distinctValues = (5,6,7,8), frequencies = (1,2,1,2) +

+ Code-wise, you would write: + 
 
+ ArrayList distinctValues = new ArrayList(); 
+ 
+ ArrayList frequencies = new ArrayList();  
+ 
+ frequencies(sortedData,distinctValues,frequencies);
+
+

+

+
Parameters:
sortedData - the data; must be sorted ascending.
distinctValues - a ArrayList to be filled with the distinct values; can have any size.
frequencies - a ArrayList to be filled with the frequencies; can have any size; + set this parameter to null to ignore it.
See Also:
Frequency, +Unique
+
+
+
+ +

+kurtosis

+
+public static float kurtosis(float moment4,
+                             float standardDeviation)
+
+
Returns the kurtosis (aka excess) of a data sequence. +

+

+
Parameters:
moment4 - the fourth central moment, which is moment(data,4,mean).
standardDeviation - the standardDeviation.
+
+
+
+ +

+kurtosis

+
+public static float kurtosis(float[] data,
+                             float mean,
+                             float standardDeviation)
+
+
Returns the kurtosis (aka excess) of a data sequence, which is + -3 + moment(data,4,mean) / standardDeviation4. +

+

+
+
+
+
+ +

+max

+
+public static int max(int a,
+                      int b)
+
+
+
+
+
+
+ +

+max

+
+public static float max(float a,
+                        float b)
+
+
+
+
+
+
+ +

+max

+
+public static double max(double a,
+                         double b)
+
+
+
+
+
+
+ +

+max

+
+public static double max(double[] data)
+
+
Returns the largest member of a data sequence. +

+

+
+
+
+
+ +

+max

+
+public static float max(float[] data)
+
+
Returns the largest member of a data sequence. +

+

+
+
+
+
+ +

+max

+
+public static int max(int[] data)
+
+
Returns the largest member of a data sequence. +

+

+
+
+
+
+ +

+max

+
+public static float max(float[][] data)
+
+
Returns the largest member of a matrix. +

+

+
+
+
+
+ +

+max

+
+public static int max(int[][] data)
+
+
Returns the largest member of a matrix. +

+

+
+
+
+
+ +

+mean

+
+public static float mean(float[] data)
+
+
Returns the arithmetic mean of a data sequence; + That is Sum( data[i] ) / data.length . + Similar to Descriptive.Mean.arithmetic(float[]). +

+

+
+
+
+
+ +

+meanDeviation

+
+public static float meanDeviation(float[] data,
+                                  float mean)
+
+
Returns the mean deviation of a dataset. + That is Sum( Math.abs(data[i]-mean)) ) / data.length. +

+

+
+
+
+
+ +

+median

+
+public static float median(float[] data,
+                           boolean isSorted)
+
+
Returns the median of a data sequence. +

+

+
Parameters:
data - the data sequence;
isSorted - true if the data sequence is sorted (in ascending order), else false.
+
+
+
+ +

+min

+
+public static int min(int a,
+                      int b)
+
+
+
+
+
+
+ +

+min

+
+public static float min(float a,
+                        float b)
+
+
+
+
+
+
+ +

+min

+
+public static double min(double a,
+                         double b)
+
+
+
+
+
+
+ +

+min

+
+public static double min(double[] data)
+
+
Returns the smallest member of a data sequence. +

+

+
+
+
+
+ +

+min

+
+public static float min(float[] data)
+
+
Returns the smallest member of a data sequence. +

+

+
+
+
+
+ +

+min

+
+public static float min(float[][] data)
+
+
Returns the smallest member of a matrix. +

+

+
+
+
+
+ +

+min

+
+public static int min(int[] data)
+
+
Returns the smallest member of a data sequence. +

+

+
+
+
+
+ +

+min

+
+public static int min(int[][] data)
+
+
Returns the smallest member of a matrix. +

+

+
+
+
+
+ +

+mod

+
+public static float[] mod(float[] data)
+
+
Returns the array containing the elements that appear the most in a given dataset. + (The return type has to be an array since a dataset can have more than one mod value). +

+

+
Parameters:
data - the data array +
Returns:
the array containing the (distinct) elements that appear the most.
+
+
+
+ +

+moment

+
+public static float moment(float[] data,
+                           int k,
+                           float c)
+
+
Returns the moment of k-th order with constant c of a data sequence, + which is Sum( (data[i]-c)k ) / data.size(). +

+

+
+
+
+
+ +

+outliers

+
+public static float[] outliers(float[] data,
+                               float lowerLimit,
+                               float upperLimit,
+                               boolean isSorted)
+
+
Returns the array containing all elements in the dataset that are less than + or equal to the lowerLimit + and more than or equal to the upperLimit +

+

+
Parameters:
data - the data array
lowerLimit -
upperLimit -
isSorted - true if the data array has been sorted in ascending order, else set to false.
+
+
+
+ +

+product

+
+public static float product(int size,
+                            float sumOfLogarithms)
+
+
Returns the product, which is Prod( data[i] ). + In other words: data[0]*data[1]*...*data[data.length-1]. + This method uses the equivalent definition: + prod = pow( exp( Sum( Log(x[i]) ) / length*length). +

+

+
+
+
+
+ +

+product

+
+public static float product(float[] data)
+
+
Returns the product of a data sequence, which is Prod( data[i] ). + In other words: data[0]*data[1]*...*data[data.length-1]. + Note that you may easily get numeric overflows. Use product(int,float) + instead to avoid that. +

+

+
+
+
+
+ +

+quartiles

+
+public static float[] quartiles(float[] data,
+                                boolean isSorted)
+
+
Returns the quartiles of the input data array (not necessarily sorted). + +

Details:
+ The first quartile, or lower quartile (Q[0]), is the value that cuts off + the first 25% of the data when it is sorted in ascending order. + The second quartile, or median (Q[1]), is the value that cuts off the first 50%. + The third quartile, or upper quartile (Q[2], is the value that cuts off the first 75%. +

+

+

+
Parameters:
data - The data array.
isSorted - true if the data array has been sorted in ascending order, else set to false. +
Returns:
The 3 quartile values Q[0], Q[1], and Q[2].
+
+
+
+ +

+quantile

+
+public static float quantile(float[] sortedData,
+                             float phi)
+
+
Returns the phi-quantile; that is, an element elem + for which holds that phi percent of data elements are less than + elem. + The quantile need not necessarily be contained in the data sequence, + it can be a linear interpolation. +

+

+
Parameters:
sortedData - the data sequence; must be sorted ascending.
phi - the percentage; must satisfy 0 <= phi <= 1.
+
+
+
+ +

+quantileInverse

+
+public static float quantileInverse(float[] sortedList,
+                                    float element)
+
+
Returns how many percent of the elements contained in the receiver are <= element. + Does linear interpolation if the element is not contained but lies in between + two contained elements. +

+

+
Parameters:
sortedList - the list to be searched (must be sorted ascending).
element - the element to search for. +
Returns:
the percentage phi of elements <= element + (0.0 <= phi <= 1.0).
+
+
+
+ +

+quantiles

+
+public static float[] quantiles(float[] sortedData,
+                                float[] percentages)
+
+
Returns the quantiles of the specified percentages. + The quantiles need not necessarily be contained in the data sequence, it can be a linear interpolation. +

+

+
Parameters:
sortedData - the data sequence; must be sorted ascending.
percentages - the percentages for which quantiles are to be computed. + Each percentage must be in the interval [0.0f,1.0f]. +
Returns:
the quantiles.
+
+
+
+ +

+rankInterpolated

+
+public static float rankInterpolated(float[] sortedList,
+                                     float element)
+
+
Returns the linearly interpolated number of elements in an array that + are ≤ a given element. + The rank is the number of elements ≤ element. + Ranks are of the form {0, 1, 2,..., sortedList.size()}. +

If no element is ≤ element, then the rank is zero.

+ +

If the element lies in between two contained elements, then + linear interpolation is used and a non integer value is returned.

+

+

+
Parameters:
sortedList - the list to be searched (must be sorted ascending).
element - the element to search for. +
Returns:
the rank of the element.
+
+
+
+ +

+rms

+
+public static float rms(int size,
+                        double sumOfSquares)
+
+
Returns the RMS (Root-Mean-Square) of a data sequence. + That is Math.sqrt(Sum( data[i]*data[i] ) / data.length). + The RMS of data sequence is the square-root of the mean of the squares of the elements in the data sequence. + It is a measure of the average "size" of the elements of a data sequence. +

+

+
Parameters:
sumOfSquares - sumOfSquares(data) == Sum( data[i]*data[i] ) of the data sequence.
size - the number of elements in the data sequence.
+
+
+
+ +

+skew

+
+public static float skew(float moment3,
+                         float standardDeviation)
+
+
Returns the skew of a data sequence when the 3rd moment has already been computed. +

+

+
Parameters:
moment3 - the third central moment, which is moment(data,3,mean).
standardDeviation - the standardDeviation.
+
+
+
+ +

+skew

+
+public static float skew(float[] data,
+                         float mean,
+                         float standardDeviation)
+
+
Returns the skew of a data sequence, which is moment(data,3,mean) / standardDeviation3. +

+

+
+
+
+
+ +

+std

+
+public static float std(float[] data,
+                        boolean unbiased)
+
+
Returns the standard deviation of a dataset. + + There are two definitions of the standard deviation: + 
+ sigma_1 = 1/(N-1) * Sum( (x[i] - mean(x))^2 )
+ sigma_2 = 1/(N) * Sum( (x[i] - mean(x))^2 )
+
+ sigma_1 is the square root of an unbiased estimator of the variance of the population + the x is drawn, as long as x consists of independent, identically distributed samples. + sigma_2 corresponds to the second moment of the set of values about their mean. +

+ std(data,unbiased==true) returns sigma_1 above, while std(data,unbiased==false) returns sigma_2. +

+

+
Parameters:
data - the dataset
unbiased - set to true to return the unbiased standard deviation, + false to return the biased version.
+
+
+
+ +

+std

+
+public static float[] std(float[][] data,
+                          boolean unbiased)
+
+
Returns an array with each element of the array corresponding to + the standard deviations of each column of the input + matrix. Each column of the matrix corresponds to a dataset, and each row an observation. + + There are two definitions of the standard deviation: + 
+ sigma_1 = 1/(N-1) * Sum( (x[i] - mean(x))^2 )
+ sigma_2 = 1/(N) * Sum( (x[i] - mean(x))^2 )
+
+ sigma_1 is the square root of an unbiased estimator of the variance of the population + the x is drawn, as long as x consists of independent, identically distributed samples. + sigma_2 corresponds to the second moment of the set of values about their mean. +

+ std(data,unbiased==true) returns sigma_1 above, while std(data,unbiased==false) returns sigma_2. +

+

+
Parameters:
data - the dataset
unbiased - set to true to return the unbiased standard deviation, + false to return the biased version.
+
+
+
+ +

+stdUnbiased

+
+public static float stdUnbiased(int size,
+                                float sampleVariance)
+
+
Returns the unbiased sample standard deviation assuming the sample is normally distributed. + + Ref: R.R. Sokal, F.J. Rohlf, Biometry: the principles and practice of statistics + in biological research (W.H. Freeman and Company, New York, 1998, 3rd edition) + p. 53. +

See also this entry on wikipedia.org +

+

+
Parameters:
size - the number of elements of the data sequence.
sampleVariance - the sample variance.
+
+
+
+ +

+tukeyFiveNum

+
+public static float[] tukeyFiveNum(float[] data)
+
+
Return the tukey five number summary of a dataset consisting of the minimum, maximum, + and three quartile values. +

+

+
Parameters:
data - the data array +
Returns:
the array of five numbers.
+
+
+
+ +

+var

+
+public static float var(float[] data,
+                        boolean unbiased)
+
+
Returns the variance of a dataset, V. + For matrices, var(X,unbiased=true) returns an array containing the variance of each column of X. + The result V is an unbiased estimator of the variance of the population from which + X is drawn, as long as X consists of independent, identically distributed samples. +

+ var(x,true) normalizes V by N - 1 if N > 1, where N is the sample size. + This is an unbiased estimator of the variance of the population from which X is drawn, + as long as X consists of independent, identically distributed samples. For N = 1, + V is normalized by 1. +

+ V = var(x,false) normalizes by N and produces the second moment of the sample about its mean. + +

Reference: +
+ Algorithms for calculating variance, Wikipedia.org +
+ Incremental calculation of weighted mean and variance, Tony Finch +

+

+
Parameters:
data - the data sequence.
unbiased - set to true to return the unbiased variance (division by (N-1)), false to return the biased value (division by N). +
Returns:
the variance in the data.
+
+
+
+ +

+var

+
+public static float[] var(float[][] data,
+                          boolean unbiased)
+
+
Returns an array containing the variance of each column of the input matrix X. + The result V is an unbiased estimator of the variance of the population from which + X is drawn, as long as X consists of independent, identically distributed samples. +

+ var(X,unbiased=true) normalizes V by N - 1 if N > 1, where N is the sample size. + This is an unbiased estimator of the variance of the population from which X is drawn, + as long as X consists of independent, identically distributed samples. For N = 1, + V is normalized by 1. +

+ V = var(X,unbiased=false) normalizes by N and produces the second moment of the sample about its mean. + +

Reference: +
+ Algorithms for calculating variance, Wikipedia.org +
+ Incremental calculation of weighted mean and variance, Tony Finch +

+

+
Parameters:
data - the data sequence.
unbiased - set to true to return the unbiased variance (division by (N-1)), false to return the biased value (division by N). +
Returns:
the variance in the data.
+
+
+
+ +

+zScore

+
+public static float zScore(float x,
+                           float mean,
+                           float standardDeviation)
+
+
+ +
Returns:
the z-score of that element computed as (x-mean)/standardDeviation
+
+
+
+ +

+zScore

+
+public static float[] zScore(float[] x,
+                             float mean,
+                             float standardDeviation)
+
+
Returns the array of z-scores for a given data array. + with each elment given by + z[i] = ( x[i] - mean ) / standardDeviation. +

+

+ +
Returns:
the standardized array, z
+
+
+
+ +

+zScore

+
+public static float[][] zScore(float[][] X,
+                               float[] means,
+                               float[] standardDeviations)
+
+
Computes the standardized version of the input matrix. That is each, each element + of column j, of the output is given by + Z[i][j] = ( X[i][j]- mean(X[,j]) / standardDeviation(X[,j]) + where mean(X[,j]) is the mean value of column j of X. +

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Distance.html b/drawing/papaya/reference/papaya/Distance.html new file mode 100644 index 0000000..780a608 --- /dev/null +++ b/drawing/papaya/reference/papaya/Distance.html @@ -0,0 +1,492 @@ + + + + + + +Distance (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Distance

+
+java.lang.Object
+  extended by papaya.Distance
+
+
+
+
public final class Distance
extends Object
+ + +

+Contains methods for computing various "distance" metrics for multidimensional scaling. +

+ For an m-by-n input matrix with m observations and n variables, the output D is + the symmetric m-by-m matrix with zeros along the diagonals and element ij + specifying the distance between rows i and j. +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static float[][]chebychev(float[][] X) + +
+          Computes the Chebychev distance matrix between pairs of objects + in the m-by-n data matrix X.
+static float[][]cityblock(float[][] X) + +
+          Computes the cityblock (or Manhattan) distance matrix between pairs of objects + in the m-by-n data matrix X.
+static float[][]correlation(float[][] X) + +
+          Computes the correlation distance matrix between pairs of objects + in the m-by-n data matrix X.
+static float[][]cosine(float[][] X) + +
+          Computes the cosine distance matrix between pairs of objects + in the m-by-n data matrix X.
+static float[][]euclidean(float[][] X) + +
+          Computes the Euclidean distance between pairs of objects + in the m-by-n data matrix X.
+static float[][]mahalanobis(float[][] X) + +
+          Computes the Mahalanobis distance matrix of the m-by-n input matrix X.
+static float[][]minkowski(float[][] X, + int exp) + +
+          Returns the Minkowski distance matrix of the m-by-n input matrix X.
+static float[][]seuclidean(float[][] X) + +
+          Computes the standardized Euclidean distance between pairs of objects + in the m-by-n data matrix X by standardizing X first prior to computing + the distances.
+static float[][]spearman(float[][] X) + +
+          Computes the Spearman distance matrix of the m-by-n input matrix X.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+cityblock

+
+public static float[][] cityblock(float[][] X)
+
+
Computes the cityblock (or Manhattan) distance matrix between pairs of objects + in the m-by-n data matrix X. That is, + 
+ Dist[i][j] = (X[i][1] - X[j][1]) + (X[i][2] - X[j][2]) + ... + (X[i][n] - X[j][n]). 
+
+

+ Rows of X correspond to observations, and columns correspond to variables. + Returns the m-by-m matrix D with D[r1][r2] corresponding to the cityblock + (or manhattan) distance between the rows of the input X. +

+

+
+
+
+
+ +

+chebychev

+
+public static float[][] chebychev(float[][] X)
+
+
Computes the Chebychev distance matrix between pairs of objects + in the m-by-n data matrix X. That is, + 
+ Dist[i][j] =Max( |X[i][1] - X[j][1]| , |X[i][2] - X[j][2]| , ... , |(X[i][n] - X[j][n]|). 
+
+

+ Rows of X correspond to observations, and columns correspond to variables. + Returns the m-by-m matrix D with D[r1][r2] corresponding to the Chebychev + distance between the rows of the input X. +

+

+
+
+
+
+ +

+correlation

+
+public static float[][] correlation(float[][] X)
+
+
Computes the correlation distance matrix between pairs of objects + in the m-by-n data matrix X. E.g., if y1 and y2 corresponds to observation (or row) + 1 and 2 of X, then + 
+ Dist[1][2] = 1 -  sum_{j=1^numColumns} ( ( y1_j - mean(y1) ) * ( y2_j - mean(y2) ) / ( n * std(y1)*std(y2) ) ), 
+
+ where n = number of columns. +

+ Rows of X correspond to observations, and columns correspond to variables. + Returns the m-by-m matrix D with D[r1][r2] corresponding to the correlation + distance between the rows of the input X. +

+

+
+
+
+
+ +

+cosine

+
+public static float[][] cosine(float[][] X)
+
+
Computes the cosine distance matrix between pairs of objects + in the m-by-n data matrix X. E.g., if y1 and y2 corresponds to observation (or row) + 1 and 2 of X, then + 
+ Dist[1][2] = 1- sum_{j=1^numColumns} ( y1_j * y2_j ) / ( mag(y1)*mag(y2) ), 
+
+ where mag(y1) = sum_{i=1 to numColumns} (y1[j]*y1[j]) and likewise + for mag(y2). + etc. +

+ Rows of X correspond to observations, and columns correspond to variables. + Returns the m-by-m matrix D with D[r1][r2] corresponding to the cosine + distance between the rows of the input X. +

+

+
+
+
+
+ +

+euclidean

+
+public static float[][] euclidean(float[][] X)
+
+
Computes the Euclidean distance between pairs of objects + in the m-by-n data matrix X. That is, + 
+ Dist[i][j]^2 = (X[i][1] - X[j][1]) ^2+ (X[i][2] - X[j][2])^2 + ... + (X[i][n] - X[j][n])^2. 
+
+

+ Rows of X correspond to observations, and columns correspond to variables. + Returns the m-by-m matrix D with D[r1][r2] corresponding to the Euclidean + distance between the rows of the input X. +

+

+
+
+
+
+ +

+seuclidean

+
+public static float[][] seuclidean(float[][] X)
+
+
Computes the standardized Euclidean distance between pairs of objects + in the m-by-n data matrix X by standardizing X first prior to computing + the distances. The standardized X is computed using + 
+ standardized value = (original value - mean)/standard deviation
+
+ where the mean and standard deviation correspond to the column mean and std. +

+ Rows of X correspond to observations, and columns correspond to variables. + Returns the m-by-m matrix D with D[r1][r2] corresponding to the standardized + Euclidean distance between the rows of the input X. +

+

+
+
+
+
+ +

+mahalanobis

+
+public static float[][] mahalanobis(float[][] X)
+
+
Computes the Mahalanobis distance matrix of the m-by-n input matrix X. That is, + 
+ Dist[i][j]^2 = (X[i][1] - X[j][1])^2/ invcov[1][1] + ... + (X[i][n] - X[j][n])^2/ invcov[n][n]. 
+
+ + Rows of X correspond to observations, and columns correspond to variables. + Returns the m-by-m matrix D with D[r1][r2] corresponding to the s + mahalanobis distance between the rows of the input X. +

+

+
+
+
+
+ +

+minkowski

+
+public static float[][] minkowski(float[][] X,
+                                  int exp)
+
+
Returns the Minkowski distance matrix of the m-by-n input matrix X. That is, + 
+ Dist[i][j]^p= (X[i][1] - X[j][1])^p/ + (X[i][2] - X[j][2])^p + ... + (X[i][n] - X[j][n])^p.
+
+ Notice that for the special case of p = 1, the Minkowski metric + gives the city block metric, for the special case of p = 2, + the Minkowski metric gives the Euclidean distance, + and for the special case of p = &inf;, the Minkowski metric gives the Chebychev distance. + Also notice that the larger the value of p, the higher the probability of causing overflow + errors (which are, in turn, highly correlated to headaches and overall feelings of malaise). +

+

+
Parameters:
exp - the Minkowski exponent (positive).
+
+
+
+ +

+spearman

+
+public static float[][] spearman(float[][] X)
+
+
Computes the Spearman distance matrix of the m-by-n input matrix X. E.g., if y1 and y2 corresponds to observation (or row) + 1 and 2 of X with corresponding ranks +
r11, r12, ... , r1n +
+ and +
r21, r22, ... , r2n,
then + 

+ Dist[1][2] = 1 -  sum_{j=1^numColumns} ( ( r1_j - mean(r1) ) * ( r2_j - mean(r2) ) / ( n * std(r1)*std(r2) ) ), 
+
+ and similarly for the remaining rows. +

+ Rows of X correspond to observations, and columns correspond to variables. + Returns the m-by-m matrix D with D[r1][r2] corresponding to the Spearman + distance between the rows of the input X. +

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Eigenvalue.html b/drawing/papaya/reference/papaya/Eigenvalue.html new file mode 100644 index 0000000..b48dff6 --- /dev/null +++ b/drawing/papaya/reference/papaya/Eigenvalue.html @@ -0,0 +1,358 @@ + + + + + + +Eigenvalue (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Eigenvalue

+
+java.lang.Object
+  extended by papaya.Eigenvalue
+
+
+
+
public class Eigenvalue
extends Object
+ + +

+Eigenvalues and eigenvectors of a real matrix. +

+ If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is orthogonal. + I.e. A = V.times(D.times(V.transpose())) and + V.times(V.transpose()) equals the identity matrix. +

+ If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.times(V) equals V.times(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*inverse(V) depends upon V.cond(). +

+Shamelessly copied (and modified) from the +JAMA Java +Matrix package. To make things compatible with how most users use Processing, the +class take in float matrices. However, to preserve the acccuracy of the computations, the algorithm +first casts the input into a double array, prior to doing anything. All methods also return doubles; Use +Cast.doubleToFloat(double[][]) if you want/need to cast everything back to floats for +further (non-high-accuracy-dependant) processing (pun intended). +

+ +

+

+ +

+ + + + + + + + + + + +
+Constructor Summary
Eigenvalue(float[][] Arg) + +
+          Check for symmetry, then construct the eigenvalue decomposition.
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ double[][]getD() + +
+          Return the block diagonal eigenvalue matrix
+ double[]getImagEigenvalues() + +
+          Return the imaginary parts of the eigenvalues
+ double[]getRealEigenvalues() + +
+          Return the real parts of the eigenvalues
+ double[][]getV() + +
+          Return the eigenvector matrix with each column corresponding to + an eigenvector of the input matrix.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+Eigenvalue

+
+public Eigenvalue(float[][] Arg)
+
+
Check for symmetry, then construct the eigenvalue decomposition. + Upon initialization, the matrices D and V, as well as the vectors containing the + real and imaginary eigenvalues are computed and stored. +

+

+
See Also:
getV(), +getD(), +getRealEigenvalues(), +getImagEigenvalues()
+
+ + + + + + + + +
+Method Detail
+ +

+getV

+
+public double[][] getV()
+
+
Return the eigenvector matrix with each column corresponding to + an eigenvector of the input matrix. +

+

+ +
Returns:
V
+
+
+
+ +

+getRealEigenvalues

+
+public double[] getRealEigenvalues()
+
+
Return the real parts of the eigenvalues +

+

+ +
Returns:
real(diag(D))
+
+
+
+ +

+getImagEigenvalues

+
+public double[] getImagEigenvalues()
+
+
Return the imaginary parts of the eigenvalues +

+

+ +
Returns:
imag(diag(D))
+
+
+
+ +

+getD

+
+public double[][] getD()
+
+
Return the block diagonal eigenvalue matrix +

+

+ +
Returns:
D
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Find.html b/drawing/papaya/reference/papaya/Find.html new file mode 100644 index 0000000..26f8612 --- /dev/null +++ b/drawing/papaya/reference/papaya/Find.html @@ -0,0 +1,3151 @@ + + + + + + +Find (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Find

+
+java.lang.Object
+  extended by papaya.Find
+
+
+
All Implemented Interfaces:
PapayaConstants
+
+
+
+
public final class Find
extends Object
implements PapayaConstants
+ + +

+Static class for finding indices in an array corresponding to a given value/object. +

+ (Portions of this code were (conveniently!) copied and pasted from commons.apache.org.) :) +

+

+ +

+

+ +

+ + + + + + + +
+Field Summary
+  + + + + + + + +
Fields inherited from interface papaya.PapayaConstants
BASELINE, big, biginv, BOTTOM, CENTER, CORNER, FONTNAME, GRAY, INDEX_NOT_FOUND, INDICES_NOT_FOUND, LEFT, LOGPI, MACHEP, MAXGAM, MAXLOG, MINLOG, RIGHT, SQRTH, SQTPI, STROKEWEIGHT, TEXTSIZE, TOP
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static booleancontains(byte[] array, + byte valueToFind) + +
+          Checks if the value is in the given array.
+static booleancontains(char[] array, + char valueToFind) + +
+          Checks if the value is in the given array.
+static booleancontains(double[] array, + double valueToFind) + +
+          Checks if the value is in the given array.
+static booleancontains(double[] array, + double valueToFind, + double tolerance) + +
+          Checks if a value falling within the given tolerance is in the + given array.
+static booleancontains(float[] array, + float valueToFind) + +
+          Checks if the value is in the given array.
+static booleancontains(int[] array, + int valueToFind) + +
+          Checks if the value is in the given array.
+static booleancontains(long[] array, + long valueToFind) + +
+          Checks if the value is in the given array.
+static booleancontains(Object[] array, + Object objectToFind) + +
+          Checks if the object is in the given array.
+static booleancontains(short[] array, + short valueToFind) + +
+          Checks if the value is in the given array.
+static intindexOf(boolean[] array, + boolean valueToFind) + +
+          Finds the index of the given value in the array.
+static intindexOf(boolean[] array, + boolean valueToFind, + int startIndex) + +
+          Finds the index of the given value in the array starting at the given index.
+static intindexOf(byte[] array, + byte valueToFind) + +
+          Finds the index of the given value in the array.
+static intindexOf(byte[] array, + byte valueToFind, + int startIndex) + +
+          Finds the index of the given value in the array starting at the given index.
+static intindexOf(char[] array, + char valueToFind) + +
+          Finds the index of the given value in the array.
+static intindexOf(char[] array, + char valueToFind, + int startIndex) + +
+          Finds the index of the given value in the array starting at the given index.
+static intindexOf(double[] array, + double valueToFind) + +
+          Finds the index of the given value in the array.
+static intindexOf(double[] array, + double valueToFind, + double tolerance) + +
+          Finds the index of the given value within a given tolerance in the array.
+static intindexOf(double[] array, + double valueToFind, + int startIndex) + +
+          Finds the index of the given value in the array starting at the given index.
+static intindexOf(double[] array, + double valueToFind, + int startIndex, + double tolerance) + +
+          Finds the index of the given value in the array starting at the given index.
+static intindexOf(float[] array, + float valueToFind) + +
+          Finds the index of the given value in the array.
+static intindexOf(float[] array, + float valueToFind, + int startIndex) + +
+          Finds the index of the given value in the array starting at the given index.
+static intindexOf(int[] array, + int valueToFind) + +
+          Finds the index of the given value in the array.
+static intindexOf(int[] array, + int valueToFind, + int startIndex) + +
+          Finds the index of the given value in the array starting at the given index.
+static intindexOf(long[] array, + long valueToFind) + +
+          Finds the index of the given value in the array.
+static intindexOf(long[] array, + long valueToFind, + int startIndex) + +
+          Finds the index of the given value in the array starting at the given index.
+static intindexOf(Object[] array, + Object objectToFind) + +
+          Finds the index of the given object in the array.
+static intindexOf(Object[] array, + Object objectToFind, + int startIndex) + +
+          Finds the index of the given object in the array starting at the given index.
+static intindexOf(short[] array, + short valueToFind) + +
+          Finds the index of the given value in the array.
+static intindexOf(short[] array, + short valueToFind, + int startIndex) + +
+          Finds the index of the given value in the array starting at the given index.
+static int[]indicesGreaterThan(float[] array, + float valueOfMin) + +
+           
+static int[]indicesGreaterThan(int[] array, + int valueOfMin) + +
+           
+static int[]indicesGreaterThanOrEqualTo(float[] array, + float valueOfMin) + +
+           
+static int[]indicesGreaterThanOrEqualTo(int[] array, + int valueOfMin) + +
+           
+static int[]indicesLessThan(float[] array, + float valueOfMax) + +
+           
+static int[]indicesLessThan(int[] array, + int valueOfMax) + +
+           
+static int[]indicesLessThanOrEqualTo(float[] array, + float valueOfMax) + +
+           
+static int[]indicesLessThanOrEqualTo(int[] array, + int valueOfMax) + +
+           
+static int[]indicesWith(boolean[] array, + boolean valueToFind) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(boolean[] array, + boolean valueToFind, + int startIndex) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(byte[] array, + byte valueToFind) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(byte[] array, + byte valueToFind, + int startIndex) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(char[] array, + char valueToFind) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(char[] array, + char valueToFind, + int startIndex) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(double[] array, + double valueToFind) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(double[] array, + double valueToFind, + int startIndex) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(float[] array, + float valueToFind) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(float[] array, + float valueToFind, + int startIndex) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(int[] array, + int valueToFind) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(int[] array, + int valueToFind, + int startIndex) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(long[] array, + long valueToFind) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(long[] array, + long valueToFind, + int startIndex) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(Object[] array, + Object objectToFind) + +
+          Finds the indices containing the specified object in the array.
+static int[]indicesWith(Object[] array, + Object objectToFind, + int startIndex) + +
+          Finds the indices containing the specified object in the array.
+static int[]indicesWith(short[] array, + short valueToFind) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWith(short[] array, + short valueToFind, + int startIndex) + +
+          Finds the indices containing the specified value in the array.
+static int[]indicesWithin(float[] array, + float minVal, + float maxVal) + +
+          Finds the indices for the array elements within the min and max value (inclusive).
+static int[]indicesWithin(int[] array, + float minVal, + float maxVal) + +
+          Finds the indices for the array elements within the min and max value (inclusive).
+static intlastIndexOf(boolean[] array, + boolean valueToFind) + +
+          Finds the last index of the given value within the array.
+static intlastIndexOf(boolean[] array, + boolean valueToFind, + int startIndex) + +
+          Finds the last index of the given value in the array starting at the given index.
+static intlastIndexOf(byte[] array, + byte valueToFind) + +
+          Finds the last index of the given value within the array.
+static intlastIndexOf(byte[] array, + byte valueToFind, + int startIndex) + +
+          Finds the last index of the given value in the array starting at the given index.
+static intlastIndexOf(char[] array, + char valueToFind) + +
+          Finds the last index of the given value within the array.
+static intlastIndexOf(char[] array, + char valueToFind, + int startIndex) + +
+          Finds the last index of the given value in the array starting at the given index.
+static intlastIndexOf(double[] array, + double valueToFind) + +
+          Finds the last index of the given value within the array.
+static intlastIndexOf(double[] array, + double valueToFind, + double tolerance) + +
+          Finds the last index of the given value within a given tolerance in the array.
+static intlastIndexOf(double[] array, + double valueToFind, + int startIndex) + +
+          Finds the last index of the given value in the array starting at the given index.
+static intlastIndexOf(double[] array, + double valueToFind, + int startIndex, + double tolerance) + +
+          Finds the last index of the given value in the array starting at the given index.
+static intlastIndexOf(float[] array, + float valueToFind) + +
+          Finds the last index of the given value within the array.
+static intlastIndexOf(float[] array, + float valueToFind, + int startIndex) + +
+          Finds the last index of the given value in the array starting at the given index.
+static intlastIndexOf(int[] array, + int valueToFind) + +
+          Finds the last index of the given value within the array.
+static intlastIndexOf(int[] array, + int valueToFind, + int startIndex) + +
+          Finds the last index of the given value in the array starting at the given index.
+static intlastIndexOf(long[] array, + long valueToFind) + +
+          Finds the last index of the given value within the array.
+static intlastIndexOf(long[] array, + long valueToFind, + int startIndex) + +
+          Finds the last index of the given value in the array starting at the given index.
+static intlastIndexOf(Object[] array, + Object objectToFind) + +
+          Finds the last index of the given object within the array.
+static intlastIndexOf(Object[] array, + Object objectToFind, + int startIndex) + +
+          Finds the last index of the given object in the array starting at the given index.
+static intlastIndexOf(short[] array, + short valueToFind) + +
+          Finds the last index of the given value within the array.
+static intlastIndexOf(short[] array, + short valueToFind, + int startIndex) + +
+          Finds the last index of the given value in the array starting at the given index.
+static intnumGreaterThan(float[] array, + float valueOfMin) + +
+          Finds the number of elements strictly greater than the specified value.
+static intnumGreaterThan(int[] array, + int valueOfMin) + +
+          Finds the number of elements strictly greater than the specified value.
+static intnumGreaterThanOrEqualTo(float[] array, + float valueOfMin) + +
+          Finds the number of elements greater than or equal to the specified value.
+static intnumGreaterThanOrEqualTo(int[] array, + int valueOfMin) + +
+          Finds the number of elements greater than or equal to the specified value.
+static intnumLessThan(float[] array, + float valueOfMax) + +
+          Finds the number of elements strictly less than the specified value.
+static intnumLessThan(int[] array, + int valueOfMax) + +
+          Finds the number of elements strictly less than the specified value.
+static intnumLessThanOrEqualTo(float[] array, + float valueOfMax) + +
+          Finds the number of elements less than or equal to the specified value.
+static intnumLessThanOrEqualTo(int[] array, + int valueOfMax) + +
+          Finds the number of elements less than or equal to the specified value.
+static intnumRepeats(boolean[] array, + boolean valueToFind) + +
+          Finds the number of times a given value/object is present in an array.
+static intnumRepeats(byte[] array, + byte valueToFind) + +
+          Finds the number of times a given value/object is present in an array.
+static intnumRepeats(char[] array, + char valueToFind) + +
+          Finds the number of times a given value/object is present in an array.
+static intnumRepeats(double[] array, + double valueToFind) + +
+          Finds the number of times a given value/object is present in an array.
+static intnumRepeats(float[] array, + float valueToFind) + +
+          Finds the number of times a given value/object is present in an array.
+static intnumRepeats(int[] array, + int valueToFind) + +
+          Finds the number of times a given value/object is present in an array.
+static intnumRepeats(long[] array, + long valueToFind) + +
+          Finds the number of times a given value/object is present in an array.
+static intnumRepeats(Object[] array, + Object objectToFind) + +
+          Finds the number of times a given value/object is present in an array.
+static intnumRepeats(short[] array, + short valueToFind) + +
+          Finds the number of times a given value/object is present in an array.
+static float[]uniqueElems(float[] array) + +
+          Find the unique elements in a float array (uses HashSets)
+static int[]uniqueElems(int[] array) + +
+          Find the unique elements in a int array (uses HashSets)
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+indexOf

+
+public static int indexOf(Object[] array,
+                          Object objectToFind)
+
+

Finds the index of the given object in the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
objectToFind - the object to find, may be null +
Returns:
the index of the object within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(Object[] array,
+                          Object objectToFind,
+                          int startIndex)
+
+

Finds the index of the given object in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex is treated as zero. A startIndex larger than the array + length will return PapayaConstants.INDEX_NOT_FOUND (-1).

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
objectToFind - the object to find, may be null
startIndex - the index to start searching at +
Returns:
the index of the object within the array starting at the index, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(Object[] array,
+                              Object objectToFind)
+
+

Finds the last index of the given object within the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to travers backwords looking for the object, may be null
objectToFind - the object to find, may be null +
Returns:
the last index of the object within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(Object[] array,
+                              Object objectToFind,
+                              int startIndex)
+
+

Finds the last index of the given object in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex will return PapayaConstants.INDEX_NOT_FOUND (-1). A startIndex larger than + the array length will search from the end of the array.

+

+

+
+
+
+
Parameters:
array - the array to traverse for looking for the object, may be null
objectToFind - the object to find, may be null
startIndex - the start index to travers backwards from +
Returns:
the last index of the object within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+contains

+
+public static boolean contains(Object[] array,
+                               Object objectToFind)
+
+

Checks if the object is in the given array.

+ +

The method returns false if a null array is passed in.

+

+

+
+
+
+
Parameters:
array - the array to search through
objectToFind - the object to find +
Returns:
true if the array contains the object
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(Object[] array,
+                                Object objectToFind)
+
+

Finds the indices containing the specified object in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object to find, may be null
objectToFind - the object to find +
Returns:
the indices containing the object within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(Object[] array,
+                                Object objectToFind,
+                                int startIndex)
+
+

Finds the indices containing the specified object in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object to find, may be null
objectToFind - the object to find
startIndex - the index to start searching at +
Returns:
the indices containing the object within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+numRepeats

+
+public static int numRepeats(Object[] array,
+                             Object objectToFind)
+
+

Finds the number of times a given value/object is present in an array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
objectToFind - the object to find. +
Returns:
the number of times that value/object appears in the array + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(long[] array,
+                          long valueToFind)
+
+

Finds the index of the given value in the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(long[] array,
+                          long valueToFind,
+                          int startIndex)
+
+

Finds the index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex is treated as zero. A startIndex larger than the array + length will return PapayaConstants.INDEX_NOT_FOUND (-1).

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(long[] array,
+                              long valueToFind)
+
+

Finds the last index of the given value within the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to travers backwords looking for the object, may be null
valueToFind - the object to find +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(long[] array,
+                              long valueToFind,
+                              int startIndex)
+
+

Finds the last index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex will return PapayaConstants.INDEX_NOT_FOUND (-1). A startIndex larger than the + array length will search from the end of the array.

+

+

+
+
+
+
Parameters:
array - the array to traverse for looking for the object, may be null
valueToFind - the value to find
startIndex - the start index to travers backwards from +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+contains

+
+public static boolean contains(long[] array,
+                               long valueToFind)
+
+

Checks if the value is in the given array.

+ +

The method returns false if a null array is passed in.

+

+

+
+
+
+
Parameters:
array - the array to search through
valueToFind - the value to find +
Returns:
true if the array contains the object
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(long[] array,
+                                long valueToFind)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(long[] array,
+                                long valueToFind,
+                                int startIndex)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+numRepeats

+
+public static int numRepeats(long[] array,
+                             long valueToFind)
+
+

Finds the number of times a given value/object is present in an array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueToFind - the object to find. +
Returns:
the number of times that value/object appears in the array + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(int[] array,
+                          int valueToFind)
+
+

Finds the index of the given value in the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(int[] array,
+                          int valueToFind,
+                          int startIndex)
+
+

Finds the index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex is treated as zero. A startIndex larger than the array + length will return PapayaConstants.INDEX_NOT_FOUND (-1).

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(int[] array,
+                              int valueToFind)
+
+

Finds the last index of the given value within the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to travers backwords looking for the object, may be null
valueToFind - the object to find +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(int[] array,
+                              int valueToFind,
+                              int startIndex)
+
+

Finds the last index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex will return PapayaConstants.INDEX_NOT_FOUND (-1). A startIndex larger than the + array length will search from the end of the array.

+

+

+
+
+
+
Parameters:
array - the array to traverse for looking for the object, may be null
valueToFind - the value to find
startIndex - the start index to travers backwards from +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+contains

+
+public static boolean contains(int[] array,
+                               int valueToFind)
+
+

Checks if the value is in the given array.

+ +

The method returns false if a null array is passed in.

+

+

+
+
+
+
Parameters:
array - the array to search through
valueToFind - the value to find +
Returns:
true if the array contains the object
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(int[] array,
+                                int valueToFind)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(int[] array,
+                                int valueToFind,
+                                int startIndex)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+indicesWithin

+
+public static int[] indicesWithin(int[] array,
+                                  float minVal,
+                                  float maxVal)
+
+

Finds the indices for the array elements within the min and max value (inclusive).

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
+
+
+
+ +

+indicesLessThanOrEqualTo

+
+public static int[] indicesLessThanOrEqualTo(int[] array,
+                                             int valueOfMax)
+
+
+
+
+
+
+
+
+
+ +

+indicesLessThan

+
+public static int[] indicesLessThan(int[] array,
+                                    int valueOfMax)
+
+
+
+
+
+
+
+
+
+ +

+indicesGreaterThanOrEqualTo

+
+public static int[] indicesGreaterThanOrEqualTo(int[] array,
+                                                int valueOfMin)
+
+
+
+
+
+
+
+
+
+ +

+indicesGreaterThan

+
+public static int[] indicesGreaterThan(int[] array,
+                                       int valueOfMin)
+
+
+
+
+
+
+
+
+
+ +

+numRepeats

+
+public static int numRepeats(int[] array,
+                             int valueToFind)
+
+

Finds the number of times a given value/object is present in an array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueToFind - the object to find. +
Returns:
the number of times that value/object appears in the array + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+numLessThanOrEqualTo

+
+public static int numLessThanOrEqualTo(int[] array,
+                                       int valueOfMax)
+
+

Finds the number of elements less than or equal to the specified value.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueOfMax - the maximum value +
Returns:
the number of elements ? that value
+
+
+
+ +

+numLessThan

+
+public static int numLessThan(int[] array,
+                              int valueOfMax)
+
+

Finds the number of elements strictly less than the specified value.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueOfMax - the maximum value +
Returns:
the number of elements strictly less than that value
+
+
+
+ +

+numGreaterThanOrEqualTo

+
+public static int numGreaterThanOrEqualTo(int[] array,
+                                          int valueOfMin)
+
+

Finds the number of elements greater than or equal to the specified value.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueOfMax - the maximum value +
Returns:
the number of elements ? that value
+
+
+
+ +

+numGreaterThan

+
+public static int numGreaterThan(int[] array,
+                                 int valueOfMin)
+
+

Finds the number of elements strictly greater than the specified value.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueOfMax - the maximum value +
Returns:
the number of elements strictly greater than that value
+
+
+
+ +

+uniqueElems

+
+public static int[] uniqueElems(int[] array)
+
+
Find the unique elements in a int array (uses HashSets) +

+

+
+
+
+
+
+
+
+ +

+indexOf

+
+public static int indexOf(short[] array,
+                          short valueToFind)
+
+

Finds the index of the given value in the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(short[] array,
+                          short valueToFind,
+                          int startIndex)
+
+

Finds the index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex is treated as zero. A startIndex larger than the array + length will return PapayaConstants.INDEX_NOT_FOUND (-1).

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(short[] array,
+                              short valueToFind)
+
+

Finds the last index of the given value within the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to travers backwords looking for the object, may be null
valueToFind - the object to find +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(short[] array,
+                              short valueToFind,
+                              int startIndex)
+
+

Finds the last index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex will return PapayaConstants.INDEX_NOT_FOUND (-1). A startIndex larger than the + array length will search from the end of the array.

+

+

+
+
+
+
Parameters:
array - the array to traverse for looking for the object, may be null
valueToFind - the value to find
startIndex - the start index to travers backwards from +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+contains

+
+public static boolean contains(short[] array,
+                               short valueToFind)
+
+

Checks if the value is in the given array.

+ +

The method returns false if a null array is passed in.

+

+

+
+
+
+
Parameters:
array - the array to search through
valueToFind - the value to find +
Returns:
true if the array contains the object
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(short[] array,
+                                short valueToFind)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(short[] array,
+                                short valueToFind,
+                                int startIndex)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+numRepeats

+
+public static int numRepeats(short[] array,
+                             short valueToFind)
+
+

Finds the number of times a given value/object is present in an array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueToFind - the object to find. +
Returns:
the number of times that value/object appears in the array + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(char[] array,
+                          char valueToFind)
+
+

Finds the index of the given value in the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
Since:
+
2.1
+
+
+
+
+ +

+indexOf

+
+public static int indexOf(char[] array,
+                          char valueToFind,
+                          int startIndex)
+
+

Finds the index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex is treated as zero. A startIndex larger than the array + length will return PapayaConstants.INDEX_NOT_FOUND (-1).

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
Since:
+
2.1
+
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(char[] array,
+                              char valueToFind)
+
+

Finds the last index of the given value within the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to travers backwords looking for the object, may be null
valueToFind - the object to find +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
Since:
+
2.1
+
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(char[] array,
+                              char valueToFind,
+                              int startIndex)
+
+

Finds the last index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex will return PapayaConstants.INDEX_NOT_FOUND (-1). A startIndex larger than the + array length will search from the end of the array.

+

+

+
+
+
+
Parameters:
array - the array to traverse for looking for the object, may be null
valueToFind - the value to find
startIndex - the start index to travers backwards from +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
Since:
+
2.1
+
+
+
+
+ +

+contains

+
+public static boolean contains(char[] array,
+                               char valueToFind)
+
+

Checks if the value is in the given array.

+ +

The method returns false if a null array is passed in.

+

+

+
+
+
+
Parameters:
array - the array to search through
valueToFind - the value to find +
Returns:
true if the array contains the object
Since:
+
2.1
+
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(char[] array,
+                                char valueToFind)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(char[] array,
+                                char valueToFind,
+                                int startIndex)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+numRepeats

+
+public static int numRepeats(char[] array,
+                             char valueToFind)
+
+

Finds the number of times a given value/object is present in an array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueToFind - the object to find. +
Returns:
the number of times that value/object appears in the array + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(byte[] array,
+                          byte valueToFind)
+
+

Finds the index of the given value in the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(byte[] array,
+                          byte valueToFind,
+                          int startIndex)
+
+

Finds the index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex is treated as zero. A startIndex larger than the array + length will return PapayaConstants.INDEX_NOT_FOUND (-1).

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(byte[] array,
+                              byte valueToFind)
+
+

Finds the last index of the given value within the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to travers backwords looking for the object, may be null
valueToFind - the object to find +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(byte[] array,
+                              byte valueToFind,
+                              int startIndex)
+
+

Finds the last index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex will return PapayaConstants.INDEX_NOT_FOUND (-1). A startIndex larger than the + array length will search from the end of the array.

+

+

+
+
+
+
Parameters:
array - the array to traverse for looking for the object, may be null
valueToFind - the value to find
startIndex - the start index to travers backwards from +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+contains

+
+public static boolean contains(byte[] array,
+                               byte valueToFind)
+
+

Checks if the value is in the given array.

+ +

The method returns false if a null array is passed in.

+

+

+
+
+
+
Parameters:
array - the array to search through
valueToFind - the value to find +
Returns:
true if the array contains the object
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(byte[] array,
+                                byte valueToFind)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(byte[] array,
+                                byte valueToFind,
+                                int startIndex)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+numRepeats

+
+public static int numRepeats(byte[] array,
+                             byte valueToFind)
+
+

Finds the number of times a given value/object is present in an array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueToFind - the object to find. +
Returns:
the number of times that value/object appears in the array + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(double[] array,
+                          double valueToFind)
+
+

Finds the index of the given value in the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(double[] array,
+                          double valueToFind,
+                          double tolerance)
+
+

Finds the index of the given value within a given tolerance in the array. + This method will return the index of the first value which falls between the region + defined by valueToFind - tolerance and valueToFind + tolerance.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find
tolerance - tolerance of the search +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(double[] array,
+                          double valueToFind,
+                          int startIndex)
+
+

Finds the index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex is treated as zero. A startIndex larger than the array + length will return PapayaConstants.INDEX_NOT_FOUND (-1).

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(double[] array,
+                          double valueToFind,
+                          int startIndex,
+                          double tolerance)
+
+

Finds the index of the given value in the array starting at the given index. + This method will return the index of the first value which falls between the region + defined by valueToFind - tolerance and valueToFind + tolerance.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex is treated as zero. A startIndex larger than the array + length will return PapayaConstants.INDEX_NOT_FOUND (-1).

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find
startIndex - the index to start searching at
tolerance - tolerance of the search +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(double[] array,
+                              double valueToFind)
+
+

Finds the last index of the given value within the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to travers backwords looking for the object, may be null
valueToFind - the object to find +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(double[] array,
+                              double valueToFind,
+                              double tolerance)
+
+

Finds the last index of the given value within a given tolerance in the array. + This method will return the index of the last value which falls between the region + defined by valueToFind - tolerance and valueToFind + tolerance.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find
tolerance - tolerance of the search +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(double[] array,
+                              double valueToFind,
+                              int startIndex)
+
+

Finds the last index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex will return PapayaConstants.INDEX_NOT_FOUND (-1). A startIndex larger than the + array length will search from the end of the array.

+

+

+
+
+
+
Parameters:
array - the array to traverse for looking for the object, may be null
valueToFind - the value to find
startIndex - the start index to travers backwards from +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(double[] array,
+                              double valueToFind,
+                              int startIndex,
+                              double tolerance)
+
+

Finds the last index of the given value in the array starting at the given index. + This method will return the index of the last value which falls between the region + defined by valueToFind - tolerance and valueToFind + tolerance.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex will return PapayaConstants.INDEX_NOT_FOUND (-1). A startIndex larger than the + array length will search from the end of the array.

+

+

+
+
+
+
Parameters:
array - the array to traverse for looking for the object, may be null
valueToFind - the value to find
startIndex - the start index to travers backwards from
tolerance - search for value within plus/minus this amount +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+contains

+
+public static boolean contains(double[] array,
+                               double valueToFind)
+
+

Checks if the value is in the given array.

+ +

The method returns false if a null array is passed in.

+

+

+
+
+
+
Parameters:
array - the array to search through
valueToFind - the value to find +
Returns:
true if the array contains the object
+
+
+
+ +

+contains

+
+public static boolean contains(double[] array,
+                               double valueToFind,
+                               double tolerance)
+
+

Checks if a value falling within the given tolerance is in the + given array. If the array contains a value within the inclusive range + defined by (value - tolerance) to (value + tolerance).

+ +

The method returns false if a null array + is passed in.

+

+

+
+
+
+
Parameters:
array - the array to search
valueToFind - the value to find
tolerance - the array contains the tolerance of the search +
Returns:
true if value falling within tolerance is in array
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(double[] array,
+                                double valueToFind)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(double[] array,
+                                double valueToFind,
+                                int startIndex)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+numRepeats

+
+public static int numRepeats(double[] array,
+                             double valueToFind)
+
+

Finds the number of times a given value/object is present in an array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueToFind - the object to find. +
Returns:
the number of times that value/object appears in the array + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(float[] array,
+                          float valueToFind)
+
+

Finds the index of the given value in the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(float[] array,
+                          float valueToFind,
+                          int startIndex)
+
+

Finds the index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex is treated as zero. A startIndex larger than the array + length will return PapayaConstants.INDEX_NOT_FOUND (-1).

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(float[] array,
+                              float valueToFind)
+
+

Finds the last index of the given value within the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to travers backwords looking for the object, may be null
valueToFind - the object to find +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(float[] array,
+                              float valueToFind,
+                              int startIndex)
+
+

Finds the last index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex will return PapayaConstants.INDEX_NOT_FOUND (-1). A startIndex larger than the + array length will search from the end of the array.

+

+

+
+
+
+
Parameters:
array - the array to traverse for looking for the object, may be null
valueToFind - the value to find
startIndex - the start index to travers backwards from +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+contains

+
+public static boolean contains(float[] array,
+                               float valueToFind)
+
+

Checks if the value is in the given array.

+ +

The method returns false if a null array is passed in.

+

+

+
+
+
+
Parameters:
array - the array to search through
valueToFind - the value to find +
Returns:
true if the array contains the object
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(float[] array,
+                                float valueToFind)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(float[] array,
+                                float valueToFind,
+                                int startIndex)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+indicesWithin

+
+public static int[] indicesWithin(float[] array,
+                                  float minVal,
+                                  float maxVal)
+
+

Finds the indices for the array elements within the min and max value (inclusive).

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
+
+
+
+ +

+numRepeats

+
+public static int numRepeats(float[] array,
+                             float valueToFind)
+
+

Finds the number of times a given value/object is present in an array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueToFind - the object to find. +
Returns:
the number of times that value/object appears in the array + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indicesLessThanOrEqualTo

+
+public static int[] indicesLessThanOrEqualTo(float[] array,
+                                             float valueOfMax)
+
+
+
+
+
+
+
+
+
+ +

+indicesLessThan

+
+public static int[] indicesLessThan(float[] array,
+                                    float valueOfMax)
+
+
+
+
+
+
+
+
+
+ +

+indicesGreaterThanOrEqualTo

+
+public static int[] indicesGreaterThanOrEqualTo(float[] array,
+                                                float valueOfMin)
+
+
+
+
+
+
+
+
+
+ +

+indicesGreaterThan

+
+public static int[] indicesGreaterThan(float[] array,
+                                       float valueOfMin)
+
+
+
+
+
+
+
+
+
+ +

+numLessThanOrEqualTo

+
+public static int numLessThanOrEqualTo(float[] array,
+                                       float valueOfMax)
+
+

Finds the number of elements less than or equal to the specified value.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueOfMax - the maximum value +
Returns:
the number of elements ? that value
+
+
+
+ +

+numLessThan

+
+public static int numLessThan(float[] array,
+                              float valueOfMax)
+
+

Finds the number of elements strictly less than the specified value.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueOfMax - the maximum value +
Returns:
the number of elements strictly less than that value
+
+
+
+ +

+numGreaterThanOrEqualTo

+
+public static int numGreaterThanOrEqualTo(float[] array,
+                                          float valueOfMin)
+
+

Finds the number of elements greater than or equal to the specified value.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueOfMax - the maximum value +
Returns:
the number of elements ? that value
+
+
+
+ +

+numGreaterThan

+
+public static int numGreaterThan(float[] array,
+                                 float valueOfMin)
+
+

Finds the number of elements strictly greater than the specified value.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueOfMax - the maximum value +
Returns:
the number of elements strictly greater than that value
+
+
+
+ +

+uniqueElems

+
+public static float[] uniqueElems(float[] array)
+
+
Find the unique elements in a float array (uses HashSets) +

+

+
+
+
+
+
+
+
+ +

+indexOf

+
+public static int indexOf(boolean[] array,
+                          boolean valueToFind)
+
+

Finds the index of the given value in the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indexOf

+
+public static int indexOf(boolean[] array,
+                          boolean valueToFind,
+                          int startIndex)
+
+

Finds the index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex is treated as zero. A startIndex larger than the array + length will return PapayaConstants.INDEX_NOT_FOUND (-1).

+

+

+
+
+
+
Parameters:
array - the array to search through for the object, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null + array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(boolean[] array,
+                              boolean valueToFind)
+
+

Finds the last index of the given value within the array.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) if + null array input.

+

+

+
+
+
+
Parameters:
array - the array to travers backwords looking for the object, may be null
valueToFind - the object to find +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+lastIndexOf

+
+public static int lastIndexOf(boolean[] array,
+                              boolean valueToFind,
+                              int startIndex)
+
+

Finds the last index of the given value in the array starting at the given index.

+ +

This method returns PapayaConstants.INDEX_NOT_FOUND (-1) for a null input array.

+ +

A negative startIndex will return PapayaConstants.INDEX_NOT_FOUND (-1). A startIndex larger than + the array length will search from the end of the array.

+

+

+
+
+
+
Parameters:
array - the array to traverse for looking for the object, may be null
valueToFind - the value to find
startIndex - the start index to travers backwards from +
Returns:
the last index of the value within the array, + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(boolean[] array,
+                                boolean valueToFind)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+indicesWith

+
+public static int[] indicesWith(boolean[] array,
+                                boolean valueToFind,
+                                int startIndex)
+
+

Finds the indices containing the specified value in the array.

+ +

This method returns PapayaConstants.INDICES_NOT_FOUND (int[] = -1) for a null input array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value to find, may be null
valueToFind - the value to find
startIndex - the index to start searching at +
Returns:
the indices containing the value within the array, + PapayaConstants.INDICES_NOT_FOUND (int[] = -1) if not found or null array input
+
+
+
+ +

+numRepeats

+
+public static int numRepeats(boolean[] array,
+                             boolean valueToFind)
+
+

Finds the number of times a given value/object is present in an array.

+

+

+
+
+
+
Parameters:
array - the array to search through for the value/object
valueToFind - the object to find. +
Returns:
the number of times that value/object appears in the array + PapayaConstants.INDEX_NOT_FOUND (-1) if not found or null array input
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Frequency.html b/drawing/papaya/reference/papaya/Frequency.html new file mode 100644 index 0000000..141f54d --- /dev/null +++ b/drawing/papaya/reference/papaya/Frequency.html @@ -0,0 +1,502 @@ + + + + + + +Frequency (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Frequency

+
+java.lang.Object
+  extended by papaya.Frequency
+
+
+
+
public class Frequency
extends Object
+ + +

+Class for getting the frequency distribution, cumulative frequency distribution, and other + distribution-related parameters of a given array of floats or ints. + To initialize, use something like this: +

+ Frequency freq= new Frequency(dataArray, minimumVal,maximumVal,widthOfEachBin); + + Once initialized, it stores 3 things: +

    +
  • The array containing the number of elements in each of the histogram bins (getFrequency()). +
  • The number of bins. +
  • The length of the full data array. +
+ +

A number of different methods are available for computing other distribution-related parameters + (e.g. the relative frequency distribution, the cumulative frequency distribution, etc).

+ +

See the FrequencyExample in the examples folder for an example.

+

+ +

+

+
Author:
+
Adila Faruk
+
+
+ +

+ + + + + + + + + + + + + + +
+Constructor Summary
Frequency(float[] _inputDat, + float _minVal, + float _maxVal, + float _binWidth) + +
+          Initialize the class by setting the minimum value, maximum value, and the bin width.
Frequency(int[] _inputDat, + int _minVal, + int _maxVal, + int _binWidth) + +
+          Initialize the class by setting the minimum value, maximum value, and the bin width.
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ float[]compCumFrequency() + +
+          Computes the cumulative frequency of the data.
+ float[]compRelCumFrequency() + +
+          Computes the cumulative relative frequency of the data.
+ float[]compRelCumFrequencyPct() + +
+          Computes the cumulative frequency of the data as a percentage.
+ float[]compRelFrequency() + +
+          Computes the fraction of the total data that's in each bin.
+ float[]compRelFrequencyPct() + +
+          Computes the percents of the total data that's in each bin.
+ float[]getFrequency() + +
+          Returns the pre-computed frequency array.
+ intgetLength() + +
+          returns the length of the dataset.
+ intgetNumBins() + +
+          Returns the number of bins.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+Frequency

+
+public Frequency(float[] _inputDat,
+                 float _minVal,
+                 float _maxVal,
+                 float _binWidth)
+
+
Initialize the class by setting the minimum value, maximum value, and the bin width. + Upon initialization, the number of bins are determined and the + frequency distribution array is computed for the given input data and histogram bin width. + This frequency distribution can be accessed using the getFrequency() function. + Note that this is the only place where you can set the frequency distribution. + +

How is the number of bins computed? +
Like this: +
bins = floor[ (max - min) / binWidth ] +1 ,
+ as opposed to ceil[ (max - min) / binWidth ]. + Why? The latter algorithm is problematic when [ (max - min) / binWidth ] + is a whole number. + E.g. let min = 0.0, max = 100.0, and binWidth = 10.0. We get 10 bins with +

    +
  • 1st bin = bin[0] --> contains elements 0.0 - 9.999... +
  • 2nd bin = bin[1] --> contains elements 10.0 - 19.999... +
  • ... +
  • ... +
  • 10th bin = bin[9] --> contains elements 90.0-99.999... +
+ Poor 100. He's got nowhere to go but into an Array Index out of bound Exception! +

+

What element goes into what bin? +
Let value = data[i]; +
value will go into bin number floor( (_inputDat[i]-_minVal)/_binWidth ); +

+

+

+
Parameters:
_inputDat - the input data
_minVal - the minimum value in the array
_maxVal - the maximum value in the array
_binWidth - the width of each of the bins
+
+
+ +

+Frequency

+
+public Frequency(int[] _inputDat,
+                 int _minVal,
+                 int _maxVal,
+                 int _binWidth)
+
+
Initialize the class by setting the minimum value, maximum value, and the bin width. + Upon initialization, the number of bins are determined and the + frequency distribution array is computed for the given input data and histogram bin width. + This frequency distribution can be accessed using the getFrequency() function. + Note that this is the only place where you can set the frequency distribution. + +

See Frequency(float[] _inputDat, float _minVal, float _maxVal, float _binWidth) for + more details. +

+

+

+ + + + + + + + +
+Method Detail
+ +

+compRelFrequency

+
+public float[] compRelFrequency()
+
+
Computes the fraction of the total data that's in each bin. + This is similar to dividing the number in each bin by the total + number of elements in the data array. +

+

+
+
+
+
+ +

+compRelFrequencyPct

+
+public float[] compRelFrequencyPct()
+
+
Computes the percents of the total data that's in each bin. + This isimilar to dividing the number in each bin by the total + number of elements in the data array x 100% +

+

+
+
+
+
+ +

+compCumFrequency

+
+public float[] compCumFrequency()
+
+
Computes the cumulative frequency of the data. +

+

+
+
+
+
+ +

+compRelCumFrequency

+
+public float[] compRelCumFrequency()
+
+
Computes the cumulative relative frequency of the data. + This is similar to dividing the number in each bin of + the cumulative frequency array (compCumFrequency()) by + the number of elements in the data array. +

+

+
+
+
+
+ +

+compRelCumFrequencyPct

+
+public float[] compRelCumFrequencyPct()
+
+
Computes the cumulative frequency of the data as a percentage. + This is similar to dividing the number in each bin of + the cumulative frequency array (compCumFrequency()) by + the number of elements in the data array x 100%. +

+

+
+
+
+
+ +

+getFrequency

+
+public float[] getFrequency()
+
+
Returns the pre-computed frequency array. + An array of floats so division won't cause any surprises. +

+

+
+
+
+
+ +

+getNumBins

+
+public int getNumBins()
+
+
Returns the number of bins. +

+

+
+
+
+
+ +

+getLength

+
+public int getLength()
+
+
returns the length of the dataset. +

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Gamma.html b/drawing/papaya/reference/papaya/Gamma.html new file mode 100644 index 0000000..2d08a2e --- /dev/null +++ b/drawing/papaya/reference/papaya/Gamma.html @@ -0,0 +1,449 @@ + + + + + + +Gamma (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Gamma

+
+java.lang.Object
+  extended by papaya.Gamma
+
+
+
All Implemented Interfaces:
PapayaConstants
+
+
+
+
public class Gamma
extends Object
implements PapayaConstants
+ + +

+Gamma and Beta functions. +

+ Implementation: + The code is mostly adapted from the CERN + Jet Java libraries, which in turn was adapted from the Cephes Mathematical Library. As far a + as I can tell, Stephen L. Moshier wrote the original C++ code for CEPHES (1989, moshier@na-net.ornl.gov) + and Wolfgang Hoschek (at CERN, hats off to you mate!) then adapted it for the + Java platform, making some significant changes along the way. +
+

+ +

+

+ +

+ + + + + + + +
+Field Summary
+  + + + + + + + +
Fields inherited from interface papaya.PapayaConstants
BASELINE, big, biginv, BOTTOM, CENTER, CORNER, FONTNAME, GRAY, INDEX_NOT_FOUND, INDICES_NOT_FOUND, LEFT, LOGPI, MACHEP, MAXGAM, MAXLOG, MINLOG, RIGHT, SQRTH, SQTPI, STROKEWEIGHT, TEXTSIZE, TOP
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static floatbeta(double a, + double b) + +
+          Returns the beta function of the arguments.
+static doublegamma(double x) + +
+          Returns the Gamma function of the argument, Γ(x)
+static doubleincompleteBeta(double aa, + double bb, + double xx) + +
+          Returns the Incomplete Beta Function evaluated from zero to xx; formerly named ibeta.
+static doubleincompleteBetaInverse(double aa, + double bb, + double yy0) + +
+          Returns the inverse of the incomplete Beta integral.
+static doubleincompleteGamma(double a, + double x) + +
+          Returns the Incomplete Gamma function; formerly named igamma.
+static doubleincompleteGammaComplement(double a, + double x) + +
+          Returns the Complemented Incomplete Gamma function; formerly named igamc.
+static doublelogGamma(double x) + +
+          Returns the natural logarithm of the gamma function; formerly named lgamma.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+beta

+
+public static float beta(double a,
+                         double b)
+                  throws ArithmeticException
+
+
Returns the beta function of the arguments. + 
+ 
+ beta( a, b )  = Γ(a) * Γ(b) ) Γ(a+b)
+
+
+

+

+
+
+
+ +
Throws: +
ArithmeticException
+
+
+
+ +

+gamma

+
+public static double gamma(double x)
+                    throws ArithmeticException
+
+
Returns the Gamma function of the argument, Γ(x) +

+

+
+
+
+ +
Throws: +
ArithmeticException
+
+
+
+ +

+incompleteBeta

+
+public static double incompleteBeta(double aa,
+                                    double bb,
+                                    double xx)
+                             throws ArithmeticException
+
+
Returns the Incomplete Beta Function evaluated from zero to xx; formerly named ibeta. +

+

+
+
+
+
Parameters:
aa - the alpha parameter of the beta distribution.
bb - the beta parameter of the beta distribution.
xx - the integration end point. +
Throws: +
ArithmeticException
+
+
+
+ +

+incompleteBetaInverse

+
+public static double incompleteBetaInverse(double aa,
+                                           double bb,
+                                           double yy0)
+
+
Returns the inverse of the incomplete Beta integral. + That is, given y, the function finds x such that + 
+  incompleteBeta( a, b, x ) = y.
+
+ The routine performs interval halving until incompleteBeta(a,b,x) - y = 0, + to within roughly 10^-13 of the true solution. If this precision is not reached, the + method returns the current approximation of x, and prints a warning statement + specifying the current error. Typically, this is on the order of 10^-12. +

+

+
+
+
+
Parameters:
aa - the alpha parameter of the beta distribution.
bb - the beta parameter of the beta distribution.
yy0 - the value for which to solve for the corresponding x in the + incomplete Beta integral. +
Returns:
the value x such that incompleteBeta( a, b, x ) = y.
+
+
+
+ +

+incompleteGamma

+
+public static double incompleteGamma(double a,
+                                     double x)
+                              throws ArithmeticException
+
+
Returns the Incomplete Gamma function; formerly named igamma. +

+

+
+
+
+
Parameters:
a - the parameter of the gamma distribution.
x - the integration end point. +
Throws: +
ArithmeticException
+
+
+
+ +

+incompleteGammaComplement

+
+public static double incompleteGammaComplement(double a,
+                                               double x)
+                                        throws ArithmeticException
+
+
Returns the Complemented Incomplete Gamma function; formerly named igamc. +

+

+
+
+
+
Parameters:
a - the parameter of the gamma distribution.
x - the integration start point. +
Throws: +
ArithmeticException
+
+
+
+ +

+logGamma

+
+public static double logGamma(double x)
+                       throws ArithmeticException
+
+
Returns the natural logarithm of the gamma function; formerly named lgamma. +

+

+
+
+
+ +
Throws: +
ArithmeticException
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/LU.html b/drawing/papaya/reference/papaya/LU.html new file mode 100644 index 0000000..da77217 --- /dev/null +++ b/drawing/papaya/reference/papaya/LU.html @@ -0,0 +1,449 @@ + + + + + + +LU (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class LU

+
+java.lang.Object
+  extended by papaya.LU
+
+
+
+
public class LU
extends Object
+ + +

+LU Decomposition. +

+For an m x n matrix A with m > n, the LU decomposition is an m x n +unit lower triangular matrix L, an n x n upper triangular matrix U, +and a permutation vector piv of length m so that A(piv,:) = L*U; +If m < n, then L is m x m and U is m x n. +

+The LU decomposition with pivoting always exists, even if the matrix is +singular, so the constructor will never fail. The primary use of the +LU decomposition is in the solution of square systems of simultaneous +linear equations. This will fail if isNonsingular() returns false. +

+Shamelessly copied (and modified) from the +JAMA Java +Matrix package. To make things compatible with how most users use Processing, the +class take in float matrices. However, to preserve the acccuracy of the computations, the algorithm +first casts the input into a double array, prior to doing anything. All methods also return doubles; Use +Cast.doubleToFloat(double[][]) if you want/need to cast everything back to floats for +further (non-high-accuracy-dependant) processing (pun intended). +

+ +

+

+ +

+ + + + + + + + + + + +
+Constructor Summary
LU(float[][] A) + +
+          Constructor.
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ doubledet() + +
+          Determinant
+ float[]getFloatPivot() + +
+          Return pivot permutation vector as a one-dimensional float array
+ double[][]getL() + +
+          Return lower triangular factor, L.
+ int[]getPivot() + +
+          Return pivot permutation vector
+ double[][]getU() + +
+          Return upper triangular factor, U
+ booleanisNonsingular() + +
+          Is the matrix nonsingular?
+ double[][]solve(float[][] B) + +
+          Solve A*X = B
+ double[]solve(float[] b, + boolean returnZeroesForSingularCase) + +
+          Solve A*x = b for x
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+LU

+
+public LU(float[][] A)
+
+
Constructor. Takes in a matrix and computes the LU matrix. Additional + parameters can be obtained by calling one of the available methods. +

+

+
See Also:
getL(), +getU(), +getPivot(), +getFloatPivot(), +det()
+
+ + + + + + + + +
+Method Detail
+ +

+isNonsingular

+
+public boolean isNonsingular()
+
+
Is the matrix nonsingular? +

+

+ +
Returns:
true if U, and hence A, is nonsingular.
+
+
+
+ +

+getL

+
+public double[][] getL()
+
+
Return lower triangular factor, L. +

+

+
+
+
+
+ +

+getU

+
+public double[][] getU()
+
+
Return upper triangular factor, U +

+

+
+
+
+
+ +

+getPivot

+
+public int[] getPivot()
+
+
Return pivot permutation vector +

+

+ +
Returns:
piv
+
+
+
+ +

+getFloatPivot

+
+public float[] getFloatPivot()
+
+
Return pivot permutation vector as a one-dimensional float array +

+

+ +
Returns:
piv
+
+
+
+ +

+det

+
+public double det()
+
+
Determinant +

+

+ +
Returns:
det(A) +
Throws: +
IllegalArgumentException - Matrix must be square
+
+
+
+ +

+solve

+
+public double[] solve(float[] b,
+                      boolean returnZeroesForSingularCase)
+
+
Solve A*x = b for x +

+

+
Parameters:
b - An array with as many elements as the number of rows in A. +
Returns:
x so that L*U*x = b(piv,:) +
Throws: +
IllegalArgumentException - Matrix row dimensions must agree. +
RuntimeException - Matrix is singular.
+
+
+
+ +

+solve

+
+public double[][] solve(float[][] B)
+
+
Solve A*X = B +

+

+
Parameters:
B - A Matrix with as many rows as A and any number of columns. +
Returns:
X so that L*U*X = B(piv,:) +
Throws: +
IllegalArgumentException - Matrix row dimensions must agree. +
RuntimeException - Matrix is singular.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Linear.BoxCox.html b/drawing/papaya/reference/papaya/Linear.BoxCox.html new file mode 100644 index 0000000..bdb3d05 --- /dev/null +++ b/drawing/papaya/reference/papaya/Linear.BoxCox.html @@ -0,0 +1,285 @@ + + + + + + +Linear.BoxCox (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Linear.BoxCox

+
+java.lang.Object
+  extended by papaya.Linear.BoxCox
+
+
+
Enclosing class:
Linear
+
+
+
+
public static class Linear.BoxCox
extends Object
+ + +

+Contains methods related to the Box-Cox transformation of a data set; useful in + determining the best transformation that will yield the best method for converting + a monotonic, non-linear relationship between x and y into + a linear one. +

Reference: +
Box, George E. P.; Cox, D. R. (1964). "An analysis of transformations". + Journal of the Royal Statistical Society, Series B 26 (2): 211?252. +
+ NIST/SEMATECH e-Handbook of Statistical Methods, EDA Section 1.3.3.6: Box-Cox Linearity Plots + (The reader's digest version of the original.) +

+ +

+

+ +

+ + + + + + + + + + + + + + + + +
+Method Summary
+static float[]correlation(float[] x, + float[] y, + float[] lambda) + +
+          Performs the box-cox transformation on y for a sequence of λ + and returns the array of linear correlation coefficients + between the x and the box-cox transformed y.
+static float[]transform(float[] data, + float lambda) + +
+          Performs the box-cox transformation, returning the transformed data.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+correlation

+
+public static float[] correlation(float[] x,
+                                  float[] y,
+                                  float[] lambda)
+
+
Performs the box-cox transformation on y for a sequence of λ + and returns the array of linear correlation coefficients + between the x and the box-cox transformed y. + at each value of λ . + The value of λ corresponding to the maximum correlation + (or minimum for negative correlation) is the optimal choice for + λ such that the relationship between x and T(y) is linear. +

Reference: +
+ NIST/SEMATECH e-Handbook of Statistical Methods, EDA Section 1.3.3.6: Box-Cox Linearity Plots +

+

+
Parameters:
x - the independent data array
y - the dependent data array
lambda - an array of lambda values +
Returns:
the array containing the linear correlation coefficients, r.
+
+
+
+ +

+transform

+
+public static float[] transform(float[] data,
+                                float lambda)
+
+
Performs the box-cox transformation, returning the transformed data. + That is, it computes and returns + 
+ y[i](λ) = (y[i]^λ-1) / λ if λ ≠ 0
+ 
+ y[i](λ) = log(y[i])if λ = 0
+
+ Requirements: all elements of y are >0. +

+

+
Parameters:
data - the data to be transformed
lambda - the lambda value +
Returns:
the transformed data, or y(λ) above.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Linear.Significance.html b/drawing/papaya/reference/papaya/Linear.Significance.html new file mode 100644 index 0000000..2f8a36f --- /dev/null +++ b/drawing/papaya/reference/papaya/Linear.Significance.html @@ -0,0 +1,302 @@ + + + + + + +Linear.Significance (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Linear.Significance

+
+java.lang.Object
+  extended by papaya.Linear.Significance
+
+
+
Enclosing class:
Linear
+
+
+
+
public static class Linear.Significance
extends Object
+ + +

+Contains methods used to compute the significance, or pvalue of the input correlations. + The significance is computed using the normal of student-t approximations and hence are + not to be used for small datasets(i.e. size<20). +

+ +

+

+ +

+ + + + + + + + + + + +
+Constructor Summary
Linear.Significance() + +
+           
+  + + + + + + + + + + + + + + + +
+Method Summary
+static floatintercept(float intercept, + float interceptStdErr, + int df) + +
+          Returns the p-value, or significance, of the computed intercept under the null-hypothesis + of intercept = 0 (two-tailed test).
+static floatslope(float slope, + float slopeStdErr, + int df) + +
+          Returns the p-value, or significance, of the computed slope under the null-hypothesis + of slope = 0 (two-tailed test).
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+Linear.Significance

+
+public Linear.Significance()
+
+
+ + + + + + + + +
+Method Detail
+ +

+slope

+
+public static float slope(float slope,
+                          float slopeStdErr,
+                          int df)
+
+
Returns the p-value, or significance, of the computed slope under the null-hypothesis + of slope = 0 (two-tailed test). The p-value is computed using the student-T distribution + with df degrees of freedom and test statistic + 
 t = slope/slopeStdErr,
+

+

+
Parameters:
slope - the slope of the best fit linear line
slopeStdErr - the standard error of the slope
df - the degrees of freedom (typically (n-2), but could also be (n-1) if the + intercept was previously specified.
+
+
+
+ +

+intercept

+
+public static float intercept(float intercept,
+                              float interceptStdErr,
+                              int df)
+
+
Returns the p-value, or significance, of the computed intercept under the null-hypothesis + of intercept = 0 (two-tailed test). The p-value is computed using the student-T distribution + with df degrees of freedom and test statistic + 
t=intercept/interceptStdErr
+

+

+
Parameters:
intercept - the intercept of the best fit linear line
interceptStdErr - the standard error of the intercept
df - the degrees of freedom (n-2)
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Linear.StdErr.html b/drawing/papaya/reference/papaya/Linear.StdErr.html new file mode 100644 index 0000000..0d5bde2 --- /dev/null +++ b/drawing/papaya/reference/papaya/Linear.StdErr.html @@ -0,0 +1,299 @@ + + + + + + +Linear.StdErr (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Linear.StdErr

+
+java.lang.Object
+  extended by papaya.Linear.StdErr
+
+
+
Enclosing class:
Linear
+
+
+
+
public static class Linear.StdErr
extends Object
+ + +

+Contains methods related to computing the standard errors of the residuals, slope and intercept + associated with the best-fit linear line. +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static floatintercept(float[] x, + float residualStdErr) + +
+          Returns the standard error of the computed slope given x and the + standard error in the residuals.
+static floatresidual(float[] residuals, + int df) + +
+          Returns the standard error of the residuals given the degrees of freedom.
+static floatslope(float[] x, + float residualStdErr) + +
+          Returns the standard error of the computed slope given x and the + standard error in the residuals.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+residual

+
+public static float residual(float[] residuals,
+                             int df)
+
+
Returns the standard error of the residuals given the degrees of freedom. + That is, + 
+ residualStdErr = Sqrt ( Sum( (delta[i] - mean(delta))^2 ) / df )
+
+ where df is the degrees of freedom ( (n-1) if the y-intercept was pre-specified in the + best-fit line, (n-2) if neither slope nor intercept were specified.) +

+

+
Parameters:
residuals -
df - +
Returns:
standard error of the residual
+
+
+
+ +

+slope

+
+public static float slope(float[] x,
+                          float residualStdErr)
+
+
Returns the standard error of the computed slope given x and the + standard error in the residuals. That is, + 
+ slopeStdErr = residualStdErr / Sum ( (x[i] - mean(x))^2 ).
+
+

+

+
Parameters:
x - the independent variable
residualStdErr - the standard error of the residual +
Returns:
the error in the slope.
+
+
+
+ +

+intercept

+
+public static float intercept(float[] x,
+                              float residualStdErr)
+
+
Returns the standard error of the computed slope given x and the + standard error in the residuals. That is, + 
+ interceptStdErr = slopeStdErr / Sqrt( Sum(x[i]*x[i])/size ).
+
+ where the slopeStdErr is computed using the methods specified + in slope(float[], float). +

+

+
Parameters:
x - the independent variable
residualStdErr - the standard error of the residual +
Returns:
error in the slope.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Linear.html b/drawing/papaya/reference/papaya/Linear.html new file mode 100644 index 0000000..7ec2034 --- /dev/null +++ b/drawing/papaya/reference/papaya/Linear.html @@ -0,0 +1,433 @@ + + + + + + +Linear (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Linear

+
+java.lang.Object
+  extended by papaya.Linear
+
+
+
All Implemented Interfaces:
PapayaConstants
+
+
+
+
public class Linear
extends Object
implements PapayaConstants
+ + +

+Contains methods related to determining the linear linear + relationship between two datasets (of equal arrays) such as the + best-fit linear line parameters, box-cox transformations, etc. +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + +
+Nested Class Summary
+static classLinear.BoxCox + +
+          Contains methods related to the Box-Cox transformation of a data set; useful in + determining the best transformation that will yield the best method for converting + a monotonic, non-linear relationship between x and y into + a linear one.
+static classLinear.Significance + +
+          Contains methods used to compute the significance, or pvalue of the input correlations.
+static classLinear.StdErr + +
+          Contains methods related to computing the standard errors of the residuals, slope and intercept + associated with the best-fit linear line.
+  + + + + + + +
+Field Summary
+  + + + + + + + +
Fields inherited from interface papaya.PapayaConstants
BASELINE, big, biginv, BOTTOM, CENTER, CORNER, FONTNAME, GRAY, INDEX_NOT_FOUND, INDICES_NOT_FOUND, LEFT, LOGPI, MACHEP, MAXGAM, MAXLOG, MINLOG, RIGHT, SQRTH, SQTPI, STROKEWEIGHT, TEXTSIZE, TOP
+  + + + + + + + + + + +
+Constructor Summary
Linear() + +
+           
+  + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static float[]bestFit(float[] x, + float[] y) + +
+          Returns the slope and y-intercept of the best fit linear line + z = slope*x + intercept by minimizing the sum of least squares + between z and the y.
+static floatbestFit(float[] x, + float[] y, + float intercept) + +
+          Returns the slope of the best fit linear line for the prescribed y-intercept.
+static float[]residuals(float[] x, + float[] y) + +
+          Compute and return the array of residuals given by + Delta_i = z_i - y_i, + where + z_i = (slope*x_i + intercept) is the best fit linear line.
+static float[]residuals(float[] x, + float[] y, + float slope, + float intercept) + +
+          Compute and return the array of residuals given by + Delta_i = z_i - y_i, + where + z_i = (slope*x_i + intercept) is the best fit linear line.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+Linear

+
+public Linear()
+
+
+ + + + + + + + +
+Method Detail
+ +

+bestFit

+
+public static float[] bestFit(float[] x,
+                              float[] y)
+
+
Returns the slope and y-intercept of the best fit linear line + z = slope*x + intercept by minimizing the sum of least squares + between z and the y. +

+

+
+
+
+
Parameters:
x - the x data
y - the y data +
Returns:
a 2-by-1 array with the first element coeff[0]corresponding to + the slope, and the second element coeff[1] equal to the y-intercept.
+
+
+
+ +

+bestFit

+
+public static float bestFit(float[] x,
+                            float[] y,
+                            float intercept)
+
+
Returns the slope of the best fit linear line for the prescribed y-intercept. + That is, + z = slope*x + intercept, where the intercept is specified + by the user. E.g. intercept = 1 will result in z = slope*x+1. + The slope is computed by minimizing the sum of least squares + between z and the y. +

+

+
+
+
+
Parameters:
x - the x data
y - the y data
intercept - the intercept of the best-fit line with the y-axis. +
Returns:
the slope of the best-fit linear line.
+
+
+
+ +

+residuals

+
+public static float[] residuals(float[] x,
+                                float[] y,
+                                float slope,
+                                float intercept)
+
+
Compute and return the array of residuals given by + Delta_i = z_i - y_i, + where + z_i = (slope*x_i + intercept) is the best fit linear line. +

+

+
+
+
+
Parameters:
slope - the slope of the best-fit linear line
intercept - the y-intercept of the best fit linear line
+
+
+
+ +

+residuals

+
+public static float[] residuals(float[] x,
+                                float[] y)
+
+
Compute and return the array of residuals given by + Delta_i = z_i - y_i, + where + z_i = (slope*x_i + intercept) is the best fit linear line. + You'd basically use this to compute the spread of a best fit line (max - min) +

+

+
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/MDS.html b/drawing/papaya/reference/papaya/MDS.html new file mode 100644 index 0000000..d9908be --- /dev/null +++ b/drawing/papaya/reference/papaya/MDS.html @@ -0,0 +1,253 @@ + + + + + + +MDS (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class MDS

+
+java.lang.Object
+  extended by papaya.MDS
+
+
+
+
public final class MDS
extends Object
+ + +

+Contains methods for performing but classical and non-classical multidimensional scaling. +

+ For an m-by-n input matrix with m observations and n variables, the output D is + the symmetric m-by-m matrix with zeros along the diagonals and element ij + specifying the distance between rows i and j. +

+ +

+

+ +

+ + + + + + + + + + + + +
+Method Summary
+static float[][]classical(float[][] D, + int p, + boolean showEigenvalues) + +
+          Performs classical (metric) multidimensional scaling, on an input matrix of Distances (computed + using e.g.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+classical

+
+public static float[][] classical(float[][] D,
+                                  int p,
+                                  boolean showEigenvalues)
+
+
Performs classical (metric) multidimensional scaling, on an input matrix of Distances (computed + using e.g. Distance ) and outputs the best-fitting p-dimensional configuration of points + (p<N). The output matrix Y has p columns with rows + giving the coordinates of the points chosen to represent the dissimilarities. + When D corresponds to the Euclidian distance matrix, the p + dimensional coordinates correspond exactly to the first p principal components. +

+ Remarks +

    +
  • If p > kwhere k is the number of + positive eigenvalues of Y*Y', then only the + first k columns of Y are computed. +
    • +
  • Set showEigenvalues to true to print the + values of the "scalar product matrix" Y*Y' to the screen. + (This is a good idea if you want to know how well the first p dimensions + captures most of the variation in D.
    • +
> +

+

+
Parameters:
D - the input distance matrix (see Distance)
p - the dimension (number of columns) of the output matrix.
showEigenvalues - whether to print the eigenvalues to the screen or otherwise. +
Returns:
Y, N-by-p (or N-by-k) matrix consisting of N points in each of the p (or k) dimensions.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Mat.html b/drawing/papaya/reference/papaya/Mat.html new file mode 100644 index 0000000..66a6207 --- /dev/null +++ b/drawing/papaya/reference/papaya/Mat.html @@ -0,0 +1,2622 @@ + + + + + + +Mat (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Mat

+
+java.lang.Object
+  extended by papaya.Mat
+
+
+
+
public final class Mat
extends Object
+ + +

+Static class for performing some basic matrix operations. +

+ Guidelines +
+ Methods that modify an array by a value always take the array as the first parameter, and + the value as the second. + For example, +

+ I try to follow that guiding principle with all methods that take in an input + array (e.g. swap(float[] array, int index1, int index2), + populate(float[] array, int[] indices)). +

+ Remarks +
+ Almost all the methods here take in float arrays or matrices, although I've also added in a few + methods that operate on integers. In addition, to avoid accidental array manipulation, + all methods return a new array or matrix instead of modifying the original one. E.g. +
C[i][j] = A[i][j]*B[i][j] return C +
as opposed to +
A[i][j] = A[i][j]*B[i][j], return A +
in dotMultiply(float[][],float[][]). + (If you find it performing to the contrary though, please let me know!) + +

+ Some non-trivial matrix-math related methods, including those for getting + the condition number, inverse, rank, and norms of a 2D input matrix are also included. + Making everything float-based instead of double-based naturally results in some precision loss but + the internal computations are done using doubles to minimize this. + +

+

+ +

+

+
See Also:
Cast, +Find, +NaNs, +Rank, +Sorting
+
+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static float[]abs(float[] array) + +
+          Return absolute values of an array
+static int[]abs(int[] array) + +
+          Return absolute values of an array
+static floatceilToNearest(float currentVal, + int interval) + +
+          Function for ceiling a number to the closest interval.
+static float[]column(float[][] inputMat, + int columnIndex) + +
+          Function to get one column of a 2D matrix
+static float[][]column(float[][] inputMat, + int indexStart, + int indexEnd) + +
+          Function to get columns of a 2-D matrix.
+static int[]column(int[][] inputMat, + int columnIndex) + +
+           
+static floatcompare(float a, + float b) + +
+          Returns -1 if a is less than b, or 1 if a is greater than b, or 0.
+static intcompare(int a, + int b) + +
+          Returns -1 if a is less than b, or 1 if a is greater than b, or 0.
+static float[]concat(float[] a, + float[] b) + +
+          Concatenates two arrays a and b into a new array + c such that c = {a,b}.
+static int[]concat(int[] a, + int[] b) + +
+           
+static float[]constant(float constValue, + int size) + +
+          Returns an array with of length size with + each element equal to the specified constValue.
+static int[]constant(int constValue, + int size) + +
+          Returns an array with of length size with + each element equal to the specified constValue.
+static float[][]copy(float[][] data) + +
+          Make a deep copy of a matrix
+static float[]copyThenSort(float[] data) + +
+          Sorts and returns a copy of the input array in ascending order
+static float[]cross(float[] a, + float[] b) + +
+          vector cross product: c = a (cross) b
+static floatdet(float[][] data) + +
+          returns the determinant of the square input matrix.
+static float[][]divide(float[][] A, + float value) + +
+          Divides each element of the input matrix A by the input value
+static float[]divide(float[] data, + float value) + +
+          Divides all elements of input array by value.
+static float[]divide(float[] x, + float[] y) + +
+          Element by element division such that z[i] = x[i]/y[i].
+static float[][]dotDivide(float[][] A, + float[][] B) + +
+          Element by element matrix division such that C_ij = A_ij/B_ij.
+static float[][]dotMultiply(float[][] A, + float[][] B) + +
+          Element by element matrix multiplication such that C_ij = A_ij*B_ij.
+static floatdotProduct(float[] a, + float[] b) + +
+          dot product of two arrays such that z = sum(a_i*b_i)
+static floatfloorToNearest(float currentVal, + int interval) + +
+          Function for flooring a number to the closest interval.
+static float[][]identity(int dimension) + +
+          returns the identity matrix of the specified dimension
+static float[][]inverse(float[][] A) + +
+          Matrix inverse if A is square, pseudoinverse otherwise
+static float[]inverse(float[] data, + float replaceZeroWith) + +
+          Returns the array z[i] = 1/x[i]; If x[i] is zero, it sets z[i] + to the specified replaceZeroWith value instead.
+static booleanisConstant(float[] a) + +
+           
+static float[]linspace(float start, + float end, + float stepSize) + +
+           
+static int[]linspace(int start, + int end) + +
+          Returns the array of (end-start+1) points going from + start (inclusive) to end (inclusive): + y[0] = start; y[1] = start+1; ...
+static int[]linspace(int start, + int end, + int stepSize) + +
+           
+static float[]log(float[] data) + +
+          Returns an array with each element equal to the natural logarithm (the base-e logarithm) + the corresponding input array.
+static float[]log10(float[] data) + +
+          Returns an array with each element equal to the log 10 value (base 10 logarithm) + of the corresponding input array.
+static float[]logToBase(float[] data, + float base) + +
+          Returns an array with each element equal to the log A value + of the corresponding input array.
+static floatmag(float[] data) + +
+          Returns the magnitude of the input array = sqrt(x1^2 + x2^2 + ...
+static float[]map(float[] data, + float from, + float to) + +
+          Similar to map([] value, valueArrayMinimum, valueArrayMaximum, from, to)
+static float[]map(float[] data, + float low1, + float high1, + float low2, + float high2) + +
+          Function for mapping an input array of floats for plotting + Extends processing "map" function to accomodate + arrays.
+static floatmap(float data, + float low1, + float high1, + float low2, + float high2) + +
+          Convenience function to map a variable from one coordinate space to another.
+static float[][]multiply(float[][] A, + float a) + +
+          Multiplies the matrix A with the scalar a returning a*A = B + where B_ij = a*A_ij.
+static float[]multiply(float[][] A, + float[] x) + +
+          Multiplies the matrix A with the vector x returning A*x = y + where y_j= Sum(k=j to n) A_ij*x_j.
+static float[][]multiply(float[][] A, + float[][] B) + +
+          Multiplies two matrices A and B returning C = A*B + where C_ij = Sum(k=1 to n) A_ik*B_kj.
+static float[]multiply(float[] data, + float number) + +
+          Multiplies each element of an array by a number, and returns the multiplied array.
+static float[]multiply(float[] data1, + float[] data2) + +
+          Multiplies two arrays and returns the multiplied array.
+static floatnorm1(float[][] data) + +
+          Returns the norm1 of the input matrix, equal to the + maximum absolute column sum of the matrix.
+static floatnorm2(float[] data) + +
+          Returns the norm2 or magnitude of an array.
+static floatnorm2(float[][] data) + +
+          Returns the norm2 (or maximum singular value) of the input matrix.
+static float[]normalizeToMinMax(float[] data) + +
+          Returns an array with elements consisting of the data + normalized to the specified min/max; new data goes from 0 to 1.
+static float[]normalizeToSum(float[] data) + +
+          Returns an array with elements given by z[i] = data[i] / sum(data);
+static floatnormF(float[][] data) + +
+          /** Returns the Frobenius norm of the input matrix; + sqrt of sum of squares of all elements.
+static floatnormInf(float[][] data) + +
+          Returns the Infinity norm of the input matrix, equal to the + maximum row sum.
+static double[]populate(double[] fullDataset, + int[] indices) + +
+          Returns an array with each element corresponding to fullDataset[indices[i]].
+static float[]populate(float[] fullDataset, + int[] indices) + +
+          Returns an array with each element corresponding to fullDataset[indices[i]].
+static int[]populate(int[] fullDataset, + int[] indices) + +
+          Returns an array with each element corresponding to fullDataset[indices[i]].
+static String[]populate(String[] fullDataset, + int[] indices) + +
+          Returns an array with each element corresponding to fullDataset[indices[i]].
+static voidprint(double[][] data, + int d) + +
+          Print the matrix to the screen with each row of the + matrix taking up one line.
+static voidprint(double[][] data, + String[] columnLabels, + String[] rowLabels, + int d) + +
+          Print the matrix to the screen with the columns and rows labeled according to the + input strings.
+static voidprint(double[] data, + int d) + +
+          Print the array to the screen in a single line.
+static voidprint(float[][] data, + int d) + +
+          Print the matrix to the screen with each row of the + matrix taking up one line.
+static voidprint(float[][] data, + String[] columnLabels, + String[] rowLabels, + int d) + +
+          Print the matrix to the screen with the columns and rows labeled according to the + input strings.
+static voidprint(float[] data, + int d) + +
+          Print the array to the screen in a single line.
+static voidprint(int[][] data, + int d) + +
+          Print the matrix to the screen with each row of the + matrix taking up one line.
+static voidprint(int[][] data, + String[] columnLabels, + String[] rowLabels, + int d) + +
+          Print the matrix to the screen with the columns and rows labeled according to the + input strings.
+static voidprint(int[] data, + int d) + +
+          Print the array to the screen in a single line.
+static intrank(float[][] data) + +
+          Returns the effective numerical rank (obtained from SVD) + of the input matrix.
+static float[][]replace(float[][] A, + float oldValue, + float newValue) + +
+          Returns a new matrix B equal to A, except that all elements in A which are equal to oldValue with + the newValue.
+static float[]replace(float[] data, + float oldValue, + float newValue) + +
+          Returns a new array data2 which is similar to data, except that all elements in data + which are equal to oldValue are replaced with + the newValue.
+static float[][]reshape(float[][] arr, + int numRows, + int numColumns) + +
+          Reshapes a matrix into the new specified dimensions.
+static double[]reverse(double[] data) + +
+          reverses the order of the elements in an array.
+static float[]reverse(float[] data) + +
+          reverses the order of the elements in an array.
+static int[]reverse(int[] data) + +
+          reverses the order of the elements in an array.
+static floatroundToDecimalPlace(float number, + int decimal) + +
+          Function for rounding to a given decimal place.
+static float[][]skewSymmetric(float[][] data) + +
+          Returns the skew symmetric part of the input matrix ((A-A')/2).
+static ArrayList[]split(float[] sortedList, + float[] splitters) + +
+          Splits (partitions) an array into sublists such that each sublist contains the elements with a given range.
+static float[][]subMatrix(float[][] inputMat, + int[] rowIndices, + int[] columnIndices) + +
+          Function to get a (2D) submatrix of a (2D) matrix (a copy, not a pointer).
+static float[][]subMatrix(float[][] inputMat, + int[] rowIndices, + int columnStart, + int columnEnd) + +
+          Function to get a (2D) submatrix of a (2D) matrix (a copy, not a pointer).
+static float[][]subMatrix(float[][] inputMat, + int rowStart, + int rowEnd, + int[] columnIndices) + +
+          Function to get a (2D) submatrix of a (2D) matrix (a copy, not a pointer).
+static float[][]subMatrix(float[][] inputMat, + int rowStart, + int rowEnd, + int columnStart, + int columnEnd) + +
+          Get a (2D) submatrix of a (2D) matrix (a copy, not a pointer).
+static int[][]subMatrix(int[][] inputMat, + int[] rowIndices, + int[] columnIndices) + +
+           
+static float[][]subtract(float[][] x, + float[][] y) + +
+          Returns the matrix z = x-y where each element of z[i][j] = x[i][j] - y[i][j]
+static float[]subtract(float[] x, + float[] y) + +
+          Returns the array z = x-y where each element of z[i] = x[i] - y[i]
+static floatsum(float[] data) + +
+          Returns the sum of a data sequence.
+static float[][]sum(float[][] x, + float[][] y) + +
+          Returns the matrix z = x+y where each element of z[i][j] = x[i][j] + y[i][j]
+static float[]sum(float[] data, + float number) + +
+          Sum of an array with a number.
+static float[]sum(float[] data1, + float[] data2) + +
+          Returns the sum of two data sequences.
+static intsum(int[] data) + +
+          Returns the sum of a data sequence.
+static int[]sum(int[] data, + int number) + +
+          Sum of an array with a number.
+static int[]sum(int[] data1, + int[] data2) + +
+          Returns the sum of two data sequences.
+static voidswap(float[] data, + int oldIndex, + int newIndex) + +
+          Swap function that swaps the values in an array
+static voidswap(int[] data, + int oldIndex, + int newIndex) + +
+          Swap function that swaps the values in an array (overload function)
+static float[][]symmetric(float[][] data) + +
+          Returns the symmetric part of the input matrix ((A+A')/2).
+static floattrace(float[][] data) + +
+          Returns the matrix trace or sum of the diagonal elements.
+static float[][]transpose(float[][] data) + +
+          Returns the transpose of the input matrix.
+static int[][]transpose(int[][] data) + +
+           
+static float[]within(float[] numbers, + float min, + float max) + +
+          returns an array containing all numbers within the min and max (inclusive).
+static booleanwithin(float number, + float min, + float max) + +
+          Checks to see if a number is in the range specified by [min,max].
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+abs

+
+public static float[] abs(float[] array)
+
+
Return absolute values of an array +

+

+
+
+
+
+ +

+abs

+
+public static int[] abs(int[] array)
+
+
Return absolute values of an array +

+

+
+
+
+
+ +

+column

+
+public static float[][] column(float[][] inputMat,
+                               int indexStart,
+                               int indexEnd)
+
+
Function to get columns of a 2-D matrix. +

+

+
Parameters:
inputMat - inputMatrix.
indexStart - index of the start column (inclusive)
indexEnd - index of the end column (inclusive) +
Returns:
outputMat consisting of the specified columns [indexStart, indexStart+1, ...., indexEnd]
+
+
+
+ +

+column

+
+public static float[] column(float[][] inputMat,
+                             int columnIndex)
+
+
Function to get one column of a 2D matrix +

+

+
Parameters:
inputMat - input matrix.
columnIndex - index of the column to get +
Returns:
outputColumn the specified column
+
+
+
+ +

+column

+
+public static int[] column(int[][] inputMat,
+                           int columnIndex)
+
+
+
+
+
+
+ +

+compare

+
+public static int compare(int a,
+                          int b)
+
+
Returns -1 if a is less than b, or 1 if a is greater than b, or 0. + This is the comparator function for natural order. +

+

+
+
+
+
+ +

+compare

+
+public static float compare(float a,
+                            float b)
+
+
Returns -1 if a is less than b, or 1 if a is greater than b, or 0. + This is the comparator function for natural order. +

+

+
+
+
+
+ +

+concat

+
+public static float[] concat(float[] a,
+                             float[] b)
+
+
Concatenates two arrays a and b into a new array + c such that c = {a,b}. +

+

+
+
+
+
+ +

+concat

+
+public static int[] concat(int[] a,
+                           int[] b)
+
+
+
+
+
+
+ +

+constant

+
+public static float[] constant(float constValue,
+                               int size)
+
+
Returns an array with of length size with + each element equal to the specified constValue. +

+

+
See Also:
Arrays.fill
+
+
+
+ +

+constant

+
+public static int[] constant(int constValue,
+                             int size)
+
+
Returns an array with of length size with + each element equal to the specified constValue. +

+

+
See Also:
Arrays.fill
+
+
+
+ +

+copy

+
+public static float[][] copy(float[][] data)
+
+
Make a deep copy of a matrix +

+

+
+
+
+
+ +

+copyThenSort

+
+public static float[] copyThenSort(float[] data)
+
+
Sorts and returns a copy of the input array in ascending order +

+

+ +
Returns:
a sorted copy of the input array.
+
+
+
+ +

+cross

+
+public static float[] cross(float[] a,
+                            float[] b)
+
+
vector cross product: c = a (cross) b +

+

+
+
+
+
+ +

+det

+
+public static float det(float[][] data)
+
+
returns the determinant of the square input matrix. +

+

+ +
Throws: +
IllegalArgumentException - if the matrix is not square.
+
+
+
+ +

+divide

+
+public static float[] divide(float[] data,
+                             float value)
+
+
Divides all elements of input array by value. + That is, z[i] = x[i] / value. +

+

+ +
Throws: +
IllegalArgumentException - if value is zero.
+
+
+
+ +

+divide

+
+public static float[] divide(float[] x,
+                             float[] y)
+
+
Element by element division such that z[i] = x[i]/y[i]. No checks are + done to see if any y[i] == 0 so make sure you know what + you're doing. +

+

+
+
+
+
+ +

+divide

+
+public static float[][] divide(float[][] A,
+                               float value)
+
+
Divides each element of the input matrix A by the input value +

+

+
+
+
+
+ +

+dotDivide

+
+public static float[][] dotDivide(float[][] A,
+                                  float[][] B)
+
+
Element by element matrix division such that C_ij = A_ij/B_ij. No checks are + done to see if the elements of B_ij == 0 so make sure you know what + you're doing. +

+

+
+
+
+
+ +

+dotMultiply

+
+public static float[][] dotMultiply(float[][] A,
+                                    float[][] B)
+
+
Element by element matrix multiplication such that C_ij = A_ij*B_ij. +

+

+
+
+
+
+ +

+dotProduct

+
+public static float dotProduct(float[] a,
+                               float[] b)
+
+
dot product of two arrays such that z = sum(a_i*b_i) +

+

+
+
+
+
+ +

+identity

+
+public static float[][] identity(int dimension)
+
+
returns the identity matrix of the specified dimension +

+

+
+
+
+
+ +

+inverse

+
+public static float[] inverse(float[] data,
+                              float replaceZeroWith)
+
+
Returns the array z[i] = 1/x[i]; If x[i] is zero, it sets z[i] + to the specified replaceZeroWith value instead. +

+

+
+
+
+
+ +

+inverse

+
+public static float[][] inverse(float[][] A)
+
+
Matrix inverse if A is square, pseudoinverse otherwise +

+

+ +
Returns:
inverse(A) if A is square, pseudoinverse otherwise.
+
+
+
+ +

+isConstant

+
+public static boolean isConstant(float[] a)
+
+
+
+
+
+
+ +

+log

+
+public static float[] log(float[] data)
+
+
Returns an array with each element equal to the natural logarithm (the base-e logarithm) + the corresponding input array. + This function expects the values greater than 0.0; No internal checks are done. +

+

+
+
+
+
+ +

+log10

+
+public static float[] log10(float[] data)
+
+
Returns an array with each element equal to the log 10 value (base 10 logarithm) + of the corresponding input array. + This function expects the values greater than 0.0; No internal checks are done. +

+

+
+
+
+
+ +

+logToBase

+
+public static float[] logToBase(float[] data,
+                                float base)
+
+
Returns an array with each element equal to the log A value + of the corresponding input array. This is + computed using the property log_A(x) = log(x) / log(A) where + log is the natural logarithm (base e), and A is the new log base. + This function expects the values greater than 0.0; No internal checks are done. +

+

+
Parameters:
base - the log base. E.g. to get log2, we would use logToBase(data,2).
+
+
+
+ +

+linspace

+
+public static int[] linspace(int start,
+                             int end)
+
+
Returns the array of (end-start+1) points going from + start (inclusive) to end (inclusive): + y[0] = start; y[1] = start+1; ... , y[n] = end;. +
+ For example, int[] ii = linspace(2,5); + produces the array ii = {2,3,4,5}; with length 4. + 
+ It is similar to this:
+ 
+ for(int i=0; i<=end-start+1; i++){
+ 
    y[i] = i + start;
+ 
}
+ 
+
+

+

+
Parameters:
start - the start index (inclusive)
end - the end index (inclusive);
+
+
+
+ +

+linspace

+
+public static int[] linspace(int start,
+                             int end,
+                             int stepSize)
+
+
+
Parameters:
start - the start index (inclusive)
end - the end index (inclusive);
stepSize - the stepsize to take +
Returns:
array of length num = floor((end-start)/(float)stepSize) (meaning that it could end BEFORE 'end' if you + don't size your stepsize properly.
+
+
+
+ +

+linspace

+
+public static float[] linspace(float start,
+                               float end,
+                               float stepSize)
+
+
+
Parameters:
start - the start index (inclusive)
end - the end index (inclusive);
stepSize - the stepsize to take +
Returns:
array of length num = ((end-start)/stepSize)
+
+
+
+ +

+mag

+
+public static float mag(float[] data)
+
+
Returns the magnitude of the input array = sqrt(x1^2 + x2^2 + ... + xn^2) +

+

+
+
+
+
+ +

+map

+
+public static float map(float data,
+                        float low1,
+                        float high1,
+                        float low2,
+                        float high2)
+
+
Convenience function to map a variable from one coordinate space to another. + I.e. + map(value, low1, high1, low2, high2) = low2 + (value - low1) * ( (high2-low2) / (high1-low1) ) + +

Similar to Processing's "map" function.

+

+

+ +
Returns:
mapped data array
+
+
+
+ +

+map

+
+public static float[] map(float[] data,
+                          float from,
+                          float to)
+
+
Similar to map([] value, valueArrayMinimum, valueArrayMaximum, from, to) +

+

+ +
Returns:
mapped data array
+
+
+
+ +

+map

+
+public static float[] map(float[] data,
+                          float low1,
+                          float high1,
+                          float low2,
+                          float high2)
+
+
Function for mapping an input array of floats for plotting + Extends processing "map" function to accomodate + arrays. E.g. map(value, low1, high1, low2, high2) + is now + map([] value, low1, high1, low2, high2) +

+

+ +
Returns:
mapped data array
+
+
+
+ +

+multiply

+
+public static float[][] multiply(float[][] A,
+                                 float[][] B)
+
+
Multiplies two matrices A and B returning C = A*B + where C_ij = Sum(k=1 to n) A_ik*B_kj. + Precondition: Number of columns in A = number of rows in B. +

+

+
+
+
+
+ +

+multiply

+
+public static float[] multiply(float[][] A,
+                               float[] x)
+
+
Multiplies the matrix A with the vector x returning A*x = y + where y_j= Sum(k=j to n) A_ij*x_j. + Precondition: Number of columns in A = number of elements in x. +

+

+
+
+
+
+ +

+multiply

+
+public static float[][] multiply(float[][] A,
+                                 float a)
+
+
Multiplies the matrix A with the scalar a returning a*A = B + where B_ij = a*A_ij. +

+

+
+
+
+
+ +

+multiply

+
+public static float[] multiply(float[] data1,
+                               float[] data2)
+
+
Multiplies two arrays and returns the multiplied array. + That is, z[i] = x[i] * y[i]. +

+

+
+
+
+
+ +

+multiply

+
+public static float[] multiply(float[] data,
+                               float number)
+
+
Multiplies each element of an array by a number, and returns the multiplied array. + That is, z[i] = k * x[i] . +

+

+
+
+
+
+ +

+norm1

+
+public static float norm1(float[][] data)
+
+
Returns the norm1 of the input matrix, equal to the + maximum absolute column sum of the matrix. +

+

+
+
+
+
+ +

+norm2

+
+public static float norm2(float[][] data)
+
+
Returns the norm2 (or maximum singular value) of the input matrix. +

+

+
+
+
+
+ +

+norm2

+
+public static float norm2(float[] data)
+
+
Returns the norm2 or magnitude of an array. Similar to mag(float[]). +

+

+
+
+
+
+ +

+normF

+
+public static float normF(float[][] data)
+
+
/** Returns the Frobenius norm of the input matrix; + sqrt of sum of squares of all elements. +

+

+
+
+
+
+ +

+normInf

+
+public static float normInf(float[][] data)
+
+
Returns the Infinity norm of the input matrix, equal to the + maximum row sum. +

+

+
+
+
+
+ +

+normalizeToMinMax

+
+public static float[] normalizeToMinMax(float[] data)
+
+
Returns an array with elements consisting of the data + normalized to the specified min/max; new data goes from 0 to 1. +

+

+ +
Returns:
normalized data array
+
+
+
+ +

+normalizeToSum

+
+public static float[] normalizeToSum(float[] data)
+
+
Returns an array with elements given by z[i] = data[i] / sum(data); +

+

+ +
Returns:
normalized data array
+
+
+
+ +

+populate

+
+public static double[] populate(double[] fullDataset,
+                                int[] indices)
+
+
Returns an array with each element corresponding to fullDataset[indices[i]]. + That is, if the indices.length = n, then + 
+ y[0] = fullDataset[ indices[0] ];
+ y[1] = fullDataset[ indices[1] ];
+ ...
+ ...
+ y[n-1] = fullDataset[ indices[n-1] ];
+
+

+

+
Parameters:
indices - the indices in the fullDataset you want to extract and store.
fullDataset - the full dataset.
+
+
+
+ +

+populate

+
+public static float[] populate(float[] fullDataset,
+                               int[] indices)
+
+
Returns an array with each element corresponding to fullDataset[indices[i]]. + That is, if the indices.length = n, then + 
+ y[0] = fullDataset[ indices[0] ];
+ y[1] = fullDataset[ indices[1] ];
+ ...
+ ...
+ y[n-1] = fullDataset[ indices[n-1] ];
+
+

+

+
Parameters:
indices - the indices in the fullDataset you want to extract and store.
fullDataset - the full dataset.
+
+
+
+ +

+populate

+
+public static int[] populate(int[] fullDataset,
+                             int[] indices)
+
+
Returns an array with each element corresponding to fullDataset[indices[i]]. + That is, if the indices.length = n, then + 
+ y[0] = fullDataset[ indices[0] ];
+ y[1] = fullDataset[ indices[1] ];
+ ...
+ ...
+ y[n-1] = fullDataset[ indices[n-1] ];
+
+

+

+
Parameters:
indices - the indices in the fullDataset you want to extract and store.
fullDataset - the full dataset.
+
+
+
+ +

+populate

+
+public static String[] populate(String[] fullDataset,
+                                int[] indices)
+
+
Returns an array with each element corresponding to fullDataset[indices[i]]. + That is, if the indices.length = n, then + 
+ y[0] = fullDataset[ indices[0] ];
+ y[1] = fullDataset[ indices[1] ];
+ ...
+ ...
+ y[n-1] = fullDataset[ indices[n-1] ];
+
+

+

+
Parameters:
indices - the indices in the fullDataset you want to extract and store.
fullDataset - the full dataset.
+
+
+
+ +

+print

+
+public static void print(double[] data,
+                         int d)
+
+
Print the array to the screen in a single line. Similar to print, + except that the entire array is printed on a single line on the screen and + you can format the number of decimal digits directly instead of using Processing's + nf or one of the other variants of it. +

+

+
Parameters:
data - the matrix to be printed.
d - Number of digits after the decimal to display..
+
+
+
+ +

+print

+
+public static void print(double[][] data,
+                         int d)
+
+
Print the matrix to the screen with each row of the + matrix taking up one line. Similar to println, except that + each row of the matrix is printed on a single line on the screen and + you can format the number of decimal digits directly instead of using Processing's + nf or one of the other variants of it. +

+

+
Parameters:
data - the matrix to be printed.
d - Number of digits after the decimal to display..
+
+
+
+ +

+print

+
+public static void print(double[][] data,
+                         String[] columnLabels,
+                         String[] rowLabels,
+                         int d)
+
+
Print the matrix to the screen with the columns and rows labeled according to the + input strings. Output resembles what you'd see in a .txt file (assuming the matrix isn't + too large). +

+

+
Parameters:
data - the matrix to be printed.
d - Number of digits after the decimal to display..
+
+
+
+ +

+print

+
+public static void print(float[] data,
+                         int d)
+
+
Print the array to the screen in a single line. Similar to print, + except that the entire array is printed on a single line on the screen and + you can format the number of decimal digits directly instead of using Processing's + nf or one of the other variants of it. +

+

+
Parameters:
data - the matrix to be printed.
d - Number of digits after the decimal to display..
+
+
+
+ +

+print

+
+public static void print(float[][] data,
+                         int d)
+
+
Print the matrix to the screen with each row of the + matrix taking up one line. Similar to println, except that + each row of the matrix is printed on a single line on the screen and + you can format the number of decimal digits directly instead of using Processing's + nf or one of the other variants of it. +

+

+
Parameters:
data - the matrix to be printed.
d - Number of digits after the decimal to display..
+
+
+
+ +

+print

+
+public static void print(float[][] data,
+                         String[] columnLabels,
+                         String[] rowLabels,
+                         int d)
+
+
Print the matrix to the screen with the columns and rows labeled according to the + input strings. Output resembles what you'd see in a .txt file (assuming the matrix isn't + too large). +

+

+
Parameters:
data - the matrix to be printed.
d - Number of digits after the decimal to display..
+
+
+
+ +

+print

+
+public static void print(int[] data,
+                         int d)
+
+
Print the array to the screen in a single line. Similar to print, + except that the entire array is printed on a single line on the screen and + you can format the number of decimal digits directly instead of using Processing's + nf or one of the other variants of it. +

+

+
Parameters:
data - the matrix to be printed.
d - Number of digits after the decimal to display..
+
+
+
+ +

+print

+
+public static void print(int[][] data,
+                         int d)
+
+
Print the matrix to the screen with each row of the + matrix taking up one line. Similar to println, except that + each row of the matrix is printed on a single line on the screen and + you can format the number of decimal digits directly instead of using Processing's + nf or one of the other variants of it. +

+

+
Parameters:
data - the matrix to be printed.
d - Number of digits after the decimal to display..
+
+
+
+ +

+print

+
+public static void print(int[][] data,
+                         String[] columnLabels,
+                         String[] rowLabels,
+                         int d)
+
+
Print the matrix to the screen with the columns and rows labeled according to the + input strings. Output resembles what you'd see in a .txt file (assuming the matrix isn't + too large). +

+

+
Parameters:
data - the matrix to be printed.
d - Number of digits after the decimal to display..
+
+
+
+ +

+rank

+
+public static int rank(float[][] data)
+
+
Returns the effective numerical rank (obtained from SVD) + of the input matrix. + See Rank for ranking the elements of an input 1D array. +

+

+
+
+
+
+ +

+replace

+
+public static float[][] replace(float[][] A,
+                                float oldValue,
+                                float newValue)
+
+
Returns a new matrix B equal to A, except that all elements in A which are equal to oldValue with + the newValue. Useful, for example, in replacing zeros with + some other number (for dotDivide(float[][], float[][])), or for wall-street related book-keeping... +

+

+
+
+
+
+ +

+replace

+
+public static float[] replace(float[] data,
+                              float oldValue,
+                              float newValue)
+
+
Returns a new array data2 which is similar to data, except that all elements in data + which are equal to oldValue are replaced with + the newValue. Useful, for example, in replacing zeros with + some other number (for divide(float[], float[])), or for wall-street related book-keeping... +

+

+
+
+
+
+ +

+reshape

+
+public static float[][] reshape(float[][] arr,
+                                int numRows,
+                                int numColumns)
+
+
Reshapes a matrix into the new specified dimensions. +

+

+
+
+
+
+ +

+reverse

+
+public static double[] reverse(double[] data)
+
+
reverses the order of the elements in an array. +

+

+
+
+
+
+ +

+reverse

+
+public static float[] reverse(float[] data)
+
+
reverses the order of the elements in an array. +

+

+
+
+
+
+ +

+reverse

+
+public static int[] reverse(int[] data)
+
+
reverses the order of the elements in an array. +

+

+
+
+
+
+ +

+roundToDecimalPlace

+
+public static float roundToDecimalPlace(float number,
+                                        int decimal)
+
+
Function for rounding to a given decimal place. + Convenient for displaying text when Processing's nf,nfc,etc is insufficient. + Only works if the input number has got more decimal places than the + number to round to. +

+ Examples: +
roundToDecimalPlace(1.234567, 2) --> 1.23; +
roundToDecimalPlace(100, 2) --> 100; +

+

+

+
Parameters:
number - number to round.
decimal - decimal place to round to. +
Returns:
number rounded to the specified decimal place
+
+
+
+ +

+floorToNearest

+
+public static float floorToNearest(float currentVal,
+                                   int interval)
+
+
Function for flooring a number to the closest interval. Useful for + setting up the tick labels for plotting. +

+ Examples: +
floorToNearest(173.2,5) --> 170; +
floorToNearest(28,10) --> 20; +

+

+

+
Parameters:
currentVal - number to floor.
interval - to floor to. E.g. in fives, twos, tens, etc. +
Returns:
number.
+
+
+
+ +

+ceilToNearest

+
+public static float ceilToNearest(float currentVal,
+                                  int interval)
+
+
Function for ceiling a number to the closest interval. Useful for + setting up the tick labels for plotting. +

+ Examples: +
ceilToNearest(173.2,5) --> 175; +
ceilToNearest(28,10) --> 30; +

+

+

+
Parameters:
currentVal - number to ceil.
interval - to ceil to. E.g. in fives, twos, tens, etc. +
Returns:
number.
+
+
+
+ +

+split

+
+public static ArrayList[] split(float[] sortedList,
+                                float[] splitters)
+
+
Splits (partitions) an array into sublists such that each sublist contains the elements with a given range. + splitters=(a,b,c,...,y,z) defines the ranges [-inf,a), [a,b), [b,c), ..., [y,z), [z,inf]. +

Examples:
+

    + data = (1,2,3,4,5,8,8,8,10,11). +
    splitters=(2,8) yields 3 bins: (1), (2,3,4,5) (8,8,8,10,11). +
    splitters=() yields 1 bin: (1,2,3,4,5,8,8,8,10,11). +
    splitters=(-5) yields 2 bins: (), (1,2,3,4,5,8,8,8,10,11). +
    splitters=(100) yields 2 bins: (1,2,3,4,5,8,8,8,10,11), (). +
+

+

+
Parameters:
sortedList - the list to be partitioned (must be sorted ascending).
splitters - the points at which the list shall be partitioned (must be sorted ascending). +
Returns:
the sublists (an array with length == splitters.length + 1. + Each sublist is returned sorted ascending.
+
+
+
+ +

+subMatrix

+
+public static float[][] subMatrix(float[][] inputMat,
+                                  int rowStart,
+                                  int rowEnd,
+                                  int columnStart,
+                                  int columnEnd)
+
+
Get a (2D) submatrix of a (2D) matrix (a copy, not a pointer). +

+

+
Parameters:
inputMat - input matrix
rowStart - row to start at (inclusive)
rowEnd - row to end at (inclusive)
columnStart - column to start at (inclusive)
columnEnd - column to end at (inclusive) +
Returns:
submatrix containing (rowEnd-rowStart+1) rows and (columnEnd-columnStart+1) columns; + copy of A(rowStart:rowEnd, columnStart:columnEnd). +
Throws: +
IllegalArgumentException - if the rowStart, rowEnd, columnStart, or columnEnd parameters + are not within the inputMatrix size bounds.
+
+
+
+ +

+subMatrix

+
+public static float[][] subMatrix(float[][] inputMat,
+                                  int[] rowIndices,
+                                  int columnStart,
+                                  int columnEnd)
+
+
Function to get a (2D) submatrix of a (2D) matrix (a copy, not a pointer). +

+

+
Parameters:
inputMat - input matrix
rowIndices - the row indices
columnStart - column to start at (inclusive)
columnEnd - column to end at (inclusive) +
Returns:
the submatrix containing a copy of the input matrix's specified rows from + columnStart to columnEnd; copy of A(rowIndices(:), columnStart:columnEnd). +
Throws: +
IllegalArgumentException - if the inputs are not within the inputMatrix size bounds.
+
+
+
+ +

+subMatrix

+
+public static float[][] subMatrix(float[][] inputMat,
+                                  int rowStart,
+                                  int rowEnd,
+                                  int[] columnIndices)
+
+
Function to get a (2D) submatrix of a (2D) matrix (a copy, not a pointer). +

+

+
Parameters:
inputMat - input matrix
rowStart - row to start at (inclusive)
rowEnd - column to end at (inclusive)
columnIndices - the column indices +
Returns:
the submatrix containing the specified rows, and going from the original matrices + rowStart to rowEnd columns; copy of A(rowIndices(:), columnStart:columnEnd). +
Throws: +
IllegalArgumentException - if the inputs are not within the inputMatrix size bounds.
+
+
+
+ +

+subMatrix

+
+public static float[][] subMatrix(float[][] inputMat,
+                                  int[] rowIndices,
+                                  int[] columnIndices)
+
+
Function to get a (2D) submatrix of a (2D) matrix (a copy, not a pointer). +

+

+
Parameters:
inputMat - input matrix
rowIndices - the row indices
columnIndices - the column indices +
Returns:
the submatrix containing the specified rows, and going from the original matrices + rowStart to rowEnd columns; copy of A(rowIndices(:), columnStart:columnEnd). +
Throws: +
IllegalArgumentException - if the inputs are not within the inputMatrix size bounds.
+
+
+
+ +

+subMatrix

+
+public static int[][] subMatrix(int[][] inputMat,
+                                int[] rowIndices,
+                                int[] columnIndices)
+
+
+
+
+
+
+ +

+subtract

+
+public static float[] subtract(float[] x,
+                               float[] y)
+
+
Returns the array z = x-y where each element of z[i] = x[i] - y[i] +

+

+
+
+
+
+ +

+subtract

+
+public static float[][] subtract(float[][] x,
+                                 float[][] y)
+
+
Returns the matrix z = x-y where each element of z[i][j] = x[i][j] - y[i][j] +

+

+
+
+
+
+ +

+sum

+
+public static float sum(float[] data)
+
+
Returns the sum of a data sequence. + That is Sum( data[i] ). +

+

+
+
+
+
+ +

+sum

+
+public static float[] sum(float[] data1,
+                          float[] data2)
+
+
Returns the sum of two data sequences. + That is Sum( data[i] ). +

+

+
+
+
+
+ +

+sum

+
+public static float[] sum(float[] data,
+                          float number)
+
+
Sum of an array with a number. That is + Sum( data[i] + number). +

+

+ +
Returns:
array with each element equal to data[i] + number
+
+
+
+ +

+sum

+
+public static int sum(int[] data)
+
+
Returns the sum of a data sequence. + That is Sum( data[i] ). +

+

+
+
+
+
+ +

+sum

+
+public static int[] sum(int[] data1,
+                        int[] data2)
+
+
Returns the sum of two data sequences. + That is Sum( data[i] ). +

+

+
+
+
+
+ +

+sum

+
+public static int[] sum(int[] data,
+                        int number)
+
+
Sum of an array with a number. That is + Sum( data[i] + number). +

+

+ +
Returns:
array with each element equal to data[i] + number
+
+
+
+ +

+sum

+
+public static float[][] sum(float[][] x,
+                            float[][] y)
+
+
Returns the matrix z = x+y where each element of z[i][j] = x[i][j] + y[i][j] +

+

+
+
+
+
+ +

+swap

+
+public static void swap(float[] data,
+                        int oldIndex,
+                        int newIndex)
+
+
Swap function that swaps the values in an array +

+

+
Parameters:
data - is an array of floats
oldIndex -
newIndex - e.g. data[newIndex,oldIndex] = data[oldIndex,newIndex]
+
+
+
+ +

+swap

+
+public static void swap(int[] data,
+                        int oldIndex,
+                        int newIndex)
+
+
Swap function that swaps the values in an array (overload function) +

+

+
Parameters:
data - is an array of integers
oldIndex -
newIndex - e.g. data[newIndex,oldIndex] = data[oldIndex,newIndex]
+
+
+
+ +

+symmetric

+
+public static float[][] symmetric(float[][] data)
+
+
Returns the symmetric part of the input matrix ((A+A')/2). +

+

+
+
+
+
+ +

+skewSymmetric

+
+public static float[][] skewSymmetric(float[][] data)
+
+
Returns the skew symmetric part of the input matrix ((A-A')/2). +

+

+
+
+
+
+ +

+trace

+
+public static float trace(float[][] data)
+
+
Returns the matrix trace or sum of the diagonal elements. +

+

+
+
+
+
+ +

+transpose

+
+public static float[][] transpose(float[][] data)
+
+
Returns the transpose of the input matrix. +

+

+
+
+
+
+ +

+transpose

+
+public static int[][] transpose(int[][] data)
+
+
+ +
Returns:
the transpose of the input matrix
+
+
+
+ +

+within

+
+public static boolean within(float number,
+                             float min,
+                             float max)
+
+
Checks to see if a number is in the range specified by [min,max]. + Returns true if min ≤ number ≤ max). +

+

+
Parameters:
min - left-most limit (inclusive)
max - right-most limit (inclusive)
number - the value to check for. +
Returns:
true if the number is within the bounds, else false
+
+
+
+ +

+within

+
+public static float[] within(float[] numbers,
+                             float min,
+                             float max)
+
+
returns an array containing all numbers within the min and max (inclusive). + If nothing is within the min and max, an array of length 1 with the first element = -1 is returned +

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/NaNs.html b/drawing/papaya/reference/papaya/NaNs.html new file mode 100644 index 0000000..2c83fb3 --- /dev/null +++ b/drawing/papaya/reference/papaya/NaNs.html @@ -0,0 +1,447 @@ + + + + + + +NaNs (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class NaNs

+
+java.lang.Object
+  extended by papaya.NaNs
+
+
+
+
public final class NaNs
extends Object
+ + +

+

Contains various methods for dealing with NaNs in your data.

+ Currently only accommodates float and double arrays. Java's Integer.isNaN doesn't + seem to exist or I'd include that as well. +

+ +

+

+
Author:
+
Adila Faruk
+
+
+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static booleancontainsNaNs(double[] data) + +
+          Checks for presence of NaNs in the data array.
+static booleancontainsNaNs(float[] data) + +
+          Checks for presence of NaNs in the data array.
+static double[]eliminate(double[] data) + +
+          Eliminate the NaNs from the input array.
+static float[]eliminate(float[] data) + +
+          Eliminate the NaNs from the input array.
+static ArrayList<Integer>getNaNPositions(double[] data) + +
+          Returns an array list of indexes where data[i] is NaN.
+static ArrayList<Integer>getNaNPositions(float[] data) + +
+          Returns an array list of indexes where data[i] is NaN.
+static double[]replaceNewWith(double[] data, + double newNaN) + +
+          Returns a new array with NaN elements in the original data set replaced with the value + specified by newNaN.
+static float[]replaceNewWith(float[] data, + float newNaN) + +
+          Returns a new array with NaN elements in the original data set replaced with the value + specified by newNaN.
+static voidreplaceOriginalWith(double[] data, + double newNaN) + +
+          Modifies the original data array by replacing the NaN elements in the data set with the value + specified by newNaN.
+static voidreplaceOriginalWith(float[] data, + float newNaN) + +
+          Modifies the original data array by replacing the NaN elements in the data set with the value + specified by newNaN.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+eliminate

+
+public static double[] eliminate(double[] data)
+
+
Eliminate the NaNs from the input array. +

+

+
Parameters:
data - the array containing NaNs +
Returns:
the new array (with length < data.length) devoid + of NaNs.
+
+
+
+ +

+replaceNewWith

+
+public static double[] replaceNewWith(double[] data,
+                                      double newNaN)
+
+
Returns a new array with NaN elements in the original data set replaced with the value + specified by newNaN. +

+

+
Parameters:
data - the array containing NaNs
newNaN - the value to replace the NaNs with. +
Returns:
new array with NaNs replaced with the values specified by newNaN.
+
+
+
+ +

+replaceOriginalWith

+
+public static void replaceOriginalWith(double[] data,
+                                       double newNaN)
+
+
Modifies the original data array by replacing the NaN elements in the data set with the value + specified by newNaN. +

+

+
Parameters:
data - the array containing NaNs
newNaN - the value to replace the NaNs with.
+
+
+
+ +

+containsNaNs

+
+public static boolean containsNaNs(double[] data)
+
+
Checks for presence of NaNs in the data array. +

+

+
Parameters:
data - array to be searched for NaNs +
Returns:
true iff ranks contains one or more NaNs
+
+
+
+ +

+getNaNPositions

+
+public static ArrayList<Integer> getNaNPositions(double[] data)
+
+
Returns an array list of indexes where data[i] is NaN. +

+

+
Parameters:
data - array to search for NaNs +
Returns:
list of indexes i such that data[i] = NaN
+
+
+
+ +

+eliminate

+
+public static float[] eliminate(float[] data)
+
+
Eliminate the NaNs from the input array. +

+

+
Parameters:
data - the array containing NaNs +
Returns:
the new array (with length < data.length) devoid + of NaNs.
+
+
+
+ +

+replaceNewWith

+
+public static float[] replaceNewWith(float[] data,
+                                     float newNaN)
+
+
Returns a new array with NaN elements in the original data set replaced with the value + specified by newNaN. +

+

+
Parameters:
data - the array containing NaNs
newNaN - the value to replace the NaNs with. +
Returns:
new array with NaNs replaced with the values specified by newNaN.
+
+
+
+ +

+replaceOriginalWith

+
+public static void replaceOriginalWith(float[] data,
+                                       float newNaN)
+
+
Modifies the original data array by replacing the NaN elements in the data set with the value + specified by newNaN. +

+

+
Parameters:
data - the array containing NaNs
newNaN - the value to replace the NaNs with.
+
+
+
+ +

+containsNaNs

+
+public static boolean containsNaNs(float[] data)
+
+
Checks for presence of NaNs in the data array. +

+

+
Parameters:
data - array to be searched for NaNs +
Returns:
true iff ranks contains one or more NaNs
+
+
+
+ +

+getNaNPositions

+
+public static ArrayList<Integer> getNaNPositions(float[] data)
+
+
Returns an array list of indexes where data[i] is NaN. +

+

+
Parameters:
data - array to search for NaNs +
Returns:
list of indexes i such that data[i] = NaN
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Normality.Dago.html b/drawing/papaya/reference/papaya/Normality.Dago.html new file mode 100644 index 0000000..b56d605 --- /dev/null +++ b/drawing/papaya/reference/papaya/Normality.Dago.html @@ -0,0 +1,373 @@ + + + + + + +Normality.Dago (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Normality.Dago

+
+java.lang.Object
+  extended by papaya.Normality.Dago
+
+
+
Enclosing class:
Normality
+
+
+
+
public static class Normality.Dago
extends Object
+ + +

+Methods for computing the skewnewss, kurtosis, and D'Agostino-Peasrson K^2 "omnibus" test-statistics (that + combine the former two), and accompanying significance (or p-values) + for testing the underlying population normality. + +

Implementation: + +
Let mk denote the kth moment, + mk = ∑_(i=1 to n)(x_i - mean(x))/n. Then, we can define the following: +
Sample estimate of the third standardized moment: b1 = m3/(m2)^(3/2)
+
Sample estimate of the fourth standardized moment: b2 = m4/m2
+
The test statistics Z(b1), Z(b2) are approximately normally distributed under + the null hypothesis of population normality. Both Z(b1) and Z(b2) can be used to + test one-sided and two-sided alternative hypothesis. + +

+ D'Agostino and Pearson (1973) also introduced the following "omnibus" test statistic, +
K^2 = (Z(b1))^2 + (Z(b2))^2,
+ which is able to detect deviations from normality due to either skewness or kurtosis + This K^2 statistic has an approximately Chi-Squared distribution with 2 degrees of + freedom when the population is normally distributed. + Similar to Z(b1) and Z(b2), K^2 can be used to test one-sided and two-sided alternative hypothesis. + +

Requirements +
data set has to have more than 20 elements. An error is thrown otherwise since the normal + approximation is no longer valid (technically, the it is valid for Zb1, as long as n > 8, but + since we're computing everything, the requirement has been set a little higher. + +

Remarks: +

    +
  • + The normal approximation for the zb1 is only valid for sample sizes > 8. For smaller sample sizes, + it is suggested that you consult a look-up table. Likewise, the normal approximation for the +
  • + b1 and b2 differ from the Fisher g statistic parameters g1 + and g2 used in SAS, and SPSS but they are related by a linear transformation (see + cited paper for details). +
  • + For users familiar with the R software package, this class is analogous to the + R's dagoTest class in the fBasics library albeit with some implementation. +
+

+ References: +
D'Agostino, R., Albert Belanger, A., D'Agostino Jr, R., 1990 + A Suggestion for Using Powerful and Informative Tests of Normality + +
D?Agostino, R., Pearson, E., 1973. Tests for departures from normality. + Empirical results for the distribution of b1 and b2.Biometrika 60, 613?622. +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static float[]chi2(float[] data) + +
+          Computes and returns an array containing the test statistic chi2, or the + "omnibus" test statistic, and the significance, or "p-value" of this test statistic.
+static float[]kurtosis(float[] data) + +
+          Computes and returns an array containing the test statistic zb2associated with + b2 and the significance, or "p-value" of the kurtosis test statistic zb2, assuming a + two-tailed null hypothesis as well as .
+static float[]pValues(float[] data) + +
+          Returns an array containing the three significance, or p-values, for testing normality.
+static float[]skew(float[] data) + +
+          Computes and returns an array containing the test statistic zb1associated with sqrt(b1) and + the significance, or "p-value" of the skew test statistic zb1, assuming a + two-tailed null hypothesis as well as .
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+skew

+
+public static float[] skew(float[] data)
+
+
Computes and returns an array containing the test statistic zb1associated with sqrt(b1) and + the significance, or "p-value" of the skew test statistic zb1, assuming a + two-tailed null hypothesis as well as . The first element of the output array is the + test statistic zb1 associated with sqrt(b1) = m3/m2^(3/2) where mk is + the kth momement as specified in Descriptive.moment(float[], int, float) and the second element is + the p-value for the two-tailed null hypothesis with + 
+ pValueSkew = 2* ( 1-Probability.normcdf( zb1 ) ).
+
+ (D'Agostino et al. (1990)) . +

+

+
+
+
+
+ +

+kurtosis

+
+public static float[] kurtosis(float[] data)
+
+
Computes and returns an array containing the test statistic zb2associated with + b2 and the significance, or "p-value" of the kurtosis test statistic zb2, assuming a + two-tailed null hypothesis as well as . The first element of the output array is the + test statistic zb2 associated with b2 = m4/m2^2 where mk is + the kth momement as specified in Descriptive.moment(float[], int, float). and the second element is + the p-value for the two-tailed null hypothesis with + 
+ pValueKurtosis = 2* ( 1-Probability.normcdf( zb2 ) ).
+
+ (D'Agostino et al. (1990)) . +

+

+
+
+
+
+ +

+chi2

+
+public static float[] chi2(float[] data)
+
+
Computes and returns an array containing the test statistic chi2, or the + "omnibus" test statistic, and the significance, or "p-value" of this test statistic. + The first element of the output array is the test statistic the ombibus test + statistic chi2 and the second element is + the p-value: + 
+ pValueChiSquared = ( 1-Probability.chi2cdf( chi2 ) ).
+
+ (D'Agostino et al. (1990)) . +

+

+
+
+
+
+ +

+pValues

+
+public static float[] pValues(float[] data)
+
+
Returns an array containing the three significance, or p-values, for testing normality. + The first element corresponds to the p-value associated with D'Agostino's Chi-Squared + test statistic (or omnibus test, chi2(float[])), the second corresponds to D'Agostino's + skew test (skew(float[])), and the + third corresponds to D'Agostino's kurtosis test (kurtosis(float[])). +

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Normality.html b/drawing/papaya/reference/papaya/Normality.html new file mode 100644 index 0000000..a3291d3 --- /dev/null +++ b/drawing/papaya/reference/papaya/Normality.html @@ -0,0 +1,289 @@ + + + + + + +Normality (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Normality

+
+java.lang.Object
+  extended by papaya.Normality
+
+
+
All Implemented Interfaces:
PapayaConstants
+
+
+
+
public class Normality
extends Object
implements PapayaConstants
+ + +

+Contains various utilities for checking if the dataset comes from a normal distribution. +

+ +

+

+ +

+ + + + + + + + + + + +
+Nested Class Summary
+static classNormality.Dago + +
+          Methods for computing the skewnewss, kurtosis, and D'Agostino-Peasrson K^2 "omnibus" test-statistics (that + combine the former two), and accompanying significance (or p-values) + for testing the underlying population normality.
+  + + + + + + +
+Field Summary
+  + + + + + + + +
Fields inherited from interface papaya.PapayaConstants
BASELINE, big, biginv, BOTTOM, CENTER, CORNER, FONTNAME, GRAY, INDEX_NOT_FOUND, INDICES_NOT_FOUND, LEFT, LOGPI, MACHEP, MAXGAM, MAXLOG, MINLOG, RIGHT, SQRTH, SQTPI, STROKEWEIGHT, TEXTSIZE, TOP
+  + + + + + + + + + + + +
+Method Summary
+static float[]normalProbability(float[] data) + +
+          Return the Normal order statistic medians (N) necessary to produce a Q-Q plot + for a normal distribution (or normal probability plot).
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+normalProbability

+
+public static float[] normalProbability(float[] data)
+
+
Return the Normal order statistic medians (N) necessary to produce a Q-Q plot + for a normal distribution (or normal probability plot). + That is, given a data array, this method computes the Normal order statistic medians + and the ordered response values or z-scores of the input. + A plot of the N vs z should form an approximate straight line if the + data is normally distributed; + departures from this straight line indicate departures from normality with the shape of the line + providing clues as to the distribution of the data. +

+ The normal order statistic medians are computed as +
N[i] = Probability.norminv(U[i]) + where U[i] are the uniform order statistic medians, given by +

    +
    U[i] = 1 - U(n) for i = 1 +
    U[i] = (i - 0.3175)/(n + 0.365) for i = 2, 3, ..., n-1 +
    U[i] = 0.5^(1/n) for i = n +
+

Reference: + NIST/SEMATECH e-Handbook of Statistical Methods, EDA Section 1.3.3.21: Normal Probability Plots +

+

+
+
+
+
Parameters:
data - the data array +
Returns:
the Normal order statistic medians
See Also:
Descriptive.zScore(float[],float,float)
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/OneWayAnova.html b/drawing/papaya/reference/papaya/OneWayAnova.html new file mode 100644 index 0000000..e23cef2 --- /dev/null +++ b/drawing/papaya/reference/papaya/OneWayAnova.html @@ -0,0 +1,441 @@ + + + + + + +OneWayAnova (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class OneWayAnova

+
+java.lang.Object
+  extended by papaya.OneWayAnova
+
+
+
+
public class OneWayAnova
extends Object
+ + +

+Computes the one-way ANOVA p-value to test the equality of two or more sample + means by analyzing the sample variances using the test statistic + F = variance between samples / variance within samples. + Once initialized, the following values are computed and stored: +

    +
  • dfbg: degrees of freedom between the groups (dfbg()). +
  • ssbg: sum of squared deviates between the groups (ssbg()). +
  • dfwg: degrees of freedom within the groups, or "Error" dfs (dfwg()). +
  • sswg: sum of squared deviates within the groups (sswg()). +
  • F: the test statistic, computed as (ssbg/dfbg) / (sswg/dfwg) (F()). +
  • pValue: the p-value, or significance level, corresponding to a two-tailed + null hypothesis of no difference between the samples (pValue()). +
+ +

Preconditions:

    +
  • The categoryData Collection must contain + float[] arrays.
    • +
  • There must be at least two float[] arrays in the + categoryData collection and each of these arrays must + contain at least two values.

+ +

This implementation is based on a description provided in Chapter 13 of the VassarStats + online textbook + Mean values are not computed directly in the algorithm as this tends to cause round-off error. + Rather, we use the more stable SumOfSquares - Sum^2: + 

+ Sum_(i=1 to n) (x_i - mean(x) )^2 = Sum_(i=1 to n)(x_i)^2 - (Sum_(i=1 to n) x_i)^2/n.
+
+

+

+ +

+

+ +

+ + + + + + + + + + + +
+Constructor Summary
OneWayAnova(Collection<float[]> categoryData) + +
+          Performs an Analysis of Variance (ANOVA) for a collection of float arrays.
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ intdfbg() + +
+          Returns the degrees of freedom between groups.
+ intdfwg() + +
+          Returns the degrees of freedom within each group.
+ floatetasqrd() + +
+          Computes eta^2: a measure of the strength of the curvilinear relationship + between the independent and dependent variable.
+ floatF() + +
+          Returns the test statistic F.
+ floatpValue() + +
+          Returns the significance, or "p-value" of the test statistic F().
+ floatssbg() + +
+          Returns the sum of squared deviates between each group.
+ floatsswg() + +
+          Returns the sum of squared deviates of the data within each group.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+OneWayAnova

+
+public OneWayAnova(Collection<float[]> categoryData)
+
+
Performs an Analysis of Variance (ANOVA) for a collection of float arrays. +

+

+
Parameters:
categoryData - the data coresponding to the different groups
See Also:
Collection
+
+ + + + + + + + +
+Method Detail
+ +

+etasqrd

+
+public float etasqrd()
+
+
Computes eta^2: a measure of the strength of the curvilinear relationship + between the independent and dependent variable. Useful in the context of + one-way ANOVAs of independent samples. For example, the independent + variable could be the amount of papaya consumed by 4 different groups + (0, 1, 2, or 3 papayas/dar) and the dependent variable could be a measurement of their + satisfaction with life. +

+

+
+
+
+
+ +

+dfbg

+
+public int dfbg()
+
+
Returns the degrees of freedom between groups. That is, + if there are k groups, dfbg = k-1; +

+

+
+
+
+
+ +

+dfwg

+
+public int dfwg()
+
+
Returns the degrees of freedom within each group. That is, + if there are k groups, and each have got n_i elements, + dfwg = (n_1-1) + (n_2 -1) + ... + (n_k - 1); +

+

+
+
+
+
+ +

+F

+
+public float F()
+
+
Returns the test statistic F. That is, + 
 
+ F = (ssbg/dfbg) / (sswg/dfwg);
+
+

+

+
+
+
+
+ +

+pValue

+
+public float pValue()
+
+
Returns the significance, or "p-value" of the test statistic F(). + That is, + 
 
+ p = 1 - Probability.fcdf(F,dfbg,dfwg);
+
+

+

+
+
+
+
+ +

+sswg

+
+public float sswg()
+
+
Returns the sum of squared deviates of the data within each group. That is, + if there are k groups, and each have got n_i elements, + 
+ sswg = Sum_(i=1 to n1) (xi1-mean(x1))^2 + Sum_(i=1 to n2) (xi2-mean(xk))^2 + ... + Sum_(i=1 to nk) (xik-mean(xk))^2;
+
+

+

+
+
+
+
+ +

+ssbg

+
+public float ssbg()
+
+
Returns the sum of squared deviates between each group. That is, + if there are k groups, each with mean value y_i, then + 
+ ssbg = Sum_(i=1 to k) (y_i)-mean(y))
+
+

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/PapayaConstants.html b/drawing/papaya/reference/papaya/PapayaConstants.html new file mode 100644 index 0000000..ef05b0c --- /dev/null +++ b/drawing/papaya/reference/papaya/PapayaConstants.html @@ -0,0 +1,602 @@ + + + + + + +PapayaConstants (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Interface PapayaConstants

+
+
All Known Implementing Classes:
BoxPlot, Comparison, Correlation, CorrelationPlot, Find, Gamma, Linear, Normality, Probability, ScatterPlot, SubPlot, Visuals
+
+
+
+
public interface PapayaConstants
+ + +

+PapayaConstants stores some of the constants used in plotting. + I try to follow processing's conventions where possible + as specified in processing.core.PConstants + The Processing Javadoc has more details. +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Field Summary
+static intBASELINE + +
+           
+static doublebig + +
+           
+static doublebiginv + +
+           
+static intBOTTOM + +
+           
+static intCENTER + +
+           
+static intCORNER + +
+           
+static StringFONTNAME + +
+          Default font used.
+static int[]GRAY + +
+           
+static intINDEX_NOT_FOUND + +
+          Index to return if a given value/object is not found in the Cast function.
+static int[]INDICES_NOT_FOUND + +
+          Index array to return if a given value/object is not found in the Cast function.
+static intLEFT + +
+           
+static doubleLOGPI + +
+           
+static doubleMACHEP + +
+          machine constants
+static doubleMAXGAM + +
+           
+static doubleMAXLOG + +
+           
+static doubleMINLOG + +
+           
+static intRIGHT + +
+           
+static doubleSQRTH + +
+           
+static doubleSQTPI + +
+           
+static float[]STROKEWEIGHT + +
+           
+static int[]TEXTSIZE + +
+           
+static intTOP + +
+           
+  +

+ + + + + + + + +
+Field Detail
+ +

+BASELINE

+
+static final int BASELINE
+
+
+
See Also:
Constant Field Values
+
+
+ +

+CORNER

+
+static final int CORNER
+
+
+
See Also:
Constant Field Values
+
+
+ +

+BOTTOM

+
+static final int BOTTOM
+
+
+
See Also:
Constant Field Values
+
+
+ +

+CENTER

+
+static final int CENTER
+
+
+
See Also:
Constant Field Values
+
+
+ +

+LEFT

+
+static final int LEFT
+
+
+
See Also:
Constant Field Values
+
+
+ +

+TOP

+
+static final int TOP
+
+
+
See Also:
Constant Field Values
+
+
+ +

+RIGHT

+
+static final int RIGHT
+
+
+
See Also:
Constant Field Values
+
+
+ +

+FONTNAME

+
+static final String FONTNAME
+
+
Default font used. +

+

+
See Also:
Constant Field Values
+
+
+ +

+STROKEWEIGHT

+
+static final float[] STROKEWEIGHT
+
+
+
+
+
+ +

+GRAY

+
+static final int[] GRAY
+
+
+
+
+
+ +

+TEXTSIZE

+
+static final int[] TEXTSIZE
+
+
+
+
+
+ +

+INDEX_NOT_FOUND

+
+static final int INDEX_NOT_FOUND
+
+
Index to return if a given value/object is not found in the Cast function. +

+

+
See Also:
Constant Field Values
+
+
+ +

+INDICES_NOT_FOUND

+
+static final int[] INDICES_NOT_FOUND
+
+
Index array to return if a given value/object is not found in the Cast function. +

+

+
+
+
+ +

+MACHEP

+
+static final double MACHEP
+
+
machine constants +

+

+
See Also:
Constant Field Values
+
+
+ +

+MAXLOG

+
+static final double MAXLOG
+
+
+
See Also:
Constant Field Values
+
+
+ +

+MINLOG

+
+static final double MINLOG
+
+
+
See Also:
Constant Field Values
+
+
+ +

+MAXGAM

+
+static final double MAXGAM
+
+
+
See Also:
Constant Field Values
+
+
+ +

+SQTPI

+
+static final double SQTPI
+
+
+
See Also:
Constant Field Values
+
+
+ +

+SQRTH

+
+static final double SQRTH
+
+
+
See Also:
Constant Field Values
+
+
+ +

+LOGPI

+
+static final double LOGPI
+
+
+
See Also:
Constant Field Values
+
+
+ +

+big

+
+static final double big
+
+
+
See Also:
Constant Field Values
+
+
+ +

+biginv

+
+static final double biginv
+
+
+
See Also:
Constant Field Values
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Polynomial.html b/drawing/papaya/reference/papaya/Polynomial.html new file mode 100644 index 0000000..c1d7f79 --- /dev/null +++ b/drawing/papaya/reference/papaya/Polynomial.html @@ -0,0 +1,347 @@ + + + + + + +Polynomial (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Polynomial

+
+java.lang.Object
+  extended by papaya.Polynomial
+
+
+
+
public final class Polynomial
extends Object
+ + +

+Static Class for casting one variable type to another. +

+ +

+

+
Author:
+
Nur Adila Faruk Senan
+
+
+ +

+ + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static double[]polyval(double[] x, + double[] coeff) + +
+          y = polyval(x,coeff) returns the array values of a polynomial of degree n evaluated at + each element of x.
+static doublepolyval(double x, + double[] coeff) + +
+          y = polyval(x,coeff) returns the value of a polynomial of degree n evaluated at x.
+static float[]polyval(float[] x, + float[] coeff) + +
+          y = polyval(x,coeff) returns the value of a polynomial of degree n evaluated at x.
+static floatpolyval(float x, + float[] coeff) + +
+          y = polyval(x,coeff) returns the value of a polynomial of degree n evaluated at x.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+polyval

+
+public static double polyval(double x,
+                             double[] coeff)
+                      throws ArithmeticException
+
+
y = polyval(x,coeff) returns the value of a polynomial of degree n evaluated at x. + The input argument coeff is an array of length n+1 whose elements are the coefficients + in descending powers of the polynomial to be evaluated. +

+ y = coeff[0]*x^n + coeff[1]*x^(n-1) + .... + coeff[n-1]*x + coeff[n]. +

+

+ E.g. for a quadratic function, y = coeff[0]*x^2 + coeff[1]*x + coeff[2]. +

+

+

+
Parameters:
x - argument to the polynomial.
coeff - the coefficients of the polynomial. +
Throws: +
ArithmeticException
+
+
+
+ +

+polyval

+
+public static double[] polyval(double[] x,
+                               double[] coeff)
+                        throws ArithmeticException
+
+
y = polyval(x,coeff) returns the array values of a polynomial of degree n evaluated at + each element of x. + The input argument coeff is an array of length n+1 whose elements are the coefficients + in descending powers of the polynomial to be evaluated. +

+ y = coeff[0]*x^n + coeff[1]*x^(n-1) + .... + coeff[n-1]*x + coeff[n]. +

+

+ E.g. for a quadratic function, y = coeff[0]*x^2 + coeff[1]*x + coeff[2]. +

+

+

+
Parameters:
x - array argument to the polynomial.
coeff - the coefficients of the polynomial. +
Throws: +
ArithmeticException
+
+
+
+ +

+polyval

+
+public static float polyval(float x,
+                            float[] coeff)
+                     throws ArithmeticException
+
+
y = polyval(x,coeff) returns the value of a polynomial of degree n evaluated at x. + The input argument coeff is an array of length n+1 whose elements are the coefficients + in descending powers of the polynomial to be evaluated. +

+ y = coeff[0]*x^n + coeff[1]*x^(n-1) + .... + coeff[n-1]*x + coeff[n]. +

+

+ E.g. for a quadratic function, y = coeff[0]*x^2 + coeff[1]*x + coeff[2]. +

+

+

+
Parameters:
x - argument to the polynomial.
coeff - the coefficients of the polynomial. +
Throws: +
ArithmeticException
+
+
+
+ +

+polyval

+
+public static float[] polyval(float[] x,
+                              float[] coeff)
+                       throws ArithmeticException
+
+
y = polyval(x,coeff) returns the value of a polynomial of degree n evaluated at x. + The input argument coeff is an array of length n+1 whose elements are the coefficients + in descending powers of the polynomial to be evaluated. +

+ y = coeff[0]*x^n + coeff[1]*x^(n-1) + .... + coeff[n-1]*x + coeff[n]. +

+

+ E.g. for a quadratic function, y = coeff[0]*x^2 + coeff[1]*x + coeff[2]. +

+

+

+
Parameters:
x - array argument to the polynomial.
coeff - the coefficients of the polynomial. +
Throws: +
ArithmeticException
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Probability.html b/drawing/papaya/reference/papaya/Probability.html new file mode 100644 index 0000000..4646e21 --- /dev/null +++ b/drawing/papaya/reference/papaya/Probability.html @@ -0,0 +1,1262 @@ + + + + + + +Probability (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Probability

+
+java.lang.Object
+  extended by papaya.Probability
+
+
+
All Implemented Interfaces:
PapayaConstants
+
+
+
+
public class Probability
extends Object
implements PapayaConstants
+ + +

+Cumulative distribution functions and corresponding inverses of certain probability distributions. +

+ Description: +
...cdf signifies the cumulative distribution function and is similar to + the q... functions in R and the ...cdf functions in + MATLAB. The cdf represent the integral, from -infinity to 0 of the + corresponding continuous probability density function (pdf), or, the sum from 0 to x + of an associated finite pdf.
+ +
...inv signifies the inverse of the cumulative distribution function and is similar to + the p... functions in R and the ...inv functions in + MATLAB.
+ +

Implementation: +

    +
  • Direct application examples: +
    normcdf(1.96) = 0.975 --> 97.5% of the curve is within +/-1.96 of 0. +
    norminv(0.975) = 1.96 --> finds the point x (=1.96) such that normcdf(x) = .975. +
    norminv( normcdf(x) ) = x +
  • Significance tests: +
    Two-tailed significance test with alpha = 0.05 and H_0: μ=0 + --> p = 1-alpha/2 = 0.975 + --> Reject null hypothesis μ=0 if + the test statistic is greater or less than than +/-1.96 (= +/- norminv(p) ). + +
    One-tailed significance test with alpha = 0.05 and H_0: μ < 0 + --> p = 1-alpha = 0.95 + --> Reject null hypothesis μ < 0 if + the test statistic is greater than 1.645 (= norminv(p) ). +
    One-tailed significance test with alpha = 0.05 and H_0: μ > 0 + --> p = 1-alpha = 0.95 + --> Reject null hypothesis μ > 0 if + the test statistic is less than -1.645 (= -norminv(p) ). +
+

+ + + The code is partially adapted from the CERN Jet Java libraries, which in turn was adapted from the + Cephes Mathematical Library. As far a as I can tell, Stephen L. Moshier wrote the original C++ code for + CEPHES (1989, moshier@na-net.ornl.gov), Gedeck (at Novartis) and Wolfgang Hoschek (at CERN, hats off to you mate!) + then adapted it for the Java platform, making some significant changes along the way. +
+ 2012 rolls along, and Adila (hello!) finds the library and makes even more changes, increasing the + probability (ha.ha.) of things going massively wrong (pValue<.0001). +

+ +

+

+ +

+ + + + + + + +
+Field Summary
+  + + + + + + + +
Fields inherited from interface papaya.PapayaConstants
BASELINE, big, biginv, BOTTOM, CENTER, CORNER, FONTNAME, GRAY, INDEX_NOT_FOUND, INDICES_NOT_FOUND, LEFT, LOGPI, MACHEP, MAXGAM, MAXLOG, MINLOG, RIGHT, SQRTH, SQTPI, STROKEWEIGHT, TEXTSIZE, TOP
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static doublebetacdf(double x, + double a, + double b) + +
+          Returns the area from zero to x under the beta density + function.
+static doublebetacdfComplemented(double x, + double a, + double b) + +
+          Returns the area under the right hand tail (from x to + infinity) of the beta density function.
+static doublebetainv(double p, + double a, + double b) + +
+          Returns the inverse of the beta cumulative distribution function.
+static doublebinomcdf(double p, + int k, + int n) + +
+          Returns the sum of the terms 0 through k of the Binomial + probability density.
+static doublebinomcdfComplemented(double p, + int k, + int n) + +
+          Returns the sum of the terms k+1 through n of the Binomial + probability density.
+static doublebinominv(double y, + int k, + int n) + +
+          Finds the event probability p such that the sum of the + terms 0 through k of the Binomial probability density + is equal to the given cumulative probability y.
+static doublechi2cdf(double x, + double v) + +
+          Returns the area under the left hand tail (from 0 to x) + of the Chi square probability density function with + v degrees of freedom.
+static doublechi2cdfComplemented(double x, + double v) + +
+          Returns the area under the right hand tail (from x to + infinity) of the Chi square probability density function + with v degrees of freedom.
+static doubleerf(double x) + +
+          Returns the error function of the normal distribution.
+static doubleerfComplemented(double a) + +
+          Returns the complementary Error function of the normal distribution; formerly named erfc.
+static doublefcdf(double x, + int df1, + int df2) + +
+          Returns the area from zero to x under the F density + function (also known as Snedcor's density or the + variance ratio density); formerly named fdtr.
+static doublefcdfComplemented(double x, + int df1, + int df2) + +
+          Returns the area from x to infinity under the F density + function (also known as Snedcor's density or the + variance ratio density); formerly named fdtrc.
+static doublefinv(double p, + int df1, + int df2) + +
+          Finds the F density argument x such that the integral + from 0 to x of the F density is equal to p; formerly named fdtri.
+static doublegammacdf(double x, + double a, + double b) + +
+          Returns the integral from zero to x of the gamma probability + density function.
+static doublegammacdfComplemented(double x, + double a, + double b) + +
+          Returns the integral from x to infinity of the gamma + probability density function:
+static doublenbinomcdf(double p, + int k, + int n) + +
+          Returns the sum of the terms 0 through k of the Negative Binomial Distribution.
+static doublenbinomcdfComplemented(double p, + int k, + int n) + +
+          Returns the sum of the terms k+1 to infinity of the Negative + Binomial distribution.
+static doublenormcdf(double a) + +
+          Returns the area under the Normal (Gaussian) probability density + function, integrated from minus infinity to x (assumes mean is zero, variance is one).
+static doublenormcdf(double x, + double mean, + double variance) + +
+          Returns the area under the Normal (Gaussian) probability density + function, integrated from minus infinity to x when the + data has not been standardized (i.e.
+static doublenorminv(double y0) + +
+          Returns the value, x, for which the area under the + Normal (Gaussian) probability density function (integrated from + minus infinity to x) is equal to the argument y + (assumes mean is zero, variance is one); formerly named ndtri.
+static doublepoissoncdf(double mean, + int k) + +
+          Returns the sum of the first k terms of the Poisson distribution.
+static doublepoissoncdfComplemented(int k, + double mean) + +
+          Returns the sum of the terms k+1 to Infinity of the Poisson distribution.
+static doubletcdf(double t, + double k) + +
+          Returns the integral from minus infinity to t of the Student-t + distribution with k > 0 degrees of freedom.
+static doubletinv(double p, + double k) + +
+          Returns the value, t, for which the area under the + Student-t probability density function (integrated from + minus infinity to t) is equal to p.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+betacdf

+
+public static double betacdf(double x,
+                             double a,
+                             double b)
+
+
Returns the area from zero to x under the beta density + function. + 
+ 
+ P(x) = Γ(a+b) / [ Γ(a) * Γ(b)  ] * Integral_(0 to x) [  t^(a-1) * (1-t)^(b-1) ] dt
+
+
+ This function is identical to the incomplete beta + integral function + + Gamma.incompleteBeta(a, b, x). + + The complemented function is betacdfComplemented, specified by + + 1 - P(1-x) = Gamma.incompleteBeta( b, a, x ); +

+

+
+
+
+
+
+
+
+ +

+betacdfComplemented

+
+public static double betacdfComplemented(double x,
+                                         double a,
+                                         double b)
+
+
Returns the area under the right hand tail (from x to + infinity) of the beta density function. + + This function is identical to the incomplete beta + integral function Gamma.incompleteBeta(b, a, x). +

+

+
+
+
+
+
+
+
+ +

+betainv

+
+public static double betainv(double p,
+                             double a,
+                             double b)
+
+
Returns the inverse of the beta cumulative distribution function. + That is, given p, the function finds x such that + 
+  Gamma.incompleteBeta( a, b, x ) = beta(x, a, b) = p;
+
+ + This function is identical to the incomplete beta inverse + function Gamma.incompleteBetaInverse(aa, bb, yy0). +

+

+
+
+
+
Parameters:
a - the alpha parameter of the beta distribution.
b - the beta parameter of the beta distribution.
p - the value for which to solve for the corresponding x in the + incomplete Beta integral. +
Returns:
the value x such that beta( a, b, x ) = p.
+
+
+
+ +

+binomcdf

+
+public static double binomcdf(double p,
+                              int k,
+                              int n)
+
+
Returns the sum of the terms 0 through k of the Binomial + probability density. + 
+ 
+ Sum_(j=0 to k)  [ (n!)/(j!*(n-j)! ]  *  [ p^j * (1-p)^(n-j) ]
+
+
+ The terms are not summed directly; instead the incomplete + beta integral is employed, according to the formula +

+ y = binomcdf( p, k, n) = Gamma.incompleteBeta( n-k, k+1, 1-p ). +

+ All arguments must be positive, +

+

+
+
+
+
Parameters:
k - end term.
n - the number of trials.
p - the probability of success (must be in (0.0,1.0)).
+
+
+
+ +

+binomcdfComplemented

+
+public static double binomcdfComplemented(double p,
+                                          int k,
+                                          int n)
+
+
Returns the sum of the terms k+1 through n of the Binomial + probability density. + 
+ 
+ Sum_(j=k+1 to n)  [ (n!)/(j!*(n-j)! ]  *  [ p^j * (1-p)^(n-j) ]
+
+
+ The terms are not summed directly; instead the incomplete + beta integral is employed, according to the formula +

+ y = binomcdfComplemented( p, k, n ) = Gamma.incompleteBeta( k+1, n-k, p ). +

+ All arguments must be positive, +

+

+
+
+
+
Parameters:
k - (start-1) term.
n - the number of trials.
p - the probability of success (must be in (0.0,1.0)).
+
+
+
+ +

+binominv

+
+public static double binominv(double y,
+                              int k,
+                              int n)
+
+
Finds the event probability p such that the sum of the + terms 0 through k of the Binomial probability density + is equal to the given cumulative probability y. That is, +
+ binomcdf( p, k, n ) = y;
+
+ This is accomplished using the inverse beta integral + function and the relation +

+ 1 - p = Gamma.incompleteBetaInverse( n-k, k+1, y ). +

+ All arguments must be positive. +

+

+
+
+
+
Parameters:
k - end term.
n - the number of trials.
y - the value to solve for such that binomcdf( p, k, n ) = y.
+
+
+
+ +

+chi2cdf

+
+public static double chi2cdf(double x,
+                             double v)
+                      throws ArithmeticException
+
+
Returns the area under the left hand tail (from 0 to x) + of the Chi square probability density function with + v degrees of freedom. + 
+ 
+ P( x | v ) = 1/ [ 2^(v/2) * Γ(v/2)  ] * Integral_(from 0 to x) [ t^(v/2-1) * e^(-t/2) ] dt
+                                  
+
+ where x is the Chi-square variable. +

+ The incomplete gamma integral is used, according to the + formula +

+ y = chi2cdf( x, v ) = Gamma.incompleteGamma( v/2.0, x/2.0 ). +

+ The arguments must both be positive. +

+

+
+
+
+
Parameters:
v - degrees of freedom.
x - integration end point. +
Throws: +
ArithmeticException
+
+
+
+ +

+chi2cdfComplemented

+
+public static double chi2cdfComplemented(double x,
+                                         double v)
+                                  throws ArithmeticException
+
+
Returns the area under the right hand tail (from x to + infinity) of the Chi square probability density function + with v degrees of freedom. + 
+ 
+ P( x | v ) = 1/ [ 2^(v/2) * Γ(v/2)  ] * Integral_(from x to infinity) [ t^(v/2-1) * e^(-t/2) ] dt
+
+
+ where x is the Chi-square variable. + + The incomplete gamma integral is used, according to the + formula + + y = chi2cdfComplemented( x, v ) = incompleteGammaComplement( v/2.0, x/2.0 ). + + The arguments must both be positive. +

+

+
+
+
+
Parameters:
v - degrees of freedom.
x - integration start point. +
Throws: +
ArithmeticException
+
+
+
+ +

+erf

+
+public static double erf(double x)
+                  throws ArithmeticException
+
+
Returns the error function of the normal distribution. + The integral is + 
+ 
+ erf(x) = 2/sqrt(PI) * Integral_(0 to x) [ e^(-t^2) ] dt
+                           
+
+ Implementation: + For 0 <= |x| < 1, erf(x) = x * P4(x^2)/Q5(x^2) ; otherwise + erf(x) = 1 - erfc(x). +

+

+

+
+
+
+
Parameters:
x - the integral end point. +
Throws: +
ArithmeticException
+
+
+
+ +

+erfComplemented

+
+public static double erfComplemented(double a)
+                              throws ArithmeticException
+
+
Returns the complementary Error function of the normal distribution; formerly named erfc. + 
+ 
+  erfc(x) = 2/sqrt(PI) * Integral_(x to inf) [ e^(-t^2) ] dt
+                = 1 - 2/sqrt(PI) * Integral_(0 to x) [ e^(-t^2) ] dt
+                = 1 - erf(x).
+                          
+
+ Implementation: + For small x, erfc(x) = 1 - erf(x); otherwise rational + approximations are computed. +

+

+

+
+
+
+
Parameters:
a - corresponds to x above. An internal check is performed to see if + a is < 0 or otherwise. If a < 0 --> x = -a. Else, x = a. +
Throws: +
ArithmeticException
+
+
+
+ +

+fcdf

+
+public static double fcdf(double x,
+                          int df1,
+                          int df2)
+
+
Returns the area from zero to x under the F density + function (also known as Snedcor's density or the + variance ratio density); formerly named fdtr. + Corresponds to the left hand tail of the F-distribution. + + The incomplete beta integral is used, according to the formula + 
+
+ P(x) = Gamma.incompleteBeta( df1/2, df2/2, (df1*x/(df2 + df1*x) ).
+
+
+

+

+
+
+
+
Parameters:
df1 - ( greater than or equal to 1 )
df2 - ( greater than or equal to 1 )
x - the integration end point (greater than or equal to 0).
+
+
+
+ +

+fcdfComplemented

+
+public static double fcdfComplemented(double x,
+                                      int df1,
+                                      int df2)
+
+
Returns the area from x to infinity under the F density + function (also known as Snedcor's density or the + variance ratio density); formerly named fdtrc. + Corresponds to the right hand tail of the F-distribution ( and + to the values presented in F-distribution tables). + + The incomplete beta integral is used, according to the + relation +
+ 
+ P(x) = Gamma.incompleteBeta( df2/2, df1/2, (df2/(df2 + df1*x) )
+ 
+
+

+

+
+
+
+
Parameters:
df1 - df1 ( greater than or equal to 1 )
df2 - df2 ( greater than or equal to 1 )
x - the left integration point. Corresponds to the F value in look-up tables. +
Returns:
The area from x to inf. under the F density function.
+
+
+
+ +

+finv

+
+public static double finv(double p,
+                          int df1,
+                          int df2)
+
+
Finds the F density argument x such that the integral + from 0 to x of the F density is equal to p; formerly named fdtri. + That is, it solves for the value of x, given p such that + 
+ fcdf(x,df1,df2) - p = 0.
+
+ + This is accomplished using the inverse beta integral + function and the relations +
+ z = incompleteBetaInverse( df2/2, df1/2, p ),
+ x = 1 - df2 * (1-z) / (df1 z),
+
+ if p > Gamma.incompleteBeta( 0.5*df1, 0.5*df2, 0.5 );, or p < 0.001 and, +
+ z = incompleteBetaInverse( df1/2, df2/2, p ),
+ x = 1 - df2 * z / (df1 (1-z)),
+
+ otherwise. + The significance level for a one-sided test (or α in look-up tables) is then 1-x +

+

+
+
+
+
Parameters:
df1 - degrees of freedom of the first dataset
df2 - degrees of freedom of the second dataset
p - the fcdf value for which to solve for x +
Returns:
the point x such that fcdf(x,df1,df2) = p. +
Throws: +
IllegalArgumentException - if df1 or df2 are less than 1, or p is not in (0,1].
+
+
+
+ +

+gammacdf

+
+public static double gammacdf(double x,
+                              double a,
+                              double b)
+
+
Returns the integral from zero to x of the gamma probability + density function. + 
+ 
+ y = a^b / Γ(b) * Integral_(0 to x) [ t^(b-1) e^(-a*t) ]dt
+
+
+ The incomplete gamma integral is used, according to the + relation + + y = Gamma.incompleteGamma( b, a*x ). +

+

+
+
+
+
Parameters:
a - the paramater a (alpha) of the gamma distribution.
b - the paramater b (beta, lambda) of the gamma distribution.
x - integration end point. +
Returns:
y the integral from zero to x of the gamma pdf.
+
+
+
+ +

+gammacdfComplemented

+
+public static double gammacdfComplemented(double x,
+                                          double a,
+                                          double b)
+
+
Returns the integral from x to infinity of the gamma + probability density function: + 
+ 
+ y = a^b / Γ(b) * Integral_(from x to infinity) [t^(b-1) * e^(-a*t) ] dt
+
+
+ The incomplete gamma integral is used, according to the + relation +

+ y = Gamma.incompleteGammaComplement( b, a*x ). +

+

+
+
+
+
Parameters:
a - the paramater a (alpha) of the gamma distribution.
b - the paramater b (beta, lambda) of the gamma distribution.
x - integration start point.
+
+
+
+ +

+nbinomcdf

+
+public static double nbinomcdf(double p,
+                               int k,
+                               int n)
+
+
Returns the sum of the terms 0 through k of the Negative Binomial Distribution. + 
+ 
+ Sum_(from j=0 to k)  [ (n+j-1)! / ( j! * (n-1)! ) ] * [ p^n* (1-p)^j ]
+   
+
+ In a sequence of Bernoulli trials, this is the probability + that k or fewer failures precede the n-th success. +

+ The terms are not computed individually; instead the incomplete + beta integral is employed, according to the formula +

+ y = nbinomcdf( p, k, n ) = Gamma.incompleteBeta( n, k+1, p ). + + All arguments must be positive, +

+

+
+
+
+
Parameters:
k - end term.
n - the number of trials.
p - the probability of success (must be in (0.0,1.0)).
+
+
+
+ +

+nbinomcdfComplemented

+
+public static double nbinomcdfComplemented(double p,
+                                           int k,
+                                           int n)
+
+
Returns the sum of the terms k+1 to infinity of the Negative + Binomial distribution. + 
+ 
+ Sum_(from j=k+1 to inf)  [ (n+j-1)! / ( j! * (n-1)! ) ] * [ p^n* (1-p)^j ]
+ 
+
+ The terms are not computed individually; instead the incomplete + beta integral is employed, according to the formula +

+ y = nbinomcdfComplemented( p, k, n ) = Gamma.incompleteBeta( k+1, n, 1-p ). + + All arguments must be positive, +

+

+
+
+
+
Parameters:
k - (start-1) term.
n - the number of trials.
p - the probability of success (must be in (0.0,1.0)).
+
+
+
+ +

+normcdf

+
+public static double normcdf(double a)
+                      throws ArithmeticException
+
+
Returns the area under the Normal (Gaussian) probability density + function, integrated from minus infinity to x (assumes mean is zero, variance is one). + 
+ 
+ normcdf(x) = 1/sqrt(2pi) * Integral_(-inf to x) [ e^(-t^2/2) ] dt
+           =  ( 1 + erf(z) ) / 2
+           =  erfc(z) / 2
+           
+
+ where z = x/sqrt(2). + Computation is via the functions erf and erfComplement. +

+ Relation to alpha value (or confidence level): +

    +
    Two tailed test: alpha = 2*( 1-normcdf(x) ).
    +
    one-tailed test: alpha = ( 1-normcdf(x) ).
    +
+

+

+

+
+
+
+
Parameters:
a - x in the equation above. +
Throws: +
ArithmeticException
+
+
+
+ +

+normcdf

+
+public static double normcdf(double x,
+                             double mean,
+                             double variance)
+                      throws ArithmeticException
+
+
Returns the area under the Normal (Gaussian) probability density + function, integrated from minus infinity to x when the + data has not been standardized (i.e. mean ≠0, variance ≠1). + 
+  
+ normcdf(x,mean,variance) = 1/sqrt(2pi*v) * Integral_(-inf to x) [ e^(-(t-mean)^2 / 2v) ] dt
+
+
+ where v = variance. + Computation is via the functions erf. +

+

+
+
+
+
Parameters:
mean - the mean of the normal distribution.
variance - the variance of the normal distribution.
x - the integration limit. +
Throws: +
ArithmeticException
+
+
+
+ +

+norminv

+
+public static double norminv(double y0)
+                      throws ArithmeticException
+
+
Returns the value, x, for which the area under the + Normal (Gaussian) probability density function (integrated from + minus infinity to x) is equal to the argument y + (assumes mean is zero, variance is one); formerly named ndtri. + That is, +

+ normcdf(x) = y0. +

+

+ For small arguments 0 < y < exp(-2), the program computes + z = sqrt( -2.0 * log(y) ); then the approximation is + x = z - log(z)/z - (1/z) P(1/z) / Q(1/z). + There are two rational functions P/Q, one for 0 < y < exp(-32) + and the other for y up to exp(-2). + For larger arguments, + w = y - 0.5, and x/sqrt(2pi) = w + w**3 R(w**2)/S(w**2)). + Finally, this returns -infinity for y0 = 0 + and +infinity for y0 = 1. +

+

+
+
+
+
Parameters:
y0 - the argument to the function +
Throws: +
ArithmeticException
+
+
+
+ +

+poissoncdf

+
+public static double poissoncdf(double mean,
+                                int k)
+                         throws ArithmeticException
+
+
Returns the sum of the first k terms of the Poisson distribution. + 
+ 
+ Sum_(j=0 to k) [ e^(-m) *  m^j /j! ]
+
+
+ The terms are not summed directly; instead the incomplete + gamma integral is employed, according to the relation +

+ y = poissoncdf( mean, k m ) = Gamma.incompleteGammaComplement( k+1, mean ). + + The arguments must both be positive. +

+

+
+
+
+
Parameters:
k - number of terms.
mean - the mean of the poisson distribution. +
Throws: +
ArithmeticException
+
+
+
+ +

+poissoncdfComplemented

+
+public static double poissoncdfComplemented(int k,
+                                            double mean)
+                                     throws ArithmeticException
+
+
Returns the sum of the terms k+1 to Infinity of the Poisson distribution. + 
+  
+ Sum_(j=k+1 to inf.) [ e^(-m) *  m^j /j! ]
+ 
+
+ The terms are not summed directly; instead the incomplete + gamma integral is employed, according to the formula +

+ y = poissoncdfComplemented( k, m ) = Gamma.incompleteGamma( k+1, m ). + + The arguments must both be positive. +

+

+
+
+
+
Parameters:
k - (start-1) term.
mean - the mean of the poisson distribution. +
Throws: +
ArithmeticException
+
+
+
+ +

+tcdf

+
+public static double tcdf(double t,
+                          double k)
+                   throws ArithmeticException
+
+
Returns the integral from minus infinity to t of the Student-t + distribution with k > 0 degrees of freedom. + 
+ 
+ Γ((k+1)/2) / [ sqrt(k*pi) * Γ(k/2)  ] * Integral_(-inf to t) [  ( 1+x^2/k )^( (-k+1)/2 ) ] dx
+ 
+
+ Relation to incomplete beta integral: +

+
tcdf(t,k) = 0.5 * Gamma.incompleteBeta( k/2, 1/2, z ), when t < 0,
+
tcdf(t,k) = 1-0.5 * Gamma.incompleteBeta( k/2, 1/2, z ), when t > 0,
+

+ where z = k/(k + t^2). + Relation to alpha value (or confidence level): +
    +
    Two tailed test: alpha = 2*( 1-tcdf(t,k) ).
    +
    one-tailed test: alpha = ( 1-tcdf(t,k) ).
    +
+

+

+
+
+
+
Parameters:
k - degrees of freedom.
t - integration end point. +
Throws: +
ArithmeticException
+
+
+
+ +

+tinv

+
+public static double tinv(double p,
+                          double k)
+
+
Returns the value, t, for which the area under the + Student-t probability density function (integrated from + minus infinity to t) is equal to p. + The function uses the tcdf function to determine the return + value iteratively. +

+

+
+
+
+
Parameters:
p - the fcdf value for which to solve for x
k - the degrees of freedom
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/QR.html b/drawing/papaya/reference/papaya/QR.html new file mode 100644 index 0000000..effc2b8 --- /dev/null +++ b/drawing/papaya/reference/papaya/QR.html @@ -0,0 +1,398 @@ + + + + + + +QR (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class QR

+
+java.lang.Object
+  extended by papaya.QR
+
+
+
+
public class QR
extends Object
+ + +

+QR Decomposition. +

+ For an m-by-n matrix A with m ≥ n, the QR decomposition is an m-by-n + orthogonal matrix Q and an n-by-n upper triangular matrix R so that + A = Q*R. +

+ The QR decompostion always exists, even if the matrix does not have + full rank, so the constructor will never fail. The primary use of the + QR decomposition is in the least squares solution of nonsquare systems + of simultaneous linear equations. This will fail if isFullRank() + returns false. +

+Shamelessly copied (and modified) from the +JAMA Java +Matrix package. To make things compatible with how most users use Processing, the +class take in float matrices. However, to preserve the acccuracy of the computations, the algorithm +first casts the input into a double array, prior to doing anything. All methods also return doubles; Use +Cast.doubleToFloat(double[][]) if you want/need to cast everything back to floats for +further (non-high-accuracy-dependant) processing (pun intended). +

+ +

+

+ +

+ + + + + + + + + + + +
+Constructor Summary
QR(float[][] A) + +
+          QR Decomposition, computed by Householder reflections.
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ double[][]getH() + +
+          Return the Householder vectors
+ double[][]getQ() + +
+          Generate and return the (economy-sized) orthogonal factor
+ double[][]getR() + +
+          Return the upper triangular factor
+ booleanisFullRank() + +
+          Is the matrix full rank?
+ double[]solve(float[] b) + +
+          Least squares solution of A*X = b
+ double[][]solve(float[][] B) + +
+          Least squares solution of A*X = B
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+QR

+
+public QR(float[][] A)
+
+
QR Decomposition, computed by Householder reflections. +

+

+
Parameters:
A - Rectangular matrix
+
+ + + + + + + + +
+Method Detail
+ +

+isFullRank

+
+public boolean isFullRank()
+
+
Is the matrix full rank? +

+

+ +
Returns:
true if R, and hence A, has full rank.
+
+
+
+ +

+getH

+
+public double[][] getH()
+
+
Return the Householder vectors +

+

+ +
Returns:
Lower trapezoidal matrix whose columns define the reflections
+
+
+
+ +

+getR

+
+public double[][] getR()
+
+
Return the upper triangular factor +

+

+ +
Returns:
R
+
+
+
+ +

+getQ

+
+public double[][] getQ()
+
+
Generate and return the (economy-sized) orthogonal factor +

+

+ +
Returns:
Q
+
+
+
+ +

+solve

+
+public double[] solve(float[] b)
+
+
Least squares solution of A*X = b +

+

+
Parameters:
b - An array with the same length as the number of rows in A. +
Returns:
x that minimizes the two norm of Q*R*x-b. +
Throws: +
IllegalArgumentException - Matrix row dimensions must agree. +
RuntimeException - Matrix is rank deficient.
+
+
+
+ +

+solve

+
+public double[][] solve(float[][] B)
+
+
Least squares solution of A*X = B +

+

+
Parameters:
B - A Matrix with as many rows as A and any number of columns. +
Returns:
X that minimizes the two norm of Q*R*X-B. +
Throws: +
IllegalArgumentException - Matrix row dimensions must agree. +
RuntimeException - Matrix is rank deficient.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Rank.html b/drawing/papaya/reference/papaya/Rank.html new file mode 100644 index 0000000..7648e92 --- /dev/null +++ b/drawing/papaya/reference/papaya/Rank.html @@ -0,0 +1,464 @@ + + + + + + +Rank (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Rank

+
+java.lang.Object
+  extended by papaya.Rank
+
+
+
+
public class Rank
extends Object
+ + +

+

Ranking based on the natural ordering on floats for a sequence of data that may also + contain NaNs.

+

When present, NaNs are treated according to the configured NaNStrategy constants and ties + are handled using the configured tiesStrategy constants as follows: + +

Strategies for handling NaN values in rank transformations. +

    +
  • 0 (REMOVED, default) - NaNs are removed before the rank transform is applied
    • +
  • 1 (MINIMAL) - NaNs are treated as minimal in the ordering, equivalent to + (that is, tied with) Float.NEGATIVE_INFINITY.
    • +
  • 2 (MAXIMAL) - NaNs are treated as maximal in the ordering, equivalent to + Float.POSITIVE_INFINITY
    • +
  • 3 (FIXED) - NaNs are left "in place," that is the rank transformation is + applied to the other elements in the input array, but the NaN elements + are returned unchanged.
    • +
+

+ +

Strategies for handling tied values in rank transformations: +

    +
  • 0 (AVERAGE, default) - Tied values are assigned the average of the applicable ranks. + For example, (1,3,4,3) is ranked as (1,2.5,4,2.5)
    • +
  • 1 (MINIMUM) - Tied values are assigned the minimum applicable rank, or the rank + of the first occurrence. For example, (1,3,4,3) is ranked as (1,2,4,2)
    • +
  • 2 (MAXIMUM) - Tied values are assigned the maximum applicable rank, or the rank + of the last occurrence. For example, (1,3,4,3) is ranked as (1,3,4,3)
    • +
  • 3 (SEQUENTIAL) - Ties are assigned ranks in order of occurrence in the original array, + for example (1,3,4,3) is ranked as (1,2,4,3)
    • +
+

+ + The defaults are 0 (REMOVED) and 0 (AVERAGE) for the NaNStrategy and TiesStrategy respectively. + +

Examples: + + + + + + + + + + + + + + + + + + + + + + + +
+ Input data: (20, 17, 30, 42.3, 17, 50, Float.NaN, Float.NEGATIVE_INFINITY, 17) +
NaNStrategyTiesStrategyrank(data)
0 (default = NaNs removed)0 (default = ties averaged)(5, 3, 6, 7, 3, 8, 1, 3)
0 (default = NaNs removed)1 (MINIMUM)(5, 2, 6, 7, 2, 8, 1, 2)
1 (MINIMAL)0 (default = ties averaged)(6, 4, 7, 8, 4, 9, 1.5, 1.5, 4)
1 (MINIMAL)2 (MAXIMUM)(6, 5, 7, 8, 5, 9, 2, 2, 5)
2 (MAXIMAL)2 (MAXIMUM)/td> + (5, 4, 6, 7, 4, 8, 9, 1, 4)

+ + (Code adapted from the org.apache.commons.math.stat.ranking package, and modified extensively). +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static float[]rank(float[] data, + int tiesStrategy) + +
+          Rank an array (with no NaNs) using the natural ordering on Floats with ties + resolved using tiesStrategy.
+static float[]rank(float[] data, + int tiesStrategy, + int nanStrategy) + +
+          Rank an array containing NaN values using the natural ordering on Floats, with + NaN values handled according to nanStrategy and ties + resolved using tiesStrategy.
+static float[]rank(int[] data, + int tiesStrategy) + +
+          Rank an array (with no NaNs) using the natural ordering on Floats with ties + resolved using tiesStrategy.
+static float[]rank(int[] data, + int tiesStrategy, + int nanStrategy) + +
+          Rank an array containing NaN values using the natural ordering on Floats, with + NaN values handled according to nanStrategy and ties + resolved using tiesStrategy.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+rank

+
+public static float[] rank(int[] data,
+                           int tiesStrategy,
+                           int nanStrategy)
+
+
Rank an array containing NaN values using the natural ordering on Floats, with + NaN values handled according to nanStrategy and ties + resolved using tiesStrategy. + +

Input values that specify which strategy to use for handling tied values in the + rank transformations: +

    +
  • 0 (AVERAGE, default) - Tied values are assigned the average of the applicable ranks. + For example, (1,3,4,3) is ranked as (1,2.5,4,2.5)
    • +
  • 1 (MINIMUM) - Tied values are assigned the minimum applicable rank, or the rank + of the first occurrence. For example, (1,3,4,3) is ranked as (1,2,4,2)
    • +
  • 2 (MAXIMUM) - Tied values are assigned the maximum applicable rank, or the rank + of the last occurrence. For example, (1,3,4,3) is ranked as (1,3,4,3)
    • +
  • 3 (SEQUENTIAL) - Ties are assigned ranks in order of occurrence in the original array, + for example (1,3,4,3) is ranked as (1,2,4,3)
    • +
+

+ +

Input values that specify which strategy to use for handling NaN values in the + rank transformations: +

    +
  • 0 (REMOVED, default) - NaNs are removed before the rank transform is applied
    • +
  • 1 (MINIMAL) - NaNs are treated as minimal in the ordering, equivalent to + (that is, tied with) Float.NEGATIVE_INFINITY.
    • +
  • 2 (MAXIMAL) - NaNs are treated as maximal in the ordering, equivalent to + Float.POSITIVE_INFINITY
    • +
  • 3 (FIXED) - NaNs are left "in place," that is the rank transformation is + applied to the other elements in the input array, but the NaN elements + are returned unchanged.
    • +
+

+ If the data array has no NaN values, use rank(float[], int) instead. It is quicker. +

+

+
Parameters:
data - array to be ranked. This is cast to a float array prior to ranking.
nanStrategy - 0,1,2 or 3 corresponding to the NaN strategy to employ.
tiesStrategy - 0,1,2 or 3 corresponding to the ties strategy to employ. +
Returns:
array of ranks
+
+
+
+ +

+rank

+
+public static float[] rank(float[] data,
+                           int tiesStrategy,
+                           int nanStrategy)
+
+
Rank an array containing NaN values using the natural ordering on Floats, with + NaN values handled according to nanStrategy and ties + resolved using tiesStrategy. + +

Input values that specify which strategy to use for handling tied values in the + rank transformations: +

    +
  • 0 (AVERAGE, default) - Tied values are assigned the average of the applicable ranks. + For example, (1,3,4,3) is ranked as (1,2.5,4,2.5)
    • +
  • 1 (MINIMUM) - Tied values are assigned the minimum applicable rank, or the rank + of the first occurrence. For example, (1,3,4,3) is ranked as (1,2,4,2)
    • +
  • 2 (MAXIMUM) - Tied values are assigned the maximum applicable rank, or the rank + of the last occurrence. For example, (1,3,4,3) is ranked as (1,3,4,3)
    • +
  • 3 (SEQUENTIAL) - Ties are assigned ranks in order of occurrence in the original array, + for example (1,3,4,3) is ranked as (1,2,4,3)
    • +
+

+ +

Input values that specify which strategy to use for handling NaN values in the + rank transformations: +

    +
  • 0 (REMOVED, default) - NaNs are removed before the rank transform is applied
    • +
  • 1 (MINIMAL) - NaNs are treated as minimal in the ordering, equivalent to + (that is, tied with) Float.NEGATIVE_INFINITY.
    • +
  • 2 (MAXIMAL) - NaNs are treated as maximal in the ordering, equivalent to + Float.POSITIVE_INFINITY
    • +
  • 3 (FIXED) - NaNs are left "in place," that is the rank transformation is + applied to the other elements in the input array, but the NaN elements + are returned unchanged.
    • +
+

+ If the data array has no NaN values, use rank(float[], int) instead. It is quicker. +

+

+
Parameters:
data - array to be ranked
nanStrategy - 0,1,2 or 3 corresponding to the NaN strategy to employ.
tiesStrategy - 0,1,2 or 3 corresponding to the ties strategy to employ. +
Returns:
array of ranks
+
+
+
+ +

+rank

+
+public static float[] rank(int[] data,
+                           int tiesStrategy)
+
+
Rank an array (with no NaNs) using the natural ordering on Floats with ties + resolved using tiesStrategy. +

Input values that specify which strategy to use for handling NaN values in the + rank transformations: +

    +
  • 0 (AVERAGE, default) - Tied values are assigned the average of the applicable ranks. + For example, (1,3,4,3) is ranked as (1,2.5,4,2.5)
    • +
  • 1 (MINIMUM) - Tied values are assigned the minimum applicable rank, or the rank + of the first occurrence. For example, (1,3,4,3) is ranked as (1,2,4,2)
    • +
  • 2 (MAXIMUM) - Tied values are assigned the maximum applicable rank, or the rank + of the last occurrence. For example, (1,3,4,3) is ranked as (1,3,4,3)
    • +
  • 3 (SEQUENTIAL) - Ties are assigned ranks in order of occurrence in the original array, + for example (1,3,4,3) is ranked as (1,2,4,3)
    • +
+

+

+

+
Parameters:
data - array to be ranked. The array is cast to a float array prior to ranking
tiesStrategy - the strategy to employ for ties. +
Returns:
array of ranks
+
+
+
+ +

+rank

+
+public static float[] rank(float[] data,
+                           int tiesStrategy)
+
+
Rank an array (with no NaNs) using the natural ordering on Floats with ties + resolved using tiesStrategy. +

Input values that specify which strategy to use for handling NaN values in the + rank transformations: +

    +
  • 0 (AVERAGE, default) - Tied values are assigned the average of the applicable ranks. + For example, (1,3,4,3) is ranked as (1,2.5,4,2.5)
    • +
  • 1 (MINIMUM) - Tied values are assigned the minimum applicable rank, or the rank + of the first occurrence. For example, (1,3,4,3) is ranked as (1,2,4,2)
    • +
  • 2 (MAXIMUM) - Tied values are assigned the maximum applicable rank, or the rank + of the last occurrence. For example, (1,3,4,3) is ranked as (1,3,4,3)
    • +
  • 3 (SEQUENTIAL) - Ties are assigned ranks in order of occurrence in the original array, + for example (1,3,4,3) is ranked as (1,2,4,3)
    • +
+

+

+

+
Parameters:
data - array to be ranked.
tiesStrategy - the strategy to employ for ties. +
Returns:
array of ranks
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/SVD.html b/drawing/papaya/reference/papaya/SVD.html new file mode 100644 index 0000000..aab308c --- /dev/null +++ b/drawing/papaya/reference/papaya/SVD.html @@ -0,0 +1,417 @@ + + + + + + +SVD (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class SVD

+
+java.lang.Object
+  extended by papaya.SVD
+
+
+
+
public class SVD
extends Object
+ + +

+Singular Value Decomposition. +

+For an m x n matrix A with m > n, +the singular value decomposition is an m-by-n orthogonal matrix +U, an n-by-n diagonal matrix S, and +an n-by-n orthogonal matrix V so that A = U*S*V'. +

+The singular values, sigma[k] = S[k][k], are ordered so that +sigma[0] > sigma[1] > ... > sigma[n-1]. +

+The singular value decompostion always exists, so the constructor will +never fail. The matrix condition number and the effective numerical +rank can be computed from this decomposition. +

+Shamelessly copied (and modified) from the +JAMA Java +Matrix package. To make things compatible with how most users use Processing, the +class take in float matrices. However, to preserve the acccuracy of the computations, the algorithm +first casts the input into a double array, prior to doing anything. All methods also return doubles; Use +Cast.doubleToFloat(double[][]) if you want/need to cast everything back to floats for +further (non-high-accuracy-dependant) processing (pun intended). +

+ +

+

+ +

+ + + + + + + + + + + +
+Constructor Summary
SVD(float[][] AA) + +
+          Construct the singular value decomposition.
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ doublecond() + +
+          Two norm condition number
+ double[][]getS() + +
+          Return the diagonal matrix of singular values
+ double[]getSingularValues() + +
+          Return the one-dimensional array of singular values
+ double[][]getU() + +
+          Return the left singular vectors
+ double[][]getV() + +
+          Return the right singular vectors
+ doublenorm2() + +
+          Two norm
+ intrank() + +
+          Effective numerical matrix rank
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Constructor Detail
+ +

+SVD

+
+public SVD(float[][] AA)
+
+
Construct the singular value decomposition. At the end of this call, + U, V, and S have been computed. +

+

+
Parameters:
AA - Rectangular matrix
+
+ + + + + + + + +
+Method Detail
+ +

+getU

+
+public double[][] getU()
+
+
Return the left singular vectors +

+

+ +
Returns:
U
+
+
+
+ +

+getV

+
+public double[][] getV()
+
+
Return the right singular vectors +

+

+ +
Returns:
V
+
+
+
+ +

+getSingularValues

+
+public double[] getSingularValues()
+
+
Return the one-dimensional array of singular values +

+

+ +
Returns:
diagonal of S.
+
+
+
+ +

+getS

+
+public double[][] getS()
+
+
Return the diagonal matrix of singular values +

+

+ +
Returns:
S
+
+
+
+ +

+norm2

+
+public double norm2()
+
+
Two norm +

+

+ +
Returns:
max(S)
+
+
+
+ +

+cond

+
+public double cond()
+
+
Two norm condition number +

+

+ +
Returns:
max(S)/min(S)
+
+
+
+ +

+rank

+
+public int rank()
+
+
Effective numerical matrix rank +

+

+ +
Returns:
Number of nonnegligible singular values.
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/ScatterPlot.html b/drawing/papaya/reference/papaya/ScatterPlot.html new file mode 100644 index 0000000..f58a4bf --- /dev/null +++ b/drawing/papaya/reference/papaya/ScatterPlot.html @@ -0,0 +1,609 @@ + + + + + + +ScatterPlot (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class ScatterPlot

+
+java.lang.Object
+  extended by papaya.Visuals
+      extended by papaya.ScatterPlot
+
+
+
All Implemented Interfaces:
PapayaConstants
+
+
+
+
public class ScatterPlot
extends Visuals
+ + +

+A simple class to plot x vs y data as a + scatter plot. Default is to draw the points as ellipses, + but you can also use rectangles, and connect the points with + lines. +

+ +

+

+
Author:
+
Adila Faruk
+
+
+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Field Summary
+ booleanasConnectedLines + +
+           
+ booleanasEllipses + +
+           
+ booleanasRectangles + +
+           
+ floatbottomBound + +
+          Specifies the space on the bottom, between the plot area and the bounding + rectangle.
+ booleandrawAxes + +
+          Specifies whether to draw the axes
+ booleandrawRectangle + +
+          Specifies whether to draw the bounding rectangle around the plot.
+ floatleftBound + +
+          Specifies the space on the left between the plot area, and the + bounding rectangle.
+ floatrightBound + +
+          Specifies the space on the right betweent the plot area, and the + bounding rectangle.
+ floattopBound + +
+          Specifies the space on the top, between the plot area and the bounding + rectangle.
+ boolean[]XYLabels + +
+           
+ boolean[]XYTicks + +
+           
+  + + + + + + + +
Fields inherited from class papaya.Visuals
bgColor
+  + + + + + + + +
Fields inherited from interface papaya.PapayaConstants
BASELINE, big, biginv, BOTTOM, CENTER, CORNER, FONTNAME, GRAY, INDEX_NOT_FOUND, INDICES_NOT_FOUND, LEFT, LOGPI, MACHEP, MAXGAM, MAXLOG, MINLOG, RIGHT, SQRTH, SQTPI, STROKEWEIGHT, TEXTSIZE, TOP
+  + + + + + + + + + + +
+Constructor Summary
ScatterPlot(PApplet _theParent, + float _plotLeft, + float _plotTop, + float _plotWidth, + float _plotHeight) + +
+           
+  + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddrawRectangle() + +
+          Draws a rectangle around the plot.
+ voiddrawScatterPlot(float[] _xDat, + float[] _yDat, + float _sWeight, + int _sColor) + +
+          Parent function to plot scatter plot of the data.
+ voidsetDataExtremes(float _minXDat, + float _maxXDat, + float _minYDat, + float _maxYDat) + +
+          Set the minimum/maximum values on the x and y axis to nice numbers.
+  + + + + + + + +
Methods inherited from class papaya.Visuals
drawAxes, drawRect, drawRect, getBottom, getHeight, getLeft, getRight, getTop, getWidth, horizLine, legendHoriz, legendVert, line, mapXData, mapXData, mapYData, mapYData, setBackgroundColor, setHeight, setLeft, setTop, setupFont, setupFont, setWidth, vertLine, writeLabels, writeLabels, writeLabels, writeLabels, writeLabels, writeTitle, xLabels, xLabels, xTicks, yLabels, yLabels, YLines, yTicks
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Field Detail
+ +

+asConnectedLines

+
+public boolean asConnectedLines
+
+
+
+
+
+ +

+asRectangles

+
+public boolean asRectangles
+
+
+
+
+
+ +

+asEllipses

+
+public boolean asEllipses
+
+
+
+
+
+ +

+XYLabels

+
+public boolean[] XYLabels
+
+
+
+
+
+ +

+XYTicks

+
+public boolean[] XYTicks
+
+
+
+
+
+ +

+drawRectangle

+
+public boolean drawRectangle
+
+
Specifies whether to draw the bounding rectangle around the plot. +

+

+
+
+
+ +

+drawAxes

+
+public boolean drawAxes
+
+
Specifies whether to draw the axes +

+

+
+
+
+ +

+leftBound

+
+public float leftBound
+
+
Specifies the space on the left between the plot area, and the + bounding rectangle. That is, the left-most point of + the rectangle is given by plotLeft-leftBound. +

+

+
+
+
+ +

+rightBound

+
+public float rightBound
+
+
Specifies the space on the right betweent the plot area, and the + bounding rectangle. That is, the right-most point of + the rectangle is given by plotLeft+plotWidth+rightBound. +

+

+
+
+
+ +

+topBound

+
+public float topBound
+
+
Specifies the space on the top, between the plot area and the bounding + rectangle. That is, the top-most point of the rectangle is given by + plotTop - topBound. +

+

+
+
+
+ +

+bottomBound

+
+public float bottomBound
+
+
Specifies the space on the bottom, between the plot area and the bounding + rectangle. That is, the bottom-most point of the rectangle is given by + plotTop + plotHeight + bottomBound. +

+

+
+
+ + + + + + + + +
+Constructor Detail
+ +

+ScatterPlot

+
+public ScatterPlot(PApplet _theParent,
+                   float _plotLeft,
+                   float _plotTop,
+                   float _plotWidth,
+                   float _plotHeight)
+
+
+ + + + + + + + +
+Method Detail
+ +

+setDataExtremes

+
+public void setDataExtremes(float _minXDat,
+                            float _maxXDat,
+                            float _minYDat,
+                            float _maxYDat)
+
+
Set the minimum/maximum values on the x and y axis to nice numbers. + e.g. 60 instead of 63.183628, 90 instead of 87.1, etc. + It'll try do it automatically for you, if you don't set it here, + but no guarantees on the result being a nice number. For example, it might + go from 61 to 89 instead of 60 to 90. +

+

+
Parameters:
_minXDat - the minimum x value to use. Set to more than the x data minimum.
_maxXDat - the maximum x value to use. Set to more than the x data maximum.
_minYDat - the minimum y value to use. Set to more than the y data minimum.
_maxYDat - the maximum y value to use. Set to more than the y data maximum.
+
+
+
+ +

+drawRectangle

+
+public void drawRectangle()
+
+
Draws a rectangle around the plot. +
    +
  • Left most point: plotLeft-leftBound
    • +
  • Top most point: plotTop-topBound
    • +
  • Width: plotWidth+leftBound+rightBound
    • +
  • Height: plotHeight+topBound+bottomBound
    • +
+

+

+
+
+
+
+ +

+drawScatterPlot

+
+public void drawScatterPlot(float[] _xDat,
+                            float[] _yDat,
+                            float _sWeight,
+                            int _sColor)
+
+
Parent function to plot scatter plot of the data. +

+

+
Parameters:
_xDat - x Data array
_yDat - y Data array
_sWeight - stroke weight
_sColor - stroke color
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Sorting.html b/drawing/papaya/reference/papaya/Sorting.html new file mode 100644 index 0000000..08646bf --- /dev/null +++ b/drawing/papaya/reference/papaya/Sorting.html @@ -0,0 +1,521 @@ + + + + + + +Sorting (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Sorting

+
+java.lang.Object
+  extended by papaya.Sorting
+
+
+
+
public final class Sorting
extends Object
+ + +

+Class for getting the array of indices that can be used to sort the array in ascending or + descending order. This is especially useful if you want to preserve the ordering of + your original array, or if you want to manipulate more than one array according to the + sorted order of only one of them. +

+ For example, assume we have three arrays X, Y and Z. We want to sort all three arrays by + X (or some arbitrary comparison function). For example, we have
+ X={3, 2, 1}, Y={3.0, 1.0, 2.0}, Z={6.0, 7.0, 8.0}. The output should + be +
+ X={1, 2, 3}, Y={2.0, 1.0, 3.0}, Z={8.0, 7.0, 6.0}. + To do this, we can use the indices corresponding to the elements of X sorted + in ascending order: +

+ X={3,2,1} so indicesForSorting = {2,1,0} + (X[2] holds the smallest value of X, + X[1] holds the next smallest value of X, and X[0] + holds the largest value of X). + The indicesForSorting can then be used to arrange Y and Z + in the same order. + +

+ The algorithm used to obtain these indices is a modified version of the + tuned quicksort proposed by Jon L. Bentley and M. Douglas McIlroy's "Engineering a + Sort Function", Software-Practice and Experience, Vol. 23(11) + P. 1249-1265 (November 1993) (program 7 of the paper; currently used in the Arrays.sort() method + to sort arrays). +

It is a modified version in the sense that the original array remains unsorted. Instead, + a copy of the original array is used in the sorting routine, and the array of + indices [0,1,2,...N-1] sorted concurrently with the array being sorted. +

+ +

+

+
Author:
+
Adila Faruk
+
+
+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+static int[]indices(double[] a, + boolean isAscending) + +
+           
+static int[]indices(double[] a, + int fromIndex, + int toIndex, + boolean isAscending) + +
+           
+static int[]indices(float[] a, + boolean isAscending) + +
+          Gets the array of indices that can be used to sort the array in ascending or + descending order.
+static int[]indices(float[] a, + int fromIndex, + int toIndex, + boolean isAscending) + +
+          Gets the array of indices that can be used to sort the section of the + input array going from fromIndex(inclusive) to toIndex(exclusive) + in ascending or descending order.
+static int[]indices(int[] a, + boolean isAscending) + +
+           
+static int[]indices(int[] a, + int fromIndex, + int toIndex, + boolean isAscending) + +
+           
+static voidtwoArrays(double[] x, + double[] y, + int fromIndex, + int toIndex, + boolean isAscending) + +
+           
+static voidtwoArrays(float[] x, + float[] y, + int fromIndex, + int toIndex, + boolean isAscending) + +
+          Sorts the input x and y arrays according to + x and going from fromIndex(inclusive) to toIndex(exclusive) + in ascending or descending order.
+static voidtwoArrays(int[] x, + int[] y, + int fromIndex, + int toIndex, + boolean isAscending) + +
+           
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Method Detail
+ +

+indices

+
+public static int[] indices(float[] a,
+                            boolean isAscending)
+
+
Gets the array of indices that can be used to sort the array in ascending or + descending order. + +

+ The algorithm used to obtain these indices is a modified version of the + tuned quicksort proposed by Jon L. Bentley and M. Douglas McIlroy's "Engineering a + Sort Function", Software-Practice and Experience, Vol. 23(11) + P. 1249-1265 (November 1993) (program 7 of the paper; currently used in the Arrays.sort() method + to sort arrays). +

It is a modified version in the sense that the original array remains unsorted. Instead, + a copy of the original array is used in the sorting routine, and the array of + indices [0,1,2,...N-1] sorted concurrently with the array being sorted. +

+

+
Parameters:
a - the input array
isAscending - true for data sorted in increasing order. +
Returns:
integar array of indices (with length=data.length) that can be used + to sort the data from low to high or vice-versa.. + * @throws IllegalArgumentException if fromIndex > toIndex +
Throws: +
ArrayIndexOutOfBoundsException - if fromIndex < 0 or + toIndex > a.length
+
+
+
+ +

+indices

+
+public static int[] indices(double[] a,
+                            boolean isAscending)
+
+
+
+
+
+
+ +

+indices

+
+public static int[] indices(int[] a,
+                            boolean isAscending)
+
+
+
+
+
+
+ +

+indices

+
+public static int[] indices(float[] a,
+                            int fromIndex,
+                            int toIndex,
+                            boolean isAscending)
+
+
Gets the array of indices that can be used to sort the section of the + input array going from fromIndex(inclusive) to toIndex(exclusive) + in ascending or descending order. + +

+ The algorithm used to obtain these indices is a modified version of the + tuned quicksort proposed by Jon L. Bentley and M. Douglas McIlroy's "Engineering a + Sort Function", Software-Practice and Experience, Vol. 23(11) + P. 1249-1265 (November 1993) (program 7 of the paper; currently used in the Arrays.sort() method + to sort arrays). +

It is a modified version in the sense that the original array remains unsorted. Instead, + a copy of the original array is used in the sorting routine, and the array of + indices [fromIndex,fromIndex+1, ... , toIndex-1] sorted concurrently with the array being sorted. +

+

+
Parameters:
a - the array to be sorted.
fromIndex - the index of the first element (inclusive) to be + sorted.
toIndex - the index of the last element (exclusive) to be sorted.
isAscending - true for data sorted in increasing order. +
Throws: +
IllegalArgumentException - if fromIndex > toIndex +
ArrayIndexOutOfBoundsException - if fromIndex < 0 or + toIndex > a.length
+
+
+
+ +

+indices

+
+public static int[] indices(double[] a,
+                            int fromIndex,
+                            int toIndex,
+                            boolean isAscending)
+
+
+
+
+
+
+ +

+indices

+
+public static int[] indices(int[] a,
+                            int fromIndex,
+                            int toIndex,
+                            boolean isAscending)
+
+
+
+
+
+
+ +

+twoArrays

+
+public static void twoArrays(float[] x,
+                             float[] y,
+                             int fromIndex,
+                             int toIndex,
+                             boolean isAscending)
+
+
Sorts the input x and y arrays according to + x and going from fromIndex(inclusive) to toIndex(exclusive) + in ascending or descending order. + +

+ The algorithm used to obtain these indices is a modified version of the + tuned quicksort proposed by Jon L. Bentley and M. Douglas McIlroy's "Engineering a + Sort Function", Software-Practice and Experience, Vol. 23(11) + P. 1249-1265 (November 1993) (program 7 of the paper; currently used in the Arrays.sort() method + to sort arrays). +

It is a modified version in the sense that two arrays are sorted according to the first + array. At the end of the method, the section of both arrays going from + fromIndex (inclusive) to toIndex(exclusive) are sorted according + to the first array's order. Use a copy of both arrays if you want to preserve the natural order of + the original arrays. +

+

+
Parameters:
x - the array to sort.
y - the second array, to sort according to x.
fromIndex - the index of the first element (inclusive) to be + sorted.
toIndex - the index of the last element (exclusive) to be sorted.
isAscending - true for data sorted in increasing order. +
Throws: +
IllegalArgumentException - if fromIndex > toIndex +
ArrayIndexOutOfBoundsException - if fromIndex < 0 or + toIndex > a.length
See Also:
Arrays.sort(float[])
+
+
+
+ +

+twoArrays

+
+public static void twoArrays(double[] x,
+                             double[] y,
+                             int fromIndex,
+                             int toIndex,
+                             boolean isAscending)
+
+
+
+
+
+
+ +

+twoArrays

+
+public static void twoArrays(int[] x,
+                             int[] y,
+                             int fromIndex,
+                             int toIndex,
+                             boolean isAscending)
+
+
+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/SubPlot.html b/drawing/papaya/reference/papaya/SubPlot.html new file mode 100644 index 0000000..a037029 --- /dev/null +++ b/drawing/papaya/reference/papaya/SubPlot.html @@ -0,0 +1,793 @@ + + + + + + +SubPlot (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class SubPlot

+
+java.lang.Object
+  extended by papaya.Visuals
+      extended by papaya.SubPlot
+
+
+
All Implemented Interfaces:
PapayaConstants
+
+
+
+
public class SubPlot
extends Visuals
+ + +

+Convenient class for drawing multiple scatter plots. +

+ +

+

+
Author:
+
Adila Faruk
+
+
+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Field Summary
+ floatbottomBound + +
+          Specifies the space on the bottom, between the plot area and the bounding + rectangle.
+ booleandrawAxes + +
+          Specifies whether to draw the axes
+ booleandrawRectangle + +
+          Specifies whether to draw the bounding rectangle around the plot.
+ floatleftBound + +
+          Specifies the space on the left between the plot area, and the + bounding rectangle.
+ floatrightBound + +
+          Specifies the space on the right betweent the plot area, and the + bounding rectangle.
+ ScatterPlot[][]s + +
+           
+ floattopBound + +
+          Specifies the space on the top, between the plot area and the bounding + rectangle.
+ float[][]xLefts + +
+           
+ floatxSpacing + +
+           
+ floatxW + +
+           
+ floatyH + +
+           
+ floatySpacing + +
+           
+ float[][]yTops + +
+           
+  + + + + + + + +
Fields inherited from class papaya.Visuals
bgColor
+  + + + + + + + +
Fields inherited from interface papaya.PapayaConstants
BASELINE, big, biginv, BOTTOM, CENTER, CORNER, FONTNAME, GRAY, INDEX_NOT_FOUND, INDICES_NOT_FOUND, LEFT, LOGPI, MACHEP, MAXGAM, MAXLOG, MINLOG, RIGHT, SQRTH, SQTPI, STROKEWEIGHT, TEXTSIZE, TOP
+  + + + + + + + + + + +
+Constructor Summary
SubPlot(PApplet theParent, + float xLeft, + float yTop, + float xWidth, + float yHeight, + int numX, + int numY) + +
+          Creates numX*numY plots, each of with xWidth, and height yHeight.
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddrawScatterPlot(float[] xDat, + float[] yDat, + int fColor, + int xnum, + int ynum) + +
+          Draws the scatterplot for subplot(xnum,ynum) by calling ScatterPlot.drawScatterPlot(float[], float[], float, int).
+ voidlegendHoriz(String where, + int[] colors, + String[] labels) + +
+          Draws a legend going to the right with the first element situated at (x,y).
+ voidlegendVert(float x, + float y, + int[] colors, + String[] labels) + +
+          Draws a legend going downwards with the first element situated at (x,y).
+ voidsetDataExtremes(float minXDat, + float maxXDat, + float minYDat, + float maxYDat, + int xnum, + int ynum) + +
+          Sets the data extremes for subplot(xnum,ynum) by calling ScatterPlot.setDataExtremes(float, float, float, float)
+ voidwriteTitle(PFont pFont, + String title, + int xnum, + int ynum) + +
+          Writes the title for subplot(xnum,ynum).
+ voidwriteTitle(String title, + int xnum, + int ynum) + +
+          Writes the title for subplot(xnum,ynum).
+ voidxLabels(int _numDiv, + int xnum, + int ynum) + +
+          Writes the x labels for subplot(xnum,ynum).
+ voidyLabels(int _numDiv, + int xnum, + int ynum) + +
+          Writes the y labels for subplot(xnum,ynum).
+  + + + + + + + +
Methods inherited from class papaya.Visuals
drawAxes, drawRect, drawRect, getBottom, getHeight, getLeft, getRight, getTop, getWidth, horizLine, legendHoriz, line, mapXData, mapXData, mapYData, mapYData, setBackgroundColor, setHeight, setLeft, setTop, setupFont, setupFont, setWidth, vertLine, writeLabels, writeLabels, writeLabels, writeLabels, writeLabels, writeTitle, xLabels, xLabels, xTicks, yLabels, yLabels, YLines, yTicks
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Field Detail
+ +

+drawRectangle

+
+public boolean drawRectangle
+
+
Specifies whether to draw the bounding rectangle around the plot. +

+

+
+
+
+ +

+drawAxes

+
+public boolean drawAxes
+
+
Specifies whether to draw the axes +

+

+
+
+
+ +

+leftBound

+
+public float leftBound
+
+
Specifies the space on the left between the plot area, and the + bounding rectangle. That is, the left-most point of + the rectangle is given by plotLeft-leftBound. +

+

+
+
+
+ +

+rightBound

+
+public float rightBound
+
+
Specifies the space on the right betweent the plot area, and the + bounding rectangle. That is, the right-most point of + the rectangle is given by plotLeft+plotWidth+rightBound. +

+

+
+
+
+ +

+topBound

+
+public float topBound
+
+
Specifies the space on the top, between the plot area and the bounding + rectangle. That is, the top-most point of the rectangle is given by + plotTop - topBound. +

+

+
+
+
+ +

+bottomBound

+
+public float bottomBound
+
+
Specifies the space on the bottom, between the plot area and the bounding + rectangle. That is, the bottom-most point of the rectangle is given by + plotTop + plotHeight + bottomBound. +

+

+
+
+
+ +

+xLefts

+
+public float[][] xLefts
+
+
+
+
+
+ +

+yTops

+
+public float[][] yTops
+
+
+
+
+
+ +

+xW

+
+public float xW
+
+
+
+
+
+ +

+yH

+
+public float yH
+
+
+
+
+
+ +

+ySpacing

+
+public float ySpacing
+
+
+
+
+
+ +

+xSpacing

+
+public float xSpacing
+
+
+
+
+
+ +

+s

+
+public ScatterPlot[][] s
+
+
+
+
+ + + + + + + + +
+Constructor Detail
+ +

+SubPlot

+
+public SubPlot(PApplet theParent,
+               float xLeft,
+               float yTop,
+               float xWidth,
+               float yHeight,
+               int numX,
+               int numY)
+
+
Creates numX*numY plots, each of with xWidth, and height yHeight. + subplot(1,1) has its top left corner situated at xLeft, yTop. + subplot(1,2) has its top left corner situated at xLeft, yTop + yHeight + yInterval. + ... + ... + subplot(1,numY) has its top left corner situated at xLeft, yTop + (numY-1)*(yHeight+ySpacing) +

+

+ + + + + + + + +
+Method Detail
+ +

+setDataExtremes

+
+public void setDataExtremes(float minXDat,
+                            float maxXDat,
+                            float minYDat,
+                            float maxYDat,
+                            int xnum,
+                            int ynum)
+
+
Sets the data extremes for subplot(xnum,ynum) by calling ScatterPlot.setDataExtremes(float, float, float, float) +

+

+
+
+
+
+ +

+drawScatterPlot

+
+public void drawScatterPlot(float[] xDat,
+                            float[] yDat,
+                            int fColor,
+                            int xnum,
+                            int ynum)
+
+
Draws the scatterplot for subplot(xnum,ynum) by calling ScatterPlot.drawScatterPlot(float[], float[], float, int). For + more control, use s[xnum][ynum].drawScatterPlot directly. +

+

+
+
+
+
+ +

+writeTitle

+
+public void writeTitle(PFont pFont,
+                       String title,
+                       int xnum,
+                       int ynum)
+
+
Writes the title for subplot(xnum,ynum). For more control over the placement, color, size, + I highly recommend you do this yourself. :) +

+

+
+
+
+
+ +

+writeTitle

+
+public void writeTitle(String title,
+                       int xnum,
+                       int ynum)
+
+
Writes the title for subplot(xnum,ynum). For more control over the placement, color, size, + I highly recommend you do this yourself. :) +

+

+
+
+
+
+ +

+legendVert

+
+public void legendVert(float x,
+                       float y,
+                       int[] colors,
+                       String[] labels)
+
+
Draws a legend going downwards with the first element situated at (x,y). + 100% similar to Visuals.legendVert(float, float, int[], java.lang.String[]). +

+

+
Overrides:
legendVert in class Visuals
+
+
+
Parameters:
colors - the legend colors
labels - labels that go with each color
+
+
+
+ +

+legendHoriz

+
+public void legendHoriz(String where,
+                        int[] colors,
+                        String[] labels)
+
+
Draws a legend going to the right with the first element situated at (x,y). + Useful for situations where you are plotting more than one dataset. +

+

+
Parameters:
where - "top" if you want to place the legend at the top, otherwise, it + will default to placing it at the bottom of the plots.
colors - the legend colors
labels - labels that go with each color
+
+
+
+ +

+yLabels

+
+public void yLabels(int _numDiv,
+                    int xnum,
+                    int ynum)
+
+
Writes the y labels for subplot(xnum,ynum). For more control, call the + underlying scatterplot directly using s[xnum][ynum].yLabels. +

+

+
+
+
+
+ +

+xLabels

+
+public void xLabels(int _numDiv,
+                    int xnum,
+                    int ynum)
+
+
Writes the x labels for subplot(xnum,ynum). For more control, call the + underlying scatterplot directly using s[xnum][ynum].xLabels. +

+

+
+
+
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Unique.html b/drawing/papaya/reference/papaya/Unique.html new file mode 100644 index 0000000..4673b9b --- /dev/null +++ b/drawing/papaya/reference/papaya/Unique.html @@ -0,0 +1,338 @@ + + + + + + +Unique (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Unique

+
+java.lang.Object
+  extended by papaya.Unique
+
+
+
+
public class Unique
extends Object
+ + +

+Class for getting and storing an unsorted array's unique elements, + the indices of these elements, and the number of times the elements occur. +

This class is overkill if: +
+ you want to store only the unique elements. Use a Java + Set instead. +
+ you don't want to store everything in a class. Use the + Descriptive.frequencies(float[], java.util.ArrayList, java.util.ArrayList) method instead. +

+ +

+

+ +

+ + + + + + + + + + + + + + + + + + + +
+Field Summary
+ ArrayList<Integer>frequencies + +
+          ArrayList containing the frequencies of the corresponding unique value
+ int[][]idx + +
+          Class containing the integer arrays that hold the indices of each unique value.
+ ArrayList<Float>values + +
+          ArrayList containing the unique values
+  + + + + + + + + + + +
+Constructor Summary
Unique(float[] data, + boolean storeIndices) + +
+          Class for storing the unique values in an unsorted data array.
+  + + + + + + + +
+Method Summary
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Field Detail
+ +

+values

+
+public ArrayList<Float> values
+
+
ArrayList containing the unique values +

+

+
+
+
+ +

+frequencies

+
+public ArrayList<Integer> frequencies
+
+
ArrayList containing the frequencies of the corresponding unique value +

+

+
+
+
+ +

+idx

+
+public int[][] idx
+
+
Class containing the integer arrays that hold the indices of each unique value. +

+

+
+
+ + + + + + + + +
+Constructor Detail
+ +

+Unique

+
+public Unique(float[] data,
+              boolean storeIndices)
+
+
Class for storing the unique values in an unsorted data array. Does essentially the same + thing as the Descriptive.frequencies method would, except: +


+ - The input data array is unsorted. +
+
+ - You can choose to store the indices of each unique value as well by setting the @param storeIndices + to true. +
+
+ - It (currently) only works for float arrays. +
+

Example:

+

+ data = (8,5,6,7,8,5,5) --> values = (5,6,7,8), frequencies = (3,1,1,2), + idx[0] = {1,5,6}, idx[1] = {2}, idx[2] = {3}, idx[3] = {0,4} +

+

+

+
Parameters:
data - the data array
storeIndices - set to true if you want to store the indices, + else set to false +
+ +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/Visuals.html b/drawing/papaya/reference/papaya/Visuals.html new file mode 100644 index 0000000..73ea0dd --- /dev/null +++ b/drawing/papaya/reference/papaya/Visuals.html @@ -0,0 +1,1404 @@ + + + + + + +Visuals (Javadocs: papaya) + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + +
Package   Class  Tree  Deprecated  Index  Help 
+		 + +
+ PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
+ SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
+ + + +
+ +

+ +papaya +
+Class Visuals

+
+java.lang.Object
+  extended by papaya.Visuals
+
+
+
All Implemented Interfaces:
PapayaConstants
+
+
+
Direct Known Subclasses:
BoxPlot, CorrelationPlot, ScatterPlot, SubPlot
+
+
+
+
public class Visuals
extends Object
implements PapayaConstants
+ + +

+Visuals is the parent class behind most of the other plotting classes. + +

+ It: +
+ 1. Contains some useful functions for the visual representation + of your data (e.g. setting up your font, writing labels, mapping + arrays to the plot right-left-top-bottom parameters, xTicks, yTicks, + etc.) that should help you reduce the amount of code you end up + writing. +
+ 2. Is extended by the available "Plotting" classes used to quickly give a + visual snapshot of your data. +

+

+ +

+

+ +

+ + + + + + + + + + + +
+Field Summary
+ intbgColor + +
+          Specifies the plot background color
+  + + + + + + + +
Fields inherited from interface papaya.PapayaConstants
BASELINE, big, biginv, BOTTOM, CENTER, CORNER, FONTNAME, GRAY, INDEX_NOT_FOUND, INDICES_NOT_FOUND, LEFT, LOGPI, MACHEP, MAXGAM, MAXLOG, MINLOG, RIGHT, SQRTH, SQTPI, STROKEWEIGHT, TEXTSIZE, TOP
+  + + + + + + + + + + +
+Constructor Summary
Visuals(PApplet _theParent, + float _plotLeft, + float _plotTop, + float _plotWidth, + float _plotHeight) + +
+          The parent class behind the other plotting classes.
+  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+Method Summary
+ voiddrawAxes(int _sColor, + float _sWeight) + +
+          Draws the plot axes using a line with color _sColor, and weight _sWeight
+ voiddrawRect() + +
+          Draw the plot background rectangle using the default plot + dimensions and background color.
+ voiddrawRect(float _left, + float _top, + float _width, + float _height, + int _rectColor) + +
+          Draws the plot background rectangle using the input dimensions and + background color.
+ floatgetBottom() + +
+           
+ floatgetHeight() + +
+           
+ floatgetLeft() + +
+           
+ floatgetRight() + +
+           
+ floatgetTop() + +
+           
+ floatgetWidth() + +
+           
+ voidhorizLine(float _xFrom, + float _xTo, + float _y, + int _sColor, + float _sWeight) + +
+          draws a horizonal line with color _sColor, and weight _sWeight
+ voidlegendHoriz(float x, + float y, + int[] colors, + String[] labels) + +
+          Draws a legend going to the right with the first element situated at (x,y).
+ voidlegendVert(float x, + float y, + int[] colors, + String[] labels) + +
+          Draws a legend going downwards with the first element situated at (x,y).
+ voidline(float _x1, + float _y1, + float _x2, + float _y2, + int _sColor, + float _sWeight) + +
+          Draws a straight line going from (x[0],y[0]) to (x[1],y[1]) + with color _sColor, and weight _sWeight
+ float[]mapXData(float[] data) + +
+          Maps the x-data from the range min(data) to max(data) to + the plotLeft and plotLeft+plotWidth.
+ float[]mapXData(float[] data, + float minXDat, + float maxXDat) + +
+          Maps the x-data from the range minXDat to maxXDat to + the plotLeft and plotRight.
+ float[]mapYData(float[] data) + +
+          Maps the y-data from the range min(data) to max(data) to + the plotBottom and plotTop.
+ float[]mapYData(float[] data, + float minYDat, + float maxYDat) + +
+          Maps the y-data from the range minYDat to maxYDat to + the plotBottom and plotTop.
+ voidsetBackgroundColor(int _backgroundColor) + +
+           
+ voidsetHeight(float _plotHeight) + +
+           
+ voidsetLeft(float _plotLeft) + +
+           
+ voidsetTop(float _plotTop) + +
+           
+ voidsetupFont(String _fontName, + int _xAlign, + int _yAlign, + int _tSize) + +
+          function for setting the font up for writing the labels
+ voidsetupFont(String _fontName, + int _xAlign, + int _yAlign, + int _tSize, + int _fontColor) + +
+          overload setupFont function that takes in font color
+ voidsetWidth(float _plotWidth) + +
+           
+ voidvertLine(float _yFrom, + float _yTo, + float _x, + int _sColor, + float _sWeight) + +
+          draws a vertical line with color _sColor, and weight _sWeight
+ voidwriteLabels(float _text, + float _xPos, + float _yPos) + +
+           
+ voidwriteLabels(PFont _plotFont, + float _text, + float _xPos, + float _yPos) + +
+           
+ voidwriteLabels(PFont _plotFont, + String[] _text, + float[] _xPos, + float[] _yPos) + +
+           
+ voidwriteLabels(PFont _plotFont, + String _text, + float _xPos, + float _yPos) + +
+           
+ voidwriteLabels(String _text, + float _xPos, + float _yPos) + +
+           
+ voidwriteTitle(String _title, + PFont _plotFont) + +
+          titles the plot given the String _title and the PFont
+ voidxLabels(float _left, + float _width, + float _xDatMin, + float _xDatMax, + int _numDiv) + +
+          Write the x-axis labels.
+ voidxLabels(float _left, + float _width, + String[] _xLabels) + +
+          Write the x-axis labels.
+ voidxTicks(float _left, + float _width, + int _numDiv, + int _tickHeight) + +
+          Draws the x-axis tickmarks.
+ voidyLabels(float _top, + float _height, + float _yDatMin, + float _yDatMax, + int _numDiv) + +
+          Write the y-axis labels.
+ voidyLabels(float _top, + float _height, + String[] _yLabels) + +
+          Write the y-axis labels.
+ voidYLines(int _numDiv) + +
+          Draws horizontal y-lines on the plot
+ voidyTicks(float _top, + float _height, + int _numDiv, + int _tickWidth) + +
+          Draws the y-axis tickmarks.
+  + + + + + + + +
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
+  +

+ + + + + + + + +
+Field Detail
+ +

+bgColor

+
+public int bgColor
+
+
Specifies the plot background color +

+

+
+
+ + + + + + + + +
+Constructor Detail
+ +

+Visuals

+
+public Visuals(PApplet _theParent,
+               float _plotLeft,
+               float _plotTop,
+               float _plotWidth,
+               float _plotHeight)
+
+
The parent class behind the other plotting classes. + +

+ Visuals contains some useful functions for the (elementary!) visual representation + of your data (e.g. setting up your font, writing labels, mapping + arrays to the plot right-left-top-bottom parameters, xTicks, yTicks,legends, + etc). Nothing very fancy like writing x-labels at an angle or computing your + tax returns for you though so don't get your hopes up. Sorry. +

+

+
Parameters:
_theParent - the Processing papplet. Just "this" in your sketch.
_plotLeft - the plot left
_plotTop - the plot top (in Processing coordinates!)
_plotWidth - the plot width
_plotHeight - the plot height. +

The bottom of the plot area is then given by _plotTop + _plotHeight + while the right is _plotLeft + _plotWidth.

+
+ + + + + + + + +
+Method Detail
+ +

+mapXData

+
+public float[] mapXData(float[] data)
+
+
Maps the x-data from the range min(data) to max(data) to + the plotLeft and plotLeft+plotWidth. That is, + mappedData[i] = plotLeft + (data[i] - min) / (max-min) * plotWidth. + This is not done directly though, but rather, the + Mat.map(float[] data, float low1, float high1, float low2, float high2) + function is used. +

+

+
+
+
+
Parameters:
data - the x data to map. +
Returns:
the mapped data.
+
+
+
+ +

+mapXData

+
+public float[] mapXData(float[] data,
+                        float minXDat,
+                        float maxXDat)
+
+
Maps the x-data from the range minXDat to maxXDat to + the plotLeft and plotRight. That is, + mappedData[i] = plotLeft + (data[i] - minXDat) / (maxXDat-minXDat) * plotWidth. + This is not done directly though, but rather, the + Mat.map(float[] data, float low1, float high1, float low2, float high2) + function is used. +

+ Note: No internal checks are done to make sure that the min/max values are in the + data range. +

+

+

+
+
+
+
Parameters:
data - the x data to map.
minXDat - the minimum value to use in the data mapping.
maxXDat - the maximum value to use in the data mapping. +
Returns:
the mapped data.
+
+
+
+ +

+mapYData

+
+public float[] mapYData(float[] data)
+
+
Maps the y-data from the range min(data) to max(data) to + the plotBottom and plotTop. That is, + mappedData[i] = plotBottom + (data[i] - min) / (max-min) * (-plotHeight). + (The minus sign above accounts for the difference in Processing's coordinate system + and what we associate with Top/Bottom). + The computation above is not done directly though, but rather, the + Mat.map(float[] data, float low1, float high1, float low2, float high2) + function is used. +

+

+
+
+
+
Parameters:
data - the y data to map. +
Returns:
the mapped data.
+
+
+
+ +

+mapYData

+
+public float[] mapYData(float[] data,
+                        float minYDat,
+                        float maxYDat)
+
+
Maps the y-data from the range minYDat to maxYDat to + the plotBottom and plotTop. That is, + mappedData[i] = plotBottom + (data[i] - minYDat) / (maxYDat-minYDat) * (-plotHeight). + (The minus sign above accounts for the difference in Processing's coordinate system + and what we associate with Top/Bottom). + The computation above is not done directly though, but rather, the + Mat.map(float[] data, float low1, float high1, float low2, float high2) + function is used. +

+ Note: No internal checks are done to make sure that the min/max values are in the + data range. +

+

+

+
+
+
+
Parameters:
data - the x data to map.
minYDat - the minimum value to use in the data mapping.
maxYDat - the maximum value to use in the data mapping. +
Returns:
the mapped data.
+
+
+
+ +

+drawAxes

+
+public void drawAxes(int _sColor,
+                     float _sWeight)
+
+
Draws the plot axes using a line with color _sColor, and weight _sWeight +

+

+
+
+
+
+
+
+
+ +

+drawRect

+
+public void drawRect()
+
+
Draw the plot background rectangle using the default plot + dimensions and background color. + +
  • Left most point: plotLeft
    • +
  • Top most point: plotTop
    • +
  • Width: plotWidth
    • +
  • Height: plotHeight
    • + +

    +

    +
    +
    +
    +
    +
    +
    +
    + +

    +drawRect

    +
    +public void drawRect(float _left,
+                     float _top,
+                     float _width,
+                     float _height,
+                     int _rectColor)
    +
    +
    Draws the plot background rectangle using the input dimensions and + background color. +

    +

    +
    +
    +
    +
    Parameters:
    _left - the left-most point of the rectangle
    _top - the top-most point of the rectangle
    _width - the width of the rectangle
    _height - the height of the rectangle
    _rectColor - the rectangle color.
    +
    +
    +
    + +

    +legendVert

    +
    +public void legendVert(float x,
+                       float y,
+                       int[] colors,
+                       String[] labels)
    +
    +
    Draws a legend going downwards with the first element situated at (x,y). + Useful for situations where you are plotting more than one dataset. +

    +

    +
    +
    +
    +
    Parameters:
    colors - the legend colors
    labels - labels that go with each color
    +
    +
    +
    + +

    +legendHoriz

    +
    +public void legendHoriz(float x,
+                        float y,
+                        int[] colors,
+                        String[] labels)
    +
    +
    Draws a legend going to the right with the first element situated at (x,y). + Useful for situations where you are plotting more than one dataset. +

    +

    +
    +
    +
    +
    Parameters:
    colors - the legend colors
    labels - labels that go with each color
    +
    +
    +
    + +

    +xTicks

    +
    +public void xTicks(float _left,
+                   float _width,
+                   int _numDiv,
+                   int _tickHeight)
    +
    +
    Draws the x-axis tickmarks. +

    +

    +
    +
    +
    +
    Parameters:
    _left - left most tick position. Set to negative to make it default + to the plotLeft)
    _width - (_left + _width) = right most tick position. Set to negative
    _numDiv - the number of divisions. The number of tick marks drawn = _numDiv+1.
    _tickHeight - the height of the tick mark.
    +
    +
    +
    + +

    +xLabels

    +
    +public void xLabels(float _left,
+                    float _width,
+                    float _xDatMin,
+                    float _xDatMax,
+                    int _numDiv)
    +
    +
    Write the x-axis labels. +

    +

    +
    +
    +
    +
    Parameters:
    _left - left most label position. Set to negative to make it default + to the plotLeft)
    _width - (_left + _width) = right most label position. Set to negative + to make it default to the plotWidth
    _xDatMin - minimum data value to show in the label
    _xDatMax - maximum data value to show in the label
    _numDiv - the number of divisions.
    +
    +
    +
    + +

    +xLabels

    +
    +public void xLabels(float _left,
+                    float _width,
+                    String[] _xLabels)
    +
    +
    Write the x-axis labels. +

    +

    +
    +
    +
    +
    Parameters:
    _left - left most label position. Set to negative to make it default + to the plotLeft)
    _width - (_left + _width) = right most label position. Set to negative + to make it default to the plotWidth
    _xLabels - the String array of labels.
    +
    +
    +
    + +

    +yTicks

    +
    +public void yTicks(float _top,
+                   float _height,
+                   int _numDiv,
+                   int _tickWidth)
    +
    +
    Draws the y-axis tickmarks. +

    +

    +
    +
    +
    +
    Parameters:
    _top - top most tick position in Processing's coordinate system. + Set to negative to make it default to the plotTop)
    _height - (top + height) = bottom most label position in Processing's coordinate system. + Set to negative to make it default to the plotHeight.
    _numDiv - the number of divisions. The number of tick marks drawn = _numDiv+1.
    _tickWidth - the width of the tick mark.
    +
    +
    +
    + +

    +yLabels

    +
    +public void yLabels(float _top,
+                    float _height,
+                    float _yDatMin,
+                    float _yDatMax,
+                    int _numDiv)
    +
    +
    Write the y-axis labels. +

    +

    +
    +
    +
    +
    Parameters:
    _top - top most label position in Processing's coordinate system. + Set to negative to make it default to the plotTop)
    _height - (top + height) = bottom most label positionin Processing's coordinate system. + Set to negative to make it default to the plotHeight.
    _yDatMin - minimum data value to show in the label
    _yDatMax - maximum data value to show in the label
    _numDiv - the number of divisions.
    +
    +
    +
    + +

    +yLabels

    +
    +public void yLabels(float _top,
+                    float _height,
+                    String[] _yLabels)
    +
    +
    Write the y-axis labels. +

    +

    +
    +
    +
    +
    Parameters:
    _top - top most label position in Processing's coordinate system. + Set to negative to make it default to the plotTop)
    _height - (top + height) = bottom most label positionin Processing's coordinate system. + Set to negative to make it default to the plotHeight.
    _yLabels - the String array of labels.
    +
    +
    +
    + +

    +YLines

    +
    +public void YLines(int _numDiv)
    +
    +
    Draws horizontal y-lines on the plot +

    +

    +
    +
    +
    +
    Parameters:
    _numDiv - number of divisions. The number of lines drawn = numDiv+1
    +
    +
    +
    + +

    +horizLine

    +
    +public void horizLine(float _xFrom,
+                      float _xTo,
+                      float _y,
+                      int _sColor,
+                      float _sWeight)
    +
    +
    draws a horizonal line with color _sColor, and weight _sWeight +

    +

    +
    +
    +
    +
    +
    +
    +
    + +

    +vertLine

    +
    +public void vertLine(float _yFrom,
+                     float _yTo,
+                     float _x,
+                     int _sColor,
+                     float _sWeight)
    +
    +
    draws a vertical line with color _sColor, and weight _sWeight +

    +

    +
    +
    +
    +
    +
    +
    +
    + +

    +line

    +
    +public void line(float _x1,
+                 float _y1,
+                 float _x2,
+                 float _y2,
+                 int _sColor,
+                 float _sWeight)
    +
    +
    Draws a straight line going from (x[0],y[0]) to (x[1],y[1]) + with color _sColor, and weight _sWeight +

    +

    +
    +
    +
    +
    +
    +
    +
    + +

    +writeTitle

    +
    +public void writeTitle(String _title,
+                       PFont _plotFont)
    +
    +
    titles the plot given the String _title and the PFont +

    +

    +
    +
    +
    +
    +
    +
    +
    + +

    +writeLabels

    +
    +public void writeLabels(PFont _plotFont,
+                        String[] _text,
+                        float[] _xPos,
+                        float[] _yPos)
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +writeLabels

    +
    +public void writeLabels(PFont _plotFont,
+                        String _text,
+                        float _xPos,
+                        float _yPos)
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +writeLabels

    +
    +public void writeLabels(PFont _plotFont,
+                        float _text,
+                        float _xPos,
+                        float _yPos)
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +writeLabels

    +
    +public void writeLabels(float _text,
+                        float _xPos,
+                        float _yPos)
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +writeLabels

    +
    +public void writeLabels(String _text,
+                        float _xPos,
+                        float _yPos)
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +setupFont

    +
    +public void setupFont(String _fontName,
+                      int _xAlign,
+                      int _yAlign,
+                      int _tSize)
    +
    +
    function for setting the font up for writing the labels +

    +

    +
    +
    +
    +
    +
    +
    +
    + +

    +setupFont

    +
    +public void setupFont(String _fontName,
+                      int _xAlign,
+                      int _yAlign,
+                      int _tSize,
+                      int _fontColor)
    +
    +
    overload setupFont function that takes in font color +

    +

    +
    +
    +
    +
    +
    +
    +
    + +

    +setBackgroundColor

    +
    +public void setBackgroundColor(int _backgroundColor)
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +getLeft

    +
    +public float getLeft()
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +getRight

    +
    +public float getRight()
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +getTop

    +
    +public float getTop()
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +getBottom

    +
    +public float getBottom()
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +getWidth

    +
    +public float getWidth()
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +getHeight

    +
    +public float getHeight()
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +setLeft

    +
    +public void setLeft(float _plotLeft)
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +setWidth

    +
    +public void setWidth(float _plotWidth)
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +setTop

    +
    +public void setTop(float _plotTop)
    +
    +
    +
    +
    +
    +
    +
    +
    +
    + +

    +setHeight

    +
    +public void setHeight(float _plotHeight)
    +
    +
    +
    +
    +
    +
    +
    +
    + +
    + + + + + + + + + + + + + + + + + + + +
    + + + + + + + + + + +
    Package   Class  Tree  Deprecated  Index  Help 
    +    		 + +
    + PREV CLASS  + NEXT CLASS + FRAMES   + NO FRAMES   +  + + + +
    + SUMMARY: NESTED | FIELD | CONSTR | METHOD +DETAIL: FIELD | CONSTR | METHOD
    + + + +
    + + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/package-frame.html b/drawing/papaya/reference/papaya/package-frame.html new file mode 100644 index 0000000..1f62577 --- /dev/null +++ b/drawing/papaya/reference/papaya/package-frame.html @@ -0,0 +1,119 @@ + + + + + + +papaya (Javadocs: papaya) + + + + + + + + + + + +papaya + + + + +
    +Interfaces  + +
    +PapayaConstants
    + + + + + + +
    +Classes  + +
    +BoxPlot +
    +Cast +
    +Comparison +
    +Comparison.TTest +
    +Correlation +
    +Correlation.Significance +
    +Correlation.Weighted +
    +CorrelationPlot +
    +Descriptive +
    +Descriptive.Mean +
    +Descriptive.Pooled +
    +Descriptive.Sum +
    +Descriptive.Weighted +
    +Distance +
    +Eigenvalue +
    +Find +
    +Frequency +
    +Gamma +
    +Linear +
    +Linear.BoxCox +
    +Linear.Significance +
    +Linear.StdErr +
    +LU +
    +Mat +
    +MDS +
    +NaNs +
    +Normality +
    +Normality.Dago +
    +OneWayAnova +
    +Polynomial +
    +Probability +
    +QR +
    +Rank +
    +ScatterPlot +
    +Sorting +
    +SubPlot +
    +SVD +
    +Unique +
    +Visuals
    + + + + diff --git a/drawing/papaya/reference/papaya/package-summary.html b/drawing/papaya/reference/papaya/package-summary.html new file mode 100644 index 0000000..99ad853 --- /dev/null +++ b/drawing/papaya/reference/papaya/package-summary.html @@ -0,0 +1,344 @@ + + + + + + +papaya (Javadocs: papaya) + + + + + + + + + + + + +
    + + + + + + + + + + + + + + + +
    + + + + + + + + + + +
    Package  Class  Tree  Deprecated  Index  Help 
    +    		 + +
    + PREV PACKAGE  + NEXT PACKAGE + FRAMES   + NO FRAMES   +  + + + +
    + + + +
    +

    +Package papaya +

    + + + + + + + + + +
    +Interface Summary
    PapayaConstantsPapayaConstants stores some of the constants used in plotting.
    +  + +

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +Class Summary
    BoxPlotBoxPlot class
    CastStatic Class for casting Object arrays to their corresponding primitive type.
    ComparisonContains a number of methods for comparing more than one dataset + against each other.
    Comparison.TTestMethods related to comparing two populations.
    CorrelationContains utilities related to computing covariances, as well as linear and rank correlation.
    Correlation.SignificanceContains methods used to compute the significance, or pvalue of the input correlations.
    Correlation.WeightedContains methods related to computing the correlation and covariance of weighted + datasets.
    CorrelationPlotTakes in a matrix and plots the data in each of the columns versus + each other.
    DescriptiveBasic descriptive statistics class for exploratory data analysis.
    Descriptive.MeanContains methods for computing the arithmetic, geometric, harmonic, trimmed, and winsorized + means (among others).
    Descriptive.PooledClass for computing the pooled mean and variance of data sequences
    Descriptive.SumMethods for computing various different sums of datasets such as sum of inversions, + logs, products, power deviations, squares, etc.
    Descriptive.WeightedContains methods related to weighted datasets.
    DistanceContains methods for computing various "distance" metrics for multidimensional scaling.
    EigenvalueEigenvalues and eigenvectors of a real matrix.
    FindStatic class for finding indices in an array corresponding to a given value/object.
    FrequencyClass for getting the frequency distribution, cumulative frequency distribution, and other + distribution-related parameters of a given array of floats or ints.
    GammaGamma and Beta functions.
    LinearContains methods related to determining the linear linear + relationship between two datasets (of equal arrays) such as the + best-fit linear line parameters, box-cox transformations, etc.
    Linear.BoxCoxContains methods related to the Box-Cox transformation of a data set; useful in + determining the best transformation that will yield the best method for converting + a monotonic, non-linear relationship between x and y into + a linear one.
    Linear.SignificanceContains methods used to compute the significance, or pvalue of the input correlations.
    Linear.StdErrContains methods related to computing the standard errors of the residuals, slope and intercept + associated with the best-fit linear line.
    LULU Decomposition.
    MatStatic class for performing some basic matrix operations.
    MDSContains methods for performing but classical and non-classical multidimensional scaling.
    NaNsContains various methods for dealing with NaNs in your data.
    NormalityContains various utilities for checking if the dataset comes from a normal distribution.
    Normality.DagoMethods for computing the skewnewss, kurtosis, and D'Agostino-Peasrson K^2 "omnibus" test-statistics (that + combine the former two), and accompanying significance (or p-values) + for testing the underlying population normality.
    OneWayAnovaComputes the one-way ANOVA p-value to test the equality of two or more sample + means by analyzing the sample variances using the test statistic + F = variance between samples / variance within samples.
    PolynomialStatic Class for casting one variable type to another.
    ProbabilityCumulative distribution functions and corresponding inverses of certain probability distributions.
    QRQR Decomposition.
    RankRanking based on the natural ordering on floats for a sequence of data that may also + contain NaNs.
    ScatterPlotA simple class to plot x vs y data as a + scatter plot.
    SortingClass for getting the array of indices that can be used to sort the array in ascending or + descending order.
    SubPlotConvenient class for drawing multiple scatter plots.
    SVDSingular Value Decomposition.
    UniqueClass for getting and storing an unsorted array's unique elements, + the indices of these elements, and the number of times the elements occur.
    VisualsVisuals is the parent class behind most of the other plotting classes.
    +  + +

    +

    +
    +
    + + + + + + + + + + + + + + + +
    + + + + + + + + + + +
    Package  Class  Tree  Deprecated  Index  Help 
    +    		 + +
    + PREV PACKAGE  + NEXT PACKAGE + FRAMES   + NO FRAMES   +  + + + +
    + + + +
    + + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/papaya/package-tree.html b/drawing/papaya/reference/papaya/package-tree.html new file mode 100644 index 0000000..9bf13b7 --- /dev/null +++ b/drawing/papaya/reference/papaya/package-tree.html @@ -0,0 +1,166 @@ + + + + + + +papaya Class Hierarchy (Javadocs: papaya) + + + + + + + + + + + + +
    + + + + + + + + + + + + + + + +
    + + + + + + + + + + +
    Package  Class   Tree  Deprecated  Index  Help 
    +    		 + +
    + PREV  + NEXT + FRAMES   + NO FRAMES   +  + + + +
    + + + +
    +
    +

    +Hierarchy For Package papaya +

    +
    +

    +Class Hierarchy +

    + +

    +Interface Hierarchy +

    + +
    + + + + + + + + + + + + + + + +
    + + + + + + + + + + +
    Package  Class   Tree  Deprecated  Index  Help 
    +    		 + +
    + PREV  + NEXT + FRAMES   + NO FRAMES   +  + + + +
    + + + +
    + + + Processing library papaya by + Adila Faruk. (C) 2014 + + + + diff --git a/drawing/papaya/reference/resources/inherit.gif b/drawing/papaya/reference/resources/inherit.gif new file mode 100644 index 0000000000000000000000000000000000000000..c814867a13deb0ca7ea2156c6ca1d5a03372af7e GIT binary patch literal 57 zcmZ?wbhEHbIIT!9-C*e{wE9>Kx3D)-;0v)C; KYxQGgum%9JOA&7X literal 0 HcmV?d00001 diff --git a/drawing/papaya/reference/stylesheet.css b/drawing/papaya/reference/stylesheet.css new file mode 100644 index 0000000..7e746f8 --- /dev/null +++ b/drawing/papaya/reference/stylesheet.css @@ -0,0 +1,115 @@ +/* Javadoc style sheet */ +/* Define colors, fonts and other style attributes here to override the defaults */ +/* +To compile: +cd into folder +sass -s --watch stylesheet.scss:stylesheet.css +or, just use the Makefile! +*/ +/** colors */ +/* Page background color */ +body { + background-color: #FFFFFF; + color: #444444; + font-family: Arial, Helvetica, sans-serif; + font-size: 13px; + max-width: 900px; } + +/* + #B0DAFF Light blue text + #1279C6 Blue background + #04469D Darker blue background + $steelblue Orange Text + #F1F1F1 Ligher gray +*/ +/* Headings */ +h1, h2, h3, h4, h5, h6 { + color: #1f77b4; } + +/* Links */ +a:link { + color: #1f77b4; + text-decoration: underline; } + +a:visited { + color: #72587f; } + +/*a:focus {font-weight:bold; color:#04469D; text-decoration:underline; }*/ +a:hover { + font-weight: bold; } + +/* HR and table borders*/ +hr { + border-style: solid 1px #666666; } + +table { + border-style: solid 1px #666666; + max-width: 100%; + overflow: wrap; } + +th { + border-style: none; } + +td { + padding: 4px; + -size: 0.9em; } + +code, +kbd, +pre, +samp { + font-family: Menlo, Monaco, Consolas, "Courier New", monospace; + font-size: 0.9em; } + +code { + padding: 2px 4px; + font-size: .9em; + color: #4a4a4a; + background-color: #f8f8f8; + border-radius: 4px; + border:1px solid #cacaca; +} +/* Table colors */ +.TableHeadingColor, .TableSubHeadingColor { + background: #222222; + color: #FFFFFF; + border-radius: 4px; } + +.TableRowColor { + background: #FFFFFF; + color: #666666; + font-size: 0.9em; } + +/* Font used in left-hand frame lists */ +.FrameTitleFont { + font-size: 100%; + font-family: Helvetica, Arial, sans-serif; + color: #1f77b4; } + +.FrameHeadingFont, .FrameItemFont { + font-size: 0.9em; + font-family: Helvetica, Arial, sans-serif; + color: #1f77b4; } + +/* Navigation bar fonts and colors */ +.NavBarCell1 { + background-color: #222222; + color: #222222; + border-radius: 4px; } + +.NavBarCell1Rev { + background-color: #1f77b4 !important; + color: #FFFFFF; + border-radius: 4px; } + +.NavBarFont1, .NavBarFont1Rev { + font-family: Arial, Helvetica, sans-serif; + color: #FFFFFF; } + +.NavBarFont1:hover { + color: #1f77b4; } + +.NavBarCell2, .NavBarCell3 { + font-family: Arial, Helvetica, sans-serif; + background-color: #FFFFFF; + color: #222222; } diff --git a/drawing/papaya/src/papaya/BoxPlot.java b/drawing/papaya/src/papaya/BoxPlot.java new file mode 100644 index 0000000..a886939 --- /dev/null +++ b/drawing/papaya/src/papaya/BoxPlot.java @@ -0,0 +1,166 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + * + */ +package papaya; + +import java.util.Arrays; +import java.io.*; +import java.lang.Object; +import java.lang.String; + +import processing.core.*; +import processing.core.PApplet; +import processing.core.PFont; + +/** + * BoxPlot class + * + */ + +public class BoxPlot extends Visuals{ + + private float[][] fiveNumArr; + private int numDataSets; + private float minVal,maxVal; + private PApplet myParent; + + + /** + * Specifies whether to draw the bounding rectangle around the plot. + */ + public boolean drawRectangle = true; + /** + * Specifies whether to draw the axes + */ + public boolean drawAxes = true; + /** + * Specifies the space on the left between the plot area, and the + * bounding rectangle. That is, the left-most point of + * the rectangle is given by plotLeft-leftBound. + */ + public float leftBound = 40; + /** + * Specifies the space on the right betweent the plot area, and the + * bounding rectangle. That is, the right-most point of + * the rectangle is given by plotLeft+plotWidth+rightBound. + */ + public float rightBound=20; + /** + * Specifies the space on the top, between the plot area and the bounding + * rectangle. That is, the top-most point of the rectangle is given by + * plotTop - topBound. + */ + public float topBound = 20; + /** + * Specifies the space on the bottom, between the plot area and the bounding + * rectangle. That is, the bottom-most point of the rectangle is given by + * plotTop + plotHeight + bottomBound. + */ + public float bottomBound=20; + //CENTER = 3; BOTTOM = 102; TOP = 101; BASELINE = 0; LEFT = 37; RIGHT = 39; + + public BoxPlot(PApplet _theParent, float _plotLeft, float _plotTop, float _plotWidth, float _plotHeight){ + super(_theParent,_plotLeft,_plotTop,_plotWidth,_plotHeight); + myParent = _theParent; + //bgColor = super.bgColor; + } + /** + * Sets the data to be plotted. + * @param _fiveNumArr array of five number box plot summaries + * with each row corresponding to a given data set. See {@link Descriptive#tukeyFiveNum} for more info. + * + * @param _minVal the minimum value to show in the plot + * @param _maxVal the maximum value to show in the plot + */ + public void setData(float[][] _fiveNumArr, float _minVal, float _maxVal){ + fiveNumArr = _fiveNumArr; + numDataSets = fiveNumArr.length; + minVal = _minVal; + maxVal = _maxVal; + } + /** + * + * @return the tukey five number array + */ + public float[][] getData(){ + return fiveNumArr; + } + + /** + * Plot the box plots. + * @param _labels labels for the box plot + * @param _sWeight the stroke weight to use for the lines. + * @param _fColor the fill color for the boxplots + */ + public void drawBoxPlot(String[] _labels, float _sWeight, int _fColor){ + + if(drawRectangle){ + drawRect(plotLeft-leftBound,plotTop-topBound,plotWidth+leftBound+rightBound,plotHeight+topBound+bottomBound,bgColor); + } + + // Draw the box plots. + float wEach = plotWidth/(numDataSets+1); + float wBox = wEach/4; + float xPos; + if(drawAxes){ + // map the minimum and maximum values + float[] minmax = Mat.map(new float[]{minVal,maxVal},minVal,maxVal,plotTop+plotHeight,plotTop); + vertLine(minmax[0],minmax[1], plotLeft, 50,.5f); + horizLine(plotLeft + .5f*wEach, plotLeft + (numDataSets+.5f)*wEach, plotTop + plotHeight, 50,.5f); + xLabels(plotLeft + wEach, numDataSets*wEach, _labels); + xTicks(plotLeft + wEach, numDataSets*wEach, numDataSets,5); + yLabels(plotTop, plotHeight, minVal,maxVal,5); + yTicks(plotTop, plotHeight, 5 ,10); + } + + for(int i=0; itoArray(T[] a)     method specified in the java Collections + * interface, but for float[] and int[] arrays (as opposed to Float[] and Integer[]). + *

    + * + *

    + * @author Nur Adila Faruk Senan + */ +public final class Cast { + + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected Cast(){ + } + + /** + * function for casting ArrayList to int[] + * @param _inputDat ArrayList array that needs to be cast to int[] + * @return the resulting int[] array + */ + public static int[] arrayListToInt(ArrayList _inputDat){ +// if(_inputDat.size()==0){ +// System.out.println("Warning: zero length array "); +// } + int[] outputDat = new int[_inputDat.size()]; + for(int i = 0; i<_inputDat.size(); i++) + outputDat[i] = _inputDat.get(i); + return outputDat; + } + + /** + * function for casting ArrayList to float[] + * @param _inputDat ArrayList array that needs to be cast to float[] + * @return the resulting float[] array + */ + public static float[] arrayListToFloat(ArrayList _inputDat){ + float[] outputDat = new float[_inputDat.size()]; + for(int i = 0; i<_inputDat.size(); i++){ + outputDat[i] = _inputDat.get(i); + } + return outputDat; + } + + /** + * function for casting float[][] to double[][] + * @param _inputDat float[][] 2d array + * @return deep copy of _inputDat with each element cast to a double + */ + public static double[][] floatToDouble(float[][] _inputDat){ + int numColumns = _inputDat[0].length; int numRows = _inputDat.length; + double[][] outputDat = new double[numRows][numColumns]; + for(int i = 0; i theSet) { + int[] a = new int[theSet.size()]; + int i = 0; + for (Integer val : theSet) a[i++] = val; + return a; + } + /** + * Function for casting a Set to float[] + */ + public static float[] setToFloat(Set theSet) { + float[] a = new float[theSet.size()]; + int i = 0; + for (Float val : theSet) a[i++] = val; + return a; + } + + /** + * Function for casting a Set to String array. This is really just one line of code, but it's + * much easier to have it as an external function rather than having to remember it + */ + public static String[] setToString(Set theSet) { + return (String[])theSet.toArray(new String[theSet.size()]); + } + + + /** + * function for casting Vector to int[] + * @param _inputDat Vector array that needs to be cast to int[] + * @return the resulting int[] array + */ + public static int[] vectorToInt(Vector _inputDat){ + int[] outputDat = new int[_inputDat.size()]; + for(int i = 0; i<_inputDat.size(); i++) + outputDat[i] = _inputDat.get(i); + return outputDat; + } + + /** + * function for casting Vector to float[] + * @param _inputDat Vector array that needs to be cast to float[] + * @return the resulting float[] array + */ + public static float[] vectorToFloat(Vector _inputDat){ + float[] outputDat = new float[_inputDat.size()]; + for(int i = 0; i<_inputDat.size(); i++){ + outputDat[i] = _inputDat.get(i); + } + return outputDat; + } + + /** + * Returns a PVector array with the x, y, and z coordinates set to the input values + * (technically not a cast, but a reorganization). + */ + public static PVector[] floatToPVector(float[] x, float[] y, float[] z){ + int size = x.length; + Check.equalLengths(size,y); Check.equalLengths(size, z); + PVector[] p = new PVector[size]; + for(int i=0; iU and p-value for + * assessing whether one of two samples of independent observations tends to have + * larger values than the other. That is, + * 
    U = min(U1,U2)
    + * where + * 
    +	 * U1 = Sum(Ranks1)  - n1*(n1+1)/2,   
+	 * U2 = Sum(Ranks2) - n2*(n2+1)/2.
+	 *
    + * and the significance, or p-value is computed assuming + * a two-tailed null-hypothesis that both samples are similar. + * @param data1 the first dataset + * @param data2 the second dataset + * @return a 2 element array with first element corresponding to the test statistic, and second + * equal to the p-value or significance. + * @throws IllegalArgumentException if either of the sample sizes is less than 8 (the normal approximation + * is no longer valid in that case. Best to consult a table instead). + */ + public static float[] mannWhitney(float[] data1, float[] data2){ + int size1 = data1.length, size2 = data2.length; + if(size1 < 8 || size2 < 8) + throw new IllegalArgumentException("size1 and size2 need to be greater than 8."); + + float[] allData = Mat.concat(data1,data2); + float[] ranksAll = Rank.rank(allData,0); + + /* sum up the ranks of the first dataset*/ + float ranks1Sum = ranksAll[0]; + for(int i=1; ipaired     samples from X and Y and is a convenient method + * as it makes very few assumptions about the nature of the distributions under test. + *

    + *

    To elaborate, the null hypothesis H0 states that given a random pair of measurements (X[i], Y[i]), + * X[i] and Y[i] are equally likely to be larger than the other. + * Now, let n be the number of pairs for which Y[i] ≠ X[i] and w + * be the number of pairs for which Y[i] - X[i] > 0. + * Assuming that H0 is true, then W follows a binomial distribution W ~ b(n, 0.5). + * + * This method returns the sum of the terms 0 through w of the Binomial + * probability density. + * 

     
+	 * Sum_(j=0 to w)  [ (n!)/(j!*(n-j)! ]  *  [ p^j * (1-p)^(n-j) ]
+	 * from 0 to the test-statistic, or
+	 * 
    
+	 * p = Probability.binomcdf(.5,w,n).
+	 * 
    
+	 * For n > 100, the normal distribution cdf is returned instead.
+	 * If this is less than the critical value, then we can reject the null hypothesis that there
+	 * is no difference between the samples X and Y.
+	 * 
+	 * @param x data set containing 1st observation sequence
+	 * @param y data set containing 2nd observation sequence
+	 * @return the significance, or p-value, assuming a two-tailed null hypothesis (i.e. no difference)
+	 */
+	public static float signTest(float[] x, float[] y){
+		int size = x.length;
+		Check.equalLengths(size,y);
+		int numMore=0,numLess=0;
+		for(int i=0; i0) numMore++;
+			else if (val<0) numLess++;
+		}
+		int numTotal = numMore + numLess;
+		double p; 
+		int minOfTwo = Math.min(numMore,numLess);
+		if(numTotal<100){
+			p = Probability.binomcdf(.5, minOfTwo, numTotal);			
+		} else{
+			double z = (2*minOfTwo + 1 - numTotal)/Math.sqrt(numTotal);
+			p = Probability.normcdf(z);
+		}	
+		return (float)p;
+	}
+
+	/** Methods related to comparing two populations. Each method returns an array with the
+	 * first element containing the t-statistic, and the second corresponding to the 
+	 * p-value, or significance, of rejecting the null hypothesis. 
+	 * 
    
+	 * Tests can be:
      
+	 * 
    • One-sample or two-sample
      • 
+	 * 
    • One-sided or two-sided
      • 
+	 * 
    • Paired or unpaired (for two-sample tests)
      • 
+	 * 
    • Homoscedastic (equal variance assumption) or heteroscedastic
+	 * (for two sample tests)
      • 
+	 * 
    • Fixed significance level (boolean-valued) or returning p-values.
+	 * 
    
+	 * 
    
+	 * Test statistics are available for all tests.  Methods including "Test" in
+	 * in their names perform tests, all other methods return t-statistics.  Among
+	 * the "Test" methods, double-valued methods return p-values;
+	 * boolean-valued methods perform fixed significance level tests.
+	 * Significance levels are always specified as numbers between 0 and 0.5
+	 * (e.g. tests at the 95% level  use alpha=0.05).
    
+	 * 
    
+	* 
+	 * Note: Inspired by the
+	 * stats.inference.TTest class available in the Apache Commons math library. */
+	public static class TTest{
+		protected TTest(){}
+
+		/** 
+		 * Returns the t-statistic and p-value for checking whether the means 
+		 * between the two datasets are different under the assumption that both
+		 * datasets have equal variances. The p-value corresponds to the
+		 * null hypothesis of no-difference (i.e. two-tailed).
+		 * @return an array with the first element = t and the second element = p.
+		 */
+		public static float[] equalVar(float[] data1, float[] data2){
+			int[] sizes = new int[]{data1.length,data2.length};
+			float[] means = new float[]{Descriptive.mean(data1),Descriptive.mean(data2)};
+			float[] variances = new float[]{Descriptive.var(data1,true),Descriptive.var(data2,true)};
+			float pooledVariance = Descriptive.Pooled.var(variances,sizes,true);
+			float sizeSum = 1f/sizes[0] + 1f/sizes[1];
+			double t = (means[0]-means[1])/Math.sqrt(pooledVariance*sizeSum);
+			int df = sizes[0] + sizes[1] - 2;
+			float p = (float)twoTailedStudentT(t,df);
+			return new float[]{(float)t,p};
+		}
+
+		/** Returns the t-statistic and p-value for checking whether the means 
+		 * between the two datasets are different under the assumption that both
+		 * datasets have unequal variances. The p-value corresponds to the
+		 * null hypothesis of no-difference (i.e. two-tailed).
+		 * This is also known as Welch's t-test.
+		 * @return an array with the first element = t and the second element = p.
+		 */
+		public static float[] unequalVar(float[] data1, float[] data2){
+			int size1 = data1.length; int size2 = data2.length; 
+			float mean1 = Descriptive.mean(data1); float mean2 = Descriptive.mean(data2);
+			float var1 = Descriptive.var(data1,true); float var2 = Descriptive.var(data2,true);
+			float var1n1 = var1/size1; float var2n2 = var2/size2;
+			// test statistic
+			double t = (mean1-mean2)/Math.sqrt(var1n1 + var2n2);
+			// df
+			double numerator = (var1n1 + var2n2)*(var1n1 + var2n2);
+			double denominator = var1n1*var1n1/(size1-1) + var2n2*var2n2/(size2-1);
+			double df = (numerator/denominator);
+			float p = (float)twoTailedStudentT(t,df);
+			return new float[]{(float)t,p};
+		}
+
+		/** 
+		 * Returns the t-statistic and p-value for checking a pair of dependent samples.
+		 * That is, when there is only one sample that has been tested twice
+		 * (repeated measures) or when there are two samples that have been 
+		 * matched or "paired". The p-value corresponds to the
+		 * null hypothesis of no-difference in both measurements (i.e. two-tailed).
+		 * 
    Both datasets have to have equal lengths.
+		 * @param before the dataset before treatment/measurement.
+		 * @param after the dataset after treatment/measurement.
+		 * @return an array with the first element = t and the second element = p.
+		 */
+		public static float[] paired(float[] before, float[] after){
+			int size = before.length;
+			Check.equalLengths(size,after);
+			float[] diff =new float[size];
+			float sum = 0;
+			for (int i = 0; i < size; i++) {
+				diff[i] += after[i]-before[i];
+				sum+=diff[i];
+			}	
+			float mean = sum/size;
+			float sd = Descriptive.std(diff,false) / (float)Math.sqrt(size);
+			double t = mean/sd;
+			float p = (float)twoTailedStudentT(t,size-1);
+			return new float[]{(float)t,p};
+		}
+
+
+		/** Returns the welch's t-test degree of freedom */		 
+		protected static float welchdf(float[] data1, float[] data2){
+			int size1 = data1.length; int size2 = data2.length; 
+			float var1 = Descriptive.var(data1,true); 
+			float var2 = Descriptive.var(data2,true);
+			float var1n1 = var1/size1; float var2n2 = var2/size2;
+			double numerator = (var1n1 + var2n2)*(var1n1 + var2n2);
+			double denominator = var1n1*var1n1/(size1-1) + var2n2*var2n2/(size2-1);
+			return (float)(numerator/denominator);
+		}
+
+	}
+	private static double twoTailedNormal(double z){
+		if(z>0) return ( 2*(1.0- (Probability.normcdf(z)) ) );
+		else return (2 * (Probability.normcdf(z)));
+	}
+
+	private static double twoTailedStudentT(double t, double df){
+		if(t>0) return ( 2*(1.0- (Probability.tcdf(t,df)) ) );
+		else return (2 * (Probability.tcdf(t,df)));
+	}
+
+
+	/**
+	 * Non-parametric statistical hypothesis test used when comparing two related samples
+	 * or repeated measurements on a single sample to assess whether their population mean 
+	 * ranks differ (i.e. it's a paired difference test).
+	 * It can be used as an alternative to the paired Student's t-test when the 
+	 * population cannot be assumed to be normally distributed or the data is on the ordinal scale.
+	 * 
    Note: 
+	 * If we wish to make an inference about the mean (or about the median) difference, 
+	 * then we assume the distribution of the differences is symmetric. 
+	 * If we only want to test the hypothesis that the probability that the sum of a randomly 
+	 * chosen pair of differences exceeding zero is 0.5 then no distributional assumption is needed.
+	 * 
    
+	 */
+	//Wilcoxon signed-rank test
+
+	/** A non-parametric method for testing whether samples originate from the same distribution.
+	 * It is used for comparing more than two samples that are independent, or not related. 
+	 * The parametric equivalence of the Kruskal-Wallis test is the one-way analysis of variance (ANOVA). 
+	 * The factual null hypothesis is that the populations from which the samples originate, 
+	 * have the same median. 
+	 * When the Kruskal-Wallis test leads to significant results, 
+	 * then at least one of the samples is different from the other samples. 
+	 * The test does not identify where the differences occur or how many 
+	 * differences actually occur. 
+	 * It is an extension of the Mann?Whitney U test to 3 or more groups.
+	 * The Mann-Whitney would help analyze the specific sample pairs for significant differences.
+	 *
+	 * 
     Since it is a non-parametric method, the Kruskal?Wallis test does not assume a normal distribution, 
+	 * unlike the analogous one-way analysis of variance. 
+	 * However, the test does assume an identically-shaped and scaled distribution for each group, 
+	 * except for any difference in medians.
+	 * */
+	// Kruskal-Wallis test.
+
+}
diff --git a/drawing/papaya/src/papaya/Correlation.java b/drawing/papaya/src/papaya/Correlation.java
new file mode 100644
index 0000000..b094040
--- /dev/null
+++ b/drawing/papaya/src/papaya/Correlation.java
@@ -0,0 +1,546 @@
+/**
+ * papaya: A collection of utilities for Statistics and Matrix-related manipulations
+ * http://adilapapaya.com/papayastatistics/, 1.1.0
+ * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014
+ *
+ *
+ * Copyright (C) 2014 Adila Faruk http://adilapapaya.com 
+ * Copyright 1999 CERN - European Organization for Nuclear Research.
+ * Copyright 1995 Stephen L.Moshier.
+ * 
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA  02111-1307  USA
+ */
+
+package papaya;
+import java.util.*;
+import java.io.*;
+import processing.core.*;
+
+/**
+ * Contains utilities related to computing covariances, as well as linear and rank correlation.
+ * Methods relating to computing 
+ * 
      
+ * 
    • normal correlations and covariances (biased or unbiased) are in the main class.
+ * 
    • weighted correlation and covariances are in the {@link Weighted} subclass.
+ * 
    • significance of the correlations (i.e. p-values) are in the {@link Significance} subclass.
+ * 
    
+ * Whatever it is, remember that correlation does not always imply causation.
+ */
+public final class Correlation implements PapayaConstants {
+	/**
+	 * Makes this class non instantiable, but still let's others inherit from it.
+	 */
+	protected Correlation() {}
+	/**
+	 * Computes the sample autocorrelation by removing the sample mean from the input series,
+	 * then normalizing the sequence by the sample variance. That is, it returns
+	 * 
    +	 * R(lag) = E[ (X[t] - mu) * ( X[t+lag] - mu ) ] / variance(X).	
+	 * where 
+	 * E[ (X[t] - mu) * ( X[t+lag] - mu ) ]  = 1/size(X) * Sum_(i=0 to size-lag)( (X[t]-mu)*X[t+lag]-mu) ). 
+	 * 
    
+	 * Reference: Box, G. E. P., G. M. Jenkins, and G. C. Reinsel. 
+	 * Time Series Analysis: Forecasting and Control. 3rd ed.
+	 * Upper Saddle River, NJ: Prentice-Hall, 1994.
+	 * 
    
+	 * @param data the array of data
+	 * @param lag the lag value. Has to be smaller than the data sequence length
+	 * @param mean the data mean
+	 * @param variance the data variance
+	 * @return the autocorrelation value
+	 */
+	public static float auto(float[] data, int lag, float mean, float variance) {
+		int size = data.length;
+		if (lag >= size) throw new IllegalArgumentException("Lag is too large");
+	    if(lag==0) return 1f;
+		double run = 0;
+		for( int i=0; i=1) return 1f;
+		if(autocorr<=-1) return -1f;
+		return autocorr;
+	}
+
+	/**
+	 * Returns the lag-1 autocorrelation of a dataset; 
+	 * Note that this method uses computations different from 
+	 * auto(data, 1, mean, variance).
+	 */
+	public static float autoLag1(float[] data, float mean) {
+		int size = data.length;
+		double r1 ;
+		double q = 0 ;
+		double v = (data[0] - mean) * (data[0] - mean) ;
+
+		for (int i = 1; i < size ; i++) {
+			double delta0 = (data[i-1] - mean);
+			double delta1 = (data[i] - mean);
+			q += (delta0 * delta1 - q)/(i + 1);
+			v += (delta1 * delta1 - v)/(i + 1);
+		}
+		r1 = q / v ;
+		return (float)r1;
+	}	
+	/**
+	 * Returns the (Pearson Product Moment) correlation matrix between multiple columns of a matrix
+	 * with each column corresponding to a dataset, and each row an observation.
+	 * That is, given P columns, data1, data2, ... , dataP,
+	 * each of length n, it computes and returns the P-by-P correlation
+	 * matrix, C with each element CJK given by
+	 * 
    +	 * CJK = CKJ = corr(dataJ,dataK,unbiasedValue).
+	 * 
    
+	 * @param data The input data. Each column corresponds to a dataset; 
+	 * each row corresponds to an observation 
+	 * @param unbiased set to true to return the unbiased correlation,
+	 * false to return the biased version.
+	 * @return the correlation matrix (symmetric, by definition)
+	 */
+	public static float[][] linear(float[][] data, boolean unbiased){	
+		int numColumns = data[0].length;
+		int size = data.length;
+		float[][] corrMat = new float[numColumns][numColumns];	
+		float[] data1 = new float[size], data2 = new float[size];	
+		for(int c1=0; c1
+	 * corr = cov(x,y,unbiasedValue)/sqrt( cov(x,x, unbiasedValue)*cov(y,y,unbiasedValue) )
+	 *
    + * @param unbiased set to true to return the unbiased correlation, + * false to return the biased version. + */ + public static float linear(float[] data1, float[] data2, boolean unbiased) { + float denom = cov(data1,data1,unbiased)*cov(data2,data2,unbiased); + return cov(data1,data2,unbiased)/(float)Math.sqrt(denom); + } + + /** + * Computes Spearman's rank-correlation, or rho, between multiple columns of a matrix + * with each column corresponding to a dataset, and each row an observation. + * That is, each pair of columns are first converted to ranks rXJ, rXK + * and the correlation between the ranks computed using the Pearson correlation coefficient + * formula. + * @param unbiased set to true to return the unbiased correlation, + * false to return the biased version. + */ + public static float[][] spearman(float[][] data, boolean unbiased){ + + int numColumns = data[0].length; + int size = data.length; + float[][] corrMat = new float[numColumns][numColumns]; + float[] data1 = new float[size], data2 = new float[size]; + for(int c1=0; c1rho. + * That is, the raw dataset Xi,Yi are first converted to ranks rXi, rYi + * and the correlation between the ranks computed using the Pearson correlation coefficient + * formula. + * @param unbiased set to true to return the unbiased correlation, + * false to return the biased version. + */ + public static float spearman(float[] x, float[] y, boolean unbiased){ + int size = x.length; + Check.equalLengths(size,y); + float[] rX = Rank.rank(x,0); + float[] rY = Rank.rank(y,0); + float rs = linear(rX,rY,unbiased); + //System.out.print("\nx = \t"); Mat.print(x,1); + //System.out.print("\ny = \t"); Mat.print(y,1); + //System.out.println("\nrX = "); Mat.print(rX,1); + //System.out.println("\nrY = "); Mat.print(rY,1); + return rs; + } + /** + * Computes Kendall's rank correlation or tau between two datasets. + * That is, the raw dataset Xi,Yi are first converted to ranks rXi, rYi + * and tau computed as + * 
    tau = (nC - nD)/(sqrt(n0-n1)*sqrt(n0-n2))
    + * where + *
    nC is the number of concordant pairs
    + *
    nD is the number of discordant pairs
    + *
    n0 is the sum of ranks = n*(n-1)/2
    + *
    n1 is the sum of tied ranks in dataset 1
    + *
    n2 is the sum of tied ranks in dataset 2
    + * @param unbiased set to true to return the unbiased correlation, + * false to return the biased version. + */ +// public static float kendall(float[] x, float[] y, boolean unbiased){ +// int size = x.length; +// Check.equalLengths(size,y); +// float[] rX = Rank.rank(x,0); +// float[] rY = Rank.rank(y,0); +// //int nConcordant = +// float rs = linear(rX,rY,unbiased); +// return rs; +// } + + /** + * Returns the covariance of two data sequences data1 and data2, + * each of length N. That is, + * 
     
+	 * cov(data1, data2) = E(  (data1[i] - mean(data1))* (data2[i] - mean(data2)) ),
+	 *
    + * where E is the mathematical expectation. + *

    + * cov(x,y,true) normalizes by N - 1, if N > 1, where N is the number of observations. + * This makes cov(x,y,true) the best unbiased estimate of the covariance matrix if the + * observations are from a normal distribution. For N = 1, cov(x,y,true) normalizes by N. + *

    + * cov(x,y,false) normalizes by N and produces the second moment matrix of the observations + * about their mean. + * @param data1 x + * @param data2 y + * @param unbiased set to true to return the unbiased covariance (division by N-1), + * false to return the biased version (division by N). + */ + public static float cov(float[] data1, float[] data2, boolean unbiased) { + int size = data1.length; + Check.equalLengths(size,data2); + Check.size0(size); + + float sumx = data1[0], sumy = data2[0], Sxy=0; + for (int i=1; iP columns, data1, data2, ... , dataP, + * each of length n, it computes and returns the P-by-P covariance + * matrix, S with each element SJK given by + * 

    +	 * SJK = SKJ = cov(dataJ,dataK,bias).	
+	 *
    + * + * cov(data,true) normalizes by N - 1, if N > 1, where N is the number of observations + * (or the number of rows in the input matrix). + * This makes cov(data,true) the best unbiased estimate of the covariance matrix if the + * observations are from a normal distribution. For N = 1, cov(data) normalizes by N. + * + *

    + * cov(data,false) normalizes by N and produces the second moment matrix of the observations + * about their mean. + * @param data Each column corresponds to a dataset; each row corresponds to an observation + * @param unbiased set to true to return the unbiased covariance matrix, false to return the biased version. + */ + public static float[][] cov(float[][] data, boolean unbiased) { + int numColumns = data[0].length; + int size = data.length; + float[] data1 = new float[size], data2 = new float[size]; + float[][] covMat = new float[numColumns][numColumns]; + for(int c1=0; c1 + * C_JK = S_JK / sqrt(S_JJ,unbiasedValue)*sqrt(S_KK,unbiasedValue). + * + * See {@link Weighted#cov(float[][],boolean)}. + * @param data input matrix each column corresponding to a sample, each row an observation. + * @param weights the weights to use. + * @param unbiased set to true to return the unbiased weighted correlation matrix, false to return the biased version. + */ + public static float[][] corr(float[][] data, float[] weights, boolean unbiased){ + int size = data.length; + int numColumns = data[0].length; + float[][] corr= new float[numColumns][numColumns]; + float[][] cov = cov(data,weights,unbiased); + for(int c1=0; c1 + * The formula used to compute element S_JK of the unbiased covariance matrix is: + * 

    +		 * S_JK = biasCorrection * Sum ( w[i] * ( dataJ[i] - mu_w(dataJ) )*( dataK[i] - mu_w(dataK) ) ) / Sum (w[i])
+		 *
    + * where mu_w corresponds to the weighted mean of the dataset + * and the biasCorrection term above is + * 
    +		 * biasCorrection = ( Sum(w[i]) )^2  / ( ( Sum(w[i]) )^2 - Sum( w[i]^2 )  ).
+		 *
    + * The elements of the biased covariance matrix are computed sans the bias Correction factor. + *

    + * Reference: + * Covariance of weighted samples, wikipedia.org. + * @param data input matrix each column corresponding to a sample, each row an observation. + * @param weights the weights to use. + * @param unbiased set to true to return the unbiased weighted covariance matrix, false to return the biased version. + */ + public static float[][] cov(float[][] data, float[] weights, boolean unbiased){ + int size = data.length; + int numColumns = data[0].length; + float[][] cov = new float[numColumns][numColumns]; + for(int c1=0; c1not to be used for small datasets(i.e. size<20). + */ + public static class Significance{ + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected Significance(){}; + /** + * + * The Durbin-Watson statistic is a test statistic used to detect the presence + * of autocorrelation ({@link Correlation#auto}) + * in the residuals (prediction errors) from a regression analysis. + *

    + * If e_t is the residual associated with the observation at time t, + * and there are T observations, then the test statistic, d is + *

    + * 
    +		 * d =   Sum_{from t=2 to T} ( e_t - e_{t-1} )^2    /   Sum_{from t=1 to T} ( e_t )^2
+		 *
    + * @return d the Durbin Watson test statistic + */ + public static float durbinWatson(float[] data) { + int size = data.length; + if (size < 2) throw new IllegalArgumentException("data sequence must contain at least two values."); + + float run = 0; + float run_sq = 0; + run_sq = data[0] * data[0]; + for(int i=1; ir + * between two datasets under the null hypothesis of no correlation. + * That is, H_0: ρ=0 (No linear correlation; Two-tailed test). The p-value is + * computed by transforming the correlation to create a t-statistic + * having n-2 degrees of freedom: + * 
     t = r * sqrt( (n-2)/(1-r^2) ),
    + * where n is the size of the corresponding datasets. + * @param r the linear correlation coefficient + * @param size the size of the corresponding datasets (i.e. number of rows/observations). + * @throws IllegalArgumentException if the size is less than 20. Below this, + * the student-T approximation is inaccurate. + */ + public static float linear(float r, int size){ + double t = studentT(r,size-2); + return (float)twoTailedStudentT(t,size-2); + + } + /** + * Returns the p-value, or significance level of the Spearman rank-correlation rho + * between two datasets under the null hypothesis of no correlation. + * That is, H_0: ρ_0=0 (No linear correlation; Two-tailed test). + * The p-value is computed by transforming the correlation to create a t-statistic + * having n-2 degrees of freedom: + * 
     t = rho * sqrt( (n-2)/(1-rho^2) ),
    + * where n is the size of the corresponding datasets. + * @param rho the Spearman-correlation coefficient + * @param size the size of the corresponding datasets (i.e. number of rows/observations). + * @throws IllegalArgumentException if the size is less than 20. Below this, + * the student-T approximation is inaccurate. + */ + public static float spearman(float rho, int size){ + Check.size20(size); + double t = studentT(rho,size-2); + return (float)twoTailedStudentT(t,size-2); + } + + /** + * Returns the Fisher transformation of the input correlation coefficient. That is, + * 
    F(r) = atanh(r);
    + * @param corrcoef the correlation coefficient, r + * @return F(r) + */ + private static double fisher(float corrcoef){ + if(corrcoef==1) return MAXLOG; + if(corrcoef==-1) return MINLOG; + if(corrcoef==0) return 0.0f; + double log = Math.log((1+corrcoef)/(1-corrcoef)); + return (.5*log); + } + /** + * Returns the Student-T test statistic of the input correlation coefficient. That is, + * 
    t = abs(r) * sqrt( df/(1-r^2) ), 		df = size-2.
    + * @param corrcoef the correlation coefficient, r + * @param df the degrees of freedom. Corresponds to size-2 + */ + private static double studentT(float corrcoef, int df){ + if(corrcoef==1) return MAXLOG; + if(corrcoef==-1) return MINLOG; + if(corrcoef==0) return 0.0f; + return corrcoef*Math.sqrt( (df)/(1-corrcoef*corrcoef) ); + } + + private static double twoTailedNormal(double z){ + if(z>0) return ( 2*(1.0- (Probability.normcdf(z)) ) ); + else return (2 * (Probability.normcdf(z))); + } + + private static double twoTailedStudentT(double t, int df){ + if(t>0) return ( 2*(1.0- (Probability.tcdf(t,df)) ) ); + else return (2 * (Probability.tcdf(t,df))); + } + + /** + * Returns the z value of the Spearman rank-correlation. + * That is, + * 
    z = sqrt((n-3)(1.06)) * F(r), 		F(r) = atanh(r);
    + * @param corrcoef the correlation coefficient, r + * @param size the size of the dataset + */ + private static double zSpearman(float corrcoef, int size){ + Check.size3(size); + double f = fisher(corrcoef); + return Math.sqrt((size-3)/1.06)*f; + } + }// end test class +}// end Correlation class diff --git a/drawing/papaya/src/papaya/CorrelationPlot.java b/drawing/papaya/src/papaya/CorrelationPlot.java new file mode 100644 index 0000000..75e49de --- /dev/null +++ b/drawing/papaya/src/papaya/CorrelationPlot.java @@ -0,0 +1,161 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; +import java.util.Arrays; +import java.io.*; +import java.lang.Object; +import java.lang.String; + +import processing.core.*; + +/** + * Takes in a matrix and plots the data in each of the columns versus + * each other. Each of the columns are normalized to their minimum and maximum values which + * can be a little misleading. For example, say you are looking at columns specifying the weight + * of different panda bears over 100 days. + * Panda bear A (Ling-Ling)'s weight varies from 650 to 970 pounds + * (she's an emotional eater), while panda bear B (Thomas)'s weight varies from 512 to 516 pounds + * (he's not a big fan of bamboo; also kind of metrosexual). The correlation plot will not show you + * this difference in magnitudes or ranges! + * There are many ways of addressing that, and all of them involve you writing your + * own code. :) + *

    If you absolutely insist on using this despite the warning above, then the (somewhat messy) hack + * around it is to pad each column of your data with 2 additional rows containing the + * minimum and maximum that you want to abide by. Just make sure it doesn't muck everything + * else up though! + */ +public class CorrelationPlot extends Visuals{ + + + protected PApplet myParent; + + /**width and height of the individual plots */ + private float w; + private float h; + private int numColumns; + + //CENTER = 3; BOTTOM = 102; TOP = 101; BASELINE = 0; LEFT = 37; RIGHT = 39; + + /** Setup the plot dimensions */ + public CorrelationPlot(PApplet _theParent, float _plotLeft, float _plotTop, float _plotWidth, float _plotHeight){ + super(_theParent,_plotLeft,_plotTop,_plotWidth,_plotHeight); + myParent = _theParent; + bgColor = super.bgColor; + } + + /** + * Plots the scatter plot of each of the columns of the input data matrix vs. the + * other columns. Each of the columns are normalized to their minimum and maximum values which + * can be a little misleading. For example, say you are looking at columns specifying the weight + * of different panda bears over 100 days. + * Panda bear A (Ling-Ling)'s weight varies from 450 to 670 pounds + * (she's an emotional eater), while panda bear B (Thomas)'s weight varies from 512 to 516 pounds + * (he's not a big fan of bamboo). The correlation plot will not show you this difference + * since both could follow the same sort of distribution. + * + * There are many ways of addressing that, and all of them involve you writing your + * own code. :) + *

    If you absolutely insist on using this despite the warning above, then the (very messy) hack + * around it is to pad each column of your data with 2 additional rows containing the + * minimum and maximum that you want to abide by. Just make sure it doesn't muck everything + * else up though! + * + * @param data the data array with each column corresponding to a dataset + * @param pos 0 for top right plots, 1 for bottom left plots + * @param fColor the fill color for the dots on the plot. + */ + public void drawPlot(float[][] data, int pos, int fColor){ + if(pos!=0 && pos!=1) + throw new IllegalArgumentException("Set pos to 0 for top right plots or 1 for bottom left plots."); + if(numColumns!=data[0].length) + throw new IllegalArgumentException("Number of categories doesn't match the number of columns in the matrix."); + + w = plotWidth/numColumns; + h = plotHeight/numColumns; + + float x,y; + + for(int r=0; r + * 2012 rolls along, and Adila (hello!) finds the library and modifies it for Processing, adding a + * number of new methods and updating some of the present ones, all while talking about + * herself in the third person. :) + */ + +package papaya; +import java.util.*; +import java.io.*; +import processing.core.*; + +/** + * Basic descriptive statistics class for exploratory data analysis. + * Methods for computing Correlations and Covariances are in the {@link Correlation} + * class. Where appropriate, methods with similar functions are grouped into + * static subclasses. For example, the {@link Sum} class contains the following + * methods: + *

      + *
    • {@link Sum#inversions} + *
    • {@link Sum#logs} + *
    • {@link Sum#products} + *
    • {@link Sum#powerDeviations} + *
    • {@link Sum#powers} + *
    • {@link Sum#squaredDeviations} + *
    • {@link Sum#squares} + *
    • {@link Sum#sum} + *
    + * while the {@link Mean} class has the + *
      + *
    • {@link Mean#columnMean} + *
    • {@link Mean#rowMean} + *
    • {@link Mean#arithmetic} + *
    • {@link Mean#geometric} + *
    • {@link Mean#harmonic} + *
    • {@link Mean#trimmed} + *
    + * utilities. + */ +public class Descriptive extends Object { + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected Descriptive() {} + + /** + * Checks if the given range is within the contained array's bounds. + * @throws IndexOutOfBoundsException if to!=from-1 || from<0 || from>to || to>=size. + */ + protected static void checkRangeFromTo(int from, int to, int theSize) { + if (to==from-1) return; + if (from<0 || from>to || to>=theSize) + throw new IndexOutOfBoundsException("from: "+from+", to: "+to+", size="+theSize); + } + /** + * + * Computes the frequency (number of occurances, count) of each distinct value in the given sorted data. + * After this call, both distinctValues and frequencies have a new size (which is equal for both), + * which is the number of distinct values in the sorted data. + *

    + * Distinct values are filled into distinctValues, starting at index 0. + * The frequency of each distinct value is filled into frequencies, starting at index 0. + * As a result, the smallest distinct value (and its frequency) can be found at index 0, + * the second smallest distinct value (and its frequency) at index 1, ..., + * the largest distinct value (and its frequency) at index distinctValues.size()-1. + *

    + * Example: + *
    + * sortedData = (5,6,6,7,8,8) --> distinctValues = (5,6,7,8), frequencies = (1,2,1,2) + *

    + * Code-wise, you would write: + * 
     
+	 * ArrayList distinctValues = new ArrayList(); 
+	 * 
+	 * ArrayList frequencies = new ArrayList();  
+	 * 
+	 * frequencies(sortedData,distinctValues,frequencies);
+	 *
    + * + * @param sortedData the data; must be sorted ascending. + * @param distinctValues a ArrayList to be filled with the distinct values; can have any size. + * @param frequencies a ArrayList to be filled with the frequencies; can have any size; + * set this parameter to null to ignore it. + * + * @see Frequency + * @see Unique + */ + public static void frequencies(float[] sortedData, ArrayList distinctValues, ArrayList frequencies) { + distinctValues.clear(); + if (frequencies!=null) frequencies.clear(); + + int size = sortedData.length; + int i=0; + + while (i + * This method computes those updated values without needing to know the already recorded elements. + * This is interesting for interactive online monitoring and/or applications that cannot keep the entire huge data sequence in memory. + *

    + *
    Definition of sumOfSquares: sumOfSquares(data) = Sum ( data[i] * data[i] ). + * + * @param data the additional elements to be incorporated into min, max, etc. + * @param from the index of the first element within data to consider. + * @param to the index of the last element within data to consider. + * The method incorporates elements data[from], ..., data[to]. + * @param inOut the old values in the following format: + *

      + *
    • inOut[0] is the old minimum. + *
    • inOut[1] is the old maximum. + *
    • inOut[2] is the old sum. + *
    • inOut[3] is the old sum of squares. + *
    + * If no data sequence elements have so far been recorded set the values as follows + *
      + *
    • inOut[0] = Float.POSITIVE_INFINITY as the old minimum. + *
    • inOut[1] = Float.NEGATIVE_INFINITY as the old maximum. + *
    • inOut[2] = 0.0 as the old sum. + *
    • inOut[3] = 0.0 as the old sum of squares. + *
    + *

    + * @return the updated values filled into the inOut array. + */ + + public static void sumOfSquares(float[] data, int from, int to, double[] inOut) { + checkRangeFromTo(from,to,data.length); + + // read current values + double min = inOut[0]; + double max = inOut[1]; + double sum = inOut[2]; + double sumSquares = inOut[3]; + + for (int i=from; i<=to; i++) { + float element = data[i]; + sum += element; + sumSquares += element*element; + if (element < min) min = element; + if (element > max) max = element; + + /* + double oldDeviation = element - mean; + mean += oldDeviation / (N+1); + sumSquaredDeviations += (element-mean)*oldDeviation; // cool, huh? + */ + + /* + double oldMean = mean; + mean += (element - mean)/(N+1); + if (N > 0) { + sumSquaredDeviations += (element-mean)*(element-oldMean); // cool, huh? + } + */ + + } + + // store new values + inOut[0] = min; + inOut[1] = max; + inOut[2] = sum; + inOut[3] = sumSquares; + + // At this point of return the following postcondition holds: + // data.length-from elements have been consumed by this call. + } + + /** + * Incrementally maintains and updates various sums of powers of the form Sum(data[i]k). + * + * Assume we have already recorded some data sequence elements data[i] + * and know the values of Sum(data[i]from), Sum(data[i]from+1), ..., Sum(data[i]to). + * Assume further, we are to record some more elements + * and to derive updated values of these sums. + *

    + * This method computes those updated values without needing to know the already recorded elements. + * This is interesting for interactive online monitoring and/or applications that cannot keep the entire huge data sequence in memory. + * For example, the incremental computation of moments is based upon such sums of powers: + *

    + * The moment of k-th order with constant c of a data sequence, + * is given by Sum( (data[i]-c)k ) / data.size(). + * It can incrementally be computed by using the equivalent formula + *

    + * moment(k,c) = m(k,c) / data.size() where + *
    m(k,c) = Sum( -1i * b(k,i) * ci * sumOfPowers(k-i)) for i = 0 .. k and + *
    b(k,i) = {@link cern.jet.math.Arithmetic#binomial(long,long) binomial(k,i)} and + *
    sumOfPowers(k) = Sum( data[i]k ). + *

    + * @param data the additional elements to be incorporated into min, max, etc. + * @param from the index of the first element within data to consider. + * @param to the index of the last element within data to consider. + * The method incorporates elements data[from], ..., data[to]. + * + * @param inOut the old values of the sums in the following format: + *

      + *
    • sumOfPowers[0] is the old Sum(data[i]fromSumIndex). + *
    • sumOfPowers[1] is the old Sum(data[i]fromSumIndex+1). + *
    • ... + *
    • sumOfPowers[toSumIndex-fromSumIndex] is the old Sum(data[i]toSumIndex). + *
    + * If no data sequence elements have so far been recorded set all old values of the sums to 0.0. + * + * @return the updated values filled into the sumOfPowers array. + */ + public static void sumOfPowers(float[] data, int from, int to, int fromSumIndex, int toSumIndex, double[] sumOfPowers) { + int size = data.length; + int lastIndex = toSumIndex - fromSumIndex; + if (from > size || lastIndex+1 > sumOfPowers.length) throw new IllegalArgumentException(); + + // optimized for common parameters + if (fromSumIndex==1) { // handle quicker + if (toSumIndex==2) { + double sum = sumOfPowers[0]; + double sumSquares = sumOfPowers[1]; + for (int i=from-1; ++i<=to; ) { + float element = data[i]; + sum += element; + sumSquares += element*element; + //if (element < min) min = element; + //else if (element > max) max = element; + } + sumOfPowers[0] += sum; + sumOfPowers[1] += sumSquares; + return; + } + else if (toSumIndex==3) { + double sum = sumOfPowers[0]; + double sumSquares = sumOfPowers[1]; + double sum_xxx = sumOfPowers[2]; + for (int i=from-1; ++i<=to; ) { + float element = data[i]; + sum += element; + sumSquares += element*element; + sum_xxx += element*element*element; + //if (element < min) min = element; + //else if (element > max) max = element; + } + sumOfPowers[0] += sum; + sumOfPowers[1] += sumSquares; + sumOfPowers[2] += sum_xxx; + return; + } + else if (toSumIndex==4) { // handle quicker + double sum = sumOfPowers[0]; + double sumSquares = sumOfPowers[1]; + double sum_xxx = sumOfPowers[2]; + double sum_xxxx = sumOfPowers[3]; + for (int i=from-1; ++i<=to; ) { + float element = data[i]; + sum += element; + sumSquares += element*element; + sum_xxx += element*element*element; + sum_xxxx += element*element*element*element; + //if (element < min) min = element; + //else if (element > max) max = element; + } + sumOfPowers[0] += sum; + sumOfPowers[1] += sumSquares; + sumOfPowers[2] += sum_xxx; + sumOfPowers[3] += sum_xxxx; + return; + } + } + + if (fromSumIndex==toSumIndex || (fromSumIndex >= -1 && toSumIndex <= 5)) { // handle quicker + for (int i=fromSumIndex; i<=toSumIndex; i++) { + sumOfPowers[i-fromSumIndex] += Sum.powerDeviations(data,i,0.0f,from,to); + } + return; + } + // now the most general case: + // optimized for maximum speed, but still not quite quick + for (int i=from-1; ++i<=to; ) { + float element = data[i]; + double pow = Math.pow(element,fromSumIndex); + + int j=0; + for (int m=lastIndex; --m >= 0; ) { + sumOfPowers[j++] += pow; + pow *= element; + } + sumOfPowers[j] += pow; + } + // At this point of return the following postcondition holds: + // data.size()-fromIndex elements have been consumed by this call. + } + /** + * Incrementally maintains and updates sum and sum of squares of a weighted data sequence. + * + * Assume we have already recorded some data sequence elements + * and know their sum and sum of squares. + * Assume further, we are to record some more elements + * and to derive updated values of sum and sum of squares. + *

    + * This method computes those updated values without needing to know the already recorded elements. + * This is interesting for interactive online monitoring and/or applications that cannot keep the entire huge data sequence in memory. + *

    + *
    Definition of sum: sum = Sum ( data[i] * weights[i] ). + *
    Definition of sumOfSquares: sumOfSquares = Sum ( data[i] * data[i] * weights[i]). + * + * + * @param data the additional elements to be incorporated into min, max, etc. + * @param weights the weight of each element within data. + * @param from the index of the first element within data (and weights) to consider. + * @param to the index of the last element within data (and weights) to consider. + * The method incorporates elements data[from], ..., data[to]. + * @param inOut the old values in the following format: + *

      + *
    • inOut[0] is the old sum. + *
    • inOut[1] is the old sum of squares. + *
    + * If no data sequence elements have so far been recorded set the values as follows + *
      + *
    • inOut[0] = 0.0 as the old sum. + *
    • inOut[1] = 0.0 as the old sum of squares. + *
    + * + * @return the updated values filled into the inOut array. + */ + public static void sumOfSquaresWeighted(float[] data, float[] weights, int from, int to, float[] inOut) { + int dataSize = data.length; + checkRangeFromTo(from,to,dataSize); + if (dataSize != weights.length) throw new IllegalArgumentException("from="+from+", to="+to+", data.length="+dataSize+", weights.length="+weights.length); + + // read current values + float sum = inOut[0]; + float sumOfSquares = inOut[1]; + + for (int i=from-1; ++i<=to; ) { + float element = data[i]; + float weight = weights[i]; + float prod = element*weight; + + sum += prod; + sumOfSquares += element * prod; + } + + // store new values + inOut[0] = sum; + inOut[1] = sumOfSquares; + + // At this point of return the following postcondition holds: + // data.size()-from elements have been consumed by this call. + } + + }// end IncrUpdate class + /** + * Returns the kurtosis (aka excess) of a data sequence. + * @param moment4 the fourth central moment, which is moment(data,4,mean). + * @param standardDeviation the standardDeviation. + */ + public static float kurtosis(float moment4, float standardDeviation) { + return -3 + moment4 / (standardDeviation * standardDeviation * standardDeviation * standardDeviation); + } + /** + * Returns the kurtosis (aka excess) of a data sequence, which is + * -3 + moment(data,4,mean) / standardDeviation4. + */ + public static float kurtosis(float[] data, float mean, float standardDeviation) { + return kurtosis(moment(data,4,mean), standardDeviation); + } + + public static int max(int a, int b) { + return (a > b) ? a : b; + } + + public static float max(float a, float b) { + return (a > b) ? a : b; + } + + + public static double max(double a, double b) { + return (a > b) ? a : b; + } + + + /** + * Returns the largest member of a data sequence. + */ + public static double max(double[] data) { + int size = data.length; + Check.size0(size); + double max = data[size-1]; + for (int i = size-1; --i >= 0;) { + if (data[i] > max) max = data[i]; + } + return max; + } + /** + * Returns the largest member of a data sequence. + */ + public static float max(float[] data) { + int size = data.length; + Check.size0(size); + float max = data[0]; + for (int i = 0; iSum( data[i] ) / data.length . + */ + public static float arithmetic(float[] data) { + return Sum.sum(data) / data.length; + } + + /** + * Returns the geometric mean of a data sequence. + * Note that for a geometric mean to be meaningful, the minimum of the data sequence must not be less or equal to zero. + *
    + * The geometric mean is given by pow( Product( data[i] ), 1/size) + * which is equivalent to Math.exp( Sum( Log(data[i]) ) / size). + *

    + * The latter version is used here is the former easily results in overflows. + */ + public static float geometric(int size, float sumOfLogarithms) { + return (float)Math.exp(sumOfLogarithms/size); + // this version would easily results in overflows + //return Math.pow(product, 1/size); + } + /** + * Returns the geometric mean of a data sequence. + * Note that for a geometric mean to be meaningful, the minimum of the data sequence must not be less or equal to zero. + *
    + * The geometric mean is given by pow( Product( data[i] ), 1/data.size()). + * This method tries to avoid overflows at the expense of an equivalent but somewhat slow definition: + * geometricMean = Math.exp( Sum( Log(data[i]) ) / size). + */ + public static float geometric(float[] data) { + return geometric(data.length, (float)Sum.logs(data,0,data.length-1)); + } + /** + * Returns the harmonic mean of a data sequence. + * + * @param size the number of elements in the data sequence. + * @param sumOfInversions Sum( 1.0 / data[i]). + */ + public static float harmonic(int size, float sumOfInversions) { + return size / sumOfInversions; + } + + /** + * Returns the harmonic mean of a data sequence as Sum( 1.0 / data[i]). + * + * @param data array + */ + public static float harmonic(float[] data) { + return (float)data.length / (float)Sum.inversions(data, 0, data.length-1); + } + /** + * Returns the trimmed arithmetic mean of a sorted data sequence. + * @param sortedData the data sequence; must be sorted ascending. + * @param mean the mean of the (full) sorted data sequence. + * @param left the number of leading elements to trim. + * @param right the number of trailing elements to trim. + * */ + public static float trimmed(float[] sortedData, float mean, int left, int right) { + int size = sortedData.length; + Check.size0(size); + if (left+right >= size) throw new IllegalArgumentException("Not enough data. left: "+left+", right: "+right+", data length: "+ size); + int origLn=size; + for(int i=0; imust be sorted ascending. + * @param mean the mean of the (full) sorted data sequence. + * @param left the number of leading elements to trim. + * @param right the number of trailing elements to trim. + */ + public static float winsorized(float[] sortedData, float mean, int left, int right) { + int size = sortedData.length; + Check.size0(size); + if (left+right >= size) throw new IllegalArgumentException("Not enough data."); + + float leftElement = sortedData[left]; + float winsorMean = mean; + for(int i=0; iarithmetic mean of a data sequence; + * That is Sum( data[i] ) / data.length . + * Similar to {@link Mean#arithmetic}. + */ + public static float mean(float[] data) { + return Mean.arithmetic(data); + } + /** + * Returns the mean deviation of a dataset. + * That is Sum( Math.abs(data[i]-mean)) ) / data.length. + */ + public static float meanDeviation(float[] data, float mean) { + + int size = data.length; + double sum=0; + for (int i=size; --i >= 0;) sum += Math.abs(data[i]-mean); + return (float)sum/size; + } + + /** + * Returns the median of a data sequence. + * @param data the data sequence; + * @param isSorted true if the data sequence is sorted (in ascending order), else false. + */ + public static float median(float[] data, boolean isSorted) { + if(isSorted) return quantile(data, 0.5f); + else{ + float[] sortedData = Mat.copyThenSort(data); + return quantile(sortedData, 0.5f); + } + } + + public static int min(int a, int b) { + return (a < b) ? a : b; + } + + public static float min(float a, float b) { + return (a < b) ? a : b; + } + public static double min(double a, double b) { + return (a < b) ? a : b; + } + /** + * Returns the smallest member of a data sequence. + */ + public static double min(double[] data) { + int size = data.length; + Check.size0(size); + double min = data[0]; + for (int i = 1; i distinctValues = new ArrayList(); + ArrayList frequencies = new ArrayList(); + frequencies(data,distinctValues,frequencies); + int maxRepeats = frequencies.get(0); int size = frequencies.size(); + for(int i=1; imaxRepeats) { + maxRepeats = frequencies.get(i); + } + } + ArrayList tempMod = new ArrayList(); + for(int i=0; ik-th order with constant c of a data sequence, + * which is Sum( (data[i]-c)k ) / data.length. + * + * @param sumOfPowers sumOfPowers[m] == Sum( data[i]m) ) for m = 0,1,..,k as returned by method + * {@link #incrementalUpdateSumsOfPowers(DoubleArrayList,int,int,int,int,double[])}. + * In particular there must hold sumOfPowers.length == k+1. + * @param size the number of elements of the data sequence. + */ + // public static float moment(int k, float c, int size, float[] sumOfPowers) { + // double sum=0; + // int sign = 1; + // for (int i=0; i<=k; i++) { + // double y; + // if (i==0) y = 1; + // else if (i==1) y = c; + // else if (i==2) y = c*c; + // else if (i==3) y = c*c*c; + // else y = Math.pow(c, i); + // //sum += sign * + // sum += sign * cern.jet.math.Arithmetic.binomial(k,i) * y * sumOfPowers[k-i]; + // sign = -sign; + // } + // /* + // for (int i=0; i<=k; i++) { + // sum += sign * cern.jet.math.Arithmetic.binomial(k,i) * Math.pow(c, i) * sumOfPowers[k-i]; + // sign = -sign; + // } + // */ + // return sum/size; + // } + /** + * Returns the moment of k-th order with constant c of a data sequence, + * which is Sum( (data[i]-c)k ) / data.size(). + */ + public static float moment(float[] data, int k, float c) { + return (float)Sum.powerDeviations(data,k,c) / data.length; + } + /** + * Returns the array containing all elements in the dataset that are less than + * or equal to the lowerLimit + * and more than or equal to the upperLimit + * @param data the data array + * @param lowerLimit + * @param upperLimit + * @param isSorted true if the data array has been sorted in ascending order, else set to false. + */ + public static float[] outliers(float[] data, float lowerLimit, float upperLimit, boolean isSorted){ + int size = data.length; + float[] sortedData = new float[size]; + if(isSorted){ + sortedData = data; + } + else{ + sortedData = Mat.copyThenSort(data); + } + float max = sortedData[size-1]; float min = sortedData[0]; + float[] tempArray = new float[size]; + int i=0; + if(lowerLimit>=min){ + while(sortedData[i]<=lowerLimit){ + tempArray[i] = sortedData[i]; + i++; + } + } + int newSize = i; + i = size-1; + if(upperLimit<=max){ + while(sortedData[i]>=upperLimit){ + tempArray[i] = sortedData[i]; + i--; + newSize++; + } + } + float[] outliers = Arrays.copyOf(tempArray,newSize); + //Arrays.sort(outliers); + return outliers; + } + + /** Class for computing the pooled mean and variance of data sequences */ + public static class Pooled{ + protected Pooled(){} + + /** + * Returns the pooled mean of two data sequences. + * That is (size1 * mean1 + size2 * mean2) / (size1 + size2). + *

    + * @param size1 the number of elements in data sequence 1. + * @param mean1 the mean of data sequence 1. + * @param size2 the number of elements in data sequence 2. + * @param mean2 the mean of data sequence 2. + */ + public static float mean(float mean1, int size1, float mean2, int size2) { + return (size1 * mean1 + size2 * mean2) / (size1 + size2); + } + /** + * Returns the pooled mean of a k data sequences. + * That is (size1 * mean1 + size2 * mean1 + ... + sizek * meank) / (size1 + size2 + ... + sizek). + *

    + * + */ + public static float mean(float[] means, int[] sizes) { + int size = sizes.length; + Check.equalLengths(size,means); + float sum=0, sumSizes=0; + for(int i=0; i + * unbiasedPooledVar = Sum( (size_i -1)*variance_i ) / Sum( (size_i-1) ), + * + * while the biased pooled variance is computed using + * 

    +		 * biasedPooledVar = Sum( (size_i)*variance_i ) / Sum(size_i),
+		 * 
+		 * For more than 2 datasets, use {@link Pooled#var(float[],int[],boolean)}.
+		 *
+		 * @param size1 the number of elements in data sequence 1.
+		 * @param variance1 the variance of data sequence 1.
+		 * @param size2 the number of elements in data sequence 2.
+		 * @param variance2 the variance of data sequence 2.
+		 * @param unbiased set to true to return the unbiased pooled variance,
+		 * false to return the biased version.
+		 */
+		public static float var(float variance1, int size1, float variance2, int size2, boolean unbiased) {
+			if(!unbiased) return (size1 * variance1 + size2 * variance2) / (size1 + size2);
+			else return((size1-1)*variance1+(size2-1)*variance2)/(size1+size2-2);
+		}
+		/**
+		 * Returns the pooled variance of k data sequences. The unbiased estimate of the
+		 * pooled variance is computed as
+		 * 
    +		 * unbiasedPooledVar = Sum( (sizes[i] -1)*variances[i] ) / Sum( (sizes[i]-1) ),
+		 * 
    
+		 * while the biased pooled variance is computed using
+		 * 
    +		 * biasedPooledVar = Sum( (sizes[i])*variances[i] ) / Sum(sizes[i]),
+		 */
+		public static float var(float[] variances, int[] sizes, boolean unbiased) {
+			int size = sizes.length;
+			Check.equalLengths(size, variances);
+			float sizeSum = sizes[0];
+			float varianceSum=0;
+			float pooledVar = 0;
+			if(unbiased){
+				for(int i=0; iProd( data[i] ).
+	 * In other words: data[0]*data[1]*...*data[data.length-1].
+	 * This method uses the equivalent definition:
+	 * prod = pow( exp( Sum( Log(x[i]) ) / length*length).
+	 */
+	public static float product(int size, float sumOfLogarithms) {
+		return (float)Math.pow(Math.exp(sumOfLogarithms/size), size);
+	}
+	/**
+	 * Returns the product of a data sequence, which is Prod( data[i] ).
+	 * In other words: data[0]*data[1]*...*data[data.length-1].
+	 * Note that you may easily get numeric overflows. Use {@link product(int,float)}
+	 * instead to avoid that.
+	 */
+	public static float product(float[] data) {
+		int size = data.length;
+		float product = 1;
+		for (int i=size; --i >= 0;) product *= data[i];
+		return product;
+	}
+
+	/** 
+	 * Returns the quartiles of the input data array (not necessarily sorted).
+	 * 
+	 * 
    Details:
    
+	 * The first quartile, or lower quartile (Q[0]), is the value that cuts off 
+	 * the first 25% of the data when it is sorted in ascending order. 
+	 * The second quartile, or median (Q[1]), is the value that cuts off the first 50%.
+	 * The third quartile, or upper quartile (Q[2], is the value that cuts off the first 75%.
+	 * 
    
+	 * 
+	 * @param data The data array.
+	 * @param isSorted true if the data array has been sorted in ascending order, else set to false.
+	 * @return The 3 quartile values Q[0], Q[1], and Q[2].
+	 */
+	public static float[] quartiles(float[] data, boolean isSorted){	
+		float[] quartiles = new float[3];
+		if(isSorted){
+			quartiles = Descriptive.quantiles(data, new float[]{.25f,.5f,.75f});
+		}
+		else{
+			quartiles = Descriptive.quantiles(Mat.copyThenSort(data), new float[]{.25f,.5f,.75f});
+		}
+		return quartiles;
+	}
+
+	/**
+	 * Returns the phi-quantile; that is, an element elem 
+	 * for which holds that phi percent of data elements are less than 
+	 * elem.
+	 * The quantile need not necessarily be contained in the data sequence, 
+	 * it can be a linear interpolation.
+	 * @param sortedData the data sequence; must be sorted ascending.
+	 * @param phi the percentage; must satisfy 0 <= phi <= 1.
+	 */
+	public static float quantile(float[] sortedData, float phi) {
+
+		int size = sortedData.length;
+
+		float index = phi * (size - 1) ;
+		int lhs = (int)index ;
+		float delta = index - lhs ;
+		float result;
+
+		if (size == 0) return 0.0f ;
+
+		if (lhs == size - 1) {
+			result = sortedData[lhs] ;
+		}
+		else {
+			result = (1 - delta) * sortedData[lhs] + delta * sortedData[lhs + 1] ;
+		}
+		return result ;
+	}
+	/**
+	 * Returns how many percent of the elements contained in the receiver are <= element.
+	 * Does linear interpolation if the element is not contained but lies in between 
+	 * two contained elements.
+	 *
+	 * @param sortedList the list to be searched (must be sorted ascending).
+	 * @param element the element to search for.
+	 * @return the percentage phi of elements <= element 
+	 * (0.0 <= phi <= 1.0).
+	 */
+	public static float quantileInverse(float[] sortedList, float element) {
+		return rankInterpolated(sortedList,element) / sortedList.length;
+	}
+	/**
+	 * Returns the quantiles of the specified percentages.
+	 * The quantiles need not necessarily be contained in the data sequence, it can be a linear interpolation.
+	 * @param sortedData the data sequence; must be sorted ascending.
+	 * @param percentages the percentages for which quantiles are to be computed.
+	 * Each percentage must be in the interval [0.0f,1.0f].
+	 * @return the quantiles.
+	 */
+	public static float[] quantiles(float[] sortedData, float[] percentages) {
+		int s = percentages.length;
+		ArrayList quantiles = new ArrayList(s);
+		for (int i=0; i < s; i++) {
+			quantiles.add(quantile(sortedData, percentages[i]));
+		}
+		return Cast.arrayListToFloat(quantiles);
+	}
+	/**
+	 * Returns the linearly interpolated number of elements in an array that 
+	 * are ≤ a given element.
+	 * The rank is the number of elements ≤ element.
+	 * Ranks are of the form {0, 1, 2,..., sortedList.size()}.
+	 * 
     If no element is ≤ element, then the rank is zero.
    
+	 * 
+	 * 
    If the element lies in between two contained elements, then 
+	 * linear interpolation is used and a non integer value is returned.
    
+	 *
+	 * @param sortedList the list to be searched (must be sorted ascending).
+	 * @param element the element to search for.
+	 * @return the rank of the element.
+	 */
+	public static float rankInterpolated(float[] sortedList, float element) {
+		int index = Arrays.binarySearch(sortedList,element);
+		if (index >= 0) { // element found
+			// skip to the right over multiple occurances of element.
+			int to = index+1;
+			int s = sortedList.length;
+			while (toMath.sqrt(Sum( data[i]*data[i] ) / data.length).
+	 * The RMS of data sequence is the square-root of the mean of the squares of the elements in the data sequence.
+	 * It is a measure of the average "size" of the elements of a data sequence.
+	 *
+	 * @param sumOfSquares sumOfSquares(data) == Sum( data[i]*data[i] ) of the data sequence.
+	 * @param size the number of elements in the data sequence.
+	 */
+	public static float rms(int size, double sumOfSquares) {
+		return (float)Math.sqrt(sumOfSquares/size);
+	}
+	
+	/**
+	 * Contains sample-related statistical methods.
+	 */
+	private static class Sample{
+		protected Sample(){}
+		/**
+		 * Returns the sample kurtosis (aka excess) of a data sequence.
+		 * That is, 
+		 * 
    +		 * γ_2 = moment4*n^2*(n+1)/ ((n-1)*(n-2)*(n-3)*var^2) - 3*(n-1)^2/ ( (n-2)*(n-3) ) 
+		 *     = Sum( (y_i-ymean)^4 )*n*(n+1)/ ((n-1)*(n-2)*(n-3)*var^2) - 3*(n-1)^2/ ( (n-2)*(n-3) ), 
+		 * 
    
+		 * where n is the length of the input data array.
+		 * 
    
+		 * Ref: R.R. Sokal, F.J. Rohlf, Biometry: the principles and practice of statistics
+		 * in biological research (W.H. Freeman and Company, New York, 1998, 3rd edition)
+		 * p. 114-115.
+		 *
+		 * @param size the number of elements of the data sequence.
+		 * @param moment4 the fourth central moment, which is moment(data,4,mean).
+		 * @param sampleVariance the sample variance.
+		 */
+		public static float sampleKurtosis(int size, float moment4, float sampleVariance) {
+			float n=size; // set to float to avoid NaNs.
+			float s2=sampleVariance; // (y-ymean)^2/(n-1)
+			float m4 = moment4*n;    // (y-ymean)^4
+			return m4*n*(n+1) / ( (n-1)*(n-2)*(n-3)*s2*s2 )
+					- 3.0f*(n-1)*(n-1)/((n-2)*(n-3));
+		}
+		/**
+		 * Returns the sample kurtosis (aka excess) of a data sequence.
+		 */
+		public static float sampleKurtosis(float[] data, float mean, float sampleVariance) {
+			return sampleKurtosis(data.length,moment(data,4,mean), sampleVariance);
+		}
+		/**
+		 * Return the standard error of the sample kurtosis. That is,
+		 * 
    +		 * Sqrt( 24n*(n-1)*(n-1)/((n-3)*(n-2)*(n+3)*(n+5)) ), 
+		 * 
    
+		 * where n is the length of the input array.
+		 * 
    
+		 * Ref: R.R. Sokal, F.J. Rohlf, Biometry: the principles and practice of statistics
+		 * in biological research (W.H. Freeman and Company, New York, 1998, 3rd edition)
+		 * p. 138.
+		 * @param size the number of elements of the data sequence.
+		 */
+		public static float sampleKurtosisStandardError(int size) {
+			float n=size; // set to float to avoid NaNs.
+			return (float)Math.sqrt( 24.0*n*(n-1)*(n-1)/((n-3)*(n-2)*(n+3)*(n+5)) );
+		}
+		/**
+		 * Returns the sample skew of a data sequence. That is
+		 * 
    +		 * γ_1 = moment3*n^2 / ((n-1)*(n-2)*stdev^3)
+		 *     = Sum( (y_i-ymean)^3 )/stdev^3  *  n /  ((n-1)*(n-2)), 
+		 * 
    
+		 * where n is the length of the input data array.
+		 * 
    
+		 * Ref: R.R. Sokal, F.J. Rohlf, Biometry: the principles and practice of statistics
+		 * in biological research (W.H. Freeman and Company, New York, 1998, 3rd edition)
+		 * p. 114-115.
+		 * @param size the number of elements of the data sequence.
+		 * @param moment3 the third central moment, which is moment(data,3,mean).
+		 * @param sampleVariance the sample variance.
+		 */
+		public static float sampleSkew(int size, float moment3, float sampleVariance) {
+			float  n=size; // set to float to avoid NaNs
+			float s=(float)Math.sqrt(sampleVariance); // sqrt( (y-ymean)^2/(n-1) )
+			float m3 = moment3*n;    // (y-ymean)^3
+			return n*m3 / ((n-1)*(n-2)*s*s*s);
+		}
+		/**
+		 * Returns the sample skew of a data sequence.
+		 */
+		public static float sampleSkew(float[] data, float mean, float sampleVariance) {
+			return sampleSkew(data.length, moment(data,3,mean), sampleVariance);
+		}
+		/**
+		 * Return the standard error of the sample skew. That is,
+		 * 
    +		 * Sqrt( 6n*(n-1)/((n-2)*(n+1)*(n+3)) ), 
+		 * 
    
+		 * where n is the length of the input array.
+		 * 
    
+		 * Ref: R.R. Sokal, F.J. Rohlf, Biometry: the principles and practice of statistics
+		 * in biological research (W.H. Freeman and Company, New York, 1998, 3rd edition)
+		 * p. 138.
+		 *
+		 * @param size the number of elements of the data sequence.
+		 */
+		public static float sampleSkewStandardError(int size) {
+			float n=size;
+			return (float)Math.sqrt( 6.0*n*(n-1)/((n-2)*(n+1)*(n+3)) );
+		}
+	}
+	
+	/**
+	 * Returns the skew of a data sequence when the 3rd moment has already been computed.
+	 * @param moment3 the third central moment, which is moment(data,3,mean).
+	 * @param standardDeviation the standardDeviation.
+	 */
+	public static float skew(float moment3, float standardDeviation) {
+		return moment3 / (standardDeviation * standardDeviation * standardDeviation);
+	}
+	/**
+	 * Returns the skew of a data sequence, which is moment(data,3,mean) / standardDeviation3.
+	 */
+	public static float skew(float[] data, float mean, float standardDeviation) {
+		return skew(moment(data,3,mean), standardDeviation);
+	}
+	
+	/**
+	 * Returns the standard deviation of a dataset.
+	 * 
+	 * There are two definitions of the standard deviation:
+	 * 
    +	 * sigma_1 = 1/(N-1) * Sum( (x[i] - mean(x))^2 )
+	 * sigma_2 = 1/(N) * Sum( (x[i] - mean(x))^2 )
+	 * 
    
+	 * sigma_1 is the square root of an unbiased estimator of the variance of the population
+	 * the x is drawn, as long as x consists of independent, identically distributed samples.
+	 * sigma_2 corresponds to the second moment of the set of values about their mean.
+	 * 
    
+	 * std(data,unbiased==true) returns sigma_1 above, while std(data,unbiased==false) returns sigma_2.
+	 * @param data the dataset  
+	 * @param unbiased set to true to return the unbiased standard deviation,
+	 * false to return the biased version.
+	 */
+	public static float std(float[] data, boolean unbiased) {
+		return (float)Math.sqrt(var(data,unbiased));
+	}
+	
+	
+	/**
+	 * Returns an array with each element of the array corresponding to
+	 * the standard deviations of each column of the input
+	 * matrix. Each column of the matrix corresponds to a dataset, and each row an observation.
+	 * 
+	 * There are two definitions of the standard deviation:
+	 * 
    +	 * sigma_1 = 1/(N-1) * Sum( (x[i] - mean(x))^2 )
+	 * sigma_2 = 1/(N) * Sum( (x[i] - mean(x))^2 )
+	 * 
    
+	 * sigma_1 is the square root of an unbiased estimator of the variance of the population
+	 * the x is drawn, as long as x consists of independent, identically distributed samples.
+	 * sigma_2 corresponds to the second moment of the set of values about their mean.
+	 * 
    
+	 * std(data,unbiased==true) returns sigma_1 above, while std(data,unbiased==false) returns sigma_2.
+	 * 
+	 * @param data the dataset
+	 * @param unbiased set to true to return the unbiased standard deviation,
+	 * false to return the biased version.
+	 */
+	public static float[] std(float[][] data, boolean unbiased) {
+		int numColumns = data[0].length; 
+		float[] std = new float[numColumns];
+		float[] dataEach = new float[data.length];
+		float variance = 0;
+		for(int i=0; inormally distributed.
+	 *
+	 * Ref: R.R. Sokal, F.J. Rohlf, Biometry: the principles and practice of statistics
+	 * in biological research (W.H. Freeman and Company, New York, 1998, 3rd edition)
+	 * p. 53.
+	 * 
    See also this entry on wikipedia.org
+	 *
+	 * @param size the number of elements of the data sequence.
+	 * @param sampleVariance the sample variance.
+	 */
+	public static float stdUnbiased(int size, float sampleVariance) {
+		double s, Cn;
+		int   n=size;
+		// The standard deviation calculated as the sqrt of the variance underestimates
+		// the unbiased standard deviation.
+		s=Math.sqrt(sampleVariance);
+		// It needs to be multiplied by this correction factor.
+		if (n>30) {
+			Cn = 1 + 1.0/(4*(n-1)); // Cn = 1+1/(4*(n-1));
+		} else {
+			Cn =  Math.sqrt((n-1)*0.5)*Gamma.gamma((n-1)*0.5)/Gamma.gamma(n*0.5);
+		}
+		return (float) (Cn*s);
+	}
+
+	/** Methods for computing  various different sums of datasets such as sum of inversions,
+	 * logs, products, power deviations, squares, etc. */
+	 
+	public static class Sum{
+		protected Sum(){};
+		/**
+		 * Returns the sum of inversions of a data sequence,
+		 * which is Sum( 1.0 / data[i]).
+		 * @param data the data sequence.
+		 * @param from the index of the first data element (inclusive).
+		 * @param to the index of the last data element (inclusive).
+		 */
+		public static double inversions(float[] data, int from, int to) {
+			return powerDeviations(data,-1,0.0f,from,to);
+		}
+		/**
+		 * Returns the sum of logarithms of a data sequence, which is Sum( Log(data[i]).
+		 * @param data the data sequence.
+		 * @param from the index of the first data element (inclusive).
+		 * @param to the index of the last data element (inclusive).
+		 */
+		public static double logs(float[] data, int from, int to) {
+			double logsum = 0;
+			for (int i=from-1; ++i <= to;) logsum += Math.log(data[i]);
+			return (float)logsum;
+		}
+		/**
+		 * Returns the sum of the product of two data arrays, Sum( x[i] * y[i]).
+		 * @param data1 the first data sequence.
+		 * @param data2 the second data sequence
+		 * @return the sum of the product of the two data sequences.
+		 */
+		public static double products(float[] data1, float[] data2) {
+			int size = data1.length;
+			Check.equalLengths(size,data2);
+
+			double sumOfProduct = data1[0]*data2[0];
+			for (int i=1; iSum( (data[i]-c)k ); 
+		 * optimized for common parameters like c == 0.0 and/or k == -2 .. 4.
+		 */
+		public static double powerDeviations(float[] data, int k, float c) {
+			return powerDeviations(data,k,c,0,data.length-1);
+		}
+		/**
+		 * Returns Sum( (data[i]-c)k ) for all i = from .. to; 
+		 * optimized for common parameters like c == 0.0 and/or k == -2 .. 5.
+		 * Note that no checks are made for divisions by zero (important for  
+		 * k = -2 and k = -1), so think twice before using this
+		 * if the data has elements = 0.
+		 */
+
+		public static double powerDeviations(final float[] data, final int k, final float c, final int from, final int to) {
+
+			double sum = 0.0;
+			double v;
+			int i;
+			switch (k) { // optimized for speed
+			case -2: 
+				if (c==0.0) for (i=from-1; ++i<=to; ) { v = data[i]; sum += 1/(v*v); }
+				else for (i=from-1; ++i<=to; ) { v = data[i]-c; sum += 1/(v*v); }
+				break;
+			case -1:
+				if (c==0.0) for (i=from-1; ++i<=to; ) sum += 1/(data[i]);
+				else for (i=from-1; ++i<=to; ) sum += 1/(data[i]-c);
+				break;
+			case 0: 
+				sum += to-from+1;
+				break;
+			case 1: 
+				if (c==0.0) for (i=from-1; ++i<=to; ) sum += data[i];
+				else for (i=from-1; ++i<=to; ) sum += data[i]-c;
+				break;
+			case 2: 
+				if (c==0.0) for (i=from-1; ++i<=to; ) { v = data[i]; sum += v*v; }
+				else for (i=from-1; ++i<=to; ) { v = data[i]-c; sum += v*v; }
+				break;
+			case 3: 
+				if (c==0.0) for (i=from-1; ++i<=to; ) { v = data[i]; sum += v*v*v; }
+				else for (i=from-1; ++i<=to; ) { v = data[i]-c; sum += v*v*v; }
+				break;
+			case 4: 
+				if (c==0.0) for (i=from-1; ++i<=to; ) { v = data[i]; sum += v*v*v*v; }
+				else for (i=from-1; ++i<=to; ) { v = data[i]-c; sum += v*v*v*v; }
+				break;
+			case 5: 
+				if (c==0.0) for (i=from-1; ++i<=to; ) { v = data[i]; sum += v*v*v*v*v; }
+				else for (i=from-1; ++i<=to; ) { v = data[i]-c; sum += v*v*v*v*v; }
+				break;
+			default:
+				for (i=from-1; ++i<=to; ) sum += Math.pow(data[i]-c, k);
+				break;
+			}
+			return sum;
+		}
+		/**
+		 * Returns the sum of powers of a data sequence, which is Sum ( data[i]k ).
+		 */
+		public static double powers(float[] data, int k) {
+			return powerDeviations(data,k,0);
+		}
+		/**
+		 * Returns the sum of squared mean deviation of of a data sequence.
+		 * That is variance * (size-1) == Sum( (data[i] - mean)^2 ).
+		 *
+		 * @param size the number of elements of the data sequence. 
+		 * @param variance the variance of the data sequence.
+		 */
+		public static float squaredDeviations(int size, float variance) {
+			return variance * (size-1);
+		}
+		/**
+		 * Returns the sum of squares of a data sequence.
+		 * That is Sum ( data[i]*data[i] ).
+		 */
+		public static double squares(float[] data) {
+			return powerDeviations(data,2,0.0f);
+		}
+		/**
+		 * Returns the simple sum of a data sequence.
+		 * That is Sum( data[i] ). 
+		 * @see Mat#sum(float[])  
+		 * @see Mat#sum(float[], float[])  
+		 * @see Mat#sum(float[],float)  
+		 */
+		public static float sum(float[] data) {
+			return (float)Sum.powerDeviations(data,1,0.0f);
+		}
+	} // end Sum class
+	
+	/**
+	 * Return the tukey five number summary of a dataset consisting of the minimum, maximum,
+	 * and three quartile values.
+	 * @param data the data array
+	 * @return the array of five numbers.
+	 */
+	public static float[] tukeyFiveNum(float[] data){
+		int size = data.length;
+		float[] sortedArray = Mat.copyThenSort(data);		
+		float[] Q = quartiles(sortedArray, true);
+		float[] fiveNum = new float[5];
+		fiveNum[0] = sortedArray[0]; 
+		fiveNum[4]=sortedArray[size-1];
+		fiveNum[1] = Q[0]; fiveNum[2] = Q[1]; fiveNum[3] = Q[2];
+		return fiveNum;
+	}
+
+	/**
+	 * Returns the variance of a dataset, V. 
+	 * For matrices, var(X,unbiased=true) returns an array containing the variance of each column of X. 
+	 * The result V is an unbiased estimator of the variance of the population from which
+	 * X is drawn, as long as X consists of independent, identically distributed samples.
+	 * 
    
+	 * var(x,true) normalizes V by N - 1 if N > 1, where N is the sample size. 
+	 * This is an unbiased estimator of the variance of the population from which X is drawn, 
+	 * as long as X consists of independent, identically distributed samples. For N = 1, 
+	 * V is normalized by 1.
+	 * 
    
+	 * V = var(x,false) normalizes by N and produces the second moment of the sample about its mean. 
+	 * 
+	 * 
    Reference: 
+	 * 
    
+	 *    Algorithms for calculating variance, Wikipedia.org
+	 * 
    
+	 * Incremental calculation of weighted mean and variance, Tony Finch 
+	 * @param data the data sequence. 
+	 * @param unbiased set to true to return the unbiased variance (division by (N-1)), false to return the biased value (division by N).
+	 * @return the variance in the data.
+	 */
+	public static float var(float[] data, boolean unbiased) {
+		int size = data.length;
+		float varianceSum = varianceNotNormalized(data);
+		if(unbiased && size>1) return varianceSum/(size-1);
+		return varianceSum/size;
+	}
+	
+	/**
+	 * Returns an array containing the variance of each column of the input matrix X. 
+	 * The result V is an unbiased estimator of the variance of the population from which
+	 * X is drawn, as long as X consists of independent, identically distributed samples.
+	 * 
    
+	 * var(X,unbiased=true) normalizes V by N - 1 if N > 1, where N is the sample size. 
+	 * This is an unbiased estimator of the variance of the population from which X is drawn, 
+	 * as long as X consists of independent, identically distributed samples. For N = 1, 
+	 * V is normalized by 1.
+	 * 
    
+	 * V = var(X,unbiased=false) normalizes by N and produces the second moment of the sample about its mean. 
+	 *
+	 * 
    Reference: 
+	 * 
    
+	 *    Algorithms for calculating variance, Wikipedia.org
+	 * 
    
+	 * Incremental calculation of weighted mean and variance, Tony Finch 
+	 * @param data the data sequence. 
+	 * @param unbiased set to true to return the unbiased variance (division by (N-1)), false to return the biased value (division by N).
+	 * @return the variance in the data.
+	 */
+	public static float[] var(float[][] data, boolean unbiased) {
+		int numColumns = data[0].length; 
+		float[] variances = new float[numColumns];
+		float[] dataEach = new float[data.length];
+		for(int i=0; inot been normalized
+	 * by the size.
+	 * 
    
+	 * formula: var(data) = (Sum.squares(data) - mean(data)^2) / size
+	 */
+	protected static float varianceNotNormalized(float[] data){
+		float size = data.length;
+		float mean = data[0]; 
+		float varianceSum = 0;	
+		for(int i = 1; i < size; ++i) {
+			float stepSum = data[i]-mean; // deviation of data from previous mean
+			mean += stepSum/(i+1); // mean_at_step_k = mean_at_step_k-1 + (data[k] - mean_at_step_k-1) / k
+			varianceSum+=stepSum*(data[i]-mean);
+		}
+		return varianceSum;
+	}
+	
+	
+	/**
+	 * Contains methods related to weighted datasets.
+	 */
+	public static class Weighted{
+		protected Weighted(){}
+		/**
+		 * Returns the weighted mean of a data sequence. Used when the values in a set of 
+		 * data do not share equal importance.
+		 * That is  Sum (data[i] * weights[i]) / Sum ( weights[i] ).
+		 */
+		public static float mean(float[] data, float[] weights) {
+			int size = data.length;
+			Check.equalLengths(size,weights);	
+			float sum = 0.0f;
+			float weightsSum = 0.0f;
+			for (int i=size; --i >= 0; ) {
+				sum += data[i] * weights[i];
+				weightsSum += weights[i];
+			}
+			return sum/weightsSum;
+		}
+		/**
+		 * Returns the weighted RMS (Root-Mean-Square) of a data sequence.
+		 * That is Sum( data[i] * data[i] * weights[i]) / Sum( data[i] * weights[i] ),
+		 * or in other words sumOfProducts / sumOfSquaredProducts.
+		 *
+		 * @param sumOfProducts == Sum( data[i] * weights[i] ).
+		 * @param sumOfSquaredProducts == Sum( data[i] * data[i] * weights[i] ).
+		 */
+		public static float rms(float sumOfProducts, float sumOfSquaredProducts) {
+			return sumOfProducts / sumOfSquaredProducts;
+		}
+		
+
+		/**
+		 * Returns the weighted variance of a data sequence of length N
+		 * There are (unfortunately) many different definitions of the unbiased weighted variance. 
+		 * Here, we use the following formula 
+		 * 
    +		 * weighted.var(x,w,unbiased=true) = biasCorrection * Sum ( w[i] * (x[i] - mu_w)^2  ) / Sum(w[i]).
+		 * 
    
+		 * where mu_w corresponds to the weighted mean and the biasCorrection
+		 * term 
+		 * 
    +		 * biasCorrection = ( Sum(w[i]) )^2  / ( ( Sum(w[i]) )^2 - Sum( w[i]^2 )  ).
+		 * 
    
+		 * corrects for the bias in the variance. 
+		 * weighted.var(x,w,unbiased=false) computes the biased weighted variance and is given by the formula above,
+		 * but without the correction factor.
+		 * 
+		 * 
    The formula above agrees with that presented in
+		 * 
+		 * the NIST Information Technology Laboratory page.
+		 * The algorithm used, is a one-pass formula credited to
+		 * "D. H. D. West (1979). Communications of the ACM, 22, 9, 532-535: 
+		 * Updating Mean and Variance Estimates: An Improved Method", and spelled out under the  
+		 * 
    
+		 * weighted incremental algorithm section of the link.
+		 * 
+		 * @param unbiased set to true to return the unbiased variance (division by (N-1)), false to return the biased value (division by N).
+		 * @return the weighted variance.
+		 */
+		public static float var(float[] data, float[] weights, boolean unbiased) {
+			int size = data.length;
+			Check.equalLengths(size,weights);
+			if(size==1) return 0;
+			float weightSum = weights[0]; // Sum of weights from 0 to i
+			float varianceSum = 0; 
+			float mean = data[0];
+			float weightSumSquared = weights[0]*weights[0];
+
+			/** at step i:
+			  mean= meanOld +weights[i]/weightSum * (data[i] - meanOld)
+			  S[i]+= weights[i]*(data[i] - meanOld)*(data[i] - mean)
+			 */
+			for(int i=1; i(x-mean)/standardDeviation
+	 */
+	public static float zScore(float x, float mean, float standardDeviation){
+		return (x-mean)/standardDeviation;
+	}
+
+	/**
+	 * Returns the array of z-scores for a given data array.
+	 * with each elment given by
+	 * z[i] = ( x[i] - mean ) / standardDeviation.
+	 * @return the standardized array, z
+	 */
+	public static float[] zScore(float[] x, float mean, float standardDeviation){
+		float[] z = new float[x.length];
+		for(int i=0; ij, of the output is given by
+	 * Z[i][j] = ( X[i][j]- mean(X[,j]) / standardDeviation(X[,j])
+	 * where mean(X[,j]) is the mean value of column j of X.
+	 */
+	public static float[][] zScore(float[][] X, float[] means, float[] standardDeviations){
+		int numRows = X.length; int numColumns = X[0].length;
+		float[][] z = new float[numRows][numColumns];
+		Check.equalLengths(numColumns,means);
+		Check.equalLengths(numColumns,standardDeviations);
+		for(int i=0; i
+ * For an m-by-n input matrix with m observations and n variables, the output D is 
+ * the symmetric m-by-m matrix with zeros along the diagonals and element ij 
+ * specifying the distance between rows i and j.
+ * 
+ */
+public final class Distance {
+
+	/**
+	 * Makes this class non instantiable, but still let's others inherit from it.
+	 */
+	protected Distance(){
+
+	}
+
+	/**
+	 * Computes the cityblock (or Manhattan) distance matrix between pairs of objects 
+	 * in the m-by-n data matrix X. That is,
+	 * 
    +	 * Dist[i][j] = (X[i][1] - X[j][1]) + (X[i][2] - X[j][2]) + ... + (X[i][n] - X[j][n]). 
+	 * 
    
+	 * 
    
+	 * Rows of X correspond to observations, and columns correspond to variables. 
+	 * Returns the m-by-m matrix D with D[r1][r2] corresponding to the cityblock
+	 * (or manhattan) distance between the rows of the input X.
+	 */
+	public static float[][] cityblock(float[][] X){
+		int numRows = X.length; int numColumns = X[0].length;
+		float[][] distMatrix = new float[numRows][numRows];
+		double val = 0.0;
+		for(int r = 0; r
+	 * Dist[i][j] =Max( |X[i][1] - X[j][1]| , |X[i][2] - X[j][2]| , ... , |(X[i][n] - X[j][n]|). 
+	 * 
    
+	 * 
    
+	 * Rows of X correspond to observations, and columns correspond to variables. 
+	 * Returns the m-by-m matrix D with D[r1][r2] corresponding to the Chebychev
+	 * distance between the rows of the input X.
+	 */
+	public static float[][] chebychev(float[][] X){
+		int numRows = X.length; int numColumns = X[0].length;
+		float[][] distMatrix = new float[numRows][numRows];
+		double val = 0.0;
+		for(int r = 0; r
+	 * Dist[1][2] = 1 -  sum_{j=1^numColumns} ( ( y1_j - mean(y1) ) * ( y2_j - mean(y2) ) / ( n * std(y1)*std(y2) ) ), 
+	 *
    + * where n = number of columns. + *

    + * Rows of X correspond to observations, and columns correspond to variables. + * Returns the m-by-m matrix D with D[r1][r2] corresponding to the correlation + * distance between the rows of the input X. + */ + public static float[][] correlation(float[][] X){ + int numRows = X.length; int numColumns = X[0].length; + float[][] distMatrix = new float[numRows][numRows]; + float[] mean = new float[numRows]; float[] std = new float[numRows]; + for(int i=0; i + * Dist[1][2] = 1- sum_{j=1^numColumns} ( y1_j * y2_j ) / ( mag(y1)*mag(y2) ), + * + * where mag(y1) = sum_{i=1 to numColumns} (y1[j]*y1[j]) and likewise + * for mag(y2). + * etc. + *

    + * Rows of X correspond to observations, and columns correspond to variables. + * Returns the m-by-m matrix D with D[r1][r2] corresponding to the cosine + * distance between the rows of the input X. + */ + public static float[][] cosine(float[][] X){ + int numRows = X.length; int numColumns = X[0].length; + float[][] distMatrix = new float[numRows][numRows]; + float[] mag = new float[numRows]; + for(int i=0; i + * Dist[i][j]^2 = (X[i][1] - X[j][1]) ^2+ (X[i][2] - X[j][2])^2 + ... + (X[i][n] - X[j][n])^2. + * + *

    + * Rows of X correspond to observations, and columns correspond to variables. + * Returns the m-by-m matrix D with D[r1][r2] corresponding to the Euclidean + * distance between the rows of the input X. + */ + public static float[][] euclidean(float[][] X){ + int numRows = X.length; int numColumns = X[0].length; + float[][] distMatrix = new float[numRows][numRows]; + double val = 0.0; + for(int r = 0; r + * standardized value = (original value - mean)/standard deviation + * + * where the mean and standard deviation correspond to the column mean and std. + *

    + * Rows of X correspond to observations, and columns correspond to variables. + * Returns the m-by-m matrix D with D[r1][r2] corresponding to the standardized + * Euclidean distance between the rows of the input X. + */ + public static float[][] seuclidean(float[][] X){ + float[] means = Descriptive.Mean.columnMean(X); + float[] stds = Descriptive.std(X,true);//unbiased + float[][] distMatrix = euclidean(Descriptive.zScore(X,means,stds)); + return distMatrix; + } + /** + * Computes the Mahalanobis distance matrix of the m-by-n input matrix X. That is, + * 

    +	 * Dist[i][j]^2 = (X[i][1] - X[j][1])^2/ invcov[1][1] + ... + (X[i][n] - X[j][n])^2/ invcov[n][n]. 
+	 *
    + * + * Rows of X correspond to observations, and columns correspond to variables. + * Returns the m-by-m matrix D with D[r1][r2] corresponding to the s + * mahalanobis distance between the rows of the input X. + */ + public static float[][] mahalanobis(float[][] X){ + int numRows = X.length; int numColumns = X[0].length; + double[][] invCov = new LU(Correlation.cov(X,true)).solve(Mat.identity(numColumns)); + float[][] distMatrix = new float[numRows][numRows]; + for(int r = 0; r + * Dist[i][j]^p= (X[i][1] - X[j][1])^p/ + (X[i][2] - X[j][2])^p + ... + (X[i][n] - X[j][n])^p. + * + * Notice that for the special case of p = 1, the Minkowski metric + * gives the city block metric, for the special case of p = 2, + * the Minkowski metric gives the Euclidean distance, + * and for the special case of p = &inf;, the Minkowski metric gives the Chebychev distance. + * Also notice that the larger the value of p, the higher the probability of causing overflow + * errors (which are, in turn, highly correlated to headaches and overall feelings of malaise). + * @param exp the Minkowski exponent (positive). + */ + public static float[][] minkowski(float[][] X, int exp){ + if(exp<1) throw new IllegalArgumentException("Exponent has to be a scalar positive value"); + // check if it fits any of these + if(exp==1) return cityblock(X); + if(exp==2) return euclidean(X); + if(exp>100) return chebychev(X); + // otherwise, compute it. + int numRows = X.length; int numColumns = X[0].length; + float[][] distMatrix = new float[numRows][numRows]; + for(int r = 0; rr11, r12, ... , r1n + *
    + * and + *
    r21, r22, ... , r2n,
    then + * 
    
+	 * Dist[1][2] = 1 -  sum_{j=1^numColumns} ( ( r1_j - mean(r1) ) * ( r2_j - mean(r2) ) / ( n * std(r1)*std(r2) ) ), 
+	 *
    + * and similarly for the remaining rows. + *

    + * Rows of X correspond to observations, and columns correspond to variables. + * Returns the m-by-m matrix D with D[r1][r2] corresponding to the Spearman + * distance between the rows of the input X. + */ + public static float[][] spearman(float[][] X){ + int numRows = X.length; int numColumns = X[0].length; + float[][] distMatrix = new float[numRows][numRows]; + // get the rank for all rows + float[][] rank = new float[numRows][numColumns]; + float mean = (numColumns+1)/2; + double[] std = new double[numRows]; + for(int i=0; i 0 + // additionalArg = varargin{1}; % get exponent from input args + // else + // error('stats:pdist:InvalidExponent',... + // 'The exponent for the Minkowski metric must be positive.'); + // end + // case 'cos' % Cosine + // Xnorm = sqrt(sum(X.^2, 2)); + // if min(Xnorm) <= eps(full(max(Xnorm))) + // error('stats:pdist:InappropriateDistance',... + // ['Some points have small relative magnitudes, making them ', ... + // 'effectively zero.\nEither remove those points, or choose a ', ... + // 'distance other than cosine.'], []); + // end + // X = X ./ Xnorm(:,ones(1,p)); + // additionalArg = []; + // case 'cor' % Correlation + // X = X - repmat(mean(X,2),1,p); + // Xnorm = sqrt(sum(X.^2, 2)); + // if min(Xnorm) <= eps(full(max(Xnorm))) + // error('stats:pdist:InappropriateDistance',... + // ['Some points have small relative standard deviations, making ', ... + // 'them effectively constant.\nEither remove those points, or ', ... + // 'choose a distance other than correlation.'], []); + // end + // X = X ./ Xnorm(:,ones(1,p)); + // additionalArg = []; + // case 'spe' + // X = tiedrank(X')'; % treat rows as a series + // X = X - (p+1)/2; % subtract off the (constant) mean + // Xnorm = sqrt(sum(X.^2, 2)); + // if min(Xnorm) <= eps(full(max(Xnorm))) + // error('stats:pdist:InappropriateDistance',... + // ['Some points have too many ties, making them effectively ', ... + // 'constant.\nEither remove those points, or choose a ', ... + // 'distance other than rank correlation.'], []); + // end + // X = X ./ Xnorm(:,ones(1,p)); + // additionalArg = []; + // otherwise + // additionalArg = []; + // end + + + +} \ No newline at end of file diff --git a/drawing/papaya/src/papaya/Eigenvalue.java b/drawing/papaya/src/papaya/Eigenvalue.java new file mode 100644 index 0000000..ac83507 --- /dev/null +++ b/drawing/papaya/src/papaya/Eigenvalue.java @@ -0,0 +1,991 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; + +/** Eigenvalues and eigenvectors of a real matrix. +

    + If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is + diagonal and the eigenvector matrix V is orthogonal. + I.e. A = V.times(D.times(V.transpose())) and + V.times(V.transpose()) equals the identity matrix. +

    + If A is not symmetric, then the eigenvalue matrix D is block diagonal + with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, + lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The + columns of V represent the eigenvectors in the sense that A*V = V*D, + i.e. A.times(V) equals V.times(D). The matrix V may be badly + conditioned, or even singular, so the validity of the equation + A = V*D*inverse(V) depends upon V.cond(). +

    +Shamelessly copied (and modified) from the +JAMA Java +Matrix package. To make things compatible with how most users use Processing, the +class take in float matrices. However, to preserve the acccuracy of the computations, the algorithm +first casts the input into a double array, prior to doing anything. All methods also return doubles; Use +{@link Cast#doubleToFloat(double[][])} if you want/need to cast everything back to floats for +further (non-high-accuracy-dependant) processing (pun intended). + */ + + +public class Eigenvalue { + +/* ------------------------ + Class variables + * ------------------------ */ + + /** Row and column dimension (square matrix). + @serial matrix dimension. + */ + private int n; + + /** Symmetry flag. + @serial internal symmetry flag. + */ + private boolean issymmetric; + + /** Arrays for internal storage of eigenvalues. + @serial internal storage of eigenvalues. + */ + private double[] d, e; + + /** Array for internal storage of eigenvectors. + @serial internal storage of eigenvectors. + */ + private double[][] V; + + /** Array for internal storage of nonsymmetric Hessenberg form. + @serial internal storage of nonsymmetric Hessenberg form. + */ + private double[][] H; + + /** Working storage for nonsymmetric algorithm. + @serial working storage for nonsymmetric algorithm. + */ + private double[] ort; + +/* ------------------------ + Private Methods + * ------------------------ */ + + // Symmetric Householder reduction to tridiagonal form. + + private void tred2 () { + + // This is derived from the Algol procedures tred2 by + // Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + // Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + // Fortran subroutine in EISPACK. + + for (int j = 0; j < n; j++) { + d[j] = V[n-1][j]; + } + + // Householder reduction to tridiagonal form. + + for (int i = n-1; i > 0; i--) { + + // Scale to avoid under/overflow. + + double scale = 0.0; + double h = 0.0; + for (int k = 0; k < i; k++) { + scale = scale + Math.abs(d[k]); + } + if (scale == 0.0) { + e[i] = d[i-1]; + for (int j = 0; j < i; j++) { + d[j] = V[i-1][j]; + V[i][j] = 0.0; + V[j][i] = 0.0; + } + } else { + + // Generate Householder vector. + + for (int k = 0; k < i; k++) { + d[k] /= scale; + h += d[k] * d[k]; + } + double f = d[i-1]; + double g = Math.sqrt(h); + if (f > 0) { + g = -g; + } + e[i] = scale * g; + h = h - f * g; + d[i-1] = f - g; + for (int j = 0; j < i; j++) { + e[j] = 0.0; + } + + // Apply similarity transformation to remaining columns. + + for (int j = 0; j < i; j++) { + f = d[j]; + V[j][i] = f; + g = e[j] + V[j][j] * f; + for (int k = j+1; k <= i-1; k++) { + g += V[k][j] * d[k]; + e[k] += V[k][j] * f; + } + e[j] = g; + } + f = 0.0; + for (int j = 0; j < i; j++) { + e[j] /= h; + f += e[j] * d[j]; + } + double hh = f / (h + h); + for (int j = 0; j < i; j++) { + e[j] -= hh * d[j]; + } + for (int j = 0; j < i; j++) { + f = d[j]; + g = e[j]; + for (int k = j; k <= i-1; k++) { + V[k][j] -= (f * e[k] + g * d[k]); + } + d[j] = V[i-1][j]; + V[i][j] = 0.0; + } + } + d[i] = h; + } + + // Accumulate transformations. + + for (int i = 0; i < n-1; i++) { + V[n-1][i] = V[i][i]; + V[i][i] = 1.0; + double h = d[i+1]; + if (h != 0.0) { + for (int k = 0; k <= i; k++) { + d[k] = V[k][i+1] / h; + } + for (int j = 0; j <= i; j++) { + double g = 0.0; + for (int k = 0; k <= i; k++) { + g += V[k][i+1] * V[k][j]; + } + for (int k = 0; k <= i; k++) { + V[k][j] -= g * d[k]; + } + } + } + for (int k = 0; k <= i; k++) { + V[k][i+1] = 0.0; + } + } + for (int j = 0; j < n; j++) { + d[j] = V[n-1][j]; + V[n-1][j] = 0.0; + } + V[n-1][n-1] = 1.0; + e[0] = 0.0; + } + + // Symmetric tridiagonal QL algorithm. + + private void tql2 () { + + // This is derived from the Algol procedures tql2, by + // Bowdler, Martin, Reinsch, and Wilkinson, Handbook for + // Auto. Comp., Vol.ii-Linear Algebra, and the corresponding + // Fortran subroutine in EISPACK. + + for (int i = 1; i < n; i++) { + e[i-1] = e[i]; + } + e[n-1] = 0.0; + + double f = 0.0; + double tst1 = 0.0; + double eps = Math.pow(2.0,-52.0); + for (int l = 0; l < n; l++) { + + // Find small subdiagonal element + + tst1 = Math.max(tst1,Math.abs(d[l]) + Math.abs(e[l])); + int m = l; + while (m < n) { + if (Math.abs(e[m]) <= eps*tst1) { + break; + } + m++; + } + + // If m == l, d[l] is an eigenvalue, + // otherwise, iterate. + + if (m > l) { + int iter = 0; + do { + iter = iter + 1; // (Could check iteration count here.) + + // Compute implicit shift + + double g = d[l]; + double p = (d[l+1] - g) / (2.0 * e[l]); + double r = SVD.hypot(p,1.0); + if (p < 0) { + r = -r; + } + d[l] = e[l] / (p + r); + d[l+1] = e[l] * (p + r); + double dl1 = d[l+1]; + double h = g - d[l]; + for (int i = l+2; i < n; i++) { + d[i] -= h; + } + f = f + h; + + // Implicit QL transformation. + + p = d[m]; + double c = 1.0; + double c2 = c; + double c3 = c; + double el1 = e[l+1]; + double s = 0.0; + double s2 = 0.0; + for (int i = m-1; i >= l; i--) { + c3 = c2; + c2 = c; + s2 = s; + g = c * e[i]; + h = c * p; + r = SVD.hypot(p,e[i]); + e[i+1] = s * r; + s = e[i] / r; + c = p / r; + p = c * d[i] - s * g; + d[i+1] = h + s * (c * g + s * d[i]); + + // Accumulate transformation. + + for (int k = 0; k < n; k++) { + h = V[k][i+1]; + V[k][i+1] = s * V[k][i] + c * h; + V[k][i] = c * V[k][i] - s * h; + } + } + p = -s * s2 * c3 * el1 * e[l] / dl1; + e[l] = s * p; + d[l] = c * p; + + // Check for convergence. + + } while (Math.abs(e[l]) > eps*tst1); + } + d[l] = d[l] + f; + e[l] = 0.0; + } + + // Sort eigenvalues and corresponding vectors. + + for (int i = 0; i < n-1; i++) { + int k = i; + double p = d[i]; + for (int j = i+1; j < n; j++) { + if (d[j] < p) { + k = j; + p = d[j]; + } + } + if (k != i) { + d[k] = d[i]; + d[i] = p; + for (int j = 0; j < n; j++) { + p = V[j][i]; + V[j][i] = V[j][k]; + V[j][k] = p; + } + } + } + } + + // Nonsymmetric reduction to Hessenberg form. + + private void orthes () { + + // This is derived from the Algol procedures orthes and ortran, + // by Martin and Wilkinson, Handbook for Auto. Comp., + // Vol.ii-Linear Algebra, and the corresponding + // Fortran subroutines in EISPACK. + + int low = 0; + int high = n-1; + + for (int m = low+1; m <= high-1; m++) { + + // Scale column. + + double scale = 0.0; + for (int i = m; i <= high; i++) { + scale = scale + Math.abs(H[i][m-1]); + } + if (scale != 0.0) { + + // Compute Householder transformation. + + double h = 0.0; + for (int i = high; i >= m; i--) { + ort[i] = H[i][m-1]/scale; + h += ort[i] * ort[i]; + } + double g = Math.sqrt(h); + if (ort[m] > 0) { + g = -g; + } + h = h - ort[m] * g; + ort[m] = ort[m] - g; + + // Apply Householder similarity transformation + // H = (I-u*u'/h)*H*(I-u*u')/h) + + for (int j = m; j < n; j++) { + double f = 0.0; + for (int i = high; i >= m; i--) { + f += ort[i]*H[i][j]; + } + f = f/h; + for (int i = m; i <= high; i++) { + H[i][j] -= f*ort[i]; + } + } + + for (int i = 0; i <= high; i++) { + double f = 0.0; + for (int j = high; j >= m; j--) { + f += ort[j]*H[i][j]; + } + f = f/h; + for (int j = m; j <= high; j++) { + H[i][j] -= f*ort[j]; + } + } + ort[m] = scale*ort[m]; + H[m][m-1] = scale*g; + } + } + + // Accumulate transformations (Algol's ortran). + + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + V[i][j] = (i == j ? 1.0 : 0.0); + } + } + + for (int m = high-1; m >= low+1; m--) { + if (H[m][m-1] != 0.0) { + for (int i = m+1; i <= high; i++) { + ort[i] = H[i][m-1]; + } + for (int j = m; j <= high; j++) { + double g = 0.0; + for (int i = m; i <= high; i++) { + g += ort[i] * V[i][j]; + } + // Double division avoids possible underflow + g = (g / ort[m]) / H[m][m-1]; + for (int i = m; i <= high; i++) { + V[i][j] += g * ort[i]; + } + } + } + } + } + + + // Complex scalar division. + + private transient double cdivr, cdivi; + private void cdiv(double xr, double xi, double yr, double yi) { + double r,d; + if (Math.abs(yr) > Math.abs(yi)) { + r = yi/yr; + d = yr + r*yi; + cdivr = (xr + r*xi)/d; + cdivi = (xi - r*xr)/d; + } else { + r = yr/yi; + d = yi + r*yr; + cdivr = (r*xr + xi)/d; + cdivi = (r*xi - xr)/d; + } + } + + + // Nonsymmetric reduction from Hessenberg to real Schur form. + + private void hqr2 () { + + // This is derived from the Algol procedure hqr2, + // by Martin and Wilkinson, Handbook for Auto. Comp., + // Vol.ii-Linear Algebra, and the corresponding + // Fortran subroutine in EISPACK. + + // Initialize + + int nn = this.n; + int n = nn-1; + int low = 0; + int high = nn-1; + double eps = Math.pow(2.0,-52.0); + double exshift = 0.0; + double p=0,q=0,r=0,s=0,z=0,t,w,x,y; + + // Store roots isolated by balanc and compute matrix norm + + double norm = 0.0; + for (int i = 0; i < nn; i++) { + if (i < low | i > high) { + d[i] = H[i][i]; + e[i] = 0.0; + } + for (int j = Math.max(i-1,0); j < nn; j++) { + norm = norm + Math.abs(H[i][j]); + } + } + + // Outer loop over eigenvalue index + + int iter = 0; + while (n >= low) { + + // Look for single small sub-diagonal element + + int l = n; + while (l > low) { + s = Math.abs(H[l-1][l-1]) + Math.abs(H[l][l]); + if (s == 0.0) { + s = norm; + } + if (Math.abs(H[l][l-1]) < eps * s) { + break; + } + l--; + } + + // Check for convergence + // One root found + + if (l == n) { + H[n][n] = H[n][n] + exshift; + d[n] = H[n][n]; + e[n] = 0.0; + n--; + iter = 0; + + // Two roots found + + } else if (l == n-1) { + w = H[n][n-1] * H[n-1][n]; + p = (H[n-1][n-1] - H[n][n]) / 2.0; + q = p * p + w; + z = Math.sqrt(Math.abs(q)); + H[n][n] = H[n][n] + exshift; + H[n-1][n-1] = H[n-1][n-1] + exshift; + x = H[n][n]; + + // Real pair + + if (q >= 0) { + if (p >= 0) { + z = p + z; + } else { + z = p - z; + } + d[n-1] = x + z; + d[n] = d[n-1]; + if (z != 0.0) { + d[n] = x - w / z; + } + e[n-1] = 0.0; + e[n] = 0.0; + x = H[n][n-1]; + s = Math.abs(x) + Math.abs(z); + p = x / s; + q = z / s; + r = Math.sqrt(p * p+q * q); + p = p / r; + q = q / r; + + // Row modification + + for (int j = n-1; j < nn; j++) { + z = H[n-1][j]; + H[n-1][j] = q * z + p * H[n][j]; + H[n][j] = q * H[n][j] - p * z; + } + + // Column modification + + for (int i = 0; i <= n; i++) { + z = H[i][n-1]; + H[i][n-1] = q * z + p * H[i][n]; + H[i][n] = q * H[i][n] - p * z; + } + + // Accumulate transformations + + for (int i = low; i <= high; i++) { + z = V[i][n-1]; + V[i][n-1] = q * z + p * V[i][n]; + V[i][n] = q * V[i][n] - p * z; + } + + // Complex pair + + } else { + d[n-1] = x + p; + d[n] = x + p; + e[n-1] = z; + e[n] = -z; + } + n = n - 2; + iter = 0; + + // No convergence yet + + } else { + + // Form shift + + x = H[n][n]; + y = 0.0; + w = 0.0; + if (l < n) { + y = H[n-1][n-1]; + w = H[n][n-1] * H[n-1][n]; + } + + // Wilkinson's original ad hoc shift + + if (iter == 10) { + exshift += x; + for (int i = low; i <= n; i++) { + H[i][i] -= x; + } + s = Math.abs(H[n][n-1]) + Math.abs(H[n-1][n-2]); + x = y = 0.75 * s; + w = -0.4375 * s * s; + } + + // MATLAB's new ad hoc shift + + if (iter == 30) { + s = (y - x) / 2.0; + s = s * s + w; + if (s > 0) { + s = Math.sqrt(s); + if (y < x) { + s = -s; + } + s = x - w / ((y - x) / 2.0 + s); + for (int i = low; i <= n; i++) { + H[i][i] -= s; + } + exshift += s; + x = y = w = 0.964; + } + } + + iter = iter + 1; // (Could check iteration count here.) + + // Look for two consecutive small sub-diagonal elements + + int m = n-2; + while (m >= l) { + z = H[m][m]; + r = x - z; + s = y - z; + p = (r * s - w) / H[m+1][m] + H[m][m+1]; + q = H[m+1][m+1] - z - r - s; + r = H[m+2][m+1]; + s = Math.abs(p) + Math.abs(q) + Math.abs(r); + p = p / s; + q = q / s; + r = r / s; + if (m == l) { + break; + } + if (Math.abs(H[m][m-1]) * (Math.abs(q) + Math.abs(r)) < + eps * (Math.abs(p) * (Math.abs(H[m-1][m-1]) + Math.abs(z) + + Math.abs(H[m+1][m+1])))) { + break; + } + m--; + } + + for (int i = m+2; i <= n; i++) { + H[i][i-2] = 0.0; + if (i > m+2) { + H[i][i-3] = 0.0; + } + } + + // Double QR step involving rows l:n and columns m:n + + for (int k = m; k <= n-1; k++) { + boolean notlast = (k != n-1); + if (k != m) { + p = H[k][k-1]; + q = H[k+1][k-1]; + r = (notlast ? H[k+2][k-1] : 0.0); + x = Math.abs(p) + Math.abs(q) + Math.abs(r); + if (x != 0.0) { + p = p / x; + q = q / x; + r = r / x; + } + } + if (x == 0.0) { + break; + } + s = Math.sqrt(p * p + q * q + r * r); + if (p < 0) { + s = -s; + } + if (s != 0) { + if (k != m) { + H[k][k-1] = -s * x; + } else if (l != m) { + H[k][k-1] = -H[k][k-1]; + } + p = p + s; + x = p / s; + y = q / s; + z = r / s; + q = q / p; + r = r / p; + + // Row modification + + for (int j = k; j < nn; j++) { + p = H[k][j] + q * H[k+1][j]; + if (notlast) { + p = p + r * H[k+2][j]; + H[k+2][j] = H[k+2][j] - p * z; + } + H[k][j] = H[k][j] - p * x; + H[k+1][j] = H[k+1][j] - p * y; + } + + // Column modification + + for (int i = 0; i <= Math.min(n,k+3); i++) { + p = x * H[i][k] + y * H[i][k+1]; + if (notlast) { + p = p + z * H[i][k+2]; + H[i][k+2] = H[i][k+2] - p * r; + } + H[i][k] = H[i][k] - p; + H[i][k+1] = H[i][k+1] - p * q; + } + + // Accumulate transformations + + for (int i = low; i <= high; i++) { + p = x * V[i][k] + y * V[i][k+1]; + if (notlast) { + p = p + z * V[i][k+2]; + V[i][k+2] = V[i][k+2] - p * r; + } + V[i][k] = V[i][k] - p; + V[i][k+1] = V[i][k+1] - p * q; + } + } // (s != 0) + } // k loop + } // check convergence + } // while (n >= low) + + // Backsubstitute to find vectors of upper triangular form + + if (norm == 0.0) { + return; + } + + for (n = nn-1; n >= 0; n--) { + p = d[n]; + q = e[n]; + + // Real vector + + if (q == 0) { + int l = n; + H[n][n] = 1.0; + for (int i = n-1; i >= 0; i--) { + w = H[i][i] - p; + r = 0.0; + for (int j = l; j <= n; j++) { + r = r + H[i][j] * H[j][n]; + } + if (e[i] < 0.0) { + z = w; + s = r; + } else { + l = i; + if (e[i] == 0.0) { + if (w != 0.0) { + H[i][n] = -r / w; + } else { + H[i][n] = -r / (eps * norm); + } + + // Solve real equations + + } else { + x = H[i][i+1]; + y = H[i+1][i]; + q = (d[i] - p) * (d[i] - p) + e[i] * e[i]; + t = (x * s - z * r) / q; + H[i][n] = t; + if (Math.abs(x) > Math.abs(z)) { + H[i+1][n] = (-r - w * t) / x; + } else { + H[i+1][n] = (-s - y * t) / z; + } + } + + // Overflow control + + t = Math.abs(H[i][n]); + if ((eps * t) * t > 1) { + for (int j = i; j <= n; j++) { + H[j][n] = H[j][n] / t; + } + } + } + } + + // Complex vector + + } else if (q < 0) { + int l = n-1; + + // Last vector component imaginary so matrix is triangular + + if (Math.abs(H[n][n-1]) > Math.abs(H[n-1][n])) { + H[n-1][n-1] = q / H[n][n-1]; + H[n-1][n] = -(H[n][n] - p) / H[n][n-1]; + } else { + cdiv(0.0,-H[n-1][n],H[n-1][n-1]-p,q); + H[n-1][n-1] = cdivr; + H[n-1][n] = cdivi; + } + H[n][n-1] = 0.0; + H[n][n] = 1.0; + for (int i = n-2; i >= 0; i--) { + double ra,sa,vr,vi; + ra = 0.0; + sa = 0.0; + for (int j = l; j <= n; j++) { + ra = ra + H[i][j] * H[j][n-1]; + sa = sa + H[i][j] * H[j][n]; + } + w = H[i][i] - p; + + if (e[i] < 0.0) { + z = w; + r = ra; + s = sa; + } else { + l = i; + if (e[i] == 0) { + cdiv(-ra,-sa,w,q); + H[i][n-1] = cdivr; + H[i][n] = cdivi; + } else { + + // Solve complex equations + + x = H[i][i+1]; + y = H[i+1][i]; + vr = (d[i] - p) * (d[i] - p) + e[i] * e[i] - q * q; + vi = (d[i] - p) * 2.0 * q; + if (vr == 0.0 & vi == 0.0) { + vr = eps * norm * (Math.abs(w) + Math.abs(q) + + Math.abs(x) + Math.abs(y) + Math.abs(z)); + } + cdiv(x*r-z*ra+q*sa,x*s-z*sa-q*ra,vr,vi); + H[i][n-1] = cdivr; + H[i][n] = cdivi; + if (Math.abs(x) > (Math.abs(z) + Math.abs(q))) { + H[i+1][n-1] = (-ra - w * H[i][n-1] + q * H[i][n]) / x; + H[i+1][n] = (-sa - w * H[i][n] - q * H[i][n-1]) / x; + } else { + cdiv(-r-y*H[i][n-1],-s-y*H[i][n],z,q); + H[i+1][n-1] = cdivr; + H[i+1][n] = cdivi; + } + } + + // Overflow control + + t = Math.max(Math.abs(H[i][n-1]),Math.abs(H[i][n])); + if ((eps * t) * t > 1) { + for (int j = i; j <= n; j++) { + H[j][n-1] = H[j][n-1] / t; + H[j][n] = H[j][n] / t; + } + } + } + } + } + } + + // Vectors of isolated roots + + for (int i = 0; i < nn; i++) { + if (i < low | i > high) { + for (int j = i; j < nn; j++) { + V[i][j] = H[i][j]; + } + } + } + + // Back transformation to get eigenvectors of original matrix + + for (int j = nn-1; j >= low; j--) { + for (int i = low; i <= high; i++) { + z = 0.0; + for (int k = low; k <= Math.min(j,high); k++) { + z = z + V[i][k] * H[k][j]; + } + V[i][j] = z; + } + } + } + + +/* ------------------------ + Constructor + * ------------------------ */ + + /** Check for symmetry, then construct the eigenvalue decomposition. + * Upon initialization, the matrices D and V, as well as the vectors containing the + * real and imaginary eigenvalues are computed and stored. + * @see getV() + * @see getD() + * @see getRealEigenvalues() + * @see getImagEigenvalues() + */ + + public Eigenvalue (float[][] Arg) { + double[][] A = Cast.floatToDouble(Arg); + n = Arg[0].length; + V = new double[n][n]; + d = new double[n]; + e = new double[n]; + + issymmetric = true; + for (int j = 0; (j < n) & issymmetric; j++) { + for (int i = 0; (i < n) & issymmetric; i++) { + issymmetric = (A[i][j] == A[j][i]); + } + } + + if (issymmetric) { + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + V[i][j] = A[i][j]; + } + } + + // Tridiagonalize. + tred2(); + + // Diagonalize. + tql2(); + + } else { + H = new double[n][n]; + ort = new double[n]; + + for (int j = 0; j < n; j++) { + for (int i = 0; i < n; i++) { + H[i][j] = A[i][j]; + } + } + + // Reduce to Hessenberg form. + orthes(); + + // Reduce Hessenberg to real Schur form. + hqr2(); + } + } + +/* ------------------------ + Public Methods + * ------------------------ */ + + /** Return the eigenvector matrix with each column corresponding to + * an eigenvector of the input matrix. + @return V + */ + + public double[][] getV () { + return V; + } + + /** Return the real parts of the eigenvalues + @return real(diag(D)) + */ + public double[] getRealEigenvalues () { + return d; + } + + /** Return the imaginary parts of the eigenvalues + @return imag(diag(D)) + */ + + public double[] getImagEigenvalues () { + return e; + } + + /** Return the block diagonal eigenvalue matrix + @return D + */ + + public double[][] getD () { + double[][] D = new double[n][n]; + for (int i = 0; i < n; i++) { + D[i][i] = d[i]; + if (e[i] > 0) { + D[i][i+1] = e[i]; + } else if (e[i] < 0) { + D[i][i-1] = e[i]; + } + } + return D; + } +} + + + + + diff --git a/drawing/papaya/src/papaya/Find.java b/drawing/papaya/src/papaya/Find.java new file mode 100644 index 0000000..d3eee6d --- /dev/null +++ b/drawing/papaya/src/papaya/Find.java @@ -0,0 +1,1945 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ + +package papaya; + +import java.util.*; +import java.io.*; +import processing.core.*; + +/** + * Static class for finding indices in an array corresponding to a given value/object. + *

    + * (Portions of this code were (conveniently!) copied and pasted from commons.apache.org.) :) + *

    + * + */ +public final class Find implements PapayaConstants { + +// /** +// * Index to return if not found. +// */ +// public static final int INDEX_NOT_FOUND = -1; +// +// /** +// * Index array to return if not found. +// */ +// public static final int[] INDICES_NOT_FOUND = new int[]{-1}; + + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected Find(){ + } + + // IndexOf search + // ---------------------------------------------------------------------- + + // Object IndexOf + //----------------------------------------------------------------------- + /** + *

    Finds the index of the given object in the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object, may be {@code null} + * @param objectToFind the object to find, may be {@code null} + * @return the index of the object within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(Object[] array, Object objectToFind) { + return indexOf(array, objectToFind, 0); + } + + /** + *

    Finds the index of the given object in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex is treated as zero. A startIndex larger than the array + * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).

    + * + * @param array the array to search through for the object, may be {@code null} + * @param objectToFind the object to find, may be {@code null} + * @param startIndex the index to start searching at + * @return the index of the object within the array starting at the index, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(Object[] array, Object objectToFind, int startIndex) { + if (array == null) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + if (objectToFind == null) { + for (int i = startIndex; i < array.length; i++) { + if (array[i] == null) { + return i; + } + } + } else if (array.getClass().getComponentType().isInstance(objectToFind)) { + for (int i = startIndex; i < array.length; i++) { + if (objectToFind.equals(array[i])) { + return i; + } + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Finds the last index of the given object within the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to travers backwords looking for the object, may be {@code null} + * @param objectToFind the object to find, may be {@code null} + * @return the last index of the object within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(Object[] array, Object objectToFind) { + return lastIndexOf(array, objectToFind, Integer.MAX_VALUE); + } + + /** + *

    Finds the last index of the given object in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than + * the array length will search from the end of the array.

    + * + * @param array the array to traverse for looking for the object, may be {@code null} + * @param objectToFind the object to find, may be {@code null} + * @param startIndex the start index to travers backwards from + * @return the last index of the object within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(Object[] array, Object objectToFind, int startIndex) { + if (array == null) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + return INDEX_NOT_FOUND; + } else if (startIndex >= array.length) { + startIndex = array.length - 1; + } + if (objectToFind == null) { + for (int i = startIndex; i >= 0; i--) { + if (array[i] == null) { + return i; + } + } + } else if (array.getClass().getComponentType().isInstance(objectToFind)) { + for (int i = startIndex; i >= 0; i--) { + if (objectToFind.equals(array[i])) { + return i; + } + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Checks if the object is in the given array.

    + * + *

    The method returns {@code false} if a {@code null} array is passed in.

    + * + * @param array the array to search through + * @param objectToFind the object to find + * @return {@code true} if the array contains the object + */ + public static boolean contains(Object[] array, Object objectToFind) { + return indexOf(array, objectToFind) != INDEX_NOT_FOUND; + } + + /** + *

    Finds the indices containing the specified object in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object to find, may be {@code null} + * @param objectToFind the object to find + * @return the indices containing the object within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(Object[] array, Object objectToFind) { + return indicesWith(array, objectToFind, 0); + } + + /** + *

    Finds the indices containing the specified object in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object to find, may be {@code null} + * @param objectToFind the object to find + * @param startIndex the index to start searching at + * @return the indices containing the object within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(Object[] array, Object objectToFind, int startIndex) { + if (array == null) { + return INDICES_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + Vector indices = new Vector(); + + if (objectToFind == null) { + for (int i = startIndex; i < array.length; i++) { + if (array[i] == null) { + indices.add(i); + } + } + } else if (array.getClass().getComponentType().isInstance(objectToFind)) { + for (int i = startIndex; i < array.length; i++) { + if (objectToFind.equals(array[i])) { + indices.add(i); + } + } + } + + if(indices.size()>0){ + return Cast.vectorToInt(indices); + } + else{ + return INDICES_NOT_FOUND; + } + } + + /** + *

    Finds the number of times a given value/object is present in an array.

    + * + * @param array the array to search through for the value/object + * @param objectToFind the object to find. + * @return the number of times that value/object appears in the array + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int numRepeats(Object[] array, Object objectToFind) { + int count=0; + if (objectToFind == null) { + for (int i = 0; i < array.length; i++) { + if (array[i] == null) { + count++; + } + } + } else if (array.getClass().getComponentType().isInstance(objectToFind)) { + for (int i = 0; i < array.length; i++) { + if (objectToFind.equals(array[i])) { + count++; + } + } + } + return count; + } + + + // long IndexOf + //----------------------------------------------------------------------- + /** + *

    Finds the index of the given value in the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(long[] array, long valueToFind) { + return indexOf(array, valueToFind, 0); + } + + /** + *

    Finds the index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex is treated as zero. A startIndex larger than the array + * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(long[] array, long valueToFind, int startIndex) { + if (array == null) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + for (int i = startIndex; i < array.length; i++) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Finds the last index of the given value within the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to travers backwords looking for the object, may be {@code null} + * @param valueToFind the object to find + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(long[] array, long valueToFind) { + return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); + } + + /** + *

    Finds the last index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the + * array length will search from the end of the array.

    + * + * @param array the array to traverse for looking for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the start index to travers backwards from + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(long[] array, long valueToFind, int startIndex) { + if (array == null) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + return INDEX_NOT_FOUND; + } else if (startIndex >= array.length) { + startIndex = array.length - 1; + } + for (int i = startIndex; i >= 0; i--) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Checks if the value is in the given array.

    + * + *

    The method returns {@code false} if a {@code null} array is passed in.

    + * + * @param array the array to search through + * @param valueToFind the value to find + * @return {@code true} if the array contains the object + */ + public static boolean contains(long[] array, long valueToFind) { + return indexOf(array, valueToFind) != INDEX_NOT_FOUND; + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(long[] array, long valueToFind) { + return indicesWith(array, valueToFind, 0); + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(long[] array, long valueToFind, int startIndex) { + if (array == null) { + return INDICES_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + Vector indices = new Vector(); + for (int i = startIndex; i < array.length; i++) { + if (array[i] == valueToFind) { + indices.add(i); + } + } + return checkIndices(indices); + } + + /** + *

    Finds the number of times a given value/object is present in an array.

    + * + * @param array the array to search through for the value/object + * @param valueToFind the object to find. + * @return the number of times that value/object appears in the array + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int numRepeats(long[] array, long valueToFind) { + int count=0; + for (int i=0; iFinds the index of the given value in the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(int[] array, int valueToFind) { + return indexOf(array, valueToFind, 0); + } + + /** + *

    Finds the index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex is treated as zero. A startIndex larger than the array + * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(int[] array, int valueToFind, int startIndex) { + if (array == null) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + for (int i = startIndex; i < array.length; i++) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Finds the last index of the given value within the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to travers backwords looking for the object, may be {@code null} + * @param valueToFind the object to find + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(int[] array, int valueToFind) { + return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); + } + + /** + *

    Finds the last index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the + * array length will search from the end of the array.

    + * + * @param array the array to traverse for looking for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the start index to travers backwards from + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(int[] array, int valueToFind, int startIndex) { + if (array == null) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + return INDEX_NOT_FOUND; + } else if (startIndex >= array.length) { + startIndex = array.length - 1; + } + for (int i = startIndex; i >= 0; i--) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Checks if the value is in the given array.

    + * + *

    The method returns {@code false} if a {@code null} array is passed in.

    + * + * @param array the array to search through + * @param valueToFind the value to find + * @return {@code true} if the array contains the object + */ + public static boolean contains(int[] array, int valueToFind) { + return indexOf(array, valueToFind) != INDEX_NOT_FOUND; + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(int[] array, int valueToFind) { + return indicesWith(array, valueToFind, 0); + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(int[] array, int valueToFind, int startIndex) { + if (array == null) { + return INDICES_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + Vector indices = new Vector(); + for (int i = startIndex; i < array.length; i++) { + if (array[i] == valueToFind) { + indices.add(i); + } + } + return checkIndices(indices); + } + /** + *

    Finds the indices for the array elements within the min and max value (inclusive).

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + */ + public static int[] indicesWithin(int[] array, float minVal, float maxVal) { + if (array == null) { + return INDICES_NOT_FOUND; + } + Vector indices = new Vector(); + for (int i = 0; i < array.length; i++) { + if (array[i] >= minVal && array[i]<= maxVal) { + indices.add(i); + } + } + return checkIndices(indices); + } + + public static int[] indicesLessThanOrEqualTo(int[] array, int valueOfMax){ + ArrayList indices = new ArrayList(); + for(int i=0; i=valueOfMin) indices.add(i); + } + return Cast.arrayListToInt(indices); + } + + public static int[] indicesGreaterThan(int[] array, int valueOfMin){ + ArrayList indices = new ArrayList(); + for(int i=0; ivalueOfMin) indices.add(i); + } + return Cast.arrayListToInt(indices); + } + + /** + *

    Finds the number of times a given value/object is present in an array.

    + * + * @param array the array to search through for the value/object + * @param valueToFind the object to find. + * @return the number of times that value/object appears in the array + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int numRepeats(int[] array, int valueToFind) { + int count=0; + for (int i=0; iFinds the number of elements less than or equal to the specified value.

    + * + * @param array the array to search through for the value/object + * @param valueOfMax the maximum value + * @return the number of elements ? that value + */ + public static int numLessThanOrEqualTo(int[] array, int valueOfMax) { + int count=0; + for (int i=0; iFinds the number of elements strictly less than the specified value.

    + * + * @param array the array to search through for the value/object + * @param valueOfMax the maximum value + * @return the number of elements strictly less than that value + */ + public static int numLessThan(int[] array, int valueOfMax) { + int count=0; + for (int i=0; iFinds the number of elements greater than or equal to the specified value.

    + * + * @param array the array to search through for the value/object + * @param valueOfMax the maximum value + * @return the number of elements ? that value + */ + public static int numGreaterThanOrEqualTo(int[] array, int valueOfMin) { + int count=0; + for (int i=0; i= valueOfMin) { + count++; + } + } + return count; + } + + /** + *

    Finds the number of elements strictly greater than the specified value.

    + * + * @param array the array to search through for the value/object + * @param valueOfMax the maximum value + * @return the number of elements strictly greater than that value + */ + public static int numGreaterThan(int[] array, int valueOfMin) { + int count=0; + for (int i=0; i valueOfMin) { + count++; + } + } + return count; + } + + /** Find the unique elements in a int array (uses HashSets) */ + public static int[] uniqueElems(int[] array){ + Set uniqueVals = new HashSet(); + for(int i=0; iFinds the index of the given value in the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(short[] array, short valueToFind) { + return indexOf(array, valueToFind, 0); + } + + /** + *

    Finds the index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex is treated as zero. A startIndex larger than the array + * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(short[] array, short valueToFind, int startIndex) { + if (array == null) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + for (int i = startIndex; i < array.length; i++) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Finds the last index of the given value within the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to travers backwords looking for the object, may be {@code null} + * @param valueToFind the object to find + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(short[] array, short valueToFind) { + return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); + } + + /** + *

    Finds the last index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the + * array length will search from the end of the array.

    + * + * @param array the array to traverse for looking for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the start index to travers backwards from + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(short[] array, short valueToFind, int startIndex) { + if (array == null) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + return INDEX_NOT_FOUND; + } else if (startIndex >= array.length) { + startIndex = array.length - 1; + } + for (int i = startIndex; i >= 0; i--) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Checks if the value is in the given array.

    + * + *

    The method returns {@code false} if a {@code null} array is passed in.

    + * + * @param array the array to search through + * @param valueToFind the value to find + * @return {@code true} if the array contains the object + */ + public static boolean contains(short[] array, short valueToFind) { + return indexOf(array, valueToFind) != INDEX_NOT_FOUND; + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(short[] array, short valueToFind) { + return indicesWith(array, valueToFind, 0); + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(short[] array, short valueToFind, int startIndex) { + if (array == null) { + return INDICES_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + Vector indices = new Vector(); + for (int i = startIndex; i < array.length; i++) { + if (array[i] == valueToFind) { + indices.add(i); + } + } + return checkIndices(indices); + } + /** + *

    Finds the number of times a given value/object is present in an array.

    + * + * @param array the array to search through for the value/object + * @param valueToFind the object to find. + * @return the number of times that value/object appears in the array + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int numRepeats(short[] array, short valueToFind) { + int count=0; + for (int i=0; iFinds the index of the given value in the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + * @since 2.1 + */ + public static int indexOf(char[] array, char valueToFind) { + return indexOf(array, valueToFind, 0); + } + + /** + *

    Finds the index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex is treated as zero. A startIndex larger than the array + * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + * @since 2.1 + */ + public static int indexOf(char[] array, char valueToFind, int startIndex) { + if (array == null) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + for (int i = startIndex; i < array.length; i++) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Finds the last index of the given value within the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to travers backwords looking for the object, may be {@code null} + * @param valueToFind the object to find + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + * @since 2.1 + */ + public static int lastIndexOf(char[] array, char valueToFind) { + return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); + } + + /** + *

    Finds the last index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the + * array length will search from the end of the array.

    + * + * @param array the array to traverse for looking for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the start index to travers backwards from + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + * @since 2.1 + */ + public static int lastIndexOf(char[] array, char valueToFind, int startIndex) { + if (array == null) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + return INDEX_NOT_FOUND; + } else if (startIndex >= array.length) { + startIndex = array.length - 1; + } + for (int i = startIndex; i >= 0; i--) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Checks if the value is in the given array.

    + * + *

    The method returns {@code false} if a {@code null} array is passed in.

    + * + * @param array the array to search through + * @param valueToFind the value to find + * @return {@code true} if the array contains the object + * @since 2.1 + */ + public static boolean contains(char[] array, char valueToFind) { + return indexOf(array, valueToFind) != INDEX_NOT_FOUND; + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(char[] array, char valueToFind) { + return indicesWith(array, valueToFind, 0); + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(char[] array, char valueToFind, int startIndex) { + if (array == null) { + return INDICES_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + Vector indices = new Vector(); + for (int i = startIndex; i < array.length; i++) { + if (array[i] == valueToFind) { + indices.add(i); + } + } + return checkIndices(indices); + } + + /** + *

    Finds the number of times a given value/object is present in an array.

    + * + * @param array the array to search through for the value/object + * @param valueToFind the object to find. + * @return the number of times that value/object appears in the array + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int numRepeats(char[] array,char valueToFind) { + int count=0; + for (int i=0; iFinds the index of the given value in the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(byte[] array, byte valueToFind) { + return indexOf(array, valueToFind, 0); + } + + /** + *

    Finds the index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex is treated as zero. A startIndex larger than the array + * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(byte[] array, byte valueToFind, int startIndex) { + if (array == null) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + for (int i = startIndex; i < array.length; i++) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Finds the last index of the given value within the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to travers backwords looking for the object, may be {@code null} + * @param valueToFind the object to find + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(byte[] array, byte valueToFind) { + return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); + } + + /** + *

    Finds the last index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the + * array length will search from the end of the array.

    + * + * @param array the array to traverse for looking for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the start index to travers backwards from + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(byte[] array, byte valueToFind, int startIndex) { + if (array == null) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + return INDEX_NOT_FOUND; + } else if (startIndex >= array.length) { + startIndex = array.length - 1; + } + for (int i = startIndex; i >= 0; i--) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Checks if the value is in the given array.

    + * + *

    The method returns {@code false} if a {@code null} array is passed in.

    + * + * @param array the array to search through + * @param valueToFind the value to find + * @return {@code true} if the array contains the object + */ + public static boolean contains(byte[] array, byte valueToFind) { + return indexOf(array, valueToFind) != INDEX_NOT_FOUND; + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(byte[] array, byte valueToFind) { + return indicesWith(array, valueToFind, 0); + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(byte[] array, byte valueToFind, int startIndex) { + if (array == null) { + return INDICES_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + Vector indices = new Vector(); + for (int i = startIndex; i < array.length; i++) { + if (array[i] == valueToFind) { + indices.add(i); + } + } + return checkIndices(indices); + } + + /** + *

    Finds the number of times a given value/object is present in an array.

    + * + * @param array the array to search through for the value/object + * @param valueToFind the object to find. + * @return the number of times that value/object appears in the array + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int numRepeats(byte[] array, byte valueToFind) { + int count=0; + for (int i=0; iFinds the index of the given value in the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(double[] array, double valueToFind) { + return indexOf(array, valueToFind, 0); + } + + /** + *

    Finds the index of the given value within a given tolerance in the array. + * This method will return the index of the first value which falls between the region + * defined by valueToFind - tolerance and valueToFind + tolerance.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @param tolerance tolerance of the search + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(double[] array, double valueToFind, double tolerance) { + return indexOf(array, valueToFind, 0, tolerance); + } + + /** + *

    Finds the index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex is treated as zero. A startIndex larger than the array + * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(double[] array, double valueToFind, int startIndex) { + if (array.length == 0) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + for (int i = startIndex; i < array.length; i++) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Finds the index of the given value in the array starting at the given index. + * This method will return the index of the first value which falls between the region + * defined by valueToFind - tolerance and valueToFind + tolerance.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex is treated as zero. A startIndex larger than the array + * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @param tolerance tolerance of the search + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(double[] array, double valueToFind, int startIndex, double tolerance) { + if (array.length == 0) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + double min = valueToFind - tolerance; + double max = valueToFind + tolerance; + for (int i = startIndex; i < array.length; i++) { + if (array[i] >= min && array[i] <= max) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Finds the last index of the given value within the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to travers backwords looking for the object, may be {@code null} + * @param valueToFind the object to find + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(double[] array, double valueToFind) { + return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); + } + + /** + *

    Finds the last index of the given value within a given tolerance in the array. + * This method will return the index of the last value which falls between the region + * defined by valueToFind - tolerance and valueToFind + tolerance.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @param tolerance tolerance of the search + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(double[] array, double valueToFind, double tolerance) { + return lastIndexOf(array, valueToFind, Integer.MAX_VALUE, tolerance); + } + + /** + *

    Finds the last index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the + * array length will search from the end of the array.

    + * + * @param array the array to traverse for looking for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the start index to travers backwards from + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(double[] array, double valueToFind, int startIndex) { + if (array.length == 0) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + return INDEX_NOT_FOUND; + } else if (startIndex >= array.length) { + startIndex = array.length - 1; + } + for (int i = startIndex; i >= 0; i--) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Finds the last index of the given value in the array starting at the given index. + * This method will return the index of the last value which falls between the region + * defined by valueToFind - tolerance and valueToFind + tolerance.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the + * array length will search from the end of the array.

    + * + * @param array the array to traverse for looking for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the start index to travers backwards from + * @param tolerance search for value within plus/minus this amount + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(double[] array, double valueToFind, int startIndex, double tolerance) { + if (array.length == 0) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + return INDEX_NOT_FOUND; + } else if (startIndex >= array.length) { + startIndex = array.length - 1; + } + double min = valueToFind - tolerance; + double max = valueToFind + tolerance; + for (int i = startIndex; i >= 0; i--) { + if (array[i] >= min && array[i] <= max) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Checks if the value is in the given array.

    + * + *

    The method returns {@code false} if a {@code null} array is passed in.

    + * + * @param array the array to search through + * @param valueToFind the value to find + * @return {@code true} if the array contains the object + */ + public static boolean contains(double[] array, double valueToFind) { + return indexOf(array, valueToFind) != INDEX_NOT_FOUND; + } + + /** + *

    Checks if a value falling within the given tolerance is in the + * given array. If the array contains a value within the inclusive range + * defined by (value - tolerance) to (value + tolerance).

    + * + *

    The method returns {@code false} if a {@code null} array + * is passed in.

    + * + * @param array the array to search + * @param valueToFind the value to find + * @param tolerance the array contains the tolerance of the search + * @return true if value falling within tolerance is in array + */ + public static boolean contains(double[] array, double valueToFind, double tolerance) { + return indexOf(array, valueToFind, 0, tolerance) != INDEX_NOT_FOUND; + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(double[] array, double valueToFind) { + return indicesWith(array, valueToFind, 0); + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(double[] array, double valueToFind, int startIndex) { + if (array == null) { + return INDICES_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + Vector indices = new Vector(); + for (int i = startIndex; i < array.length; i++) { + if (array[i] == valueToFind) { + indices.add(i); + } + } + return checkIndices(indices); + } + + /** + *

    Finds the number of times a given value/object is present in an array.

    + * + * @param array the array to search through for the value/object + * @param valueToFind the object to find. + * @return the number of times that value/object appears in the array + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int numRepeats(double[] array, double valueToFind) { + int count=0; + for (int i=0; iFinds the index of the given value in the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(float[] array, float valueToFind) { + return indexOf(array, valueToFind, 0); + } + + /** + *

    Finds the index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex is treated as zero. A startIndex larger than the array + * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(float[] array, float valueToFind, int startIndex) { + if (array.length == 0) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + for (int i = startIndex; i < array.length; i++) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + + /** + *

    Finds the last index of the given value within the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to travers backwords looking for the object, may be {@code null} + * @param valueToFind the object to find + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(float[] array, float valueToFind) { + return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); + } + + /** + *

    Finds the last index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the + * array length will search from the end of the array.

    + * + * @param array the array to traverse for looking for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the start index to travers backwards from + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(float[] array, float valueToFind, int startIndex) { + if (array.length == 0) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + return INDEX_NOT_FOUND; + } else if (startIndex >= array.length) { + startIndex = array.length - 1; + } + for (int i = startIndex; i >= 0; i--) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Checks if the value is in the given array.

    + * + *

    The method returns {@code false} if a {@code null} array is passed in.

    + * + * @param array the array to search through + * @param valueToFind the value to find + * @return {@code true} if the array contains the object + */ + public static boolean contains(float[] array, float valueToFind) { + return indexOf(array, valueToFind) != INDEX_NOT_FOUND; + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(float[] array, float valueToFind) { + return indicesWith(array, valueToFind, 0); + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(float[] array, float valueToFind, int startIndex) { + if (array == null) { + return INDICES_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + Vector indices = new Vector(); + for (int i = startIndex; i < array.length; i++) { + if (array[i] == valueToFind) { + indices.add(i); + } + } + return checkIndices(indices); + } + + /** + *

    Finds the indices for the array elements within the min and max value (inclusive).

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + */ + public static int[] indicesWithin(float[] array, float minVal, float maxVal) { + if (array == null) { + return INDICES_NOT_FOUND; + } + Vector indices = new Vector(); + for (int i = 0; i < array.length; i++) { + if (array[i] >= minVal && array[i]<= maxVal) { + indices.add(i); + } + } + return checkIndices(indices); + } + + /** + *

    Finds the number of times a given value/object is present in an array.

    + * + * @param array the array to search through for the value/object + * @param valueToFind the object to find. + * @return the number of times that value/object appears in the array + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int numRepeats(float[] array, float valueToFind) { + int count=0; + for (int i=0; i=valueOfMin) indices.add(i); + } + return Cast.arrayListToInt(indices); + } + + public static int[] indicesGreaterThan(float[] array, float valueOfMin){ + ArrayList indices = new ArrayList(); + for(int i=0; ivalueOfMin) indices.add(i); + } + return Cast.arrayListToInt(indices); + } + + /** + *

    Finds the number of elements less than or equal to the specified value.

    + * + * @param array the array to search through for the value/object + * @param valueOfMax the maximum value + * @return the number of elements ? that value + */ + public static int numLessThanOrEqualTo(float[] array, float valueOfMax) { + int count=0; + for (int i=0; iFinds the number of elements strictly less than the specified value.

    + * + * @param array the array to search through for the value/object + * @param valueOfMax the maximum value + * @return the number of elements strictly less than that value + */ + public static int numLessThan(float[] array, float valueOfMax) { + int count=0; + for (int i=0; iFinds the number of elements greater than or equal to the specified value.

    + * + * @param array the array to search through for the value/object + * @param valueOfMax the maximum value + * @return the number of elements ? that value + */ + public static int numGreaterThanOrEqualTo(float[] array, float valueOfMin) { + int count=0; + for (int i=0; i= valueOfMin) { + count++; + } + } + return count; + } + + /** + *

    Finds the number of elements strictly greater than the specified value.

    + * + * @param array the array to search through for the value/object + * @param valueOfMax the maximum value + * @return the number of elements strictly greater than that value + */ + public static int numGreaterThan(float[] array, float valueOfMin) { + int count=0; + for (int i=0; i valueOfMin) { + count++; + } + } + return count; + } + + /** Find the unique elements in a float array (uses HashSets) */ + public static float[] uniqueElems(float[] array){ + Set uniqueVals = new HashSet(); + for(int i=0; iFinds the index of the given value in the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int indexOf(boolean[] array, boolean valueToFind) { + return indexOf(array, valueToFind, 0); + } + + /** + *

    Finds the index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex is treated as zero. A startIndex larger than the array + * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).

    + * + * @param array the array to search through for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} + * array input + */ + public static int indexOf(boolean[] array, boolean valueToFind, int startIndex) { + if (array.length == 0) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + for (int i = startIndex; i < array.length; i++) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Finds the last index of the given value within the array.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) if + * {@code null} array input.

    + * + * @param array the array to travers backwords looking for the object, may be {@code null} + * @param valueToFind the object to find + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(boolean[] array, boolean valueToFind) { + return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); + } + + /** + *

    Finds the last index of the given value in the array starting at the given index.

    + * + *

    This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.

    + * + *

    A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than + * the array length will search from the end of the array.

    + * + * @param array the array to traverse for looking for the object, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the start index to travers backwards from + * @return the last index of the value within the array, + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int lastIndexOf(boolean[] array, boolean valueToFind, int startIndex) { + if (array.length == 0) { + return INDEX_NOT_FOUND; + } + if (startIndex < 0) { + return INDEX_NOT_FOUND; + } else if (startIndex >= array.length) { + startIndex = array.length - 1; + } + for (int i = startIndex; i >= 0; i--) { + if (valueToFind == array[i]) { + return i; + } + } + return INDEX_NOT_FOUND; + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(boolean[] array, boolean valueToFind) { + return indicesWith(array, valueToFind, 0); + } + + /** + *

    Finds the indices containing the specified value in the array.

    + * + *

    This method returns {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) for a {@code null} input array.

    + * + * @param array the array to search through for the value to find, may be {@code null} + * @param valueToFind the value to find + * @param startIndex the index to start searching at + * @return the indices containing the value within the array, + * {@link #INDICES_NOT_FOUND} ({@code int[] = -1}) if not found or {@code null} array input + */ + public static int[] indicesWith(boolean[] array, boolean valueToFind, int startIndex) { + if (array == null) { + return INDICES_NOT_FOUND; + } + if (startIndex < 0) { + startIndex = 0; + } + Vector indices = new Vector(); + for (int i = startIndex; i < array.length; i++) { + if (array[i] == valueToFind) { + indices.add(i); + } + } + return checkIndices(indices); + } + + /** + *

    Finds the number of times a given value/object is present in an array.

    + * + * @param array the array to search through for the value/object + * @param valueToFind the object to find. + * @return the number of times that value/object appears in the array + * {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input + */ + public static int numRepeats(boolean[] array, boolean valueToFind) { + int count=0; + for (int i=0; i0){ + return Cast.vectorToInt(indices); + } + else{ + return INDICES_NOT_FOUND; + } + + } +} + diff --git a/drawing/papaya/src/papaya/Frequency.java b/drawing/papaya/src/papaya/Frequency.java new file mode 100644 index 0000000..c2aa9df --- /dev/null +++ b/drawing/papaya/src/papaya/Frequency.java @@ -0,0 +1,195 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; + +import java.util.*; +import java.io.*; +import processing.core.*; +import processing.core.PApplet; +import processing.core.PImage; + +/** + * Class for getting the frequency distribution, cumulative frequency distribution, and other + * distribution-related parameters of a given array of floats or ints. + * To initialize, use something like this: + *

    + * Frequency freq= new Frequency(dataArray, minimumVal,maximumVal,widthOfEachBin); + * + * Once initialized, it stores 3 things: + *

      + *
    • The array containing the number of elements in each of the histogram bins ({@link getFrequency()}). + *
    • The number of bins. + *
    • The length of the full data array. + *
    + * + *

    A number of different methods are available for computing other distribution-related parameters + * (e.g. the relative frequency distribution, the cumulative frequency distribution, etc).

    + * + *

    See the FrequencyExample in the examples folder for an example.

    + * + * @author Adila Faruk + */ + +// TO DO: OBJECTS!!!! +public class Frequency{ + + private int numBins = 0; + private int ln = 0; + // stored as a float so that we don't mess things up when dividing! + private float[] frequency; + + /** + * Initialize the class by setting the minimum value, maximum value, and the bin width. + * Upon initialization, the number of bins are determined and the + * frequency distribution array is computed for the given input data and histogram bin width. + * This frequency distribution can be accessed using the {@link getFrequency()} function. + * Note that this is the only place where you can set the frequency distribution. + * + *

    How is the number of bins computed? + *
    Like this: + *
    bins = floor[ (max - min) / binWidth ] +1 ,
    + * as opposed to ceil[ (max - min) / binWidth ]. + * Why? The latter algorithm is problematic when [ (max - min) / binWidth ] + * is a whole number. + * E.g. let min = 0.0, max = 100.0, and binWidth = 10.0. We get 10 bins with + *

      + *
    • 1st bin = bin[0] --> contains elements 0.0 - 9.999... + *
    • 2nd bin = bin[1] --> contains elements 10.0 - 19.999... + *
    • ... + *
    • ... + *
    • 10th bin = bin[9] --> contains elements 90.0-99.999... + *
    + * Poor 100. He's got nowhere to go but into an Array Index out of bound Exception! + *

    + *

    What element goes into what bin? + *
    Let value = data[i]; + *
    value will go into bin number floor( (_inputDat[i]-_minVal)/_binWidth ); + *

    + * + * @param _inputDat the input data + * @param _minVal the minimum value in the array + * @param _maxVal the maximum value in the array + * @param _binWidth the width of each of the bins + */ + public Frequency(float[] _inputDat, float _minVal, float _maxVal, float _binWidth){ + numBins = (int)Math.floor((_maxVal - _minVal)/_binWidth) +1; + frequency = new float[numBins]; + for (int i=0; i<_inputDat.length; i++) { + frequency[(int) Math.floor( (_inputDat[i]-_minVal)/_binWidth ) ]++; + } + ln = _inputDat.length; + } + + /** + * Initialize the class by setting the minimum value, maximum value, and the bin width. + * Upon initialization, the number of bins are determined and the + * frequency distribution array is computed for the given input data and histogram bin width. + * This frequency distribution can be accessed using the {@link getFrequency()} function. + * Note that this is the only place where you can set the frequency distribution. + * + *

    See {@link Frequency(float[] _inputDat, float _minVal, float _maxVal, float _binWidth)} for + * more details. + *

    + */ + public Frequency(int[] _inputDat, int _minVal, int _maxVal, int _binWidth){ + numBins = ( (_maxVal - _minVal)/_binWidth) +1; + frequency = new float[numBins]; + for (int i=0; i<_inputDat.length; i++) { + frequency[ (_inputDat[i]-_minVal)/_binWidth ]++; + } + ln = _inputDat.length; + } + + /** + * Computes the fraction of the total data that's in each bin. + * This is similar to dividing the number in each bin by the total + * number of elements in the data array. + */ + public float[] compRelFrequency() { + return Mat.multiply( frequency, (float)1/ln ); + } + + /** + * Computes the percents of the total data that's in each bin. + * This isimilar to dividing the number in each bin by the total + * number of elements in the data array x 100% + */ + public float[] compRelFrequencyPct() { + return Mat.multiply( frequency, (float)100/ln ); + } + + /** + * Computes the cumulative frequency of the data. + */ + public float[] compCumFrequency() { + float[] cumFreq = new float[frequency.length]; + cumFreq[0] = frequency[0]; + for(int i=1; i + * Implementation: + * The code is mostly adapted from the CERN + * Jet Java libraries, which in turn was adapted from the Cephes Mathematical Library. As far a + * as I can tell, Stephen L. Moshier wrote the original C++ code for CEPHES (1989, moshier@na-net.ornl.gov) + * and Wolfgang Hoschek (at CERN, hats off to you mate!) then adapted it for the + * Java platform, making some significant changes along the way. + *
    + * + */ +//public class Gamma extends cern.jet.math.Constants { +public class Gamma implements PapayaConstants { + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected Gamma() {} + /** + * Returns the beta function of the arguments. + * 
    +	 * 
+	 * beta( a, b )  = Γ(a) * Γ(b) ) Γ(a+b)
+	 *
+	 *
    + */ + static public float beta(double a, double b) throws ArithmeticException { + double y; + + y = a + b; + y = gamma(y); + if( y == 0.0 ) return 1.0f; + + if( a > b ) { + y = gamma(a)/y; + y *= gamma(b); + } + else { + y = gamma(b)/y; + y *= gamma(a); + } + + return((float)y); + } + /** + * Returns the Gamma function of the argument, Γ(x) + */ + static public double gamma(double x) throws ArithmeticException { + + double P[] = { + 1.60119522476751861407E-4, + 1.19135147006586384913E-3, + 1.04213797561761569935E-2, + 4.76367800457137231464E-2, + 2.07448227648435975150E-1, + 4.94214826801497100753E-1, + 9.99999999999999996796E-1 + }; + double Q[] = { + -2.31581873324120129819E-5, + 5.39605580493303397842E-4, + -4.45641913851797240494E-3, + 1.18139785222060435552E-2, + 3.58236398605498653373E-2, + -2.34591795718243348568E-1, + 7.14304917030273074085E-2, + 1.00000000000000000320E0 + }; + //double MAXGAM = 171.624376956302725; + //double LOGPI = 1.14472988584940017414; + + double p, z; + int i; + + double q = Math.abs(x); + + if( q > 33.0 ) { + if( x < 0.0 ) { + p = Math.floor(q); + if( p == q ) throw new ArithmeticException("gamma: overflow"); + i = (int)p; + z = q - p; + if( z > 0.5 ) { + p += 1.0; + z = q - p; + } + z = q * Math.sin( Math.PI * z ); + if( z == 0.0 ) throw new ArithmeticException("gamma: overflow"); + z = Math.abs(z); + z = Math.PI/(z * stirlingFormula(q) ); + + return -z; + } else { + return stirlingFormula(x); + } + } + + z = 1.0; + while( x >= 3.0 ) { + x -= 1.0; + z *= x; + } + + while( x < 0.0 ) { + if( x == 0.0 ) { + throw new ArithmeticException("gamma: singular"); + } else + if( x > -1.E-9 ) { + return( z/((1.0 + 0.5772156649015329 * x) * x) ); + } + z /= x; + x += 1.0; + } + + while( x < 2.0 ) { + if( x == 0.0 ) { + throw new ArithmeticException("gamma: singular"); + } else + if( x < 1.e-9 ) { + return( z/((1.0 + 0.5772156649015329 * x) * x) ); + } + z /= x; + x += 1.0; + } + + if( (x == 2.0) || (x == 3.0) ) return z; + + x -= 2.0; + p = Polynomial.polyval( x, P ); + q = Polynomial.polyval( x, Q ); + return z * p / q; + + } + /** + * Returns the Incomplete Beta Function evaluated from zero to xx; formerly named ibeta. + * + * @param aa the alpha parameter of the beta distribution. + * @param bb the beta parameter of the beta distribution. + * @param xx the integration end point. + */ + public static double incompleteBeta( double aa, double bb, double xx ) throws ArithmeticException { + double a, b, t, x, xc, w, y; + boolean flag; + + if( aa <= 0.0 || bb <= 0.0 ) throw new + ArithmeticException("incompleteBeta: Domain error!"); + + if( (xx <= 0.0) || ( xx >= 1.0) ) { + if( xx == 0.0 ) return 0.0; + if( xx == 1.0 ) return 1.0; + throw new ArithmeticException("incompleteBeta: Domain error!"); + } + + flag = false; + if( (bb * xx) <= 1.0 && xx <= 0.95) { + t = powerSeries(aa, bb, xx); + return t; + } + + w = 1.0 - xx; + + /* Reverse a and b if x is greater than the mean. */ + if( xx > (aa/(aa+bb)) ) { + flag = true; + a = bb; + b = aa; + xc = xx; + x = w; + } else { + a = aa; + b = bb; + xc = w; + x = xx; + } + + if( flag && (b * x) <= 1.0 && x <= 0.95) { + t = powerSeries(a, b, x); + if( t <= MACHEP ) t = 1.0 - MACHEP; + else t = 1.0 - t; + return t; + } + + /* Choose expansion for better convergence. */ + y = x * (a+b-2.0) - (a-1.0); + if( y < 0.0 ) + w = incompleteBetaFraction1( a, b, x ); + else + w = incompleteBetaFraction2( a, b, x ) / xc; + + /* Multiply w by the factor + x^a (1-x)^b Γ(a+b) / ( a *Γ(a) *Γ(b) ) . */ + + y = a * Math.log(x); + t = b * Math.log(xc); + if( (a+b) < MAXGAM && Math.abs(y) < MAXLOG && Math.abs(t) < MAXLOG ) { + t = Math.pow(xc,b); + t *= Math.pow(x,a); + t /= a; + t *= w; + t *= gamma(a+b) / (gamma(a) * gamma(b)); + if( flag ) { + if( t <= MACHEP ) t = 1.0 - MACHEP; + else t = 1.0 - t; + } + return t; + } + /* Resort to logarithms. */ + y += t + logGamma(a+b) - logGamma(a) - logGamma(b); + y += Math.log(w/a); + if( y < MINLOG ) + t = 0.0; + else + t = Math.exp(y); + + if( flag ) { + if( t <= MACHEP ) t = 1.0 - MACHEP; + else t = 1.0 - t; + } + return t; + } + + /** + * Returns the inverse of the incomplete Beta integral. + * That is, given y, the function finds x such that + * 
    +	 *  incompleteBeta( a, b, x ) = y.
+	 *
    + * The routine performs interval halving until incompleteBeta(a,b,x) - y = 0, + * to within roughly 10^-13 of the true solution. If this precision is not reached, the + * method returns the current approximation of x, and prints a warning statement + * specifying the current error. Typically, this is on the order of 10^-12. + * + * @param aa the alpha parameter of the beta distribution. + * @param bb the beta parameter of the beta distribution. + * @param yy0 the value for which to solve for the corresponding x in the + * incomplete Beta integral. + * @return the value x such that incompleteBeta( a, b, x ) = y. + */ + public static double incompleteBetaInverse(double aa,double bb,double yy0 ) + { + double a=0, b=0, y0=0, d, y=0, x=0, x0, x1, lgm=0, yp, di=0, dithresh=0, yl, yh, xt; + int i=0, rflg=0, dir=0, nflg; + + //ap_error::make_assertion(y>=0&&y<=1); + if( yy0 <= 0 ) + return 0.0; + if( yy0 >= 1.0 ) + return 1.0; + x0 = 0.0; + yl = 0.0; // ylow + x1 = 1.0; + yh = 1.0; // yhigh + + int count = 0; + double precision = 1e-8; + + /* Make an initial approximation for the inverse function */ + + if( aa <= 1.0 || bb <= 1.0 ) + { + dithresh = 1.0e-6; + rflg = 0; + a = aa; + b = bb; + y0 = yy0; + x = a/(a+b); // approximate x using the mean value + y = incompleteBeta( a, b, x ); + } + else{ + a=aa; + b=bb; + y0 = yy0; + + yp = -Probability.norminv(yy0); + if( yy0 > 0.5 ) + { + yp = -yp; // since the normal distribution is symmetric + } + // log gamma + lgm = (yp * yp - 3.0)/6.0; + x = 2.0/( 1.0/(2.0*a-1.0) + 1.0/(2.0*b-1.0) ); + + d = yp * Math.sqrt( x + lgm ) / x + - ( 1.0/(2.0*b-1.0) - 1.0/(2.0*a-1.0) ) + * (lgm + 5.0/6.0 - 2.0/(3.0*x)); + d = 2.0 * d; + if( d < MINLOG ) + { + x = 0.0; + return x; + } + x = a/( a + b * Math.exp(d) ); + y = incompleteBeta( a, b, x ); + } + + /* This only works because the incompleteBeta function is an increasing function */ + while (Math.abs(y-y0) > precision && count<1000) + { + // if y>y0, we're too far right so move x1 to x + if (y > y0) + { + x1 = x; + } + else // y<=y0 we're too far left so move x0 to the right. + { + x0 = x; + } + x = (x1 + x0) / 2; + y = incompleteBeta( a, b, x ); + count++; // so we don't end up in a never-ending loop. + } + if(count>=1000){ + System.out.println("Warning: incompleteBetaInverse: Could not solve to specified precision."+ + "Returning closest match ( error = " + Math.abs(y-y0)+" )"); + } + return x; + } + + /** + * Continued fraction expansion #1 for incomplete beta integral; formerly named incbcf. + */ + static double incompleteBetaFraction1( double a, double b, double x ) throws ArithmeticException { + double xk, pk, pkm1, pkm2, qk, qkm1, qkm2; + double k1, k2, k3, k4, k5, k6, k7, k8; + double r, t, ans, thresh; + int n; + + k1 = a; + k2 = a + b; + k3 = a; + k4 = a + 1.0; + k5 = 1.0; + k6 = b - 1.0; + k7 = k4; + k8 = a + 2.0; + + pkm2 = 0.0; + qkm2 = 1.0; + pkm1 = 1.0; + qkm1 = 1.0; + ans = 1.0; + r = 1.0; + n = 0; + thresh = 3.0 * MACHEP; + do { + xk = -( x * k1 * k2 )/( k3 * k4 ); + pk = pkm1 + pkm2 * xk; + qk = qkm1 + qkm2 * xk; + pkm2 = pkm1; + pkm1 = pk; + qkm2 = qkm1; + qkm1 = qk; + + xk = ( x * k5 * k6 )/( k7 * k8 ); + pk = pkm1 + pkm2 * xk; + qk = qkm1 + qkm2 * xk; + pkm2 = pkm1; + pkm1 = pk; + qkm2 = qkm1; + qkm1 = qk; + + if( qk != 0 ) r = pk/qk; + if( r != 0 ) { + t = Math.abs( (ans - r)/r ); + ans = r; + } else + t = 1.0; + + if( t < thresh ) return ans; + + k1 += 1.0; + k2 += 1.0; + k3 += 2.0; + k4 += 2.0; + k5 += 1.0; + k6 -= 1.0; + k7 += 2.0; + k8 += 2.0; + + if( (Math.abs(qk) + Math.abs(pk)) > big ) { + pkm2 *= biginv; + pkm1 *= biginv; + qkm2 *= biginv; + qkm1 *= biginv; + } + if( (Math.abs(qk) < biginv) || (Math.abs(pk) < biginv) ) { + pkm2 *= big; + pkm1 *= big; + qkm2 *= big; + qkm1 *= big; + } + } while( ++n < 300 ); + + return ans; + } + /** + * Continued fraction expansion #2 for incomplete beta integral; formerly named incbd. + */ + static double incompleteBetaFraction2( double a, double b, double x ) throws ArithmeticException { + double xk, pk, pkm1, pkm2, qk, qkm1, qkm2; + double k1, k2, k3, k4, k5, k6, k7, k8; + double r, t, ans, z, thresh; + int n; + + k1 = a; + k2 = b - 1.0; + k3 = a; + k4 = a + 1.0; + k5 = 1.0; + k6 = a + b; + k7 = a + 1.0;; + k8 = a + 2.0; + + pkm2 = 0.0; + qkm2 = 1.0; + pkm1 = 1.0; + qkm1 = 1.0; + z = x / (1.0-x); + ans = 1.0; + r = 1.0; + n = 0; + thresh = 3.0 * MACHEP; + do { + xk = -( z * k1 * k2 )/( k3 * k4 ); + pk = pkm1 + pkm2 * xk; + qk = qkm1 + qkm2 * xk; + pkm2 = pkm1; + pkm1 = pk; + qkm2 = qkm1; + qkm1 = qk; + + xk = ( z * k5 * k6 )/( k7 * k8 ); + pk = pkm1 + pkm2 * xk; + qk = qkm1 + qkm2 * xk; + pkm2 = pkm1; + pkm1 = pk; + qkm2 = qkm1; + qkm1 = qk; + + if( qk != 0 ) r = pk/qk; + if( r != 0 ) { + t = Math.abs( (ans - r)/r ); + ans = r; + } else + t = 1.0; + + if( t < thresh ) return ans; + + k1 += 1.0; + k2 -= 1.0; + k3 += 2.0; + k4 += 2.0; + k5 += 1.0; + k6 += 1.0; + k7 += 2.0; + k8 += 2.0; + + if( (Math.abs(qk) + Math.abs(pk)) > big ) { + pkm2 *= biginv; + pkm1 *= biginv; + qkm2 *= biginv; + qkm1 *= biginv; + } + if( (Math.abs(qk) < biginv) || (Math.abs(pk) < biginv) ) { + pkm2 *= big; + pkm1 *= big; + qkm2 *= big; + qkm1 *= big; + } + } while( ++n < 300 ); + + return ans; + } + /** + * Returns the Incomplete Gamma function; formerly named igamma. + * @param a the parameter of the gamma distribution. + * @param x the integration end point. + */ + static public double incompleteGamma(double a, double x) + throws ArithmeticException { + + + double ans, ax, c, r; + + if( x <= 0 || a <= 0 ) return 0.0; + + if( x > 1.0 && x > a ) return 1.0 - incompleteGammaComplement(a,x); + + /* Compute x**a * exp(-x) / gamma(a) */ + ax = a * Math.log(x) - x - logGamma(a); + if( ax < -MAXLOG ) return( 0.0 ); + + ax = Math.exp(ax); + + /* power series */ + r = a; + c = 1.0; + ans = 1.0; + + do { + r += 1.0; + c *= x/r; + ans += c; + } + while( c/ans > MACHEP ); + + return( ans * ax/a ); + + } + /** + * Returns the Complemented Incomplete Gamma function; formerly named igamc. + * @param a the parameter of the gamma distribution. + * @param x the integration start point. + */ + static public double incompleteGammaComplement( double a, double x ) throws ArithmeticException { + double ans, ax, c, yc, r, t, y, z; + double pk, pkm1, pkm2, qk, qkm1, qkm2; + + if( x <= 0 || a <= 0 ) return 1.0; + + if( x < 1.0 || x < a ) return 1.0 - incompleteGamma(a,x); + + ax = a * Math.log(x) - x - logGamma(a); + if( ax < -MAXLOG ) return 0.0; + + ax = Math.exp(ax); + + /* continued fraction */ + y = 1.0 - a; + z = x + y + 1.0; + c = 0.0; + pkm2 = 1.0; + qkm2 = x; + pkm1 = x + 1.0; + qkm1 = z * x; + ans = pkm1/qkm1; + + do { + c += 1.0; + y += 1.0; + z += 2.0; + yc = y * c; + pk = pkm1 * z - pkm2 * yc; + qk = qkm1 * z - qkm2 * yc; + if( qk != 0 ) { + r = pk/qk; + t = Math.abs( (ans - r)/r ); + ans = r; + } else + t = 1.0; + + pkm2 = pkm1; + pkm1 = pk; + qkm2 = qkm1; + qkm1 = qk; + if( Math.abs(pk) > big ) { + pkm2 *= biginv; + pkm1 *= biginv; + qkm2 *= biginv; + qkm1 *= biginv; + } + } while( t > MACHEP ); + + return ans * ax; + } + /** + * Returns the natural logarithm of the gamma function; formerly named lgamma. + */ + public static double logGamma(double x) throws ArithmeticException { + double p, q, w, z; + + double A[] = { + 8.11614167470508450300E-4, + -5.95061904284301438324E-4, + 7.93650340457716943945E-4, + -2.77777777730099687205E-3, + 8.33333333333331927722E-2 + }; + double B[] = { + -1.37825152569120859100E3, + -3.88016315134637840924E4, + -3.31612992738871184744E5, + -1.16237097492762307383E6, + -1.72173700820839662146E6, + -8.53555664245765465627E5 + }; + double C[] = { + 1.00000000000000000000E0, + -3.51815701436523470549E2, + -1.70642106651881159223E4, + -2.20528590553854454839E5, + -1.13933444367982507207E6, + -2.53252307177582951285E6, + -2.01889141433532773231E6 + }; + + if( x < -34.0 ) { + q = -x; + w = logGamma(q); + p = Math.floor(q); + if( p == q ) throw new ArithmeticException("logGamma: Overflow"); + z = q - p; + if( z > 0.5 ) { + p += 1.0; + z = p - q; + } + z = q * Math.sin( Math.PI * z ); + if( z == 0.0 ) throw new + ArithmeticException("logGamma: Overflow"); + z = LOGPI - Math.log( z ) - w; + return z; + } + + if( x < 13.0 ) { + z = 1.0; + while( x >= 3.0 ) { + x -= 1.0; + z *= x; + } + while( x < 2.0 ) { + if( x == 0.0 ) throw new + ArithmeticException("logGamma: Overflow"); + z /= x; + x += 1.0; + } + if( z < 0.0 ) z = -z; + if( x == 2.0 ) return Math.log(z); + x -= 2.0; + p = x * Polynomial.polyval( x, B) / Polynomial.polyval( x, C); + return( Math.log(z) + p ); + } + + if( x > 2.556348e305 ) throw new + ArithmeticException("logGamma: Overflow"); + + q = ( x - 0.5 ) * Math.log(x) - x + 0.91893853320467274178; + //if( x > 1.0e8 ) return( q ); + if( x > 1.0e8 ) return( q ); + + p = 1.0/(x*x); + if( x >= 1000.0 ) + q += (( 7.9365079365079365079365e-4 * p + - 2.7777777777777777777778e-3) *p + + 0.0833333333333333333333) / x; + else + q += Polynomial.polyval( p, A ) / x; + return q; + } + /** + * Power series for incomplete beta integral; formerly named pseries. + * Use when b*x is small and x not too close to 1. + */ + static double powerSeries( double a, double b, double x ) throws ArithmeticException { + double s, t, u, v, n, t1, z, ai; + + ai = 1.0 / a; + u = (1.0 - b) * x; + v = u / (a + 1.0); + t1 = v; + t = u; + n = 2.0; + s = 0.0; + z = MACHEP * ai; + while( Math.abs(v) > z ) { + u = (n - b) * x / n; + t *= u; + v = t / (a + n); + s += v; + n += 1.0; + } + s += t1; + s += ai; + + u = a * Math.log(x); + if( (a+b) < MAXGAM && Math.abs(u) < MAXLOG ) { + t = Gamma.gamma(a+b)/(Gamma.gamma(a)*Gamma.gamma(b)); + s = s * t * Math.pow(x,a); + } else { + t = Gamma.logGamma(a+b) - Gamma.logGamma(a) - Gamma.logGamma(b) + u + Math.log(s); + if( t < MINLOG ) s = 0.0; + else s = Math.exp(t); + } + return s; + } + /** + * Returns the Gamma function computed by Stirling's formula; formerly named stirf. + * The polynomial STIR is valid for 33 <= x <= 172. + */ + static double stirlingFormula(double x) throws ArithmeticException { + double STIR[] = { + 7.87311395793093628397E-4, + -2.29549961613378126380E-4, + -2.68132617805781232825E-3, + 3.47222221605458667310E-3, + 8.33333333333482257126E-2, + }; + double MAXSTIR = 143.01608; + + double w = 1.0/x; + double y = Math.exp(x); + + w = 1.0 + w * Polynomial.polyval( w, STIR); + + if( x > MAXSTIR ) { + /* Avoid overflow in Math.pow() */ + double v = Math.pow( x, 0.5 * x - 0.25 ); + y = v * (v / y); + } else { + y = Math.pow( x, x - 0.5 ) / y; + } + y = SQTPI * y * w; + return y; + } +} diff --git a/drawing/papaya/src/papaya/LU.java b/drawing/papaya/src/papaya/LU.java new file mode 100644 index 0000000..0ac1b42 --- /dev/null +++ b/drawing/papaya/src/papaya/LU.java @@ -0,0 +1,410 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; + +/** LU Decomposition. +

    +For an m x n matrix A with m > n, the LU decomposition is an m x n +unit lower triangular matrix L, an n x n upper triangular matrix U, +and a permutation vector piv of length m so that A(piv,:) = L*U; +If m < n, then L is m x m and U is m x n. +

    +The LU decomposition with pivoting always exists, even if the matrix is +singular, so the constructor will never fail. The primary use of the +LU decomposition is in the solution of square systems of simultaneous +linear equations. This will fail if isNonsingular() returns false. +

    +Shamelessly copied (and modified) from the +JAMA Java +Matrix package. To make things compatible with how most users use Processing, the +class take in float matrices. However, to preserve the acccuracy of the computations, the algorithm +first casts the input into a double array, prior to doing anything. All methods also return doubles; Use +{@link Cast#doubleToFloat(double[][])} if you want/need to cast everything back to floats for +further (non-high-accuracy-dependant) processing (pun intended). + */ + +public class LU { + + /* ------------------------ +Class variables + * ------------------------ */ + + /** Array for internal storage of decomposition. +@serial internal array storage. + */ + private double[][] LU; + + /** Row and column dimensions, and pivot sign. +@serial column dimension. +@serial row dimension. +@serial pivot sign. + */ + private int numRows, numColumns, pivsign; + + /** Internal storage of pivot vector. +@serial pivot vector. + */ + private int[] piv; + + /* ------------------------ +Constructor + * ------------------------ */ + + /** Constructor. Takes in a matrix and computes the LU matrix. Additional + * parameters can be obtained by calling one of the available methods. + * @see getL() + * @see getU() + * @see getPivot() + * @see getFloatPivot() + * @see det() + */ + public LU (float[][] A) { + + // Use a "left-looking", dot-product, Crout/Doolittle algorithm. + LU = Cast.floatToDouble(A); + numRows = A.length; + numColumns = A[0].length; + piv = new int[numRows]; + for (int i = 0; i < numRows; i++) { + piv[i] = i; + } + pivsign = 1; + double[] LUrowi; + double[] LUcolj = new double[numRows]; + + // Outer loop. + + for (int j = 0; j < numColumns;j++) { + + // Make a copy of the j-th column to localize references. + + for (int i = 0; i < numRows; i++) { + LUcolj[i] = LU[i][j]; + } + + // Apply previous transformations. + + for (int i = 0; i < numRows; i++) { + LUrowi = LU[i]; + + // Most of the time is spent in the following dot product. + + int kmax = Math.min(i,j); + float s = 0.0f; + for (int k = 0; k < kmax; k++) { + s += LUrowi[k]*LUcolj[k]; + } + + LUrowi[j] = LUcolj[i] -= s; + } + + // Find pivot and exchange if necessary. + + int p = j; + for (int i = j+1; i < numRows; i++) { + if (Math.abs(LUcolj[i]) > Math.abs(LUcolj[p])) { + p = i; + } + } + if (p != j) { + for (int k = 0; k < numColumns; k++) { + double t = LU[p][k]; LU[p][k] = LU[j][k]; LU[j][k] = t; + } + int k = piv[p]; piv[p] = piv[j]; piv[j] = k; + pivsign = -pivsign; + } + + // Compute multipliers. + + if (j < numRows & LU[j][j] != 0.0) { + for (int i = j+1; i < numRows; i++) { + LU[i][j] /= LU[j][j]; + } + } + } + } + + /* ------------------------ +Temporary, experimental code. +------------------------ *\ + +\** LU Decomposition, computed by Gaussian elimination. +

    +This constructor computes L and U with the "daxpy"-based elimination +algorithm used in LINPACK and MATLAB. In Java, we suspect the dot-product, +Crout algorithm will be faster. We have temporarily included this +constructor until timing experiments confirm this suspicion. +

    +@param A Rectangular matrix +@param linpackflag Use Gaussian elimination. Actual value ignored. +@return Structure to access L, U and piv. + *\ + +public LUDecomposition (Matrix A, int linpackflag) { + // Initialize. + LU = A.getArrayCopy(); + m = A.getRowDimension(); + n = A.getColumnDimension(); + piv = new int[m]; + for (int i = 0; i < numRows; i++) { + piv[i] = i; + } + pivsign = 1; + // Main loop. + for (int k = 0; k < numColumns k++) { + // Find pivot. + int p = k; + for (int i = k+1; i < numRows; i++) { + if (Math.abs(LU[i][k]) > Math.abs(LU[p][k])) { + p = i; + } + } + // Exchange if necessary. + if (p != k) { + for (int j = 0; j < numColumns;j++) { + double t = LU[p][j]; LU[p][j] = LU[k][j]; LU[k][j] = t; + } + int t = piv[p]; piv[p] = piv[k]; piv[k] = t; + pivsign = -pivsign; + } + // Compute multipliers and eliminate k-th column. + if (LU[k][k] != 0.0) { + for (int i = k+1; i < numRows; i++) { + LU[i][k] /= LU[k][k]; + for (int j = k+1; j < numColumns;j++) { + LU[i][j] -= LU[i][k]*LU[k][j]; + } + } + } + } +} + +\* ------------------------ +End of temporary code. + * ------------------------ */ + + /* ------------------------ +Public Methods + * ------------------------ */ + + /** Is the matrix nonsingular? +@return true if U, and hence A, is nonsingular. + */ + + public boolean isNonsingular () { + for (int j = 0; j < numColumns;j++) { + if (LU[j][j] == 0) + return false; + } + return true; + } + + /** Return lower triangular factor, L.*/ + public double[][] getL () { + double[][] L = new double[numRows][numColumns]; + for (int i = 0; i < numRows; i++) { + for (int j = 0; j < numColumns;j++) { + if (i > j) { + L[i][j] = LU[i][j]; + } else if (i == j) { + L[i][j] = 1.0f; + } else { + L[i][j] = 0.0f; + } + } + } + return L; + } + + /** Return upper triangular factor, U */ + public double[][] getU () { + double[][] U = new double[numColumns][numColumns]; + for (int i = 0; i < numColumns; i++) { + for (int j = 0; j < numColumns;j++) { + if (i <= j) { + U[i][j] = LU[i][j]; + } else { + U[i][j] = 0.0f; + } + } + } + return U; + } + + /** Return pivot permutation vector +@return piv + */ + + public int[] getPivot () { + int[] p = new int[numRows]; + for (int i = 0; i < numRows; i++) { + p[i] = piv[i]; + } + return p; + } + + /** Return pivot permutation vector as a one-dimensional float array + * @return piv + */ + + public float[] getFloatPivot () { + float[] vals = new float[numRows]; + for (int i = 0; i < numRows; i++) { + vals[i] = (float) piv[i]; + } + return vals; + } + + /** Determinant + *@return det(A) + *@exception IllegalArgumentException Matrix must be square + */ + public double det () { + if (numRows != numColumns) { + throw new IllegalArgumentException("Matrix must be square."); + } + double d = (double) pivsign; + for (int j = 0; j < numColumns;j++) { + d *= LU[j][j]; + } + return d; + } + + /** Solve A*x = b for x + * @param b An array with as many elements as the number of rows in A. + * @return x so that L*U*x = b(piv,:) + * @exception IllegalArgumentException Matrix row dimensions must agree. + * @exception RuntimeException Matrix is singular. + */ + public double[] solve (float[] b, boolean returnZeroesForSingularCase) { + if (b.length != numRows) { + throw new IllegalArgumentException("Matrix row dimensions must agree."); + } + if (!this.isNonsingular()) { + if(returnZeroesForSingularCase) return new double[numColumns]; + else throw new RuntimeException("Matrix is singular."); + } + + // Copy right hand side with pivoting + double[] X = Cast.floatToDouble(Mat.populate(b,piv)); + //System.out.println(X.length+","+b.length+","+LU[0].length); + // Solve L*Y = B(piv,:) + for (int k = 0; k < numColumns; k++) { + for (int i = k+1; i < numColumns; i++) { + X[i] -= X[k]*LU[i][k]; + } + } + // Solve U*X = Y; + for (int k = numColumns-1; k >= 0; k--) { + X[k] /= LU[k][k]; + for (int i = 0; i < k; i++) { + X[i] -= X[k]*LU[i][k]; + } + } + //Mat.print(X,3); System.out.print("\n"); + return X; + } + + /** Solve A*X = B + * @param B A Matrix with as many rows as A and any number of columns. + * @return X so that L*U*X = B(piv,:) + * @exception IllegalArgumentException Matrix row dimensions must agree. + * @exception RuntimeException Matrix is singular. + */ + public double[][] solve (float[][] B) { + if (B.length != numRows) { + throw new IllegalArgumentException("Matrix row dimensions must agree."); + } + if (!this.isNonsingular()) { + throw new RuntimeException("Matrix is singular."); + } + + // Copy right hand side with pivoting + int nx = B[0].length; + double[][] X = subMatrix(B,piv,0,nx-1); + // Solve L*Y = B(piv,:) + for (int k = 0; k < numColumns; k++) { + for (int i = k+1; i < numColumns; i++) { + for (int j = 0; j < nx; j++) { + X[i][j] -= X[k][j]*LU[i][k]; + } + } + } + // Solve U*X = Y; + for (int k = numColumns-1; k >= 0; k--) { + for (int j = 0; j < nx; j++) { + X[k][j] /= LU[k][k]; + } + for (int i = 0; i < k; i++) { + for (int j = 0; j < nx; j++) { + X[i][j] -= X[k][j]*LU[i][k]; + } + } + } + return X; + } + + /** + * Function to get a (2D) submatrix of a (2D) matrix (a copy, not a pointer). + * @param inputMat input matrix + * @param rowIndices the row indices + * @param columnStart column to start at (inclusive) + * @param columnEnd column to end at (inclusive) + * @return the submatrix containing a copy of the input matrix's specified rows from + * columnStart to columnEnd; copy of A(rowIndices(:), columnStart:columnEnd). + * @throws IllegalArgumentException if the inputs are not within the inputMatrix size bounds. + */ + private static double[][] subMatrix(float[][] inputMat, int[] rowIndices, int columnStart, int columnEnd) { + int numRows = rowIndices.length; + int numColumns = columnEnd-columnStart+1; + double[][] outputMat = new double[numRows][numColumns]; + for (int i = 0; i z[i] = x[i] * y[i]. + */ + private static double[] multiply(float[] data1, int[] pivot){ + int size = data1.length; + double[] multiplied = new double[size]; + for(int i=0; iz = slope*x + intercept by minimizing the sum of least squares + * between z and the y. + * @param x the x data + * @param y the y data + * @return a 2-by-1 array with the first element coeff[0]corresponding to + * the slope, and the second element coeff[1] equal to the y-intercept. + */ + public static float[] bestFit(float[] x, float[] y){ + int size = x.length; + Check.equalLengths(size,y); + if(size<3) throw new IllegalArgumentException("Each data array needs to hold at least 3 values."); + + // the best-fit linear line coefficients. + double sumX = 0; double sumY = 0; double sumXY = 0; double sumXX = 0; + for(int i=0; iz = slope*x + intercept, where the intercept is specified + * by the user. E.g. intercept = 1 will result in z = slope*x+1. + * The slope is computed by minimizing the sum of least squares + * between z and the y. + * @param x the x data + * @param y the y data + * @param intercept the intercept of the best-fit line with the y-axis. + * + * @return the slope of the best-fit linear line. + */ + public static float bestFit(float[] x, float[] y, float intercept){ + int size = x.length; + Check.equalLengths(size,y); + if(size<3) throw new IllegalArgumentException("Each data array needs to hold at least 3 values."); + // the best-fit linear line coefficients. + double sumX = 0; double sumY = 0; double sumXY = 0; double sumXX = 0; + for(int i=0; iDelta_i = z_i - y_i, + * where + * z_i = (slope*x_i + intercept) is the best fit linear line. + * @param slope the slope of the best-fit linear line + * @param intercept the y-intercept of the best fit linear line + */ + public static float[] residuals(float[] x, float[] y, float slope, float intercept){ + int size = x.length; Check.equalLengths(size,y); + float[] delta = new float[size]; + for(int i=0; iDelta_i = z_i - y_i, + * where + * z_i = (slope*x_i + intercept) is the best fit linear line. + * You'd basically use this to compute the spread of a best fit line (max - min) + */ + public static float[] residuals(float[] x, float[] y){ + int size = x.length; Check.equalLengths(size,y); + float[] params = bestFit(x,y); + float[] delta = new float[size]; + for(int i=0; i + * residualStdErr = Sqrt ( Sum( (delta[i] - mean(delta))^2 ) / df ) + * + * where df is the degrees of freedom ( (n-1) if the y-intercept was pre-specified in the + * best-fit line, (n-2) if neither slope nor intercept were specified.) + * @param residuals + * @param df + * @return standard error of the residual + */ + public static float residual(float[] residuals, int df){ + int size = residuals.length; + return (float)Math.sqrt( Descriptive.var(residuals,false) * size/df ); + } + /** + * Returns the standard error of the computed slope given x and the + * standard error in the residuals. That is, + * 

    +		 * slopeStdErr = residualStdErr / Sum ( (x[i] - mean(x))^2 ).
+		 *
    + * @param x the independent variable + * @param residualStdErr the standard error of the residual + * @return the error in the slope. + */ + public static float slope(float[] x, float residualStdErr ){ + float v = Descriptive.varianceNotNormalized(x); + double slopeError = residualStdErr/Math.sqrt(v); + return (float)slopeError; + } + /** + * Returns the standard error of the computed slope given x and the + * standard error in the residuals. That is, + * 
    +		 * interceptStdErr = slopeStdErr / Sqrt( Sum(x[i]*x[i])/size ).
+		 *
    + * where the slopeStdErr is computed using the methods specified + * in {@link StdErr#slope}. + * @param x the independent variable + * @param residualStdErr the standard error of the residual + * @return error in the slope. + */ + public static float intercept(float[] x, float residualStdErr ){ + int size = x.length; + float slopeError = slope(x,residualStdErr); + double sumXX = 0; + for(int i=0; inot to be used for small datasets(i.e. size<20). + */ + public static class Significance{ + /** + * Returns the p-value, or significance, of the computed slope under the null-hypothesis + * of slope = 0 (two-tailed test). The p-value is computed using the student-T distribution + * with df degrees of freedom and test statistic + * 
     t = slope/slopeStdErr,
    + * @param slope the slope of the best fit linear line + * @param slopeStdErr the standard error of the slope + * @param df the degrees of freedom (typically (n-2), but could also be (n-1) if the + * intercept was previously specified. + */ + public static float slope(float slope, float slopeStdErr, int df){ + double t = slope/slopeStdErr; + System.out.println("t slope: "+t); + return (float)twoTailedStudentT(t,df); + } + /** + * Returns the p-value, or significance, of the computed intercept under the null-hypothesis + * of intercept = 0 (two-tailed test). The p-value is computed using the student-T distribution + * with df degrees of freedom and test statistic + * 
    t=intercept/interceptStdErr
    + * @param intercept the intercept of the best fit linear line + * @param interceptStdErr the standard error of the intercept + * @param df the degrees of freedom (n-2) + */ + public static float intercept(float intercept, float interceptStdErr, int df){ + double t = intercept/interceptStdErr; + System.out.println("t intercept: "+t); + return (float)twoTailedStudentT(t,df); + } + } + + /** + * Contains methods related to the Box-Cox transformation of a data set; useful in + * determining the best transformation that will yield the best method for converting + * a monotonic, non-linear relationship between x and y into + * a linear one. + *

    Reference: + *
    Box, George E. P.; Cox, D. R. (1964). "An analysis of transformations". + * Journal of the Royal Statistical Society, Series B 26 (2): 211?252. + *
    + * NIST/SEMATECH e-Handbook of Statistical Methods, EDA Section 1.3.3.6: Box-Cox Linearity Plots + * (The reader's digest version of the original.) + * + */ + public static class BoxCox{ + protected BoxCox(){} + + /** + * Performs the box-cox transformation on y for a sequence of λ + * and returns the array of linear correlation coefficients + * between the x and the box-cox transformed y. + * at each value of λ . + * The value of λ corresponding to the maximum correlation + * (or minimum for negative correlation) is the optimal choice for + * λ such that the relationship between x and T(y) is linear. + *

    Reference: + *
    + * NIST/SEMATECH e-Handbook of Statistical Methods, EDA Section 1.3.3.6: Box-Cox Linearity Plots + * + * @param x the independent data array + * @param y the dependent data array + * @param lambda an array of lambda values + * @return the array containing the linear correlation coefficients, r. + */ + public static float[] correlation(float[] x, float[] y, float []lambda){ + /* Check that the data is all positive */ + if(Descriptive.min(x)<=0) throw new IllegalArgumentException("y (the dependent variable) has to be strictly > 0."); + int size = x.length; + Check.equalLengths(size,y); + float[] transformed = new float[size]; + int numSteps = lambda.length; + float[] corrcoef = new float[numSteps]; + for(int i=0; i + * y[i](λ) = (y[i]^λ-1) / λ if λ ≠ 0 + * + * y[i](λ) = log(y[i])if λ = 0 + * + * Requirements: all elements of y are >0. + * @param data the data to be transformed + * @param lambda the lambda value + * @return the transformed data, or y(λ) above. + * */ + public static float[] transform(float[] data, float lambda){ + /* Check that the data is all positive */ + if(Descriptive.min(data)<=0) throw new IllegalArgumentException("data has to be strictly > 0."); + int size = data.length; + float[] transformed = new float[size]; + if(lambda==0){ + for(int i=0; i0) return ( 2*(1.0- (Probability.tcdf(t,df)) ) ); + else return (2 * (Probability.tcdf(t,df))); + } +} + + + + + + + + diff --git a/drawing/papaya/src/papaya/MDS.java b/drawing/papaya/src/papaya/MDS.java new file mode 100644 index 0000000..add55c3 --- /dev/null +++ b/drawing/papaya/src/papaya/MDS.java @@ -0,0 +1,149 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ + +package papaya; + +import java.util.*; +import java.io.*; +import java.text.NumberFormat; +import java.text.DecimalFormat; +import java.text.DecimalFormatSymbols; + +import processing.core.*; + +/** + * Contains methods for performing but classical and non-classical multidimensional scaling. + *

    + * For an m-by-n input matrix with m observations and n variables, the output D is + * the symmetric m-by-m matrix with zeros along the diagonals and element ij + * specifying the distance between rows i and j. + * + */ +public final class MDS { + + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected MDS(){ + + } + static double MACHEP = PapayaConstants.MACHEP; + + /** + * Performs classical (metric) multidimensional scaling, on an input matrix of Distances (computed + * using e.g. {@link Distance} ) and outputs the best-fitting p-dimensional configuration of points + * (p<N). The output matrix Y has p columns with rows + * giving the coordinates of the points chosen to represent the dissimilarities. + * When D corresponds to the Euclidian distance matrix, the p + * dimensional coordinates correspond exactly to the first p principal components. + *

    + * Remarks + *

      + *
    • If p > kwhere k is the number of + * positive eigenvalues of Y*Y', then only the + * first k columns of Y are computed. + *
      • + *
    • Set showEigenvalues to true to print the + * values of the "scalar product matrix" Y*Y' to the screen. + * (This is a good idea if you want to know how well the first p dimensions + * captures most of the variation in D.
      • + *
    > + * @param D the input distance matrix (see {@link Distance}) + * @param p the dimension (number of columns) of the output matrix. + * @param showEigenvalues whether to print the eigenvalues to the screen or otherwise. + * @return Y, N-by-p (or N-by-k) matrix consisting of N points in each of the p (or k) dimensions. + */ + public static float[][] classical(float[][] D, int p, boolean showEigenvalues){ + Check.square(D); + int n = D.length; + float[][] P = createP(n); + float[][] B = new float[n][n]; + double sum = 0.0; + // Doubly center D + for(int i=0; ikeep.length) { + System.out.println("\nNumber of dimensions exceeds the number of positive Eigenvalues. "+ + "Returning the first "+ln+" dimensions instead.\n"); + } + float[][] Y = new float[n][ln]; + if(keep.length==0) + System.out.println("\nUnable to find a suitable Y. Maximum eigenvalue is "+Descriptive.max(e)); + else{ + //Y = V(:,i(keep)) * diag(sqrt(e(keep))); + double sqrtEig = 0.0; + for(int c=0; cval) {indices[j]=i; j++;} + } + return Arrays.copyOf(indices,j); + } + +} \ No newline at end of file diff --git a/drawing/papaya/src/papaya/Mat.java b/drawing/papaya/src/papaya/Mat.java new file mode 100644 index 0000000..a48de20 --- /dev/null +++ b/drawing/papaya/src/papaya/Mat.java @@ -0,0 +1,1511 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ + +package papaya; + +import java.util.*; +import java.io.*; +import java.text.NumberFormat; +import java.text.DecimalFormat; +import java.text.DecimalFormatSymbols; + +import processing.core.*; + +/** + * Static class for performing some basic matrix operations. + *

    + * Guidelines + *
    + * Methods that modify an array by a value always take the array as the first parameter, and + * the value as the second. + * For example, + *

      + *
      {@link divide(float[] array, float numberToDivideBy)} + *
      {@link multiply(float[] array, float numberToMultiplyBy)} + *
      {@link sum(float[] array, float numberToAdd)} + *
    + * I try to follow that guiding principle with all methods that take in an input + * array (e.g. {@link swap(float[] array, int index1, int index2)}, + * {@link populate(float[] array, int[] indices)}). + *

    + * Remarks + *
    + * Almost all the methods here take in float arrays or matrices, although I've also added in a few + * methods that operate on integers. In addition, to avoid accidental array manipulation, + * all methods return a new array or matrix instead of modifying the original one. E.g. + *
    C[i][j] = A[i][j]*B[i][j] return C + *
    as opposed to + *
    A[i][j] = A[i][j]*B[i][j], return A + *
    in {@link dotMultiply(float[][],float[][])}. + * (If you find it performing to the contrary though, please let me know!) + * + *

    + * Some non-trivial matrix-math related methods, including those for getting + * the condition number, inverse, rank, and norms of a 2D input matrix are also included. + * Making everything float-based instead of double-based naturally results in some precision loss but + * the internal computations are done using doubles to minimize this. + * + *

    + * + * @see Cast + * @see Find + * @see NaNs + * @see Rank + * @see Sorting + * + */ +public final class Mat { + + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected Mat(){ + + } + /** + * Appends the part of the specified list between from (inclusive) and + * to (inclusive) to the receiver. + * + *@param listToAddTo ArrayList to add the elements to. Clears this list before + * adding the elements in. + * @param data the array to be added to the listToAddTo. + * @param from the index of the first element to be appended (inclusive). + * @param to the index of the last element to be appended (inclusive). + * @exception IndexOutOfBoundsException index is out of range + * ((from<0 || from>to || to>=sortedData.length)). + */ + private static void addAllOfFromTo(ArrayList listToAddTo, float[] sortedData,int from, int to){ + if (from<0 || from>to || to>sortedData.length) { + throw new IndexOutOfBoundsException("from: "+from+", to: "+to+", sortedData.length: "+sortedData.length); + } + // print a warning just in case. + if(listToAddTo.size()>0){ + System.out.println("Warning: Input ArrayList has size "+listToAddTo.size()+ + ". Appending the data to the end of the end"); + } + for(int i = from; i<=to; i++){ + listToAddTo.add(sortedData[i]); + } + } + + /** Return absolute values of an array */ + public static float[] abs(float[] array){ + float[] output = new float[array.length]; + for(int i=0; i=inputMat[0].length || indexStart >indexEnd || indexStart<0) + throw new IllegalArgumentException("Invalid indices"); + float[][] outputMat = new float[inputMat.length][indexEnd-indexStart+1]; + int k; + for (int i = 0; i b ? 1 : 0; + } + /** Returns -1 if a is less than b, or 1 if a is greater than b, or 0. + This is the comparator function for natural order. */ + + public static float compare(float a, float b) { + return a < b ? -1 : a > b ? 1 : 0; + } + + /** + * Concatenates two arrays a and b into a new array + * c such that c = {a,b}. + */ + public static float[] concat(float[] a, float[] b) { + float[] c= new float[a.length+b.length]; + System.arraycopy(a, 0, c, 0, a.length); + System.arraycopy(b, 0, c, a.length, b.length); + return c; + } + public static int[] concat(int[] a, int[] b) { + int[] c= new int[a.length+b.length]; + System.arraycopy(a, 0, c, 0, a.length); + System.arraycopy(b, 0, c, a.length, b.length); + return c; + } + + /** + * Returns an array with of length size with + * each element equal to the specified constValue. + * @see Arrays.fill + */ + public static float[] constant(float constValue, int size){ + float[] constant = new float[size]; + for(int i=0; isize with + * each element equal to the specified constValue. + * @see Arrays.fill + */ + public static int[] constant(int constValue, int size){ + int[] constant = new int[size]; + for(int i=0; ia copy of the input array in ascending order + * @return a sorted copy of the input array. + */ + public static float[] copyThenSort(float[] data){ + float[] sortedData = new float[data.length]; + System.arraycopy(data, 0, sortedData, 0, data.length); + Arrays.sort(sortedData); + return sortedData; + } + + /** vector cross product: c = a (cross) b */ + public static float[] cross(float[] a, float[] b){ + if(a.length!=3 || b.length!=3) throw new IllegalArgumentException("Inputs to Mat.cross have lengths !=3"); + float[] c = new float[3]; + c[0] = a[1]*b[2] - a[2]*b[1]; + c[1] = a[2]*b[0] - a[0]*b[2]; + c[2] = a[0]*b[1] - a[1]*b[0]; + return c; + } + + /** returns the determinant of the square input matrix. + * @throws IllegalArgumentException if the matrix is not square. */ + public static float det (float[][] data) { + return (float)(new LU(data).det()); + } + + /** + * Divides all elements of input array by value. + * That is, z[i] = x[i] / value. + * @throws IllegalArgumentException if value is zero. + */ + public static float[] divide(float[] data, float value){ + if(value==0) throw new IllegalArgumentException("Division by zero"); + float[] divided = new float[data.length]; + for(int i=0; idimension*/ + public static float[][] identity(int dimension){ + float[][] ii = new float[dimension][dimension]; + for(int i=0; ireplaceZeroWith value instead. + */ + public static float[] inverse(float[] data, float replaceZeroWith){ + float[] inverse = new float[data.length]; + for(int i=0; ilog_A(x) = log(x) / log(A) where + * log is the natural logarithm (base e), and A is the new log base. + * This function expects the values greater than 0.0; No internal checks are done. + * @param base the log base. E.g. to get log2, we would use logToBase(data,2). + */ + public static float[] logToBase(float[] data, float base){ + float[] log = new float[data.length]; + double logBase = Math.log(base); + for(int i=0; istart (inclusive) to end (inclusive): + * y[0] = start; y[1] = start+1; ... , y[n] = end;. + *
    + * For example, int[] ii = linspace(2,5); + * produces the array ii = {2,3,4,5}; with length 4. + * 

    +	 * It is similar to this:
+	 * 
+	 * for(int i=0; i<=end-start+1; i++){
+	 * 
       	y[i] = i + start;
+	 * 
    }
+	 *     
+	 *
    + * @param start the start index (inclusive) + * @param end the end index (inclusive); + */ + public static int[] linspace(int start, int end){ + int[] indices = new int[end-start+1]; + for(int i=0; i + * + * @return mapped data array + */ + public static float map(float data, float low1, float high1, float low2, float high2){ + return low2 + (data-low1) * (high2-low2) / (high1-low1); + } + + /** + * Similar to map([] value, valueArrayMinimum, valueArrayMaximum, from, to) + * @return mapped data array + */ + public static float[] map(float[] data, float from, float to){ + return map( data, Descriptive.min(data), Descriptive.max(data), from, to); + } + + /** + * Function for mapping an input array of floats for plotting + * Extends processing "map" function to accomodate + * arrays. E.g. map(value, low1, high1, low2, high2) + * is now + * map([] value, low1, high1, low2, high2) + * @return mapped data array + */ + public static float[] map(float[] data, float low1, float high1, float low2, float high2){ + float[] mappedData = new float[data.length]; + float ratio; + if( high1 == low1 ){ + System.out.println("Input array range is zero. Returning original array"); + return data; + } + else{ + ratio = (high2-low2)/(high1-low1); + for(int i=0; i z[i] = x[i] * y[i]. + */ + public static float[] multiply(float[] data1, float[] data2){ + int size = data1.length; + Check.equalLengths(size,data2); + float[] multiplied = new float[size]; + for(int i=0; i z[i] = k * x[i] . + */ + public static float[] multiply(float[] data, float number){ + float[] multiplied = new float[data.length]; + + for(int i=0; i + * y[0] = fullDataset[ indices[0] ]; + * y[1] = fullDataset[ indices[1] ]; + * ... + * ... + * y[n-1] = fullDataset[ indices[n-1] ]; + * + * @param indices the indices in the fullDataset you want to extract and store. + * @param fullDataset the full dataset. + */ + public static double[] populate( double[] fullDataset, int[] indices) { + double[] outputDat = new double[indices.length]; + for (int i=0; i + * y[0] = fullDataset[ indices[0] ]; + * y[1] = fullDataset[ indices[1] ]; + * ... + * ... + * y[n-1] = fullDataset[ indices[n-1] ]; + * + * @param indices the indices in the fullDataset you want to extract and store. + * @param fullDataset the full dataset. + */ + public static float[] populate( float[] fullDataset, int[] indices) { + float[] outputDat = new float[indices.length]; + for (int i=0; i + * y[0] = fullDataset[ indices[0] ]; + * y[1] = fullDataset[ indices[1] ]; + * ... + * ... + * y[n-1] = fullDataset[ indices[n-1] ]; + * + * @param indices the indices in the fullDataset you want to extract and store. + * @param fullDataset the full dataset. + */ + public static int[] populate( int[] fullDataset, int[] indices) { + int[] outputDat = new int[indices.length]; + for (int i=0; i + * y[0] = fullDataset[ indices[0] ]; + * y[1] = fullDataset[ indices[1] ]; + * ... + * ... + * y[n-1] = fullDataset[ indices[n-1] ]; + * + * @param indices the indices in the fullDataset you want to extract and store. + * @param fullDataset the full dataset. + */ + public static String[] populate(String[] fullDataset, int[] indices){ + String[] outputDat = new String[indices.length]; + for (int i=0; iprint, + * except that the entire array is printed on a single line on the screen and + * you can format the number of decimal digits directly instead of using Processing's + * nf or one of the other variants of it. + * @param data the matrix to be printed. + * @param d Number of digits after the decimal to display.. + */ + public static void print(double[] data, int d) { + if(d<0) throw new IllegalArgumentException("Can't display "+d+" decimal digits without recreating" + + "the number system."); + int numColumns = data.length; + // number format + DecimalFormat format = setupFormat(d); + for (int j=0; jprintln, except that + * each row of the matrix is printed on a single line on the screen and + * you can format the number of decimal digits directly instead of using Processing's + * nf or one of the other variants of it. + * @param data the matrix to be printed. + * @param d Number of digits after the decimal to display.. + */ + public static void print(double[][] data, int d) { + if(d<0) throw new IllegalArgumentException("Can't display "+d+" decimal digits without recreating" + + "the number system."); + int numRows = data.length; + // number format + DecimalFormat format = setupFormat(d); + for (int i=0; iprint, + * except that the entire array is printed on a single line on the screen and + * you can format the number of decimal digits directly instead of using Processing's + * nf or one of the other variants of it. + * @param data the matrix to be printed. + * @param d Number of digits after the decimal to display.. + */ + public static void print(float[] data, int d) { + if(d<0) throw new IllegalArgumentException("Can't display "+d+" decimal digits without recreating" + + "the number system."); + int numColumns = data.length; + // number format + DecimalFormat format = setupFormat(d); + for (int j=0; jprintln, except that + * each row of the matrix is printed on a single line on the screen and + * you can format the number of decimal digits directly instead of using Processing's + * nf or one of the other variants of it. + * @param data the matrix to be printed. + * @param d Number of digits after the decimal to display.. + */ + public static void print(float[][] data, int d) { + if(d<0) throw new IllegalArgumentException("Can't display "+d+" decimal digits without recreating" + + "the number system."); + int numRows = data.length; + // number format + DecimalFormat format = setupFormat(d); + for (int i=0; iprint, + * except that the entire array is printed on a single line on the screen and + * you can format the number of decimal digits directly instead of using Processing's + * nf or one of the other variants of it. + * @param data the matrix to be printed. + * @param d Number of digits after the decimal to display.. + */ + public static void print(int[] data, int d) { + if(d<0) throw new IllegalArgumentException("Can't display "+d+" decimal digits without recreating" + + "the number system."); + int numColumns = data.length; + // number format + DecimalFormat format = setupFormat(d); + for (int j=0; jprintln, except that + * each row of the matrix is printed on a single line on the screen and + * you can format the number of decimal digits directly instead of using Processing's + * nf or one of the other variants of it. + * @param data the matrix to be printed. + * @param d Number of digits after the decimal to display.. + */ + public static void print(int[][] data, int d) { + if(d<0) throw new IllegalArgumentException("Can't display "+d+" decimal digits without recreating" + + "the number system."); + int numRows = data.length; + // number format + DecimalFormat format = setupFormat(d); + for (int i=0; ioldValue with + * the newValue. Useful, for example, in replacing zeros with + * some other number (for {@link dotDivide(float[][], float[][])}), or for wall-street related book-keeping... + */ + public static float[][] replace(float[][] A, float oldValue, float newValue){ + int numRows = A.length; + int numColumns = A[0].length; + float[][] C = new float[numRows][numColumns]; + for(int i=0; ioldValue are replaced with + * the newValue. Useful, for example, in replacing zeros with + * some other number (for {@link divide(float[], float[])}), or for wall-street related book-keeping... + */ + public static float[] replace(float[] data, float oldValue, float newValue){ + int numRows = data.length; + float[]C = new float[numRows]; + for(int i=0; iOnly works if the input number has got more decimal places than the + * number to round to. + *

    + * Examples: + *
    roundToDecimalPlace(1.234567, 2) --> 1.23; + *
    roundToDecimalPlace(100, 2) --> 100; + *

    + * @param number number to round. + * @param decimal decimal place to round to. + * @return number rounded to the specified decimal place + */ + public static float roundToDecimalPlace(float number, int decimal) { + return (float) ( (Math.round((number*Math.pow(10, decimal))))/Math.pow(10, decimal) ); + } + protected static DecimalFormat setupFormat(int d){ + DecimalFormat format = new DecimalFormat(); + format.setDecimalFormatSymbols(new DecimalFormatSymbols(Locale.US)); + format.setMinimumIntegerDigits(1); + format.setMaximumFractionDigits(d); + format.setMinimumFractionDigits(d); + format.setGroupingUsed(false); + return format; + } + + /** + * Function for flooring a number to the closest interval. Useful for + * setting up the tick labels for plotting. + *

    + * Examples: + *
    floorToNearest(173.2,5) --> 170; + *
    floorToNearest(28,10) --> 20; + *

    + * @param currentVal number to floor. + * @param interval to floor to. E.g. in fives, twos, tens, etc. + * @return number. + */ + public static float floorToNearest(float currentVal, int interval){ + return (float)(Math.floor(currentVal/interval)*interval); + } + /** + * Function for ceiling a number to the closest interval. Useful for + * setting up the tick labels for plotting. + *

    + * Examples: + *
    ceilToNearest(173.2,5) --> 175; + *
    ceilToNearest(28,10) --> 30; + *

    + * @param currentVal number to ceil. + * @param interval to ceil to. E.g. in fives, twos, tens, etc. + * @return number. + */ + public static float ceilToNearest(float currentVal, int interval){ + return (float)(Math.ceil(currentVal/interval)*interval); + } + + /** + * Splits (partitions) an array into sublists such that each sublist contains the elements with a given range. + * splitters=(a,b,c,...,y,z) defines the ranges [-inf,a), [a,b), [b,c), ..., [y,z), [z,inf]. + *

    Examples:
    + *

      + * data = (1,2,3,4,5,8,8,8,10,11). + *
      splitters=(2,8) yields 3 bins: (1), (2,3,4,5) (8,8,8,10,11). + *
      splitters=() yields 1 bin: (1,2,3,4,5,8,8,8,10,11). + *
      splitters=(-5) yields 2 bins: (), (1,2,3,4,5,8,8,8,10,11). + *
      splitters=(100) yields 2 bins: (1,2,3,4,5,8,8,8,10,11), (). + *
    + * @param sortedList the list to be partitioned (must be sorted ascending). + * @param splitters the points at which the list shall be partitioned (must be sorted ascending). + * @return the sublists (an array with length == splitters.length + 1. + * Each sublist is returned sorted ascending. + */ + public static ArrayList[] split(float[] sortedList, float[] splitters) { + // assertion: data is sorted ascending. + // assertion: splitValues is sorted ascending. + int numBins = splitters.length + 1; + + ArrayList[] bins = new ArrayList[numBins]; + for (int i=numBins; --i >= 0;) bins[i] = new ArrayList(); + + int listSize = sortedList.length; + int nextStart = 0; + int i=0; + while (nextStart < listSize && i < numBins-1) { + float splitValue = splitters[i]; + int index = Arrays.binarySearch( sortedList,splitValue ); + if (index < 0) { // splitValue not found + int insertionPosition = -index - 1; + addAllOfFromTo(bins[i], sortedList, nextStart,insertionPosition-1); + nextStart = insertionPosition; + } + else { // splitValue found + // For multiple identical elements ("runs"), binarySearch does not define which of all valid indexes is returned. + // Thus, skip over to the first element of a run. + do { + index--; + } while (index >= 0 && sortedList[index] == splitValue); + + addAllOfFromTo(bins[i], sortedList, nextStart, index); + nextStart = index + 1; + } + i++; + } + // now fill the remainder + addAllOfFromTo(bins[numBins-1] , sortedList, nextStart,sortedList.length-1); + return bins; + } + + /** + * Get a (2D) submatrix of a (2D) matrix (a copy, not a pointer). + * @param inputMat input matrix + * @param rowStart row to start at (inclusive) + * @param rowEnd row to end at (inclusive) + * @param columnStart column to start at (inclusive) + * @param columnEnd column to end at (inclusive) + * @return submatrix containing (rowEnd-rowStart+1) rows and (columnEnd-columnStart+1) columns; + * copy of A(rowStart:rowEnd, columnStart:columnEnd). + * @throws IllegalArgumentException if the rowStart, rowEnd, columnStart, or columnEnd parameters + * are not within the inputMatrix size bounds. + */ + public static float[][] subMatrix(float[][] inputMat, int rowStart, int rowEnd, int columnStart, int columnEnd) { + int numRows = rowEnd-rowStart+1; + int numColumns = columnEnd-columnStart+1; + if(numRows>inputMat.length || rowStart<0 || rowEnd>inputMat.length-1) throw new IllegalArgumentException("Row indices are not within the matrix bounds"); + if(numColumns>inputMat[0].length || columnStart<0 || columnEnd>inputMat[0].length-1) throw new IllegalArgumentException("Column indices are not within the matrix bounds"); + float[][] outputMat = new float[numRows][numColumns]; + + for (int i = 0; iA(rowIndices(:), columnStart:columnEnd). + * @throws IllegalArgumentException if the inputs are not within the inputMatrix size bounds. + */ + public static float[][] subMatrix(float[][] inputMat, int[] rowIndices, int columnStart, int columnEnd) { + int numRows = rowIndices.length; + int numColumns = columnEnd-columnStart+1; + if(numRows>inputMat.length) throw new IllegalArgumentException("Row indices are not within the matrix bounds"); + if(numColumns>inputMat[0].length || columnStart<0 || columnEnd>inputMat[0].length-1) throw new IllegalArgumentException("Column indices are not within the matrix bounds"); + float[][] outputMat = new float[numRows][numColumns]; + for (int i = 0; iA(rowIndices(:), columnStart:columnEnd). + * @throws IllegalArgumentException if the inputs are not within the inputMatrix size bounds. + */ + public static float[][] subMatrix(float[][] inputMat, int rowStart, int rowEnd, int[] columnIndices) { + int numRows = rowEnd-rowStart+1; + int numColumns = columnIndices.length; + if(numRows>inputMat.length || rowStart<0 || rowEnd>inputMat.length-1) throw new IllegalArgumentException("Row indices are not within the matrix bounds"); + if(numColumns>inputMat[0].length) throw new IllegalArgumentException("Column indices are not within the matrix bounds"); + float[][] outputMat = new float[numRows][numColumns]; + for (int i = 0; iA(rowIndices(:), columnStart:columnEnd). + * @throws IllegalArgumentException if the inputs are not within the inputMatrix size bounds. + */ + public static float[][] subMatrix(float[][] inputMat, int[] rowIndices, int[] columnIndices) { + int numRows = rowIndices.length; + int numColumns = columnIndices.length; + if(numRows>inputMat.length) + throw new IllegalArgumentException("Row indices are not within the matrix bounds. Num Rows = "+numRows+", inputMat.length = "+inputMat.length); + if(numColumns>inputMat[0].length) + throw new IllegalArgumentException("Column indices are not within the matrix bounds. Num Columns = "+numColumns+", inputMat[0].length = "+inputMat[0].length); + float[][] outputMat = new float[numRows][numColumns]; + for (int i = 0; iinputMat.length) + throw new IllegalArgumentException("Row indices are not within the matrix bounds. Num Rows = "+numRows+", inputMat.length = "+inputMat.length); + if(numColumns>inputMat[0].length) + throw new IllegalArgumentException("Column indices are not within the matrix bounds. Num Columns = "+numColumns+", inputMat[0].length = "+inputMat[0].length); + int[][] outputMat = new int[numRows][numColumns]; + for (int i = 0; iSum( data[i] ). + */ + public static float sum(float[] data) { + float sum = data[0]; + for (int i = 1; i < data.length; i++) sum += data[i]; + return sum; + //return sumOfPowerDeviations(data,1,0.0f); + } + /** + * Returns the sum of two data sequences. + * That is Sum( data[i] ). + */ + public static float[] sum(float[] data1, float[] data2) { + int size = data1.length; + Check.equalLengths(size,data2); + float[] sum = new float[size]; + for (int i = 0; i < data1.length; i++) sum[i] = data1[i] + data2[i]; + return sum; + } + + /** + * Sum of an array with a number. That is + * Sum( data[i] + number). + * + * @return array with each element equal to data[i] + number + */ + public static float[] sum(float[] data, float number) { + float[] sum = new float[data.length]; + for (int i = 0; i < data.length; i++) sum[i] = data[i] + number; + return sum; + } + + /** + * Returns the sum of a data sequence. + * That is Sum( data[i] ). + */ + public static int sum(int[] data) { + int sum = data[0]; + for (int i = 1; i < data.length; i++) sum += data[i]; + return sum; + //return sumOfPowerDeviations(data,1,0.0f); + } + /** + * Returns the sum of two data sequences. + * That is Sum( data[i] ). + */ + public static int[] sum(int[] data1, int[] data2) { + int size = data1.length; + Check.equalLengths(size,data2); + int[] sum = new int[size]; + for (int i = 0; i < data1.length; i++) sum[i] = data1[i] + data2[i]; + return sum; + } + + /** + * Sum of an array with a number. That is + * Sum( data[i] + number). + * + * @return array with each element equal to data[i] + number + */ + public static int[] sum(int[] data,int number) { + int[] sum = new int[data.length]; + for (int i = 0; i < data.length; i++) sum[i] = data[i] + number; + return sum; + } + + /** + * Returns the matrix z = x+y where each element of z[i][j] = x[i][j] + y[i][j] + */ + public static float[][] sum(float[][] x, float[][] y) { + int numRows = x.length, numColumns = x[0].length; + //Check.equalLengths(numRows,y.length); + float[][] z = new float[numRows][]; + for (int i = 0; i < numRows; i++) { + z[i] = sum(x[i],y[i]); + } + return z; + } + /** + * Swap function that swaps the values in an array + * @param data is an array of floats + * @param oldIndex + * @param newIndex + * e.g. data[newIndex,oldIndex] = data[oldIndex,newIndex] + */ + public static void swap(float[] data, int oldIndex, int newIndex){ + float tmp = data[oldIndex]; + data[oldIndex] = data[newIndex]; + data[newIndex] = tmp; + } + /** + * Swap function that swaps the values in an array (overload function) + * @param data is an array of integers + * @param oldIndex + * @param newIndex + * e.g. data[newIndex,oldIndex] = data[oldIndex,newIndex] + */ + public static void swap(int[] data, int oldIndex, int newIndex){ + int tmp = data[oldIndex]; + data[oldIndex] = data[newIndex]; + data[newIndex] = tmp; + } + + /** Returns the symmetric part of the input matrix ((A+A')/2).*/ + public static float[][] symmetric(float[][] data ){ + Check.square(data); + int size = data.length; + float[][] symm = new float[size][size]; + for(int c=0; c min ≤ number ≤ max). + * @param min left-most limit (inclusive) + * @param max right-most limit (inclusive) + * @param number the value to check for. + * @return true if the number is within the bounds, else false + */ + public static boolean within(float number, float min, float max) { + if (number>=min && number<=max) return true; + else return false; + } + + /** + * returns an array containing all numbers within the min and max (inclusive). + * If nothing is within the min and max, an array of length 1 with the first element = -1 is returned + */ + public static float[] within(float[] numbers, float min, float max) { + ArrayList arrayWithin = new ArrayList(); + for(int i=0; i0) return Cast.arrayListToFloat(arrayWithin); + else return new float[]{-1}; + } + +} \ No newline at end of file diff --git a/drawing/papaya/src/papaya/NaNs.java b/drawing/papaya/src/papaya/NaNs.java new file mode 100644 index 0000000..246eca4 --- /dev/null +++ b/drawing/papaya/src/papaya/NaNs.java @@ -0,0 +1,288 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; + +import java.util.ArrayList; + +import processing.core.*; + +/** + *

    Contains various methods for dealing with NaNs in your data.

    + * Currently only accommodates float and double arrays. Java's Integer.isNaN doesn't + * seem to exist or I'd include that as well. + * + * @author Adila Faruk + * + */ +public final class NaNs { + + + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected NaNs(){} + + + /** + * Eliminate the NaNs from the input array. + * + * @param data the array containing NaNs + * @return the new array (with length < data.length) devoid + * of NaNs. + */ + public static double[] eliminate(double[] data){ + double[] data2 = new double[data.length]; + int j=0; + for(int i=0; idata[i] is NaN. + * + * @param data array to search for NaNs + * @return list of indexes i such that data[i] = NaN + */ + public static ArrayList getNaNPositions(double[] data) { + ArrayList out = new ArrayList(); + for (int i = 0; i < data.length; i++) { + if (Double.isNaN(data[i])) { + out.add(Integer.valueOf(i)); + } + } + return out; + } + + + /** + * Eliminate the NaNs from the input array. + * + * @param data the array containing NaNs + * @return the new array (with length < data.length) devoid + * of NaNs. + */ + public static float[] eliminate(float[] data){ + float[] data2 = new float[data.length]; + int j=0; + for(int i=0; idata[i] is NaN. + * + * @param data array to search for NaNs + * @return list of indexes i such that data[i] = NaN + */ + public static ArrayList getNaNPositions(float[] data) { + ArrayList out = new ArrayList(); + for (int i = 0; i < data.length; i++) { + if (Float.isNaN(data[i])) { + out.add(Integer.valueOf(i)); + } + } + return out; + } + +} + +///** +// * Eliminate the NaNs from the input array. +// * +// * @param data the array containing NaNs +// * @return the new array (with length < data.length) devoid +// * of NaNs. +// */ +//public static int[] eliminate(int[] data){ +// int[] data2 = new int[data.length]; +// int j=0; +// for(int i=0; idata[i] is NaN. +// * +// * @param data array to search for NaNs +// * @return list of indexes i such that data[i] = NaN +// */ +//public static ArrayList getNaNPositions(int[] data) { +// ArrayList out = new ArrayList(); +// for (int i = 0; i < data.length; i++) { +// if (Integer.isNaN(data[i])) { +// out.add(Integer.valueOf(i)); +// } +// } +// return out; +//} \ No newline at end of file diff --git a/drawing/papaya/src/papaya/Normality.java b/drawing/papaya/src/papaya/Normality.java new file mode 100644 index 0000000..2506543 --- /dev/null +++ b/drawing/papaya/src/papaya/Normality.java @@ -0,0 +1,282 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; + +import java.util.*; +import java.io.*; +import processing.core.*; +/** + * Contains various utilities for checking if the dataset comes from a normal distribution. + */ + +public class Normality implements PapayaConstants { + + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected Normality(){} + protected static void checkLength20(int size){ + if(size<20) throw new IllegalArgumentException("Dataset contains "+size+" elements which is" + + "less than the minimum of 20."); + } + + /** + * Return the Normal order statistic medians (N) necessary to produce a Q-Q plot + * for a normal distribution (or normal probability plot). + * That is, given a data array, this method computes the Normal order statistic medians + * and the ordered response values or z-scores of the input. + * A plot of the N vs z should form an approximate straight line if the + * data is normally distributed; + * departures from this straight line indicate departures from normality with the shape of the line + * providing clues as to the distribution of the data. + *

    + * The normal order statistic medians are computed as + *
    N[i] = Probability.norminv(U[i]) + * where U[i] are the uniform order statistic medians, given by + *

      + *
      U[i] = 1 - U(n) for i = 1 + *
      U[i] = (i - 0.3175)/(n + 0.365) for i = 2, 3, ..., n-1 + *
      U[i] = 0.5^(1/n) for i = n + *
    + *

    Reference: + * NIST/SEMATECH e-Handbook of Statistical Methods, EDA Section 1.3.3.21: Normal Probability Plots + * @param data the data array + * @return the Normal order statistic medians + * @see Descriptive#zScore(float[],float,float) + */ + public static float[] normalProbability(float[] data){ + int size = data.length; + float[] N = new float[size]; + double factor = (double)1/size; + double U = Math.pow(.5,factor); // U_n + N[0] = (float)Probability.norminv(1-U); + N[size-1] = (float)Probability.norminv(U); + //U(i) = (i - 0.3175)/(n + 0.365) for i = 2, 3, ..., n-1 + for(int i=1; iImplementation: + * + *
    Let mk denote the kth moment, + * mk = ∑_(i=1 to n)(x_i - mean(x))/n. Then, we can define the following: + *
    Sample estimate of the third standardized moment: b1 = m3/(m2)^(3/2)
    + *
    Sample estimate of the fourth standardized moment: b2 = m4/m2
    + *
    The test statistics Z(b1), Z(b2) are approximately normally distributed under + * the null hypothesis of population normality. Both Z(b1) and Z(b2) can be used to + * test one-sided and two-sided alternative hypothesis. + * + *

    + * D'Agostino and Pearson (1973) also introduced the following "omnibus" test statistic, + *
    K^2 = (Z(b1))^2 + (Z(b2))^2,
    + * which is able to detect deviations from normality due to either skewness or kurtosis + * This K^2 statistic has an approximately Chi-Squared distribution with 2 degrees of + * freedom when the population is normally distributed. + * Similar to Z(b1) and Z(b2), K^2 can be used to test one-sided and two-sided alternative hypothesis. + * + *

    Requirements + *
    data set has to have more than 20 elements. An error is thrown otherwise since the normal + * approximation is no longer valid (technically, the it is valid for Zb1, as long as n > 8, but + * since we're computing everything, the requirement has been set a little higher. + * + *

    Remarks: + *

      + *
    • + * The normal approximation for the zb1 is only valid for sample sizes > 8. For smaller sample sizes, + * it is suggested that you consult a look-up table. Likewise, the normal approximation for the + *
    • + * b1 and b2 differ from the Fisher g statistic parameters g1 + * and g2 used in SAS, and SPSS but they are related by a linear transformation (see + * cited paper for details). + *
    • + * For users familiar with the R software package, this class is analogous to the + * R's dagoTest class in the fBasics library albeit with some implementation. + *
    + *

    + * References: + *
    D'Agostino, R., Albert Belanger, A., D'Agostino Jr, R., 1990 + * A Suggestion for Using Powerful and Informative Tests of Normality + * + *
    D?Agostino, R., Pearson, E., 1973. Tests for departures from normality. + * Empirical results for the distribution of b1 and b2.Biometrika 60, 613?622. + */ + public static class Dago { + + protected Dago(){}; + + /** + * Computes and returns an array containing the test statistic zb1associated with sqrt(b1) and + * the significance, or "p-value" of the skew test statistic zb1, assuming a + * two-tailed null hypothesis as well as . The first element of the output array is the + * test statistic zb1 associated with sqrt(b1) = m3/m2^(3/2) where mk is + * the kth momement as specified in {@link Descriptive#moment} and the second element is + * the p-value for the two-tailed null hypothesis with + * 

    +		 * pValueSkew = 2* ( 1-Probability.normcdf( zb1 ) ).
+		 *
    + * (D'Agostino et al. (1990)) . + */ + public static float[] skew(float[] data){ + float n = data.length; + checkLength20((int)n); + + float mean = Descriptive.mean(data); + float m2 = Descriptive.moment(data,2,mean); + double sd = Math.sqrt(m2); + double m3 = Descriptive.moment(data,3,mean); + double b1 = m3/(sd*sd*sd); + double y = b1* Math.sqrt( (n+1)*(n+3)/( 6*(n-2) ) ); // standardized b1 + // standardized moment + double beta2 = 3*(n*n+27*n-70)*(n+1)*(n+3)/ ( (n-2)*(n+5)*(n+7)*(n+9) ); + double Wsquared = -1 + Math.sqrt(2*(beta2-1)); + double W = Math.sqrt(Wsquared); + double delta = 1/Math.sqrt(Math.log(W)); + double alpha = Math.sqrt(2/(Wsquared-1)); + double yalpha = y/alpha; + double Zb1 = (delta*Math.log(yalpha + Math.sqrt(yalpha*yalpha+1))); + + return new float[]{(float)Zb1,(float)twoTailedNormal(Zb1)}; + } + + /** + * Computes and returns an array containing the test statistic zb2associated with + * b2 and the significance, or "p-value" of the kurtosis test statistic zb2, assuming a + * two-tailed null hypothesis as well as . The first element of the output array is the + * test statistic zb2 associated with b2 = m4/m2^2 where mk is + * the kth momement as specified in {@link Descriptive#moment}. and the second element is + * the p-value for the two-tailed null hypothesis with + * 
    +		 * pValueKurtosis = 2* ( 1-Probability.normcdf( zb2 ) ).
+		 *
    + * (D'Agostino et al. (1990)) . + */ + public static float[] kurtosis(float[] data){ + float n = data.length; + checkLength20((int)n); + float mean = Descriptive.mean(data); + float m2 = Descriptive.moment(data,2,mean); + double m4 = Descriptive.moment(data,4,mean); + + double b2 = m4/(m2*m2); + double b2Mean = 3*(n-1)/(n+1); + double b2Var = 24*n*(n-2)*(n-3)/( (n+1)*(n+1)*(n+3)*(n+5) ); + double x = (b2-b2Mean)/Math.sqrt(b2Var); + double beta1 = 6*(n*n-5*n+2)/((n+7)*(n+9)) * Math.sqrt( (6*(n+3)*(n+5)) / (n*(n-2)*(n-3)) ); // third standardized moment of b2 + double A = 6+8/beta1* ( 2/beta1 + Math.sqrt(1+ 4/(beta1*beta1)) ); + double nineA = 9*A; + double temp = (1-2/A)/( 1+x*Math.sqrt(2/(A-4)) ); + double Zb2 = ( (1-2/(nineA) - Math.pow (temp,1.0/3.0) )/ Math.sqrt(2/(nineA))); + return new float[]{(float)Zb2,(float)twoTailedNormal(Zb2)}; + } + + /** + * Computes and returns an array containing the test statistic chi2, or the + * "omnibus" test statistic, and the significance, or "p-value" of this test statistic. + * The first element of the output array is the test statistic the ombibus test + * statistic chi2 and the second element is + * the p-value: + * 
    +		 * pValueChiSquared = ( 1-Probability.chi2cdf( chi2 ) ).
+		 *
    + * (D'Agostino et al. (1990)) . + */ + public static float[] chi2(float[] data){ + float n = data.length; + checkLength20((int)n); + float Zb1 = skew(data)[0]; float Zb2 = kurtosis(data)[0]; + double Ksquared = Zb1*Zb1 + Zb2*Zb2; + float p = (float)( 1-Probability.chi2cdf(Ksquared,2.0) ); + return new float[]{(float)Ksquared,p}; + } + /** + * Returns an array containing the three significance, or p-values, for testing normality. + * The first element corresponds to the p-value associated with D'Agostino's Chi-Squared + * test statistic (or omnibus test, {@link Dago#chi2}), the second corresponds to D'Agostino's + * skew test ({@link Dago#skew}), and the + * third corresponds to D'Agostino's kurtosis test ({@link Dago#kurtosis}). + */ + public static float[] pValues(float[] data){ + float n = data.length; + if(n<20) throw new IllegalArgumentException("Dataset contains "+n+" elements which is" + + "less than the minimum of 20."); + float mean = Descriptive.mean(data); + float m2 = Descriptive.moment(data,2,mean); + double sd = Math.sqrt(m2); + double m3 = Descriptive.moment(data,3,mean); + double m4 = Descriptive.moment(data,4,mean); + double b1 = m3/(sd*sd*sd); + double y = b1* Math.sqrt( (n+1)*(n+3)/( 6*(n-2) ) ); // standardized b1 + // standardized moment + double beta2 = 3*(n*n+27*n-70)*(n+1)*(n+3)/ ( (n-2)*(n+5)*(n+7)*(n+9) ); + double Wsquared = -1 + Math.sqrt(2*(beta2-1)); + double W = Math.sqrt(Wsquared); + double delta = 1/Math.sqrt(Math.log(W)); + double alpha = Math.sqrt(2/(Wsquared-1)); + double yalpha = y/alpha; + double Zb1 = (delta*Math.log(yalpha + Math.sqrt(yalpha*yalpha+1))); + // kurtosis + double b2 = m4/(m2*m2); + double b2Mean = 3*(n-1)/(n+1); + double b2Var = 24*n*(n-2)*(n-3)/( (n+1)*(n+1)*(n+3)*(n+5) ); + double x = (b2-b2Mean)/Math.sqrt(b2Var); + double beta1 = 6*(n*n-5*n+2)/((n+7)*(n+9)) * Math.sqrt( (6*(n+3)*(n+5)) / (n*(n-2)*(n-3)) ); // third standardized moment of b2 + double A = 6+8/beta1* ( 2/beta1 + Math.sqrt(1+ 4/(beta1*beta1)) ); + double nineA = 9*A; + double temp = (1-2/A)/( 1+x*Math.sqrt(2/(A-4)) ); + double Zb2 = ( (1-2/(nineA) - Math.pow (temp,1.0/3.0) )/ Math.sqrt(2/(nineA))); + // omnibus K-squared + double Ksquared = Zb1*Zb1 + Zb2*Zb2; + + float pSkew = (float)twoTailedNormal(Zb1); + float pKurtosis = (float)twoTailedNormal(Zb2); + float pKSquared = (float)( 1-Probability.chi2cdf(Ksquared,2.0) ); + return new float[]{pKSquared,pSkew,pKurtosis}; + } + } + + +private static double twoTailedNormal(double z){ + if(z>0) return ( 2*(1.0- (Probability.normcdf(z)) ) ); + else return (2 * (Probability.normcdf(z))); +} + + +} diff --git a/drawing/papaya/src/papaya/OneWayAnova.java b/drawing/papaya/src/papaya/OneWayAnova.java new file mode 100644 index 0000000..f654ece --- /dev/null +++ b/drawing/papaya/src/papaya/OneWayAnova.java @@ -0,0 +1,196 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; + +import java.util.*; +import java.io.*; +import processing.core.*; +/** + + * Computes the one-way ANOVA p-value to test the equality of two or more sample + * means by analyzing the sample variances using the test statistic + * F = variance between samples / variance within samples. + * Once initialized, the following values are computed and stored: + *
      + *
    • dfbg: degrees of freedom between the groups ({@link dfbg()}). + *
    • ssbg: sum of squared deviates between the groups ({@link ssbg()}). + *
    • dfwg: degrees of freedom within the groups, or "Error" dfs ({@link dfwg()}). + *
    • sswg: sum of squared deviates within the groups ({@link sswg()}). + *
    • F: the test statistic, computed as (ssbg/dfbg) / (sswg/dfwg) ({@link F()}). + *
    • pValue: the p-value, or significance level, corresponding to a two-tailed + * null hypothesis of no difference between the samples ({@link pValue()}). + *
    + * + *

    Preconditions:

      + *
    • The categoryData Collection must contain + * float[] arrays.
      • + *
    • There must be at least two float[] arrays in the + * categoryData collection and each of these arrays must + * contain at least two values.

    + * + *

    This implementation is based on a description provided in Chapter 13 of the VassarStats + * online textbook + * Mean values are not computed directly in the algorithm as this tends to cause round-off error. + * Rather, we use the more stable SumOfSquares - Sum^2: + * 

    + * Sum_(i=1 to n) (x_i - mean(x) )^2 = Sum_(i=1 to n)(x_i)^2 - (Sum_(i=1 to n) x_i)^2/n.
+ *
    + *

    + * + */ + + +public class OneWayAnova{ + int dfbg = 0; + int dfwg = 0; + double sswg = 0; + double ssbg = 0; + double sst = 0; // total sum of squares + double F = 0; + double p = -1; + /** + * Performs an Analysis of Variance (ANOVA) for a collection of float arrays. + * @param categoryData the data coresponding to the different groups + * @see Collection + */ + public OneWayAnova(Collection categoryData){ + if(categoryData.size()<2)throw new IllegalArgumentException("Input needs to contain at least two float arrays"); + + double totsum = 0; + double totsumsq = 0; + int totnum = 0; + + for (float[] data : categoryData) { + if(data.length<2) throw new IllegalArgumentException("Each float array has to contain at least two elements"); + double sum = 0; + double sumsq = 0; + int num = 0; + + for (int i = 0; i < data.length; i++) { + double val = data[i]; + + double valSquared = val*val; + // within category + num++; + sum += val; + sumsq +=valSquared; + + // for all categories + totnum++; + totsum += val; + totsumsq += valSquared; + } + dfwg += num - 1; // df2 = sum(n_i-1) + double ss = sumsq - sum * sum / num; + sswg += ss; // add the sum of squares to the final tally + } + sst = totsumsq - totsum * totsum/totnum; // total sum of squares + ssbg = sst - sswg; // error sum of squares + dfbg = categoryData.size() - 1; // df1 = k-1 + double msbg = ssbg/dfbg; + double mswg = sswg/dfwg; + F = msbg/mswg; + + p = 1.0 - Probability.fcdf(F,dfbg,dfwg); + } + + /** + * Computes eta^2: a measure of the strength of the curvilinear relationship + * between the independent and dependent variable. Useful in the context of + * one-way ANOVAs of independent samples. For example, the independent + * variable could be the amount of papaya consumed by 4 different groups + * (0, 1, 2, or 3 papayas/dar) and the dependent variable could be a measurement of their + * satisfaction with life. + */ + public float etasqrd(){ + return (float)(ssbg/sst); + } + /** + * Returns the degrees of freedom between groups. That is, + * if there are k groups, dfbg = k-1; + */ + public int dfbg(){ + return dfbg; + + } + + /** + * Returns the degrees of freedom within each group. That is, + * if there are k groups, and each have got n_i elements, + * dfwg = (n_1-1) + (n_2 -1) + ... + (n_k - 1); + */ + public int dfwg(){ + return dfwg; + + } + + /** + * Returns the test statistic F. That is, + * 
     
+     * F = (ssbg/dfbg) / (sswg/dfwg);
+     *
    + */ + public float F(){ + return (float)(F); + + } + + /** + * Returns the significance, or "p-value" of the test statistic {@link F()}. + * That is, + * 
     
+     * p = 1 - Probability.fcdf(F,dfbg,dfwg);
+     *
    + */ + public float pValue(){ + return (float)(p); + + } + + /** + * Returns the sum of squared deviates of the data within each group. That is, + * if there are k groups, and each have got n_i elements, + * 
    +	 * sswg = Sum_(i=1 to n1) (xi1-mean(x1))^2 + Sum_(i=1 to n2) (xi2-mean(xk))^2 + ... + Sum_(i=1 to nk) (xik-mean(xk))^2;
+	 *
    + */ + public float sswg(){ + return (float)sswg; + + } + + /** + * Returns the sum of squared deviates between each group. That is, + * if there are k groups, each with mean value y_i, then + * 
    +	 * ssbg = Sum_(i=1 to k) (y_i)-mean(y))
+	 *
    + */ + public float ssbg(){ + return (float)ssbg; + + } + + +} diff --git a/drawing/papaya/src/papaya/PapayaConstants.java b/drawing/papaya/src/papaya/PapayaConstants.java new file mode 100644 index 0000000..0ce44ad --- /dev/null +++ b/drawing/papaya/src/papaya/PapayaConstants.java @@ -0,0 +1,94 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; + +import java.awt.event.KeyEvent; + +import processing.core.*; +import processing.core.PApplet; +import processing.core.PFont; +import processing.core.PConstants; + +/** + * PapayaConstants stores some of the constants used in plotting. + * I try to follow processing's conventions where possible + * as specified in processing.core.PConstants + * The Processing Javadoc has more details. + * + */ +public interface PapayaConstants{ + + public final static int BASELINE = 0; + + public final static int CORNER = 0; + + public final static int BOTTOM = 102; + + public final static int CENTER = 3; + + public final static int LEFT = 37; + + public final static int TOP = 101; + + public final static int RIGHT = 39; + + /** + * Default font used. + */ + public final static String FONTNAME = "Helvetica"; + + public final static float[] STROKEWEIGHT ={0.25f, .5f, .75f, 1}; + + public final static int[] GRAY ={100, 150, 200, 240, 250}; + + public final static int[] TEXTSIZE = {6,8,10,12}; + + + /** + * Index to return if a given value/object is not found in the {@link Cast} function. + */ + public static final int INDEX_NOT_FOUND = -1; + + /** + * Index array to return if a given value/object is not found in the {@link Cast} function. + */ + public static final int[] INDICES_NOT_FOUND = new int[]{-1}; + + /** + * machine constants + */ + public static final double MACHEP = 1.11022302462515654042E-16; + public static final double MAXLOG = 7.09782712893383996732E2; + public static final double MINLOG = -7.451332191019412076235E2; + public static final double MAXGAM = 171.624376956302725; + public static final double SQTPI = 2.50662827463100050242E0; + public static final double SQRTH = 7.07106781186547524401E-1; + public static final double LOGPI = 1.14472988584940017414; + + public static final double big = 4.503599627370496e15; + public static final double biginv = 2.22044604925031308085e-16; + +} + diff --git a/drawing/papaya/src/papaya/Polynomial.java b/drawing/papaya/src/papaya/Polynomial.java new file mode 100644 index 0000000..78f3bd6 --- /dev/null +++ b/drawing/papaya/src/papaya/Polynomial.java @@ -0,0 +1,129 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; + +import java.util.*; +import java.io.*; +import processing.core.*; +import processing.core.PApplet; +import processing.core.PImage; + +/** + * Static Class for casting one variable type to another. + * + * @author Nur Adila Faruk Senan + */ +public final class Polynomial { + + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected Polynomial() {} + + /** + * y = polyval(x,coeff) returns the value of a polynomial of degree n evaluated at x. + * The input argument coeff is an array of length n+1 whose elements are the coefficients + * in descending powers of the polynomial to be evaluated. + *

    + * y = coeff[0]*x^n + coeff[1]*x^(n-1) + .... + coeff[n-1]*x + coeff[n]. + *

    + *

    + * E.g. for a quadratic function, y = coeff[0]*x^2 + coeff[1]*x + coeff[2]. + *

    + * @param x argument to the polynomial. + * @param coeff the coefficients of the polynomial. + */ + public static double polyval(double x, double coeff[] ) throws ArithmeticException { + int n = coeff.length; + double ans = coeff[0]; + for(int i=1; i + * y = coeff[0]*x^n + coeff[1]*x^(n-1) + .... + coeff[n-1]*x + coeff[n]. + *

    + *

    + * E.g. for a quadratic function, y = coeff[0]*x^2 + coeff[1]*x + coeff[2]. + *

    + * @param x array argument to the polynomial. + * @param coeff the coefficients of the polynomial. + */ + public static double[] polyval(double[] x, double coeff[] ) throws ArithmeticException { + int size = x.length; + double[] y = new double[size]; + for(int i=0; i + * y = coeff[0]*x^n + coeff[1]*x^(n-1) + .... + coeff[n-1]*x + coeff[n]. + *

    + *

    + * E.g. for a quadratic function, y = coeff[0]*x^2 + coeff[1]*x + coeff[2]. + *

    + * @param x argument to the polynomial. + * @param coeff the coefficients of the polynomial. + */ + public static float polyval(float x , float coeff[]) throws ArithmeticException { + int n = coeff.length; + float ans = coeff[0]; + for(int i=1; i + * y = coeff[0]*x^n + coeff[1]*x^(n-1) + .... + coeff[n-1]*x + coeff[n]. + *

    + *

    + * E.g. for a quadratic function, y = coeff[0]*x^2 + coeff[1]*x + coeff[2]. + *

    + * @param x array argument to the polynomial. + * @param coeff the coefficients of the polynomial. + */ + public static float[] polyval(float[] x, float coeff[] ) throws ArithmeticException { + int size = x.length; + float[] y = new float[size]; + for(int i=0; i + * Description: + *
    ...cdf signifies the cumulative distribution function and is similar to + * the q... functions in R and the ...cdf functions in + * MATLAB. The cdf represent the integral, from -infinity to 0 of the + * corresponding continuous probability density function (pdf), or, the sum from 0 to x + * of an associated finite pdf.
    + * + *
    ...inv signifies the inverse of the cumulative distribution function and is similar to + * the p... functions in R and the ...inv functions in + * MATLAB.
    + * + *

    Implementation: + *

      + *
    • Direct application examples: + *
      normcdf(1.96) = 0.975 --> 97.5% of the curve is within +/-1.96 of 0. + *
      norminv(0.975) = 1.96 --> finds the point x (=1.96) such that normcdf(x) = .975. + *
      norminv( normcdf(x) ) = x + *
    • Significance tests: + *
      Two-tailed significance test with alpha = 0.05 and H_0: μ=0 + * --> p = 1-alpha/2 = 0.975 + * --> Reject null hypothesis μ=0 if + * the test statistic is greater or less than than +/-1.96 (= +/- norminv(p) ). + * + *
      One-tailed significance test with alpha = 0.05 and H_0: μ < 0 + * --> p = 1-alpha = 0.95 + * --> Reject null hypothesis μ < 0 if + * the test statistic is greater than 1.645 (= norminv(p) ). + *
      One-tailed significance test with alpha = 0.05 and H_0: μ > 0 + * --> p = 1-alpha = 0.95 + * --> Reject null hypothesis μ > 0 if + * the test statistic is less than -1.645 (= -norminv(p) ). + *
    + *

    + * + * + * The code is partially adapted from the CERN Jet Java libraries, which in turn was adapted from the + * Cephes Mathematical Library. As far a as I can tell, Stephen L. Moshier wrote the original C++ code for + * CEPHES (1989, moshier@na-net.ornl.gov), Gedeck (at Novartis) and Wolfgang Hoschek (at CERN, hats off to you mate!) + * then adapted it for the Java platform, making some significant changes along the way. + *
    + * 2012 rolls along, and Adila (hello!) finds the library and makes even more changes, increasing the + * probability (ha.ha.) of things going massively wrong (pValue<.0001). + * + */ + +//public class Probability extends cern.jet.math.Constants { +public class Probability implements PapayaConstants { + /************************************************* + * COEFFICIENTS FOR METHOD normalInverse() * + *************************************************/ + /* approximation for 0 <= |y - 0.5| <= 3/8 */ + protected static final double P0[] = { + -5.99633501014107895267E1, + 9.80010754185999661536E1, + -5.66762857469070293439E1, + 1.39312609387279679503E1, + -1.23916583867381258016E0, + }; + protected static final double Q0[] = { + 1.00000000000000000000E0, + 1.95448858338141759834E0, + 4.67627912898881538453E0, + 8.63602421390890590575E1, + -2.25462687854119370527E2, + 2.00260212380060660359E2, + -8.20372256168333339912E1, + 1.59056225126211695515E1, + -1.18331621121330003142E0, + }; + + + /* Approximation for interval z = sqrt(-2 log y ) for z between 2 and 8 + * i.e., y between exp(-2) = .135 and exp(-32) = 1.27e-14. + */ + protected static final double P1[] = { + 4.05544892305962419923E0, + 3.15251094599893866154E1, + 5.71628192246421288162E1, + 4.40805073893200834700E1, + 1.46849561928858024014E1, + 2.18663306850790267539E0, + -1.40256079171354495875E-1, + -3.50424626827848203418E-2, + -8.57456785154685413611E-4, + }; + protected static final double Q1[] = { + 1.00000000000000000000E0, + 1.57799883256466749731E1, + 4.53907635128879210584E1, + 4.13172038254672030440E1, + 1.50425385692907503408E1, + 2.50464946208309415979E0, + -1.42182922854787788574E-1, + -3.80806407691578277194E-2, + -9.33259480895457427372E-4, + }; + + /* Approximation for interval z = sqrt(-2 log y ) between 8 and 64 + * i.e., y between exp(-32) = 1.27e-14 and exp(-2048) = 3.67e-890. + */ + protected static final double P2[] = { + 3.23774891776946035970E0, + 6.91522889068984211695E0, + 3.93881025292474443415E0, + 1.33303460815807542389E0, + 2.01485389549179081538E-1, + 1.23716634817820021358E-2, + 3.01581553508235416007E-4, + 2.65806974686737550832E-6, + 6.23974539184983293730E-9, + }; + protected static final double Q2[] = { + 1.00000000000000000000E0, + 6.02427039364742014255E0, + 3.67983563856160859403E0, + 1.37702099489081330271E0, + 2.16236993594496635890E-1, + 1.34204006088543189037E-2, + 3.28014464682127739104E-4, + 2.89247864745380683936E-6, + 6.79019408009981274425E-9, + }; + + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected Probability() {} + /** + * Returns the area from zero to x under the beta density + * function. + * 
    +	 * 
+	 * P(x) = Γ(a+b) / [ Γ(a) * Γ(b)  ] * Integral_(0 to x) [  t^(a-1) * (1-t)^(b-1) ] dt
+	 *
+	 *
    + * This function is identical to the incomplete beta + * integral function + * + * Gamma.incompleteBeta(a, b, x). + * + * The complemented function is {@link betacdfComplemented}, specified by + * + * 1 - P(1-x) = Gamma.incompleteBeta( b, a, x ); + * + */ + static public double betacdf(double x, double a, double b) { + return Gamma.incompleteBeta( a, b, x ); + } + /** + * Returns the area under the right hand tail (from x to + * infinity) of the beta density function. + * + * This function is identical to the incomplete beta + * integral function Gamma.incompleteBeta(b, a, x). + */ + static public double betacdfComplemented(double x, double a, double b ) { + return Gamma.incompleteBeta( b, a, x ); + } + + /** + * Returns the inverse of the beta cumulative distribution function. + * That is, given p, the function finds x such that + * 
    +	 *  Gamma.incompleteBeta( a, b, x ) = beta(x, a, b) = p;
+	 *
    + * + * This function is identical to the incomplete beta inverse + * function Gamma.incompleteBetaInverse(aa, bb, yy0). + * + * @param a the alpha parameter of the beta distribution. + * @param b the beta parameter of the beta distribution. + * @param p the value for which to solve for the corresponding x in the + * incomplete Beta integral. + * @return the value x such that beta( a, b, x ) = p. + */ + static public double betainv( double p, double a, double b) { + return Gamma.incompleteBetaInverse( a, b, p); + } + /** + * Returns the sum of the terms 0 through k of the Binomial + * probability density. + * 
    +	 * 
+	 * Sum_(j=0 to k)  [ (n!)/(j!*(n-j)! ]  *  [ p^j * (1-p)^(n-j) ]
+	 *
+	 *
    + * The terms are not summed directly; instead the incomplete + * beta integral is employed, according to the formula + *

    + * y = binomcdf( p, k, n) = Gamma.incompleteBeta( n-k, k+1, 1-p ). + *

    + * All arguments must be positive, + * @param k end term. + * @param n the number of trials. + * @param p the probability of success (must be in (0.0,1.0)). + */ + static public double binomcdf(double p, int k, int n) { + if( (p < 0.0) || (p > 1.0) ) throw new IllegalArgumentException(); + if( (k < 0) || (n < k) ) throw new IllegalArgumentException(); + + if( k == n ) return( 1.0 ); + if( k == 0 ) return Math.pow( 1.0-p, n-k ); + + return Gamma.incompleteBeta( n-k, k+1, 1.0 - p ); + } + /** + * Returns the sum of the terms k+1 through n of the Binomial + * probability density. + * 

    +	 * 
+	 * Sum_(j=k+1 to n)  [ (n!)/(j!*(n-j)! ]  *  [ p^j * (1-p)^(n-j) ]
+	 *
+	 *
    + * The terms are not summed directly; instead the incomplete + * beta integral is employed, according to the formula + *

    + * y = binomcdfComplemented( p, k, n ) = Gamma.incompleteBeta( k+1, n-k, p ). + *

    + * All arguments must be positive, + * @param k (start-1) term. + * @param n the number of trials. + * @param p the probability of success (must be in (0.0,1.0)). + */ + static public double binomcdfComplemented( double p , int k, int n) { + if( (p < 0.0) || (p > 1.0) ) throw new IllegalArgumentException(); + if( (k < 0) || (n < k) ) throw new IllegalArgumentException(); + + if( k == n ) return( 0.0 ); + if( k == 0 ) return 1.0 - Math.pow( 1.0-p, n-k ); + + return Gamma.incompleteBeta( k+1, n-k, p ); + } + + /** + * Finds the event probability p such that the sum of the + * terms 0 through k of the Binomial probability density + * is equal to the given cumulative probability y. That is, + *

    +	 * binomcdf( p, k, n ) = y;
+	 *
    + * This is accomplished using the inverse beta integral + * function and the relation + *

    + * 1 - p = Gamma.incompleteBetaInverse( n-k, k+1, y ). + *

    + * All arguments must be positive. + * @param k end term. + * @param n the number of trials. + * @param y the value to solve for such that binomcdf( p, k, n ) = y. + */ + static public double binominv( double y, int k, int n){ + double dk, dn, p; + + if( (y < 0.0) || (y > 1.0) ) throw new IllegalArgumentException("Test statistic not within possible range."); + if( (k < 0) || (n < k) ) throw new IllegalArgumentException(); + + dn = n - k; + if( k == 0 ) + { + if( y > 0.8 ) + p = -Math.expm1( Math.log1p(y-1.0) / dn ); + else + p = 1.0 - Math.pow( y, 1.0/dn ); + } + else + { + dk = k + 1; + p = Gamma.incompleteBeta( dn, dk, 0.5 ); + if( p > 0.5 ) + p = Gamma.incompleteBetaInverse( dk, dn, 1.0-y ); + else + p = 1.0 - Gamma.incompleteBetaInverse( dn, dk, y ); + } + return( p ); + } + + /** + * Returns the area under the left hand tail (from 0 to x) + * of the Chi square probability density function with + * v degrees of freedom. + * 
    +	 * 
+	 * P( x | v ) = 1/ [ 2^(v/2) * Γ(v/2)  ] * Integral_(from 0 to x) [ t^(v/2-1) * e^(-t/2) ] dt
+	 *                                  
+	 *
    + * where x is the Chi-square variable. + *

    + * The incomplete gamma integral is used, according to the + * formula + *

    + * y = chi2cdf( x, v ) = Gamma.incompleteGamma( v/2.0, x/2.0 ). + *

    + * The arguments must both be positive. + * + * @param v degrees of freedom. + * @param x integration end point. + */ + static public double chi2cdf(double x, double v) throws ArithmeticException { + if( x < 0.0 || v < 1.0 ) return 0.0; + + //if(v==2) return 1-Math.exp(x/2.0); // special case. + + return Gamma.incompleteGamma( v/2.0, x/2.0 ); + } + /** + * Returns the area under the right hand tail (from x to + * infinity) of the Chi square probability density function + * with v degrees of freedom. + * 

    +	 * 
+	 * P( x | v ) = 1/ [ 2^(v/2) * Γ(v/2)  ] * Integral_(from x to infinity) [ t^(v/2-1) * e^(-t/2) ] dt
+	 *
+	 *
    + * where x is the Chi-square variable. + * + * The incomplete gamma integral is used, according to the + * formula + * + * y = chi2cdfComplemented( x, v ) = incompleteGammaComplement( v/2.0, x/2.0 ). + * + * The arguments must both be positive. + * + * @param v degrees of freedom. + * @param x integration start point. + */ + static public double chi2cdfComplemented(double x, double v) throws ArithmeticException { + if( x < 0.0 || v < 1.0 ) return 0.0; + return Gamma.incompleteGammaComplement( v/2.0, x/2.0 ); + } + /** + * Returns the error function of the normal distribution. + * The integral is + * 
    +	 * 
+	 * erf(x) = 2/sqrt(PI) * Integral_(0 to x) [ e^(-t^2) ] dt
+	 *                           
+	 *
    + * Implementation: + * For 0 <= |x| < 1, erf(x) = x * P4(x^2)/Q5(x^2) ; otherwise + * erf(x) = 1 - erfc(x). + *

    + * + * @param x the integral end point. + */ + static public double erf(double x) throws ArithmeticException { + double y, z; + final double T[] = { + 9.60497373987051638749E0, + 9.00260197203842689217E1, + 2.23200534594684319226E3, + 7.00332514112805075473E3, + 5.55923013010394962768E4 + }; + final double U[] = { + 1.00000000000000000000E0, + 3.35617141647503099647E1, + 5.21357949780152679795E2, + 4.59432382970980127987E3, + 2.26290000613890934246E4, + 4.92673942608635921086E4 + }; + + if( Math.abs(x) > 1.0 ) return( 1.0 - erfComplemented(x) ); + z = x * x; + y = x * Polynomial.polyval( z, T) / Polynomial.polyval( z, U); + return y; + } + /** + * Returns the complementary Error function of the normal distribution; formerly named erfc. + * 

    +	 * 
+	 *  erfc(x) = 2/sqrt(PI) * Integral_(x to inf) [ e^(-t^2) ] dt
+	 *  		= 1 - 2/sqrt(PI) * Integral_(0 to x) [ e^(-t^2) ] dt
+	 *  		= 1 - erf(x).
+	 *			  
+	 *
    + * Implementation: + * For small x, erfc(x) = 1 - erf(x); otherwise rational + * approximations are computed. + *

    + * @param a corresponds to x above. An internal check is performed to see if + * a is < 0 or otherwise. If a < 0 --> x = -a. Else, x = a. + */ + static public double erfComplemented(double a) throws ArithmeticException { + double x,y,z,p,q; + + double P[] = { + 2.46196981473530512524E-10, + 5.64189564831068821977E-1, + 7.46321056442269912687E0, + 4.86371970985681366614E1, + 1.96520832956077098242E2, + 5.26445194995477358631E2, + 9.34528527171957607540E2, + 1.02755188689515710272E3, + 5.57535335369399327526E2 + }; + double Q[] = { + 1.00000000000000000000E0, + 1.32281951154744992508E1, + 8.67072140885989742329E1, + 3.54937778887819891062E2, + 9.75708501743205489753E2, + 1.82390916687909736289E3, + 2.24633760818710981792E3, + 1.65666309194161350182E3, + 5.57535340817727675546E2 + }; + + double R[] = { + 5.64189583547755073984E-1, + 1.27536670759978104416E0, + 5.01905042251180477414E0, + 6.16021097993053585195E0, + 7.40974269950448939160E0, + 2.97886665372100240670E0 + }; + double S[] = { + 1.00000000000000000000E0, + 2.26052863220117276590E0, + 9.39603524938001434673E0, + 1.20489539808096656605E1, + 1.70814450747565897222E1, + 9.60896809063285878198E0, + 3.36907645100081516050E0 + }; + + if( a < 0.0 ) x = -a; + else x = a; + + if( x < 1.0 ) return 1.0 - erf(a); + + z = -a * a; + + if( z < -MAXLOG ) { + if( a < 0 ) return( 2.0 ); + else return( 0.0 ); + } + + z = Math.exp(z); + + if( x < 8.0 ) { + p = Polynomial.polyval( x, P ); + q = Polynomial.polyval( x, Q ); + } else { + p = Polynomial.polyval( x, R); + q = Polynomial.polyval( x, S ); + } + + y = (z * p)/q; + + if( a < 0 ) y = 2.0 - y; + + if( y == 0.0 ) { + if( a < 0 ) return 2.0; + else return( 0.0 ); + } + + return y; + } + /** + * Returns the area from zero to x under the F density + * function (also known as Snedcor's density or the + * variance ratio density); formerly named fdtr. + * Corresponds to the left hand tail of the F-distribution. + * + * The incomplete beta integral is used, according to the formula + * 

    +	 *
+	 * P(x) = Gamma.incompleteBeta( df1/2, df2/2, (df1*x/(df2 + df1*x) ).
+	 *
+	 *
    + * + * @param df1 ( greater than or equal to 1 ) + * @param df2 ( greater than or equal to 1 ) + * @param x the integration end point (greater than or equal to 0). + */ + public static double fcdf( double x, int df1, int df2 ){ + double a, b, w; + + if( (df1 < 1) || (df2 < 1) || x < 0.0 ) throw new IllegalArgumentException("F-distribution domain error."); + a = df1; + b = df2; + w = a * x; + w = w / (b + w); + return Gamma.incompleteBeta(0.5*a, 0.5*b, w); + } + + /** + * Returns the area from x to infinity under the F density + * function (also known as Snedcor's density or the + * variance ratio density); formerly named fdtrc. + * Corresponds to the right hand tail of the F-distribution ( and + * to the values presented in F-distribution tables). + * + * The incomplete beta integral is used, according to the + * relation + *
    +	 * 
+	 * P(x) = Gamma.incompleteBeta( df2/2, df1/2, (df2/(df2 + df1*x) )
+	 * 
+	 *
    + * + * @param df1 df1 ( greater than or equal to 1 ) + * @param df2 df2 ( greater than or equal to 1 ) + * @param x the left integration point. Corresponds to the F value in look-up tables. + * @return The area from x to inf. under the F density function. + */ + public static double fcdfComplemented(double x, int df1, int df2){ + + double a, b, w; + + if( (df1 < 1) || (df2 < 1) || (x < 0.0) ) throw new IllegalArgumentException("Complementary F-distribution domain error."); + + a = df1; + b = df2; + w = b / (b + a * x); // df1 / (df1 + df2*x) + return Gamma.incompleteBeta( 0.5*b, 0.5*a, w ); + } + + /** + * Finds the F density argument x such that the integral + * from 0 to x of the F density is equal to p; formerly named fdtri. + * That is, it solves for the value of x, given p such that + * 
    +	 * fcdf(x,df1,df2) - p = 0.
+	 *
    + * + * This is accomplished using the inverse beta integral + * function and the relations + *
    +	 * z = incompleteBetaInverse( df2/2, df1/2, p ),
+	 * x = 1 - df2 * (1-z) / (df1 z),
+	 *
    + * if p > Gamma.incompleteBeta( 0.5*df1, 0.5*df2, 0.5 );, or p < 0.001 and, + *
    +	 * z = incompleteBetaInverse( df1/2, df2/2, p ),
+	 * x = 1 - df2 * z / (df1 (1-z)),
+	 *
    + * otherwise. + * The significance level for a one-sided test (or α in look-up tables) is then 1-x + * + * @param df1 degrees of freedom of the first dataset + * @param df2 degrees of freedom of the second dataset + * @param p the fcdf value for which to solve for x + * @return the point x such that fcdf(x,df1,df2) = p. + * @throws IllegalArgumentException if df1 or df2 are less than 1, or p is not in (0,1]. + */ + public static double finv( double p, int df1, int df2){ + double a, b, w, x; + + if( (df1 < 1) || (df2 < 1) || (p <= 0.0) || (p > 1.0) ) + throw new IllegalArgumentException("Domain error in fInverse"); + a = df1; + b = df2; + /* Compute probability for x = 0.5. */ + w = Gamma.incompleteBeta( 0.5*b, 0.5*a, 0.5 ); + /* If that is greater than y, then the solution is in w < .5. + Otherwise, solve at 1-y to remove cancellation in (b - b*w). */ + if( w > p || p < 0.001) + { + /* FComplemented: w = b / (b + a * x); --> x = b(1/w- 1)/a = b*(1-w)/(a*w) */ + w = Gamma.incompleteBetaInverse( 0.5*b, 0.5*a, p ); + x = (b - b*w)/(a*w); + } + else + { + /* F: w = a*x/ (a*x+b) --> solve for x = b*w/(a*(1-w)) + */ + w = Gamma.incompleteBetaInverse( 0.5*a, 0.5*b, 1.0-p );// incbi( 0.5*a, 0.5*b, 1.0-p ); + x = b*w/(a*(1.0-w)); + } + return x; + } + + + /** + * Returns the integral from zero to x of the gamma probability + * density function. + * 
    +	 * 
+	 * y = a^b / Γ(b) * Integral_(0 to x) [ t^(b-1) e^(-a*t) ]dt
+	 *
+	 *
    + * The incomplete gamma integral is used, according to the + * relation + * + * y = Gamma.incompleteGamma( b, a*x ). + * + * @param a the paramater a (alpha) of the gamma distribution. + * @param b the paramater b (beta, lambda) of the gamma distribution. + * @param x integration end point. + * @return y the integral from zero to x of the gamma pdf. + */ + static public double gammacdf( double x, double a, double b ) { + if( x < 0.0 ) return 0.0; + return Gamma.incompleteGamma(b, a*x); + } + /** + * Returns the integral from x to infinity of the gamma + * probability density function: + * 
    +	 * 
+	 * y = a^b / Γ(b) * Integral_(from x to infinity) [t^(b-1) * e^(-a*t) ] dt
+	 *
+	 *
    + * The incomplete gamma integral is used, according to the + * relation + *

    + * y = Gamma.incompleteGammaComplement( b, a*x ). + * + * @param a the paramater a (alpha) of the gamma distribution. + * @param b the paramater b (beta, lambda) of the gamma distribution. + * @param x integration start point. + */ + static public double gammacdfComplemented( double x, double a, double b ) { + if( x < 0.0 ) return 0.0; + return Gamma.incompleteGammaComplement(b, a*x); + } + /** + * Returns the sum of the terms 0 through k of the Negative Binomial Distribution. + * 

    +	 * 
+	 * Sum_(from j=0 to k)  [ (n+j-1)! / ( j! * (n-1)! ) ] * [ p^n* (1-p)^j ]
+	 *   
+	 *
    + * In a sequence of Bernoulli trials, this is the probability + * that k or fewer failures precede the n-th success. + *

    + * The terms are not computed individually; instead the incomplete + * beta integral is employed, according to the formula + *

    + * y = nbinomcdf( p, k, n ) = Gamma.incompleteBeta( n, k+1, p ). + * + * All arguments must be positive, + * @param k end term. + * @param n the number of trials. + * @param p the probability of success (must be in (0.0,1.0)). + */ + static public double nbinomcdf(double p, int k, int n) { + if( (p < 0.0) || (p > 1.0) ) throw new IllegalArgumentException(); + if(k < 0) return 0.0; + + return Gamma.incompleteBeta( n, k+1, p ); + } + /** + * Returns the sum of the terms k+1 to infinity of the Negative + * Binomial distribution. + * 

    +	 * 
+	 * Sum_(from j=k+1 to inf)  [ (n+j-1)! / ( j! * (n-1)! ) ] * [ p^n* (1-p)^j ]
+	 * 
+	 *
    + * The terms are not computed individually; instead the incomplete + * beta integral is employed, according to the formula + *

    + * y = nbinomcdfComplemented( p, k, n ) = Gamma.incompleteBeta( k+1, n, 1-p ). + * + * All arguments must be positive, + * @param k (start-1) term. + * @param n the number of trials. + * @param p the probability of success (must be in (0.0,1.0)). + */ + static public double nbinomcdfComplemented( double p, int k, int n ) { + if( (p < 0.0) || (p > 1.0) ) throw new IllegalArgumentException(); + if(k < 0) return 0.0; + + return Gamma.incompleteBeta( k+1, n, 1.0-p ); + } + /** + * Returns the area under the Normal (Gaussian) probability density + * function, integrated from minus infinity to x (assumes mean is zero, variance is one). + * 

    +	 * 
+	 * normcdf(x) = 1/sqrt(2pi) * Integral_(-inf to x) [ e^(-t^2/2) ] dt
+	 *           =  ( 1 + erf(z) ) / 2
+	 *           =  erfc(z) / 2
+	 *           
+	 *
    + * where z = x/sqrt(2). + * Computation is via the functions erf and erfComplement. + *

    + * Relation to alpha value (or confidence level): + *

      + *
      Two tailed test: alpha = 2*( 1-normcdf(x) ).
      + *
      one-tailed test: alpha = ( 1-normcdf(x) ).
      + *
    + *

    + * @param a x in the equation above. + */ + static public double normcdf( double a) throws ArithmeticException { + double x, y, z; + + x = a * SQRTH; + z = Math.abs(x); + + if( z < SQRTH ) y = 0.5 + 0.5 * erf(x); + else { + y = 0.5 * erfComplemented(z); + if( x > 0 ) y = 1.0 - y; + } + + return y; + } + /** + * Returns the area under the Normal (Gaussian) probability density + * function, integrated from minus infinity to x when the + * data has not been standardized (i.e. mean ≠0, variance ≠1). + * 
    +	 *  
+	 * normcdf(x,mean,variance) = 1/sqrt(2pi*v) * Integral_(-inf to x) [ e^(-(t-mean)^2 / 2v) ] dt
+	 *
+	 *
    + * where v = variance. + * Computation is via the functions erf. + * + * @param mean the mean of the normal distribution. + * @param variance the variance of the normal distribution. + * @param x the integration limit. + */ + static public double normcdf(double x, double mean, double variance) throws ArithmeticException { + if (x>0) + return 0.5 + 0.5*erf((x-mean)/Math.sqrt(2.0*variance)); + else + return 0.5 - 0.5*erf((-(x-mean))/Math.sqrt(2.0*variance)); + } + /** + * Returns the value, x, for which the area under the + * Normal (Gaussian) probability density function (integrated from + * minus infinity to x) is equal to the argument y + * (assumes mean is zero, variance is one); formerly named ndtri. + * That is, + *

    + * normcdf(x) = y0. + *

    + *

    + * For small arguments 0 < y < exp(-2), the program computes + * z = sqrt( -2.0 * log(y) ); then the approximation is + * x = z - log(z)/z - (1/z) P(1/z) / Q(1/z). + * There are two rational functions P/Q, one for 0 < y < exp(-32) + * and the other for y up to exp(-2). + * For larger arguments, + * w = y - 0.5, and x/sqrt(2pi) = w + w**3 R(w**2)/S(w**2)). + * Finally, this returns -infinity for y0 = 0 + * and +infinity for y0 = 1. + * + * @param y0 the argument to the function + */ + static public double norminv( double y0) throws ArithmeticException { + double x, y, z, y2, x0, x1; + int code; + + final double s2pi = Math.sqrt(2.0*Math.PI); + + if( y0 < 0.0 ) throw new IllegalArgumentException(); + if( y0 > 1.0 ) throw new IllegalArgumentException(); + if( y0==0.0 )return -Double.NEGATIVE_INFINITY; + if( y0==1.0 )return Double.POSITIVE_INFINITY; + + code = 1; + y = y0; + if( y > (1.0 - 0.13533528323661269189) ) { /* 0.135... = exp(-2) */ + y = 1.0 - y; + code = 0; + } + + if( y > 0.13533528323661269189 ) { + y = y - 0.5; + y2 = y * y; + x = y + y * (y2 * Polynomial.polyval( y2, P0)/Polynomial.polyval( y2, Q0)); + x = x * s2pi; + return(x); + } + + x = Math.sqrt( -2.0 * Math.log(y) ); + x0 = x - Math.log(x)/x; + + z = 1.0/x; + if( x < 8.0 ) /* y > exp(-32) = 1.2664165549e-14 */ + x1 = z * Polynomial.polyval( z, P1 )/Polynomial.polyval( z, Q1 ); + else + x1 = z * Polynomial.polyval( z, P2 )/Polynomial.polyval( z, Q2 ); + x = x0 - x1; + if( code != 0 ) + x = -x; + return( x ); + } + /** + * Returns the sum of the first k terms of the Poisson distribution. + * 

    +	 * 
+	 * Sum_(j=0 to k) [ e^(-m) *  m^j /j! ]
+	 *
+	 *
    + * The terms are not summed directly; instead the incomplete + * gamma integral is employed, according to the relation + *

    + * y = poissoncdf( mean, k m ) = Gamma.incompleteGammaComplement( k+1, mean ). + * + * The arguments must both be positive. + * + * @param k number of terms. + * @param mean the mean of the poisson distribution. + */ + static public double poissoncdf( double mean, int k) throws ArithmeticException { + if( mean < 0 ) throw new IllegalArgumentException(); + if( k < 0 ) return 0.0; + return Gamma.incompleteGammaComplement((double)(k+1) ,mean); + } + /** + * Returns the sum of the terms k+1 to Infinity of the Poisson distribution. + * 

    +	 *  
+	 * Sum_(j=k+1 to inf.) [ e^(-m) *  m^j /j! ]
+	 * 
+	 *
    + * The terms are not summed directly; instead the incomplete + * gamma integral is employed, according to the formula + *

    + * y = poissoncdfComplemented( k, m ) = Gamma.incompleteGamma( k+1, m ). + * + * The arguments must both be positive. + * + * @param k (start-1) term. + * @param mean the mean of the poisson distribution. + */ + static public double poissoncdfComplemented(int k, double mean) throws ArithmeticException { + if( mean < 0.0 ) throw new IllegalArgumentException(); + if( k < -1 ) return 0.0; + return Gamma.incompleteGamma((double)(k+1),mean); + } + /** + * Returns the integral from minus infinity to t of the Student-t + * distribution with k > 0 degrees of freedom. + * 

    +	 * 
+	 * Γ((k+1)/2) / [ sqrt(k*pi) * Γ(k/2)  ] * Integral_(-inf to t) [  ( 1+x^2/k )^( (-k+1)/2 ) ] dx
+	 * 
+	 *
    + * Relation to incomplete beta integral: + *

    + *
    tcdf(t,k) = 0.5 * Gamma.incompleteBeta( k/2, 1/2, z ), when t < 0,
    + *
    tcdf(t,k) = 1-0.5 * Gamma.incompleteBeta( k/2, 1/2, z ), when t > 0,
    + *

    + * where z = k/(k + t^2). + * Relation to alpha value (or confidence level): + *
      + *
      Two tailed test: alpha = 2*( 1-tcdf(t,k) ).
      + *
      one-tailed test: alpha = ( 1-tcdf(t,k) ).
      + *
    + * @param k degrees of freedom. + * @param t integration end point. + */ + static public double tcdf(double t, double k) throws ArithmeticException { + if( k <= 0.0 ) throw new IllegalArgumentException(); + if( t == 0.0 ) return( 0.5 ); + + if( t < 0 ){ + return 0.5 * Gamma.incompleteBeta( 0.5*k, 0.5, k / (k + t * t) ); + } + else { + return 1.0 - 0.5 * Gamma.incompleteBeta( 0.5*k, 0.5, k / (k + t * t) ); + } + } + /** + * Returns the value, t, for which the area under the + * Student-t probability density function (integrated from + * minus infinity to t) is equal to p. + * The function uses the tcdf function to determine the return + * value iteratively. + * + * @param p the fcdf value for which to solve for x + * @param k the degrees of freedom + */ + public static double tinv(double p, double k) { + if(p<0 || p>1) throw new IllegalArgumentException(p + "is not a valid value for p"); + + if(p==.5) return 0; + if(p==0.0) return tcdf(1e-8,k); + if(p==1.0) return tcdf(1-1e-8,k); + + + /* if p is in the left region, correct it. */ + double cumProb = p; // Cumulative probability = 1-alpha/2 + int multiplier = 1; + // Solution lies in the left half of the student-T curve ( t < 0) + // so we solve for the equivalent t-value in the right half, and then + // multiply that by -1. + if(cumProb < .5){ + cumProb = 1-cumProb; + multiplier = -1; + } + + double f1,f2,f3; + double x1,x2,x3; + double g,s12; + + // make a first approximation using the norm-inv function. + x1 = norminv(cumProb); + // Return inverse of normal for large size (k > 30 is pretty sufficient usually). + if (k > 200) { + return x1; + } + + /* Find a pair of x1,x2 that bracket zero to + guarantee asymptotic convergence later on */ + f1 = tcdf(x1,k)-cumProb; + x2 = x1; f2 = f1; + do { + if (f1>0) { + x2 = x2/2; // decrease x2 + } else { + x2 = x2+x1; // increase x2 + } + f2 = tcdf(x2,k)-cumProb; // + } while (f1*f2>0); + + // Find better approximation now that f1 and f2 bracket zero. + // Pegasus-method (also known as the false-position-method or regula-falsi-method) + do { + // Calculate slope of secant and t value for which it is 0. + s12 = (f2-f1)/(x2-x1); + x3 = x2 - f2/s12; + + // Calculate function value at x3 + f3 = tcdf(x3,k)-cumProb; + if (Math.abs(f3)<1e-8) { // This criteria needs to be very tight! + // We found a perfect value -> return + return multiplier*x3; + } + + if (f3*f2<0) { + x1=x2; f1=f2; + x2=x3; f2=f3; + } else { + g = f2/(f2+f3); + f1=g*f1; + x2=x3; f2=f3; + } + } while(Math.abs(x2-x1)>0.001); + + if (Math.abs(f2)<=Math.abs(f1)) { + return multiplier*x2; + } else { + return multiplier*x1; + } + } +} diff --git a/drawing/papaya/src/papaya/QR.java b/drawing/papaya/src/papaya/QR.java new file mode 100644 index 0000000..8fc33db --- /dev/null +++ b/drawing/papaya/src/papaya/QR.java @@ -0,0 +1,296 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; + +/** QR Decomposition. +

    + For an m-by-n matrix A with m ≥ n, the QR decomposition is an m-by-n + orthogonal matrix Q and an n-by-n upper triangular matrix R so that + A = Q*R. +

    + The QR decompostion always exists, even if the matrix does not have + full rank, so the constructor will never fail. The primary use of the + QR decomposition is in the least squares solution of nonsquare systems + of simultaneous linear equations. This will fail if isFullRank() + returns false. +

    +Shamelessly copied (and modified) from the +JAMA Java +Matrix package. To make things compatible with how most users use Processing, the +class take in float matrices. However, to preserve the acccuracy of the computations, the algorithm +first casts the input into a double array, prior to doing anything. All methods also return doubles; Use +{@link Cast#doubleToFloat(double[][])} if you want/need to cast everything back to floats for +further (non-high-accuracy-dependant) processing (pun intended). + */ + + + + +public class QR { + /* ------------------------ + Class variables + * ------------------------ */ + + /** Array for internal storage of decomposition. + @serial internal array storage. + */ + private double[][] QR; + + /** Row and column dimensions. + @serial column dimension. + @serial row dimension. + */ + private int m, n; + + /** Array for internal storage of diagonal of R. + @serial diagonal of R. + */ + private double[] Rdiag; + + /* ------------------------ + Constructor + * ------------------------ */ + + /** QR Decomposition, computed by Householder reflections. + * @param A Rectangular matrix + */ + + public QR (float[][] A) { + // Initialize. + QR = Cast.floatToDouble(A); + m = A.length; + n = A[0].length; + Rdiag = new double[n]; + + // Main loop. + for (int k = 0; k < n; k++) { + // Compute 2-norm of k-th column without under/overflow. + double nrm = 0; + for (int i = k; i < m; i++) { + nrm = SVD.hypot(nrm,QR[i][k]); + } + + if (nrm != 0.0) { + // Form k-th Householder vector. + if (QR[k][k] < 0) { + nrm = -nrm; + } + for (int i = k; i < m; i++) { + QR[i][k] /= nrm; + } + QR[k][k] += 1.0; + + // Apply transformation to remaining columns. + for (int j = k+1; j < n; j++) { + double s = 0.0; + for (int i = k; i < m; i++) { + s += QR[i][k]*QR[i][j]; + } + s = -s/QR[k][k]; + for (int i = k; i < m; i++) { + QR[i][j] += s*QR[i][k]; + } + } + } + Rdiag[k] = -nrm; + } + } + + /* ------------------------ + Public Methods + * ------------------------ */ + + /** Is the matrix full rank? + @return true if R, and hence A, has full rank. + */ + + public boolean isFullRank () { + for (int j = 0; j < n; j++) { + if (Rdiag[j] == 0) + return false; + } + return true; + } + + /** Return the Householder vectors + @return Lower trapezoidal matrix whose columns define the reflections + */ + + public double[][] getH () { + double[][] H = new double[m][n]; + for (int i = 0; i < m; i++) { + for (int j = 0; j < n; j++) { + if (i >= j) { + H[i][j] = QR[i][j]; + } else { + H[i][j] = 0.0; + } + } + } + return H; + } + + /** Return the upper triangular factor + @return R + */ + + public double[][] getR () { + double[][] R = new double[n][n]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + if (i < j) { + R[i][j] = QR[i][j]; + } else if (i == j) { + R[i][j] = Rdiag[i]; + } else { + R[i][j] = 0.0; + } + } + } + return R; + } + + /** Generate and return the (economy-sized) orthogonal factor + @return Q + */ + + public double[][] getQ () { + double[][] Q = new double[m][n]; + for (int k = n-1; k >= 0; k--) { + for (int i = 0; i < m; i++) { + Q[i][k] = 0.0; + } + Q[k][k] = 1.0; + for (int j = k; j < n; j++) { + if (QR[k][k] != 0) { + double s = 0.0; + for (int i = k; i < m; i++) { + s += QR[i][k]*Q[i][j]; + } + s = -s/QR[k][k]; + for (int i = k; i < m; i++) { + Q[i][j] += s*QR[i][k]; + } + } + } + } + return Q; + } + + /** Least squares solution of A*X = b + @param b An array with the same length as the number of rows in A. + @return x that minimizes the two norm of Q*R*x-b. + @exception IllegalArgumentException Matrix row dimensions must agree. + @exception RuntimeException Matrix is rank deficient. + */ + + public double[] solve (float[] b) { + if (b.length != m) { + throw new IllegalArgumentException("Matrix row dimensions must agree."); + } + if (!this.isFullRank()) { + throw new RuntimeException("Matrix is rank deficient."); + } + + // Copy right hand side + int nx = 1; //B[0].length; + double[] X = Cast.floatToDouble(b); + + // Compute Y = transpose(Q)*B + for (int k = 0; k < n; k++) { + double s = 0.0; + for (int i = k; i < m; i++) { + s += QR[i][k]*X[i]; + } + s = -s/QR[k][k]; + for (int i = k; i < m; i++) { + X[i] += s*QR[i][k]; + } + + } + //Mat.print(Cast.doubleToFloat(X),4); + // Solve R*x = y; + for (int k = n-1; k >= 0; k--) { + X[k] /= Rdiag[k]; + + for (int i = 0; i < k; i++) { + X[i] -= X[k]*QR[i][k]; + + } + } + return X; + + } + + /** Least squares solution of A*X = B + @param B A Matrix with as many rows as A and any number of columns. + @return X that minimizes the two norm of Q*R*X-B. + @exception IllegalArgumentException Matrix row dimensions must agree. + @exception RuntimeException Matrix is rank deficient. + */ + + public double[][] solve (float[][] B) { + if (B.length != m) { + throw new IllegalArgumentException("Matrix row dimensions must agree."); + } + if (!this.isFullRank()) { + throw new RuntimeException("Matrix is rank deficient."); + } + + // Copy right hand side + int nx = B[0].length; + double[][] X = Cast.floatToDouble(B); + + // Compute Y = transpose(Q)*B + for (int k = 0; k < n; k++) { + for (int j = 0; j < nx; j++) { + double s = 0.0; + for (int i = k; i < m; i++) { + s += QR[i][k]*X[i][j]; + } + s = -s/QR[k][k]; + for (int i = k; i < m; i++) { + X[i][j] += s*QR[i][k]; + } + } + } + // Solve R*X = Y; + for (int k = n-1; k >= 0; k--) { + for (int j = 0; j < nx; j++) { + X[k][j] /= Rdiag[k]; + } + for (int i = 0; i < k; i++) { + for (int j = 0; j < nx; j++) { + X[i][j] -= X[k][j]*QR[i][k]; + } + } + } + return X; + } +} + + + + + diff --git a/drawing/papaya/src/papaya/Rank.java b/drawing/papaya/src/papaya/Rank.java new file mode 100644 index 0000000..0628635 --- /dev/null +++ b/drawing/papaya/src/papaya/Rank.java @@ -0,0 +1,618 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; +import java.io.*; +import processing.core.*; + +/** + *

    Ranking based on the natural ordering on floats for a sequence of data that may also + * contain NaNs.

    + *

    When present, NaNs are treated according to the configured NaNStrategy constants and ties + * are handled using the configured tiesStrategy constants as follows: + * + *

    Strategies for handling NaN values in rank transformations. + *

      + *
    • 0 (REMOVED, default) - NaNs are removed before the rank transform is applied
      • + *
    • 1 (MINIMAL) - NaNs are treated as minimal in the ordering, equivalent to + * (that is, tied with) Float.NEGATIVE_INFINITY.
      • + *
    • 2 (MAXIMAL) - NaNs are treated as maximal in the ordering, equivalent to + * Float.POSITIVE_INFINITY
      • + *
    • 3 (FIXED) - NaNs are left "in place," that is the rank transformation is + * applied to the other elements in the input array, but the NaN elements + * are returned unchanged.
      • + *
    + *

    + * + *

    Strategies for handling tied values in rank transformations: + *

      + *
    • 0 (AVERAGE, default) - Tied values are assigned the average of the applicable ranks. + * For example, (1,3,4,3) is ranked as (1,2.5,4,2.5)
      • + *
    • 1 (MINIMUM) - Tied values are assigned the minimum applicable rank, or the rank + * of the first occurrence. For example, (1,3,4,3) is ranked as (1,2,4,2)
      • + *
    • 2 (MAXIMUM) - Tied values are assigned the maximum applicable rank, or the rank + * of the last occurrence. For example, (1,3,4,3) is ranked as (1,3,4,3)
      • + *
    • 3 (SEQUENTIAL) - Ties are assigned ranks in order of occurrence in the original array, + * for example (1,3,4,3) is ranked as (1,2,4,3)
      • +
    + *

    + * + * The defaults are 0 (REMOVED) and 0 (AVERAGE) for the NaNStrategy and TiesStrategy respectively. + * + *

    Examples: + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
    + * Input data: (20, 17, 30, 42.3, 17, 50, Float.NaN, Float.NEGATIVE_INFINITY, 17) + *
    NaNStrategyTiesStrategyrank(data)
    0 (default = NaNs removed)0 (default = ties averaged)(5, 3, 6, 7, 3, 8, 1, 3)
    0 (default = NaNs removed)1 (MINIMUM)(5, 2, 6, 7, 2, 8, 1, 2)
    1 (MINIMAL)0 (default = ties averaged)(6, 4, 7, 8, 4, 9, 1.5, 1.5, 4)
    1 (MINIMAL)2 (MAXIMUM)(6, 5, 7, 8, 5, 9, 2, 2, 5)
    2 (MAXIMAL)2 (MAXIMUM)/td> + * (5, 4, 6, 7, 4, 8, 9, 1, 4)

    + * + * (Code adapted from the org.apache.commons.math.stat.ranking package, and modified extensively). + */ +public class Rank { + + // NaNs ---------------------------------------- + /** NaNs are removed before computing ranks. Corresponds to default */ + private static final int REMOVED = 0; + + /** NaNs are considered maximal in the ordering */ + private static final int MINIMAL = 1; + + /** NaNs are considered minimal in the ordering */ + private static final int MAXIMAL = 2; + + /** NaNs are left in place */ + private static final int FIXED = 3; + + + // TIES ---------------------------------------- + /** Ties get the average of applicable ranks. Corresponds to default */ + private static final int AVERAGE = 0; + + /** Ties get the minimum applicable rank */ + private static final int MINIMUM =1; + + /** Ties get the maximum applicable rank */ + private static final int MAXIMUM = 2; + + /** Ties assigned sequential ranks in order of occurrence */ + private static final int SEQUENTIAL = 3; + + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected Rank(){} + + /** + * Rank an array containing NaN values using the natural ordering on Floats, with + * NaN values handled according to nanStrategy and ties + * resolved using tiesStrategy. + * + *

    Input values that specify which strategy to use for handling tied values in the + * rank transformations: + *

      + *
    • 0 (AVERAGE, default) - Tied values are assigned the average of the applicable ranks. + * For example, (1,3,4,3) is ranked as (1,2.5,4,2.5)
      • + *
    • 1 (MINIMUM) - Tied values are assigned the minimum applicable rank, or the rank + * of the first occurrence. For example, (1,3,4,3) is ranked as (1,2,4,2)
      • + *
    • 2 (MAXIMUM) - Tied values are assigned the maximum applicable rank, or the rank + * of the last occurrence. For example, (1,3,4,3) is ranked as (1,3,4,3)
      • + *
    • 3 (SEQUENTIAL) - Ties are assigned ranks in order of occurrence in the original array, + * for example (1,3,4,3) is ranked as (1,2,4,3)
      • + *
    + *

    + * + *

    Input values that specify which strategy to use for handling NaN values in the + * rank transformations: + *

      + *
    • 0 (REMOVED, default) - NaNs are removed before the rank transform is applied
      • + *
    • 1 (MINIMAL) - NaNs are treated as minimal in the ordering, equivalent to + * (that is, tied with) Float.NEGATIVE_INFINITY.
      • + *
    • 2 (MAXIMAL) - NaNs are treated as maximal in the ordering, equivalent to + * Float.POSITIVE_INFINITY
      • + *
    • 3 (FIXED) - NaNs are left "in place," that is the rank transformation is + * applied to the other elements in the input array, but the NaN elements + * are returned unchanged.
      • + *
    + *

    + * If the data array has no NaN values, use {@link rank(float[], int)} instead. It is quicker. + * @param data array to be ranked. This is cast to a float array prior to ranking. + * @param nanStrategy 0,1,2 or 3 corresponding to the NaN strategy to employ. + * @param tiesStrategy 0,1,2 or 3 corresponding to the ties strategy to employ. + * @return array of ranks + */ + public static float[] rank(int[] data, int tiesStrategy, int nanStrategy) { + checkNaNStrategy(nanStrategy); + checkTiesStrategy(tiesStrategy); + // Array recording initial positions of data to be ranked + IntFloatPair[] ranks = new IntFloatPair[data.length]; + for (int i = 0; i < data.length; i++) { + ranks[i] = new IntFloatPair((float)data[i], i); + } + List nanPositions = nanStrategy(ranks, nanStrategy); + // Sort the IntFloatPairs + Arrays.sort(ranks); + float[] out = new float[ranks.length]; + rankIt(ranks,out, tiesStrategy); + + if (nanStrategy==FIXED){ + restoreNaNs(out, nanPositions); + } + return out; + } + + /** + * Rank an array containing NaN values using the natural ordering on Floats, with + * NaN values handled according to nanStrategy and ties + * resolved using tiesStrategy. + * + *

    Input values that specify which strategy to use for handling tied values in the + * rank transformations: + *

      + *
    • 0 (AVERAGE, default) - Tied values are assigned the average of the applicable ranks. + * For example, (1,3,4,3) is ranked as (1,2.5,4,2.5)
      • + *
    • 1 (MINIMUM) - Tied values are assigned the minimum applicable rank, or the rank + * of the first occurrence. For example, (1,3,4,3) is ranked as (1,2,4,2)
      • + *
    • 2 (MAXIMUM) - Tied values are assigned the maximum applicable rank, or the rank + * of the last occurrence. For example, (1,3,4,3) is ranked as (1,3,4,3)
      • + *
    • 3 (SEQUENTIAL) - Ties are assigned ranks in order of occurrence in the original array, + * for example (1,3,4,3) is ranked as (1,2,4,3)
      • + *
    + *

    + * + *

    Input values that specify which strategy to use for handling NaN values in the + * rank transformations: + *

      + *
    • 0 (REMOVED, default) - NaNs are removed before the rank transform is applied
      • + *
    • 1 (MINIMAL) - NaNs are treated as minimal in the ordering, equivalent to + * (that is, tied with) Float.NEGATIVE_INFINITY.
      • + *
    • 2 (MAXIMAL) - NaNs are treated as maximal in the ordering, equivalent to + * Float.POSITIVE_INFINITY
      • + *
    • 3 (FIXED) - NaNs are left "in place," that is the rank transformation is + * applied to the other elements in the input array, but the NaN elements + * are returned unchanged.
      • + *
    + *

    + * If the data array has no NaN values, use {@link rank(float[], int)} instead. It is quicker. + * @param data array to be ranked + * @param nanStrategy 0,1,2 or 3 corresponding to the NaN strategy to employ. + * @param tiesStrategy 0,1,2 or 3 corresponding to the ties strategy to employ. + * @return array of ranks + */ + public static float[] rank(float[] data, int tiesStrategy, int nanStrategy) { + checkNaNStrategy(nanStrategy); + checkTiesStrategy(tiesStrategy); + // Array recording initial positions of data to be ranked + IntFloatPair[] ranks = new IntFloatPair[data.length]; + for (int i = 0; i < data.length; i++) { + ranks[i] = new IntFloatPair(data[i], i); + } + List nanPositions = nanStrategy(ranks, nanStrategy); + // Sort the IntFloatPairs + Arrays.sort(ranks); + float[] out = new float[ranks.length]; + rankIt(ranks,out, tiesStrategy); + + if (nanStrategy==FIXED){ + restoreNaNs(out, nanPositions); + } + return out; + } + + /** + * Rank an array (with no NaNs) using the natural ordering on Floats with ties + * resolved using tiesStrategy. + *

    Input values that specify which strategy to use for handling NaN values in the + * rank transformations: + *

      + *
    • 0 (AVERAGE, default) - Tied values are assigned the average of the applicable ranks. + * For example, (1,3,4,3) is ranked as (1,2.5,4,2.5)
      • + *
    • 1 (MINIMUM) - Tied values are assigned the minimum applicable rank, or the rank + * of the first occurrence. For example, (1,3,4,3) is ranked as (1,2,4,2)
      • + *
    • 2 (MAXIMUM) - Tied values are assigned the maximum applicable rank, or the rank + * of the last occurrence. For example, (1,3,4,3) is ranked as (1,3,4,3)
      • + *
    • 3 (SEQUENTIAL) - Ties are assigned ranks in order of occurrence in the original array, + * for example (1,3,4,3) is ranked as (1,2,4,3)
      • + *
    + *

    + * + * @param data array to be ranked. The array is cast to a float array prior to ranking + * @param tiesStrategy the strategy to employ for ties. + * @return array of ranks + */ + public static float[] rank(int[] data, int tiesStrategy) { + checkTiesStrategy(tiesStrategy); + // Array recording initial positions of data to be ranked + IntFloatPair[] ranks = new IntFloatPair[data.length]; + for (int i = 0; i < data.length; i++) { + ranks[i] = new IntFloatPair((float)data[i], i); + } + // Sort the IntFloatPairs + Arrays.sort(ranks); + float[] out = new float[ranks.length]; + rankIt(ranks,out,tiesStrategy); + return out; + } + + /** + * Rank an array (with no NaNs) using the natural ordering on Floats with ties + * resolved using tiesStrategy. + *

    Input values that specify which strategy to use for handling NaN values in the + * rank transformations: + *

      + *
    • 0 (AVERAGE, default) - Tied values are assigned the average of the applicable ranks. + * For example, (1,3,4,3) is ranked as (1,2.5,4,2.5)
      • + *
    • 1 (MINIMUM) - Tied values are assigned the minimum applicable rank, or the rank + * of the first occurrence. For example, (1,3,4,3) is ranked as (1,2,4,2)
      • + *
    • 2 (MAXIMUM) - Tied values are assigned the maximum applicable rank, or the rank + * of the last occurrence. For example, (1,3,4,3) is ranked as (1,3,4,3)
      • + *
    • 3 (SEQUENTIAL) - Ties are assigned ranks in order of occurrence in the original array, + * for example (1,3,4,3) is ranked as (1,2,4,3)
      • + *
    + *

    + * + * @param data array to be ranked. + * @param tiesStrategy the strategy to employ for ties. + * @return array of ranks + */ + public static float[] rank(float[] data, int tiesStrategy) { + checkTiesStrategy(tiesStrategy); + // Array recording initial positions of data to be ranked + IntFloatPair[] ranks = new IntFloatPair[data.length]; + for (int i = 0; i < data.length; i++) { + ranks[i] = new IntFloatPair(data[i], i); + } + // Sort the IntFloatPairs + Arrays.sort(ranks); + float[] out = new float[ranks.length]; + rankIt(ranks,out,tiesStrategy); + return out; + } + + /** The actual ranking takes place here. + * @param ranks: the IntFloat pair of ranks + * @param out: the output ranks */ + private static void rankIt(IntFloatPair[] ranks, float[] out, int tiesStrategy){ + int pos = 1; // position in sorted array + + // Walk the sorted array, filling output array using sorted positions, + // resolving ties as we go + out[ranks[0].getPosition()] = pos; + List tiesTrace = new ArrayList(); + tiesTrace.add(ranks[0].getPosition()); + for (int i = 1; i < ranks.length; i++) { + if (Float.compare(ranks[i].getValue(), ranks[i - 1].getValue()) > 0) { + // tie sequence has ended (or had length 1) + pos = i + 1; + if (tiesTrace.size() > 1) { // if seq is nontrivial, resolve + resolveTie(out, tiesTrace, tiesStrategy); + } + tiesTrace = new ArrayList(); + tiesTrace.add(ranks[i].getPosition()); + } else { + // tie sequence continues + tiesTrace.add(ranks[i].getPosition()); + } + out[ranks[i].getPosition()] = pos; + } + if (tiesTrace.size() > 1) { // handle tie sequence at end + resolveTie(out, tiesTrace, tiesStrategy); + } + } + + /* Check if the nanStrategy input is one of those specified */ + private static void checkNaNStrategy(int num){ + if(num<0 || num>3) throw new IllegalArgumentException("NaN strategy option has to be 0, 1, 2 or 3."); + } + /* Check if the tiesStrategy input is one of those specified */ + private static void checkTiesStrategy(int num){ + if(num<0 || num>3) throw new IllegalArgumentException("Ties strategy option has to be 0, 1, 2 or 3."); + } + + /** Decide how to proceed with the NaN values */ + private static List nanStrategy(IntFloatPair[] ranks, int nanStrategy){ + List nanPositions = null; + + // Recode, remove or record positions of NaNs + switch (nanStrategy) { + case MAXIMAL: // Replace NaNs with +INFs + recodeNaNs(ranks, Float.POSITIVE_INFINITY); + break; + case MINIMAL: // Replace NaNs with -INFs + recodeNaNs(ranks, Float.NEGATIVE_INFINITY); + break; + case REMOVED: // Drop NaNs from data + ranks = removeNaNs(ranks); + break; + case FIXED: // Record positions of NaNs + nanPositions = getNanPositions(ranks); + break; + } + return nanPositions; + } + + /** + * Returns an array that is a copy of the input array with IntFloatPairs + * having NaN values removed. + * @param ranks input array + * @return array with NaN-valued entries removed + */ + private static IntFloatPair[] removeNaNs(IntFloatPair[] ranks) { + if (!containsNaNs(ranks)) { + return ranks; + } + IntFloatPair[] outRanks = new IntFloatPair[ranks.length]; + int j = 0; + for (int i = 0; i < ranks.length; i++) { + if (Float.isNaN(ranks[i].getValue())) { + // drop, but adjust original ranks of later elements + for (int k = i + 1; k < ranks.length; k++) { + ranks[k] = new IntFloatPair( + ranks[k].getValue(), ranks[k].getPosition() - 1); + } + } else { + outRanks[j] = new IntFloatPair( + ranks[i].getValue(), ranks[i].getPosition()); + j++; + } + } + IntFloatPair[] returnRanks = new IntFloatPair[j]; + System.arraycopy(outRanks, 0, returnRanks, 0, j); + return returnRanks; + } + + /** + * Recodes NaN values to the given value. + * + * @param ranks array to recode + * @param value the value to replace NaNs with + */ + private static void recodeNaNs(IntFloatPair[] ranks, float value) { + for (int i = 0; i < ranks.length; i++) { + if (Float.isNaN(ranks[i].getValue())) { + ranks[i] = new IntFloatPair( + value, ranks[i].getPosition()); + } + } + } + + /** + * Checks for presence of NaNs in ranks. + * + * @param ranks array to be searched for NaNs + * @return true iff ranks contains one or more NaNs + */ + private static boolean containsNaNs(IntFloatPair[] ranks) { + for (int i = 0; i < ranks.length; i++) { + if (Float.isNaN(ranks[i].getValue())) { + return true; + } + } + return false; + } + + /** + * Resolve a sequence of ties, using the configured TiesStrategy. + * The input ranks array is expected to take the same value + * for all indices in tiesTrace. The common value is recoded + * according to the tiesStrategy. For example, if ranks = <5,8,2,6,2,7,1,2>, + * tiesTrace = <2,4,7> and tiesStrategy is MINIMUM, ranks will be unchanged. + * The same array and trace with tiesStrategy AVERAGE will come out + * <5,8,3,6,3,7,1,3>. + * + * @param ranks array of ranks + * @param tiesTrace list of indices where ranks is constant + * -- that is, for any i and j in TiesTrace, ranks[i] == ranks[j] + * + */ + private static void resolveTie(float[] ranks, List tiesTrace, int tiesStrategy) { + + // constant value of ranks over tiesTrace + final float c = ranks[tiesTrace.get(0)]; + + // length of sequence of tied ranks + final int length = tiesTrace.size(); + + switch (tiesStrategy) { + case AVERAGE: // Replace ranks with average + double tmp = (2 * c + length - 1) / 2d; + fill(ranks, tiesTrace, (float)tmp); + break; + case MAXIMUM: // Replace ranks with maximum values + fill(ranks, tiesTrace, c + length - 1); + break; + case MINIMUM: // Replace ties with minimum + fill(ranks, tiesTrace, c); + break; + case SEQUENTIAL: // Fill sequentially from c to c + length - 1 + // walk and fill + Iterator iterator = tiesTrace.iterator(); + float f = (float)Math.round(c); + int i = 0; + while (iterator.hasNext()) { + ranks[iterator.next()] = f + i++; + } + break; + } + } + + /** + * Setsdata[i] = value for each i in tiesTrace. + * + * @param data array to modify + * @param tiesTrace list of index values to set + * @param value value to set + */ + private static void fill(float[] data, List tiesTrace, float value) { + Iterator iterator = tiesTrace.iterator(); + while (iterator.hasNext()) { + data[iterator.next()] = value; + } + } + + /** + * Set ranks[i] = Float.NaN for each i in nanPositions. + * + * @param ranks array to modify + * @param nanPositions list of index values to set to Float.NaN + */ + private static void restoreNaNs(float[] ranks, List nanPositions) { + if (nanPositions.size() == 0) { + return; + } + Iterator iterator = nanPositions.iterator(); + while (iterator.hasNext()) { + ranks[iterator.next().intValue()] = Float.NaN; + } + + } + + /** + * Returns a list of indexes where ranks is NaN. + * + * @param ranks array to search for NaNs + * @return list of indexes i such that ranks[i] = NaN + */ + private static List getNanPositions(IntFloatPair[] ranks) { + ArrayList out = new ArrayList(); + for (int i = 0; i < ranks.length; i++) { + if (Float.isNaN(ranks[i].getValue())) { + out.add(Integer.valueOf(i)); + } + } + return out; + } + + + /** + * Represents the position of a float value in an ordering. + * Comparable interface is implemented so Arrays.sort can be used + * to sort an array of IntFloatPairs by value. Note that the + * implicitly defined natural ordering is NOT consistent with equals. + */ + private static class IntFloatPair implements Comparable { + + /** Value of the pair */ + private final float value; + + /** Original position of the pair */ + private final int position; + + /** + * Construct an IntFloatPair with the given value and position. + * @param value the value of the pair + * @param position the original position + */ + public IntFloatPair(float value, int position) { + this.value = value; + this.position = position; + } + + /** + * Compare this IntFloatPair to another pair. + * Only the values are compared. + * + * @param other the other pair to compare this to + * @return result of Float.compare(value, other.value) + */ + public int compareTo(IntFloatPair other) { + return Float.compare(value, other.value); + } + + /** + * Returns the value of the pair. + * @return value + */ + public float getValue() { + return value; + } + + /** + * Returns the original position of the pair. + * @return position + */ + public int getPosition() { + return position; + } + } +} + +//public class Rank { +// private int[] rank;//= new int[numProducts]; +// private int[] idx;// = new int[numProducts]; +// +// public Rank(float[] sortedArray) { +// int size = sortedArray.length; +// rankTemp = new int[size]; +// int i=0; +// while(i +For an m x n matrix A with m > n, +the singular value decomposition is an m-by-n orthogonal matrix +U, an n-by-n diagonal matrix S, and +an n-by-n orthogonal matrix V so that A = U*S*V'. +

    +The singular values, sigma[k] = S[k][k], are ordered so that +sigma[0] > sigma[1] > ... > sigma[n-1]. +

    +The singular value decompostion always exists, so the constructor will +never fail. The matrix condition number and the effective numerical +rank can be computed from this decomposition. +

    +Shamelessly copied (and modified) from the +JAMA Java +Matrix package. To make things compatible with how most users use Processing, the +class take in float matrices. However, to preserve the acccuracy of the computations, the algorithm +first casts the input into a double array, prior to doing anything. All methods also return doubles; Use +{@link Cast#doubleToFloat(double[][])} if you want/need to cast everything back to floats for +further (non-high-accuracy-dependant) processing (pun intended). + */ + +public class SVD { + + /* ------------------------ + Class variables + * ------------------------ */ + + /** Arrays for internal storage of U and V. + @serial internal storage of U. + @serial internal storage of V. + */ + private double[][] U, V; + + /** Array for internal storage of singular values. + @serial internal storage of singular values. + */ + private double[] s; + + /** Row and column dimensions. + @serial row dimension. + @serial column dimension. + */ + private int m, n; + + /* ------------------------ + Constructor + * ------------------------ */ + + /** Construct the singular value decomposition. At the end of this call, + * U, V, and S have been computed. + @param AA Rectangular matrix + @return + */ + + public SVD (float[][] AA) { + + // Derived from LINPACK code. + // Initialize. + double[][] A = Cast.floatToDouble(AA); + m = AA.length; + n = AA[0].length; + + /* Apparently the failing cases are only a proper subset of (m= n"); } + */ + int nu = Math.min(m,n); + s = new double [Math.min(m+1,n)]; + U = new double [m][nu]; + V = new double [n][n]; + double[] e = new double [n]; + double[] work = new double [m]; + boolean wantu = true; + boolean wantv = true; + + // Reduce A to bidiagonal form, storing the diagonal elements + // in s and the super-diagonal elements in e. + + int nct = Math.min(m-1,n); + int nrt = Math.max(0,Math.min(n-2,m)); + for (int k = 0; k < Math.max(nct,nrt); k++) { + if (k < nct) { + + // Compute the transformation for the k-th column and + // place the k-th diagonal in s[k]. + // Compute 2-norm of k-th column without under/overflow. + s[k] = 0; + for (int i = k; i < m; i++) { + s[k] = hypot(s[k],A[i][k]); + } + if (s[k] != 0.0) { + if (A[k][k] < 0.0) { + s[k] = -s[k]; + } + for (int i = k; i < m; i++) { + A[i][k] /= s[k]; + } + A[k][k] += 1.0; + } + s[k] = -s[k]; + } + for (int j = k+1; j < n; j++) { + if ((k < nct) & (s[k] != 0.0)) { + + // Apply the transformation. + + double t = 0; + for (int i = k; i < m; i++) { + t += A[i][k]*A[i][j]; + } + t = -t/A[k][k]; + for (int i = k; i < m; i++) { + A[i][j] += t*A[i][k]; + } + } + + // Place the k-th row of A into e for the + // subsequent calculation of the row transformation. + + e[j] = A[k][j]; + } + if (wantu & (k < nct)) { + + // Place the transformation in U for subsequent back + // multiplication. + + for (int i = k; i < m; i++) { + U[i][k] = A[i][k]; + } + } + if (k < nrt) { + + // Compute the k-th row transformation and place the + // k-th super-diagonal in e[k]. + // Compute 2-norm without under/overflow. + e[k] = 0; + for (int i = k+1; i < n; i++) { + e[k] = hypot(e[k],e[i]); + } + if (e[k] != 0.0) { + if (e[k+1] < 0.0) { + e[k] = -e[k]; + } + for (int i = k+1; i < n; i++) { + e[i] /= e[k]; + } + e[k+1] += 1.0; + } + e[k] = -e[k]; + if ((k+1 < m) & (e[k] != 0.0)) { + + // Apply the transformation. + + for (int i = k+1; i < m; i++) { + work[i] = 0.0; + } + for (int j = k+1; j < n; j++) { + for (int i = k+1; i < m; i++) { + work[i] += e[j]*A[i][j]; + } + } + for (int j = k+1; j < n; j++) { + double t = -e[j]/e[k+1]; + for (int i = k+1; i < m; i++) { + A[i][j] += t*work[i]; + } + } + } + if (wantv) { + + // Place the transformation in V for subsequent + // back multiplication. + + for (int i = k+1; i < n; i++) { + V[i][k] = e[i]; + } + } + } + } + + // Set up the final bidiagonal matrix or order p. + + int p = Math.min(n,m+1); + if (nct < n) { + s[nct] = A[nct][nct]; + } + if (m < p) { + s[p-1] = 0.0; + } + if (nrt+1 < p) { + e[nrt] = A[nrt][p-1]; + } + e[p-1] = 0.0; + + // If required, generate U. + + if (wantu) { + for (int j = nct; j < nu; j++) { + for (int i = 0; i < m; i++) { + U[i][j] = 0.0; + } + U[j][j] = 1.0; + } + for (int k = nct-1; k >= 0; k--) { + if (s[k] != 0.0) { + for (int j = k+1; j < nu; j++) { + double t = 0; + for (int i = k; i < m; i++) { + t += U[i][k]*U[i][j]; + } + t = -t/U[k][k]; + for (int i = k; i < m; i++) { + U[i][j] += t*U[i][k]; + } + } + for (int i = k; i < m; i++ ) { + U[i][k] = -U[i][k]; + } + U[k][k] = 1.0 + U[k][k]; + for (int i = 0; i < k-1; i++) { + U[i][k] = 0.0; + } + } else { + for (int i = 0; i < m; i++) { + U[i][k] = 0.0; + } + U[k][k] = 1.0; + } + } + } + + // If required, generate V. + + if (wantv) { + for (int k = n-1; k >= 0; k--) { + if ((k < nrt) & (e[k] != 0.0)) { + for (int j = k+1; j < nu; j++) { + double t = 0; + for (int i = k+1; i < n; i++) { + t += V[i][k]*V[i][j]; + } + t = -t/V[k+1][k]; + for (int i = k+1; i < n; i++) { + V[i][j] += t*V[i][k]; + } + } + } + for (int i = 0; i < n; i++) { + V[i][k] = 0.0; + } + V[k][k] = 1.0; + } + } + + // Main iteration loop for the singular values. + + int pp = p-1; + int iter = 0; + double eps = Math.pow(2.0,-52.0); + double tiny = Math.pow(2.0,-966.0); + while (p > 0) { + int k,kase; + + // Here is where a test for too many iterations would go. + + // This section of the program inspects for + // negligible elements in the s and e arrays. On + // completion the variables kase and k are set as follows. + + // kase = 1 if s(p) and e[k-1] are negligible and k

    = -1; k--) { + if (k == -1) { + break; + } + if (Math.abs(e[k]) <= + tiny + eps*(Math.abs(s[k]) + Math.abs(s[k+1]))) { + e[k] = 0.0; + break; + } + } + if (k == p-2) { + kase = 4; + } else { + int ks; + for (ks = p-1; ks >= k; ks--) { + if (ks == k) { + break; + } + double t = (ks != p ? Math.abs(e[ks]) : 0.) + + (ks != k+1 ? Math.abs(e[ks-1]) : 0.); + if (Math.abs(s[ks]) <= tiny + eps*t) { + s[ks] = 0.0; + break; + } + } + if (ks == k) { + kase = 3; + } else if (ks == p-1) { + kase = 1; + } else { + kase = 2; + k = ks; + } + } + k++; + + // Perform the task indicated by kase. + + switch (kase) { + + // Deflate negligible s(p). + + case 1: { + double f = e[p-2]; + e[p-2] = 0.0; + for (int j = p-2; j >= k; j--) { + double t = hypot(s[j],f); + double cs = s[j]/t; + double sn = f/t; + s[j] = t; + if (j != k) { + f = -sn*e[j-1]; + e[j-1] = cs*e[j-1]; + } + if (wantv) { + for (int i = 0; i < n; i++) { + t = cs*V[i][j] + sn*V[i][p-1]; + V[i][p-1] = -sn*V[i][j] + cs*V[i][p-1]; + V[i][j] = t; + } + } + } + } + break; + + // Split at negligible s(k). + + case 2: { + double f = e[k-1]; + e[k-1] = 0.0; + for (int j = k; j < p; j++) { + double t = hypot(s[j],f); + double cs = s[j]/t; + double sn = f/t; + s[j] = t; + f = -sn*e[j]; + e[j] = cs*e[j]; + if (wantu) { + for (int i = 0; i < m; i++) { + t = cs*U[i][j] + sn*U[i][k-1]; + U[i][k-1] = -sn*U[i][j] + cs*U[i][k-1]; + U[i][j] = t; + } + } + } + } + break; + + // Perform one qr step. + + case 3: { + + // Calculate the shift. + + double scale = Math.max(Math.max(Math.max(Math.max( + Math.abs(s[p-1]),Math.abs(s[p-2])),Math.abs(e[p-2])), + Math.abs(s[k])),Math.abs(e[k])); + double sp = s[p-1]/scale; + double spm1 = s[p-2]/scale; + double epm1 = e[p-2]/scale; + double sk = s[k]/scale; + double ek = e[k]/scale; + double b = ((spm1 + sp)*(spm1 - sp) + epm1*epm1)/2.0; + double c = (sp*epm1)*(sp*epm1); + double shift = 0.0; + if ((b != 0.0) | (c != 0.0)) { + shift = Math.sqrt(b*b + c); + if (b < 0.0) { + shift = -shift; + } + shift = c/(b + shift); + } + double f = (sk + sp)*(sk - sp) + shift; + double g = sk*ek; + + // Chase zeros. + + for (int j = k; j < p-1; j++) { + double t = hypot(f,g); + double cs = f/t; + double sn = g/t; + if (j != k) { + e[j-1] = t; + } + f = cs*s[j] + sn*e[j]; + e[j] = cs*e[j] - sn*s[j]; + g = sn*s[j+1]; + s[j+1] = cs*s[j+1]; + if (wantv) { + for (int i = 0; i < n; i++) { + t = cs*V[i][j] + sn*V[i][j+1]; + V[i][j+1] = -sn*V[i][j] + cs*V[i][j+1]; + V[i][j] = t; + } + } + t = hypot(f,g); + cs = f/t; + sn = g/t; + s[j] = t; + f = cs*e[j] + sn*s[j+1]; + s[j+1] = -sn*e[j] + cs*s[j+1]; + g = sn*e[j+1]; + e[j+1] = cs*e[j+1]; + if (wantu && (j < m-1)) { + for (int i = 0; i < m; i++) { + t = cs*U[i][j] + sn*U[i][j+1]; + U[i][j+1] = -sn*U[i][j] + cs*U[i][j+1]; + U[i][j] = t; + } + } + } + e[p-2] = f; + iter = iter + 1; + } + break; + + // Convergence. + + case 4: { + + // Make the singular values positive. + + if (s[k] <= 0.0) { + s[k] = (s[k] < 0.0 ? -s[k] : 0.0); + if (wantv) { + for (int i = 0; i <= pp; i++) { + V[i][k] = -V[i][k]; + } + } + } + + // Order the singular values. + + while (k < pp) { + if (s[k] >= s[k+1]) { + break; + } + double t = s[k]; + s[k] = s[k+1]; + s[k+1] = t; + if (wantv && (k < n-1)) { + for (int i = 0; i < n; i++) { + t = V[i][k+1]; V[i][k+1] = V[i][k]; V[i][k] = t; + } + } + if (wantu && (k < m-1)) { + for (int i = 0; i < m; i++) { + t = U[i][k+1]; U[i][k+1] = U[i][k]; U[i][k] = t; + } + } + k++; + } + iter = 0; + p--; + } + break; + } + } + } + + /* ------------------------ + Public Methods + * ------------------------ */ + + /** Return the left singular vectors + @return U + */ + + public double[][] getU () { + return U; + } + + /** Return the right singular vectors + @return V + */ + + public double[][] getV () { + return V; + } + + /** Return the one-dimensional array of singular values + @return diagonal of S. + */ + + public double[] getSingularValues () { + return s; + } + + /** Return the diagonal matrix of singular values + @return S + */ + + public double[][] getS () { + double[][] S = new double[n][n]; + for (int i = 0; i < n; i++) { + S[i][i] = (double)this.s[i]; + } + return S; + } + + /** Two norm + * @return max(S) + */ + public double norm2 () { + return s[0]; + } + + /** Two norm condition number + @return max(S)/min(S) + */ + public double cond () { + return s[0]/s[Math.min(m,n)-1]; + } + + /** Effective numerical matrix rank + @return Number of nonnegligible singular values. + */ + + public int rank () { + double eps = Math.pow(2.0,-52.0); + double tol = Math.max(m,n)*s[0]*eps; + int r = 0; + for (int i = 0; i < s.length; i++) { + if (s[i] > tol) { + r++; + } + } + return r; + } + + /** sqrt(a^2 + b^2) without under/overflow. **/ + protected static double hypot(double a, double b) { + double r; + if (a*a > b*b) { + r = b/a; + r = Math.abs(a)*Math.sqrt(1+r*r); + } else if (b != 0) { + r = a/b; + r = Math.abs(b)*Math.sqrt(1+r*r); + } else { + r = 0.0; + } + return r; + } + +} + + + + + + + + diff --git a/drawing/papaya/src/papaya/ScatterPlot.java b/drawing/papaya/src/papaya/ScatterPlot.java new file mode 100644 index 0000000..ca9d365 --- /dev/null +++ b/drawing/papaya/src/papaya/ScatterPlot.java @@ -0,0 +1,205 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; +import java.util.Arrays; +import java.io.*; +import java.lang.Object; +import java.lang.String; + +import processing.core.*; + +/** + * A simple class to plot x vs y data as a + * scatter plot. Default is to draw the points as ellipses, + * but you can also use rectangles, and connect the points with + * lines. + * @author Adila Faruk + */ +public class ScatterPlot extends Visuals{ + public boolean asConnectedLines = false; + public boolean asRectangles = false; + public boolean asEllipses = true; + public boolean[] XYLabels = {true,true}; + public boolean[] XYTicks = {true,true}; + + /** + * Specifies whether to draw the bounding rectangle around the plot. + */ + public boolean drawRectangle = true; + /** + * Specifies whether to draw the axes + */ + public boolean drawAxes = true; + + protected PApplet myParent; + + /** + * Specifies the space on the left between the plot area, and the + * bounding rectangle. That is, the left-most point of + * the rectangle is given by plotLeft-leftBound. + */ + public float leftBound = 40; + /** + * Specifies the space on the right betweent the plot area, and the + * bounding rectangle. That is, the right-most point of + * the rectangle is given by plotLeft+plotWidth+rightBound. + */ + public float rightBound=20; + /** + * Specifies the space on the top, between the plot area and the bounding + * rectangle. That is, the top-most point of the rectangle is given by + * plotTop - topBound. + */ + public float topBound = 20; + /** + * Specifies the space on the bottom, between the plot area and the bounding + * rectangle. That is, the bottom-most point of the rectangle is given by + * plotTop + plotHeight + bottomBound. + */ + public float bottomBound=20; + //CENTER = 3; BOTTOM = 102; TOP = 101; BASELINE = 0; LEFT = 37; RIGHT = 39; + + protected float minX; + protected float minY; + protected float maxX; + protected float maxY; // plot min/max + protected float minXDat; + protected float minYDat; + protected float maxXDat; + protected float maxYDat; // data min/max + boolean dataExtremesHaveBeenSet=false; + + public ScatterPlot(PApplet _theParent, float _plotLeft, float _plotTop, float _plotWidth, float _plotHeight){ + super(_theParent,_plotLeft,_plotTop,_plotWidth,_plotHeight); + myParent = _theParent; + bgColor = super.bgColor; + } + + /** Set the minimum/maximum values on the x and y axis to nice numbers. + * e.g. 60 instead of 63.183628, 90 instead of 87.1, etc. + * It'll try do it automatically for you, if you don't set it here, + * but no guarantees on the result being a nice number. For example, it might + * go from 61 to 89 instead of 60 to 90. + * @param _minXDat the minimum x value to use. Set to more than the x data minimum. + * @param _maxXDat the maximum x value to use. Set to more than the x data maximum. + * @param _minYDat the minimum y value to use. Set to more than the y data minimum. + * @param _maxYDat the maximum y value to use. Set to more than the y data maximum. + */ + public void setDataExtremes(float _minXDat, float _maxXDat, float _minYDat, float _maxYDat){ + minXDat = _minXDat; maxXDat = _maxXDat; + minYDat = _minYDat; maxYDat = _maxYDat; + dataExtremesHaveBeenSet = true; + } + + /** + * Draws a rectangle around the plot. + *

      + *
    • Left most point: plotLeft-leftBound
      • + *
    • Top most point: plotTop-topBound
      • + *
    • Width: plotWidth+leftBound+rightBound
      • + *
    • Height: plotHeight+topBound+bottomBound
      • + *
    + */ + public void drawRectangle(){ + drawRect(plotLeft-leftBound,plotTop-topBound,plotWidth+leftBound+rightBound,plotHeight+topBound+bottomBound,bgColor); + } + + /** + * Parent function to plot scatter plot of the data. + * @param _xDat x Data array + * @param _yDat y Data array + * @param _sWeight stroke weight + * @param _sColor stroke color + */ + public void drawScatterPlot(float[] _xDat, float[] _yDat, float _sWeight, int _sColor){ + if(drawRectangle){ + drawRect(plotLeft-leftBound,plotTop-topBound,plotWidth+leftBound+rightBound,plotHeight+topBound+bottomBound,bgColor); + } + if(drawAxes){ + drawAxes(50,.5f); + } + + // Check if the data extemes have been set. + if(!dataExtremesHaveBeenSet){ + throw new IllegalStateException("Set the data extremes first."); + } + // map the data. + float[] xDatMapped = Mat.map(_xDat,minXDat,maxXDat,plotLeft,plotLeft+plotWidth); + float[] yDatMapped = Mat.map(_yDat,minYDat,maxYDat,plotTop+plotHeight,plotTop); + + + if(asConnectedLines){ + drawConnectedWithLines(xDatMapped,yDatMapped,_sWeight,_sColor); + } + if(asRectangles){ + drawAsRectangles(xDatMapped,yDatMapped,_sColor,10,6); + } + if(asEllipses){ + drawAsEllipses(xDatMapped,yDatMapped,_sColor,6); + } + } + + protected void drawScatterPlot(float[] _xDat, float[] _yDat){ + drawScatterPlot(_xDat,_yDat,STROKEWEIGHT[0],GRAY[0]); + } + + /** + * connects the dots + */ + protected void drawConnectedWithLines(float[] xDatMapped, float[] yDatMapped, float _sWeight, int _sColor){ + + myParent.noFill(); + myParent.stroke(_sColor); + myParent.strokeWeight(_sWeight); + + myParent.beginShape(); + for(int i=0; i + * For example, assume we have three arrays X, Y and Z. We want to sort all three arrays by + * X (or some arbitrary comparison function). For example, we have
    + * X={3, 2, 1}, Y={3.0, 1.0, 2.0}, Z={6.0, 7.0, 8.0}. The output should + * be + *
    + * X={1, 2, 3}, Y={2.0, 1.0, 3.0}, Z={8.0, 7.0, 6.0}    . + * To do this, we can use the indices corresponding to the elements of X sorted + * in ascending order: + *

    + * X={3,2,1} so indicesForSorting = {2,1,0} + * (X[2] holds the smallest value of X, + * X[1] holds the next smallest value of X, and X[0] + * holds the largest value of X). + * The indicesForSorting can then be used to arrange Y and Z + * in the same order. + * + *

    + * The algorithm used to obtain these indices is a modified version of the + * tuned quicksort proposed by Jon L. Bentley and M. Douglas McIlroy's "Engineering a + * Sort Function", Software-Practice and Experience, Vol. 23(11) + * P. 1249-1265 (November 1993) (program 7 of the paper; currently used in the Arrays.sort() method + * to sort arrays). + *

    It is a modified version in the sense that the original array remains unsorted. Instead, + * a copy of the original array is used in the sorting routine, and the array of + * indices [0,1,2,...N-1] sorted concurrently with the array being sorted. + * + * + * @author Adila Faruk + * + */ +public final class Sorting { + + /** + * Makes this class non instantiable, but still let's others inherit from it. + */ + protected Sorting(){} + + private static final int SMALL = 7; // params used in original paper + private static final int MEDIUM = 40; // params used in original paper + + /** + * Gets the array of indices that can be used to sort the array in ascending or + * descending order. + * + *

    + * The algorithm used to obtain these indices is a modified version of the + * tuned quicksort proposed by Jon L. Bentley and M. Douglas McIlroy's "Engineering a + * Sort Function", Software-Practice and Experience, Vol. 23(11) + * P. 1249-1265 (November 1993) (program 7 of the paper; currently used in the Arrays.sort() method + * to sort arrays). + *

    It is a modified version in the sense that the original array remains unsorted. Instead, + * a copy of the original array is used in the sorting routine, and the array of + * indices [0,1,2,...N-1] sorted concurrently with the array being sorted. + * + * @param a the input array + * @param isAscending true for data sorted in increasing order. + * @return integar array of indices (with length=data.length) that can be used + * to sort the data from low to high or vice-versa.. + * * @throws IllegalArgumentException if fromIndex > toIndex + * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or + * toIndex > a.length + * + * + */ + public static int[] indices(float[] a, boolean isAscending) { + return indices(a,0,a.length,isAscending); + } + public static int[] indices(double[] a, boolean isAscending) { + return indices(a,0,a.length,isAscending); + } + public static int[] indices(int[] a, boolean isAscending) { + return indices(a,0,a.length,isAscending); + } + /** + * Gets the array of indices that can be used to sort the section of the + * input array going from fromIndex(inclusive) to toIndex(exclusive) + * in ascending or descending order. + * + *

    + * The algorithm used to obtain these indices is a modified version of the + * tuned quicksort proposed by Jon L. Bentley and M. Douglas McIlroy's "Engineering a + * Sort Function", Software-Practice and Experience, Vol. 23(11) + * P. 1249-1265 (November 1993) (program 7 of the paper; currently used in the Arrays.sort() method + * to sort arrays). + *

    It is a modified version in the sense that the original array remains unsorted. Instead, + * a copy of the original array is used in the sorting routine, and the array of + * indices [fromIndex,fromIndex+1, ... , toIndex-1] sorted concurrently with the array being sorted. + * @param a the array to be sorted. + * @param fromIndex the index of the first element (inclusive) to be + * sorted. + * @param toIndex the index of the last element (exclusive) to be sorted. + * @param isAscending true for data sorted in increasing order. + * @throws IllegalArgumentException if fromIndex > toIndex + * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or + * toIndex > a.length + */ + public static int[] indices(float[] a, int fromIndex, int toIndex, boolean isAscending) { + rangeCheck(a.length, fromIndex, toIndex); + int lenToSort = toIndex-fromIndex; + //int[] indicesToSort = Mat.linspace(fromIndex, toIndex-1); + int[] indicesToSort = Mat.linspace(0,a.length-1); + float[] x = Arrays.copyOf(a,a.length); + quickSort1(x, indicesToSort, fromIndex, lenToSort, isAscending); + return indicesToSort; + } + public static int[] indices(double[] a, int fromIndex, int toIndex, boolean isAscending) { + rangeCheck(a.length, fromIndex, toIndex); + int lenToSort = toIndex-fromIndex; + //int[] indicesToSort = Mat.linspace(fromIndex, toIndex-1); + int[] indicesToSort = Mat.linspace(0,a.length-1); + double[] x = Arrays.copyOf(a,a.length); + quickSort1(x, indicesToSort, fromIndex, lenToSort, isAscending); + return indicesToSort; + } + public static int[] indices(int[] a, int fromIndex, int toIndex, boolean isAscending) { + rangeCheck(a.length, fromIndex, toIndex); + int lenToSort = toIndex-fromIndex; + //int[] indicesToSort = Mat.linspace(fromIndex, toIndex-1); + int[] indicesToSort = Mat.linspace(0,a.length-1); + int[] x = Arrays.copyOf(a,a.length); + quickSort1(x, indicesToSort, fromIndex, lenToSort, isAscending); + return indicesToSort; + } + + /** + * Sorts the input x and y arrays according to + * x and going from fromIndex(inclusive) to toIndex(exclusive) + * in ascending or descending order. + * + *

    + * The algorithm used to obtain these indices is a modified version of the + * tuned quicksort proposed by Jon L. Bentley and M. Douglas McIlroy's "Engineering a + * Sort Function", Software-Practice and Experience, Vol. 23(11) + * P. 1249-1265 (November 1993) (program 7 of the paper; currently used in the Arrays.sort() method + * to sort arrays). + *

    It is a modified version in the sense that two arrays are sorted according to the first + * array. At the end of the method, the section of both arrays going from + * fromIndex (inclusive) to toIndex(exclusive) are sorted according + * to the first array's order. Use a copy of both arrays if you want to preserve the natural order of + * the original arrays. + * @param x the array to sort. + * @param y the second array, to sort according to x. + * @param fromIndex the index of the first element (inclusive) to be + * sorted. + * @param toIndex the index of the last element (exclusive) to be sorted. + * @param isAscending true for data sorted in increasing order. + * @throws IllegalArgumentException if fromIndex > toIndex + * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or + * toIndex > a.length + * @see Arrays#sort(float[]) + */ + public static void twoArrays(float[] x, float[] y, int fromIndex, int toIndex, boolean isAscending) { + rangeCheck(x.length, fromIndex, toIndex); + int lenToSort = toIndex-fromIndex; + quickSort2(x, y, fromIndex, lenToSort, isAscending); + } + public static void twoArrays(double[] x, double[] y, int fromIndex, int toIndex, boolean isAscending) { + rangeCheck(x.length, fromIndex, toIndex); + int lenToSort = toIndex-fromIndex; + quickSort2(x, y, fromIndex, lenToSort, isAscending); + } + public static void twoArrays(int[] x, int[] y, int fromIndex, int toIndex, boolean isAscending) { + rangeCheck(x.length, fromIndex, toIndex); + int lenToSort = toIndex-fromIndex; + quickSort2(x, y, fromIndex, lenToSort, isAscending); + } + + /* Returns the index of the median of the three indexed floats */ + private static int med3(float x[], int a, int b, int c) { + // isAscending/Descending doesn't make a difference since + // we're getting the median + float ab = compare(x[a],x[b],true); + float ac = compare(x[a],x[c],true); + float bc = compare(x[b],x[c],true); + return (ab<0 ? + (bc<0 ? b : ac<0 ? c : a) : + (bc>0 ? b : ac>0 ? c : a)); + } + /* Returns the index of the median of the three indexed floats */ + private static int med3(double x[], int a, int b, int c) { + // isAscending/Descending doesn't make a difference since + // we're getting the median + double ab = compare(x[a],x[b],true); + double ac = compare(x[a],x[c],true); + double bc = compare(x[b],x[c],true); + return (ab<0 ? + (bc<0 ? b : ac<0 ? c : a) : + (bc>0 ? b : ac>0 ? c : a)); + } + /* Returns the index of the median of the three indexed floats */ + private static int med3(int x[], int a, int b, int c) { + // isAscending/Descending doesn't make a difference since + // we're getting the median + int ab = compare(x[a],x[b],true); + int ac = compare(x[a],x[c],true); + int bc = compare(x[b],x[c],true); + return (ab<0 ? + (bc<0 ? b : ac<0 ? c : a) : + (bc>0 ? b : ac>0 ? c : a)); + } + + /* compare(a,b) returns (a-b) if isAscending. else returns b-a*/ + private static void quickSort1(float[] x, int[] indices, int off, int len, boolean isAscending) { + //isAscendingnsertion sort on smallest arrays. (Checked, and works). + if (len < SMALL) { + for (int i=off; i x[j], swap the two + * so that the lower value (x[j]) is now at x[j-1]. + */ + for (int j=i; j>off && compare(x[j-1],x[j],isAscending)>0; j--){ + swap(x, j, j-1); + swap(indices, j, j-1); + } + } + return; + } + // Larger arrays: + // Choose a partition element, v that's the median of the array. + int m = off + len/2; // Small arrays, middle element + if (len > SMALL) { + int l = off; // start + int n = off + len - 1; // end + if (len > MEDIUM) { // Big arrays, pseudomedian of 9 + int s = len/8; + l = med3(x, l, l+s, l+2*s); + m = med3(x, m-s, m, m+s); + n = med3(x, n-2*s, n-s, n); + } + m = med3(x, l, m, n); // Mid-size, med of 3 + } + float v = x[m]; // the partition + + // Establish Invariant: v* (v)* v* (due to Sedgewick) + /* Index b scans up from the bottom of the array until it reaches a + * large element (greater than or equal to the partition value), + * c scans down until it reaches a small element. + * The two array elements are then swapped, and the scans continue until the pointers cross. + */ + int a = off, b = a, c = off + len - 1, d = c; + while(true) { + float comparison; + // while b < last index and x[b]<=x[median] + while (b <= c && (comparison=compare(x[b],v,isAscending))<=0) { + // if x[b]==x[median], x[start++]=x[b], x[b] = x[start++] + if (comparison == 0){ + swap(indices, a, b); + swap(x, a++, b); + } + // increment b + b++; + } + while (c >= b && (comparison=compare(x[c],v,isAscending))>=0) { + if (comparison == 0){ + swap(indices, c, d); + swap(x, c, d--); + } + c--; + } + /*At the end of the partitioning loop, b=c+1. + * Stop, and swap x[0] and x[j] */ + if (b > c) break; + swap(indices, b, c); + swap(x, b++, c--); + } + + // Swap partition elements back to middle + int s, n = off + len; + s = Math.min(a-off, b-a ); + vecswap(x, off, b-s, s); + vecswap(indices, off, b-s, s); + + s = Math.min(d-c, n-d-1); + vecswap(x, b, n-s, s); + vecswap(indices, b, n-s, s); + + + /* call quicksort recursively on the subarrays x[off]...x[b-a] + and x[end-(d-c)]...x[d-c] + */ + if ((s = b-a) > 1){ + quickSort1(x, indices, off, s, isAscending); + } + if ((s = d-c) > 1){ + quickSort1(x, indices, n-s, s, isAscending); + } + } + /* compare(a,b) returns (a-b) if isAscending. else returns b-a*/ + private static void quickSort2(float[] x, float[] y, int off, int len, boolean isAscending) { + //isAscendingnsertion sort on smallest arrays. (Checked, and works). + if (len < SMALL) { + for (int i=off; i x[j], swap the two + * so that the lower value (x[j]) is now at x[j-1]. + */ + for (int j=i; j>off && compare(x[j-1],x[j],isAscending)>0; j--){ + swap(x, j, j-1); + swap(y, j, j-1); + } + } + return; + } + // Larger arrays: + // Choose a partition element, v that's the median of the array. + int m = off + len/2; // Small arrays, middle element + if (len > SMALL) { + int l = off; // start + int n = off + len - 1; // end + if (len > MEDIUM) { // Big arrays, pseudomedian of 9 + int s = len/8; + l = med3(x, l, l+s, l+2*s); + m = med3(x, m-s, m, m+s); + n = med3(x, n-2*s, n-s, n); + } + m = med3(x, l, m, n); // Mid-size, med of 3 + } + float v = x[m]; // the partition + + // Establish Invariant: v* (v)* v* (due to Sedgewick) + /* Index b scans up from the bottom of the array until it reaches a + * large element (greater than or equal to the partition value), + * c scans down until it reaches a small element. + * The two array elements are then swapped, and the scans continue until the pointers cross. + */ + int a = off, b = a, c = off + len - 1, d = c; + while(true) { + float comparison; + // while b < last index and x[b]<=x[median] + while (b <= c && (comparison=compare(x[b],v,isAscending))<=0) { + // if x[b]==x[median], x[start++]=x[b], x[b] = x[start++] + if (comparison == 0){ + swap(y, a, b); + swap(x, a++, b); + } + // increment b + b++; + } + while (c >= b && (comparison=compare(x[c],v,isAscending))>=0) { + if (comparison == 0){ + swap(y, c, d); + swap(x, c, d--); + } + c--; + } + /*At the end of the partitioning loop, b=c+1. + * Stop, and swap x[0] and x[j] */ + if (b > c) break; + swap(y, b, c); + swap(x, b++, c--); + } + + // Swap partition elements back to middle + int s, n = off + len; + s = Math.min(a-off, b-a ); + vecswap(x, off, b-s, s); + vecswap(y, off, b-s, s); + + s = Math.min(d-c, n-d-1); + vecswap(x, b, n-s, s); + vecswap(y, b, n-s, s); + + + /* call quicksort recursively on the subarrays x[off]...x[b-a] + and x[end-(d-c)]...x[d-c] + */ + if ((s = b-a) > 1){ + quickSort2(x, y, off, s, isAscending); + } + if ((s = d-c) > 1){ + quickSort2(x, y, n-s, s, isAscending); + } + } + + /* compare(a,b) returns (a-b) if isAscending. else returns b-a*/ + private static void quickSort1(int[] x, int[] indices, int off, int len, boolean isAscending) { + //isAscendingnsertion sort on smallest arrays. (Checked, and works). + if (len < SMALL) { + for (int i=off; i x[j], swap the two + * so that the lower value (x[j]) is now at x[j-1]. + */ + for (int j=i; j>off && compare(x[j-1],x[j],isAscending)>0; j--){ + swap(x, j, j-1); + swap(indices, j, j-1); + } + } + return; + } + // Larger arrays: + // Choose a partition element, v that's the median of the array. + int m = off + len/2; // Small arrays, middle element + if (len > SMALL) { + int l = off; // start + int n = off + len - 1; // end + if (len > MEDIUM) { // Big arrays, pseudomedian of 9 + int s = len/8; + l = med3(x, l, l+s, l+2*s); + m = med3(x, m-s, m, m+s); + n = med3(x, n-2*s, n-s, n); + } + m = med3(x, l, m, n); // Mid-size, med of 3 + } + int v = x[m]; // the partition + + // Establish Invariant: v* (v)* v* (due to Sedgewick) + /* Index b scans up from the bottom of the array until it reaches a + * large element (greater than or equal to the partition value), + * c scans down until it reaches a small element. + * The two array elements are then swapped, and the scans continue until the pointers cross. + */ + int a = off, b = a, c = off + len - 1, d = c; + while(true) { + int comparison; + // while b < last index and x[b]<=x[median] + while (b <= c && (comparison=compare(x[b],v,isAscending))<=0) { + // if x[b]==x[median], x[start++]=x[b], x[b] = x[start++] + if (comparison == 0){ + swap(indices, a, b); + swap(x, a++, b); + } + // increment b + b++; + } + while (c >= b && (comparison=compare(x[c],v,isAscending))>=0) { + if (comparison == 0){ + swap(indices, c, d); + swap(x, c, d--); + } + c--; + } + /*At the end of the partitioning loop, b=c+1. + * Stop, and swap x[0] and x[j] */ + if (b > c) break; + swap(indices, b, c); + swap(x, b++, c--); + } + + // Swap partition elements back to middle + int s, n = off + len; + s = Math.min(a-off, b-a ); + vecswap(x, off, b-s, s); + vecswap(indices, off, b-s, s); + + s = Math.min(d-c, n-d-1); + vecswap(x, b, n-s, s); + vecswap(indices, b, n-s, s); + + + /* call quicksort recursively on the subarrays x[off]...x[b-a] + and x[end-(d-c)]...x[d-c] + */ + if ((s = b-a) > 1){ + quickSort1(x, indices, off, s, isAscending); + } + if ((s = d-c) > 1){ + quickSort1(x, indices, n-s, s, isAscending); + } + } + /* compare(a,b) returns (a-b) if isAscending. else returns b-a*/ + private static void quickSort2(int[] x, int[] y, int off, int len, boolean isAscending) { + //isAscendingnsertion sort on smallest arrays. (Checked, and works). + if (len < SMALL) { + for (int i=off; i x[j], swap the two + * so that the lower value (x[j]) is now at x[j-1]. + */ + for (int j=i; j>off && compare(x[j-1],x[j],isAscending)>0; j--){ + swap(x, j, j-1); + swap(y, j, j-1); + } + } + return; + } + // Larger arrays: + // Choose a partition element, v that's the median of the array. + int m = off + len/2; // Small arrays, middle element + if (len > SMALL) { + int l = off; // start + int n = off + len - 1; // end + if (len > MEDIUM) { // Big arrays, pseudomedian of 9 + int s = len/8; + l = med3(x, l, l+s, l+2*s); + m = med3(x, m-s, m, m+s); + n = med3(x, n-2*s, n-s, n); + } + m = med3(x, l, m, n); // Mid-size, med of 3 + } + int v = x[m]; // the partition + + // Establish Invariant: v* (v)* v* (due to Sedgewick) + /* Index b scans up from the bottom of the array until it reaches a + * large element (greater than or equal to the partition value), + * c scans down until it reaches a small element. + * The two array elements are then swapped, and the scans continue until the pointers cross. + */ + int a = off, b = a, c = off + len - 1, d = c; + while(true) { + int comparison; + // while b < last index and x[b]<=x[median] + while (b <= c && (comparison=compare(x[b],v,isAscending))<=0) { + // if x[b]==x[median], x[start++]=x[b], x[b] = x[start++] + if (comparison == 0){ + swap(y, a, b); + swap(x, a++, b); + } + // increment b + b++; + } + while (c >= b && (comparison=compare(x[c],v,isAscending))>=0) { + if (comparison == 0){ + swap(y, c, d); + swap(x, c, d--); + } + c--; + } + /*At the end of the partitioning loop, b=c+1. + * Stop, and swap x[0] and x[j] */ + if (b > c) break; + swap(y, b, c); + swap(x, b++, c--); + } + + // Swap partition elements back to middle + int s, n = off + len; + s = Math.min(a-off, b-a ); + vecswap(x, off, b-s, s); + vecswap(y, off, b-s, s); + + s = Math.min(d-c, n-d-1); + vecswap(x, b, n-s, s); + vecswap(y, b, n-s, s); + + + /* call quicksort recursively on the subarrays x[off]...x[b-a] + and x[end-(d-c)]...x[d-c] + */ + if ((s = b-a) > 1){ + quickSort2(x, y, off, s, isAscending); + } + if ((s = d-c) > 1){ + quickSort2(x, y, n-s, s, isAscending); + } + } + /* compare(a,b) returns (a-b) if isAscending. else returns b-a*/ + private static void quickSort1(double[] x, int[] indices, int off, int len, boolean isAscending) { + //isAscendingnsertion sort on smallest arrays. (Checked, and works). + if (len < SMALL) { + for (int i=off; i x[j], swap the two + * so that the lower value (x[j]) is now at x[j-1]. + */ + for (int j=i; j>off && compare(x[j-1],x[j],isAscending)>0; j--){ + swap(x, j, j-1); + swap(indices, j, j-1); + } + } + return; + } + // Larger arrays: + // Choose a partition element, v that's the median of the array. + int m = off + len/2; // Small arrays, middle element + if (len > SMALL) { + int l = off; // start + int n = off + len - 1; // end + if (len > MEDIUM) { // Big arrays, pseudomedian of 9 + int s = len/8; + l = med3(x, l, l+s, l+2*s); + m = med3(x, m-s, m, m+s); + n = med3(x, n-2*s, n-s, n); + } + m = med3(x, l, m, n); // Mid-size, med of 3 + } + double v = x[m]; // the partition + + // Establish Invariant: v* (v)* v* (due to Sedgewick) + /* Index b scans up from the bottom of the array until it reaches a + * large element (greater than or equal to the partition value), + * c scans down until it reaches a small element. + * The two array elements are then swapped, and the scans continue until the pointers cross. + */ + int a = off, b = a, c = off + len - 1, d = c; + while(true) { + double comparison; + // while b < last index and x[b]<=x[median] + while (b <= c && (comparison=compare(x[b],v,isAscending))<=0) { + // if x[b]==x[median], x[start++]=x[b], x[b] = x[start++] + if (comparison == 0){ + swap(indices, a, b); + swap(x, a++, b); + } + // increment b + b++; + } + while (c >= b && (comparison=compare(x[c],v,isAscending))>=0) { + if (comparison == 0){ + swap(indices, c, d); + swap(x, c, d--); + } + c--; + } + /*At the end of the partitioning loop, b=c+1. + * Stop, and swap x[0] and x[j] */ + if (b > c) break; + swap(indices, b, c); + swap(x, b++, c--); + } + + // Swap partition elements back to middle + int s, n = off + len; + s = Math.min(a-off, b-a ); + vecswap(x, off, b-s, s); + vecswap(indices, off, b-s, s); + + s = Math.min(d-c, n-d-1); + vecswap(x, b, n-s, s); + vecswap(indices, b, n-s, s); + + + /* call quicksort recursively on the subarrays x[off]...x[b-a] + and x[end-(d-c)]...x[d-c] + */ + if ((s = b-a) > 1){ + quickSort1(x, indices, off, s, isAscending); + } + if ((s = d-c) > 1){ + quickSort1(x, indices, n-s, s, isAscending); + } + } + /* compare(a,b) returns (a-b) if isAscending. else returns b-a*/ + private static void quickSort2(double[] x, double[] y, int off, int len, boolean isAscending) { + //isAscendingnsertion sort on smallest arrays. (Checked, and works). + if (len < SMALL) { + for (int i=off; i x[j], swap the two + * so that the lower value (x[j]) is now at x[j-1]. + */ + for (int j=i; j>off && compare(x[j-1],x[j],isAscending)>0; j--){ + swap(x, j, j-1); + swap(y, j, j-1); + } + } + return; + } + // Larger arrays: + // Choose a partition element, v that's the median of the array. + int m = off + len/2; // Small arrays, middle element + if (len > SMALL) { + int l = off; // start + int n = off + len - 1; // end + if (len > MEDIUM) { // Big arrays, pseudomedian of 9 + int s = len/8; + l = med3(x, l, l+s, l+2*s); + m = med3(x, m-s, m, m+s); + n = med3(x, n-2*s, n-s, n); + } + m = med3(x, l, m, n); // Mid-size, med of 3 + } + double v = x[m]; // the partition + + // Establish Invariant: v* (v)* v* (due to Sedgewick) + /* Index b scans up from the bottom of the array until it reaches a + * large element (greater than or equal to the partition value), + * c scans down until it reaches a small element. + * The two array elements are then swapped, and the scans continue until the pointers cross. + */ + int a = off, b = a, c = off + len - 1, d = c; + while(true) { + double comparison; + // while b < last index and x[b]<=x[median] + while (b <= c && (comparison=compare(x[b],v,isAscending))<=0) { + // if x[b]==x[median], x[start++]=x[b], x[b] = x[start++] + if (comparison == 0){ + swap(y, a, b); + swap(x, a++, b); + } + // increment b + b++; + } + while (c >= b && (comparison=compare(x[c],v,isAscending))>=0) { + if (comparison == 0){ + swap(y, c, d); + swap(x, c, d--); + } + c--; + } + /*At the end of the partitioning loop, b=c+1. + * Stop, and swap x[0] and x[j] */ + if (b > c) break; + swap(y, b, c); + swap(x, b++, c--); + } + + // Swap partition elements back to middle + int s, n = off + len; + s = Math.min(a-off, b-a ); + vecswap(x, off, b-s, s); + vecswap(y, off, b-s, s); + + s = Math.min(d-c, n-d-1); + vecswap(x, b, n-s, s); + vecswap(y, b, n-s, s); + + + /* call quicksort recursively on the subarrays x[off]...x[b-a] + and x[end-(d-c)]...x[d-c] + */ + if ((s = b-a) > 1){ + quickSort2(x, y, off, s, isAscending); + } + if ((s = d-c) > 1){ + quickSort2(x, y, n-s, s, isAscending); + } + } + + /** Ensures that sgn(compare(x, y)) == + * -sgn(compare(y, x)) for all x and y. (This + * implies that compare(x, y) must throw an exception if and only + * if compare(y, x) throws an exception.)

    + * + * The implementor must also ensure that the relation is transitive: + * ((compare(x, y)>0) && (compare(y, z)>0)) implies + * compare(x, z)>0.

    + * + * Finally, the implementer must ensure that compare(x, y)==0 + * implies that sgn(compare(x, z))==sgn(compare(y, z)) for all + * z.

    + * + */ + private static float compare(float value1, float value2, boolean isAscending) { + if (isAscending) return value1 - value2; + return value2 - value1; + } + private static double compare(double value1, double value2, boolean isAscending) { + if (isAscending) return value1 - value2; + return value2 - value1; + } + private static int compare(int value1, int value2, boolean isAscending) { + if (isAscending) return value1 - value2; + return value2 - value1; + } + /** Swaps x[a] with x[b]. */ + private static void swap(float x[], int a, int b) { + float t = x[a]; x[a] = x[b]; x[b] = t; + } + /** Swaps x[a] with x[b]. */ + private static void swap(double x[], int a, int b) { + double t = x[a]; x[a] = x[b]; x[b] = t; + } + /** Swaps x[a] with x[b]. */ + private static void swap(int x[], int a, int b) { + int t = x[a]; x[a] = x[b]; x[b] = t; + } + + /** Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)].*/ + private static void vecswap(float x[], int a, int b, int n) { + for (int i=0; i toIndex) + throw new IllegalArgumentException("fromIndex(" + fromIndex + + ") > toIndex(" + toIndex+")"); + if (fromIndex < 0) + throw new ArrayIndexOutOfBoundsException("from index: "+fromIndex); + if (toIndex > arrayLen) + throw new ArrayIndexOutOfBoundsException("to index: "+toIndex); + } +} diff --git a/drawing/papaya/src/papaya/SubPlot.java b/drawing/papaya/src/papaya/SubPlot.java new file mode 100644 index 0000000..1ad1d1b --- /dev/null +++ b/drawing/papaya/src/papaya/SubPlot.java @@ -0,0 +1,192 @@ +/** + * papaya: A collection of utilities for Statistics and Matrix-related manipulations + * http://adilapapaya.com/papayastatistics/, 1.1.0 + * Created by Adila Faruk, http://adilapapaya.com, May 2012, Last Updated April 2014 + * + * + * Copyright (C) 2014 Adila Faruk http://adilapapaya.com + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + */ +package papaya; +import java.util.Arrays; +import java.io.*; +import java.lang.Object; +import java.lang.String; + +import processing.core.*; + +/** + * Convenient class for drawing multiple scatter plots. + * @author Adila Faruk + */ +public class SubPlot extends Visuals { + + /** + * Specifies whether to draw the bounding rectangle around the plot. + */ + public boolean drawRectangle = false; + /** + * Specifies whether to draw the axes + */ + public boolean drawAxes = true; + + /** + * Specifies the space on the left between the plot area, and the + * bounding rectangle. That is, the left-most point of + * the rectangle is given by plotLeft-leftBound. + */ + public float leftBound = 40; + /** + * Specifies the space on the right betweent the plot area, and the + * bounding rectangle. That is, the right-most point of + * the rectangle is given by plotLeft+plotWidth+rightBound. + */ + public float rightBound=20; + /** + * Specifies the space on the top, between the plot area and the bounding + * rectangle. That is, the top-most point of the rectangle is given by + * plotTop - topBound. + */ + public float topBound = 20; + /** + * Specifies the space on the bottom, between the plot area and the bounding + * rectangle. That is, the bottom-most point of the rectangle is given by + * plotTop + plotHeight + bottomBound. + */ + public float bottomBound=20; + + + private PApplet myParent; + + + //CENTER = 3; BOTTOM = 102; TOP = 101; BASELINE = 0; LEFT = 37; RIGHT = 39; + + + boolean dataExtremesHaveBeenSet=false; + public float[][] xLefts; public float[][] yTops; + public float xW; public float yH; + public float ySpacing = 80; + public float xSpacing = 100; + public ScatterPlot[][] s; + + + /** + Creates numX*numY plots, each of with xWidth, and height yHeight. + subplot(1,1) has its top left corner situated at xLeft, yTop. + subplot(1,2) has its top left corner situated at xLeft, yTop + yHeight + yInterval. + ... + ... + subplot(1,numY) has its top left corner situated at xLeft, yTop + (numY-1)*(yHeight+ySpacing) + + */ + public SubPlot(PApplet theParent, float xLeft, float yTop, float xWidth, float yHeight, int numX, int numY) { + super(theParent,xLeft,yTop,xWidth,yHeight); + myParent = theParent; + xLefts = new float[numX][numY]; + yTops = new float[numX][numY]; + s = new ScatterPlot[numX][numY]; + + // get the x and y spacing. + yH = (yHeight - (numY-1)*ySpacing)/numY; + xW = (xWidth-(numX-1)*xSpacing)/numX; + + for (int i=0; iunsorted array's unique elements, + * the indices of these elements, and the number of times the elements occur. + *

    This class is overkill if: + *
    + * you want to store only the unique elements. Use a Java + * Set instead. + *
    + * you don't want to store everything in a class. Use the + * {@link Descriptive#frequencies} method instead. + */ +public class Unique { + + /** + * ArrayList containing the unique values + */ + public ArrayList values = new ArrayList(); + /** + * ArrayList containing the frequencies of the corresponding unique value + */ + public ArrayList frequencies = new ArrayList(); + /** + * Class containing the integer arrays that hold the indices of each unique value. + */ + public int[][] idx; + + /** + * Class for storing the unique values in an unsorted data array. Does essentially the same + * thing as the Descriptive.frequencies method would, except: + *


    + * - The input data array is unsorted. + *
    + *
    + * - You can choose to store the indices of each unique value as well by setting the @param storeIndices + * to true. + *
    + *
    + * - It (currently) only works for float arrays. + *
    + *

    Example:

    + *

    + * data = (8,5,6,7,8,5,5) --> values = (5,6,7,8), frequencies = (3,1,1,2), + * idx[0] = {1,5,6}, idx[1] = {2}, idx[2] = {3}, idx[3] = {0,4} + *

    + * + * @param data the data array + * @param storeIndices set to true if you want to store the indices, + * else set to false + * It: + *
    + * 1. Contains some useful functions for the visual representation + * of your data (e.g. setting up your font, writing labels, mapping + * arrays to the plot right-left-top-bottom parameters, xTicks, yTicks, + * etc.) that should help you reduce the amount of code you end up + * writing. + *
    + * 2. Is extended by the available "Plotting" classes used to quickly give a + * visual snapshot of your data. + *

    + * + */ + +public class Visuals implements PapayaConstants{ + + /* + * Processing applet + */ + protected PApplet myParent; + + PFont plotFont = new PFont(); + + + // protected variables ------------------------------------------- + // can be set only using get/set methods + // or in the constructor + + protected float plotLeft=10; + protected float plotWidth=180; + + protected float plotTop=10; + protected float plotHeight=180; + + /** + * Specifies the plot background color + */ + public int bgColor = GRAY[4]; + + //CENTER = 3; BOTTOM = 102; TOP = 101; BASELINE = 0; LEFT = 37; RIGHT = 39; + + /** The parent class behind the other plotting classes. + * + *

    + * Visuals contains some useful functions for the (elementary!) visual representation + * of your data (e.g. setting up your font, writing labels, mapping + * arrays to the plot right-left-top-bottom parameters, xTicks, yTicks,legends, + * etc). Nothing very fancy like writing x-labels at an angle or computing your + * tax returns for you though so don't get your hopes up. Sorry. + * + * + * @param _theParent the Processing papplet. Just "this" in your sketch. + * @param _plotLeft the plot left + * @param _plotTop the plot top (in Processing coordinates!) + * @param _plotWidth the plot width + * @param _plotHeight the plot height. + *

    The bottom of the plot area is then given by _plotTop + _plotHeight + * while the right is _plotLeft + _plotWidth.

    + */ + public Visuals(PApplet _theParent, float _plotLeft, float _plotTop, float _plotWidth, float _plotHeight){ + myParent = _theParent; + plotLeft = _plotLeft; + plotWidth = _plotWidth; + plotTop = _plotTop; + plotHeight = _plotHeight; + plotFont = myParent.createFont(FONTNAME,12f,true); + } + + /** + * Maps the x-data from the range min(data) to max(data) to + * the plotLeft and plotLeft+plotWidth. That is, + * mappedData[i] = plotLeft + (data[i] - min) / (max-min) * plotWidth. + * This is not done directly though, but rather, the + * {@link Mat#map(float[] data, float low1, float high1, float low2, float high2)} + * function is used. + * @param data the x data to map. + * @return the mapped data. + */ + public float[] mapXData(float[] data){ + float min = Descriptive.min(data); + float max = Descriptive.max(data); + return Mat.map( data,min,max,plotLeft,plotLeft + plotWidth); + } + /** + * Maps the x-data from the range minXDat to maxXDat to + * the plotLeft and plotRight. That is, + * mappedData[i] = plotLeft + (data[i] - minXDat) / (maxXDat-minXDat) * plotWidth. + * This is not done directly though, but rather, the + * {@link Mat#map(float[] data, float low1, float high1, float low2, float high2)} + * function is used. + *

    + * Note: No internal checks are done to make sure that the min/max values are in the + * data range. + *

    + * + * @param data the x data to map. + * @param minXDat the minimum value to use in the data mapping. + * @param maxXDat the maximum value to use in the data mapping. + * @return the mapped data. + */ + public float[] mapXData(float[] data, float minXDat, float maxXDat){ + return Mat.map( data,minXDat,maxXDat,plotLeft,plotLeft + plotWidth); + } + + /** + * Maps the y-data from the range min(data) to max(data) to + * the plotBottom and plotTop. That is, + * mappedData[i] = plotBottom + (data[i] - min) / (max-min) * (-plotHeight). + * (The minus sign above accounts for the difference in Processing's coordinate system + * and what we associate with Top/Bottom). + * The computation above is not done directly though, but rather, the + * {@link Mat#map(float[] data, float low1, float high1, float low2, float high2)} + * function is used. + * @param data the y data to map. + * @return the mapped data. + */ + public float[] mapYData(float[] data){ + float min = Descriptive.min(data); + float max = Descriptive.max(data); + return Mat.map( data, min, max, plotTop + plotHeight, plotTop); + } + + /** + * Maps the y-data from the range minYDat to maxYDat to + * the plotBottom and plotTop. That is, + * mappedData[i] = plotBottom + (data[i] - minYDat) / (maxYDat-minYDat) * (-plotHeight). + * (The minus sign above accounts for the difference in Processing's coordinate system + * and what we associate with Top/Bottom). + * The computation above is not done directly though, but rather, the + * {@link Mat#map(float[] data, float low1, float high1, float low2, float high2)} + * function is used. + *

    + * Note: No internal checks are done to make sure that the min/max values are in the + * data range. + *

    + * + * @param data the x data to map. + * @param minYDat the minimum value to use in the data mapping. + * @param maxYDat the maximum value to use in the data mapping. + * @return the mapped data. + */ + public float[] mapYData(float[] data, float minYDat, float maxYDat){ + return Mat.map( data,minYDat,maxYDat,plotTop + plotHeight, plotTop); + } + + + /** + * Draws the plot axes using a line with color _sColor, and weight _sWeight + */ + public void drawAxes(int _sColor, float _sWeight){ + horizLine(plotLeft,plotLeft+plotWidth,plotTop+plotHeight,_sColor,_sWeight); + vertLine(plotTop,plotTop+plotHeight,plotLeft,_sColor,_sWeight); + } + + /** + * Draw the plot background rectangle using the default plot + * dimensions and background color. + * + *
  • Left most point: plotLeft
    • + *
  • Top most point: plotTop
    • + *
  • Width: plotWidth
    • + *
  • Height: plotHeight
    • + * + */ + public void drawRect(){ + drawRect(plotLeft,plotTop,plotWidth,plotHeight,bgColor); + } + + /** + * Draws the plot background rectangle using the input dimensions and + * background color. + * @param _left the left-most point of the rectangle + * @param _top the top-most point of the rectangle + * @param _width the width of the rectangle + * @param _height the height of the rectangle + * @param _rectColor the rectangle color. + */ + public void drawRect(float _left,float _top,float _width,float _height, int _rectColor){ + myParent.stroke(150); + myParent.strokeWeight(.5f); + myParent.fill(_rectColor); + myParent.pushStyle(); + myParent.rectMode(CORNER); + myParent.rect(_left,_top,_width,_height); + myParent.popStyle(); + } + + /** + * Draws a legend going downwards with the first element situated at (x,y). + * Useful for situations where you are plotting more than one dataset. + * + * @param colors the legend colors + * @param labels labels that go with each color + */ + public void legendVert(float x, float y, int[] colors, String[] labels){ + int num = labels.length; + if(num != colors.length) throw new IllegalArgumentException("The label and color arrays have different lengths"); + + myParent.textAlign(LEFT,TOP); + + for(int i=0; i