#!/usr/bin/env node

/**

* math.js

* https://github.com/josdejong/mathjs

*

* Math.js is an extensive math library for JavaScript and Node.js,

* It features real and complex numbers, units, matrices, a large set of

* mathematical functions, and a flexible expression parser.

*

* Usage:

*

* mathjs [scriptfile(s)] {OPTIONS}

*

* Options:

*

* --version, -v Show application version

* --help, -h Show this message

* --tex Generate LaTeX instead of evaluating

* --string Generate string instead of evaluating

* --parenthesis= Set the parenthesis option to

* either of "keep", "auto" and "all"

*

* Example usage:

* mathjs Open a command prompt

* mathjs 1+2 Evaluate expression

* mathjs script.txt Run a script file

* mathjs script1.txt script2.txt Run two script files

* mathjs script.txt > results.txt Run a script file, output to file

* cat script.txt | mathjs Run input stream

* cat script.txt | mathjs > results.txt Run input stream, output to file

*

* @license

* Copyright (C) 2013-2022 Jos de Jong <[email protected]>

*

* Licensed under the Apache License, Version 2.0 (the "License"); you may not

* use this file except in compliance with the License. You may obtain a copy

* of the License at

*

* https://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

* License for the specific language governing permissions and limitations under

* the License.

*/

const fs = require('fs')

const path = require('path')

const { createEmptyMap } = require('../lib/cjs/utils/map.js')

let scope = createEmptyMap()

const PRECISION = 14 // decimals

/**

* "Lazy" load math.js: only require when we actually start using it.

* This ensures the cli application looks like it loads instantly.

* When requesting help or version number, math.js isn't even loaded.

* @return {*}

*/

function getMath () {

return require('../lib/cjs/defaultInstance.js').default

}

/**

* Helper function to format a value. Regular numbers will be rounded

* to 14 digits to prevent round-off errors from showing up.

* @param {*} value

*/

function format (value) {

const math = getMath()

return math.format(value, {

fn: function (value) {

if (typeof value === 'number') {

// round numbers

return math.format(value, PRECISION)

} else {

return math.format(value)

}

}

})

}

/**

* auto complete a text

* @param {String} text

* @return {[Array, String]} completions

*/

function completer (text) {

const math = getMath()

let matches = []

let keyword

const m = /[a-zA-Z_0-9]+$/.exec(text)

if (m) {

keyword = m[0]

// scope variables

for (const def in scope.keys()) {

if (def.indexOf(keyword) === 0) {

matches.push(def)

}

}

// commandline keywords

['exit', 'quit', 'clear'].forEach(function (cmd) {

if (cmd.indexOf(keyword) === 0) {

matches.push(cmd)

}

})

// math functions and constants

const ignore = ['expr', 'type']

for (const func in math.expression.mathWithTransform) {

if (hasOwnProperty(math.expression.mathWithTransform, func)) {

if (func.indexOf(keyword) === 0 && ignore.indexOf(func) === -1) {

matches.push(func)

}

}

}

// units

const Unit = math.Unit

for (const name in Unit.UNITS) {

if (hasOwnProperty(Unit.UNITS, name)) {

if (name.indexOf(keyword) === 0) {

matches.push(name)

}

}

}

for (const name in Unit.PREFIXES) {

if (hasOwnProperty(Unit.PREFIXES, name)) {

const prefixes = Unit.PREFIXES[name]

for (const prefix in prefixes) {

if (hasOwnProperty(prefixes, prefix)) {

if (prefix.indexOf(keyword) === 0) {

matches.push(prefix)

} else if (keyword.indexOf(prefix) === 0) {

const unitKeyword = keyword.substring(prefix.length)

for (const n in Unit.UNITS) {

if (hasOwnProperty(Unit.UNITS, n)) {

if (n.indexOf(unitKeyword) === 0 &&

Unit.isValuelessUnit(prefix + n)) {

matches.push(prefix + n)

}

}

}

}

}

}

}

}

// remove duplicates

matches = matches.filter(function (elem, pos, arr) {

return arr.indexOf(elem) === pos

})

}

return [matches, keyword]

}

/**

* Run stream, read and evaluate input and stream that to output.

* Text lines read from the input are evaluated, and the results are send to

* the output.

* @param input Input stream

* @param output Output stream

* @param mode Output mode

* @param parenthesis Parenthesis option

*/

function runStream (input, output, mode, parenthesis) {

const readline = require('readline')

const rl = readline.createInterface({

input: input || process.stdin,

output: output || process.stdout,

completer: completer

})

if (rl.output.isTTY) {

rl.setPrompt('> ')

rl.prompt()

}

// load math.js now, right *after* loading the prompt.

const math = getMath()

// TODO: automatic insertion of 'ans' before operators like +, -, *, /

rl.on('line', function (line) {

const expr = line.trim()

switch (expr.toLowerCase()) {

case 'quit':

case 'exit':

// exit application

rl.close()

break

case 'clear':

// clear memory

scope = createEmptyMap()

console.log('memory cleared')

// get next input

if (rl.output.isTTY) {

rl.prompt()

}

break

default:

if (!expr) {

break

}

switch (mode) {

case 'evaluate':

// evaluate expression

try {

let node = math.parse(expr)

let res = node.evaluate(scope)

if (math.isResultSet(res)) {

// we can have 0 or 1 results in the ResultSet, as the CLI

// does not allow multiple expressions separated by a return

res = res.entries[0]

node = node.blocks

.filter(function (entry) { return entry.visible })

.map(function (entry) { return entry.node })[0]

}

if (node) {

if (math.isAssignmentNode(node)) {

const name = findSymbolName(node)

if (name !== null) {

const value = scope.get(name)

scope.set('ans', value)

console.log(name + ' = ' + format(value))

} else {

scope.set('ans', res)

console.log(format(res))

}

} else if (math.isHelp(res)) {

console.log(res.toString())

} else {

scope.set('ans', res)

console.log(format(res))

}

}

} catch (err) {

console.log(err.toString())

}

break

case 'string':

try {

const string = math.parse(expr).toString({ parenthesis: parenthesis })

console.log(string)

} catch (err) {

console.log(err.toString())

}

break

case 'tex':

try {

const tex = math.parse(expr).toTex({ parenthesis: parenthesis })

console.log(tex)

} catch (err) {

console.log(err.toString())

}

break

}

}

// get next input

if (rl.output.isTTY) {

rl.prompt()

}

})

rl.on('close', function () {

console.log()

process.exit(0)

})

}

/**

* Find the symbol name of an AssignmentNode. Recurses into the chain of

* objects to the root object.

* @param {AssignmentNode} node

* @return {string | null} Returns the name when found, else returns null.

*/

function findSymbolName (node) {

const math = getMath()

let n = node

while (n) {

if (math.isSymbolNode(n)) {

return n.name

}

n = n.object

}

return null

}

/**

* Output application version number.

* Version number is read version from package.json.

*/

function outputVersion () {

fs.readFile(path.join(__dirname, '/../package.json'), function (err, data) {

if (err) {

console.log(err.toString())

} else {

const pkg = JSON.parse(data)

const version = pkg && pkg.version ? pkg.version : 'unknown'

console.log(version)

}

process.exit(0)

})

}

/**

* Output a help message

*/

function outputHelp () {

console.log('math.js')

console.log('https://mathjs.org')

console.log()

console.log('Math.js is an extensive math library for JavaScript and Node.js. It features ')

console.log('real and complex numbers, units, matrices, a large set of mathematical')

console.log('functions, and a flexible expression parser.')

console.log()

console.log('Usage:')

console.log(' mathjs [scriptfile(s)|expression] {OPTIONS}')

console.log()

console.log('Options:')

console.log(' --version, -v Show application version')

console.log(' --help, -h Show this message')

console.log(' --tex Generate LaTeX instead of evaluating')

console.log(' --string Generate string instead of evaluating')

console.log(' --parenthesis= Set the parenthesis option to')

console.log(' either of "keep", "auto" and "all"')

console.log()

console.log('Example usage:')

console.log(' mathjs Open a command prompt')

console.log(' mathjs 1+2 Evaluate expression')

console.log(' mathjs script.txt Run a script file')

console.log(' mathjs script.txt script2.txt Run two script files')

console.log(' mathjs script.txt > results.txt Run a script file, output to file')

console.log(' cat script.txt | mathjs Run input stream')

console.log(' cat script.txt | mathjs > results.txt Run input stream, output to file')

console.log()

process.exit(0)

}

/**

* Process input and output, based on the command line arguments

*/

const scripts = [] // queue of scripts that need to be processed

let mode = 'evaluate' // one of 'evaluate', 'tex' or 'string'

let parenthesis = 'keep'

let version = false

let help = false

process.argv.forEach(function (arg, index) {

if (index < 2) {

return

}

switch (arg) {

case '-v':

case '--version':

version = true

break

case '-h':

case '--help':

help = true

break

case '--tex':

mode = 'tex'

break

case '--string':

mode = 'string'

break

case '--parenthesis=keep':

parenthesis = 'keep'

break

case '--parenthesis=auto':

parenthesis = 'auto'

break

case '--parenthesis=all':

parenthesis = 'all'

break

// TODO: implement configuration via command line arguments

default:

scripts.push(arg)

}

})

if (version) {

outputVersion()

} else if (help) {

outputHelp()

} else if (scripts.length === 0) {

// run a stream, can be user input or pipe input

runStream(process.stdin, process.stdout, mode, parenthesis)

} else {

fs.stat(scripts[0], function (e, f) {

if (e) {

console.log(getMath().evaluate(scripts.join(' ')).toString())

} else {

// work through the queue of scripts

scripts.forEach(function (arg) {

// run a script file

runStream(fs.createReadStream(arg), process.stdout, mode, parenthesis)

})

}

})

}

// helper function to safely check whether an object as a property

// copy from the function in object.js which is ES6

function hasOwnProperty (object, property) {

return object && Object.hasOwnProperty.call(object, property)

}