datly 0.0.1 → 0.0.2

package/src/descriptive/centralTendency.js

@@ -0,0 +1,208 @@
+class CentralTendency {
+    mean(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        return validValues.reduce((sum, val) => sum + val, 0) / validValues.length;
+    }
+
+    median(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        const sorted = validValues.sort((a, b) => a - b);
+        const middle = Math.floor(sorted.length / 2);
+
+        return sorted.length % 2 === 0 ?
+            (sorted[middle - 1] + sorted[middle]) / 2 :
+            sorted[middle];
+    }
+
+    mode(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const frequency = {};
+        let maxFreq = 0;
+
+        column.forEach(value => {
+            const key = value === null || value === undefined ? 'null' : String(value);
+            frequency[key] = (frequency[key] || 0) + 1;
+            maxFreq = Math.max(maxFreq, frequency[key]);
+        });
+
+        const modes = Object.entries(frequency)
+            .filter(([_, freq]) => freq === maxFreq)
+            .map(([value, _]) => value === 'null' ? null : this.parseValue(value));
+
+        return {
+            values: modes,
+            frequency: maxFreq,
+            isMultimodal: modes.length > 1,
+            isUniform: maxFreq === 1 && Object.keys(frequency).length === column.length
+        };
+    }
+
+    parseValue(str) {
+        if (/^-?\d+$/.test(str)) return parseInt(str, 10);
+        if (/^-?\d*\.\d+$/.test(str)) return parseFloat(str);
+        if (str === 'true') return true;
+        if (str === 'false') return false;
+        return str;
+    }
+
+    geometricMean(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val) && val > 0
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('Geometric mean requires positive numeric values');
+        }
+
+        const logSum = validValues.reduce((sum, val) => sum + Math.log(val), 0);
+        return Math.exp(logSum / validValues.length);
+    }
+
+    harmonicMean(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val) && val > 0
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('Harmonic mean requires positive numeric values');
+        }
+
+        const reciprocalSum = validValues.reduce((sum, val) => sum + (1 / val), 0);
+        return validValues.length / reciprocalSum;
+    }
+
+    trimmedMean(column, percentage) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        if (typeof percentage !== 'number' || percentage < 0 || percentage >= 50) {
+            throw new Error('Percentage must be between 0 and 50');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        const sorted = validValues.sort((a, b) => a - b);
+        const trimCount = Math.floor((percentage / 100) * sorted.length);
+        const trimmed = sorted.slice(trimCount, sorted.length - trimCount);
+
+        if (trimmed.length === 0) {
+            throw new Error('Too much trimming - no values remain');
+        }
+
+        return trimmed.reduce((sum, val) => sum + val, 0) / trimmed.length;
+    }
+
+    quadraticMean(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        const sumOfSquares = validValues.reduce((sum, val) => sum + val * val, 0);
+        return Math.sqrt(sumOfSquares / validValues.length);
+    }
+
+    weightedMean(values, weights) {
+        if (!Array.isArray(values) || !Array.isArray(weights)) {
+            throw new Error('Values and weights must be arrays');
+        }
+
+        if (values.length !== weights.length) {
+            throw new Error('Values and weights must have the same length');
+        }
+
+        if (values.length === 0) {
+            throw new Error('Arrays must not be empty');
+        }
+
+        const validPairs = [];
+        for (let i = 0; i < values.length; i++) {
+            if (typeof values[i] === 'number' && typeof weights[i] === 'number' &&
+                !isNaN(values[i]) && !isNaN(weights[i]) &&
+                isFinite(values[i]) && isFinite(weights[i]) && weights[i] >= 0) {
+                validPairs.push({ value: values[i], weight: weights[i] });
+            }
+        }
+
+        if (validPairs.length === 0) {
+            throw new Error('No valid value-weight pairs found');
+        }
+
+        const totalWeight = validPairs.reduce((sum, pair) => sum + pair.weight, 0);
+
+        if (totalWeight === 0) {
+            throw new Error('Total weight cannot be zero');
+        }
+
+        const weightedSum = validPairs.reduce((sum, pair) => sum + pair.value * pair.weight, 0);
+        return weightedSum / totalWeight;
+    }
+
+    midrange(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        const min = Math.min(...validValues);
+        const max = Math.max(...validValues);
+
+        return (min + max) / 2;
+    }
+}
+
+export default CentralTendency;

package/src/descriptive/dispersion.js

@@ -0,0 +1,273 @@
+class Dispersion {
+    variance(column, sample = true) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        if (sample && validValues.length < 2) {
+            throw new Error('Sample variance requires at least 2 values');
+        }
+
+        const mean = validValues.reduce((sum, val) => sum + val, 0) / validValues.length;
+        const sumSquaredDiff = validValues.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0);
+
+        const denominator = sample ? validValues.length - 1 : validValues.length;
+        return sumSquaredDiff / denominator;
+    }
+
+    standardDeviation(column, sample = true) {
+        return Math.sqrt(this.variance(column, sample));
+    }
+
+    range(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        const min = Math.min(...validValues);
+        const max = Math.max(...validValues);
+
+        return {
+            range: max - min,
+            min: min,
+            max: max
+        };
+    }
+
+    interquartileRange(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        const sorted = validValues.sort((a, b) => a - b);
+        const q1 = this.quantile(sorted, 0.25);
+        const q3 = this.quantile(sorted, 0.75);
+
+        return {
+            iqr: q3 - q1,
+            q1: q1,
+            q3: q3
+        };
+    }
+
+    quantile(sortedArray, q) {
+        const index = (sortedArray.length - 1) * q;
+        const lower = Math.floor(index);
+        const upper = Math.ceil(index);
+        const weight = index % 1;
+
+        if (lower === upper) {
+            return sortedArray[lower];
+        }
+
+        return sortedArray[lower] * (1 - weight) + sortedArray[upper] * weight;
+    }
+
+    coefficientOfVariation(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        const mean = validValues.reduce((sum, val) => sum + val, 0) / validValues.length;
+
+        if (mean === 0) {
+            throw new Error('Cannot calculate coefficient of variation when mean is zero');
+        }
+
+        const std = this.standardDeviation(column);
+        return {
+            cv: std / Math.abs(mean),
+            cvPercent: (std / Math.abs(mean)) * 100
+        };
+    }
+
+    meanAbsoluteDeviation(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        const mean = validValues.reduce((sum, val) => sum + val, 0) / validValues.length;
+        const sumAbsDiff = validValues.reduce((sum, val) => sum + Math.abs(val - mean), 0);
+
+        return {
+            mad: sumAbsDiff / validValues.length,
+            mean: mean
+        };
+    }
+
+    medianAbsoluteDeviation(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        const sorted = validValues.sort((a, b) => a - b);
+        const median = this.quantile(sorted, 0.5);
+        const deviations = validValues.map(val => Math.abs(val - median));
+        const sortedDeviations = deviations.sort((a, b) => a - b);
+
+        return {
+            mad: this.quantile(sortedDeviations, 0.5),
+            median: median
+        };
+    }
+
+    standardError(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        const std = this.standardDeviation(column);
+        return std / Math.sqrt(validValues.length);
+    }
+
+    quartileCoefficient(column) {
+        const iqrResult = this.interquartileRange(column);
+        const q1 = iqrResult.q1;
+        const q3 = iqrResult.q3;
+
+        if (q1 + q3 === 0) {
+            throw new Error('Cannot calculate quartile coefficient when Q1 + Q3 = 0');
+        }
+
+        return (q3 - q1) / (q3 + q1);
+    }
+
+    percentileRange(column, lowerPercentile, upperPercentile) {
+        if (lowerPercentile >= upperPercentile) {
+            throw new Error('Lower percentile must be less than upper percentile');
+        }
+
+        if (lowerPercentile < 0 || upperPercentile > 100) {
+            throw new Error('Percentiles must be between 0 and 100');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('No valid numeric values found');
+        }
+
+        const sorted = validValues.sort((a, b) => a - b);
+        const lowerValue = this.quantile(sorted, lowerPercentile / 100);
+        const upperValue = this.quantile(sorted, upperPercentile / 100);
+
+        return {
+            range: upperValue - lowerValue,
+            lowerValue: lowerValue,
+            upperValue: upperValue,
+            lowerPercentile: lowerPercentile,
+            upperPercentile: upperPercentile
+        };
+    }
+
+    giniCoefficient(column) {
+        if (!Array.isArray(column) || column.length === 0) {
+            throw new Error('Column must be a non-empty array');
+        }
+
+        const validValues = column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val) && val >= 0
+        );
+
+        if (validValues.length === 0) {
+            throw new Error('Gini coefficient requires non-negative numeric values');
+        }
+
+        const sorted = validValues.sort((a, b) => a - b);
+        const n = sorted.length;
+        const mean = sorted.reduce((sum, val) => sum + val, 0) / n;
+
+        if (mean === 0) {
+            return 0;
+        }
+
+        let numerator = 0;
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n; j++) {
+                numerator += Math.abs(sorted[i] - sorted[j]);
+            }
+        }
+
+        return numerator / (2 * n * n * mean);
+    }
+
+    robustScale(column) {
+        const iqrResult = this.interquartileRange(column);
+        const median = this.quantile(column.filter(val =>
+            typeof val === 'number' && !isNaN(val) && isFinite(val)
+        ).sort((a, b) => a - b), 0.5);
+
+        const scaled = column.map(val => {
+            if (typeof val === 'number' && !isNaN(val) && isFinite(val)) {
+                return iqrResult.iqr !== 0 ? (val - median) / iqrResult.iqr : 0;
+            }
+            return null;
+        });
+
+        return {
+            scaledValues: scaled,
+            median: median,
+            iqr: iqrResult.iqr
+        };
+    }
+}
+
+export default Dispersion;