npm - mathjs - Versions diffs - 10.0.0 → 10.6.4 - Mend

mathjs 10.0.0 → 10.6.4

Files changed (1084) hide show

package/examples/browser/rocket_trajectory_optimization.html DELETED Viewed

@@ -1,301 +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;
-    }
-    #canvas-grid {
-      display: grid;
-      grid-template-columns: repeat(2, 1fr);
-      gap: 5%;
-      margin-top: 5%;
-    }
-    #canvas-grid>div {
-      overflow: hidden;
-    }
-  </style>
-</head>
-<body>
-  <h1>Rocket trajectory optimization</h1>
-  <p>
-    This example simulates the launch of a SpaceX Falcon 9 modeled using a system of ordinary differential equations.
-  </p>
-  <canvas id="canvas" width="1600" height="600"></canvas>
-  <div id="canvas-grid"></div>
-  <script>
-    // Solve ODE `dx/dt = f(x,t), x(0) = x0` numerically.
-    function ndsolve(f, x0, dt, tmax) {
-      let x = x0.clone()  // Current values of variables
-      const result = [x]  // Contains entire solution
-      const nsteps = math.divide(tmax, dt)   // Number of time steps
-      for (let i = 0; i < nsteps; i++) {
-        // Compute derivatives
-        const dxdt = f.map(func => func(...x.toArray()))
-        // Euler method to compute next time step
-        const dx = math.multiply(dxdt, dt)
-        x = math.add(x, dx)
-        result.push(x)
-      }
-      return math.matrix(result)
-    }
-    // Import the numerical ODE solver
-    math.import({ 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.9724e24 kg")            // Mass of Earth
-    sim.evaluate("mu = G * mbody")                  // Standard gravitational parameter
-    sim.evaluate("g0 = 9.80665 m/s^2")              // Standard gravity: used for calculating prop consumption (dmdt)
-    sim.evaluate("r0 = 6371 km")                    // Mean radius of Earth
-    sim.evaluate("t0 = 0 s")                        // Simulation start
-    sim.evaluate("dt = 0.5 s")                      // Simulation timestep
-    sim.evaluate("tfinal = 149.5 s")                // Simulation duration
-    sim.evaluate("isp_sea = 282 s")                 // Specific impulse (at sea level)
-    sim.evaluate("isp_vac = 311 s")                 // Specific impulse (in vacuum)
-    sim.evaluate("gamma0 = 89.99970 deg")           // Initial pitch angle (90 deg is vertical)
-    sim.evaluate("v0 = 1 m/s")                      // Initial velocity (must be non-zero because ODE is ill-conditioned)
-    sim.evaluate("phi0 = 0 deg")                    // Initial orbital reference angle
-    sim.evaluate("m1 = 433100 kg")                  // First stage mass
-    sim.evaluate("m2 = 111500 kg")                  // Second stage mass
-    sim.evaluate("m3 = 1700 kg")                    // Third stage / fairing mass
-    sim.evaluate("mp = 5000 kg")                    // Payload mass
-    sim.evaluate("m0 = m1+m2+m3+mp")                // Initial mass of rocket
-    sim.evaluate("dm = 2750 kg/s")                  // Mass flow rate
-    sim.evaluate("A = (3.66 m)^2 * pi")             // Area of the rocket
-    sim.evaluate("dragCoef = 0.2")                  // Drag coefficient
-    // Define the equations of motion. We just thrust into current direction of motion, e.g. making a gravity turn.
-    sim.evaluate("gravity(r) = mu / r^2")
-    sim.evaluate("angVel(r, v, gamma) = v/r * cos(gamma) * rad")   // Angular velocity of rocket around moon
-    sim.evaluate("density(r) = 1.2250 kg/m^3 * exp(-g0 * (r - r0) / (83246.8 m^2/s^2))") // Assume constant temperature
-    sim.evaluate("drag(r, v) = 1/2 * density(r) .* v.^2 * A * dragCoef")
-    sim.evaluate("isp(r) = isp_vac + (isp_sea - isp_vac) * density(r)/density(r0)") // pressure ~ density for constant temperature
-    sim.evaluate("thrust(isp) = g0 * isp * dm")
-    // It is important to maintain the same argument order for each of these functions.
-    sim.evaluate("drdt(r, v, m, phi, gamma, t) = v sin(gamma)")
-    sim.evaluate("dvdt(r, v, m, phi, gamma, t) = - gravity(r) * sin(gamma) + (thrust(isp(r)) - drag(r, v)) / m")
-    sim.evaluate("dmdt(r, v, m, phi, gamma, t) = - dm")
-    sim.evaluate("dphidt(r, v, m, phi, gamma, t) = angVel(r, v, gamma)")
-    sim.evaluate("dgammadt(r, v, m, phi, gamma, t) = angVel(r, v, gamma) - gravity(r) * cos(gamma) / v * rad")
-    sim.evaluate("dtdt(r, v, m, phi, gamma, t) = 1")
-    // Remember to maintain the same variable order in the call to ndsolve.
-    sim.evaluate("result_stage1 = ndsolve([drdt, dvdt, dmdt, dphidt, dgammadt, dtdt], [r0, v0, m0, phi0, gamma0, t0], dt, tfinal)")
-    // Reset initial conditions for interstage flight
-    sim.evaluate("dm = 0 kg/s")
-    sim.evaluate("tfinal = 10 s")
-    sim.evaluate("x = flatten(result_stage1[end,:])")
-    sim.evaluate("x[3] = m2+m3+mp") // New mass after stage seperation
-    sim.evaluate("result_interstage = ndsolve([drdt, dvdt, dmdt, dphidt, dgammadt, dtdt], x, dt, tfinal)")
-    // Reset initial conditions for stage 2 flight
-    sim.evaluate("dm = 270.8 kg/s")
-    sim.evaluate("isp_vac = 348 s")
-    sim.evaluate("tfinal = 350 s")
-    sim.evaluate("x = flatten(result_interstage[end,:])")
-    sim.evaluate("result_stage2 = ndsolve([drdt, dvdt, dmdt, dphidt, dgammadt, dtdt], x, dt, tfinal)")
-    // Reset initial conditions for unpowered flight
-    sim.evaluate("dm = 0 kg/s")
-    sim.evaluate("tfinal = 900 s")
-    sim.evaluate("dt = 10 s")
-    sim.evaluate("x = flatten(result_stage2[end,:])")
-    sim.evaluate("result_unpowered1 = ndsolve([drdt, dvdt, dmdt, dphidt, dgammadt, dtdt], x, dt, tfinal)")
-    // Reset initial conditions for final orbit insertion
-    sim.evaluate("dm = 270.8 kg/s")
-    sim.evaluate("tfinal = 39 s")
-    sim.evaluate("dt = 0.5 s")
-    sim.evaluate("x = flatten(result_unpowered1[end,:])")
-    sim.evaluate("result_insertion = ndsolve([drdt, dvdt, dmdt, dphidt, dgammadt, dtdt], x, dt, tfinal)")
-    // Reset initial conditions for unpowered flight
-    sim.evaluate("dm = 0 kg/s")
-    sim.evaluate("tfinal = 250 s")
-    sim.evaluate("dt = 10 s")
-    sim.evaluate("x = flatten(result_insertion[end,:])")
-    sim.evaluate("result_unpowered2 = ndsolve([drdt, dvdt, dmdt, dphidt, dgammadt, dtdt], x, dt, tfinal)")
-    // Now it's time to prepare results for plotting
-    const resultNames = ['stage1', 'interstage', 'stage2', 'unpowered1', 'insertion', 'unpowered2']
-      .map(stageName => `result_${stageName}`)
-    // Concat result matrices
-    sim.set('result',
-      math.concat(
-        ...resultNames.map(resultName =>
-          sim.evaluate(`${resultName}[:end-1, :]`)  // Avoid overlap
-        ),
-        0 // Concat in row-dimension
-      )
-    )
-    const mainDatasets = resultNames.map((resultName, i) => ({
-      label: resultName.slice(7),
-      data: sim.evaluate(
-        'concat('
-        + `(${resultName}[:,4] - phi0) * r0 / rad / km,`  // Surface distance from start (in km)
-        + `(${resultName}[:,1] - r0) / km`                // Height above surface (in km)
-        + ')'
-      ).toArray().map(([x, y]) => ({ x, y })),
-      borderColor: i % 2 ? '#999' : '#dc3912',
-      fill: false,
-      pointRadius: 0,
-    }))
-    new Chart(document.getElementById('canvas'), {
-      type: 'line',
-      data: { datasets: mainDatasets },
-      options: getMainChartOptions()
-    })
-    createChart([{
-      label: 'velocity (in m/s)',
-      data: sim.evaluate("result[:,[2,6]]")
-        .toArray()
-        .map(([v, t]) => ({ x: t.toNumber('s'), y: v.toNumber('m/s') }))
-    }])
-    createChart([{
-      label: 'height (in km)',
-      data: sim.evaluate("concat((result[:, 1] - r0), result[:, 6])")
-        .toArray()
-        .map(([r, t]) => ({ x: t.toNumber('s'), y: r.toNumber('km') })),
-    }])
-    createChart([{
-      label: 'gamma (in deg)',
-      data: sim.evaluate("result[:, [5,6]]")
-        .toArray()
-        .map(([gamma, t]) => ({ x: t.toNumber('s'), y: gamma.toNumber('deg') })),
-    }])
-    createChart([{
-      label: 'acceleration (in m/s^2)',
-      data: sim.evaluate("concat(diff(result[:, 2]) ./ diff(result[:, 6]), result[:end-1, 6])")
-        .toArray()
-        .map(([acc, t]) => ({ x: t.toNumber('s'), y: acc.toNumber('m/s^2') })),
-    }])
-    createChart([{
-      label: 'drag acceleration (in m/s^2)',
-      data: sim.evaluate("concat(drag(result[:, 1], result[:, 2]) ./ result[:, 3], result[:, 6])")
-        .toArray()
-        .map(([dragAcc, t]) => ({ x: t.toNumber('s'), y: dragAcc.toNumber('m/s^2') })),
-    }])
-    createChart(
-      [
-        {
-          data: sim.evaluate("result[:, [1,4]]")
-            .toArray()
-            .map(([r, phi]) => math.rotate([r.toNumber('km'), 0], phi))
-            .map(([x, y]) => ({ x, y })),
-        },
-        {
-          data: sim.evaluate("map(0:0.25:360, function(angle) = rotate([r0/km, 0], angle))")
-            .toArray()
-            .map(([x, y]) => ({ x, y })),
-          borderColor: "#999",
-          fill: true
-        }
-      ],
-      getEarthChartOptions()
-    )
-    // Helper functions for plotting data (nothing to learn about math.js from here on)
-    function createChart(datasets, options = {}) {
-      const container = document.createElement("div")
-      document.querySelector("#canvas-grid").appendChild(container)
-      const canvas = document.createElement("canvas")
-      container.appendChild(canvas)
-      new Chart(canvas, {
-        type: 'line',
-        data: {
-          datasets: datasets.map(dataset => ({
-            borderColor: "#dc3912",
-            fill: false,
-            pointRadius: 0,
-            ...dataset
-          }))
-        },
-        options: getChartOptions(options)
-      })
-    }
-    function getMainChartOptions() {
-      return {
-        scales: {
-          xAxes: [{
-            type: 'linear',
-            position: 'bottom',
-            scaleLabel: {
-              display: true,
-              labelString: 'surface distance travelled (in km)'
-            }
-          }],
-          yAxes: [{
-            type: 'linear',
-            scaleLabel: {
-              display: true,
-              labelString: 'height above surface (in km)'
-            }
-          }]
-        },
-        animation: false
-      }
-    }
-    function getChartOptions(options) {
-      return {
-        scales: {
-          xAxes: [{
-            type: 'linear',
-            position: 'bottom',
-            scaleLabel: {
-              display: true,
-              labelString: 'time (in s)'
-            }
-          }]
-        },
-        animation: false,
-        ...options
-      }
-    }
-    function getEarthChartOptions() {
-      return {
-        aspectRatio: 1,
-        scales: {
-          xAxes: [{
-            type: 'linear',
-            position: 'bottom',
-            min: -8000,
-            max: 8000,
-            display: false
-          }],
-          yAxes: [{
-            type: 'linear',
-            min: -8000,
-            max: 8000,
-            display: false
-          }]
-        },
-        legend: { display: false }
-      }
-    }
-  </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))
-}