nerdamer 1.1.13 → 2.0.0-rc.2

package/README.md

@@ -1,427 +1,341 @@
-[![Build Status](https://travis-ci.org/jiggzson/nerdamer.svg?branch=master)](https://travis-ci.org/jiggzson/nerdamer)
+# Nerdamer
 
-Nerdamer
-========
+Nerdamer is a symbolic mathematics library and computer algebra system for JavaScript and TypeScript.
 
-As of version 0.5.0, the library is split into the core and optional add-ons which can be loaded after the core has been loaded.
+Nerdamer 2.0 is a TypeScript rewrite of Nerdamer. The familiar string-based API remains available, while the package also exposes typed modules for direct use of the symbolic engine, algebra, calculus, solving, structures, assumptions, parser APIs, and advanced algorithms.
 
-Getting started with Nerdamer
+This branch prepares `2.0.0-rc.2`.
 
-Load the library in your html page
+## Install
 
-```html
-<!-- assuming you've saved the file in the root of course -->
-<!-- This the core and the only file needed if all you'll be doing is evaluating expresssions -->
-<script src="nerdamer.core.js"></script> 
-<!-- LOAD ADD-ONS. These files contain extended functions. See documentation -->
-<!-- again assuming you've saved the files in root -->
-<script src="Algebra.js"></script>
-<script src="Calculus.js"></script>
-<script src="Solve.js"></script>
-<script src="Extra.js"></script>
-```
-Or import everything
-```html
-<script src="all.min.js"></script>  <!-- assuming you've saved the file in the root -->
+```bash
+npm install nerdamer@next
 ```
-If you're using node.js install it using `npm i nerdamer` and then
+
+The release candidate is published under npm's `next` tag until the final 2.0 release.
+
+## Quick start
 
 ```javascript
-// const cannot be used since nerdamer gets modified when other modules are loaded  
-var nerdamer = require('nerdamer'); 
-// Load additional modules. These are not required.  
-require('nerdamer/Algebra'); 
-require('nerdamer/Calculus'); 
-require('nerdamer/Solve'); 
-require('nerdamer/Extra');
-```
-Or do a single import to import everything
-```javascript
-const nerdamer = require("nerdamer/all.min")
+const nerdamer = require('nerdamer');
+
+const expression = nerdamer('x^2+2*(cos(x)+x*x)');
+console.log(expression.text());
+// 2*cos(x)+3*x^2
 ```
 
-Some functions have dependencies from other add-ons. 
+TypeScript:
 
-You can see nerdamer in action at http://nerdamer.com/demo
+```typescript
+import nerdamer from 'nerdamer';
 
-For full documentation go to http://nerdamer.com/documentation
+const expression = nerdamer('(x+1)^3').expand();
+console.log(expression.text({ sort: true }));
+// x^3+3*x^2+3*x+1
+```
 
-All operations are done using the 'nerdamer' object. 
+TypeScript projects compiling to CommonJS should enable `esModuleInterop`.
 
-To add an expression just add it to the nerdamer object which will return a `Expression` object.
+## Full package and parser package
 
-```javascript             
-var e = nerdamer('x^2+2*(cos(x)+x*x)');
-console.log(e.text());
+The normal `nerdamer` entry point assembles the complete CAS. It registers the parser/core and math functions together with algebra, calculus, and solving.
 
-//result: 
-//2*cos(x)+3*x^2
-```            
-It is also possible to use `nerdamer` functions directly within the need for string manipulation of the input. The input will be parsed and the output will of type `Expression`. For example:
 ```javascript
-var ans = nerdamer.expand('(x-1)^5');
-console.log(ans.text());
-// -1-10*x^2-5*x^4+10*x^3+5*x+x^5
+const nerdamer = require('nerdamer');
 
-var sol = nerdamer.solve('x^2-4', 'x');
-console.log(sol.text())
-// [2,-2]
+nerdamer.factor('x^2-1').text();
+nerdamer.diff('x^3', 'x').text();
+nerdamer.solve('x^2-4', 'x').text();
 ```
 
-You can also pass in an object with known values as the second parameter.
+Nerdamer 2.0 also has a separate parser entry point. It contains the symbolic parser, scripting, assumptions, structures, complex and polynomial operations, and general math functions without loading the higher-level algebra, calculus, and solver domains.
 
-```javascript             
-var e = nerdamer('x^2+2*(cos(x)+x*x)',{x:6});
-console.log(e.text());
+```typescript
+import { Parser } from 'nerdamer/parser';
 
-//result:
-//108+2*cos(6)
-```            
-        
-
-As you can see only the substitution is performed. To evaluate the result just call evaluate. 
-Note that evaluate returns a text string or a number not an object.
+const expression = Parser.parse('sqrt(x^2+1)');
+console.log(expression.text());
+```
 
-```javascript             
-var e = nerdamer('x^2+2*(cos(x)+x*x)',{x:6}).evaluate();
-console.log(e.text());
+This separation is also reflected in the browser builds:
 
-//result:
-//109.9203405733006
-```            
-To get back the text as a fraction, call the text method and pass in the string 'fractions'.
+- `dist/bundle.js` — complete Nerdamer package;
+- `dist/parser.js` — parser-focused browser bundle.
 
-```javascript             
-var e = nerdamer('x^2+2*(cos(x)+x*x)',{x:6}).evaluate();
-console.log(e.text('fractions'));
+```html
+<script src="./node_modules/nerdamer/dist/bundle.js"></script>
+<script>
+    console.log(nerdamer('factor(x^2-1)').text());
+</script>
+```
 
-//result:
-//429607273/3908351
-```    
-You can get your expression back as LaTeX by calling the toTeX method
-```javascript             
-var LaTeX = nerdamer('x^2+2*(cos(x)+x*x)',{x:0.25}).toTeX();
-console.log(LaTeX);
+The parser bundle exposes `nerdamerParser` rather than the complete `nerdamer` API.
 
-//result:
-//2 \cdot \mathrm{cos}\left(\frac{1}{4}\right)+\frac{3}{16}
-```   
+## Package entry points
 
-To have numbers returned as decimals pass in the string 'decimals' to the toTeX method
+The npm package exports the complete callable API plus typed module entry points:
 
-```javascript             
-var LaTeX = nerdamer('x^2+2*(cos(x)+x*x)',{x:0.25}).toTeX('decimal');
-console.log(LaTeX);
+```typescript
+import nerdamer from 'nerdamer';
+import { Expression, Rational, type TextOptions } from 'nerdamer/core';
+import { Polynomial, gcd, lcm, partfrac } from 'nerdamer/algebra';
+import { diff, integrate, limit } from 'nerdamer/calculus';
+import { solve, PolynomialSolver } from 'nerdamer/solve';
+import { Matrix, Vector, ValuesSet } from 'nerdamer/structures';
+import { assume, clearAssumptions } from 'nerdamer/assumptions';
+import { Parser } from 'nerdamer/parser';
+```
 
-//result:
-//2 \cdot \mathrm{cos}\left(0.25\right)+0.1875
-```   
+Additional supported entry points are `nerdamer/advanced` and `nerdamer/debug`.
 
-Alternatively you can pass an object containing known values into evaluate method instead. The values passed in don't have to be number they can be another expression if needed.
+## Parser results
 
-```javascript             
-var e = nerdamer('x^2+2*(cos(x)+x*x)',{x:'x^2+1'});
-console.log(e.text());
+`nerdamer(...)` returns the Nerdamer entity represented by the input. Scalar symbolic input normally returns an `Expression`; equations and structured notation can return `Equation`, `Vector`, `Matrix`, `Collection`, `ValuesSet`, or `Dictionary`.
 
-//result:
-//2*cos(1+x^2)+3*(1+x^2)^2
-```            
+```javascript
+const scalar = nerdamer('x^2+1');
+const equation = nerdamer('x^2=1');
+const vector = nerdamer('[x, y, 3]');
+```
 
-Every time you parse an expression it's stored in nerdamer. To get a list of all the expressions you just call 
-nerdamer.expressions().
+This is intentional. Nerdamer 2.0 does not wrap every parser result in a compatibility `Expression` object.
 
-```javascript             
-var knownValues = {x:'x^2+1'};
-nerdamer('x^2+2*(cos(x)+x*x)').evaluate(knownValues);
-nerdamer('sin(x)^2+cos(x)^2').evaluate(knownValues);
+## Substitution and evaluation
 
-console.log(nerdamer.expressions());
+Values supplied to `nerdamer(...)` are substitutions. They do not imply numerical evaluation.
 
-//result:
-//[ 46.692712758272776, 1 ]
-```            
+```javascript
+const substituted = nerdamer('x^2+cos(x)', { x: 6 });
+const evaluated = substituted.evaluate();
+```
 
-You can request it as an object as well by passing in true. This can be convenient in some 
-situations as the numbering starts at 1;
+Values can themselves be symbolic expressions:
 
-```javascript             
-var knownValues = {x:'x^2+1'};
-nerdamer('x^2+2*(cos(x)+x*x)', knownValues );
-nerdamer('sin(x)^2+cos(x)^2', knownValues );
+```javascript
+nerdamer('x^2+1', { x: 'y+1' }).text();
+```
 
-console.log(nerdamer.expressions(true));
+## Text and TeX output
 
-//{ '1': '2*cos(1+x^(2))+3*(1+x^(2))^(2)',
-//'2': 'cos(1+x^(2))^(2)+sin(1+x^(2))^(2)' }
-```            
-        
-Functions aren't always immediately parsed to numbers. For example
+`text()` returns Nerdamer notation. Term ordering can be requested per call:
 
 ```javascript
-var result = nerdamer('cos(x)',{x:6});
-console.log(result.text());
-//cos(6)
+const expression = nerdamer('x^2+2*x+1');
+
+expression.text();
+// 1+2*x+x^2
+
+expression.text({ sort: true });
+// x^2+2*x+1
 ```
-will only subsitute out the variable name. To change this behaviour numer should be passed in as the 3rd argument.
+
+The full package also supplies `toText()` and TeX conversion:
 
 ```javascript
-var result = nerdamer('cos(x)',{x:6}, 'numer');
-console.log(result.text());
-//0.960170286650366
+expression.toText();
+expression.toTeX();
+nerdamer.convertToTeX('sqrt(x^2+1)');
+nerdamer.convertFromLaTeX('\\frac{x^2+1}{2}');
 ```
-or alternatively
+
+`convertToLaTeX()` remains as a deprecated compatibility alias.
+
+Scientific formatting can be requested through `text()` without changing the underlying expression:
 
 ```javascript
-var result = nerdamer('cos(x)').evaluate({x:6});
-console.log(result.text());
-//0.960170286650366
+nerdamer('1200').text({ scientific: 4 });
+// 1.200e3
 ```
-The difference however is that the first option directly substitutes the variables while the second first evaluates
-the expression and then makes the substitutions. This library utilizes native javascript functions as much as possible. As a result it inherits whatever rounding errors they possess. One major change with version 0.6.0 however, is dealing with floating point issues.
+
+## Algebra
 
 ```javascript
-var result = nerdamer('sqrt(x)*sqrt(x)-2', {x: 2});
-console.log(result.text());
-//0
+nerdamer.expand('(x+1)^4').text();
+nerdamer.factor('x^4-1').text();
+nerdamer.simplify('sin(x)^2+cos(x)^2').text();
+nerdamer.gcd('x^2-1', 'x^2-2*x+1').text();
+nerdamer.partfrac('1/(x^2-1)', 'x').text();
 ```
-The above expample now returns zero whereas in previous version the result would be 4.440892098500626e-16. Same goes for 0.1+0.2.
 
-An expression can be replaced directly by passing in the index of which expression to override. For example
+The 2.0 algebra implementation includes the rewritten polynomial GCD/factorization path, partial fractions, polynomial solving support, and direct polynomial APIs.
+
+Prime factorization has two explicit forms:
 
 ```javascript
-nerdamer('cos(x)',{x:6}, 'numer');
-nerdamer('sin(x)+y',{x:6}, null, 1);
-console.log(nerdamer.expressions());
-//[ 'sin(6)+y' ]
+nerdamer.pfactor(100).text();
+// [2,2,5,5]
+
+nerdamer.pfactord(100).text();
+// {2=>2,5=>2}
 ```
 
-If multiple modifier options need to be passed into nerdamer you can do so using an array. For example ...
+## Calculus
 
 ```javascript
-var e = nerdamer('cos(x)+(y-x)^2', {x:7}, ['expand', 'numer']);
-console.log(e.text());
-//-14*y+y^2+49.7539022543433
+nerdamer.diff('x^3+sin(x)', 'x').text();
+nerdamer.integrate('x^2', 'x').text();
+nerdamer.limit('sin(x)/x', 'x', '0').text();
+nerdamer.laplace('t', 't', 's').text();
 ```
 
-If you need the code as LaTeX you can pass in true as the second parameter when requesting the expressions.
-
-```javascript             
-nerdamer('x^2+2*(cos(x)+x*x)');
-nerdamer('sin(x)^0.25+cos(x)^0.5' );
-var asObject = true;
-var asLaTeX = true;
-console.log(nerdamer.expressions(asObject, asLaTeX));
-
-/*{ '1': '2 \\cdot \\mathrm{cos}\\left(x\\right)+3 \\cdot x^{2}',
-  '2': '\\sqrt{\\mathrm{cos}\\left(x\\right)}+\\mathrm{sin}\\left(x\\right)^{\\frac{1}{4}}' }*/
-```            
-        
-
-You can specify a particular location when adding an expression, which is specified with the third parameter.
-
-```javascript 
-nerdamer('x^2+2*(cos(x)+x*x)');
-nerdamer('sin(x)^0.25+cos(x)^0.5' );
-nerdamer('expr-override', undefined, 2 );
-var asObject = false;
-var asLaTeX = true;
-console.log(nerdamer.expressions(asObject, asLaTeX));
-
-/* [ '2 \\cdot \\mathrm{cos}\\left(x\\right)+3 \\cdot x^{2}',
-  '\\sqrt{\\mathrm{cos}\\left(x\\right)}+\\mathrm{sin}\\left(x\\right)^{\\frac{1}{4}}',
-  'expr-override' ]
- */
+The same functions can be used in Nerdamer notation:
+
+```javascript
+nerdamer('diff(x^3,x)').text();
 ```
 
-Here's an example of reserved variable and function names.
+## Solving
 
-```javascript 
-var reserved = nerdamer.reserved();
-console.log(reserved);
-//result:
-/* csc, sec, cot, erf, fact, mod, GCD, QGCD, LCM, pow, PI, E, cos, sin, tan, acos, asin, atan, sinh, cosh, tanh, asinh, acosh, atanh, exp, min, max, floor, ceil, round, vector, matrix, parens, sqrt, log, expand, abs, invert, transpose, dot */
+Single-variable solving returns a `SolutionSet`:
 
-//or as an array
+```javascript
+const roots = nerdamer.solve('x^2-1', 'x');
+console.log(roots.text());
+```
 
-var reserved = nerdamer.reserved(true);
-console.log(reserved);
-//result:
-/* [ 'csc', 'sec', 'cot', 'erf', 'fact', 'mod', 'GCD', 'QGCD', 'LCM', 'pow', 'PI', 'E', 'cos', 'sin', 'tan', 'acos', 'asin', 'atan', 'sinh', 'cosh', 'tanh', 'asinh', 'acosh', 'atanh', 'exp', 'min', 'max', 'floor', 'ceil', 'round', 'vector', 'matrix',
-  'parens', 'sqrt', 'log', 'expand', 'abs', 'invert', 'transpose', 'dot' ]  */
-```            
+System solving returns Nerdamer structures rather than legacy JavaScript arrays:
 
-Most math functions are passed in as part of the expression. If you want to differentiate for instance you just use the function diff which is located in the Calculus add-on as of version 0.5.0
+```javascript
+const solutions = nerdamer.solveSystem(
+    ['x+y=3', 'x-y=1'],
+    ['x', 'y']
+);
 
-```javascript             
-var e = nerdamer('diff(x^2+2*(cos(x)+x*x),x)');
+console.log(solutions.text());
+```
 
-console.log(e.text());
+The legacy `solveeqs` name is retained as the compatibility alias for system solving. `solveEquations` is not part of the 2.0 public API.
 
-//result: 
-//-2*sin(x)+6*x
-```
-        
+## Matrices, vectors, sets, and dictionaries
 
-Nerdamer can also handle runtime functions. To do this use the method setFunction. 
-The runtime functions do have symbolic capabilities and support for imaginary numbers. 
-The setfunction method is used as follows:
+Structured values are first-class parser entities:
 
-nerdamer.setFunction( function_name, parameter_array, function_body ) 
+```javascript
+nerdamer('matrix([1,2],[3,4])').text();
+nerdamer('[1,x,3]').text();
+nerdamer('{1,2,x}').text();
+```
 
-For Example:
+The corresponding TypeScript classes are exported from `nerdamer/structures`.
 
-```javascript             
-//generate some points
-var f = function(x) { return 5*x-1; }
-console.log(f(1)); //4
-console.log(f(2)); //9 - value to be found
-console.log(f(7)); //34
+## Scripting
 
-nerdamer.setFunction('interpolate',['y0','x0','y1','x1','x'],'y0+(y1-y0)*((x-x0)/(x1-x0))')
-var answer = nerdamer('interpolate(4,1,34,7,2)').evaluate();
+Nerdamer notation includes a symbolic scripting layer with assignments, user functions, local bindings, conditionals, loops, blocks, logical operations, `return`, `break`, `continue`, and error-handling helpers.
 
-console.log(answer);
+```javascript
+const result = nerdamer(`
+    f(x):=x^2+1;
+    f(12)
+`);
 
-//result: 9
+console.log(result.text());
 ```
 
-Custom functions alternatively be set in following manner.
+Control-flow operations that intentionally produce no mathematical value use an internal null signal. That signal is distinct from legitimate values such as an empty vector and is not exposed as a normal parser entity.
+
+## Runtime functions, constants, and settings
 
 ```javascript
-nerdamer('hyp(a, b) := sqrt(a^2 + b^2) ');
-var result = nerdamer('hyp(3, 4)').evaluate().text();
-console.log(result);
-//result: 5
+nerdamer.setFunction('line', ['x', 'm', 'b'], 'm*x+b');
+nerdamer.setConstant('g', 9.81);
+nerdamer.setVar('a', 5);
 ```
 
+Settings remain shared by the package instance:
 
-If you need to add a constant use the setConstant method
-
-```javascript             
-nerdamer.setConstant( 'g', 9.81);
-var weight = nerdamer('100*g').text();
-console.log(weight);
-//result:
-//981
-```            
-        
-To delete just set it to delete
-
-```javascript             
-nerdamer.setConstant( 'g', 9.81);
-var weight = nerdamer('100*g').text();
-console.log(weight);
-//981
-nerdamer.setConstant( 'g', 'delete');
-var weight = nerdamer('100*g').text();
-console.log(weight);
-//100*g
-```        
-
-You also have the option of exporting your function to a javascript function which can be useful if you need some 
-filtering from user input. Do keep in mind that the parameters are sorted alphabetically for more than one 
-parameter. To use it add the expression to nerdamer and use the buildFunction method.
-
-```javascript             
-var f = nerdamer('x^2+5').buildFunction();
-console.log(f(9));
-
-//result:
-//86
-```            
-If you have a particular order in which you need the parameters to be set, then you pass in an array with the variables in the order in which you want them for instance:
+```javascript
+nerdamer.set('LANGUAGE', 'spa');
+nerdamer.set('LANGUAGE', 'eng');
+```
 
- ```javascript
-var f = nerdamer('z+x^2+y').buildFunction(['y', 'x', 'z']);
- console.log(f(9,2,1));
- //result
- //14
- ```
+Built-in error messages are available in English, Spanish, French, German, Portuguese, Italian, and Dutch.
 
-Every time you add an expression to nerdamer it's stored. To list the expressions currently in nerdamer call 
-the 'expressions' method. To delete an expression use the 'clear' method and pass in the expression you want to delete. 
-To clear everything pass in the string 'all'.
+## Assumptions
 
-```javascript            
-nerdamer('n*R*T/v');
-nerdamer('mc^2');
-nerdamer('G*m1*m2/d^2');
+```typescript
+import nerdamer from 'nerdamer';
+import { assume, clearAssumptions } from 'nerdamer/assumptions';
 
-nerdamer.clear(2);
+assume('x > 0');
+console.log(nerdamer('sqrt(x^2)').text());
+// x
+clearAssumptions();
+```
 
-console.log(nerdamer.expressions(true));
+Repeated assumptions for a symbol are intersected. Contradictory assumptions are rejected.
 
-//result:
-//{ '1': 'R*T*n*v^(-1)', '2': 'G*d^(-2)*m1*m2' }
+## Building JavaScript functions
 
-nerdamer.clear('all');
-console.log(nerdamer.expressions(true));
-//result:
-//{}
-```            
-     
-If you need go get the variables of an expression use the variables method. This method can be called after
-nerdamer was provided an expression. For example
+Scalar expressions can be compiled to native JavaScript-number functions:
 
 ```javascript
-var variables = nerdamer('csc(x*cos(y))-no_boring_x').variables();
-console.log(variables);
-//result:
-//[ 'no_boring_x', 'x', 'y' ]
+const f = nerdamer('x^2+5').buildFunction();
+console.log(f(9));
+// 86
 ```
 
-The order in which the variables appear require a little bit of knowledge of how nerdamer organizes symbols. For the
-sake of simplicity we'll just assume that there is no particular order   
+`buildFunction()` uses dynamic JavaScript function construction. Applications whose Content Security Policy blocks dynamic code generation should use Nerdamer's symbolic or numeric evaluation APIs instead. Structured parser results cannot be compiled as scalar functions.
 
-----------------------------------------------------------------------------------------------------------------------
+## Numeric behavior
+
+Nerdamer preserves exact integer and rational arithmetic where possible. Large integers use native `BigInt`; decimal arithmetic uses Decimal.js. Complex arithmetic is represented by Nerdamer's numeric types rather than JavaScript's native `Number` alone.
 
-Using the solver
-===============
-To solve equations first load Solve.js. Just remember that Solve also required Algebra.js and Calculus.js to be loaded. You can then solve equations using nerdamer. Important: State the variable for which you are trying to solve.
 ```javascript
-var sol = nerdamer.solveEquations('x^3+8=x^2+6','x');
-console.log(sol.toString());
-//1+i,-i+1,-1
+nerdamer('0.1+0.2').text();
+nerdamer('sqrt(2)').evaluate().text();
 ```
 
-Notice that we use toString rather than text as this returns a javascript array.
+## Building from source
 
-You can also solve an expression
-```javascript
-var e = nerdamer.solveEquations('x^2+4-y', 'y');
-console.log(e[0].text());
-//4+x^2
-```
+Install dependencies and run the normal checks:
 
-You can also solve multivariate equations
-```javascript
-var sol = nerdamer.solveEquations('x^2+8+y=x+6','x');
-console.log(sol.toString());
-//0.5*((-4*y-7)^0.5+1),0.5*(-(-4*y-7)^0.5+1)
+```bash
+npm install
+npm run typecheck
+npm test
 ```
-You can do up to 3rd order polynomials for multivariate polynomials
 
-Additionally you can try for equations containing functions. This is more of a hit or miss approach unlike single variable polynomials (which uses Mr. David Binner's Jenkins-Traub port - http://www.akiti.ca/PolyRootRe.html) but it's there if you want to give it a try.
+Build the complete package:
 
-```javascript
-var sol = nerdamer.solveEquations('cos(x)+cos(3*x)=1','x');
-console.log(sol.toString());
-//5.7981235959208695,0.4850617112587174
+```bash
+npm run build
 ```
-To solve a system of linear equations pass them in as an array. For example
 
-```javascript
-var sol = nerdamer.solveEquations(['x+y=1', '2*x=6', '4*z+y=6']);
-console.log(sol);
-//[ [ 'x', 3 ], [ 'y', -2 ], [ 'z', 2 ] ]
-```
-In version 0.7.2 and up the solver can additionally be used in the following way
-```javascript
-//first parse the equation
-var x = nerdamer('x^2+2=y-7*a');
-//You can make substitutions to the equation
-x = x.evaluate({a: 'x^2-3'});
-console.log(x.toString()); //2+x^2=-7*x^2+21+y
-var solutions = x.solveFor('x');
-console.log(solutions.toString()); //(1/16)*sqrt(32*y+608),(-1/16)*sqrt(32*y+608)
+Build the parser-only browser bundle:
+
+```bash
+npm run build:parser
 ```
+
+The webpack build also accepts a language selection (`eng`, `spa`, `fra`, `deu`, `por`, `ita`, `nld`, or `all`) for browser bundles. English is the default.
+
+Before publishing, the package runs type checking, tests, coverage, both browser builds, parser documentation generation, TypeDoc validation, and packed-package validation through `prepublishOnly`.
+
+## Migrating from Nerdamer 1.x
+
+Nerdamer 2.0 keeps much of the familiar expression-oriented API, but it is a new implementation. Important migration areas include:
+
+- the old `Algebra`, `Calculus`, `Solve`, and `Extra` side-effect imports are replaced by the complete package and supported module entry points;
+- the third and fourth arguments to `nerdamer(...)` are gone;
+- global parsed-expression history is gone;
+- parser results can be structured Nerdamer entities instead of always being wrapped as an `Expression`;
+- system-solving results use `Vector`/`Dictionary` structures;
+- lower-level 1.x extension hooks such as `getCore()` and `register()` are not restored;
+- several compatibility functions were restored explicitly rather than by exposing every parser function on the root object;
+- internal numeric, parser, solver, polynomial, assumptions, set, and scripting implementations have changed substantially.
+
+See [BREAKING_CHANGES.md](BREAKING_CHANGES.md) and [Moving from Nerdamer 1.x to 2.0](docs/MIGRATING_FROM_1X.md) before upgrading an existing application.
+
+## Documentation
+
+- Website: https://nerdamer.com/
+- Documentation: https://nerdamer.com/documentation
+- Migration guide: `docs/MIGRATING_FROM_1X.md`
+- 2.0 release notes: `docs/RELEASE_NOTES_2.md`
+- Parser conventions: `docs/PARSER_CONVENTIONS.md`
+- Source repository: https://github.com/jiggzson/nerdamer
+- Issues: https://github.com/jiggzson/nerdamer/issues
+
+## License
+
+Nerdamer 2.0 is licensed under the Apache License 2.0.