/*
|
* Licensed to the Apache Software Foundation (ASF) Under one or more
|
* contributor license agreements. See the NOTICE file distributed with
|
* this work for Additional information regarding copyright ownership.
|
* The ASF licenses this file to You Under the Apache License, Version 2.0
|
* (the "License"); you may not use this file except in compliance with
|
* the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed Under the License is distributed on an "AS Is" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations Under the License.
|
*/
|
/*
|
* Created on May 30, 2005
|
*
|
*/
|
namespace HH.WMS.Utils.NPOI.SS.Formula.Functions
|
{
|
using HH.WMS.Utils.NPOI.Util;
|
using System;
|
|
/**
|
* @author Amol S. Deshmukh < amolweb at ya hoo dot com >
|
*
|
* Library for common statistics functions
|
*/
|
public class StatsLib
|
{
|
|
private StatsLib() { }
|
|
|
/**
|
* returns the mean of deviations from mean.
|
* @param v
|
*/
|
public static double avedev(double[] v)
|
{
|
double r = 0;
|
double m = 0;
|
double s = 0;
|
for (int i = 0, iSize = v.Length; i < iSize; i++)
|
{
|
s += v[i];
|
}
|
m = s / v.Length;
|
s = 0;
|
for (int i = 0, iSize = v.Length; i < iSize; i++)
|
{
|
s += Math.Abs(v[i] - m);
|
}
|
r = s / v.Length;
|
return r;
|
}
|
|
public static double stdev(double[] v)
|
{
|
double r = double.NaN;
|
if (v != null && v.Length > 1)
|
{
|
r = Math.Sqrt(devsq(v) / (v.Length - 1));
|
}
|
return r;
|
}
|
public static double var(double[] v)
|
{
|
double r = Double.NaN;
|
if (v != null && v.Length > 1)
|
{
|
r = devsq(v) / (v.Length - 1);
|
}
|
return r;
|
}
|
|
public static double varp(double[] v)
|
{
|
double r = Double.NaN;
|
if (v != null && v.Length > 1)
|
{
|
r = devsq(v) / v.Length;
|
}
|
return r;
|
}
|
/**
|
* if v Is zero Length or Contains no duplicates, return value
|
* Is double.NaN. Else returns the value that occurs most times
|
* and if there Is a tie, returns the first such value.
|
* @param v
|
*/
|
public static double mode(double[] v)
|
{
|
double r = double.NaN;
|
|
// very naive impl, may need to be optimized
|
if (v != null && v.Length > 1)
|
{
|
int[] Counts = new int[v.Length];
|
Arrays.Fill(Counts, 1);
|
for (int i = 0, iSize = v.Length; i < iSize; i++)
|
{
|
for (int j = i + 1, jSize = v.Length; j < jSize; j++)
|
{
|
if (v[i] == v[j]) Counts[i]++;
|
}
|
}
|
double maxv = 0;
|
int maxc = 0;
|
for (int i = 0, iSize = Counts.Length; i < iSize; i++)
|
{
|
if (Counts[i] > maxc)
|
{
|
maxv = v[i];
|
maxc = Counts[i];
|
}
|
}
|
r = (maxc > 1) ? maxv : double.NaN; // "no-dups" Check
|
}
|
return r;
|
}
|
|
public static double median(double[] v)
|
{
|
double r = double.NaN;
|
|
if (v != null && v.Length >= 1)
|
{
|
int n = v.Length;
|
Array.Sort(v);
|
r = (n % 2 == 0)
|
? (v[n / 2] + v[n / 2 - 1]) / 2
|
: v[n / 2];
|
}
|
|
return r;
|
}
|
|
|
public static double devsq(double[] v)
|
{
|
double r = double.NaN;
|
if (v != null && v.Length >= 1)
|
{
|
double m = 0;
|
double s = 0;
|
int n = v.Length;
|
for (int i = 0; i < n; i++)
|
{
|
s += v[i];
|
}
|
m = s / n;
|
s = 0;
|
for (int i = 0; i < n; i++)
|
{
|
s += (v[i] - m) * (v[i] - m);
|
}
|
|
r = (n == 1)
|
? 0
|
: s;
|
}
|
return r;
|
}
|
|
/*
|
* returns the kth largest element in the array. Duplicates
|
* are considered as distinct values. Hence, eg.
|
* for array {1,2,4,3,3} & k=2, returned value Is 3.
|
* <br/>
|
* k <= 0 & k >= v.Length and null or empty arrays
|
* will result in return value double.NaN
|
* @param v
|
* @param k
|
*/
|
public static double kthLargest(double[] v, int k)
|
{
|
double r = double.NaN;
|
k--; // since arrays are 0-based
|
if (v != null && v.Length > k && k >= 0)
|
{
|
Array.Sort(v);
|
r = v[v.Length - k - 1];
|
}
|
return r;
|
}
|
|
/*
|
* returns the kth smallest element in the array. Duplicates
|
* are considered as distinct values. Hence, eg.
|
* for array {1,1,2,4,3,3} & k=2, returned value Is 1.
|
* <br/>
|
* k <= 0 & k >= v.Length or null array or empty array
|
* will result in return value double.NaN
|
* @param v
|
* @param k
|
*/
|
public static double kthSmallest(double[] v, int k)
|
{
|
double r = double.NaN;
|
k--; // since arrays are 0-based
|
if (v != null && v.Length > k && k >= 0)
|
{
|
Array.Sort(v);
|
r = v[k];
|
}
|
return r;
|
}
|
}
|
}
|
