C# Numerical Methods for Scientists and Engineers

Create a Visual Studio solution and a numerical methods library, add a class library project, delete the default class, and add a nonlinear equations class to organize routines.

Implement a public interface for nonlinear equations and solve roots with the bisection method in C#, using a function delegate, bounds, and a convergence criterion to determine the root.

Implement the regula falsi method in the nonlinear equations interface by adapting the by-section method, using an x2 calculation with F(lower) and F(upper), and updating bounds until convergence.

Implement the secant method as a second numerical method with a new execute method. Accept a function, lower and upper bounds, an error tolerance, and a maximum iterations count.

Implement the Newton-Raphson method to locate roots of nonlinear equations using a function and its derivative, starting from an initial guess, with convergence criteria and a maximum iteration limit.

Create a new unit test project to run nonlinear algorithms and test the nonlinear equations class, wiring in the numerical methods library and adding a test initialize method.

Illustrate nonlinear unit tests using the by section method on f(x)=x^2-4, with convergence criteria, and verify the root within tolerance; set up, run, and debug tests.

Wrap up nonlinear unit tests by validating the regular false method, a second method, and the Newton Rapson method in C#, using lower and upper bounds, convergence criteria, and iterations.

Implement a system of linear equations solver using the Gosselin elimination method and create a public interface for the system of equations library that returns a double[] for string[] coefficients.

Apply Gauss elimination to solve a system by building a coefficient matrix, reducing to a form with zeros in the bottom left triangle, and using back substitution to obtain solution.

Learn to generate the reduced form of a matrix using Gauss elimination, including row swapping to avoid zero pivots, forward elimination, and back substitution to solve a system of equations.

Implement the swap rows method in Gauss elimination to swap nonzero rows using a temp row and a boolean flag, then proceed to back substitution for a 3x3 system.

Implement back substitution for Gauss elimination to solve a linear system in C#, using a double multi-dimensional array, processing rows backwards and validating the result to prevent division by zero.

Validate solutions in Gauss elimination by checking for not a number or infinite results, handling division by zero, and performing back substitution after swapping rows to obtain the reduced form.

Set up a unit test for solving a 2x2 system of equations using Gauss elimination, including preparing coefficients, running the method, and asserting the expected roots.

Debug unit tests for a gaussian elimination routine by using breakpoints and fixing a loop bound. Compare expected versus actual solutions and confirm tests pass for 2x2 to 4x4 systems.

Add an interpolation and regression module with a public class and interface to numerical methods library, implementing linear interpolation from two points to a target x value returning a double.

Implement a linear interpolation method in the interpolation regression class by computing y as y0 plus the slope (y1 minus y0) divided by the x1 minus x0 times (x minus x0), returning the interpolated y value.

Implement linear regression to fit data with y = a + b x, computing sums of x, x squared, y, and xy, then derive coefficients a and b.

Implement power regression in C# by fitting y = a x^b using log base 10 transformations, sums, and exponential calculations to derive a and b.

Demonstrates unit testing of linear interpolation, linear regression, and power regression using a dedicated interpolation regression library, validating models with x-y data and expected outcomes.

Implement numerical differentiation using forward, backward, and central differences based on Taylor series to approximate a function’s derivative at a point, via a public class and interface with execute methods.

The lecture demonstrates implementing the forward difference method in a concrete numerical differentiation class, deriving the derivative using f(x+2dx), f(x+dx), and f(x) with a two-step formula, returning the result.

Apply the backward difference method by evaluating f at x, x - h, and x - 2h, and combine them as (3f(x) - 4f(x - h) + f(x - 2h)) / (2h).

Explore the central difference method for numerical derivatives in science and engineering, using f(x±dx) and f(x±2dx) with a 12 dx denominator, and investigate step-size effects and unit testing.

Develop and validate numerical differentiation techniques by implementing unit tests for backward, forward, and central differences on the function x^2, verifying derivative at x=2 with a small step size.

Create a public numerical integration class and a I numerical integration interface, implementing the trapezoid method, Simpson's one-third, and Simpson's three-eighths methods to approximate areas under curves.

Implement the trapezoidal method for numerical integration by implementing the numerical integration interface, computing step size, evaluating function at lower and upper bounds, and summing areas with a do-while loop.

Apply Simpson's 1/3 method by adapting the trapezoid loop, using 2f(K) for even steps and 4f(K) for odd steps, and multiply the final sum by h/3 to compute the integral.

Apply the Simpson's 3/8 method by adapting the Simpson 1/3 logic, adjusting the do loop modulus to three, and scaling the step size by three over eight.

Author and execute unit tests for numerical integration with trapezoid, Simpson's one-third, and Simpson's three-eighths methods using x^2 from 0 to 2, then increase panels to improve accuracy.

Learn to solve ordinary differential equations using Euler and Runge-Kutta methods in c sharp numerical methods. Build a library and interface to compute time-stepped solutions for initial value problems.

Implement the Euler method in C# by modeling an ODE with a multivariate function F(t, y), configuring step size from start and end times, iterating, and returning the results array.

Implement the Runge-Kutta method by computing K1 through K4 with step size h, update time and y, and store the results, then compare to the Oilers method.

Implement and run unit tests for Euler method and Runge-Kutta on a C# differential equations library, solving y' + 2y = 2 - e^{-40 t} with y(0)=1.