datly 0.0.2 → 0.0.3

package/README.MD

@@ -1,2986 +1,2373 @@
-# Datly
-
-![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)
-![License](https://img.shields.io/badge/license-MIT-green.svg)
-![NPM](https://img.shields.io/badge/npm-datly-red.svg)
-
- **Javascript toolkit for data science, statistical analysis and machine learning.**
- ---
-
-### ⚡ Key Features:
-- 📈 **Complete Statistics Suite** - From descriptive stats to advanced hypothesis testing
-- 🤖 **7 ML Algorithms** - Classification, regression, and ensemble methods
-- 📊 **13 Visualization Types** - Interactive D3.js charts with one-line commands
-- 🔄 **Auto-Analysis** - Intelligent data exploration with automated insights
-- 🎨 **Zero Config** - Works out of the box, customizable when needed
-- 🌐 **Universal** - Same API for browser and Node.js
+# datly
+A comprehensive JavaScript library for data analysis, statistics, machine learning, and visualization.
+
 ---
 
-**Datly** is a comprehensive JavaScript library for statistical analysis, machine learning, and data visualization. Built for both browser and Node.js environments, it provides a complete toolkit for data scientists, analysts, and developers.
+## Table of Contents
+
+1. [Introduction](#introduction)
+2. [Installation](#installation)
+3. [Core Concepts](#core-concepts)
+4. [Data Preparation](#data-preparation)
+5. [Descriptive Statistics](#descriptive-statistics)
+6. [Exploratory Data Analysis](#exploratory-data-analysis)
+7. [Probability Distributions](#probability-distributions)
+8. [Hypothesis Testing](#hypothesis-testing)
+9. [Correlation Analysis](#correlation-analysis)
+10. [Regression Models](#regression-models)
+11. [Classification Models](#classification-models)
+12. [Clustering](#clustering)
+13. [Ensemble Methods](#ensemble-methods)
+14. [Visualization](#visualization)
 
 ---
 
-## 📚 Table of Contents
-
-- [Installation](#installation)
-- [Quick Start](#quick-start)
-- [Core Modules](#core-modules)
-  - [1. Data Loading](#1-data-loading)
-  - [2. Data Validation](#2-data-validation)
-  - [3. Utility Functions](#3-utility-functions)
-  - [4. Central Tendency](#4-central-tendency)
-  - [5. Dispersion Measures](#5-dispersion-measures)
-  - [6. Position Measures](#6-position-measures)
-  - [7. Shape Analysis](#7-shape-analysis)
-  - [8. Hypothesis Testing](#8-hypothesis-testing)
-  - [9. Confidence Intervals](#9-confidence-intervals)
-  - [10. Normality Tests](#10-normality-tests)
-  - [11. Correlation Analysis](#11-correlation-analysis)
-  - [12. Regression Analysis](#12-regression-analysis)
-  - [13. Report Generation](#13-report-generation)
-  - [14. Pattern Detection](#14-pattern-detection)
-  - [15. Result Interpretation](#15-result-interpretation)
-  - [16. Auto-Analysis](#16-auto-analysis)
-  - [17. Machine Learning](#17-machine-learning)
-  - [18. Data Visualization](#18-data-visualization)
-- [Complete Examples](#complete-examples)
-- [API Reference](#api-reference)
+## Introduction
+
+datly is a comprehensive JavaScript library that brings powerful data analysis, statistical testing, machine learning, and visualization capabilities to the browser and Node.js environments.
+
+### Key Features
+
+- **Descriptive Statistics**: Mean, median, variance, standard deviation, skewness, kurtosis
+- **Statistical Tests**: t-tests, ANOVA, chi-square, normality tests
+- **Machine Learning**: Linear/logistic regression, KNN, decision trees, random forests, Naive Bayes
+- **Clustering**: K-means clustering
+- **Dimensionality Reduction**: PCA (Principal Component Analysis)
+- **Data Visualization**: Histograms, scatter plots, box plots, heatmaps, and more
+- **Time Series**: Moving averages, exponential smoothing, autocorrelation
 
 ---
 
-## 🚀 Installation
+## Installation
 
 ### Browser (CDN)
 
 ```html
-<!-- Include Datly -->
 <script src="https://unpkg.com/datly"></script>
-
 <script>
-  const datly = new Datly();
+  const result = datly.mean([1, 2, 3, 4, 5]);
+  console.log(result);
 </script>
 ```
 
-### Node.js (NPM)
-
-```bash
-# Core library (statistics and machine learning)
-npm install datly
-```
+### Module Import
 
 ```javascript
-const Datly = require('datly');
-const datly = new Datly();
+import * as datly from 'datly';
 ```
 
 ---
 
-## ⚡ Quick Start
+## Core Concepts
 
-```javascript
-// Initialize the library
-const datly = new Datly();
-
-// Load data from CSV
-const data = await datly.loadCSV('data.csv');
+### Output Format
 
-// Calculate mean
-const ages = [25, 30, 35, 40, 45];
-const meanAge = datly.mean(ages);
-console.log('Mean Age:', meanAge); // 35
+All analysis functions return results in a structured YAML-like text format that can be parsed or displayed:
 
-// Perform t-test
-const group1 = [23, 25, 27, 29, 31];
-const group2 = [30, 32, 34, 36, 38];
-const tTest = datly.tTest(group1, group2);
-console.log('T-Test Result:', tTest);
-
-// Create visualization
-datly.plotHistogram(ages, {
-  title: 'Age Distribution',
-  xlabel: 'Age',
-  ylabel: 'Frequency'
-});
+```yaml
+type: statistic
+name: mean
+value: 3
+n: 5
 ```
 
----
-
-## 📦 Core Modules
+This format makes it easy to:
+- Display results in a readable format
+- Parse results programmatically
+- Store analysis outputs as text
+- Share results across different systems
 
-### 1. Data Loading
+---
 
-Load data from various sources including CSV, JSON, and file systems.
+## Data Preparation
 
-#### Methods
+### `dataframe_from_json(data)`
 
-##### `loadCSV(filePath, options)`
-Load data from a CSV file.
+Creates a dataframe summary from JSON data.
 
+**Parameters:**
+- `data`: Array of objects or single object
+
+**Returns:**
+```yaml
+type: dataframe
+columns:
+  - name
+  - age
+  - salary
+n_rows: 100
+n_cols: 3
+dtypes:
+  - string
+  - number
+  - number
+preview:
+  - name: alice
+    age: 30
+    salary: 50000
+  - name: bob
+    age: 25
+    salary: 45000
+```
+
+**Example:**
 ```javascript
-const data = await datly.loadCSV('sales.csv', {
-  delimiter: ',',
-  header: true,
-  skipEmptyLines: true,
-  encoding: 'utf8'
-});
+const data = [
+  { name: 'Alice', age: 30, salary: 50000 },
+  { name: 'Bob', age: 25, salary: 45000 },
+  { name: 'Charlie', age: 35, salary: 60000 }
+];
 
-console.log(data);
-// {
-//   headers: ['product', 'sales', 'revenue'],
-//   data: [
-//     { product: 'A', sales: 100, revenue: 5000 },
-//     { product: 'B', sales: 150, revenue: 7500 }
-//   ],
-//   length: 2,
-//   columns: 3
-// }
+const df = datly.dataframe_from_json(data);
+console.log(df);
 ```
 
-**Parameters:**
-- `filePath` (string): Path to CSV file
-- `options` (object): Configuration options
-  - `delimiter` (string): Column delimiter (default: ',')
-  - `header` (boolean): First row contains headers (default: true)
-  - `skipEmptyLines` (boolean): Skip empty rows (default: true)
-  - `encoding` (string): File encoding (default: 'utf8')
+---
 
-**Returns:** Dataset object with headers, data array, length, and column count
+## Descriptive Statistics
 
----
+### `mean(array)`
 
-##### `loadJSON(source, options)`
-Load data from JSON file, string, or object.
+Calculates the arithmetic mean of an array of numbers.
+
+**Returns:**
+```yaml
+type: statistic
+name: mean
+n: 5
+value: 3
+```
 
+**Example:**
 ```javascript
-// From file
-const data1 = await datly.loadJSON('data.json');
+datly.mean([1, 2, 3, 4, 5]); // 3
+```
+
+### `median(array)`
 
-// From JSON string
-const jsonString = '{"users": [{"name": "John", "age": 30}]}';
-const data2 = await datly.loadJSON(jsonString);
+Calculates the median value.
 
-// From object
-const obj = {
-  headers: ['name', 'age'],
-  data: [
-    { name: 'Alice', age: 25 },
-    { name: 'Bob', age: 30 }
-  ]
-};
-const data3 = await datly.loadJSON(obj);
+**Returns:**
+```yaml
+type: statistic
+name: median
+n: 5
+value: 3
 ```
 
-**Parameters:**
-- `source` (string|object): JSON file path, string, or object
-- `options` (object): Configuration options
-  - `validateTypes` (boolean): Auto-infer data types (default: true)
-  - `autoInferHeaders` (boolean): Extract headers from data (default: true)
+**Example:**
+```javascript
+datly.median([1, 2, 3, 4, 5]); // 3
+datly.median([1, 2, 3, 4]); // 2.5
+```
 
-**Returns:** Structured dataset object
+### `variance(array, sample = true)`
 
----
+Calculates the variance.
+
+**Parameters:**
+- `array`: Array of numbers
+- `sample`: If true, uses sample variance (n-1); if false, uses population variance (n)
 
-##### `parseCSV(text, options)`
-Parse CSV text into structured data.
+**Returns:**
+```yaml
+type: statistic
+name: variance
+sample: true
+n: 5
+value: 2.5
+```
 
+**Example:**
 ```javascript
-const csvText = `name,age,city
-John,30,NYC
-Jane,25,LA`;
+datly.variance([1, 2, 3, 4, 5]); // Sample variance
+datly.variance([1, 2, 3, 4, 5], false); // Population variance
+```
 
-const parsed = datly.parseCSV(csvText, {
-  delimiter: ',',
-  header: true
-});
+### `stddeviation(array, sample = true)`
+
+Calculates the standard deviation.
 
-console.log(parsed.data);
-// [
-//   { name: 'John', age: 30, city: 'NYC' },
-//   { name: 'Jane', age: 25, city: 'LA' }
-// ]
+**Returns:**
+```yaml
+type: statistic
+name: std_deviation
+sample: true
+n: 5
+value: 1.5811388300841898
 ```
 
----
+**Example:**
+```javascript
+datly.stddeviation([1, 2, 3, 4, 5]);
+```
 
-##### `cleanData(dataset)`
-Remove rows with all null values.
+### `minv(array)`
 
-```javascript
-const dataset = {
-  headers: ['a', 'b', 'c'],
-  data: [
-    { a: 1, b: 2, c: 3 },
-    { a: null, b: null, c: null }, // Will be removed
-    { a: 4, b: 5, c: 6 }
-  ],
-  length: 3,
-  columns: 3
-};
+Returns the minimum value.
 
-const cleaned = datly.cleanData(dataset);
-console.log(cleaned.length); // 2
+**Returns:**
+```yaml
+type: statistic
+name: min
+value: 1
 ```
 
----
-
-##### `getColumn(dataset, columnName)`
-Extract a single column as an array.
+### `maxv(array)`
 
-```javascript
-const data = {
-  headers: ['name', 'age', 'salary'],
-  data: [
-    { name: 'Alice', age: 25, salary: 50000 },
-    { name: 'Bob', age: 30, salary: 60000 },
-    { name: 'Charlie', age: null, salary: 55000 }
-  ]
-};
+Returns the maximum value.
 
-const ages = datly.getColumn(data, 'age');
-console.log(ages); // [25, 30] (null values filtered)
+**Returns:**
+```yaml
+type: statistic
+name: max
+value: 5
 ```
 
----
+### `quantile(array, q)`
 
-##### `getColumns(dataset, columnNames)`
-Extract multiple columns as an object.
+Calculates the q-th quantile (0 ≤ q ≤ 1).
 
+**Returns:**
+```yaml
+type: statistic
+name: quantile
+q: 0.25
+n: 100
+value: 25.5
+```
+
+**Example:**
 ```javascript
-const columns = datly.getColumns(data, ['age', 'salary']);
-console.log(columns);
-// {
-//   age: [25, 30],
-//   salary: [50000, 60000, 55000]
-// }
+datly.quantile([1, 2, 3, 4, 5], 0.25); // First quartile
+datly.quantile([1, 2, 3, 4, 5], 0.5);  // Median
+datly.quantile([1, 2, 3, 4, 5], 0.75); // Third quartile
 ```
 
----
+### `skewness(array)`
+
+Calculates the skewness (measure of asymmetry).
 
-##### `filterRows(dataset, predicate)`
-Filter dataset rows based on condition.
+**Returns:**
+```yaml
+type: statistic
+name: skewness
+value: 0
+```
 
+**Example:**
 ```javascript
-const filtered = datly.filterRows(data, row => row.age > 25);
-console.log(filtered.data);
-// [{ name: 'Bob', age: 30, salary: 60000 }]
+datly.skewness([1, 2, 3, 4, 5]); // ~0 for symmetric data
 ```
 
----
+### `kurtosis(array)`
 
-##### `sortBy(dataset, column, order)`
-Sort dataset by column.
+Calculates the kurtosis (measure of tailedness).
+
+**Returns:**
+```yaml
+type: statistic
+name: kurtosis
+value: -1.2
+```
 
+**Example:**
 ```javascript
-const sorted = datly.sortBy(data, 'salary', 'desc');
-console.log(sorted.data);
-// [
-//   { name: 'Bob', age: 30, salary: 60000 },
-//   { name: 'Charlie', age: null, salary: 55000 },
-//   { name: 'Alice', age: 25, salary: 50000 }
-// ]
+datly.kurtosis([1, 2, 3, 4, 5]);
 ```
 
 ---
 
-### 2. Data Validation
+## Exploratory Data Analysis
 
-Validate data integrity and structure.
+### `df_describe(data)`
 
-#### Methods
+Generates comprehensive descriptive statistics for a dataset.
 
-##### `validateData(dataset)`
-Validate dataset structure and integrity.
+**Returns:**
+```yaml
+type: describe
+columns:
+  age:
+    dtype: number
+    count: 100
+    missing: 0
+    mean: 35.5
+    std: 10.2
+    min: 18
+    q1: 28
+    median: 35
+    q3: 43
+    max: 65
+    skewness: 0.15
+    kurtosis: -0.5
+  name:
+    dtype: string
+    count: 100
+    missing: 2
+    unique: 95
+    top:
+      - value: john
+        freq: 3
+      - value: alice
+        freq: 2
+```
 
+**Example:**
 ```javascript
-const dataset = {
-  headers: ['a', 'b'],
-  data: [
-    { a: 1, b: 2 },
-    { a: 3, b: 4, c: 5 } // Extra column 'c'
-  ]
-};
+const data = [
+  { age: 25, salary: 50000, dept: 'IT' },
+  { age: 30, salary: 60000, dept: 'HR' },
+  { age: 35, salary: 70000, dept: 'IT' }
+];
 
-const validation = datly.validateData(dataset);
-console.log(validation);
-// {
-//   valid: true,
-//   errors: [],
-//   warnings: ['Row 1: Extra columns: c']
-// }
+const description = datly.df_describe(data);
+console.log(description);
 ```
 
----
+### `df_missing_report(data)`
 
-##### `validateNumericColumn(column)`
-Validate that column contains numeric values.
+Analyzes missing values in the dataset.
 
+**Returns:**
+```yaml
+type: missing_report
+rows:
+  - column: age
+    missing: 5
+    missing_rate: 0.05
+  - column: salary
+    missing: 0
+    missing_rate: 0
+  - column: name
+    missing: 10
+    missing_rate: 0.1
+```
+
+**Example:**
 ```javascript
-const column = [1, 2, 'three', 4, NaN, 5];
-const result = datly.validateNumericColumn(column);
-console.log(result);
-// {
-//   valid: true,
-//   validCount: 4,
-//   invalidCount: 2,
-//   cleanData: [1, 2, 4, 5]
-// }
+const report = datly.df_missing_report(data);
 ```
 
----
+### `df_corr(data, method = 'pearson')`
+
+Calculates correlation matrix between numeric columns.
 
-##### `validateSampleSize(sample, minSize)`
-Ensure sample has minimum required size.
+**Parameters:**
+- `data`: Array of objects
+- `method`: 'pearson' or 'spearman'
+
+**Returns:**
+```yaml
+type: correlation_matrix
+method: pearson
+matrix:
+  age:
+    age: 1
+    salary: 0.85
+    experience: 0.92
+  salary:
+    age: 0.85
+    salary: 1
+    experience: 0.78
+  experience:
+    age: 0.92
+    salary: 0.78
+    experience: 1
+```
 
+**Example:**
 ```javascript
-const sample = [1, 2, 3];
-try {
-  datly.validateSampleSize(sample, 5);
-} catch (error) {
-  console.log(error.message); // "Sample size (3) must be at least 5"
-}
+const corr = datly.df_corr(data, 'pearson');
+const spearman = datly.df_corr(data, 'spearman');
 ```
 
----
+### `eda_overview(data)`
 
-##### `validateConfidenceLevel(level)`
-Validate confidence level is between 0 and 1.
+Generates a comprehensive EDA report combining describe, missing values, and correlation.
 
+**Returns:**
+```yaml
+type: eda
+summary:
+  age:
+    dtype: number
+    count: 100
+    mean: 35.5
+    std: 10.2
+    ...
+missing:
+  - column: age
+    missing: 5
+    missing_rate: 0.05
+correlation:
+  age:
+    age: 1
+    salary: 0.85
+```
+
+**Example:**
 ```javascript
-datly.validateConfidenceLevel(0.95); // true
-datly.validateConfidenceLevel(1.5);  // throws error
+const overview = datly.eda_overview(data);
 ```
 
 ---
 
-### 3. Utility Functions
-
-General-purpose statistical utilities.
-
-#### Methods
+## Probability Distributions
 
-##### `detectOutliers(data, method)`
-Detect outliers using various methods.
+### Normal Distribution
 
-```javascript
-const data = [1, 2, 3, 4, 5, 100]; // 100 is an outlier
+#### `normal_pdf(x, mu = 0, sigma = 1)`
 
-// IQR method (default)
-const outliers1 = datly.detectOutliers(data, 'iqr');
-console.log(outliers1);
-// {
-//   outliers: [100],
-//   indices: [5],
-//   count: 1,
-//   percentage: 16.67
-// }
+Probability density function of normal distribution.
 
-// Z-score method
-const outliers2 = datly.detectOutliers(data, 'zscore');
+**Returns:**
+```yaml
+type: distribution
+name: normal_pdf
+params:
+  mu: 0
+  sigma: 1
+value: 0.3989422804014327
+```
 
-// Modified Z-score method
-const outliers3 = datly.detectOutliers(data, 'modified_zscore');
+**Example:**
+```javascript
+datly.normal_pdf(0); // PDF at x=0
+datly.normal_pdf([0, 1, 2], 0, 1); // PDF for multiple values
 ```
 
-**Methods available:**
-- `'iqr'`: Interquartile Range method (default)
-- `'zscore'`: Z-score method (|z| > 3)
-- `'modified_zscore'`: Modified Z-score method
+#### `normal_cdf(x, mu = 0, sigma = 1)`
 
----
+Cumulative distribution function of normal distribution.
 
-##### `frequencyTable(data)`
-Create frequency distribution table.
+**Returns:**
+```yaml
+type: distribution
+name: normal_cdf
+params:
+  mu: 0
+  sigma: 1
+value: 0.5
+```
 
+**Example:**
 ```javascript
-const colors = ['red', 'blue', 'red', 'green', 'blue', 'red'];
-const freq = datly.frequencyTable(colors);
-console.log(freq);
-// [
-//   { value: 'red', frequency: 3, relativeFrequency: 0.5, percentage: 50 },
-//   { value: 'blue', frequency: 2, relativeFrequency: 0.333, percentage: 33.33 },
-//   { value: 'green', frequency: 1, relativeFrequency: 0.167, percentage: 16.67 }
-// ]
+datly.normal_cdf(0); // P(X ≤ 0)
+datly.normal_cdf(1.96); // P(X ≤ 1.96) ≈ 0.975
 ```
 
----
+#### `normal_ppf(p, mu = 0, sigma = 1)`
 
-##### `groupBy(dataset, column, aggregations)`
-Group data and calculate aggregations.
+Percent point function (inverse CDF) of normal distribution.
+
+**Returns:**
+```yaml
+type: distribution
+name: normal_ppf
+params:
+  mu: 0
+  sigma: 1
+value: 1.959963984540054
+```
 
+**Example:**
 ```javascript
-const data = {
-  headers: ['category', 'sales', 'profit'],
-  data: [
-    { category: 'A', sales: 100, profit: 20 },
-    { category: 'B', sales: 150, profit: 30 },
-    { category: 'A', sales: 200, profit: 40 },
-    { category: 'B', sales: 180, profit: 35 }
-  ]
-};
+datly.normal_ppf(0.975); // Returns ~1.96
+```
 
-const grouped = datly.groupBy(data, 'category', {
-  sales: 'mean',
-  profit: 'sum'
-});
+### Binomial Distribution
 
-console.log(grouped);
-// {
-//   A: {
-//     count: 2,
-//     mean_sales: 150,
-//     sum_profit: 60,
-//     data: [...]
-//   },
-//   B: {
-//     count: 2,
-//     mean_sales: 165,
-//     sum_profit: 65,
-//     data: [...]
-//   }
-// }
-```
-
-**Aggregation functions:**
-- `'mean'`: Average value
-- `'median'`: Median value
-- `'sum'`: Sum of values
-- `'min'`: Minimum value
-- `'max'`: Maximum value
-- `'std'`: Standard deviation
-- `'var'`: Variance
-- `'count'`: Count of values
+#### `binomial_pmf(k, n, p)`
 
----
+Probability mass function of binomial distribution.
+
+**Parameters:**
+- `k`: Number of successes (can be array)
+- `n`: Number of trials
+- `p`: Probability of success
 
-##### `sample(dataset, size, method)`
-Extract a sample from dataset.
+**Returns:**
+```yaml
+type: distribution
+name: binomial_pmf
+params:
+  n: 10
+  p: 0.5
+value: 0.24609375
+```
 
+**Example:**
 ```javascript
-const data = {
-  headers: ['id', 'value'],
-  data: Array.from({ length: 100 }, (_, i) => ({ id: i, value: i * 10 })),
-  length: 100
-};
-
-// Random sampling
-const randomSample = datly.sample(data, 10, 'random');
+datly.binomial_pmf(5, 10, 0.5); // P(X = 5)
+datly.binomial_pmf([0, 1, 2, 3], 10, 0.3); // Multiple values
+```
 
-// Systematic sampling
-const systematicSample = datly.sample(data, 10, 'systematic');
+#### `binomial_cdf(k, n, p)`
 
-// First n records
-const firstSample = datly.sample(data, 10, 'first');
+Cumulative distribution function of binomial distribution.
 
-// Last n records
-const lastSample = datly.sample(data, 10, 'last');
+**Returns:**
+```yaml
+type: distribution
+name: binomial_cdf
+params:
+  n: 10
+  p: 0.5
+value: 0.623046875
 ```
 
----
+### Poisson Distribution
 
-##### `bootstrap(data, statistic, iterations)`
-Bootstrap resampling for estimating statistic distribution.
+#### `poisson_pmf(k, lambda)`
 
-```javascript
-const data = [23, 25, 27, 29, 31, 33, 35];
+Probability mass function of Poisson distribution.
 
-const bootstrap = datly.bootstrap(data, 'mean', 1000);
-console.log(bootstrap);
-// {
-//   bootstrapStats: [...], // 1000 bootstrap means
-//   mean: 29.5,
-//   standardError: 1.23,
-//   confidenceInterval: { lower: 27.1, upper: 31.9 }
-// }
+**Returns:**
+```yaml
+type: distribution
+name: poisson_pmf
+params:
+  lambda: 3
+value: 0.22404180765538775
 ```
 
-**Statistics available:**
-- `'mean'`: Bootstrap mean
-- `'median'`: Bootstrap median
-- `'std'`: Bootstrap standard deviation
-- `'var'`: Bootstrap variance
-- Custom function: Pass your own function
-
----
+**Example:**
+```javascript
+datly.poisson_pmf(3, 3); // P(X = 3) when λ = 3
+```
 
-##### `contingencyTable(column1, column2)`
-Create contingency table for categorical data.
+#### `poisson_cdf(k, lambda)`
 
-```javascript
-const gender = ['M', 'F', 'M', 'F', 'M', 'F'];
-const preference = ['A', 'B', 'A', 'A', 'B', 'B'];
+Cumulative distribution function of Poisson distribution.
 
-const table = datly.contingencyTable(gender, preference);
-console.log(table);
-// {
-//   table: {
-//     M: { A: 2, B: 1 },
-//     F: { A: 1, B: 2 }
-//   },
-//   totals: {
-//     row: { M: 3, F: 3 },
-//     col: { A: 3, B: 3 },
-//     grand: 6
-//   },
-//   rows: ['M', 'F'],
-//   columns: ['A', 'B']
-// }
+**Returns:**
+```yaml
+type: distribution
+name: poisson_cdf
+params:
+  lambda: 3
+value: 0.6472319374260858
 ```
 
 ---
 
-### 4. Central Tendency
+## Hypothesis Testing
 
-Measures of central tendency (mean, median, mode).
+### `t_test_one_sample(array, hypothesized_mean)`
 
-#### Methods
+One-sample t-test.
 
-##### `mean(data)`
-Calculate arithmetic mean.
+**Returns:**
+```yaml
+type: hypothesis_test
+name: one_sample_t_test
+statistic: 2.345
+df: 99
+p_value: 0.021
+mean: 105
+hypothesized_mean: 100
+```
 
+**Example:**
 ```javascript
-const data = [10, 20, 30, 40, 50];
-const avg = datly.mean(data);
-console.log(avg); // 30
+const data = [102, 98, 105, 110, 95, 100, 108];
+datly.t_test_one_sample(data, 100);
 ```
 
----
+### `t_test_paired(array1, array2)`
 
-##### `median(data)`
-Calculate median (middle value).
+Paired samples t-test.
 
-```javascript
-const data1 = [1, 3, 5, 7, 9];
-console.log(datly.median(data1)); // 5
+**Returns:**
+```yaml
+type: hypothesis_test
+name: paired_t_test
+statistic: 3.456
+df: 29
+p_value: 0.0018
+mean_difference: 2.5
+```
 
-const data2 = [1, 3, 5, 7];
-console.log(datly.median(data2)); // 4 (average of 3 and 5)
+**Example:**
+```javascript
+const before = [120, 115, 130, 125, 140];
+const after = [115, 110, 125, 120, 135];
+datly.t_test_paired(before, after);
 ```
 
----
+### `t_test_independent(array1, array2, equal_var = true)`
 
-##### `mode(data)`
-Find mode (most frequent value).
+Independent samples t-test.
 
-```javascript
-const data = [1, 2, 2, 3, 3, 3, 4, 4];
-const modeResult = datly.mode(data);
-console.log(modeResult);
-// {
-//   values: [3],
-//   frequency: 3,
-//   isMultimodal: false,
-//   isUniform: false
-// }
+**Parameters:**
+- `equal_var`: If true, assumes equal variances (pooled t-test); if false, uses Welch's t-test
 
-// Multimodal example
-const data2 = [1, 1, 2, 2, 3];
-const modeResult2 = datly.mode(data2);
-console.log(modeResult2);
-// {
-//   values: [1, 2],
-//   frequency: 2,
-//   isMultimodal: true,
-//   isUniform: false
-// }
+**Returns:**
+```yaml
+type: hypothesis_test
+name: independent_t_test
+statistic: 2.105
+df: 48
+p_value: 0.041
+means:
+  group_a: 105.5
+  group_b: 98.3
 ```
 
----
-
-##### `geometricMean(data)`
-Calculate geometric mean (for positive values).
-
+**Example:**
 ```javascript
-const data = [2, 8, 32]; // Growth rates
-const geoMean = datly.geometricMean(data);
-console.log(geoMean); // 8 (∛(2×8×32))
+const group1 = [100, 105, 110, 115, 120];
+const group2 = [95, 98, 100, 102, 105];
+datly.t_test_independent(group1, group2);
 ```
 
-**Use cases:** Growth rates, ratios, percentages
+### `z_test_one_sample(array, mu = 0, sigma = null, alpha = 0.05)`
 
----
+One-sample z-test with confidence interval.
 
-##### `harmonicMean(data)`
-Calculate harmonic mean (for rates).
+**Returns:**
+```yaml
+type: hypothesis_test
+name: one_sample_z_test
+statistic: 2.345
+p_value: 0.019
+ci_lower: 102.5
+ci_upper: 107.5
+confidence: 0.95
+extra:
+  sample_mean: 105
+  hypothesized_mean: 100
+  se: 2.13
+  sigma_used: 10
+  n: 22
+  effect_size: 0.5
+```
 
+**Example:**
 ```javascript
-const speeds = [60, 40, 30]; // km/h on different segments
-const harmMean = datly.harmonicMean(speeds);
-console.log(harmMean); // 40 (average speed)
+datly.z_test_one_sample([102, 98, 105, 110], 100, 5, 0.05);
 ```
 
-**Use cases:** Average rates, speeds, ratios
+### `anova_oneway(groups, alpha = 0.05)`
 
----
+One-way ANOVA test.
+
+**Parameters:**
+- `groups`: Array of arrays, each representing a group
 
-##### `trimmedMean(data, percentage)`
-Calculate trimmed mean (remove extreme values).
+**Returns:**
+```yaml
+type: hypothesis_test
+name: anova_oneway
+statistic: 5.678
+df:
+  between: 2
+  within: 27
+p_value: 0.009
+confidence: 0.95
+extra:
+  group_means:
+    - 102.5
+    - 108.3
+    - 115.7
+  grand_mean: 108.8
+  ssb: 450.5
+  ssw: 890.2
+```
 
+**Example:**
 ```javascript
-const data = [1, 2, 3, 100, 4, 5, 6]; // 100 is outlier
-const trimmed = datly.trimmedMean(data, 10); // Trim 10% from each end
-console.log(trimmed); // ~3.75 (without extreme values)
+const group1 = [100, 105, 110];
+const group2 = [108, 112, 115];
+const group3 = [115, 120, 125];
+datly.anova_oneway([group1, group2, group3]);
 ```
 
----
+### `chi_square_independence(observed, alpha = 0.05)`
 
-##### `weightedMean(values, weights)`
-Calculate weighted average.
+Chi-square test for independence (contingency table).
 
-```javascript
-const grades = [85, 90, 78, 92];
-const weights = [0.3, 0.3, 0.2, 0.2]; // Exam weights
-const weightedGrade = datly.weightedMean(grades, weights);
-console.log(weightedGrade); // 86.5
-```eoMean); // 8 (∛(2×8×32))
+**Parameters:**
+- `observed`: 2D array (contingency table)
+
+**Returns:**
+```yaml
+type: hypothesis_test
+name: chi_square_independence
+statistic: 8.456
+df: 2
+p_value: 0.015
+confidence: 0.95
+extra:
+  observed:
+    - - 10
+      - 20
+      - 30
+    - - 15
+      - 25
+      - 35
+  expected:
+    - - 12.5
+      - 22.5
+      - 32.5
+    - - 12.5
+      - 22.5
+      - 32.5
+  dof: 2
+```
+
+**Example:**
+```javascript
+const table = [
+  [10, 20, 30],
+  [15, 25, 35]
+];
+datly.chi_square_independence(table);
 ```
 
-**Use cases:** Growth rates, ratios, percentages
+### `chi_square_goodness(observed, expected, alpha = 0.05)`
 
----
+Chi-square goodness of fit test.
 
-##### `harmonicMean(data)`
-Calculate harmonic mean (for rates).
+**Returns:**
+```yaml
+type: hypothesis_test
+name: chi_square_goodness_of_fit
+statistic: 3.456
+df: 3
+p_value: 0.327
+confidence: 0.95
+extra:
+  observed:
+    - 45
+    - 55
+    - 48
+    - 52
+  expected:
+    - 50
+    - 50
+    - 50
+    - 50
+  dof: 3
+```
 
+**Example:**
 ```javascript
-const speeds = [60, 40, 30]; // km/h on different segments
-const harmMean = datly.centralTendency.harmonicMean(speeds);
-console.log(harmMean); // 40 (average speed)
+const observed = [45, 55, 48, 52];
+const expected = [50, 50, 50, 50];
+datly.chi_square_goodness(observed, expected);
 ```
 
-**Use cases:** Average rates, speeds, ratios
+### `shapiro_wilk(array)`
 
----
+Shapiro-Wilk test for normality.
 
-##### `trimmedMean(data, percentage)`
-Calculate trimmed mean (remove extreme values).
+**Returns:**
+```yaml
+type: hypothesis_test
+name: shapiro_wilk
+statistic: 0.987
+n: 50
+note: approximation; w > 0.9 suggests normality
+```
 
+**Example:**
 ```javascript
-const data = [1, 2, 3, 100, 4, 5, 6]; // 100 is outlier
-const trimmed = datly.centralTendency.trimmedMean(data, 10); // Trim 10% from each end
-console.log(trimmed); // ~3.75 (without extreme values)
+datly.shapiro_wilk([1.2, 2.3, 1.8, 2.1, 1.9, 2.0]);
 ```
 
----
+### `jarque_bera(array)`
 
-##### `weightedMean(values, weights)`
-Calculate weighted average.
+Jarque-Bera test for normality.
 
-```javascript
-const grades = [85, 90, 78, 92];
-const weights = [0.3, 0.3, 0.2, 0.2]; // Exam weights
-const weightedGrade = datly.centralTendency.weightedMean(grades, weights);
-console.log(weightedGrade); // 86.5
+**Returns:**
+```yaml
+type: hypothesis_test
+name: jarque_bera
+statistic: 2.345
+n: 100
+df: 2
+note: tests normality; low p-value rejects normality
 ```
 
----
-
-### 5. Dispersion Measures
-
-Measures of variability and spread.
+### `levene_test(groups)`
 
-#### Methods
+Levene's test for homogeneity of variance.
 
-##### `variance(data, sample)`
-Calculate variance.
+**Returns:**
+```yaml
+type: hypothesis_test
+name: levene_test
+statistic: 1.234
+df_between: 2
+df_within: 27
+note: tests homogeneity of variance
+```
 
+**Example:**
 ```javascript
-const data = [2, 4, 6, 8, 10];
+const g1 = [1, 2, 3, 4, 5];
+const g2 = [2, 3, 4, 5, 6];
+const g3 = [3, 4, 5, 6, 7];
+datly.levene_test([g1, g2, g3]);
+```
 
-// Sample variance (default)
-const sampleVar = datly.variance(data, true);
-console.log(sampleVar); // 10
+### `kruskal_wallis(groups)`
 
-// Population variance
-const popVar = datly.variance(data, false);
-console.log(popVar); // 8
+Kruskal-Wallis H-test (non-parametric alternative to ANOVA).
+
+**Returns:**
+```yaml
+type: hypothesis_test
+name: kruskal_wallis
+statistic: 8.765
+df: 2
+note: non-parametric alternative to anova
 ```
 
----
+### `mann_whitney(array1, array2)`
 
-##### `standardDeviation(data, sample)`
-Calculate standard deviation.
+Mann-Whitney U test (non-parametric alternative to t-test).
 
-```javascript
-const data = [2, 4, 6, 8, 10];
-const std = datly.standardDeviation(data);
-console.log(std); // 3.162 (√10)
+**Returns:**
+```yaml
+type: hypothesis_test
+name: mann_whitney_u
+statistic: 45
+z_score: -1.234
+p_value: 0.217
+note: non-parametric alternative to t-test
 ```
 
----
+### `wilcoxon_signed_rank(array1, array2)`
 
-##### `range(data)`
-Calculate range (max - min).
+Wilcoxon signed-rank test (non-parametric paired test).
 
-```javascript
-const data = [5, 10, 15, 20, 25];
-const rangeResult = datly.range(data);
-console.log(rangeResult);
-// {
-//   range: 20,
-//   min: 5,
-//   max: 25
-// }
+**Returns:**
+```yaml
+type: hypothesis_test
+name: wilcoxon_signed_rank
+statistic: 28
+z_score: 1.567
+p_value: 0.117
+n: 20
 ```
 
----
+### Confidence Intervals
 
-##### `interquartileRange(data)`
-Calculate IQR (Q3 - Q1).
+#### `confidence_interval_mean(array, confidence = 0.95)`
 
-```javascript
-const data = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-const iqr = datly.interquartileRange(data);
-console.log(iqr);
-// {
-//   iqr: 4,
-//   q1: 3,
-//   q3: 7
-// }
+Confidence interval for the mean.
+
+**Returns:**
+```yaml
+type: confidence_interval
+parameter: mean
+confidence: 0.95
+n: 50
+mean: 102.5
+lower: 98.3
+upper: 106.7
+margin: 4.2
 ```
 
----
+#### `confidence_interval_proportion(successes, n, confidence = 0.95)`
 
-##### `coefficientOfVariation(data)`
-Calculate coefficient of variation (CV%).
+Confidence interval for a proportion.
 
-```javascript
-const data = [10, 20, 30, 40, 50];
-const cv = datly.coefficientOfVariation(data);
-console.log(cv);
-// {
-//   cv: 0.471,
-//   cvPercent: 47.1
-// }
+**Returns:**
+```yaml
+type: confidence_interval
+parameter: proportion
+confidence: 0.95
+n: 100
+proportion: 0.65
+lower: 0.551
+upper: 0.749
+margin: 0.099
 ```
 
-**Interpretation:**
-- CV < 15%: Low variability
-- CV 15-30%: Moderate variability
-- CV > 30%: High variability
-
----
+#### `confidence_interval_variance(array, confidence = 0.95)`
 
-##### `meanAbsoluteDeviation(data)`
-Calculate MAD (mean absolute deviation).
+Confidence interval for variance.
 
-```javascript
-const data = [2, 4, 6, 8, 10];
-const mad = datly.meanAbsoluteDeviation(data);
-console.log(mad);
-// {
-//   mad: 2.4,
-//   mean: 6
-// }
+**Returns:**
+```yaml
+type: confidence_interval
+parameter: variance
+confidence: 0.95
+n: 30
+variance: 25.5
+lower: 18.2
+upper: 38.7
 ```
 
----
+#### `confidence_interval_difference(array1, array2, confidence = 0.95)`
 
-##### `standardError(data)`
-Calculate standard error of the mean.
+Confidence interval for difference of means.
 
-```javascript
-const data = [10, 12, 14, 16, 18, 20];
-const se = datly.standardError(data);
-console.log(se); // 1.29 (σ/√n)
+**Returns:**
+```yaml
+type: confidence_interval
+parameter: difference_of_means
+confidence: 0.95
+difference: 5.5
+lower: 2.3
+upper: 8.7
+margin: 3.2
+means:
+  group_a: 105.5
+  group_b: 100
 ```
 
 ---
 
-### 6. Position Measures
+## Correlation Analysis
 
-Quantiles, percentiles, and ranking.
+### `corr_pearson(array1, array2)`
 
-#### Methods
+Pearson correlation coefficient.
 
-##### `quantile(data, q)`
-Calculate quantile.
+**Returns:**
+```yaml
+type: statistic
+name: pearson_correlation
+value: 0.856
+```
 
+**Example:**
 ```javascript
-const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+const x = [1, 2, 3, 4, 5];
+const y = [2, 4, 5, 4, 5];
+datly.corr_pearson(x, y);
+```
 
-// Median (0.5 quantile)
-console.log(datly.quantile(data, 0.5)); // 5.5
+### `corr_spearman(array1, array2)`
 
-// First quartile
-console.log(datly.quantile(data, 0.25)); // 3.25
+Spearman rank correlation coefficient.
 
-// Third quartile
-console.log(datly.quantile(data, 0.75)); // 7.75
+**Returns:**
+```yaml
+type: statistic
+name: spearman_correlation
+value: 0.9
 ```
 
----
+### `corr_kendall(array1, array2)`
 
-##### `percentile(data, p)`
-Calculate percentile (0-100 scale).
+Kendall's tau correlation coefficient.
 
-```javascript
-const scores = [65, 70, 75, 80, 85, 90, 95];
-const p90 = datly.percentile(scores, 90);
-console.log(p90); // 93.5
+**Returns:**
+```yaml
+type: statistic
+name: kendall_tau
+value: 0.8
+concordant: 8
+discordant: 2
+n: 5
 ```
 
----
+### `corr_partial(array1, array2, array3)`
 
-##### `quartiles(data)`
-Calculate all quartiles.
+Partial correlation controlling for a third variable.
 
-```javascript
-const data = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-const quartiles = datly.quartiles(data);
-console.log(quartiles);
-// {
-//   q1: 2.5,
-//   q2: 5,    // Median
-//   q3: 7.5,
-//   iqr: 5
-// }
+**Returns:**
+```yaml
+type: statistic
+name: partial_correlation
+value: 0.456
+controlling_for: third_variable
 ```
 
----
+### `corr_matrix_all(data)`
 
-##### `percentileRank(data, value)`
-Calculate percentile rank of a value.
+Comprehensive correlation matrix with Pearson, Spearman, and Kendall.
 
-```javascript
-const scores = [60, 70, 80, 90, 100];
-const rank = datly.percentileRank(scores, 80);
-console.log(rank); // 50 (80 is at the 50th percentile)
+**Returns:**
+```yaml
+type: correlation_analysis
+pearson:
+  age:
+    age: 1
+    salary: 0.85
+  salary:
+    age: 0.85
+    salary: 1
+spearman:
+  age:
+    age: 1
+    salary: 0.82
+  salary:
+    age: 0.82
+    salary: 1
+kendall:
+  age:
+    age: 1
+    salary: 0.75
+  salary:
+    age: 0.75
+    salary: 1
 ```
 
 ---
 
-##### `zScore(data, value)`
-Calculate z-score (standardized value).
+## Regression Models
+
+### Linear Regression
 
+#### `train_linear_regression(X, y)`
+
+Trains a multiple linear regression model.
+
+**Parameters:**
+- `X`: 2D array of features [[x1, x2, ...], ...]
+- `y`: Array of target values
+
+**Returns:**
+```yaml
+type: linear_regression
+weights:
+  - 2.5
+  - 1.8
+  - -0.3
+mse: 12.34
+r2: 0.856
+n: 100
+p: 2
+```
+
+**Example:**
 ```javascript
-const data = [10, 20, 30, 40, 50];
-const z = datly.zScore(data, 40);
-console.log(z); // 0.632 standard deviations above mean
+const X = [[1, 2], [2, 3], [3, 4], [4, 5]];
+const y = [3, 5, 7, 9];
+const model = datly.train_linear_regression(X, y);
 ```
 
-**Interpretation:**
-- |z| < 1: Within 1 standard deviation
-- |z| < 2: Within 2 standard deviations
-- |z| > 3: Potential outlier
+#### `predict_linear(model, X)`
 
----
+Makes predictions using a trained linear regression model.
 
-##### `boxplotStats(data)`
-Calculate box plot statistics.
+**Parameters:**
+- `model`: Model text/object from `train_linear_regression`
+- `X`: 2D array of features
+
+**Returns:**
+```yaml
+type: prediction
+name: linear_regression
+predictions:
+  - 105.3
+  - 110.7
+  - 98.2
+```
 
+**Example:**
 ```javascript
-const data = [1, 2, 3, 4, 5, 100]; // 100 is outlier
-const stats = datly.boxplotStats(data);
-console.log(stats);
-// {
-//   min: 1,
-//   q1: 2,
-//   median: 3.5,
-//   q3: 5,
-//   max: 5,
-//   iqr: 3,
-//   lowerFence: -2.5,
-//   upperFence: 9.5,
-//   outliers: [100],
-//   outlierCount: 1
-// }
+const predictions = datly.predict_linear(model, [[5, 6], [6, 7]]);
 ```
 
----
+### Logistic Regression
 
-##### `rank(data, method)`
-Rank data values.
+#### `train_logistic_regression(X, y, options = {})`
 
-```javascript
-const data = [10, 20, 20, 30, 40];
+Trains a logistic regression model for binary classification.
+
+**Parameters:**
+- `X`: 2D array of features
+- `y`: Array of binary labels (0 or 1)
+- `options`:
+  - `learning_rate`: Learning rate (default: 0.1)
+  - `iterations`: Number of iterations (default: 1000)
+  - `l2`: L2 regularization parameter (default: 0)
+
+**Returns:**
+```yaml
+type: logistic_regression
+weights:
+  - 0.5
+  - 1.2
+  - -0.8
+accuracy: 0.92
+n: 100
+p: 2
+```
+
+**Example:**
+```javascript
+const X = [[1, 2], [2, 3], [3, 1], [4, 2]];
+const y = [0, 0, 1, 1];
+const model = datly.train_logistic_regression(X, y, {
+  learning_rate: 0.1,
+  iterations: 1000,
+  l2: 0.01
+});
+```
 
-// Average ranking (ties get average rank)
-const ranks1 = datly.rank(data, 'average');
-console.log(ranks1); // [1, 2.5, 2.5, 4, 5]
+#### `predict_logistic(model, X, threshold = 0.5)`
 
-// Min ranking (ties get minimum rank)
-const ranks2 = datly.rank(data, 'min');
-console.log(ranks2); // [1, 2, 2, 4, 5]
+Makes predictions using a trained logistic regression model.
+
+**Returns:**
+```yaml
+type: prediction
+name: logistic_regression
+threshold: 0.5
+probabilities:
+  - 0.234
+  - 0.789
+  - 0.456
+classes:
+  - 0
+  - 1
+  - 0
+```
 
-// Max ranking (ties get maximum rank)
-const ranks3 = datly.rank(data, 'max');
-console.log(ranks3); // [1, 3, 3, 4, 5]
+**Example:**
+```javascript
+const predictions = datly.predict_logistic(model, [[5, 6], [6, 7]], 0.5);
 ```
 
 ---
 
-### 7. Shape Analysis
+## Classification Models
+
+### K-Nearest Neighbors (KNN)
 
-Distribution shape: skewness and kurtosis.
+#### `train_knn_classifier(X, y, k = 5)`
 
-#### Methods
+Trains a KNN classifier.
+
+**Parameters:**
+- `X`: 2D array of features
+- `y`: Array of class labels
+- `k`: Number of neighbors (default: 5)
 
-##### `skewness(data, bias)`
-Calculate skewness (measure of asymmetry).
+**Returns:**
+```yaml
+type: knn_classifier
+k: 5
+x:
+  - - 1
+    - 2
+  - - 2
+    - 3
+y:
+  - 0
+  - 1
+n: 100
+p: 2
+```
 
+**Example:**
 ```javascript
-const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 100]; // Right-skewed
+const X = [[1, 2], [2, 3], [3, 1], [4, 2]];
+const y = [0, 0, 1, 1];
+const model = datly.train_knn_classifier(X, y, 3);
+```
 
-// Biased estimate (default)
-const skew1 = datly.skewness(data, true);
-console.log(skew1); // Positive value
+#### `predict_knn_classifier(model, X)`
 
-// Unbiased estimate
-const skew2 = datly.skewness(data, false);
-console.log(skew2);
+Makes predictions using KNN classifier.
+
+**Returns:**
+```yaml
+type: prediction
+name: knn_classifier
+k: 5
+predictions:
+  - 0
+  - 1
+  - 1
 ```
 
-**Interpretation:**
-- Skewness < -1: Highly left-skewed
-- -1 < Skewness < -0.5: Moderately left-skewed
-- -0.5 < Skewness < 0.5: Approximately symmetric
-- 0.5 < Skewness < 1: Moderately right-skewed
-- Skewness > 1: Highly right-skewed
+#### `train_knn_regressor(X, y, k = 5)`
 
----
+Trains a KNN regressor.
 
-##### `kurtosis(data, bias, excess)`
-Calculate kurtosis (measure of tailedness).
+**Returns:**
+```yaml
+type: knn_regressor
+k: 5
+x:
+  - - 1
+    - 2
+  - - 2
+    - 3
+y:
+  - 10.5
+  - 12.3
+n: 100
+p: 2
+```
 
-```javascript
-const data = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+#### `predict_knn_regressor(model, X)`
 
-// Excess kurtosis (default)
-const kurt1 = datly.kurtosis(data, false, true);
-console.log(kurt1); // -3 adjustment applied
+Makes predictions using KNN regressor.
 
-// Regular kurtosis
-const kurt2 = datly.kurtosis(data, false, false);
-console.log(kurt2);
+**Returns:**
+```yaml
+type: prediction
+name: knn_regressor
+k: 5
+predictions:
+  - 10.7
+  - 11.8
+  - 12.5
 ```
 
-**Interpretation (excess kurtosis):**
-- Excess < -1: Platykurtic (thin tails)
-- -1 < Excess < 1: Mesokurtic (normal)
-- Excess > 1: Leptokurtic (fat tails)
+### Decision Trees
 
----
+#### `train_decision_tree_classifier(X, y, options = {})`
 
-##### `isNormalDistribution(data, alpha)`
-Test if data follows normal distribution.
+Trains a decision tree classifier.
 
-```javascript
-const normalData = [2, 3, 4, 4, 5, 5, 5, 6, 6, 7];
-const test = datly.isNormalDistribution(normalData, 0.05);
-console.log(test);
-// {
-//   shapiroWilk: { statistic: 0.95, pValue: 0.12, isNormal: true },
-//   jarqueBera: { statistic: 1.23, pValue: 0.54, isNormal: true },
-//   skewness: 0.12,
-//   kurtosis: -0.34,
-//   isNormalByTests: true
-// }
+**Parameters:**
+- `options`:
+  - `max_depth`: Maximum depth of tree (default: 5)
+  - `min_samples_split`: Minimum samples required to split (default: 2)
+
+**Returns:**
+```yaml
+type: decision_tree_classifier
+tree:
+  leaf: false
+  feature: 0
+  threshold: 2.5
+  left:
+    leaf: true
+    prediction: 0
+    n: 50
+  right:
+    leaf: true
+    prediction: 1
+    n: 50
+max_depth: 5
+min_samples: 2
+n: 100
+p: 2
+```
+
+**Example:**
+```javascript
+const model = datly.train_decision_tree_classifier(X, y, {
+  max_depth: 5,
+  min_samples_split: 2
+});
 ```
 
----
+#### `train_decision_tree_regressor(X, y, options = {})`
 
-##### `jarqueBeraTest(data, alpha)`
-Jarque-Bera normality test.
+Trains a decision tree regressor.
 
-```javascript
-const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-const jb = datly.jarqueBeraTest(data);
-console.log(jb);
-// {
-//   statistic: 0.84,
-//   pValue: 0.66,
-//   skewness: 0,
-//   excessKurtosis: -1.2,
-//   isNormal: true
-// }
+**Returns:**
+```yaml
+type: decision_tree_regressor
+tree:
+  leaf: false
+  feature: 0
+  threshold: 2.5
+  left: ...
+  right: ...
+max_depth: 5
+min_samples: 2
+n: 100
+p: 2
 ```
 
----
+#### `predict_decision_tree(model, X)`
+
+Makes predictions using a decision tree.
 
-### 8. Hypothesis Testing
-
-Statistical hypothesis tests.
-
-#### Methods
-
-##### `tTest(sample1, sample2, type, alpha)`
-Perform t-test.
-
-```javascript
-// One-sample t-test
-const sample = [23, 25, 27, 29, 31];
-const populationMean = 25;
-const oneSample = datly.tTest(sample, populationMean, 'one-sample');
-console.log(oneSample);
-// {
-//   type: 'one-sample',
-//   statistic: 1.89,
-//   pValue: 0.13,
-//   degreesOfFreedom: 4,
-//   significant: false
-// }
-
-// Two-sample t-test
-const group1 = [23, 25, 27, 29, 31];
-const group2 = [28, 30, 32, 34, 36];
-const twoSample = datly.tTest(group1, group2, 'two-sample');
-console.log(twoSample);
-// {
-//   type: 'two-sample',
-//   statistic: -3.46,
-//   pValue: 0.008,
-//   significant: true,
-//   meanDifference: -5
-// }
-
-// Paired t-test
-const before = [120, 125, 130, 128, 122];
-const after = [115, 118, 125, 120, 115];
-const paired = datly.tTest(before, after, 'paired');
-console.log(paired);
+**Returns:**
+```yaml
+type: prediction
+name: decision_tree_classifier
+predictions:
+  - 0
+  - 1
+  - 1
 ```
 
----
+### Random Forest
 
-##### `zTest(sample, populationMean, populationStd, alpha)`
-Perform z-test (known population variance).
+#### `train_random_forest_classifier(X, y, options = {})`
 
-```javascript
-const sample = [105, 110, 108, 112, 115];
-const popMean = 100;
-const popStd = 15;
+Trains a random forest classifier.
 
-const zTest = datly.zTest(sample, popMean, popStd);
-console.log(zTest);
-// {
-//   type: 'z-test',
-//   statistic: 1.49,
-//   pValue: 0.136,
-//   significant: false,
-//   sampleMean: 110
-// }
+**Parameters:**
+- `options`:
+  - `n_estimators`: Number of trees (default: 10)
+  - `max_depth`: Maximum depth (default: 5)
+  - `min_samples_split`: Minimum samples to split (default: 2)
+  - `seed`: Random seed (default: 42)
+
+**Returns:**
+```yaml
+type: random_forest_classifier
+trees:
+  - leaf: false
+    feature: 0
+    threshold: 2.5
+    ...
+  - leaf: false
+    feature: 1
+    threshold: 3.2
+    ...
+n_trees: 10
+max_depth: 5
+min_samples: 2
+n: 100
+p: 2
+```
+
+**Example:**
+```javascript
+const model = datly.train_random_forest_classifier(X, y, {
+  n_estimators: 10,
+  max_depth: 5,
+  seed: 42
+});
 ```
 
----
-
-##### `anovaTest(groups, alpha)`
-One-way ANOVA test.
+#### `train_random_forest_regressor(X, y, options = {})`
 
-```javascript
-const groupA = [23, 25, 27, 29];
-const groupB = [30, 32, 34, 36];
-const groupC = [28, 30, 32, 34];
+Trains a random forest regressor.
 
-const anova = datly.anovaTest([groupA, groupB, groupC]);
-console.log(anova);
-// {
-//   type: 'one-way-anova',
-//   statistic: 12.45,
-//   pValue: 0.001,
-//   dfBetween: 2,
-//   dfWithin: 9,
-//   significant: true,
-//   groupMeans: [26, 33, 31]
-// }
+**Returns:**
+```yaml
+type: random_forest_regressor
+trees: [...]
+n_trees: 10
+max_depth: 5
+min_samples: 2
+n: 100
+p: 2
 ```
 
----
-
-##### `chiSquareTest(column1, column2, alpha)`
-Chi-square test of independence.
+#### `predict_random_forest_classifier(model, X)`
 
-```javascript
-const gender = ['M', 'F', 'M', 'F', 'M', 'F', 'M', 'F'];
-const preference = ['A', 'B', 'A', 'A', 'B', 'B', 'A', 'B'];
+Makes predictions using random forest classifier.
 
-const chiTest = datly.chiSquareTest(gender, preference);
-console.log(chiTest);
-// {
-//   type: 'chi-square-independence',
-//   statistic: 0.5,
-//   pValue: 0.48,
-//   degreesOfFreedom: 1,
-//   significant: false,
-//   cramersV: 0.25
-// }
+**Returns:**
+```yaml
+type: prediction
+name: random_forest_classifier
+n_trees: 10
+predictions:
+  - 0
+  - 1
+  - 1
 ```
 
----
-
-##### `mannWhitneyTest(sample1, sample2, alpha)`
-Mann-Whitney U test (non-parametric alternative to t-test).
+#### `predict_random_forest_regressor(model, X)`
 
-```javascript
-const group1 = [1, 2, 3, 4, 5];
-const group2 = [6, 7, 8, 9, 10];
+Makes predictions using random forest regressor.
 
-const mwTest = datly.mannWhitneyTest(group1, group2);
-console.log(mwTest);
-// {
-//   type: 'mann-whitney-u',
-//   statistic: 0,
-//   u1: 0,
-//   u2: 25,
-//   zStatistic: -2.61,
-//   pValue: 0.009,
-//   significant: true
-// }
+**Returns:**
+```yaml
+type: prediction
+name: random_forest_regressor
+n_trees: 10
+predictions:
+  - 10.7
+  - 11.8
+  - 12.5
 ```
 
----
+### Naive Bayes
 
-### 9. Confidence Intervals
+#### `train_naive_bayes(X, y)`
 
-Estimate population parameters with confidence.
+Trains a Gaussian Naive Bayes classifier.
 
-#### Methods
+**Parameters:**
+- `X`: 2D array of features
+- `y`: Array of class labels
 
-##### `mean(data, confidence)`
-Confidence interval for mean.
+**Returns:**
+```yaml
+type: naive_bayes
+classes:
+  - 0
+  - 1
+priors:
+  0: 0.5
+  1: 0.5
+stats:
+  0:
+    - mean: 2.5
+      std: 1.2
+    - mean: 3.1
+      std: 0.8
+  1:
+    - mean: 5.2
+      std: 1.5
+    - mean: 6.3
+      std: 1.1
+n: 100
+p: 2
+```
 
+**Example:**
 ```javascript
-const data = [23, 25, 27, 29, 31, 33, 35];
-const ci = datly.confidenceInterval(data, 0.95);
-console.log(ci);
-// {
-//   mean: 29,
-//   standardError: 1.63,
-//   marginOfError: 4.03,
-//   lowerBound: 24.97,
-//   upperBound: 33.03,
-//   confidence: 0.95,
-//   degreesOfFreedom: 6
-// }
+const X = [[1, 2], [2, 3], [5, 6], [6, 7]];
+const y = [0, 0, 1, 1];
+const model = datly.train_naive_bayes(X, y);
 ```
 
----
+#### `predict_naive_bayes(model, X)`
+
+Makes predictions using Naive Bayes classifier.
 
-##### `proportion(successes, total, confidence)`
-Confidence interval for proportion.
-
-```javascript
-const successes = 45; // Number of successes
-const total = 100;    // Total trials
-
-const ci = datly.confidenceIntervals.proportion(successes, total, 0.95);
-console.log(ci);
-// {
-//   normal: {
-//     proportion: 0.45,
-//     lowerBound: 0.353,
-//     upperBound: 0.547,
-//     confidence: 0.95
-//   },
-//   wilson: {
-//     proportion: 0.45,
-//     center: 0.453,
-//     lowerBound: 0.355,
-//     upperBound: 0.551,
-//     confidence: 0.95
-//   },
-//   recommended: {...} // Wilson interval for small samples
-// }
+**Returns:**
+```yaml
+type: prediction
+name: naive_bayes
+predictions:
+  - 0
+  - 1
+  - 1
 ```
 
 ---
 
-##### `variance(data, confidence)`
-Confidence interval for variance.
+## Clustering
 
-```javascript
-const data = [10, 12, 14, 16, 18, 20];
-const ci = datly.confidenceIntervals.variance(data, 0.95);
-console.log(ci);
-// {
-//   sampleVariance: 14.67,
-//   lowerBound: 6.23,
-//   upperBound: 73.33,
-//   confidence: 0.95
-// }
+### K-Means Clustering
+
+#### `train_kmeans(X, k = 3, options = {})`
+
+Trains a K-means clustering model.
+
+**Parameters:**
+- `X`: 2D array of features
+- `k`: Number of clusters (default: 3)
+- `options`:
+  - `max_iterations`: Maximum iterations (default: 100)
+  - `seed`: Random seed (default: 42)
+
+**Returns:**
+```yaml
+type: kmeans
+k: 3
+centroids:
+  - - 2.1
+    - 3.5
+  - - 5.8
+    - 6.2
+  - - 9.1
+    - 8.7
+inertia: 45.67
+n: 150
+p: 2
+```
+
+**Example:**
+```javascript
+const X = [[1, 2], [2, 3], [5, 6], [6, 7], [9, 8], [10, 9]];
+const model = datly.train_kmeans(X, 3, {
+  max_iterations: 100,
+  seed: 42
+});
 ```
 
----
+#### `predict_kmeans(model, X)`
 
-##### `meanDifference(sample1, sample2, confidence, equalVariances)`
-Confidence interval for difference between two means.
+Assigns cluster labels to new data points.
 
-```javascript
-const before = [120, 125, 130, 128, 122];
-const after = [115, 118, 125, 120, 115];
+**Returns:**
+```yaml
+type: prediction
+name: kmeans
+k: 3
+cluster_labels:
+  - 0
+  - 0
+  - 1
+  - 1
+  - 2
+  - 2
+```
 
-const ci = datly.confidenceIntervals.meanDifference(before, after, 0.95);
-console.log(ci);
-// {
-//   meanDifference: 9.2,
-//   sample1Mean: 125,
-//   sample2Mean: 115.8,
-//   lowerBound: 3.5,
-//   upperBound: 14.9,
-//   confidence: 0.95
-// }
+**Example:**
+```javascript
+const newData = [[1.5, 2.5], [5.5, 6.5], [9.5, 8.5]];
+const clusters = datly.predict_kmeans(model, newData);
 ```
 
 ---
 
-##### `correlation(x, y, confidence, method)`
-Confidence interval for correlation coefficient.
+## Ensemble Methods
 
-```javascript
-const x = [1, 2, 3, 4, 5];
-const y = [2, 4, 5, 4, 5];
+### `ensemble_voting_classifier(models, X, method = 'hard')`
 
-const ci = datly.confidenceIntervals.correlation(x, y, 0.95);
-console.log(ci);
-// {
-//   correlation: 0.775,
-//   fisherZ: 1.033,
-//   lowerBound: 0.034,
-//   upperBound: 0.965,
-//   confidence: 0.95
-// }
+Combines multiple classifier predictions through voting.
+
+**Parameters:**
+- `models`: Array of trained model texts/objects
+- `X`: 2D array of features
+- `method`: 'hard' for majority voting, 'soft' for probability averaging
+
+**Returns:**
+```yaml
+type: ensemble_prediction
+method: voting_hard
+n_models: 3
+predictions:
+  - 0
+  - 1
+  - 1
+  - 0
+```
+
+**Example:**
+```javascript
+const model1 = datly.train_logistic_regression(X, y);
+const model2 = datly.train_knn_classifier(X, y, 5);
+const model3 = datly.train_decision_tree_classifier(X, y);
+
+const ensemble = datly.ensemble_voting_classifier(
+  [model1, model2, model3],
+  X_test,
+  'hard'
+);
 ```
 
----
+### `ensemble_voting_regressor(models, X)`
 
-##### `bootstrapCI(data, statistic, confidence, iterations)`
-Bootstrap confidence interval.
+Combines multiple regressor predictions through averaging.
 
+**Returns:**
+```yaml
+type: ensemble_prediction
+method: voting_average
+n_models: 3
+predictions:
+  - 105.3
+  - 110.7
+  - 98.2
+```
+
+**Example:**
 ```javascript
-const data = [23, 25, 27, 29, 31];
+const model1 = datly.train_linear_regression(X, y);
+const model2 = datly.train_knn_regressor(X, y, 5);
+const model3 = datly.train_decision_tree_regressor(X, y);
 
-// Bootstrap CI for median
-const ci = datly.confidenceIntervals.bootstrapCI(data, 'median', 0.95, 1000);
-console.log(ci);
-// {
-//   originalStatistic: 27,
-//   bootstrapMean: 27.1,
-//   bias: 0.1,
-//   standardError: 1.4,
-//   lowerBound: 24.5,
-//   upperBound: 29.8,
-//   confidence: 0.95,
-//   iterations: 1000
-// }
+const ensemble = datly.ensemble_voting_regressor(
+  [model1, model2, model3],
+  X_test
+);
 ```
 
 ---
 
-### 10. Normality Tests
+## Model Evaluation
+
+### `train_test_split(X, y, test_size = 0.2, seed = 42)`
 
-Test if data follows normal distribution.
+Splits data into training and testing sets.
 
-#### Methods
+**Parameters:**
+- `X`: 2D array of features
+- `y`: Array of labels
+- `test_size`: Proportion for test set (default: 0.2)
+- `seed`: Random seed (default: 42)
 
-##### `shapiroWilk(data, alpha)`
-Shapiro-Wilk test (most powerful for small samples).
+**Returns:**
+```yaml
+type: split
+sizes:
+  train: 80
+  test: 20
+indices:
+  train:
+    - 0
+    - 2
+    - 3
+    ...
+  test:
+    - 1
+    - 4
+    ...
+preview:
+  x_train:
+    - - 1
+      - 2
+    - - 3
+      - 4
+  y_train:
+    - 0
+    - 1
+    - 0
+```
 
+**Example:**
 ```javascript
-const data = [2.3, 2.5, 2.7, 2.9, 3.1, 3.3, 3.5];
-const sw = datly.normalityTests.shapiroWilk(data);
-console.log(sw);
-// {
-//   statistic: 0.96,
-//   pValue: 0.82,
-//   isNormal: true,
-//   alpha: 0.05,
-//   interpretation: "Fail to reject null hypothesis..."
-// }
+const split = datly.train_test_split(X, y, 0.2, 42);
+// Use split.indices to extract train/test data
 ```
 
-**Best for:** Sample sizes 3-5000
+### Classification Metrics
 
----
+#### `metrics_classification(y_true, y_pred)`
+
+Calculates classification metrics including accuracy, precision, recall, and F1-score.
 
-##### `kolmogorovSmirnov(data, alpha)`
-Kolmogorov-Smirnov test.
+**Returns:**
+```yaml
+type: metric
+name: classification_report
+confusion_matrix:
+  tp: 45
+  fp: 5
+  tn: 42
+  fn: 8
+accuracy: 0.87
+precision: 0.9
+recall: 0.849
+f1: 0.874
+```
 
+**Example:**
 ```javascript
-const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-const ks = datly.normalityTests.kolmogorovSmirnov(data);
-console.log(ks);
-// {
-//   statistic: 0.15,
-//   pValue: 0.95,
-//   isNormal: true,
-//   lambda: 0.47
-// }
+const y_true = [0, 1, 1, 0, 1, 1, 0, 0];
+const y_pred = [0, 1, 0, 0, 1, 1, 0, 1];
+const metrics = datly.metrics_classification(y_true, y_pred);
 ```
 
-**Best for:** Large samples, continuous data
+### Regression Metrics
 
----
+#### `metrics_regression(y_true, y_pred)`
 
-##### `andersonDarling(data, alpha)`
-Anderson-Darling test (sensitive to tails).
+Calculates regression metrics including MSE, MAE, and R².
+
+**Returns:**
+```yaml
+type: metric
+name: regression_report
+mse: 12.34
+mae: 2.87
+r2: 0.856
+```
 
+**Example:**
 ```javascript
-const data = [10, 12, 14, 15, 16, 18, 20];
-const ad = datly.normalityTests.andersonDarling(data);
-console.log(ad);
-// {
-//   statistic: 0.234,
-//   adjustedStatistic: 0.247,
-//   pValue: 0.75,
-//   isNormal: true
-// }
+const y_true = [3.0, 5.0, 7.0, 9.0];
+const y_pred = [2.8, 5.2, 6.9, 9.1];
+const metrics = datly.metrics_regression(y_true, y_pred);
 ```
 
-**Best for:** Detecting tail deviations
+### Cross Validation
 
----
+#### `cross_validate(X, y, model_type, options = {})`
 
-##### `jarqueBera(data, alpha)`
-Jarque-Bera test (based on skewness and kurtosis).
+Performs k-fold cross-validation.
 
-```javascript
-const data = [5, 6, 7, 8, 9, 10, 11, 12];
-const jb = datly.normalityTests.jarqueBera(data);
-console.log(jb);
-// {
-//   statistic: 0.45,
-//   pValue: 0.80,
-//   skewness: 0,
-//   excessKurtosis: -1.2,
-//   isNormal: true
-// }
+**Parameters:**
+- `X`: 2D array of features
+- `y`: Array of labels
+- `model_type`: String - 'linear_regression', 'logistic_regression', 'knn_classifier', 'decision_tree_classifier', 'random_forest_classifier'
+- `options`:
+  - `k_folds`: Number of folds (default: 5)
+  - Model-specific options (e.g., `k` for KNN, `max_depth` for trees)
+
+**Returns:**
+```yaml
+type: cross_validation
+model_type: logistic_regression
+k_folds: 5
+scores:
+  - 0.85
+  - 0.88
+  - 0.82
+  - 0.87
+  - 0.86
+mean_score: 0.856
+std_score: 0.022
+```
+
+**Example:**
+```javascript
+const cv = datly.cross_validate(X, y, 'logistic_regression', {
+  k_folds: 5,
+  learning_rate: 0.1,
+  iterations: 1000
+});
 ```
 
-**Best for:** Large samples (n > 30)
-
----
+### Feature Importance
 
-##### `dagoTest(data, alpha)`
-D'Agostino K² test.
+#### `feature_importance_tree(model)`
 
-```javascript
-const data = Array.from({ length: 50 }, () => Math.random() * 10);
-const dago = datly.normalityTests.dagoTest(data);
-console.log(dago);
-// {
-//   statistic: 2.34,
-//   pValue: 0.31,
-//   isNormal: true,
-//   skewness: 0.23,
-//   excessKurtosis: -0.45
-// }
-```
+Extracts feature importance from tree-based models.
 
-**Best for:** Medium to large samples (n ≥ 20)
+**Parameters:**
+- `model`: Trained decision tree or random forest model
 
----
+**Returns:**
+```yaml
+type: feature_importance
+model: random_forest_classifier
+n_trees: 10
+importance:
+  - 0.45
+  - 0.32
+  - 0.15
+  - 0.08
+```
 
-##### `batchNormalityTest(data, alpha)`
-Run all normality tests at once.
-
-```javascript
-const data = [12, 14, 15, 16, 17, 18, 20, 22];
-const batch = datly.normalityTests.batchNormalityTest(data);
-console.log(batch);
-// {
-//   individualTests: {
-//     shapiroWilk: {...},
-//     jarqueBera: {...},
-//     andersonDarling: {...},
-//     kolmogorovSmirnov: {...}
-//   },
-//   summary: {
-//     testsRun: 4,
-//     testsPassingNormality: 4,
-//     consensusNormal: true,
-//     strongNormalEvidence: true
-//   },
-//   recommendation: "Strong evidence for normality..."
-// }
+**Example:**
+```javascript
+const model = datly.train_random_forest_classifier(X, y);
+const importance = datly.feature_importance_tree(model);
 ```
 
 ---
 
-### 11. Correlation Analysis
+## Data Preprocessing
 
-Measure relationships between variables.
+### Scaling
 
-#### Methods
+#### `standard_scaler_fit(X)`
 
-##### `pearson(x, y)`
-Pearson correlation (linear relationships).
+Fits a standard scaler (z-score normalization).
 
-```javascript
-const height = [160, 165, 170, 175, 180];
-const weight = [55, 60, 65, 70, 75];
+**Returns:**
+```yaml
+type: standard_scaler
+params:
+  - mean: 50.5
+    std: 15.2
+  - mean: 100.3
+    std: 25.7
+n: 100
+p: 2
+```
 
-const corr = datly.correlation.pearson(height, weight);
-console.log(corr);
-// {
-//   correlation: 1.0,
-//   pValue: 0.000,
-//   tStatistic: Infinity,
-//   significant: true,
-//   confidenceInterval: { lower: 1.0, upper: 1.0 }
-// }
+**Example:**
+```javascript
+const X = [[50, 100], [60, 120], [40, 90]];
+const scaler = datly.standard_scaler_fit(X);
 ```
 
-**Range:** -1 (perfect negative) to +1 (perfect positive)
+#### `standard_scaler_transform(scaler, X)`
 
-**Interpretation:**
-- |r| < 0.3: Weak
-- 0.3 ≤ |r| < 0.7: Moderate
-- |r| ≥ 0.7: Strong
+Transforms data using fitted standard scaler.
 
----
-
-##### `spearman(x, y)`
-Spearman correlation (monotonic relationships, rank-based).
-
-```javascript
-const x = [1, 2, 3, 4, 5];
-const y = [1, 4, 9, 16, 25]; // Non-linear but monotonic
-
-const corr = datly.correlation.spearman(x, y);
-console.log(corr);
-// {
-//   correlation: 1.0,
-//   pValue: 0.000,
-//   significant: true,
-//   xRanks: [1, 2, 3, 4, 5],
-//   yRanks: [1, 2, 3, 4, 5]
-// }
+**Returns:**
+```yaml
+type: scaled_data
+method: standard
+preview:
+  - - 0.0
+    - 0.0
+  - - 0.625
+    - 0.767
+  - - -0.625
+    - -0.767
 ```
 
-**Use when:** Data is ordinal or non-linear
-
----
-
-##### `kendall(x, y)`
-Kendall's Tau correlation.
-
+**Example:**
 ```javascript
-const x = [1, 2, 3, 4, 5];
-const y = [2, 1, 4, 3, 5];
-
-const corr = datly.correlation.kendall(x, y);
-console.log(corr);
-// {
-//   correlation: 0.6,
-//   pValue: 0.142,
-//   zStatistic: 1.47,
-//   concordantPairs: 8,
-//   discordantPairs: 2,
-//   significant: false
-// }
+const scaled = datly.standard_scaler_transform(scaler, X);
 ```
 
-**Use when:** Small sample sizes, ordinal data
+#### `minmax_scaler_fit(X)`
 
----
+Fits a min-max scaler (scales to [0, 1] range).
 
-##### `matrix(dataset, method)`
-Correlation matrix for multiple variables.
-
-```javascript
-const data = {
-  headers: ['age', 'income', 'spending'],
-  data: [
-    { age: 25, income: 30000, spending: 20000 },
-    { age: 30, income: 40000, spending: 25000 },
-    { age: 35, income: 50000, spending: 30000 },
-    { age: 40, income: 60000, spending: 35000 }
-  ]
-};
-
-const matrix = datly.correlation.matrix(data, 'pearson');
-console.log(matrix);
-// {
-//   correlations: {
-//     age: { age: 1, income: 1, spending: 1 },
-//     income: { age: 1, income: 1, spending: 1 },
-//     spending: { age: 1, income: 1, spending: 1 }
-//   },
-//   pValues: {...},
-//   strongCorrelations: [
-//     { variable1: 'age', variable2: 'income', correlation: 1.0 }
-//   ]
-// }
+**Returns:**
+```yaml
+type: minmax_scaler
+params:
+  - min: 40
+    max: 60
+  - min: 90
+    max: 120
+n: 100
+p: 2
 ```
 
----
+#### `minmax_scaler_transform(scaler, X)`
 
-##### `partialCorrelation(x, y, z)`
-Partial correlation (controlling for third variable).
-
-```javascript
-const x = [1, 2, 3, 4, 5];
-const y = [2, 3, 4, 5, 6];
-const z = [1, 1, 2, 2, 3]; // Control variable
+Transforms data using fitted min-max scaler.
 
-const partial = datly.correlation.partialCorrelation(x, y, z);
-console.log(partial);
-// {
-//   correlation: 0.95,
-//   pValue: 0.013,
-//   significant: true,
-//   controllingFor: 'third variable'
-// }
+**Returns:**
+```yaml
+type: scaled_data
+method: minmax
+preview:
+  - - 0.5
+    - 0.333
+  - - 1.0
+    - 1.0
+  - - 0.0
+    - 0.0
 ```
 
 ---
 
-##### `covariance(x, y, sample)`
-Calculate covariance.
+## Dimensionality Reduction
 
-```javascript
-const x = [1, 2, 3, 4, 5];
-const y = [2, 4, 6, 8, 10];
+### Principal Component Analysis (PCA)
 
-// Sample covariance
-const cov = datly.correlation.covariance(x, y, true);
-console.log(cov);
-// {
-//   covariance: 5,
-//   meanX: 3,
-//   meanY: 6,
-//   sampleSize: 5
-// }
-```
+#### `train_pca(X, n_components = 2)`
 
----
+Trains a PCA model.
 
-### 12. Regression Analysis
-
-Model relationships and make predictions.
-
-#### Methods
-
-##### `linear(x, y)`
-Simple linear regression.
-
-```javascript
-const x = [1, 2, 3, 4, 5];
-const y = [2, 4, 5, 4, 5];
-
-const model = datly.regression.linear(x, y);
-console.log(model);
-// {
-//   slope: 0.6,
-//   intercept: 2.2,
-//   rSquared: 0.46,
-//   adjustedRSquared: 0.28,
-//   equation: 'y = 2.2000 + 0.6000x',
-//   pValueSlope: 0.158,
-//   pValueModel: 0.158,
-//   residuals: [-0.2, 0.2, 0.4, -1.0, 0.6],
-//   predicted: [2.8, 3.4, 4.0, 4.6, 5.2]
-// }
-```
-
----
-
-##### `multiple(dataset, dependent, independents)`
-Multiple linear regression.
-
-```javascript
-const data = {
-  headers: ['sales', 'advertising', 'price', 'competition'],
-  data: [
-    { sales: 100, advertising: 10, price: 50, competition: 3 },
-    { sales: 150, advertising: 15, price: 45, competition: 2 },
-    { sales: 120, advertising: 12, price: 48, competition: 4 },
-    { sales: 180, advertising: 20, price: 40, competition: 1 }
-  ]
-};
-
-const model = datly.regression.multiple(
-  data,
-  'sales',
-  ['advertising', 'price', 'competition']
-);
-
-console.log(model);
-// {
-//   coefficients: [
-//     { variable: 'Intercept', coefficient: 50, pValue: 0.05 },
-//     { variable: 'advertising', coefficient: 5.5, pValue: 0.01 },
-//     { variable: 'price', coefficient: -2.1, pValue: 0.03 },
-//     { variable: 'competition', coefficient: -10, pValue: 0.02 }
-//   ],
-//   rSquared: 0.95,
-//   adjustedRSquared: 0.90,
-//   fStatistic: 19.0,
-//   pValueModel: 0.001,
-//   equation: 'y = 50.0000 + 5.5000*advertising + -2.1000*price + -10.0000*competition'
-// }
-```
-
----
-
-##### `polynomial(x, y, degree)`
-Polynomial regression.
-
-```javascript
-const x = [1, 2, 3, 4, 5];
-const y = [1, 4, 9, 16, 25]; // y = x²
-
-const model = datly.regression.polynomial(x, y, 2);
-console.log(model);
-// {
-//   coefficients: [0, 0, 1], // y = 0 + 0x + 1x²
-//   degree: 2,
-//   rSquared: 1.0,
-//   equation: 'y = 0.0000 + 0.0000*x + 1.0000*x^2',
-//   predicted: [1, 4, 9, 16, 25]
-// }
-```
-
----
-
-##### `logistic(x, y, maxIterations, tolerance)`
-Logistic regression (binary classification).
-
-```javascript
-const x = [1, 2, 3, 4, 5, 6];
-const y = [0, 0, 0, 1, 1, 1]; // Binary outcome
-
-const model = datly.regression.logistic(x, y);
-console.log(model);
-// {
-//   intercept: -3.5,
-//   slope: 1.2,
-//   probabilities: [0.12, 0.23, 0.38, 0.55, 0.70, 0.81],
-//   predicted: [0, 0, 0, 1, 1, 1],
-//   accuracy: 1.0,
-//   logLikelihood: -2.1,
-//   mcFaddenR2: 0.68
-// }
-```
-
----
-
-##### `predict(model, x)`
-Make predictions using fitted model.
-
-```javascript
-// After fitting a model
-const newX = [6, 7, 8];
-const predictions = datly.regression.predict(model, newX);
-console.log(predictions); // [5.8, 6.4, 7.0]
-```
-
----
+**Parameters:**
+- `X`: 2D array of features
+- `n_components`: Number of principal components (default: 2)
 
-### 13. Report Generation
-
-Generate comprehensive statistical reports.
-
-#### Methods
-
-##### `summary(dataset)`
-Generate complete statistical summary.
-
-```javascript
-const data = {
-  headers: ['age', 'income', 'department'],
-  data: [
-    { age: 25, income: 30000, department: 'Sales' },
-    { age: 30, income: 45000, department: 'IT' },
-    { age: 35, income: 50000, department: 'Sales' },
-    { age: 40, income: 60000, department: 'IT' }
-  ],
-  length: 4,
-  columns: 3
-};
-
-const report = datly.reportGenerator.summary(data);
-console.log(report);
-// {
-//   title: 'Statistical Summary Report',
-//   generatedAt: '2025-01-15T10:30:00.000Z',
-//   basicInfo: {
-//     totalRows: 4,
-//     totalColumns: 3,
-//     headers: ['age', 'income', 'department']
-//   },
-//   columnAnalysis: {
-//     age: {
-//       type: 'numeric',
-//       mean: 32.5,
-//       median: 32.5,
-//       min: 25,
-//       max: 40,
-//       standardDeviation: 6.45
-//     },
-//     income: {
-//       type: 'numeric',
-//       mean: 46250,
-//       median: 47500,
-//       ...
-//     },
-//     department: {
-//       type: 'categorical',
-//       categories: [...],
-//       mostFrequent: { value: 'Sales', frequency: 2 }
-//     }
-//   },
-//   dataQuality: {
-//     overallScore: 95,
-//     completenessScore: 100,
-//     consistencyScore: 90
-//   },
-//   keyInsights: [
-//     {
-//       type: 'correlation',
-//       title: 'Strong correlation between age and income',
-//       importance: 8
-//     }
-//   ],
-//   recommendations: [...]
-// }
+**Returns:**
+```yaml
+type: pca
+n_components: 2
+means:
+  - 50.5
+  - 100.3
+  - 75.8
+components:
+  - - 0.707
+    - 0.707
+    - 0.0
+  - - -0.707
+    - 0.707
+    - 0.0
+n: 100
+p: 3
 ```
 
----
-
-##### `exportSummary(summary, format)`
-Export report in different formats.
-
+**Example:**
 ```javascript
-const report = datly.reportGenerator.summary(data);
-
-// Export as JSON
-const json = datly.reportGenerator.exportSummary(report, 'json');
-
-// Export as text
-const text = datly.reportGenerator.exportSummary(report, 'text');
-console.log(text);
-// STATISTICAL SUMMARY REPORT
-// Generated: 1/15/2025, 10:30:00 AM
-// ==================================================
-//
-// BASIC INFORMATION
-// --------------------
-// Rows: 4
-// Columns: 3
-// ...
-
-// Export as CSV
-const csv = datly.reportGenerator.exportSummary(report, 'csv');
-```
-
----
-
-### 14. Pattern Detection
-
-Automatically detect patterns in data.
-
-#### Methods
-
-##### `analyze(dataset)`
-Comprehensive pattern analysis.
-
-```javascript
-const data = {
-  headers: ['date', 'sales', 'temperature'],
-  data: [
-    { date: '2024-01-01', sales: 100, temperature: 20 },
-    { date: '2024-01-02', sales: 110, temperature: 22 },
-    { date: '2024-01-03', sales: 105, temperature: 21 },
-    { date: '2024-01-04', sales: 115, temperature: 23 }
-  ],
-  length: 4,
-  columns: 3
-};
-
-const patterns = datly.patternDetector.analyze(data);
-console.log(patterns);
-// {
-//   patterns: {
-//     trends: [
-//       {
-//         column: 'sales',
-//         direction: 'increasing',
-//         slope: 5,
-//         rSquared: 0.75,
-//         strength: 'strong'
-//       }
-//     ],
-//     seasonality: [...],
-//     outliers: [...],
-//     correlations: {
-//       strongCorrelations: [
-//         {
-//           variable1: 'sales',
-//           variable2: 'temperature',
-//           correlation: 0.95,
-//           strength: 'very_strong'
-//         }
-//       ]
-//     },
-//     distributions: [...],
-//     clustering: [...],
-//     temporal: [...]
-//   },
-//   insights: [
-//     {
-//       type: 'trend',
-//       importance: 'high',
-//       message: 'Found 1 strong trend(s) in your data',
-//       details: ['sales: increasing trend']
-//     }
-//   ]
-// }
-```
-
----
-
-### 15. Result Interpretation
-
-Interpret statistical test results in plain language.
-
-#### Methods
-
-##### `interpret(testResult)`
-Interpret any statistical test result.
-
-```javascript
-// After performing a t-test
-const tTestResult = datly.hypothesisTesting.tTest(group1, group2);
-
-const interpretation = datly.interpreter.interpret(tTestResult);
-console.log(interpretation);
-// {
-//   testType: 't-test',
-//   summary: 'significant difference between groups (t = -3.46, p = 0.008)',
-//   conclusion: {
-//     decision: 'reject_null',
-//     statement: 'At the 95% confidence level, we reject the null hypothesis',
-//     pValue: 0.008,
-//     confidenceLevel: 95
-//   },
-//   significance: {
-//     level: 'strong',
-//     pValue: 0.008,
-//     interpretation: 'Strong evidence against null hypothesis',
-//     isSignificant: true
-//   },
-//   effectSize: {
-//     value: 0.85,
-//     magnitude: 'Large',
-//     interpretation: 'large effect size'
-//   },
-//   plainLanguage: '✓ SIGNIFICANT RESULT: Found a meaningful difference between the groups. (p-value: 0.0080)',
-//   recommendations: [
-//     'Very strong result - investigate practical significance',
-//     'Replicate findings with independent data when possible'
-//   ]
-// }
+const X = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
+const pca = datly.train_pca(X, 2);
 ```
 
----
-
-### 16. Auto-Analysis
-
-Automated end-to-end analysis.
-
-#### Methods
+#### `transform_pca(model, X)`
 
-##### `autoAnalyze(dataset, options)`
-Perform comprehensive automatic analysis.
+Transforms data to principal component space.
 
-```javascript
-const data = {
-  headers: ['age', 'income', 'gender', 'purchase'],
-  data: [
-    { age: 25, income: 30000, gender: 'M', purchase: 100 },
-    { age: 30, income: 45000, gender: 'F', purchase: 150 },
-    { age: 35, income: 50000, gender: 'M', purchase: 120 },
-    { age: 40, income: 60000, gender: 'F', purchase: 180 },
-    // ... more data
-  ],
-  length: 100,
-  columns: 4
-};
-
-const analysis = datly.autoAnalyzer.autoAnalyze(data, {
-  minCorrelationThreshold: 0.3,
-  significanceLevel: 0.05,
-  generateVisualizations: true,
-  includeAdvancedAnalysis: true
-});
-
-console.log(analysis);
-// {
-//   metadata: {
-//     analysisDate: '2025-01-15T10:30:00.000Z',
-//     datasetSize: 100,
-//     columnsAnalyzed: 4
-//   },
-//   variableClassification: {
-//     quantitative: [
-//       { name: 'age', type: 'quantitative', subtype: 'discrete' },
-//       { name: 'income', type: 'quantitative', subtype: 'continuous' },
-//       { name: 'purchase', type: 'quantitative', subtype: 'continuous' }
-//     ],
-//     qualitative: [
-//       { name: 'gender', type: 'binary', categories: ['M', 'F'] }
-//     ]
-//   },
-//   descriptiveStatistics: {
-//     age: { mean: 32.5, median: 32, std: 6.45, ... },
-//     income: { mean: 46250, median: 47500, ... },
-//     purchase: { mean: 137.5, median: 135, ... }
-//   },
-//   correlationAnalysis: {
-//     strongCorrelations: [
-//       {
-//         variable1: 'income',
-//         variable2: 'purchase',
-//         correlation: 0.92,
-//         significance: true
-//       }
-//     ]
-//   },
-//   regressionAnalysis: {
-//     models: [
-//       {
-//         independent: 'income',
-//         dependent: 'purchase',
-//         rSquared: 0.85,
-//         significant: true,
-//         equation: 'y = 10.5 + 0.0025*income'
-//       }
-//     ]
-//   },
-//   distributionAnalysis: {
-//     age: {
-//       isNormal: true,
-//       normalityPValue: 0.15,
-//       skewness: 0.12,
-//       distributionType: 'normal'
-//     }
-//   },
-//   outlierAnalysis: {
-//     income: {
-//       count: 2,
-//       percentage: 2,
-//       severity: 'low'
-//     }
-//   },
-//   insights: [
-//     {
-//       category: 'overview',
-//       priority: 'high',
-//       title: 'Dataset Composition',
-//       description: 'Dataset with 100 records, 3 numeric and 1 categorical variables',
-//       icon: '📊'
-//     },
-//     {
-//       category: 'correlation',
-//       priority: 'high',
-//       title: 'Very strong correlation between income and purchase',
-//       description: 'Positive correlation of 0.920',
-//       icon: '🔗'
-//     }
-//   ],
-//   visualizationSuggestions: [
-//     {
-//       type: 'scatter',
-//       variables: ['income', 'purchase'],
-//       priority: 'high',
-//       title: 'income vs purchase'
-//     },
-//     {
-//       type: 'histogram',
-//       variable: 'age',
-//       priority: 'medium',
-//       title: 'Distribution of age'
-//     }
-//   ],
-//   summary: {
-//     totalInsights: 8,
-//     highPriorityInsights: 3,
-//     keyFindings: [...],
-//     recommendations: [
-//       'Explore correlations identified for possible predictive modeling',
-//       'Consider transformations for non-normal distributions'
-//     ]
-//   }
-// }
+**Returns:**
+```yaml
+type: pca_transform
+n_components: 2
+preview:
+  - - 2.121
+    - 0.0
+  - - 0.707
+    - 0.0
+  - - -1.414
+    - 0.0
 ```
 
----
-
-### 17. Machine Learning
-
-Build and train ML models.
-
-#### Creating Models
-
-##### Linear Regression
-
+**Example:**
 ```javascript
-// Create model
-const model = datly.ml.createLinearRegression({
-  learningRate: 0.01,
-  iterations: 1000,
-  regularization: 'l2', // 'l1', 'l2', or null
-  lambda: 0.01
-});
-
-// Prepare data
-const X = [
-  [1, 2],
-  [2, 3],
-  [3, 4],
-  [4, 5]
-];
-const y = [3, 5, 7, 9];
-
-// Train model
-model.fit(X, y, true); // true = normalize features
-
-// Make predictions
-const predictions = model.predict([[5, 6]]);
-console.log(predictions); // [11]
-
-// Evaluate model
-const score = model.score(X, y);
-console.log(score);
-// {
-//   r2Score: 1.0,
-//   mse: 0.0,
-//   rmse: 0.0,
-//   mae: 0.0
-// }
+const transformed = datly.transform_pca(pca, X);
 ```
 
 ---
 
-##### Logistic Regression
+## Time Series Analysis
 
-```javascript
-// Create model for classification
-const model = datly.ml.createLogisticRegression({
-  learningRate: 0.01,
-  iterations: 1000
-});
+### `moving_average(array, window = 3)`
 
-// Binary classification data
-const X = [
-  [1, 2], [2, 3], [3, 4], [4, 5],
-  [5, 6], [6, 7], [7, 8], [8, 9]
-];
-const y = [0, 0, 0, 0, 1, 1, 1, 1];
-
-// Train
-model.fit(X, y);
-
-// Predict classes
-const predictions = model.predict([[3.5, 4.5], [7, 8]]);
-console.log(predictions); // [0, 1]
+Calculates moving average.
 
-// Predict probabilities
-const probabilities = model.predictProba([[3.5, 4.5]]);
-console.log(probabilities); // [{ 0: 0.62, 1: 0.38 }]
+**Parameters:**
+- `array`: Time series data
+- `window`: Window size (default: 3)
 
-// Evaluate
-const score = model.score(X, y);
-console.log(score);
-// {
-//   accuracy: 1.0,
-//   confusionMatrix: {...},
-//   classMetrics: {...}
-// }
+**Returns:**
+```yaml
+type: time_series
+method: moving_average
+window: 3
+values:
+  - 10
+  - 15
+  - 20
+  - 22
+  - 25
 ```
 
----
-
-##### K-Nearest Neighbors (KNN)
-
+**Example:**
 ```javascript
-// Create KNN model
-const model = datly.ml.createKNN({
-  k: 5,
-  metric: 'euclidean', // 'euclidean', 'manhattan', 'minkowski'
-  weights: 'uniform'   // 'uniform' or 'distance'
-});
-
-// Prepare data
-const X = [
-  [1, 2], [2, 3], [3, 4],
-  [6, 7], [7, 8], [8, 9]
-];
-const y = [0, 0, 0, 1, 1, 1]; // Classes
-
-// Train (KNN just stores the data)
-model.fit(X, y, true, 'classification');
-
-// Predict
-const predictions = model.predict([[2, 2], [7, 7]]);
-console.log(predictions); // [0, 1]
-
-// Predict with probabilities
-const proba = model.predictProba([[4, 5]]);
-console.log(proba); // [{ 0: 0.4, 1: 0.6 }]
+const data = [10, 20, 30, 20, 30, 25];
+const ma = datly.moving_average(data, 3);
 ```
 
----
-
-##### Decision Tree
-
-```javascript
-// Create decision tree
-const model = datly.ml.createDecisionTree({
-  maxDepth: 10,
-  minSamplesSplit: 2,
-  minSamplesLeaf: 1,
-  criterion: 'gini' // 'gini' or 'entropy'
-});
-
-// Train
-const X = [
-  [2.5], [3.5], [4.5], [5.5], [6.5], [7.5]
-];
-const y = [0, 0, 1, 1, 2, 2]; // Multi-class
+### `exponential_smoothing(array, alpha = 0.3)`
 
-model.fit(X, y, 'classification');
+Applies exponential smoothing.
 
-// Predict
-const predictions = model.predict([[3.0], [6.0]]);
-console.log(predictions); // [0, 1]
-
-// Get feature importance
-const importance = model.getFeatureImportance();
-console.log(importance); // { feature_0: 1.0 }
+**Parameters:**
+- `array`: Time series data
+- `alpha`: Smoothing parameter (0 < α < 1)
 
-// Model summary
-const summary = model.summary();
-console.log(summary);
-// {
-//   modelType: 'Decision Tree',
-//   taskType: 'classification',
-//   trainingMetrics: {
-//     treeDepth: 3,
-//     leafCount: 6,
-//     nodeCount: 11
-//   }
-// }
+**Returns:**
+```yaml
+type: time_series
+method: exponential_smoothing
+alpha: 0.3
+values:
+  - 10
+  - 13
+  - 18.1
+  - 18.47
+  - 21.73
 ```
 
----
-
-##### Random Forest
-
+**Example:**
 ```javascript
-// Create random forest
-const model = datly.ml.createRandomForest({
-  nEstimators: 100,    // Number of trees
-  maxDepth: 10,
-  minSamplesSplit: 2,
-  maxFeatures: 'sqrt', // 'sqrt', 'log2', or number
-  bootstrap: true
-});
-
-// Train
-const X = [
-  [1, 2], [2, 3], [3, 4], [4, 5],
-  [5, 6], [6, 7], [7, 8], [8, 9]
-];
-const y = ['A', 'A', 'A', 'B', 'B', 'C', 'C', 'C'];
-
-model.fit(X, y, 'classification');
-
-// Predict
-const predictions = model.predict([[2.5, 3.5], [7, 8]]);
-console.log(predictions); // ['A', 'C']
-
-// Get feature importance
-const importance = model.getFeatureImportance();
-console.log(importance); // [0.6, 0.4]
+const smoothed = datly.exponential_smoothing(data, 0.3);
 ```
 
----
-
-##### Naive Bayes
-
-```javascript
-// Create Naive Bayes classifier
-const model = datly.ml.createNaiveBayes({
-  type: 'gaussian' // 'gaussian', 'multinomial', or 'bernoulli'
-});
-
-// Train
-const X = [
-  [1, 2], [2, 3], [3, 4],
-  [5, 6], [6, 7], [7, 8]
-];
-const y = ['spam', 'spam', 'spam', 'ham', 'ham', 'ham'];
+### `autocorrelation(array, lag = 1)`
 
-model.fit(X, y);
+Calculates autocorrelation at a given lag.
 
-// Predict
-const predictions = model.predict([[2, 2], [6, 6]]);
-console.log(predictions); // ['spam', 'ham']
+**Parameters:**
+- `array`: Time series data
+- `lag`: Lag value (default: 1)
 
-// Predict probabilities
-const proba = model.predictProba([[4, 5]]);
-console.log(proba); // [{ spam: 0.3, ham: 0.7 }]
+**Returns:**
+```yaml
+type: statistic
+name: autocorrelation
+lag: 1
+value: 0.456
 ```
 
----
-
-##### Support Vector Machine (SVM)
-
+**Example:**
 ```javascript
-// Create SVM
-const model = datly.ml.createSVM({
-  C: 1.0,              // Regularization parameter
-  kernel: 'linear',    // 'linear', 'rbf', 'poly'
-  gamma: 'scale',      // 'scale', 'auto', or number
-  degree: 3,           // For polynomial kernel
-  learningRate: 0.001,
-  iterations: 1000
-});
-
-// Train
-const X = [
-  [1, 2], [2, 3], [3, 4],
-  [6, 7], [7, 8], [8, 9]
-];
-const y = [0, 0, 0, 1, 1, 1];
-
-model.fit(X, y);
-
-// Predict
-const predictions = model.predict([[2, 2], [7, 7]]);
-console.log(predictions); // [0, 1]
-
-// Summary
-const summary = model.summary();
-console.log(summary.trainingMetrics.nSupportVectors); // Number of support vectors
+const acf = datly.autocorrelation(data, 1);
 ```
 
 ---
 
-#### Model Utilities
+## Outlier Detection
 
-##### Train-Test Split
+### `outliers_iqr(array)`
 
-```javascript
-const X = [[1, 2], [2, 3], [3, 4], [4, 5], [5, 6]];
-const y = [0, 0, 1, 1, 1];
+Detects outliers using the IQR (Interquartile Range) method.
 
-const split = datly.ml.trainTestSplit(X, y, 0.2, true);
-// {
-//   X_train: [[...], [...], [...]],  // 80% of data
-//   X_test: [[...], [...]],           // 20% of data
-//   y_train: [0, 1, 1],
-//   y_test: [0, 1]
-// }
+**Returns:**
+```yaml
+type: outlier_detection
+method: iqr
+lower_bound: 45.5
+upper_bound: 154.5
+n_outliers: 3
+outlier_indices:
+  - 5
+  - 12
+  - 23
+outlier_values:
+  - 200
+  - 30
+  - 180
 ```
 
----
-
-##### Cross-Validation
-
+**Example:**
 ```javascript
-const model = datly.ml.createKNN({ k: 3 });
-const X = [[1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9]];
-const y = [0, 0, 0, 0, 1, 1, 1, 1];
-
-const cv = datly.ml.crossValidate(model, X, y, 5, 'classification');
-console.log(cv);
-// {
-//   scores: [1.0, 0.8, 1.0, 0.8, 0.9],
-//   meanScore: 0.9,
-//   stdScore: 0.089,
-//   folds: 5
-// }
+const data = [50, 55, 60, 65, 70, 200, 75, 80];
+const outliers = datly.outliers_iqr(data);
 ```
 
----
-
-##### Compare Models
+### `outliers_zscore(array, threshold = 3)`
 
-```javascript
-const X = [[1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7]];
-const y = [0, 0, 0, 1, 1, 1];
+Detects outliers using z-score method.
 
-const models = [
-  { name: 'KNN', model: datly.ml.createKNN({ k: 3 }) },
-  { name: 'Decision Tree', model: datly.ml.createDecisionTree() },
-  { name: 'Logistic Regression', model: datly.ml.createLogisticRegression() }
-];
+**Parameters:**
+- `array`: Array of numbers
+- `threshold`: Z-score threshold (default: 3)
 
-const comparison = datly.ml.compareModels(models, X, y, 'classification');
-console.log(comparison);
-// {
-//   results: [
-//     { name: 'KNN', score: 0.95, trainTime: 5, evalTime: 2 },
-//     { name: 'Decision Tree', score: 0.90, trainTime: 15, evalTime: 1 },
-//     { name: 'Logistic Regression', score: 0.85, trainTime: 100, evalTime: 1 }
-//   ],
-//   bestModel: { name: 'KNN', score: 0.95, ... },
-//   comparison: "📊 MODEL COMPARISON REPORT\n..."
-// }
+**Returns:**
+```yaml
+type: outlier_detection
+method: zscore
+threshold: 3
+n_outliers: 2
+outlier_indices:
+  - 5
+  - 12
+outlier_values:
+  - 200
+  - 30
 ```
 
----
-
-##### Quick Train (One-liner)
-
+**Example:**
 ```javascript
-// Train and evaluate a model in one line
-const result = datly.ml.quickTrain(
-  'randomforest',  // Model type
-  X,               // Features
-  y,               // Target
-  {
-    taskType: 'classification',
-    testSize: 0.2,
-    normalize: true,
-    nEstimators: 50
-  }
-);
-
-console.log(result);
-// {
-//   model: RandomForest {...},
-//   score: {
-//     accuracy: 0.95,
-//     confusionMatrix: {...}
-//   },
-//   trainTime: 150,
-//   summary: {...}
-// }
+const outliers = datly.outliers_zscore(data, 3);
 ```
 
 ---
 
-##### Feature Engineering
+## Visualization
 
-```javascript
-// Polynomial features
-const X = [[1], [2], [3]];
-const polyFeatures = datly.ml.polynomialFeatures(X, 2);
-console.log(polyFeatures);
-// [[1, 1], [2, 4], [3, 9]] // [x, x²]
+All visualization functions create SVG-based charts. They accept optional configuration and a selector for where to render the chart.
 
-// Standard scaling
-const data = [[1, 2], [3, 4], [5, 6]];
-const scaler = datly.ml.standardScaler(data);
-console.log(scaler.scaled);
-// [[-1.22, -1.22], [0, 0], [1.22, 1.22]]
+### Configuration Options
 
-// Transform new data
-const newData = [[2, 3]];
-const scaled = scaler.transform(newData);
-console.log(scaled);
+Common options for all plots:
+- `width`: Chart width in pixels (default: 400)
+- `height`: Chart height in pixels (default: 400)
+- `color`: Primary color (default: '#000')
+- `background`: Background color (default: '#fff')
+- `title`: Chart title
+- `xlabel`: X-axis label
+- `ylabel`: Y-axis label
 
-// Min-Max scaling
-const minMaxScaler = datly.ml.minMaxScaler(data, [0, 1]);
-console.log(minMaxScaler.scaled);
-// [[0, 0], [0.5, 0.5], [1, 1]]
-```
+### `plotHistogram(array, options = {}, selector)`
 
----
+Creates a histogram.
 
-##### ROC Curve
+**Additional Options:**
+- `bins`: Number of bins (default: 10)
 
+**Example:**
 ```javascript
-const yTrue = [0, 0, 1, 1, 1, 0, 1, 0];
-const yProba = [0.1, 0.3, 0.6, 0.8, 0.9, 0.2, 0.7, 0.4];
-
-const roc = datly.ml.rocCurve(yTrue, yProba);
-console.log(roc);
-// {
-//   fpr: [0, 0, 0.25, 0.25, 0.5, ...],
-//   tpr: [0, 0.2, 0.2, 0.4, 0.4, ...],
-//   auc: 0.85,  // Area Under Curve
-//   thresholds: [...]
-// }
-```
-
----
-
-##### Precision-Recall Curve
-
-```javascript
-const yTrue = [0, 0, 1, 1, 1, 0, 1, 0];
-const yProba = [0.1, 0.3, 0.6, 0.8, 0.9, 0.2, 0.7, 0.4];
-
-const pr = datly.ml.precisionRecallCurve(yTrue, yProba);
-console.log(pr);
-// {
-//   precision: [0.5, 0.6, 0.67, ...],
-//   recall: [1.0, 0.8, 0.67, ...],
-//   thresholds: [...]
-// }
+const data = [1, 2, 2, 3, 3, 3, 4, 4, 5];
+datly.plotHistogram(data, {
+  width: 600,
+  height: 400,
+  bins: 10,
+  title: 'Distribution',
+  color: '#4CAF50'
+}, '#chart');
 ```
 
----
+### `plotScatter(x, y, options = {}, selector)`
 
-### 18. Data Visualization
+Creates a scatter plot.
 
-Create interactive D3.js visualizations
-
-#### Setup
+**Additional Options:**
+- `size`: Point size (default: 4)
 
+**Example:**
 ```javascript
-// Initialize visualizer
-const viz = datly.viz;
-
-// Or create custom container
-const customViz = new Datly.Visualizer('my-container-id');
+const x = [1, 2, 3, 4, 5];
+const y = [2, 4, 3, 5, 6];
+datly.plotScatter(x, y, {
+  width: 600,
+  height: 400,
+  title: 'Scatter Plot',
+  xlabel: 'X Variable',
+  ylabel: 'Y Variable',
+  size: 5
+}, '#chart');
 ```
 
----
+### `plotLine(x, y, options = {}, selector)`
 
-#### Methods
+Creates a line chart.
 
-##### `histogram(data, options)`
+**Additional Options:**
+- `lineWidth`: Line width (default: 2)
+- `showPoints`: Show data points (default: false)
 
+**Example:**
 ```javascript
-const ages = [23, 25, 27, 29, 31, 33, 35, 37, 39, 41];
-
-datly.plotHistogram(ages, {
-  title: 'Age Distribution',
-  xlabel: 'Age',
-  ylabel: 'Frequency',
-  bins: 10,
-  color: '#4299e1',
-  width: 800,
-  height: 600
-});
+const x = [1, 2, 3, 4, 5];
+const y = [2, 4, 3, 5, 6];
+datly.plotLine(x, y, {
+  lineWidth: 3,
+  showPoints: true,
+  title: 'Time Series'
+}, '#chart');
 ```
 
----
+### `plotBar(categories, values, options = {}, selector)`
 
-##### `boxplot(data, options)`
+Creates a bar chart.
 
+**Example:**
 ```javascript
-// Single box plot
-const data1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 100];
-datly.plotBoxplot(data1, {
-  title: 'Sales Distribution',
-  ylabel: 'Sales ($)'
-});
-
-// Multiple box plots
-const groupA = [20, 22, 23, 25, 27];
-const groupB = [30, 32, 35, 37, 40];
-const groupC = [25, 27, 29, 31, 33];
-
-datly.plotBoxplot([groupA, groupB, groupC], {
-  title: 'Sales by Region',
-  labels: ['North', 'South', 'East'],
+const categories = ['A', 'B', 'C', 'D'];
+const values = [10, 25, 15, 30];
+datly.plotBar(categories, values, {
+  title: 'Sales by Category',
   ylabel: 'Sales ($)'
-});
+}, '#chart');
 ```
 
----
-
-##### `scatter(x, y, options)`
+### `plotBoxplot(data, options = {}, selector)`
 
-```javascript
-const height = [160, 165, 170, 175, 180, 185];
-const weight = [55, 60, 65, 70, 75, 80];
+Creates box plots for one or more groups.
 
-datly.plotScatter(height, weight, {
-  title: 'Height vs Weight',
-  xlabel: 'Height (cm)',
-  ylabel: 'Weight (kg)',
-  color: '#e74c3c',
-  size: 6,
-  labels: ['Person 1', 'Person 2', ...] // Optional
-});
-```
-
----
-
-##### `line(x, y, options)`
+**Parameters:**
+- `data`: Array of arrays (each array is a group) or single array
+- `options`:
+  - `labels`: Array of group labels
 
+**Example:**
 ```javascript
-const months = [1, 2, 3, 4, 5, 6];
-const revenue = [100, 120, 140, 130, 160, 180];
+const group1 = [1, 2, 3, 4, 5, 6];
+const group2 = [2, 3, 4, 5, 6, 7];
+const group3 = [3, 4, 5, 6, 7, 8];
 
-datly.plotLine(months, revenue, {
-  title: 'Monthly Revenue',
-  xlabel: 'Month',
-  ylabel: 'Revenue ($1000)',
-  color: '#2ecc71',
-  lineWidth: 3,
-  showPoints: true
-});
+datly.plotBoxplot([group1, group2, group3], {
+  labels: ['Group A', 'Group B', 'Group C'],
+  title: 'Comparison'
+}, '#chart');
 ```
 
----
-
-##### `bar(categories, values, options)`
-
-```javascript
-const products = ['Product A', 'Product B', 'Product C'];
-const sales = [150, 230, 180];
-
-datly.plotBar(products, sales, {
-  title: 'Sales by Product',
-  xlabel: 'Product',
-  ylabel: 'Sales',
-  color: '#f39c12',
-  horizontal: false // Set to true for horizontal bars
-});
-```
+### `plotPie(labels, values, options = {}, selector)`
 
----
+Creates a pie chart.
 
-##### `pie(labels, values, options)`
+**Additional Options:**
+- `showLabels`: Display labels (default: true)
 
+**Example:**
 ```javascript
-const categories = ['Electronics', 'Clothing', 'Food', 'Other'];
-const amounts = [35, 25, 20, 20];
-
-datly.plotPie(categories, amounts, {
-  title: 'Sales Distribution',
-  showLabels: true,
-  showPercentage: true
-});
+const labels = ['Category A', 'Category B', 'Category C'];
+const values = [30, 45, 25];
+datly.plotPie(labels, values, {
+  title: 'Market Share',
+  showLabels: true
+}, '#chart');
 ```
 
----
+### `plotHeatmap(matrix, options = {}, selector)`
 
-##### `heatmap(matrix, options)`
+Creates a heatmap for a correlation matrix.
 
+**Additional Options:**
+- `labels`: Array of variable names
+- `showValues`: Display correlation values (default: true)
+
+**Example:**
 ```javascript
-const correlationMatrix = [
+const corrMatrix = [
   [1.0, 0.8, 0.3],
   [0.8, 1.0, 0.5],
   [0.3, 0.5, 1.0]
 ];
 
-datly.plotHeatmap(correlationMatrix, {
-  title: 'Correlation Heatmap',
+datly.plotHeatmap(corrMatrix, {
   labels: ['Var1', 'Var2', 'Var3'],
-  colorScheme: 'RdBu', // Color scheme
-  showValues: true
-});
+  showValues: true,
+  title: 'Correlation Matrix'
+}, '#chart');
 ```
 
----
+### `plotViolin(data, options = {}, selector)`
+
+Creates violin plots showing distribution density.
 
-##### `violin(data, options)`
+**Parameters:**
+- `data`: Array of arrays or single array
+- `options`:
+  - `labels`: Group labels
 
+**Example:**
 ```javascript
-const groupA = [1, 2, 3, 4, 5, 6, 7];
-const groupB = [3, 4, 5, 6, 7, 8, 9];
+const group1 = [1, 2, 2, 3, 3, 3, 4, 4, 5];
+const group2 = [2, 3, 3, 4, 4, 4, 5, 5, 6];
 
-datly.plotViolin([groupA, groupB], {
-  title: 'Distribution Comparison',
-  labels: ['Control', 'Treatment'],
-  ylabel: 'Value',
-  color: '#9b59b6'
-});
+datly.plotViolin([group1, group2], {
+  labels: ['Before', 'After'],
+  title: 'Distribution Comparison'
+}, '#chart');
 ```
 
----
+### `plotDensity(array, options = {}, selector)`
 
-##### `density(data, options)`
+Creates a kernel density plot.
 
-```javascript
-const data = [23, 25, 27, 29, 31, 33, 35];
+**Additional Options:**
+- `bandwidth`: Smoothing bandwidth (default: 5)
 
+**Example:**
+```javascript
+const data = [1, 2, 2, 3, 3, 3, 4, 4, 5];
 datly.plotDensity(data, {
-  title: 'Density Plot',
-  xlabel: 'Value',
-  ylabel: 'Density',
-  color: '#1abc9c',
-  bandwidth: null // Auto-calculate or specify
-});
+  bandwidth: 0.5,
+  title: 'Density Plot'
+}, '#chart');
 ```
 
----
+### `plotQQ(array, options = {}, selector)`
 
-##### `qqplot(data, options)`
+Creates a Q-Q plot for normality assessment.
 
+**Example:**
 ```javascript
-const data = [2.3, 2.5, 2.7, 2.9, 3.1, 3.3];
-
+const data = [1.2, 2.3, 1.8, 2.1, 1.9, 2.0, 2.4];
 datly.plotQQ(data, {
-  title: 'Q-Q Plot',
-  xlabel: 'Theoretical Quantiles',
-  ylabel: 'Sample Quantiles',
-  color: '#34495e'
-});
+  title: 'Q-Q Plot'
+}, '#chart');
 ```
 
----
+### `plotParallel(data, columns, options = {}, selector)`
+
+Creates a parallel coordinates plot.
 
-##### `parallel(data, dimensions, options)`
+**Parameters:**
+- `data`: Array of objects
+- `columns`: Array of column names to include
+- `options`:
+  - `colors`: Array of colors for each observation
 
+**Example:**
 ```javascript
 const data = [
-  { age: 25, income: 30000, spending: 15000, satisfaction: 7 },
-  { age: 30, income: 45000, spending: 20000, satisfaction: 8 },
-  { age: 35, income: 60000, spending: 25000, satisfaction: 9 }
+  { age: 25, salary: 50000, experience: 2 },
+  { age: 30, salary: 60000, experience: 5 },
+  { age: 35, salary: 70000, experience: 8 }
 ];
 
-datly.plotParallel(data, ['age', 'income', 'spending', 'satisfaction'], {
-  title: 'Parallel Coordinates Plot',
-  colors: ['#e74c3c', '#3498db', '#2ecc71']
-});
+datly.plotParallel(data, ['age', 'salary', 'experience'], {
+  title: 'Parallel Coordinates'
+}, '#chart');
 ```
 
----
+### `plotPairplot(data, columns, options = {}, selector)`
 
-##### `pairplot(data, columns, options)`
+Creates a pairplot matrix showing all pairwise relationships.
 
+**Parameters:**
+- `data`: Array of objects
+- `columns`: Array of column names
+- `options`:
+  - `size`: Size of each subplot (default: 120)
+  - `color`: Point color
+
+**Example:**
 ```javascript
 const data = [
-  { height: 160, weight: 55, age: 25 },
-  { height: 165, weight: 60, age: 30 },
-  { height: 170, weight: 65, age: 35 }
+  { age: 25, salary: 50000, experience: 2 },
+  { age: 30, salary: 60000, experience: 5 },
+  { age: 35, salary: 70000, experience: 8 }
 ];
 
-datly.plotPairplot(data, ['height', 'weight', 'age'], {
-  title: 'Pair Plot',
-  color: '#3498db',
-  size: 3
-});
+datly.plotPairplot(data, ['age', 'salary', 'experience'], {
+  size: 150
+}, '#chart');
 ```
 
----
+### `plotMultiline(series, options = {}, selector)`
+
+Creates a multi-line chart for comparing time series.
 
-##### `multiline(series, options)`
+**Parameters:**
+- `series`: Array of objects with `name` and `data` properties
+  - `data`: Array of `{x, y}` objects
+- `options`:
+  - `legend`: Show legend (default: false)
 
+**Example:**
 ```javascript
 const series = [
   {
     name: 'Series A',
-    data: [
-      { x: 1, y: 10 },
-      { x: 2, y: 15 },
-      { x: 3, y: 12 }
-    ]
+    data: [{x: 1, y: 10}, {x: 2, y: 20}, {x: 3, y: 15}]
   },
   {
     name: 'Series B',
-    data: [
-      { x: 1, y: 5 },
-      { x: 2, y: 8 },
-      { x: 3, y: 10 }
-    ]
+    data: [{x: 1, y: 15}, {x: 2, y: 25}, {x: 3, y: 20}]
   }
 ];
 
 datly.plotMultiline(series, {
-  title: 'Multiple Time Series',
-  xlabel: 'Time',
-  ylabel: 'Value',
-  legend: true
-});
+  legend: true,
+  title: 'Comparison'
+}, '#chart');
 ```
 
 ---
 
-##### Special Visualization Methods
-
-```javascript
-// Correlation matrix heatmap from dataset
-const data = {
-  headers: ['var1', 'var2', 'var3'],
-  data: [
-    { var1: 1, var2: 2, var3: 3 },
-    { var1: 2, var2: 4, var3: 5 },
-    { var1: 3, var2: 5, var3: 7 }
-  ]
-};
+## Complete Example Workflow
 
-datly.plotCorrelationMatrix(data, {
-  title: 'Correlation Matrix'
-});
-
-// Distribution plot from dataset column
-datly.plotDistribution(data, 'var1', {
-  title: 'Distribution of var1'
-});
-
-// Compare multiple distributions
-datly.plotMultipleDistributions(data, ['var1', 'var2', 'var3'], {
-  title: 'Distribution Comparison'
-});
-```
-
----
-
-## 🎯 Complete Examples
-
-### Example 1: Comprehensive Data Analysis
+Here's a complete example demonstrating a typical data analysis workflow:
 
 ```javascript
-const datly = new Datly();
-
-// Load data
-const data = datly.dataLoader.loadCSV('sales_data.csv');
-
-// Validate data
-const validation = datly.validator.validateData(data);
-if (!validation.valid) {
-  console.error('Data validation failed:', validation.errors);
-}
-
-// Get descriptive statistics
-const sales = datly.dataLoader.getColumn(data, 'sales');
-console.log('Mean Sales:', datly.centralTendency.mean(sales));
-console.log('Median Sales:', datly.centralTendency.median(sales));
-console.log('Std Dev:', datly.dispersion.standardDeviation(sales));
-
-// Check for outliers
-const outliers = datly.utils.detectOutliers(sales, 'iqr');
-console.log('Outliers:', outliers);
-
-// Test normality
-const normalityTest = datly.normalityTests.shapiroWilk(sales);
-console.log('Is Normal:', normalityTest.isNormal);
-
-// Generate report
-const report = datly.reportGenerator.summary(data);
-console.log(report);
-
-datly.plotHistogram(sales, { title: 'Sales Distribution' });
-datly.plotBoxplot(sales, { title: 'Sales Box Plot' });
-```
-
----
-
-### Example 2: Hypothesis Testing Workflow
-
-```javascript
-const datly = new Datly();
-
-// Two groups to compare
-const controlGroup = [23, 25, 27, 29, 31, 33];
-const treatmentGroup = [28, 30, 32, 34, 36, 38];
+// 1. Load and explore data
+const data = [
+  { age: 25, salary: 50000, experience: 2, department: 'IT' },
+  { age: 30, salary: 60000, experience: 5, department: 'HR' },
+  { age: 35, salary: 70000, experience: 8, department: 'IT' },
+  // ... more data
+];
 
-// Perform t-test
-const tTest = datly.hypothesisTesting.tTest(
-  controlGroup,
-  treatmentGroup,
-  'two-sample'
+// 2. Perform EDA
+const overview = datly.eda_overview(data);
+console.log(overview);
+
+// 3. Check correlations
+const correlations = datly.df_corr(data, 'pearson');
+console.log(correlations);
+
+// 4. Prepare features and target
+const X = data.map(d => [d.age, d.experience]);
+const y = data.map(d => d.salary);
+
+// 5. Split data
+const split = datly.train_test_split(X, y, 0.2, 42);
+const trainIndices = split.indices.train;
+const testIndices = split.indices.test;
+
+const X_train = trainIndices.map(i => X[i]);
+const y_train = trainIndices.map(i => y[i]);
+const X_test = testIndices.map(i => X[i]);
+const y_test = testIndices.map(i => y[i]);
+
+// 6. Scale features
+const scaler = datly.standard_scaler_fit(X_train);
+const X_train_scaled = datly.standard_scaler_transform(scaler, X_train);
+const X_test_scaled = datly.standard_scaler_transform(scaler, X_test);
+
+// 7. Train model
+const model = datly.train_linear_regression(
+  JSON.parse(X_train_scaled).preview,
+  y_train
 );
 
-// Interpret results
-const interpretation = datly.interpreter.interpret(tTest);
-console.log(interpretation.plainLanguage);
-console.log('Decision:', interpretation.conclusion.decision);
-console.log('Effect Size:', interpretation.effectSize.magnitude);
-
-// Calculate confidence interval for difference
-const ci = datly.confidenceIntervals.meanDifference(
-  controlGroup,
-  treatmentGroup,
-  0.95
+// 8. Make predictions
+const predictions = datly.predict_linear(
+  model,
+  JSON.parse(X_test_scaled).preview
 );
-console.log('95% CI for difference:', ci.lowerBound, 'to', ci.upperBound);
-
-datly.plotBoxplot([controlGroup, treatmentGroup], {
-  title: 'Control vs Treatment',
-  labels: ['Control', 'Treatment']
-});
-```
-
----
 
-### Example 3: Correlation and Regression
-
-```javascript
-const datly = new Datly();
-
-const data = {
-  headers: ['advertising', 'sales'],
-  data: [
-    { advertising: 10, sales: 100 },
-    { advertising: 15, sales: 150 },
-    { advertising: 20, sales: 180 },
-    { advertising: 25, sales: 230 },
-    { advertising: 30, sales: 270 }
-  ]
-};
-
-// Extract columns
-const advertising = datly.dataLoader.getColumn(data, 'advertising');
-const sales = datly.dataLoader.getColumn(data, 'sales');
-
-// Calculate correlation
-const correlation = datly.correlation.pearson(advertising, sales);
-console.log('Correlation:', correlation.correlation);
-console.log('P-value:', correlation.pValue);
-
-// Fit regression model
-const model = datly.regression.linear(advertising, sales);
-console.log('Equation:', model.equation);
-console.log('R²:', model.rSquared);
-console.log('Model significant:', model.pValueModel < 0.05);
-
-// Make prediction
-const newAdvertising = [35];
-const prediction = datly.regression.predict(model, newAdvertising);
-console.log('Predicted sales for $35k advertising:', prediction[0]);
-
-datly.plotScatter(advertising, sales, {
-  title: 'Advertising vs Sales',
-  xlabel: 'Advertising Budget ($1000)',
-  ylabel: 'Sales ($1000)'
-});
-```
-
----
-
-### Example 4: Machine Learning Pipeline
-
-```javascript
-const datly = new Datly();
-
-// Load data
-const data = datly.dataLoader.loadJSON('iris.json');
-
-// Prepare features and target
-const X = data.data.map(row => [
-  row.sepal_length,
-  row.sepal_width,
-  row.petal_length,
-  row.petal_width
-]);
-const y = data.data.map(row => row.species);
-
-// Split data
-const split = datly.ml.trainTestSplit(X, y, 0.2, true);
-
-// Create and train model
-const model = datly.ml.createRandomForest({
-  nEstimators: 100,
-  maxDepth: 10
-});
-
-model.fit(split.X_train, split.y_train, 'classification');
-
-// Evaluate
-const score = model.score(split.X_test, split.y_test);
-console.log('Accuracy:', score.accuracy);
-console.log('Confusion Matrix:', score.confusionMatrix.display);
-
-// Cross-validation
-const cv = datly.ml.crossValidate(model, X, y, 5, 'classification');
-console.log('CV Mean Score:', cv.meanScore);
-console.log('CV Std:', cv.stdScore);
-
-// Feature importance
-const importance = model.getFeatureImportance();
-console.log('Feature Importance:', importance);
-```
-
----
-
-### Example 5: Automatic Analysis
-
-```javascript
-const datly = new Datly();
-
-// Load your data
-const data = datly.dataLoader.loadCSV('customer_data.csv');
-
-// Run automatic analysis
-const analysis = datly.autoAnalyzer.autoAnalyze(data, {
-  minCorrelationThreshold: 0.5,
-  significanceLevel: 0.05,
-  generateVisualizations: true
-});
-
-// View insights
-analysis.insights.forEach(insight => {
-  console.log(`${insight.icon} [${insight.priority}] ${insight.title}`);
-  console.log(`   ${insight.description}`);
-  if (insight.recommendation) {
-    console.log(`   → ${insight.recommendation}`);
-  }
-});
-
-// View recommended visualizations
-analysis.visualizationSuggestions.forEach(viz => {
-  console.log(`📊 ${viz.title} (${viz.type}) - Priority: ${viz.priority}`);
-});
-
-// Generate report
-const textReport = datly.reportGenerator.exportSummary(
-  analysis,
-  'text'
+// 9. Evaluate model
+const metrics = datly.metrics_regression(
+  y_test,
+  JSON.parse(predictions).predictions
 );
-console.log(textReport);
-```
-
----
+console.log(metrics);
 
-## 📖 API Reference
-
-### Core Classes
-
-- **`DataLoader`**: Load and manipulate datasets
-- **`Validator`**: Validate data integrity
-- **`Utils`**: Utility functions for data analysis
-- **`CentralTendency`**: Mean, median, mode calculations
-- **`Dispersion`**: Variance, standard deviation measures
-- **`Position`**: Quantiles, percentiles, rankings
-- **`Shape`**: Skewness and kurtosis analysis
-- **`HypothesisTesting`**: Statistical tests
-- **`ConfidenceIntervals`**: Interval estimation
-- **`NormalityTests`**: Test for normal distribution
-- **`Correlation`**: Correlation analysis
-- **`Regression`**: Regression modeling
-- **`ReportGenerator`**: Generate statistical reports
-- **`PatternDetector`**: Detect patterns in data
-- **`Interpreter`**: Interpret statistical results
-- **`AutoAnalyzer`**: Automated analysis
-- **`ML`**: Machine learning models
-- **`Visualizer`**: Data visualization
-
----
-
-## 🌐 Browser Support
-
-- Chrome (latest)
-- Firefox (latest)
-- Safari (latest)
-- Edge (latest)
-
-**Requirements:**
-- Modern JavaScript (ES6+)
+// 10. Visualize results
+datly.plotScatter(y_test, JSON.parse(predictions).predictions, {
+  title: 'Actual vs Predicted',
+  xlabel: 'Actual',
+  ylabel: 'Predicted'
+}, '#results');
+```
 
 ---
 
-## 🤝 Contributing
-
-Contributions are welcome! Please follow these steps:
+## Tips and Best Practices
 
-1. Fork the repository
-2. Create a feature branch (`git checkout -b feature/AmazingFeature`)
-3. Commit your changes (`git commit -m 'Add AmazingFeature'`)
-4. Push to the branch (`git push origin feature/AmazingFeature`)
-5. Open a Pull Request
+1. **Data Preparation**: Always check for missing values and outliers before analysis
+2. **Feature Scaling**: Scale features before training distance-based models (KNN, SVM)
+3. **Cross-Validation**: Use cross-validation to assess model performance reliably
+4. **Model Selection**: Start with simple models (linear regression) before trying complex ones
+5. **Hyperparameter Tuning**: Experiment with different hyperparameters (k in KNN, max_depth in trees)
+6. **Visualization**: Always visualize your data and results to gain insights
+7. **Statistical Tests**: Check assumptions (normality, homogeneity) before parametric tests
 
 ---
 
-## 📝 License
-
-MIT License
+## License
 
-Copyright (c) 2025 Datly
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software.
+This documentation is provided as-is. Please refer to the library's official repository for licensing information.
 
 ---
 
-## 📧 Contact
-
-For questions, issues, or feature requests:
-- GitHub Issues: [github.com/yourrepo/datly/issues](https://github.com/yourrepo/datly/issues)
-- NPM Package: [npmjs.com/package/datly](https://npmjs.com/package/datly)
+## Support
 
-**Made with ❤️ for the data science community**
+For issues, questions, or contributions, please visit the official Datly.js repository.