room101/MATH.CPP

#include "math.hpp"
#include "memory.hpp"

/*******************************************************************************
** DoubleGreaterThan
*******************************************************************************/
int
DoubleGreaterThan(const void* A, const void* B)
{
   return *((float*)A) > *((float*)B);
}
/*******************************************************************************
** TableCreate
*******************************************************************************/
float*
TableCreate(int n)
{
   return (float*)calloc(n, sizeof(float));
}
/*******************************************************************************
** TableDelete
*******************************************************************************/
void
TableDelete(float* table)
{
   free(table);
}
/*******************************************************************************
** TableCopy
*******************************************************************************/
float*
TableCopy(float* dst, float* src, int n)
{
   return (float*)memmove(dst, src, n * sizeof(float));
}
/*******************************************************************************
** TableDuplicate
*******************************************************************************/
float*
TableDuplicate(float* src, int n)
{
   return TableCopy(TableCreate(n), src, n);
}
/*******************************************************************************
** TableSort
*******************************************************************************/
float*
TableSort(float* table, int n)
{
   qsort(table, n, sizeof(float), DoubleGreaterThan);
   return table;
}
/*******************************************************************************
** TableLocate
*******************************************************************************/
float
TableLocate(float* table, int n, float scale)
{
   float* temp = TableSort(TableDuplicate(table, n), n);
   int pos = (n + 1) * scale;
   float result = (temp[pos - 1] + temp[pos]) * 0.5;
   TableDelete(temp);
   return result;
}
/*******************************************************************************
** TableQuartile
*******************************************************************************/
float
TableQuartile(float* table, int n, int quartile)
{
   return TableLocate(table, n, quartile / 4.0);
}
/*******************************************************************************
** TableInterquartileRange
*******************************************************************************/
float
TableInterquartileRange(float* table, int n)
{
   return TableQuartile(table, n, 3) - TableQuartile(table, n, 1);
}
/*******************************************************************************
** TableMedian
*******************************************************************************/
float
TableMedian(float* table, int n)
{
   return TableLocate(table, n, 0.5);
}
/*******************************************************************************
** TableSum
*******************************************************************************/
float
TableSum(float* table, int n)
{
   float result = 0.0;

   while (n--) result += table[n];   
   
   return result;
}
/*******************************************************************************
** TableMean
*******************************************************************************/
float
TableMean(float* table, int n)
{      
   return TableSum(table, n) / n;
}
/*******************************************************************************
** TableMaximum
*******************************************************************************/
float
TableMaximum(float* table, int n)
{
   float result = table[0];

   while (n--) if (table[n] > result) result = table[n];      
   
   return result;
}
/*******************************************************************************
** TableMinimum
*******************************************************************************/
float
TableMinimum(float* table, int n)
{
   float result = table[0];

   while (n--) if (table[n] < result) result = table[n];      
   
   return result;
}