Linear and non-linear equations can be solved using Math.js, a powerful mathematics library for JavaScript. For linear equations, Math.js provides functions to handle both single equations and systems of equations using matrix operations. For non-linear equations, the library supports numerical methods such as the Newton-Raphson method to approximate solutions.

Run the below command before running the code in your local system:

npm i mathjs

These are the types of equations that we are going to solve using Math.js:

Solving Linear Equations

Here, we will use Math.js to solve linear equations with the help of matrix operations. Specifically, we define the coefficients matrix and constants vector, and then use math.lusolve to find the solution, which gives us the value of x that satisfies the equation.

Example: This illustrates the linear equation “2x = 4” using Math.js and prints the value of x.

// script.js

const math = require('mathjs');

// Defining the coefficients matrix and constants vector
const coefficients = [[2]];
const constants = [4];

// Solving the equation
const solution = math.lusolve(coefficients, constants);

const x = solution[0][0];

console.log(`The solution for the equation "2x = 4" is x = ${x}`);

Output:

The solution for the equation "2x = 4" is x = 2

Solving System of Linear Equations

This lets us solve systems of linear equations using Math.js. It includes examples of setting up and solving multiple linear equations with multiple variables, using methods such as matrix operations and algebraic techniques to find solutions for the entire system.

Example: Here, We will define the coefficients matrix and constants vector, then use math.lusolve to compute the solutions for the variables x and y that satisfy the system of equations. The result gives us the values of x and y that solve the equations 2x+3y=7 and 3x+2y=8.

// script.js

const math = require('mathjs');

// Defining the coefficients matrix and constants vector
const coefficients = [
    [2, 3],
    [3, 2]
];
const constants = [7, 8];

// Solving the system of equations
const solutions = math.lusolve(coefficients, constants);

// Extracting solutions
const x = solutions[0][0];
const y = solutions[1][0];

console.log(`The solutions for the system 
             of equations are x = ${x}, y = ${y}`);

Output:

The solutions for the system of equations are x = 2, y = 1.0000000000000002

Solving Non-Linear Equations

This lets us solve non-linear equations using Math.js. It covers methods for finding solutions to equations where the variables are raised to powers other than one, including techniques for handling complex equations and numerical methods to approximate solutions.

Example: Here, We will define the non-linear function and its derivative, then iteratively refine our guess for the root by applying the Newton-Raphson method. This method continues until the root is found within a specified tolerance or the maximum number of iterations is reached.

const math = require('mathjs');

// Defining the non-linear equation as a function
function solveEquation() {
    // Example non-linear equation: x^3 - 2x - 5 = 0
    const equation = (x) => math.evaluate('x^3 - 2*x - 5', { x: x });
    const derivative = (x) => math.evaluate('3*x^2 - 2', { x: x });

    // Newton-Raphson method parameters
    const tolerance = 1e-6;
    const maxIterations = 100;
    let x0 = 2; // Initial guess

    // Newton-Raphson method
    for (let i = 0; i < maxIterations; i++) {
        const fx = equation(x0);
        const fpx = derivative(x0);

        if (Math.abs(fpx) < tolerance) {
            console.log('Derivative too small. No solution found.');
            return;
        }

        const x1 = x0 - fx / fpx;

        if (Math.abs(x1 - x0) < tolerance) {
            console.log('Root found:', x1);
            return;
        }

        x0 = x1;
    }

    console.log('Maximum iterations reached. No solution found.');
}

solveEquation();

Output:

Root found: 2.0945514815423265