📊 StatFlow

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import statflow as sf
import numpy as np

# Generate sample data
np.random.seed(42)
x = np.random.normal(100, 15, 1000)
y = np.random.normal(105, 15, 1000)

# Perform t-test
result = sf.ttest(x, y)
print(f"t-statistic: {result.statistic:.4f}")
print(f"p-value: {result.pvalue:.4f}")

# Fit a linear regression
model = sf.LinearRegression()
model.fit(x.reshape(-1, 1), y)
print(f"R-squared: {model.rsquared:.4f}")

1
2
3
4
dist = sf.Normal(mu=0, sigma=1)
samples = dist.sample(1000)
pdf_values = dist.pdf(samples)
cdf_values = dist.cdf(samples)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import statflow as sf
import numpy as np

# Simulate A/B test data
np.random.seed(42)
group_a_conversions = np.random.binomial(1, 0.10, 1000)  # 10% conversion
group_b_conversions = np.random.binomial(1, 0.12, 1000)  # 12% conversion

# Perform proportion test
result = sf.proportions_test(
    [group_a_conversions.sum(), group_b_conversions.sum()],
    [len(group_a_conversions), len(group_b_conversions)]
)

print(f"Group A conversion: {group_a_conversions.mean():.2%}")
print(f"Group B conversion: {group_b_conversions.mean():.2%}")
print(f"p-value: {result.pvalue:.4f}")

if result.pvalue < 0.05:
    print("Significant difference detected!")
else:
    print("No significant difference.")

1
2
3
4
5
6
7
8
9
10
11
# Simulate 20 hypothesis tests
p_values = [sf.ttest(
    np.random.normal(0, 1, 100),
    np.random.normal(0.2 if i < 5 else 0, 1, 100)
).pvalue for i in range(20)]

# Apply Benjamini-Hochberg correction
adjusted = sf.multipletests(p_values, method='fdr_bh', alpha=0.05)

print(f"Significant tests (uncorrected): {sum(p < 0.05 for p in p_values)}")
print(f"Significant tests (FDR corrected): {sum(adjusted.reject)}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import statflow as sf
import pandas as pd
import numpy as np

# Generate synthetic data
np.random.seed(42)
n = 200

data = pd.DataFrame({
    'hours_studied': np.random.uniform(0, 10, n),
    'sleep_hours': np.random.uniform(4, 10, n),
    'previous_score': np.random.uniform(50, 100, n)
})

# Generate exam scores with some noise
data['exam_score'] = (
    3.5 * data['hours_studied'] +
    2.0 * data['sleep_hours'] +
    0.5 * data['previous_score'] +
    np.random.normal(0, 5, n)
)

# Fit model
X = data[['hours_studied', 'sleep_hours', 'previous_score']]
y = data['exam_score']

model = sf.LinearRegression()
model.fit(X, y)

# Print summary
print(model.summary())

# Check assumptions
diagnostics = model.diagnostics()
print(f"Durbin-Watson: {diagnostics.durbin_watson:.2f}")
print(f"Condition Number: {diagnostics.condition_number:.2f}")

# Visualize residuals
model.plot_residuals()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# Binary classification
X = np.random.randn(500, 5)
z = 1.5*X[:, 0] - 0.8*X[:, 1] + np.random.randn(500)*0.5
y = (z > 0).astype(int)

model = sf.LogisticRegression()
model.fit(X, y)

# Predictions
probabilities = model.predict_proba(X)
predictions = model.predict(X)

# Evaluate
print(f"Accuracy: {(predictions == y).mean():.2%}")
print(f"AUC-ROC: {model.roc_auc_score(X, y):.4f}")

# Confusion matrix
print(model.confusion_matrix(y, predictions))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import statflow as sf
import numpy as np

# Generate AR(1) process
np.random.seed(42)
n = 500
rho = 0.7
y = np.zeros(n)
y[0] = np.random.randn()

for t in range(1, n):
    y[t] = rho * y[t-1] + np.random.randn()

# Compute autocorrelation
acf_values = sf.acf(y, nlags=20)
pacf_values = sf.pacf(y, nlags=20)

# Plot ACF/PACF
sf.plot_acf(y, lags=20)
sf.plot_pacf(y, lags=20)

# Test for stationarity
adf_result = sf.adfuller(y)
print(f"ADF Statistic: {adf_result.statistic:.4f}")
print(f"p-value: {adf_result.pvalue:.4f}")

1
2
3
4
5
6
7
8
9
# Noisy time series
t = np.linspace(0, 10, 200)
signal = np.sin(t) + 0.3 * np.random.randn(200)

# Apply moving average
smoothed = sf.moving_average(signal, window=10)

# Exponential smoothing
ema = sf.exponential_smoothing(signal, alpha=0.3)