add newton_raphson (#28)

Author: felipeasimos

.github/workflows/CI.yml

@@ -14,7 +14,7 @@ jobs:
         with:
           submodules: recursive
           fetch-depth: 0
-      - uses: mlugg/setup-zig@v1
+      - uses: mlugg/setup-zig@v2
 
       - name: Testing
         run: zig run runall.zig
@@ -23,5 +23,5 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: mlugg/setup-zig@v1
+      - uses: mlugg/setup-zig@v2
       - run: zig fmt --check --ast-check */*.zig

DIRECTORY.md

@@ -28,6 +28,9 @@
   * [Gcd](https://github.com/TheAlgorithms/Zig/blob/HEAD/math/gcd.zig)
   * [Primes](https://github.com/TheAlgorithms/Zig/blob/HEAD/math/primes.zig)
 
+## Numerical Methods
+  * [Newton Raphson Root](https://github.com/TheAlgorithms/Zig/blob/HEAD/numerical_methods/newton_raphson_root.zig)
+
 ## [Runall](https://github.com/TheAlgorithms/Zig/blob/HEAD//runall.zig)
 
 ## Search

build.zig

@@ -216,6 +216,14 @@ pub fn build(b: *std.Build) void {
             .name = "k_means_clustering.zig",
             .category = "machine_learning",
         });
+    // Numerical Methods
+    if (std.mem.eql(u8, op, "numerical_methods/newton_raphson_root"))
+        buildAlgorithm(b, .{
+            .optimize = optimize,
+            .target = target,
+            .name = "newton_raphson_root.zig",
+            .category = "numerical_methods",
+        });
 }
 
 fn buildAlgorithm(b: *std.Build, info: BInfo) void {

numerical_methods/newton_raphson_root.zig

@@ -0,0 +1,76 @@
+const StopCondition = struct {
+    n_iterations: ?usize = 1000,
+    epsilon_from_root: ?f32 = 1e-15,
+};
+
+fn shouldStop(x: f32, n_iterations: usize, stop_condition: StopCondition, func: fn (f32) f32) bool {
+    if (stop_condition.n_iterations) |n_iterations_to_stop| {
+        if (n_iterations_to_stop <= n_iterations) {
+            return true;
+        }
+    }
+    if (stop_condition.epsilon_from_root) |epsilon_from_root| {
+        if (@abs(func(x)) <= epsilon_from_root) {
+            return true;
+        }
+    }
+    return false;
+}
+
+fn newtonRaphsonMethod(x: f32, stop_condition: StopCondition, func: fn (f32) f32, derivative: fn (f32) f32) f32 {
+    var n_iterations: usize = 0;
+    var guess = x;
+    while (!shouldStop(guess, n_iterations, stop_condition, func)) : (n_iterations += 1) {
+        guess -= func(guess) / derivative(guess);
+    }
+    return guess;
+}
+
+const std = @import("std");
+const expectApproxEqAbs = std.testing.expectApproxEqAbs;
+
+test "NewtonRaphsonMethod" {
+    try expectApproxEqAbs(
+        1.4142135623730951,
+        newtonRaphsonMethod(
+            1,
+            .{
+                .epsilon_from_root = 0.0001,
+                .n_iterations = 10,
+            },
+            (struct {
+                fn func(x: f32) f32 {
+                    return x * x - 2;
+                }
+            }).func,
+            (struct {
+                fn derivative(x: f32) f32 {
+                    return 2 * x;
+                }
+            }).derivative,
+        ),
+        0.0001,
+    );
+
+    try expectApproxEqAbs(
+        2,
+        newtonRaphsonMethod(
+            1,
+            .{
+                .epsilon_from_root = 0.000001,
+                .n_iterations = 100,
+            },
+            (struct {
+                fn func(x: f32) f32 {
+                    return x * x - 4;
+                }
+            }).func,
+            (struct {
+                fn derivative(x: f32) f32 {
+                    return 2 * x;
+                }
+            }).derivative,
+        ),
+        0.0001,
+    );
+}

runall.zig

@@ -48,6 +48,9 @@ pub fn main() !void {
 
     // Machine Learning
     try runTest(allocator, "machine_learning/k_means_clustering");
+
+    // Numerical Methods
+    try runTest(allocator, "numerical_methods/newton_raphson");
 }
 
 fn runTest(allocator: std.mem.Allocator, comptime algorithm: []const u8) !void {