npm - mathjs - Versions diffs - 8.1.0 → 12.2.1 - Mend

mathjs 8.1.0 → 12.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2099) hide show

package/examples/browser/printing_html.html DELETED Viewed

@@ -1,170 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-	<meta charset="utf-8">
-	<title>math.js | printing HTML</title>
-	<script src="../../lib/browser/math.js"></script>
-	<style>
-		body {
-			font-size: 11pt;
-			font-family: verdana, arial, sans-serif;
-		}
-		h1 {
-			font-size: 1rem;
-		}
-		fieldset {
-			display: inline;
-			margin: 0 50px 10px 0;
-			padding: 0;
-			border: none;
-		}
-		input[type=text] {
-			font-size: 11pt;
-			font-family: verdana, arial, sans-serif;
-			padding: 5px;
-			width: calc(100% - 14px);
-		}
-		label {
-			margin: 0 5px 0 0;
-		}
-		table {
-			width: 100%;
-			border-collapse: collapse;
-		}
-		table td,
-		table th {
-			padding: 5px;
-			border: 1px solid LightGrey;
-		}
-		table th {
-			background-color: LightGrey;
-		}
-		/* style the HTML output */
-		.math-function {
-			color: Purple;
-			font-weight: bold;
-		}
-		.math-number {
-			color: Blue;
-		}
-		.math-boolean {
-			color: Green;
-		}
-		.math-string {
-			color: Grey;
-		}
-		.math-string::before,
-		.math-string::after {
-			content: "\"";
-		}
-		.math-property {
-			font-style: italic;
-		}
-		.math-explicit-binary-operator::before,
-		.math-explicit-binary-operator::after {
-			content: " ";
-		}
-		.math-separator::after,
-		.math-assignment-operator::after {
-			content: " ";
-		}
-	</style>
-</head>
-<body>
-<h1>Expression evaluation and HTML code generation with math.js</h1>
-<form>
-	<fieldset>
-		Parenthesis option:
-		<label><input type="radio" name="parenthesis" value="keep" checked>keep</label>
-		<label><input type="radio" name="parenthesis" value="auto">auto</label>
-		<label><input type="radio" name="parenthesis" value="all">all</label>
-	</fieldset>
-	<fieldset>
-		Implicit multiplication:
-		<label><input type="radio" name="implicit" value="hide" checked>hide</label>
-		<label><input type="radio" name="implicit" value="show">show</label>
-	</fieldset>
-</form>
-<table>
-	<tr>
-		<th>Expression</th>
-		<td><input type="text" id="expr"/></td>
-	</tr>
-	<tr>
-		<th>Result</th>
-		<td><div id="result"></div></td>
-	</tr>
-	<tr>
-		<th>HTML output</th>
-		<td><div id="output">$$$$</div></td>
-	</tr>
-	<tr>
-		<th>HTML code</th>
-		<td><div id="code">$$$$</div></td>
-	</tr>
-</table>
-<script>
-  const expr = document.getElementById('expr')
-  const output = document.getElementById('output')
-  const code = document.getElementById('code')
-  const result = document.getElementById('result')
-  let options = {parenthesis: 'keep', implicit: 'hide'}
-  // initialize with an example expression
-  expr.value = 'sqrt(75/3)+det([[-1,2],[3,1]])-sin(pi/4)^2'
-  function print () {
-    let parsed = null
-    try {
-      // parse the expression
-      parsed = math.parse(expr.value)
-      // evaluate the result of the expression
-      result.innerHTML = math.format(parsed.compile().evaluate())
-      // print the HTML output
-      const html = math.parse(expr.value).toHTML(options)
-      output.innerHTML = html
-      // print the HTML code
-      code.innerHTML = html.replace(/</g, '&lt;').
-      replace(/>/g, '&gt;').
-      replace(/&lt;\/span&gt;/g, '&lt;/span&gt;<br />')
-    }
-    catch (err) {
-      result.innerHTML = '<span style="color: red;">' + err.toString() + '</span>'
-    }
-  }
-  window.onload = print
-  expr.oninput = print
-  // make the controls work
-  const controls = document.querySelectorAll('input[type=radio]')
-  controls.forEach(function (control) {
-    control.onclick = function() {
-      options[control.name] = control.value
-      print()
-    }
-  })
-</script>
-</body>
-</html>

package/examples/browser/requirejs_loading.html DELETED Viewed

@@ -1,20 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>math.js | require.js loading</title>
-  <script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.1.20/require.min.js"></script>
-</head>
-<body>
-<script>
-  // load math.js using require.js
-  require(['../../lib/browser/math.js'], function (math) {
-    // evaluate some expression
-    const result = math.evaluate('1.2 * (2 + 4.5)')
-    document.write(result)
-  })
-</script>
-</body>
-</html>

package/examples/browser/rocket_trajectory_optimization.html DELETED Viewed

@@ -1,152 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>math.js | rocket trajectory optimization</title>
-  <script src="../../lib/browser/math.js"></script>
-  <script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.5.0/Chart.min.js"></script>
-  <style>
-    body {
-      font-family: sans-serif;
-    }
-  </style>
-</head>
-<body>
-  <h1>Rocket trajectory optimization</h1>
-  <p>
-    This example simulates the ascent stage of the Apollo Lunar Module modeled using a system of ordinary differential equations.
-  </p>
-  <canvas id=canvas1 width=1600 height=400></canvas>
-  <canvas id=canvas2 width=800 height=400></canvas>
-  <script>
-    function ndsolve(f, x0, dt, tmax) {
-      const n = f.size()[0]  // Number of variables
-      const x = x0.clone()   // Current values of variables
-      const dxdt = []        // Temporary variable to hold time-derivatives
-      const result = []      // Contains entire solution
-      const nsteps = math.divide(tmax, dt)   // Number of time steps
-      for(let i=0; i<nsteps; i++) {
-        // Compute derivatives
-        for(let j=0; j<n; j++) {
-          dxdt[j] = f.get([j]).apply(null, x.toArray())
-        }
-        // Euler method to compute next time step
-        for(let j=0; j<n; j++) {
-          x.set([j], math.add(x.get([j]), math.multiply(dxdt[j], dt)))
-        }
-        result.push(x.clone())
-      }
-      return math.matrix(result)
-    }
-    // Import the numerical ODE solver
-    math.import({ndsolve:ndsolve})
-    // Create a math.js context for our simulation. Everything else occurs in the context of the expression parser!
-    const sim = math.parser()
-    sim.evaluate("G = 6.67408e-11 m^3 kg^-1 s^-2")  // Gravitational constant
-    sim.evaluate("mbody = 5.972e24 kg")             // Mass of Earth
-    sim.evaluate("mu = G * mbody")
-    sim.evaluate("dt = 1.0 s")                      // Simulation timestep
-    sim.evaluate("tfinal = 162 s")                  // Simulation duration
-    sim.evaluate("T = 1710000 lbf * 0.9")           // Engine thrust
-    sim.evaluate("g0 = 9.80665 m/s^2")              // Standard gravity: used for calculating prop consumption (dmdt)
-    sim.evaluate("isp = 290 s")                     // Specific impulse
-    sim.evaluate("gamma0 = 89.99883 deg")           // Initial pitch angle (90 deg is vertical)
-    sim.evaluate("r0 = 6378.1370 km")               // Equatorial radius of Earth
-    sim.evaluate("v0 = 10 m/s")                     // Initial velocity (must be non-zero because ODE is ill-conditioned)
-    sim.evaluate("phi0 = 0 deg")                    // Initial orbital reference angle
-    sim.evaluate("m0 = 1207920 lbm + 30000 lbm")    // Initial mass of rocket and fuel
-    // Define the equations of motion. It is important to maintain the same argument order for each of these functions.
-    sim.evaluate("drdt(r, v, m, phi, gamma) = v sin(gamma)")
-    sim.evaluate("dvdt(r, v, m, phi, gamma) = -mu / r^2 * sin(gamma) + T / m")
-    sim.evaluate("dmdt(r, v, m, phi, gamma) = -T/g0/isp")
-    sim.evaluate("dphidt(r, v, m, phi, gamma) = v/r * cos(gamma) * rad")
-    sim.evaluate("dgammadt(r, v, m, phi, gamma) = (1/r * (v - mu / (r v)) * cos(gamma)) * rad")
-    // Again, remember to maintain the same variable order in the call to ndsolve.
-    sim.evaluate("result_stage1 = ndsolve([drdt, dvdt, dmdt, dphidt, dgammadt], [r0, v0, m0, phi0, gamma0], dt, tfinal)")
-    // Reset initial conditions for interstage flight
-    sim.evaluate("T = 0 lbf")
-    sim.evaluate("tfinal = 12 s")
-    sim.evaluate("x = flatten(result_stage1[result_stage1.size()[1],:])")
-    sim.evaluate("result_interstage = ndsolve([drdt, dvdt, dmdt, dphidt, dgammadt], x, dt, tfinal)")
-    console.log(sim.evaluate("result_interstage[result_interstage.size()[1],3]").toString())
-    // Reset initial conditions for stage 2 flight
-    sim.evaluate("T = 210000 lbf")
-    sim.evaluate("isp = 348 s")
-    sim.evaluate("tfinal = 397 s")
-    sim.evaluate("x = flatten(result_interstage[result_interstage.size()[1],:])")
-    sim.evaluate("x[3] = 273600 lbm")  // Lighten the rocket a bit since we discarded the first stage
-    sim.evaluate("result_stage2 = ndsolve([drdt, dvdt, dmdt, dphidt, dgammadt], x, dt, tfinal)")
-    // Reset initial conditions for unpowered flight
-    sim.evaluate("T = 0 lbf")
-    sim.evaluate("tfinal = 60 s")
-    sim.evaluate("x = flatten(result_stage2[result_stage2.size()[1],:])")
-    sim.evaluate("result_unpowered = ndsolve([drdt, dvdt, dmdt, dphidt, dgammadt], x, dt, tfinal)")
-    // Extract the useful information from the results so it can be plotted
-    const data_stage1 =     sim.evaluate("transpose(concat( transpose(    result_stage1[:,4] - phi0) * r0 / rad / km, (    transpose(result_stage1[:,1]) - r0) / km, 1 ))").toArray().map(function(e) { return {x: e[0], y: e[1]} })
-    const data_interstage = sim.evaluate("transpose(concat( transpose(result_interstage[:,4] - phi0) * r0 / rad / km, (transpose(result_interstage[:,1]) - r0) / km, 1 ))").toArray().map(function(e) { return {x: e[0], y: e[1]} })
-    const data_stage2 =     sim.evaluate("transpose(concat( transpose(    result_stage2[:,4] - phi0) * r0 / rad / km, (    transpose(result_stage2[:,1]) - r0) / km, 1 ))").toArray().map(function(e) { return {x: e[0], y: e[1]} })
-    const data_unpowered =  sim.evaluate("transpose(concat( transpose( result_unpowered[:,4] - phi0) * r0 / rad / km, ( transpose(result_unpowered[:,1]) - r0) / km, 1 ))").toArray().map(function(e) { return {x: e[0], y: e[1]} })
-    window['chart'] = new Chart(document.getElementById('canvas1'), {
-      type: 'line',
-      data: {
-        datasets: [{
-          label: "Stage 1",
-          data: data_stage1,
-          fill: false,
-          borderColor: "red",
-          pointRadius: 0
-        }, {
-          label: "Interstage",
-          data: data_interstage,
-          fill: false,
-          borderColor: "green",
-          pointRadius: 0
-        }, {
-          label: "Stage 2",
-          data: data_stage2,
-          fill: false,
-          borderColor: "orange",
-          pointRadius: 0
-        }, {
-          label: "Unpowered",
-          data: data_unpowered,
-          fill: false,
-          borderColor: "blue",
-          pointRadius: 0
-        }]
-      },
-      options: {
-        scales: {
-          xAxes: [{
-            type: 'linear',
-            position: 'bottom'
-          }]
-        }
-      }
-    })
-  </script>
-</body>
-</html>

package/examples/browser/webworkers/webworkers.html DELETED Viewed

@@ -1,80 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>math.js | web workers</title>
-</head>
-<body>
-<p>
-  In this example, a math.js parser is running in a separate
-  <a href="https://www.html5rocks.com/en/tutorials/workers/basics/">web worker</a>,
-  preventing the user interface from freezing during heavy calculations.
-</p>
-<p id="results"></p>
-<script>
-  /**
-   * MathWorker evaluates expressions asynchronously in a web worker.
-   *
-   * Example usage:
-   *
-   *     const worker = new MathWorker()
-   *     const expr = '12 / (2.3 + 0.7)'
-   *     worker.evaluate(expr, function (err, result) {
-   *       console.log(err, result)
-   *     })
-   */
-  function MathWorker () {
-    this.worker = new Worker('worker.js')
-    this.callbacks = {}
-    this.seq = 0
-    // create a listener to receive responses from the web worker
-    const me = this
-    this.worker.addEventListener('message', function(event) {
-      const response = JSON.parse(event.data)
-      // find the callback corresponding to this response
-      const callback = me.callbacks[response.id]
-      delete me.callbacks[response.id]
-      // call the requests callback with the result
-      callback(response.err, response.result)
-    }, false)
-  }
-  /**
-   * Evaluate an expression
-   * @param {string} expr
-   * @param {Function} callback   Called as callback(err, result)
-   */
-  MathWorker.prototype.evaluate = function evaluate (expr, callback) {
-    // build a request,
-    // add an id so we can link returned responses to the right callback
-    const id = this.seq++
-    const request = {
-      id: id,
-      expr: expr
-    }
-    // queue the callback, it will be called when the worker returns the result
-    this.callbacks[id] = callback
-    // send the request to the worker
-    this.worker.postMessage(JSON.stringify(request))
-  }
-  // create a MathWorker
-  const worker = new MathWorker()
-  // evaluate an expression via the worker
-  worker.evaluate('12 / (2.3 + 0.7)', function (err, result) {
-    document.getElementById('results').innerHTML += 'result: ' + result + '<br>'
-  })
-</script>
-</body>
-</html>

package/examples/browser/webworkers/worker.js DELETED Viewed

@@ -1,28 +0,0 @@
-importScripts('../../../lib/browser/math.js')
-// create a parser
-const parser = self.math.parser()
-self.addEventListener('message', function (event) {
-  const request = JSON.parse(event.data)
-  let result = null
-  let err = null
-  try {
-    // evaluate the expression
-    result = parser.evaluate(request.expr)
-  } catch (e) {
-    // return the error
-    err = e
-  }
-  // build a response
-  const response = {
-    id: request.id,
-    result: self.math.format(result),
-    err: err
-  }
-  // send the response back
-  self.postMessage(JSON.stringify(response))
-}, false)

package/examples/chaining.js DELETED Viewed

@@ -1,56 +0,0 @@
-// chaining
-// load math.js (using node.js)
-const math = require('..')
-// create a chained operation using the function `chain(value)`
-// end a chain using done(). Let's calculate (3 + 4) * 2
-const a = math.chain(3)
-  .add(4)
-  .multiply(2)
-  .done()
-print(a) // 14
-// Another example, calculate square(sin(pi / 4))
-const b = math.chain(math.pi)
-  .divide(4)
-  .sin()
-  .square()
-  .done()
-print(b) // 0.5
-// A chain has a few special methods: done, toString, valueOf, get, and set.
-// these are demonstrated in the following examples
-// toString will return a string representation of the chain's value
-const chain = math.chain(2).divide(3)
-const str = chain.toString()
-print(str) // "0.6666666666666666"
-// a chain has a function .valueOf(), which returns the value hold by the chain.
-// This allows using it in regular operations. The function valueOf() acts the
-// same as function done().
-print(chain.valueOf()) // 0.66666666666667
-print(chain + 2) // 2.6666666666667
-// the function subset can be used to get or replace sub matrices
-const array = [[1, 2], [3, 4]]
-const v = math.chain(array)
-  .subset(math.index(1, 0))
-  .done()
-print(v) // 3
-const m = math.chain(array)
-  .subset(math.index(0, 0), 8)
-  .multiply(3)
-  .done()
-print(m) // [[24, 6], [9, 12]]
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
-  const precision = 14
-  console.log(math.format(value, precision))
-}

package/examples/complex_numbers.js DELETED Viewed

@@ -1,67 +0,0 @@
-// complex numbers
-// load js (using node.js)
-const { complex, add, multiply, sin, sqrt, pi, equal, sort, format } = require('..')
-// create a complex number with a numeric real and complex part
-console.log('create and manipulate complex numbers')
-const a = complex(2, 3)
-print(a) // 2 + 3i
-// read the real and complex parts of the complex number
-print(a.re) // 2
-print(a.im) // 3
-// clone a complex value
-const clone = a.clone()
-print(clone) // 2 + 3i
-// adjust the complex value
-a.re = 5
-print(a) // 5 + 3i
-// create a complex number by providing a string with real and complex parts
-const b = complex('3-7i')
-print(b) // 3 - 7i
-console.log()
-// perform operations with complex numbers
-console.log('perform operations')
-print(add(a, b)) // 8 - 4i
-print(multiply(a, b)) // 36 - 26i
-print(sin(a)) // -9.6541254768548 + 2.8416922956064i
-// some operations will return a complex number depending on the arguments
-print(sqrt(4)) // 2
-print(sqrt(-4)) // 2i
-console.log()
-// create a complex number from polar coordinates
-console.log('create complex numbers with polar coordinates')
-const c = complex({ r: sqrt(2), phi: pi / 4 })
-print(c) // 1 + i
-// get polar coordinates of a complex number
-const d = complex(3, 4)
-console.log(d.abs(), d.arg()) // radius = 5, phi = 0.9272952180016122
-console.log()
-// comparision operations
-// note that there is no mathematical ordering defined for complex numbers
-// we can only check equality. To sort a list with complex numbers,
-// the natural sorting can be used
-console.log('\ncomparision and sorting operations')
-console.log('equal', equal(a, b)) // returns false
-const values = [a, b, c]
-console.log('values:', format(values, 14)) // [5 + 3i, 3 - 7i, 1 + i]
-sort(values, 'natural')
-console.log('sorted:', format(values, 14)) // [1 + i, 3 - 7i, 5 + 3i]
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
-  const precision = 14
-  console.log(format(value, precision))
-}