feat: new article

Author: DiogoRibeiro7

_posts/2019-12-29-understanding_splines_what_they_are_and_how_they_are_used_in_data_analysis.md renamed to _posts/2019-12-29-understanding_splines_what_they_how_they_used_data_analysis.md

@@ -20,6 +20,9 @@ keywords:
 - Nonlinear Models
 - Data Smoothing
 - Statistical Modeling
+- python
+- bash
+- go
 seo_description: Splines are flexible mathematical tools used for smoothing and modeling complex data patterns. Learn what they are, how they work, and their practical applications in regression, data smoothing, and machine learning.
 seo_title: What Are Splines? A Deep Dive into Their Uses in Data Analysis
 seo_type: article
@@ -29,6 +32,9 @@ tags:
 - Regression
 - Data Smoothing
 - Nonlinear Models
+- python
+- bash
+- go
 title: 'Understanding Splines: What They Are and How They Are Used in Data Analysis'
 ---
 
@@ -167,3 +173,227 @@ Splines are a versatile and powerful tool for modeling nonlinear relationships,
 From **cubic splines** for smooth curve fitting to **B-splines** for handling noise, and **natural splines** to avoid overfitting, splines give you the ability to model complex data without the limitations of traditional polynomial regression. Whether you’re a statistician, data scientist, or machine learning engineer, understanding how to use splines can enhance your ability to model and interpret data with **greater precision**.
 
 If you're dealing with **nonlinear patterns** in data, consider giving splines a try. With their balance of flexibility and smoothness, they just might be the tool you need to uncover the true relationship hiding in your data.
+
+## Appendix: Python Code for Splines
+
+Below is an example of how to use splines in Python with the `scipy` and `statsmodels` libraries. The code demonstrates fitting a spline to data, plotting the result, and using spline regression to model nonlinear relationships.
+
+### Fitting a Cubic Spline with `scipy`
+
+```python
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.interpolate import CubicSpline
+
+# Generate example data
+x = np.linspace(0, 10, 10)
+y = np.sin(x) + 0.1 * np.random.randn(10)  # Adding some noise
+
+# Fit a cubic spline
+cs = CubicSpline(x, y)
+
+# Generate finer points for smooth plotting
+x_fine = np.linspace(0, 10, 100)
+y_fine = cs(x_fine)
+
+# Plot the original data and the fitted spline
+plt.scatter(x, y, label='Data', color='red')
+plt.plot(x_fine, y_fine, label='Cubic Spline', color='blue')
+plt.title('Cubic Spline Fit')
+plt.legend()
+plt.show()
+```
+
+### B-Spline Fitting with `scipy`
+  
+  ```python
+  from scipy.interpolate import splrep, splev
+
+# Example data
+x = np.linspace(0, 10, 10)
+y = np.sin(x) + 0.1 * np.random.randn(10)
+
+# Fit B-spline (degree 3)
+tck = splrep(x, y, k=3)
+
+# Evaluate the spline at finer points
+x_fine = np.linspace(0, 10, 100)
+y_fine = splev(x_fine, tck)
+
+# Plot the result
+plt.scatter(x, y, label='Data', color='red')
+plt.plot(x_fine, y_fine, label='B-Spline', color='green')
+plt.title('B-Spline Fit')
+plt.legend()
+plt.show()
+```
+
+### Spline Regression with `statsmodels`
+  
+  ```python
+  import statsmodels.api as sm
+from patsy import dmatrix
+
+# Generate synthetic data for regression
+np.random.seed(123)
+x = np.linspace(0, 10, 100)
+y = np.sin(x) + np.random.normal(scale=0.3, size=100)
+
+# Create a cubic spline basis for regression
+transformed_x = dmatrix("bs(x, df=6, degree=3, include_intercept=True)", {"x": x})
+
+# Fit the spline regression model
+model = sm.OLS(y, transformed_x).fit()
+
+# Generate predicted values
+y_pred = model.predict(transformed_x)
+
+# Plot original data and spline regression fit
+plt.scatter(x, y, facecolor='none', edgecolor='b', label='Data')
+plt.plot(x, y_pred, color='red', label='Spline Regression Fit')
+plt.title('Spline Regression with statsmodels')
+plt.legend()
+plt.show()
+```
+
+### Natural Cubic Spline with `patsy`
+
+```python
+# Using Natural Cubic Spline in statsmodels via patsy
+
+# Create a natural spline basis for regression
+transformed_x_ns = dmatrix("cr(x, df=4)", {"x": x}, return_type='dataframe')
+
+# Fit the natural spline regression model
+model_ns = sm.OLS(y, transformed_x_ns).fit()
+
+# Generate predicted values
+y_pred_ns = model_ns.predict(transformed_x_ns)
+
+# Plot the data and natural spline regression fit
+plt.scatter(x, y, facecolor='none', edgecolor='b', label='Data')
+plt.plot(x, y_pred_ns, color='orange', label='Natural Cubic Spline Fit')
+plt.title('Natural Cubic Spline Regression')
+plt.legend()
+plt.show()
+```
+
+## Appendix: Go Code for Splines
+
+In Go, there is no built-in support for splines, but we can use third-party packages like `gonum` to implement spline interpolation and regression. Below is an example of how to use splines in Go with the `gonum` package.
+
+### Installing Required Libraries
+
+You need to install `gonum` for numerical computing:
+
+```bash
+go get gonum.org/v1/gonum
+```
+
+### Cubic Spline Interpolation with `gonum`
+
+```go
+package main
+
+import (
+    "fmt"
+    "gonum.org/v1/gonum/floats"
+    "gonum.org/v1/gonum/interp"
+    "gonum.org/v1/plot"
+    "gonum.org/v1/plot/plotter"
+    "gonum.org/v1/plot/vg"
+    "math"
+)
+
+func main() {
+    // Example data points
+    x := []float64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+    y := make([]float64, len(x))
+    for i, v := range x {
+        y[i] = math.Sin(v) + 0.1*randFloat64() // Adding noise
+    }
+
+    // Fit cubic spline
+    spline := interp.Cubic{}
+    spline.Fit(x, y)
+
+    // Generate smoother points
+    xFine := linspace(0, 10, 100)
+    yFine := make([]float64, len(xFine))
+    for i, v := range xFine {
+        yFine[i] = spline.Predict(v)
+    }
+
+    // Plot the result
+    plotCubicSpline(x, y, xFine, yFine)
+}
+
+// Function to generate random noise
+func randFloat64() float64 {
+    return (2*math.RandFloat64() - 1) * 0.1
+}
+
+// linspace generates 'n' evenly spaced points between 'start' and 'end'
+func linspace(start, end float64, n int) []float64 {
+    result := make([]float64, n)
+    floats.Span(result, start, end)
+    return result
+}
+
+// plotCubicSpline plots the original data and the fitted cubic spline
+func plotCubicSpline(x, y, xFine, yFine []float64) {
+    p, _ := plot.New()
+    p.Title.Text = "Cubic Spline Interpolation"
+    p.X.Label.Text = "X"
+    p.Y.Label.Text = "Y"
+
+    // Plot original data
+    dataPoints := make(plotter.XYs, len(x))
+    for i := range x {
+        dataPoints[i].X = x[i]
+        dataPoints[i].Y = y[i]
+    }
+    scatter, _ := plotter.NewScatter(dataPoints)
+    scatter.GlyphStyle.Shape = draw.CircleGlyph{}
+    scatter.GlyphStyle.Radius = vg.Points(3)
+
+    // Plot cubic spline interpolation
+    splineLine := make(plotter.XYs, len(xFine))
+    for i := range xFine {
+        splineLine[i].X = xFine[i]
+        splineLine[i].Y = yFine[i]
+    }
+    line, _ := plotter.NewLine(splineLine)
+
+    // Add plots to plot
+    p.Add(scatter, line)
+    p.Save(6*vg.Inch, 6*vg.Inch, "cubic_spline.png")
+}
+```
+
+### B-Spline Fitting in Go (Manual Implementation)
+
+Go doesn’t have direct support for B-splines in `gonum`, so you might have to implement it manually or find a library that does. Below is a simple example that demonstrates cubic interpolation using `gonum`'s interpolation package.
+
+```go
+package main
+
+import (
+    "fmt"
+    "gonum.org/v1/gonum/interp"
+)
+
+func main() {
+    x := []float64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+    y := []float64{0, 0.84, 0.91, 0.14, -0.75, -1, -0.75, 0.14, 0.91, 0.84, 0}
+
+    // Create a cubic spline interpolator
+    spline := interp.Cubic{}
+    spline.Fit(x, y)
+
+    // Evaluate the spline at a new point
+    xEval := 6.5
+    yEval := spline.Predict(xEval)
+    fmt.Printf("Spline evaluation at x = %v: y = %v\n", xEval, yEval)
+}
+```