jonas1ara/Numerical

This repository is a collection of standalone F\# programs that implement various numerical analysis algorithms. It provides concrete tools for solving ordinary differential equations, finding roots of functions, performing linear algebra operations, and approximating integrals and derivatives. The system serves as a practical reference library for these mathematical computations, standardized primarily on the .NET 8.0 framework.

Added a new F\# implementation of the Gaussian elimination algorithm in the src/Gaussian-elimination directory. This feature allows users to solve systems of linear equations by transforming the coefficient matrix into row-echelon form and performing backward substitution. The entry includes the core logic in Program.fs and documentation in README.md, providing a standalone executable example that demonstrates solving a 3x3 system.

src/Gaussian-elimination · high confidence

A new F\# program has been added to estimate the value of π using the Monte Carlo method. The implementation generates 1,000,000 random points within a unit square to calculate the proportion falling inside a quarter circle, providing a statistical approximation of π. Documentation and usage instructions are included in the accompanying README.

src/Monte-carlo-method-for-PI · high confidence

A new F\# program has been added to the src/Fourier-transform directory that implements the Discrete Fourier Transform (DFT) for arrays of complex numbers. The application includes a core calculation function, a helper to print complex arrays, and a main execution block that processes a sample input of four complex values and outputs the resulting frequency domain data.

src/Fourier-transform · high confidence

A new F\# application has been added to the \src/Gradient-descent\ directory, implementing the Gradient Descent optimization algorithm to find optimal parameters for a linear regression model. The code defines a cost function and its partial derivatives, then iteratively updates parameters (theta0 and theta1) using a specified learning rate and iteration count. The entry point demonstrates the algorithm using hardcoded sample data and prints the resulting optimal parameters.

src/Gradient-descent · high confidence

A new F\# program has been added to the Numerical-integration-simpson-rule directory that implements Simpson's Rule to approximate definite integrals. The application demonstrates the algorithm by calculating the integral of sin(x) from 0 to 1 using 100 subintervals, providing a more accurate approximation than rectangle or trapezoidal methods through quadratic function approximation.

src/Numerical-integration-simpson-rule · high confidence

Users can now solve ordinary differential equations using the Euler method via a new F\# program. The implementation provides a reusable function that accepts a derivative function and initial parameters, demonstrated with a specific example solving y' = -2y. Documentation and usage instructions are included to help users run the solver locally.

src/Euler-method · high confidence

A new F\# program has been added to the repository that implements the trapezoidal rule for approximating definite integrals. The code defines a reusable function to calculate the integral of any given float-to-float function over a specified interval using a user-defined number of subintervals. It includes a default example that computes the integral of sin(x) from 0 to 1 with 100 subintervals and prints the result. Documentation in the README explains the installation requirements (F\#), usage instructions, and the mathematical approach.

(repo-wide) · high confidence

Introduced a new F\# implementation of the Jacobi iterative method in \src/Jacobi-method\, allowing users to solve systems of linear equations. The program includes a \jacobiMethod\ function that iteratively refines an initial guess based on a specified tolerance and maximum iteration count, printing a warning if the limit is reached. A default example solving a 3x3 diagonally dominant system is provided in the entry point.

src/Gauss-seidel-method, src/Jacobi-method · high confidence

A new F\# program has been added to the Newton-Raphson-method directory, implementing the Newton-Raphson iterative algorithm to approximate the roots of real-valued functions. The code includes a reusable \newtonRaphson\ function that accepts a target function, its derivative, an initial guess, a tolerance threshold, and a maximum iteration count, returning the converged root or raising an error if convergence fails within the limit. A specific example is provided to find the root of the cubic function f(x) = x³ - 2x - 5, along with a README detailing installation via .NET and usage instructions.

src/Newton-Raphson-method · high confidence

Added a new F\# program and documentation for the Numerical Integration Rectangle Rule. The program approximates the definite integral of a function (defaulting to sin(x) from 0 to 1) by dividing the interval into subintervals and summing the areas of rectangles. Users can compile and run the code using \dotnet run\ to see the calculated approximation.

src/Numerical-integration-rectangle-rule · high confidence

The src/Runge-kutta-method location now includes a new F\# implementation of the fourth-order Runge-Kutta method for numerically solving ordinary differential equations. The Program.fs file provides a core function that computes solution points over a specified interval with a given step size, demonstrated via an example solving y' = -2y. The accompanying README.md documents the usage, code explanation, and references for this numerical technique.

src/Runge-kutta-method · high confidence

A new F\# program has been added to the Numerical-differentiation module that demonstrates how to approximate the first derivative of a function using the central difference method. The example specifically calculates the derivative of the sine function at x=0 with a step size of 0.1, outputting the result to the console. This addition is accompanied by a README file providing installation instructions for F\# and usage details for running the code via the .NET CLI.

src/Linear-interpolation-method, src/Monte-carlo-method-for-integration, src/Numerical-differentiation · high confidence

The project files (.fsproj) for the majority of the numerical methods (including Bisection, Euler, Fourier, Gauss-Seidel, Gaussian elimination, Gradient descent, Jacobi, LU decomposition, Linear interpolation, Linear regression, Monte Carlo methods, and various integration rules) have been created or updated to target the .NET 8.0 framework. While most methods now use .NET 8.0, the Newton-Raphson and Numerical differentiation methods remain on .NET 7.0.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 44 → 46 (+1.8)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 92 → 97 (+5.6)
• Architecture 100 → 100 (+0.0)
• Maturity 50 → 55 (+5.2)
• Readiness 15 → 15 (+0.0)
• Security 87 → 87 (+0.0)

• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• Documentation: no usage examples (README.md)

• Documentation: no architecture or design documentation (src/Numerical-integration-trapezoidal-rule/README.md)
• Documentation: no project overview (src/Numerical-integration-trapezoidal-rule/README.md)
• Documentation: no project overview (src/Runge-kutta-method/README.md)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

jonas1ara/Numerical was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.