---
title: "NSolve"
language: "en"
type: "Symbol"
summary: "NSolve[expr, vars] attempts to find numerical approximations to the solutions of the system expr of equations or inequalities for the variables vars. NSolve[expr, vars, Reals] finds solutions over the domain of real numbers."
keywords: 
- equations
- Jenkins-Traub algorithm
- numerical solution of polynomial equations
- polynomial equations
- polynomial root finding
- roots of polynomials
- solution of polynomial equations
- direct method for root finding
- direct equation solving method
- homotopy method
- monodromy method
- continuation method
- homotopy equation solving
- monodromy equation solving
- continuation equation solving
- Groebner equation solving
- numerical equation solving
- numerical root finding
- approximate roots of systems of equations
- fsolve
canonical_url: "https://reference.wolfram.com/language/ref/NSolve.html"
source: "Wolfram Language Documentation"
related_guides: 
  - 
    title: "Equation Solving"
    link: "https://reference.wolfram.com/language/guide/EquationSolving.en.md"
  - 
    title: "Polynomial Systems"
    link: "https://reference.wolfram.com/language/guide/PolynomialSystems.en.md"
  - 
    title: "Numerical Evaluation & Precision"
    link: "https://reference.wolfram.com/language/guide/NumericalEvaluationAndPrecision.en.md"
  - 
    title: "Polynomial Equations"
    link: "https://reference.wolfram.com/language/guide/PolynomialEquations.en.md"
  - 
    title: "Solvers over Regions"
    link: "https://reference.wolfram.com/language/guide/GeometricSolvers.en.md"
  - 
    title: "Solid Geometry"
    link: "https://reference.wolfram.com/language/guide/SolidGeometry.en.md"
  - 
    title: "Plane Geometry"
    link: "https://reference.wolfram.com/language/guide/PlaneGeometry.en.md"
  - 
    title: "Polygons"
    link: "https://reference.wolfram.com/language/guide/Polygons.en.md"
  - 
    title: "Geometric Computation"
    link: "https://reference.wolfram.com/language/guide/GeometricComputation.en.md"
  - 
    title: "Symbolic Vectors, Matrices and Arrays"
    link: "https://reference.wolfram.com/language/guide/SymbolicArrays.en.md"
  - 
    title: "Polyhedra"
    link: "https://reference.wolfram.com/language/guide/Polyhedra.en.md"
related_functions: 
  - 
    title: "Solve"
    link: "https://reference.wolfram.com/language/ref/Solve.en.md"
  - 
    title: "FindRoot"
    link: "https://reference.wolfram.com/language/ref/FindRoot.en.md"
  - 
    title: "NSolveValues"
    link: "https://reference.wolfram.com/language/ref/NSolveValues.en.md"
  - 
    title: "MaxRoots"
    link: "https://reference.wolfram.com/language/ref/MaxRoots.en.md"
  - 
    title: "NDSolve"
    link: "https://reference.wolfram.com/language/ref/NDSolve.en.md"
  - 
    title: "NMinimize"
    link: "https://reference.wolfram.com/language/ref/NMinimize.en.md"
  - 
    title: "InterpolatingFunction"
    link: "https://reference.wolfram.com/language/ref/InterpolatingFunction.en.md"
  - 
    title: "AsymptoticSolve"
    link: "https://reference.wolfram.com/language/ref/AsymptoticSolve.en.md"
related_tutorials: 
  - 
    title: "Numerical Mathematics: Basic Operations"
    link: "https://reference.wolfram.com/language/tutorial/NumericalCalculations.en.md"
  - 
    title: "Numerical Equation Solving"
    link: "https://reference.wolfram.com/language/tutorial/NumericalOperationsOnFunctions.en.md#1863"
  - 
    title: "Equations in One Variable"
    link: "https://reference.wolfram.com/language/tutorial/ManipulatingEquationsAndInequalities.en.md#16840"
  - 
    title: "Numerical Mathematics"
    link: "https://reference.wolfram.com/language/tutorial/NumericalOperationsOnFunctions.en.md#20411"
  - 
    title: "Numerical Solution of Polynomial Equations"
    link: "https://reference.wolfram.com/language/tutorial/NumericalOperationsOnFunctions.en.md#20638"
  - 
    title: "Implementation Notes: Numerical and Related Functions"
    link: "https://reference.wolfram.com/language/tutorial/SomeNotesOnInternalImplementation.en.md#25940"
---
# NSolve

NSolve[expr, vars] attempts to find numerical approximations to the solutions of the system expr of equations or inequalities for the variables vars. 

NSolve[expr, vars, Reals] finds solutions over the domain of real numbers.

## Details and Options

* The system ``expr`` can be any logical combination of:

|                          |                          |
| :----------------------- | :----------------------- |
| lhs == rhs               | equations                |
| lhs != rhs               | inequations              |
| lhs > rhs or lhs >= rhs  | inequalities             |
| expr∈dom                 | domain specifications    |
| {x, y, …}∈reg            | region specification     |
| ForAll[x, cond, expr]    | universal quantifiers    |
| Exists[x, cond, expr]    | existential quantifiers  |

* ``NSolve[{expr1, expr2, …}, vars]`` is equivalent to ``NSolve[expr1 && expr2 && …, vars]``.

* A single variable or a list of variables can be specified.

* ``NSolve`` gives solutions in terms of rules of the form:

|                                |                                  |
| ------------------------------ | -------------------------------- |
| {}                             | no solutions                     |
| {{x -> solx, y -> soly, …}, …} | several solutions                |
| {{}}                           | solution set is full dimensional |

* When a single variable is specified and a particular root of an equation has multiplicity greater than one, ``NSolve`` gives several copies of the corresponding solution.

* ``NSolve[expr, vars]`` assumes by default that quantities appearing algebraically in inequalities are real, while all other quantities are complex.

* In ``NSolve[expr, vars, Reals]`` all variables, parameters, constants, and function values are restricted to be real.

* ``NSolve[expr && vars∈Reals, vars, Complexes]`` solves for real values of variables, but function values are allowed to be complex.

* ``NSolve[…, x∈reg, Reals]`` constrains ``x`` to be in the region ``reg``. The different coordinates for ``x`` can be referred to using ``Indexed[x, i]``.

* ``NSolve`` deals primarily with linear and polynomial equations.

* The following options can be given:

|                   |           |                                        |
| :---------------- | :-------- | :------------------------------------- |
| MaxRoots          | Automatic | maximum number of roots returned       |
| Method            | Automatic | what method should be used             |
| RandomSeeding     | 1234      | the seeding of pseudorandom generators |
| VerifySolutions   | Automatic | whether to verify solutions            |
| WorkingPrecision  | Automatic | precision to be used in computations   |

* Possible ``Method`` settings include ``"EndomorphismMatrix"``,  ``"Homotopy"``, ``"Monodromy"``, and ``"Symbolic"``. »

---

## Examples (98)

### Basic Examples (6)

Approximate solutions to a polynomial equation:

```wl
In[1]:= NSolve[x ^ 5 - 2x + 3 == 0, x]

Out[1]= {{x -> -1.42361}, {x -> -0.246729 - 1.32082 I}, {x -> -0.246729 + 1.32082 I}, {x -> 0.958532  - 0.498428 I}, {x -> 0.958532  + 0.498428 I}}
```

---

Approximate real solutions to a polynomial equation:

```wl
In[1]:= NSolve[x ^ 5 - 2x + 3 == 0, x, Reals]

Out[1]= {{x -> -1.42361}}
```

---

Find three approximate solutions to a polynomial equation of a high degree:

```wl
In[1]:= NSolve[x ^ 1000000 - 2x + 3 == 0, x, MaxRoots -> 3]

Out[1]= {{x -> 0.999871  + 0.0160622 I}, {x -> 0.999871  + 0.0160685 I}, {x -> 0.999871  + 0.0160748 I}}
```

---

Approximate solutions to a system of polynomial equations:

```wl
In[1]:= NSolve[{x ^ 2 + y ^ 3 == 1, 2x + 3y == 4}, {x, y}]

Out[1]= {{x -> 7.93641, y -> -3.95761}, {x -> 0.719295  - 0.255679 I, y -> 0.853803  + 0.170453 I}, {x -> 0.719295  + 0.255679 I, y -> 0.853803  - 0.170453 I}}
```

---

Approximate real solutions to a system of polynomial equations:

```wl
In[1]:= NSolve[{x ^ 2 + y ^ 3 == 1, 2x + 3y == 4}, {x, y}, Reals]

Out[1]= {{x -> 7.93641, y -> -3.95761}}
```

---

Solve equations in a geometric region:

```wl
In[1]:= NSolve[{x, y}∈InfiniteLine[{{0, 0}, {2, 1}}] && {x, y}∈Circle[], {x, y}]

Out[1]= {{x -> -0.894427, y -> -0.447214}, {x -> 0.894427, y -> 0.447214}}

In[2]:= Graphics[{{Blue, InfiniteLine[{{0, 0}, {2, 1}}], Circle[]}, {Red, Point[{x, y}] /. %}}]

Out[2]= [image]
```

### Scope (48)

#### Complex Equations in One Variable (10)

Univariate polynomial equations:

```wl
In[1]:= NSolve[x ^ 5 - 2x + 17 == 0, x]

Out[1]= {{x -> -1.83251}, {x -> -0.487961 - 1.7207 I}, {x -> -0.487961 + 1.7207 I}, {x -> 1.40422  - 0.963419 I}, {x -> 1.40422  + 0.963419 I}}
```

---

Polynomial equations with inexact coefficients:

```wl
In[1]:= NSolve[x ^ 3 - 1.234x + 5.678 == 0, x]

Out[1]= {{x -> -2.01346}, {x -> 1.00673  - 1.34407 I}, {x -> 1.00673  + 1.34407 I}}
```

---

Polynomial equations with multiple roots:

```wl
In[1]:= NSolve[(x ^ 2 - 1)(x ^ 4 - 1) == 0, x]

Out[1]= {{x -> -1.}, {x -> -1.}, {x -> 0.  - 1. I}, {x -> 0.  + 1. I}, {x -> 1.}, {x -> 1.}}
```

---

Find five roots of a polynomial of a high degree:

```wl
In[1]:= NSolve[x ^ 1234567 + 9x ^ 2 + 7x - 1 == 0, x, MaxRoots -> 5]

Out[1]= {{x -> 0.123308}, {x -> 0.742796  - 0.669521 I}, {x -> 0.742799  - 0.669517 I}, {x -> 0.742803  - 0.669513 I}, {x -> 0.742806  - 0.66951 I}}
```

---

Algebraic equations:

```wl
In[1]:= NSolve[Sqrt[x] + 3x ^ (1 / 3) == 5, x]

Out[1]= {{x -> 1.80863}}
```

---

Transcendental equations:

```wl
In[1]:= NSolve[Sin[x] == 1 / 3, x]

Out[1]= {{x -> 0.339837}, {x -> 2.80176}, {x -> -3.48143}, {x -> 6.62302}, {x -> -5.94335}, {x -> 9.08494}, {x -> -9.76461}, {x -> 12.9062}, {x -> -12.2265}, {x -> 15.3681}, {x -> -16.0478}, {x -> 19.1894}, {x -> -18.5097}, {x -> 21.6513}, {x -> -22.331}, {x -> 25.4726}}
```

Find all solutions:

```wl
In[2]:= NSolve[Sin[x] == 1 / 3, x, MaxRoots -> Infinity]

Out[2]= {{x -> ConditionalExpression[1.*(0.3398369094541219 + 6.283185307179586*C[1]), Element[C[1], Integers]]}, {x -> ConditionalExpression[1.*(2.8017557441356713 + 6.283185307179586*C[1]), Element[C[1], Integers]]}}
```

Specify the number of solutions returned:

```wl
In[3]:= NSolve[5 == x 2 ^ (x ^ 2), x, MaxRoots -> 3]

Out[3]= {{x -> 1.36759}, {x -> 2.10528  + 1.90118 I}, {x -> 2.94008  + 2.89246 I}}
```

---

Univariate elementary function equations over bounded regions:

```wl
In[1]:= NSolve[Sin[E ^ x] - Cos[2 x] == 1 && -1 ≤ Re[x] ≤ 1 && -1 ≤ Im[x] ≤ 1, x]

Out[1]= {{x -> 0.915227  + 0.201675 I}, {x -> 0.915227  - 0.201675 I}}
```

---

Univariate holomorphic function equations over bounded regions:

```wl
In[1]:= NSolve[Gamma[x] - Log[x] == I / 2 && Abs[x - 2] < 3 / 2, x]

Out[1]= {{x -> 1.49329  - 0.98485 I}, {x -> 2.67101  + 0.819571 I}}
```

---

Equation with a purely imaginary period over a vertical stripe in the complex plane:

```wl
In[1]:= NSolve[Cos[Exp[x]] == 3 Exp[-x] + 1 && 0 ≤ Re[x] ≤ 1, x]

Out[1]= {{x -> 0.546541  + 1.11115 I}, {x -> 0.718553  + 3.14159 I}, {x -> 0.546541  + 5.17204 I}, {x -> 0.546541  - 1.11115 I}}
```

Find all solutions:

```wl
In[2]:= NSolve[Cos[Exp[x]] == 3 Exp[-x] + 1 && 0 ≤ Re[x] ≤ 1, x, MaxRoots -> Infinity]

Out[2]=
{{x -> ConditionalExpression[(0.5465407839974525 + 5.172036664682884*I) + (0. + 6.283185307179586*I)*C[1], 
 Element[C[1], Integers]]}, {x -> ConditionalExpression[(0.5465407839974525 + 1.1111486424967023*I) + 
  (0. + 6.283185307179586*I)*C[1], Element[C[1], Integers]]}, {x -> ConditionalExpression[(0.7185533775573053 + 3.141592653589793*I) + (0. + 6.283185307179586*I)*C[1], 
 Element[C[1], Integers]]}}
```

---

Unrestricted transcendental function equations:

```wl
In[1]:= NSolve[BesselJ[2, x]x - 2 ^ x == 3, x]

Out[1]= {{x -> -6.8903 - 0.907431 I}, {x -> -1.10462 - 2.32165 I}, {x -> 2.60079  - 2.48465 I}, {x -> 2.60079  + 2.48465 I}, {x -> -1.10462 + 2.32165 I}, {x -> -6.8903 + 0.907431 I}, {x -> -13.2485 + 0.239231 I}, {x -> -19.0014}, {x -> -13.2485 - 0.239231 I}, {x -> 6.99004  - 4.79181 I}, {x -> -20.1222}, {x -> -25.1194}, {x -> -26.6031}, {x -> -31.3067}, {x -> -33.0025}, {x -> -37.5241}}
```

#### Systems of Complex Equations in Several Variables (9)

Systems of linear equations:

```wl
In[1]:= NSolve[{x + 2y + 3z == 4, 3x + 4y + 5z == 6, 7x + 9y + 8z == 10}, {x, y, z}]

Out[1]= {{x -> -1., y -> 1., z -> 1.}}
```

---

Linear equations with inexact coefficients:

```wl
In[1]:= NSolve[1.23 x + 2.34 y + 3.45 z == 4.56  && 5.67x + 6.78y + 7.89z == 8.9 && 9.01x + 0.12y + 1.23z == 2.34, {x, y, z}]

Out[1]= {{x -> -0.005, y -> -1.06, z -> 2.04248}}
```

---

Underdetermined systems of linear equations:

```wl
In[1]:= NSolve[x + 2y + 3z == 4 && 3x + 4y + 5z == 6 && 6x + 7y + 8z == 9, {x, y, z}]

Out[1]= {{x -> -2. + 1. z, y -> 3.  - 2. z}}
```

---

Linear equations with no solutions:

```wl
In[1]:= NSolve[x + 2y + 3z == 4 && 3x + 4y + 5z == 6 && 6x + 7y + 8z == 0, {x, y, z}]

Out[1]= {}
```

---

Systems of polynomial equations:

```wl
In[1]:= NSolve[x ^ 2 + y ^ 2 == 1 && x ^ 3 + 2y ^ 3 == 3, {x, y}]

Out[1]= {{x -> -1.23767 - 0.668184 I, y -> -0.886234 + 0.933155 I}, {x -> -1.23767 + 0.668184 I, y -> -0.886234 - 0.933155 I}, {x -> 1.2809  - 0.163263 I, y -> -0.253879 - 0.823719 I}, {x -> 1.2809  + 0.163263 I, y -> -0.253879 + 0.823719 I}, {x -> -0.0432296 - 0.548902 I, y -> 1.14011  - 0.0208127 I}, {x -> -0.0432296 + 0.548902 I, y -> 1.14011  + 0.0208127 I}}
```

---

Find five out of a trillion roots of a polynomial system:

```wl
In[1]:= NSolve[x ^ 10000 == y ^ 2 + 2y + 1 && y ^ 10000 == z ^ 2 + 2z + 1 && z ^ 10000 == x ^ 2 + 2 x + 1, {x, y, z}, MaxRoots -> 5]

Out[1]= {{x -> -0.998697 - 0.000537772 I, y -> -0.998674 - 0.00063937 I, z -> -0.998688 + 0.0000781556 I}, {x -> -0.998733 - 0.00110905 I, y -> -0.998681 - 0.00118261 I, z -> -0.998723 - 0.000483895 I}, {x -> -0.998772 - 0.00169588 I, y -> -0.998716 - 0.00174014 I, z -> -0.998766 - 0.0010665 I}, {x -> -0.99881 - 0.00229455 I, y -> -0.99876 - 0.00232056 I, z -> -0.998808 - 0.0016645 I}, {x -> -0.998847 - 0.00290409 I, y -> -0.998754 - 0.00294618 I, z -> -0.998846 - 0.00164446 I}}
```

---

Underdetermined systems of polynomial equations:

```wl
In[1]:= NSolve[x ^ 2 + y ^ 2 + z ^ 2 == 1 && x y z == 2, {x, y, z}]
```

NSolve::infsolns: Infinite solution set has dimension at least 1. Returning intersection of solutions with -((69046 x)/57903)-(142003 y)/115806+(40299 z)/38602 == 1.

```wl
Out[1]= {{x -> 0.325788  - 1.04381 I, y -> 0.322648  + 1.02045 I, z -> 1.70899  + 0.00632808 I}, {x -> 0.325788  + 1.04381 I, y -> 0.322648  - 1.02045 I, z -> 1.70899  - 0.00632808 I}, {x -> 0.439871  - 0.966045 I, y -> -1.631 + 0.0358209 I, z -> -0.45541  ... 39871  + 0.966045 I, y -> -1.631 - 0.0358209 I, z -> -0.45541 + 1.06137 I}, {x -> -1.648 + 0.0424375 I, y -> 0.416393  - 0.957971 I, z -> -0.435416 - 1.07674 I}, {x -> -1.648 - 0.0424375 I, y -> 0.416393  + 0.957971 I, z -> -0.435416 + 1.07674 I}}
```

---

Algebraic equations:

```wl
In[1]:= NSolve[Sqrt[x y] == Sqrt[x + y] && Sqrt[x] - y ^ (1 / 3) == 1, {x, y}]

Out[1]= {{x -> 4.37009, y -> 1.29673}, {x -> 4.37009, y -> 1.29673}}
```

---

Transcendental equations:

```wl
In[1]:= NSolve[Sin[x + y] == x y + 1 && Cos[x - y] == AiryAi[x y] + 2, {x, y}]

Out[1]= {{x -> 0.59795  - 1.27057 I, y -> 0.530877  + 0.160125 I}, {x -> 5.49066  - 1.75784 I, y -> -0.790687 - 0.244913 I}, {x -> 11.7578  - 1.23148 I, y -> -0.222338 - 0.100319 I}, {x -> 15.5787  + 2.23392 I, y -> -0.0522746 - 0.223884 I}, {x -> 13.0377  ... 084 I}, {x -> 61.4829  - 3.51599 I, y -> -0.289143 + 0.00181026 I}, {x -> 67.7673  - 3.59871 I, y -> -0.283863 + 0.00128324 I}, {x -> 74.0506  - 3.67247 I, y -> -0.27876 + 0.000907381 I}, {x -> 80.3333  - 3.73902 I, y -> -0.27388 + 0.000633039 I}}
```

Specify the number of solutions returned:

```wl
In[2]:= NSolve[3 ^ x ^ 2 == 7 && x ^ 2 - y ^ 3 == 4, {x, y}, MaxRoots -> 5]

Out[2]= {{x -> 1.33088, y -> -1.30623}, {x -> 1.33088, y -> 0.653117  - 1.13123 I}, {x -> 1.33088, y -> 0.653117  + 1.13123 I}, {x -> 1.96957  + 1.45189 I, y -> -1.68661 + 0.712561 I}, {x -> 1.96957  + 1.45189 I, y -> 0.226211  - 1.81693 I}}
```

#### Real Equations in One Variable (11)

Polynomial equations:

```wl
In[1]:= NSolve[x ^ 5 - 2x + 1 == 0, x, Reals]

Out[1]= {{x -> -1.29065}, {x -> 0.51879}, {x -> 1.}}
```

---

Polynomial equations with multiple roots:

```wl
In[1]:= NSolve[(x ^ 2 - 1)(x ^ 4 - 1) == 0, x, Reals]

Out[1]= {{x -> -1.}, {x -> -1.}, {x -> 1.}, {x -> 1.}}
```

---

Algebraic equations:

```wl
In[1]:= NSolve[Sqrt[x] + 3x ^ (1 / 3) == 5, x, Reals]

Out[1]= {{x -> 1.80863}}
```

---

Piecewise equations:

```wl
In[1]:= NSolve[Abs[x] ^ 2 - x + UnitStep[x] == 9, x, Reals]

Out[1]= {{x -> 3.37228}, {x -> -2.54138}}
```

---

Transcendental equations, solvable using inverse functions:

```wl
In[1]:= NSolve[E ^ x - x == 7, x, Reals]

Out[1]= {{x -> -6.99909}, {x -> 2.22154}}

In[2]:= NSolve[ 27^2x - 1^(1/(x)) == Sqrt[9^2x - 1], x, Reals]

Out[2]= {{x -> 0.5}, {x -> 3.}}
```

---

Transcendental equations, solvable using special function zeros:

```wl
In[1]:= NSolve[AiryBi[1 - x ^ 2] == 0 && 2 < x < 3, x, Reals]

Out[1]= {{x -> 2.06666}, {x -> 2.41469}, {x -> 2.67766}, {x -> 2.89426}}
```

---

Transcendental inequalities, solvable using special function zeros:

```wl
In[1]:= NSolve[900 < AiryAiZero[2t + 1] ^ 2 < 1000, t, Reals]

Out[1]= {{t -> 17.5}, {t -> 18.}}
```

---

Exp-log equations:

```wl
In[1]:= NSolve[E ^ (2E ^ x) - Log[x ^ 2 + 1] - 20x == 11, x, Reals]

Out[1]= {{x -> -0.351627}, {x -> 0.383183}}
```

High-degree sparse polynomial equations:

```wl
In[2]:= NSolve[x ^ 1000000 - 2x ^ 777777 + 3x ^ 12345 + 9x ^ 67 - 10 == 0, x, Reals]

Out[2]= {{x -> -1.}, {x -> 0.999915}, {x -> 1.}, {x -> 1.}}
```

Algebraic equations involving high-degree radicals:

```wl
In[3]:= NSolve[2x ^ (123451 / 67890) - x ^ 2 + 4Sqrt[x] - 4x - 9 / 8 == 0, x, Reals]

Out[3]= {{x -> 0.300293}, {x -> 0.614664}, {x -> 4.67046}, {x -> 20.7516}}
```

Equations involving irrational real powers:

```wl
In[4]:= NSolve[x ^ Pi - x ^ x ^ Sqrt[2] - Sqrt[3]x + 2 ^ (1 / 3) == 0, x, Reals]

Out[4]= {{x -> 0.26508}, {x -> 1.40312}, {x -> 2.04927}}
```

---

Tame elementary function equations:

```wl
In[1]:= NSolve[10Sin[Tan[E ^ -x ^ 2]] - x == 3, x, Reals]

Out[1]= {{x -> -2.99876}, {x -> -1.34225}, {x -> 0.973157}}
```

---

Elementary function equations in bounded intervals:

```wl
In[1]:= NSolve[2Sin[Exp[x]] - Cos[Pi x] == 3 / 2 && -1 < x < 1, x, Reals]

Out[1]= {{x -> -0.676467}, {x -> 0.342857}}
```

---

Holomorphic function equations in bounded intervals:

```wl
In[1]:= NSolve[Cos[x] - BesselJ[5, x] == 1 / 2 && 0 ≤ x ≤ 10, x]

Out[1]= {{x -> 1.04684}, {x -> 5.71218}, {x -> 6.81481}}
```

#### Systems of Real Equations and Inequalities in Several Variables (9)

Linear systems:

```wl
In[1]:= NSolve[2 x + 3y - 5z == 1 && 3x - 4y + 7z == 3 && x + y - z == 8, {x, y, z}, Reals]

Out[1]= {{x -> 0.0909091, y -> 19.3636, z -> 11.4545}}
```

---

Polynomial systems:

```wl
In[1]:= NSolve[x y == z ^ 2 - x && x y z == 2 && x ^ 2 + y ^ 2 + z ^ 2 == 5, {x, y, z}, Reals]

Out[1]= {{x -> 1.046, y -> 1.24714, z -> 1.53314}, {x -> 1.15308, y -> 1.11157, z -> 1.56039}}
```

---

Quantified polynomial systems:

```wl
In[1]:= NSolve[Exists[x, x ^ 2 + a x + b == 0 && 2 x + a == 0 && a ^ 2 + x b ^ 2 == 1], {a, b}, Reals]

Out[1]= {{a -> 3.05729, b -> 2.33675}, {a -> 1.01684, b -> 0.258493}, {a -> -0.985378, b -> 0.242742}}

In[2]:= NSolve[ForAll[x, Exists[y, a x ^ 2 + b y ^ 2 - 3y == 1 && y < 0 && a y - y == b + 1]], {a, b}, Reals]

Out[2]= {{a -> 0, b -> -0.638897}, {a -> 1., b -> -1.}}
```

---

Algebraic systems:

```wl
In[1]:= NSolve[Sqrt[x + 2y] - 3x + 4y == 5 && x + y ^ (1 / 3) == 2, {x, y}, Reals]

Out[1]= {{x -> 0.874986, y -> 1.42388}}
```

---

Piecewise systems:

```wl
In[1]:= NSolve[Max[x ^ 2, 1 - y ^ 3] == Min[y ^ 2, x] + 7y && x + UnitStep[4 - y] == 5, {x, y}, Reals]

Out[1]= {{x -> 4., y -> 1.81507}}
```

---

Transcendental systems solvable using inverse functions:

```wl
In[1]:= NSolve[Sin[x + y] == 1 / 2 && E ^ x - y == 1 && x ^ 2 ≤ 10, {x, y}, Reals]

Out[1]= {{x -> -2.73039, y -> -0.934806}, {x -> 0.245429, y -> 0.27817}, {x -> 0.97276, y -> 1.64523}, {x -> 1.7939, y -> 5.01288}, {x -> 2.05946, y -> 6.84172}, {x -> 2.45409, y -> 10.6359}, {x -> 2.60831, y -> 12.5761}, {x -> 2.86279, y -> 16.5104}, {x -> 2.97027, y -> 18.4973}, {x -> 3.15697, y -> 22.4994}}

In[2]:= NSolve[ 3^x - 2^2y == 77 && Sqrt[3^x] - 2^y == 7, {x, y}, Reals]

Out[2]= {{x -> 4., y -> 1.}}
```

---

Systems exp-log in the first variable and polynomial in the other variables:

```wl
In[1]:= NSolve[E ^ x y ^ 3 + Log[x]y == 1 && x y + E ^ x / x == 10, {x, y}, Reals]

Out[1]= {{x -> 0.110373, y -> -1.06389}, {x -> 0.111094, y -> -0.531405}, {x -> 0.114153, y -> 1.58123}, {x -> 3.43738, y -> 0.276628}}
```

Quantified system:

```wl
In[2]:= NSolve[Exists[a, a x ^ 2 + Sinh[x ^ 2 + 1]a ^ 2 == 1 && x ^ 2 - a ^ 2 == 1], x, Reals]

Out[2]= {{x -> -1.1603}, {x -> 1.1603}, {x -> -1.06678}, {x -> 1.06678}}
```

---

Systems elementary and bounded in the first variable and polynomial in the other variables:

```wl
In[1]:= NSolve[Sin[x - Cos[x]] y ^ 3 - x == 1 && x ^ 2 + y ^ 2 == 1, {x, y}, Reals]

Out[1]= {{x -> -1., y -> 0}, {x -> -0.838398, y -> -0.545059}, {x -> -0.122235, y -> -0.992501}}
```

Quantified system:

```wl
In[2]:= NSolve[Exists[y, y ^ 3 - Cos[x] y + 2 x ^ 2 Sin[x ^ 2 - 1] == 0 && x ^ 2 + y ^ 2 == 2], x, Reals]

Out[2]= {{x -> -1.07227}, {x -> 1.07227}}
```

---

Systems holomorphic and bounded in the first variable and polynomial in the other variables:

```wl
In[1]:= NSolve[y ^ 3 - BesselJ[2, x + 2] y - y - 3 x == -2 && x ^ 2 ≤ 1 && x y - x ^ 2 + y ^ 2 == 3, {x, y}, Reals]

Out[1]= {{x -> -0.144806, y -> -1.6672}}
```

Quantified system:

```wl
In[2]:= NSolve[Exists[y, y ^ 4 - Gamma[x + 2] y - y - 3 ArcSin[x / 3] == 1 && x ^ 2 + y ^ 3 == 1 && 0 < x < 2], x, Reals]

Out[2]= {{x -> 1.11194}}
```

#### Systems with Mixed Variable Domains (1)

Mixed real and complex variables:

```wl
In[1]:= NSolve[x ^ 2 + y ^ 2 == 1 && x ^ 4 + y ^ 4 == 2 && Element[x, Reals], {x, y}]

Out[1]= {{x -> 1.16877, y -> 0.  - 0.605 I}, {x -> 1.16877, y -> 0.  + 0.605 I}, {x -> -1.16877, y -> 0.  - 0.605 I}, {x -> -1.16877, y -> 0.  + 0.605 I}}
```

#### Geometric Regions (8)

Solve over special regions in 2D:

```wl
In[1]:=
Subscript[ℛ, 1] = Circle[];
Subscript[ℛ, 2] = Line[{{-2, 1}, {1, -2}}];

In[2]:= NSolve[{x, y}∈Subscript[ℛ, 1] && {x, y}∈Subscript[ℛ, 2], {x, y}]

Out[2]= {{x -> -1., y -> 0.}, {x -> 0., y -> -1.}}
```

Plot it:

```wl
In[3]:= Graphics[{{Blue, Subscript[ℛ, 1], Subscript[ℛ, 2]}, {Red, Point[{x, y}] /. %}}]

Out[3]= [image]
```

---

Solve over special regions in 3D:

```wl
In[1]:=
Subscript[ℛ, 1] = Sphere[];
Subscript[ℛ, 2] = InfinitePlane[{{0, 0, 0}, {0, 1, 0}, {1, 0, 1}}];

In[2]:= NSolve[2 x y == z^2 && {x, y, z}∈Subscript[ℛ, 1] && {x, y, z}∈Subscript[ℛ, 2], {x, y, z}, Reals]

Out[2]= {{x -> 0., y -> -1., z -> 0.}, {x -> 0., y -> 1., z -> 0.}, {x -> 0.666667, y -> 0.333333, z -> 0.666667}, {x -> -0.666667, y -> -0.333333, z -> -0.666667}}
```

Plot it:

```wl
In[3]:= Show[{ContourPlot3D[2 x y == z^2, {x, -1.2, 1.2}, {y, -1.2, 1.2}, {z, -1.2, 1.2}, Mesh -> None, ContourStyle -> Opacity[0.5]], Graphics3D[{{Opacity[0.5], Green, Subscript[ℛ, 1]}, {Opacity[0.5], Yellow, Subscript[ℛ, 2]}, {PointSize[Large], Red, Point[{x, y, z} /. %]}}]}]

Out[3]= [image]
```

---

An implicitly defined region:

```wl
In[1]:= ℛ = ImplicitRegion[a + 2 b - 3 c ≥ 1 && a b c == 7, {a, b, c}];

In[2]:= NSolve[y^2 + x z == 1 && x + y == z ^ 2 && {x, y, z}∈ℛ, {x, y, z}, Reals]

Out[2]= {{x -> 3.1915, y -> -2.08675, z -> -1.05107}}
```

---

A parametrically defined region:

```wl
In[1]:= ℛ = ParametricRegion[{s + t, s - t, s t}, {s, t}];

In[2]:= NSolve[x y == z && x + 2 y + 3 z == 1 && {x, y, z}∈ℛ, {x, y, z}, Reals]

Out[2]= {{x -> -0.381966, y -> 1.61803, z -> -0.618034}, {x -> -0.206011, y -> 0.872678, z -> -0.179782}, {x -> -2.61803, y -> -0.618034, z -> 1.61803}, {x -> 0.539345, y -> 0.127322, z -> 0.0686704}}
```

---

Derived regions:

```wl
In[1]:=
Subscript[ℛ, 1] = Disk[{0, 0}, 2];
Subscript[ℛ, 2] = Circle[{1, 1}, 2];
Subscript[ℛ, 3] = RegionIntersection[Subscript[ℛ, 1], Subscript[ℛ, 2]];

In[2]:= NSolve[x^2 == x y + 1 && {x, y}∈Subscript[ℛ, 3], {x, y}, Reals]

Out[2]= {{x -> 0.627801, y -> -0.965062}, {x -> -0.867721, y -> 0.284724}}
```

Plot it:

```wl
In[3]:= Show[{ContourPlot[x^2 == x y + 1, {x, -2, 3}, {y, -2, 3}], Graphics[{{Opacity[0.5], Yellow, Subscript[ℛ, 1]}, {Green, Subscript[ℛ, 2]}, {Red, Point[{x, y} /.  %]}}]}]

Out[3]= [image]
```

---

Regions dependent on parameters:

```wl
In[1]:=
Subscript[ℛ, 1] = Circle[];
Subscript[ℛ, 2] = InfiniteLine[{{-2, 0}, {0, t}}];
Subscript[ℛ, 3] = Circle[{1, 1}, {2t, t}];
Subscript[ℛ, 4] = RegionIntersection[Subscript[ℛ, 1], Subscript[ℛ, 2], Subscript[ℛ, 3]];

In[2]:= NSolve[{x, y}∈Subscript[ℛ, 4], {t, x, y}, Reals]

Out[2]= {{t -> 0.420721, y -> 0.590491, x -> 0.807044}, {t -> 0.991158, y -> 0.59161, x -> -0.806224}}
```

Plot it:

```wl
In[3]:= Graphics[{{Blue, Subscript[ℛ, 1], Subscript[ℛ, 2], Subscript[ℛ, 3]}, {Red, Point[{x, y}]}} /. %]

Out[3]= [image]
```

---

Find values of parameters $a$, $b$, and $r$ for which the circles contain the given points:

```wl
In[1]:=
Subscript[ℛ, 1] = Circle[{a, b}, r];
Subscript[ℛ, 2] = Circle[{a + 1, b}, r];
Subscript[ℛ, 3] = RegionIntersection[Subscript[ℛ, 1], Subscript[ℛ, 2]];

In[2]:= NSolve[({0, 1} | {0, -1})∈Subscript[ℛ, 3], {a, b, r}, Reals]

Out[2]= {{a -> -0.5, b -> 0., r -> 1.11803}}
```

Plot it:

```wl
In[3]:= Show[{Graphics[{{Blue, Subscript[ℛ, 1]}, {Green, Subscript[ℛ, 2]}, {Red, Point[{{0, 1}, {0, -1}}]}} /. %]}]

Out[3]= [image]
```

---

Use $x\in \mathcal{R}$ to specify that $x$ is a vector in $\mathbb{R}^2$ :

```wl
In[1]:= ℛ = RegionIntersection[Circle[], Line[{{-2, -1}, {1, 2}}]];

In[2]:= NSolve[x∈ℛ, x]

Out[2]= {{x -> {-1., 0.}}, {x -> {0., 1.}}}
```

In this case $x$ is a vector in $\mathbb{R}^3$ :

```wl
In[3]:= ℛ = Sphere[];

In[4]:= NSolve[x.{1, 2, 3} == 0 && x.{-3, -2, -1} == 0 && x∈ℛ, x]

Out[4]= {{x -> {-0.408248, 0.816497, -0.408248}}, {x -> {0.408248, -0.816497, 0.408248}}}
```

### Generalizations & Extensions (1)

All variables are solved for:

```wl
In[1]:= NSolve[x ^ 2 + 3x + 1 == 0]

Out[1]= {{x -> -2.61803}, {x -> -0.381966}}
```

Working precision can be given as the last argument:

```wl
In[2]:= NSolve[x ^ 5 - x + 2, x, Reals, 30]

Out[2]= {{x -> -1.26716830454212431725289142798}}
```

### Options (10)

#### MaxRoots (4)

Find $3$ out of $12345$ roots of a polynomial:

```wl
In[1]:= NSolve[x ^ 12345 + x + 1 == 0, x, MaxRoots -> 3]

Out[1]= {{x -> -0.999399}, {x -> -0.999416 - 0.00045507 I}, {x -> -0.999447 - 0.00093351 I}}
```

---

Find $3$ out of $1000000000$ roots of a polynomial system:

```wl
In[1]:= NSolve[x ^ 1000 == y + 1 && y ^ 1000 == z + 1 && z ^ 1000 == x + 1, {x, y, z}, MaxRoots -> 3]

Out[1]= {{x -> -0.994694 - 0.00641785 I, y -> -0.995078 + 0.00083883 I, z -> -0.995209 - 0.00537744 I}, {x -> -0.994941 - 0.0116537 I, y -> -0.995589 - 0.00506129 I, z -> -0.995579 - 0.0113552 I}, {x -> -0.995424 - 0.0175493 I, y -> -0.995925 - 0.0111839 I, z -> -0.995845 - 0.0174628 I}}
```

---

Find $5$ out of infinitely many solutions of a transcendental system:

```wl
In[1]:= NSolve[Sin[x + y] == 2 && Cos[x - y] == 3, {x, y}, MaxRoots -> 5]

Out[1]= {{x -> 0.785398  - 1.53985 I, y -> 0.785398  + 0.222895 I}, {x -> 3.92699  - 1.53985 I, y -> -2.35619 + 0.222895 I}, {x -> 7.06858  - 1.53985 I, y -> -5.49779 + 0.222895 I}, {x -> 10.2102  - 1.53985 I, y -> -8.63938 + 0.222895 I}, {x -> 13.3518  - 1.53985 I, y -> -11.781 + 0.222895 I}}
```

---

With the default ``Automatic`` setting ``NSolve`` may not give all solutions:

```wl
In[1]:= NSolve[Sin[x] == 1 / 2, x]

Out[1]= {{x -> 0.523599}, {x -> 2.61799}, {x -> -3.66519}, {x -> 6.80678}, {x -> -5.75959}, {x -> 8.90118}, {x -> -9.94838}, {x -> 13.09}, {x -> -12.0428}, {x -> 15.1844}, {x -> -16.2316}, {x -> 19.3732}, {x -> -18.326}, {x -> 21.4675}, {x -> -22.5147}, {x -> 25.6563}}
```

With ``MaxRoots -> Infinity``,  ``NSolve`` attempts to find all solutions:

```wl
In[2]:= NSolve[Sin[x] == 1 / 2, x, MaxRoots -> Infinity]

Out[2]= {{x -> ConditionalExpression[1.*(0.5235987755982989 + 6.283185307179586*C[1]), Element[C[1], Integers]]}, {x -> ConditionalExpression[1.*(2.617993877991494 + 6.283185307179586*C[1]), Element[C[1], Integers]]}}
```

#### Method (4)

Solve a square polynomial system using the automatically chosen method:

```wl
In[1]:= NSolve[x ^ 2 + 2y ^ 2 == 3 && x ^ 3 - 4x y == 5, {x, y}]

Out[1]= {{x -> -0.369282 - 3.28661 I, y -> -2.62416 + 0.231252 I}, {x -> -0.369282 + 3.28661 I, y -> -2.62416 - 0.231252 I}, {x -> 1.73161, y -> 0.0277421}, {x -> -0.996522 - 0.571718 I, y -> 1.11028  - 0.256569 I}, {x -> -0.996522 + 0.571718 I, y -> 1.11028  + 0.256569 I}, {x -> 1., y -> -1.}}
```

Use the ``"EndomorphismMatrix"`` method:

```wl
In[2]:= NSolve[x ^ 2 + 2y ^ 2 == 3 && x ^ 3 - 4x y == 5, {x, y}, Method -> "EndomorphismMatrix"]

Out[2]= {{x -> -0.369282 - 3.28661 I, y -> -2.62416 + 0.231252 I}, {x -> -0.369282 + 3.28661 I, y -> -2.62416 - 0.231252 I}, {x -> 1.73161, y -> 0.0277421}, {x -> -0.996522 - 0.571718 I, y -> 1.11028  - 0.256569 I}, {x -> -0.996522 + 0.571718 I, y -> 1.11028  + 0.256569 I}, {x -> 1., y -> -1.}}
```

Use the ``"Homotopy"`` method:

```wl
In[3]:= NSolve[x ^ 2 + 2y ^ 2 == 3 && x ^ 3 - 4x y == 5, {x, y}, Method -> "Homotopy"]

Out[3]= {{x -> -0.369282 + 3.28661 I, y -> -2.62416 - 0.231252 I}, {x -> -0.369282 - 3.28661 I, y -> -2.62416 + 0.231252 I}, {x -> -0.996522 - 0.571718 I, y -> 1.11028  - 0.256569 I}, {x -> -0.996522 + 0.571718 I, y -> 1.11028  + 0.256569 I}, {x -> 1.73161, y -> 0.0277421}, {x -> 1., y -> -1.}}
```

Use the ``"Monodromy"`` method:

```wl
In[4]:= NSolve[x ^ 2 + 2y ^ 2 == 3 && x ^ 3 - 4x y == 5, {x, y}, Method -> "Monodromy"]

Out[4]= {{x -> 1.73161, y -> 0.0277421}, {x -> -0.996522 + 0.571718 I, y -> 1.11028  + 0.256569 I}, {x -> -0.996522 - 0.571718 I, y -> 1.11028  - 0.256569 I}, {x -> 1., y -> -1.}, {x -> -0.369282 + 3.28661 I, y -> -2.62416 - 0.231252 I}, {x -> -0.369282 - 3.28661 I, y -> -2.62416 + 0.231252 I}}
```

Use the ``"Symbolic"`` method:

```wl
In[5]:= NSolve[x ^ 2 + 2y ^ 2 == 3 && x ^ 3 - 4x y == 5, {x, y}, Method -> "Symbolic"]

Out[5]= {{x -> 1., y -> -1.}, {x -> 1.73161, y -> 0.0277421}, {x -> -0.996522 - 0.571718 I, y -> 1.11028  - 0.256569 I}, {x -> -0.996522 + 0.571718 I, y -> 1.11028  + 0.256569 I}, {x -> -0.369282 - 3.28661 I, y -> -2.62416 + 0.231252 I}, {x -> -0.369282 + 3.28661 I, y -> -2.62416 - 0.231252 I}}
```

---

This system has $40$ roots, which is strictly less than the bound of $64$ provided by the Bernstein-Khovanskii-Kushnirenko theorem:

```wl
In[1]:=
syst = t1^2 + t2^2 + t3^2 - 12t1 - 68 == 0 && t4^2 + t5^2 + t6^2 - 12t5 - 68 == 0 && t7^2 + t8^2 + t9^2 - 24 t8 - 12t9 + 100 == 0 && t1 t4 + t2 t5 + t3 t6 - 6 t1 - 6t5 - 52 == 0 && t1 t7 + t2 t8 + t3 t9 - 6 t1 - 12t8 - 6t9 + 64 == 0 && t4 t7 + t5 t8 + t6 t9 - 6t5 - 12t8 - 6t9 + 32 == 0 && 2t2 + 2t3 - t4 - t5 - 2 t6 - t7 - t9 + 18 == 0 && t1 + t2 + 2t3 + 2t4 + 2t6 - 2t7 + t8 - t9 - 38 == 0 && t1 + t3 - 2t4 + t5 - t6 + 2t7 - 2t8 + 8 == 0;
vars = {t1, t2, t3, t4, t5, t6, t7, t8, t9};
```

The ``"Homotopy"`` method, used by default, returns multiple copies of some of the roots:

```wl
In[2]:= (sols = NSolve[syst, vars])//Length//AbsoluteTiming

Out[2]= {4.67431, 64}
```

Remove the multiple copies:

```wl
In[3]:= Union[sols, SameTest -> (Norm[(vars /. #1) - (vars /. #2)] < 10 ^ -6&)]//Length

Out[3]= 40
```

The ``"Monodromy"`` method runs faster here and does not produce multiple copies of roots:

```wl
In[4]:= NSolve[syst, vars, Method -> "Monodromy"]//Length//AbsoluteTiming

Out[4]= {2.64056, 40}
```

---

The ``"Monodromy"`` method returns finitely many solutions of transcendental systems:

```wl
In[1]:= NSolve[Sin[x + y] + Cos[x - y] == 1 && Sin[x - y] + Cos[x + y] == 2, {x, y}, Method -> "Monodromy"]

Out[1]= {{x -> 0.785398  - 0.481212 I, y -> -0.321751}, {x -> 3.92699  - 0.481212 I, y -> -3.46334}, {x -> 7.06858  - 0.481212 I, y -> -6.60494}, {x -> 10.2102  - 0.481212 I, y -> -9.74653}, {x -> 13.3518  - 0.481212 I, y -> -12.8881}, {x -> 16.4934  - 0.4 ... 1212 I, y -> -31.7377}, {x -> 35.3429  - 0.481212 I, y -> -34.8793}, {x -> 38.4845  - 0.481212 I, y -> -38.0209}, {x -> 41.6261  - 0.481212 I, y -> -41.1625}, {x -> 44.7677  - 0.481212 I, y -> -44.304}, {x -> 47.9093  - 0.481212 I, y -> -47.4456}}
```

Use the ``"Symbolic"`` method to obtain all solutions:

```wl
In[2]:= NSolve[Sin[x + y] + Cos[x - y] == 1 && Sin[x - y] + Cos[x + y] == 2, {x, y}, Method -> "Symbolic"]

Out[2]=
{{x -> ConditionalExpression[1.*((0.7853981633974482 + 0.4812118250596033*I) + 6.283185307179586*C[1]), 
 Element[C[1], Integers]], y -> ConditionalExpression[-1.*(0.3217505543966422 + 6.283185307179586*C[2]), Element[C[2], Integers]]}, {x -> Condi ... ntegers]]}, {x -> ConditionalExpression[1.*((-2.356194490192345 - 0.4812118250596033*I) + 6.283185307179586*C[1]), 
 Element[C[1], Integers]], y -> ConditionalExpression[-1.*(-2.819842099193151 + 6.283185307179586*C[2]), Element[C[2], Integers]]}}
```

---

The ``Method`` option may also be used to locally set system options from the ``"NSolveOptions"`` group:

```wl
In[1]:= "NSolveOptions" /. SystemOptions[]

Out[1]= {"ComplexEquationMethod" -> Automatic, "EndomorphismMatrixMaxVolume" -> 4096, "HomotopyMaxVolume" -> 131072, "MonomialOrder" -> Automatic, "ReorderVariables" -> True, "SelectCriterion" -> (True&), "Tolerance" -> 0, "UseSlicingHyperplanes" -> True}
```

By default ``NSolve`` introduces slicing hyperplanes for underdetermined complex systems:

```wl
In[2]:= NSolve[x ^ 2 + y ^ 2 == 1, {x, y}]
```

NSolve::infsolns: Infinite solution set has dimension at least 1. Returning intersection of solutions with -((92291 x)/87992)-(121001 y)/175984 == 1.

```wl
Out[2]= {{x -> -0.997714, y -> 0.0675708}, {x -> -0.335987, y -> -0.941867}}
```

With ``Method -> {"UseSlicingHyperplanes" -> False}``, ``NSolve`` gives parametric solutions:

```wl
In[3]:= NSolve[x ^ 2 + y ^ 2 == 1, {x, y}, Method -> {"UseSlicingHyperplanes" -> False}]
```

Solve::svars: Equations may not give solutions for all "solve" variables.

```wl
Out[3]= {{y -> -1. Sqrt[1.  - 1. x^2]}, {y -> Sqrt[1.  - 1. x^2]}}
```

#### VerifySolutions (1)

``NSolve`` verifies solutions obtained using non-equivalent transformations:

```wl
In[1]:=
funs = {Sqrt[x + Sqrt[x]] - 2, y ^ 9 - y - 2 x ^ (1 / 7) - 3};
eqns = And@@Thread[funs == 0];
sol1 = NSolve[eqns, {x, y}];
```

With ``VerifySolutions -> False``, ``NSolve`` does not verify the solutions:

```wl
In[2]:= sol2 = NSolve[eqns, {x, y}, VerifySolutions -> False];
```

Some of the solutions returned with ``VerifySolutions -> False`` are not correct:

```wl
In[3]:= Length /@ {sol1, sol2}

Out[3]= {9, 18}
```

This uses a fast numeric test in an attempt to select correct solutions:

```wl
In[4]:= sol3 = Select[sol2, Chop[funs /. #, 10 ^ -8] == {0, 0}&];
```

In this case the simple numeric verification gives the correct solution set:

```wl
In[5]:= sol3 === sol1

Out[5]= True
```

#### WorkingPrecision (1)

By default, ``NSolve`` finds solutions of exact equations using machine-precision computations:

```wl
In[1]:= NSolve[x ^ 5 + 2 x + 7 == 0, x]

Out[1]= {{x -> -1.33998}, {x -> -0.56494 - 1.33743 I}, {x -> -0.56494 + 1.33743 I}, {x -> 1.23493  - 0.976346 I}, {x -> 1.23493  + 0.976346 I}}
```

This computes the solutions using 50-digit precision:

```wl
In[2]:= NSolve[x ^ 5 + 2 x + 7 == 0, x, WorkingPrecision -> 50]

Out[2]= {{x -> -1.3399779064938687966799794227184232949540394596906}, {x -> -0.5649399330245252713179193369528252142484312969600 - 1.3374320953062895583554990256351607089307603547142 I}, {x -> -0.5649399330245252713179193369528252142484312969600 + 1.337432 ... 07603547142 I}, {x -> 1.2349288862714596696579090483120368617254510268053 - 0.9763463870286490530429921626559008731741658185695 I}, {x -> 1.2349288862714596696579090483120368617254510268053 + 0.9763463870286490530429921626559008731741658185695 I}}
```

### Applications (17)

#### Geometry (11)

Find intersection points of a circle and a parabola:

```wl
In[1]:= pts = NSolve[x ^ 2 + y ^ 2 == 1 && y - 2x ^ 2 + 3 / 2 == 0, {x, y}]

Out[1]= {{x -> -0.587785, y -> -0.809017}, {x -> 0.951057, y -> 0.309017}, {x -> 0.587785, y -> -0.809017}, {x -> -0.951057, y -> 0.309017}}

In[2]:= Show[{ContourPlot[{x ^ 2 + y ^ 2 == 1, y - 2x ^ 2 + 3 / 2 == 0}, {x, -1.5, 1.5}, {y, -1.5, 1.5}], Graphics[{Red, PointSize[Medium], Point[{x, y} /. pts]}]}]

Out[2]= [image]
```

---

Find the intersection of ``InfiniteLine[{0, 0}, {1, 1}]`` and ``InfiniteLine[{{0, 1}, {1, 0}}]``:

```wl
In[1]:=
line1 = InfiniteLine[{0, 0}, {1, 1}];
line2 = InfiniteLine[{{0, 1}, {1, 0}}];

In[2]:= sol = NSolve[{x, y}∈line1∧{x, y}∈line2, {x, y}]

Out[2]= {{x -> 0.5, y -> 0.5}}
```

Plot it:

```wl
In[3]:= Graphics[{{Lighter[Blue, 0.5], line1, line2}, {Red, Point[{x, y} /. sol]}}, Axes -> True, ImageSize -> Small]

Out[3]= [image]
```

---

Find the intersections of ``InfiniteLine[{0, 0}, {1, 1}]`` and ``Circle[{0, 0}, 1]``:

```wl
In[1]:=
line = InfiniteLine[{0, 0}, {1, 1}];
circle = Circle[{0, 0}, 1];

In[2]:= sol = NSolve[{x, y}∈line∧{x, y}∈circle, {x, y}]

Out[2]= {{x -> -0.707107, y -> -0.707107}, {x -> 0.707107, y -> 0.707107}}
```

Plot it:

```wl
In[3]:= Graphics[{{Lighter[Blue, 0.5], line, circle}, {Red, Point[{x, y} /. sol]}}, ImageSize -> Small]

Out[3]= [image]
```

---

Find all pairwise intersections between five random lines:

```wl
In[1]:= lines = InfiniteLine /@ RandomReal[1, {5, 2, 2}];
```

Use ``BooleanCountingFunction`` to express that exactly two conditions are true:

```wl
In[2]:= sol = NSolve[{x, y}∈BooleanRegion[BooleanCountingFunction[{2}, 5], lines], {x, y}]

Out[2]= {{x -> 0.117046, y -> 0.63864}, {x -> 0.972, y -> -0.547227}, {x -> 0.431255, y -> 0.202815}, {x -> 0.579968, y -> -0.00345836}, {x -> 0.792116, y -> 1.01111}, {x -> 0.696951, y -> 0.958601}, {x -> -1.55429, y -> -0.283513}, {x -> 0.773155, y -> 1.17537}, {x -> 0.904318, y -> 0.0391024}, {x -> 0.348041, y -> -0.0338916}}
```

Plot it:

```wl
In[3]:= Graphics[{{Lighter[Blue, 0.5], lines}, {Red, PointSize[Medium], Point[{x, y} /. sol]}}]

Out[3]= [image]
```

---

Find the pairwise intersections of the circles ``Circle[{1 / 3 Cos[k 2π / 5], 1 / 3 Sin[k 2π / 5]}]`` for ``k = 0, …, 4``:

```wl
In[1]:= circles = Table[Circle[{1 / 3 Cos[k 2π / 5], 1 / 3 Sin[k 2π / 5]}], {k, 0, 4}];

In[2]:= sol = NSolve[{x, y}∈BooleanRegion[BooleanCountingFunction[{2}, 5], circles], {x, y}]

Out[2]= {{x -> 0.324908, y -> 0.999965}, {x -> -0.261247, y -> -0.804036}, {x -> 0.324908, y -> -0.999965}, {x -> -0.261247, y -> 0.804036}, {x -> 1.01151, y -> 0.734902}, {x -> -0.575167, y -> -0.417883}, {x -> 1.01151, y -> -0.734902}, {x -> -0.575167, y ...  {x -> -0.850621, y -> -0.618012}, {x -> 0.683954, y -> 0.496922}, {x -> -0.850621, y -> 0.618012}, {x -> 0.683954, y -> -0.496922}, {x -> -0.386361, y -> -1.1891}, {x -> 0.219694, y -> 0.67615}, {x -> 1.05142, y -> 0.}, {x -> -0.845414, y -> 0.}}
```

Plot it:

```wl
In[3]:= Graphics[{{Lighter[Blue, 0.5], circles}, {Red, PointSize[Medium], Point[{x, y} /. sol]}}]

Out[3]= [image]
```

---

Find the intersection of ``InfiniteLine[{{-1, 1, 1}, {1, 1, 1}}]`` and ``InfinitePlane[{{2, 0, 0}, {0, 2, 0}, {0, 0, 2}}]``:

```wl
In[1]:=
line = InfiniteLine[{{-1, 1, 1}, {1, 1, 1}}];
plane = InfinitePlane[{{2, 0, 0}, {0, 2, 0}, {0, 0, 2}}];

In[2]:= sol = NSolve[{{x, y, z}∈line, {x, y, z}∈plane}, {x, y, z}]

Out[2]= {{x -> 0., y -> 1., z -> 1.}}
```

Plot it:

```wl
In[3]:= Graphics3D[{{Opacity[0.5], line, plane}, {Red, PointSize[Large], Point[{x, y, z} /. sol]}}, Axes -> True, PlotRange -> {{-2, 2}, {-2, 2}, {-2, 2}}]

Out[3]= [image]
```

---

Find the intersections of ``InfiniteLine[{{-1, 1, 1}, {1, 1, 1}}]`` and ``Sphere[{0, 0, 0}, 3]``:

```wl
In[1]:=
line = InfiniteLine[{{-1, 1, 1}, {1, 1, 1}}];
sphere = Sphere[{0, 0, 0}, 3];

In[2]:= sol = NSolve[{{x, y, z}∈line, {x, y, z}∈sphere}, {x, y, z}]

Out[2]= {{y -> 1., z -> 1., x -> -2.64575}, {y -> 1., z -> 1., x -> 2.64575}}
```

Plot it:

```wl
In[3]:= Graphics3D[{{Opacity[0.5], line, sphere}, {Red, PointSize[Large], Point[{x, y, z} /. sol]}}, PlotRangePadding -> 0.5]

Out[3]= [image]
```

---

Find the intersections of ``InfiniteLine[{{-1, 1 / 3, 1 / 2}, {1, 1 / 3, 1 / 2}}]`` and the boundary of ``Tetrahedron[{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}}]`` :

```wl
In[1]:=
line = InfiniteLine[{{-1, 1 / 3, 1 / 2}, {1, 1 / 3, 1 / 2}}];
tet = RegionBoundary@Tetrahedron[{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}}];

In[2]:= sol = NSolve[{x, y, z}∈RegionIntersection[line, tet], {x, y, z}]

Out[2]= {{x -> 0., y -> 0.333333, z -> 0.5}, {x -> 0.166667, y -> 0.333333, z -> 0.5}}
```

Plot it:

```wl
In[3]:= Graphics3D[{{Opacity[0.5], line, Tetrahedron[{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}}]}, {Red, PointSize[Medium], Point[{x, y, z} /. sol]}}, PlotRangePadding -> 0.2]

Out[3]= [image]
```

---

Find the intersection for three random planes:

```wl
In[1]:= planes = InfinitePlane /@ RandomReal[1, {3, 3, 3}];

In[2]:= sol = NSolve[{x, y, z}∈RegionIntersection@@planes, {x, y, z}]

Out[2]= {{x -> 0.323791, y -> 0.415129, z -> 0.359286}}
```

Plot it:

```wl
In[3]:= Graphics3D[{{Opacity[0.5], planes}, {Red, PointSize[Medium], Point[{x, y, z} /. sol]}}, PlotRangePadding -> 0.1]

Out[3]= [image]
```

---

Find the intersections of the spheres ``Sphere[{1 / 3 Cos[k 2π / 3], 1 / 3 Sin[k 2π / 3], 0}]`` for ``k = 0, 1, 2``:

```wl
In[1]:= spheres = Table[Sphere[{1 / 3 Cos[k 2π / 3], 1 / 3 Sin[k 2π / 3], 0}], {k, 0, 2}];

In[2]:= sol = NSolve[{x, y, z}∈RegionIntersection@@spheres, {x, y, z}]

Out[2]= {{x -> 0., y -> 0., z -> -0.942809}, {x -> 0., y -> 0., z -> 0.942809}}
```

Plot it:

```wl
In[3]:= Graphics3D[{{Opacity[0.5], spheres}, {Red, PointSize[Large], Point[{x, y, z} /. sol]}}]

Out[3]= [image]
```

---

Find all the intersections of exactly three planes among 10 random planes:

```wl
In[1]:= planes = InfinitePlane /@ RandomReal[{-1, 1}, {10, 3, 3}];
```

Use ``BooleanCountingFunction`` to find the condition of exactly three things being true:

```wl
In[2]:= sol = NSolve[{x, y, z}∈BooleanRegion[BooleanCountingFunction[{3}, 10], planes], {x, y, z}];//Quiet
```

Plot it:

```wl
In[3]:= Graphics3D[{{Opacity[0.3], planes}, {Red, PointSize[Medium], Point[{x, y, z} /. sol]}}, PlotRange -> {{-1, 1}, {-1, 1}, {-1, 1}}]

Out[3]= [image]
```

#### Chemistry (1)

A polynomial system for the equilibria of a certain chemical reaction network:

```wl
In[1]:=
reactionpolys = {50 + Subscript[x, 1] - Subscript[x, 4] - (4 Subscript[x, 2] Subscript[x, 4]/125) - (Subscript[x, 2] Subscript[x, 5]/50) - (99 Subscript[x, 6]/100) + Subscript[x, 7], -(9/200) Subscript[x, 3] Subscript[x, 5] + 15 (50 - Subscript[x, 4] - Subscript[x, 6]) + Subscript[x, 8], -(4/125) Subscript[x, 2] Subscript[x, 4] - (1/50) Subscript[x, 4] (350 - Subscript[x, 2] - Subscript[x, 3] + Subscript[x, 4] + Subscript[x, 5]) + 16 (50 - Subscript[x, 4] - Subscript[x, 6]) + (101 Subscript[x, 6]/100), Subscript[x, 1] - (Subscript[x, 2] Subscript[x, 5]/50) - (9 Subscript[x, 3] Subscript[x, 5]/200) - (11 Subscript[x, 5] (350 - Subscript[x, 2] - Subscript[x, 3] + Subscript[x, 4] + Subscript[x, 5])/10000) + Subscript[x, 7] + (43/500) (100 - Subscript[x, 1] - Subscript[x, 5] - Subscript[x, 7] - Subscript[x, 8]) + Subscript[x, 8], (1/50) Subscript[x, 4] (350 - Subscript[x, 2] - Subscript[x, 3] + Subscript[x, 4] + Subscript[x, 5]) - (101 Subscript[x, 6]/100), (9 Subscript[x, 3] Subscript[x, 5]/200) - (273 Subscript[x, 8]/250), (Subscript[x, 2] Subscript[x, 5]/100) - Subscript[x, 7] + (23 Subscript[x, 8]/250), -(3 Subscript[x, 1]/2) + (Subscript[x, 2] Subscript[x, 5]/100)};
vars = Variables[reactionpolys];
```

Since the variables represent chemical species quantities, we are interested in real-valued solutions with all components nonnegative::

```wl
In[2]:=
nonnegSolutions[polys_, vars_, meth_ : Automatic] := Module[
	{solns, realsolns}, 
	solns = vars /. NSolve[polys, vars, Method -> meth];
	realsolns = Select[solns, FreeQ[#, Complex]&];
	Select[realsolns, Apply[And, Map[# >= 0&, #]]&]
	]
```

Find the solutions:

```wl
In[3]:= nonnegsolns = nonnegSolutions[reactionpolys, vars]

Out[3]= {{0.256221, 6.97675, 367.57, 36.6772, 5.50874, 12.811, 8.06095, 83.4416}, {0.256221, 6.97675, 367.57, 36.6772, 5.50874, 12.811, 8.06095, 83.4416}, {0.701281, 14.6721, 234.974, 14.5102, 7.16952, 35.064, 7.43877, 69.4223}, {0.862856, 9.49621, 37.1013, 6.72938, 13.6295, 43.1428, 3.21139, 20.8381}}
```

The apparent multiplicity is an artifact of the ``Automatic`` method, which tends to be fast but can sometimes overstate multiplicity:

```wl
In[4]:= nonnegSolnsE = nonnegSolutions[reactionpolys, vars, "EndomorphismMatrix"]

Out[4]= {{0.256221, 6.97675, 367.57, 36.6772, 5.50874, 12.811, 8.06095, 83.4416}, {0.701281, 14.6721, 234.974, 14.5102, 7.16952, 35.064, 7.43877, 69.4223}, {0.862856, 9.49621, 37.1013, 6.72938, 13.6295, 43.1428, 3.21139, 20.8381}}
```

#### Mechanics (3)

Direct kinematics of a [Gough-Stewart](https://link.springer.com/article/10.1007/BF02142677) parallel 6-degree of freedom platform:

```wl
In[1]:=
eqns = {t1^2 + t2^2 + t3^2 - 12t1 - 68, t4^2 + t5^2 + t6^2 - 12t5 - 68, t7^2 + t8^2 + t9^2 - 24 t8 - 12t9 + 100, t1 t4 + t2 t5 + t3 t6 - 6 t1 - 6t5 - 52, t1 t7 + t2 t8 + t3 t9 - 6 t1 - 12t8 - 6t9 + 64, t4 t7 + t5 t8 + t6 t9 - 6t5 - 12t8 - 6t9 + 32, 2t2 + 2t3 - t4 - t5 - 2 t6 - t7 - t9 + 18, t1 + t2 + 2t3 + 2t4 + 2t6 - 2t7 + t8 - t9 - 38, t1 + t3 - 2t4 + t5 - t6 + 2t7 - 2t8 + 8};
vars = {t1, t2, t3, t4, t5, t6, t7, t8, t9};
Length[solns = NSolve[eqns, vars]]

Out[1]= 64
```

This solution set claims multiple solutions; remove the multiple copies:

```wl
In[2]:= Union[solns, SameTest -> (Norm[(vars /. #1) - (vars /. #2)] < 10 ^ -6&)]//Length

Out[2]= 40
```

A different method does not produce multiple copies of solutions:

```wl
In[3]:= Length[NSolve[eqns, vars, Method -> "Monodromy"]]

Out[3]= 40
```

---

Set up an overdetermined system of six equations in four variables that arises from a camera pose estimation procedure:

```wl
In[1]:=
coords = {{1, 2, 1.49071, 4}, {1, 3, .400000, 8}, {1, 4, .894427, 4}, {2, 3, 1.49071, 4}, {2, 4, .666667, 8}, {3, 4, .894427, 4}};
vars = Array[x, 4];
polys = MapThread[x[#1] ^ 2 + x[#2] ^ 2 - #3 * x[#1] * x[#2] - #4&, Transpose[coords]]

Out[1]= {-4 + x[1]^2 - 1.49071 x[1] x[2] + x[2]^2, -8 + x[1]^2 - 0.4 x[1] x[3] + x[3]^2, -4 + x[1]^2 - 0.894427 x[1] x[4] + x[4]^2, -4 + x[2]^2 - 1.49071 x[2] x[3] + x[3]^2, -8 + x[2]^2 - 0.666667 x[2] x[4] + x[4]^2, -4 + x[3]^2 - 0.894427 x[3] x[4] + x[4]^2}
```

Use the first four polynomials so the subsystem will be exactly determined:

```wl
In[2]:= realsols = NSolve[polys[[1 ;; 4]], vars, Reals]

Out[2]= {{x[1] -> 2.22508, x[2] -> 2.99995, x[3] -> 2.24697, x[4] -> 0.797065}, {x[1] -> 2.22508, x[2] -> 2.99995, x[3] -> 2.24697, x[4] -> 1.19311}, {x[1] -> -2.22508, x[2] -> -2.99995, x[3] -> -2.24697, x[4] -> -1.19311}, {x[1] -> -2.22508, x[2] -> -2.99995, x[3] -> -2.24697, x[4] -> -0.797065}}
```

For each solution the first four residuals from plugging in a solution are small whereas the last two are non-negligible:

```wl
In[3]:= residuals = polys /. realsols

Out[3]= {{-8.881784197001252`*^-16, 0., -1.1102230246251565`*^-16, -2.6645352591003757`*^-15, 0.0409086, 0.082303}, {-8.881784197001252`*^-16, 0., 0., -2.6645352591003757`*^-15, 0.0370292, 0.0745474}, {1.509903313490213`*^-14, 3.375077994860476`*^-14, -2.220446049250313`*^-16, 1.3322676295501878`*^-14, 0.0370292, 0.0745474}, {1.509903313490213`*^-14, 3.375077994860476`*^-14, -1.1102230246251565`*^-16, 1.3322676295501878`*^-14, 0.0409086, 0.082303}}
```

Now polish each solution by using it as a starting point for minimizing the sum of squares of residuals:

```wl
In[4]:= newsols = Map[FindMinimum[polys.polys, Transpose[{vars, (vars /. #)}]]&, realsols]

Out[4]= {{2.099282803988261`*^-10, {x[1] -> 2.23607, x[2] -> 3., x[3] -> 2.23607, x[4] -> 0.997723}}, {2.0995801785780716`*^-10, {x[1] -> 2.23607, x[2] -> 3., x[3] -> 2.23607, x[4] -> 1.00228}}, {2.0995801785780716`*^-10, {x[1] -> -2.23607, x[2] -> -3., x[3] -> -2.23607, x[4] -> -1.00228}}, {2.099282803988261`*^-10, {x[1] -> -2.23607, x[2] -> -3., x[3] -> -2.23607, x[4] -> -0.997723}}}
```

---

A system of equations for static equilibria of a weight suspended by two massless cables in a plane:

```wl
In[1]:=
polys = {-1 + (3 ct1/4) + (7 ct2/5) - (9 ct3/10), (1/8) + (3 st1/4) + (7 st2/5) - (9 st3/10), (3 ct1/4) + (3 ct2/5) + (st2/5) - x, -(ct2/5) + (3 st1/4) + (3 st2/5) - y, ct1 f1 + ct3 f3, -1 + f1 st1 + f3 st3, ct1 t1 - x, st1 t1 - y0, 1 + ct3 t3 - x, -(1/8) + st3 t3 - y0, -1 + ct1^2 + st1^2, -1 + ct2^2 + st2^2, -1 + ct3^2 + st3^2};
vars = Variables[polys];
Length[solns = NSolve[polys == 0, vars]]

Out[1]= 20
```

Each real-valued solution corresponds to a distinct equilibrium position, and there are six such:

```wl
In[2]:= realsols = Union[Cases[vars /. solns, {_Real..}], SameTest -> (Norm[#1 - #2] <= 10 ^ -9&)]

Out[2]= {{-0.292814, 0.438719, -0.672671, -0.78231, 0.34054, -0.956169, 0.898624, 0.739941, -0.762755, 1.15458, 0.223346, -0.265696, 0.729323}, {-0.207901, 0.999985, 0.27117, 0.582715, 0.446756, 0.97815, 0.00547559, 0.962531, -2.14121, -2.04609, 0.44516, 0 ... 0671832, -0.0884429, 0.940221, -0.699929, 0.927081, 0.997741, 1.32452, -0.80389, 0.945992, -0.0436704, -0.927074}, {0.92654, 0.47451, 0.399132, 0.399256, -0.926827, 0.376195, -0.88025, -0.916893, 0.86727, -0.492165, 0.803561, -0.340906, 0.326263}}
```

#### Economics (1)

A reduced 8-dimensional system arising in [economics](http://homepages.math.uic.edu/~jan/Demo/redeco8.html); we use a non-default method to get better accuracy:

```wl
In[1]:=
eqns = {x1 + x1 * x2 + x2 * x3 + x3 * x4 + x4 * x5 + x5 * x6 + x6 * x7 - 1 * u8, 
x2 + x1 * x3 + x2 * x4 + x3 * x5 + x4 * x6 + x5 * x7 - 2 * u8, 
x3 + x1 * x4 + x2 * x5 + x3 * x6 + x4 * x7 - 3 * u8, 
x4 + x1 * x5 + x2 * x6 + x3 * x7 - 4 * u8, 
x5 + x1 * x6 + x2 * x7 - 5 * u8, 
x6 + x1 * x7 - 6 * u8, 
x7 - 7 * u8, 
x1 + x2 + x3 + x4 + x5 + x6 + x7 + 1};
vars = {x1, x2, x3, x4, x5, x6, x7, u8};
Length[solns = NSolve[eqns, vars, Method -> "Monodromy"]]

Out[1]= 64
```

Find the real-valued solutions:

```wl
In[2]:= Cases[vars /. solns, {_Real..}]

Out[2]= {{0.251874, 1.09122, -1.11424, -0.637152, 0.291145, -0.332878, -0.549967, -0.0785668}, {-0.742246, 0.602075, 0.736635, 0.0699789, -0.555383, -0.683628, -0.427431, -0.0610616}, {-0.347516, 1.59956, -0.714195, 1.3221, 0.767849, -1.98228, -1.64551, -0 ... 57, -0.142857, -0.142857, -0.142857, -0.142857, -0.142857, -0.142857, -0.0204082}, {1.20466, -0.466632, -0.803457, 0.434026, -0.972072, 0.21119, -0.607714, -0.0868163}, {1.59939, 1.29935, -0.16372, -1.7234, -1.40859, 1.73653, -2.33956, -0.334223}}
```

#### Difference Equations (1)

A nonlinear system of polynomial difference equations:

```wl
In[1]:= des = {a[n + 1] == b[n] ^ 2 * a[n] - 3 * c[n] - 1, b[n + 1] == a[n] * c[n] ^ 2 - 2 * b[n - 1] + 1, c[n + 1] == a[n - 1] - b[n - 2]};
```

``RSolve`` cannot find an analytic form for the solution:

```wl
In[2]:= RSolve[des, {a, b, c}, n]

Out[2]= RSolve[{a[1 + n] == -1 + a[n] b[n]^2 - 3 c[n], b[1 + n] == 1 - 2 b[-1 + n] + a[n] c[n]^2, c[1 + n] == a[-1 + n] - b[-2 + n]}, {a, b, c}, n]
```

Set up a polynomial system to find the asymptotic values:

```wl
In[3]:=
rep = {a[_] :> a, b[_] :> b, c[_] :> c};
asymp = des /. rep

Out[3]= {a == -1 + a b^2 - 3 c, b == 1 - 2 b + a c^2, c == a - b}
```

Solve it and give asymptotic possible real asymptotic values (they depend on initial conditions):

```wl
In[4]:=
desolns = NSolve[asymp, {a, b, c}];
Select[desolns, MatchQ[{a, b, c} /. #, {_Real..}]&]

Out[4]= {{a -> -2.82743, b -> -1.45134, c -> -1.37608}, {a -> 2.79341, b -> 1.61856, c -> 1.17485}, {a -> 0., b -> 0.333333, c -> -0.333333}}
```

### Properties & Relations (8)

Solutions approximately satisfy the equations:

```wl
In[1]:=
polys = {x ^ 2 + y ^ 2 - 1, 2x + 3y - 4};
NSolve[Thread[polys == 0], {x, y}]

Out[1]= {{x -> 0.615385  - 0.399704 I, y -> 0.923077  + 0.266469 I}, {x -> 0.615385  + 0.399704 I, y -> 0.923077  - 0.266469 I}}
```

Solutions are given as replacement rules and can be directly used for substitution:

```wl
In[2]:= polys /. %

Out[2]= {{6.661338147750939`*^-16 + 4.996003610813204`*^-16 I, 0.  + 0. I}, {6.661338147750939`*^-16 - 4.996003610813204`*^-16 I, 0.  + 0. I}}
```

---

``NSolve`` uses ``{}`` to represent the empty or no solution:

```wl
In[1]:= NSolve[x == 1 && x == 2, x]

Out[1]= {}
```

``NSolve`` uses ``{{}}`` to represent the universal solution or that all points satisfy the equations:

```wl
In[2]:= NSolve[x == x, x]

Out[2]= {{}}
```

---

For univariate polynomial equations, ``NSolve`` repeats solutions according to their multiplicity:

```wl
In[1]:= NSolve[(x - 1) ^ 2(x - 2) ^ 3 == 0, x]

Out[1]= {{x -> 1.}, {x -> 1.}, {x -> 2.}, {x -> 2.}, {x -> 2.}}
```

---

Find solutions over specified domains:

```wl
In[1]:= NSolve[(x ^ 4 - 1)(x ^ 4 - 4) == 0, x]

Out[1]= {{x -> -1.41421}, {x -> -1.}, {x -> 0.  - 1. I}, {x -> 0.  + 1. I}, {x -> 0.  - 1.41421 I}, {x -> 0.  + 1.41421 I}, {x -> 1.}, {x -> 1.41421}}

In[2]:= NSolve[(x ^ 4 - 1)(x ^ 4 - 4) == 0, x, Reals]

Out[2]= {{x -> -1.41421}, {x -> -1.}, {x -> 1.}, {x -> 1.41421}}
```

---

``NSolve`` represents solutions in terms of replacement rules:

```wl
In[1]:= NSolve[{x ^ 2 + y ^ 2 == 1, x ^ 3 - y ^ 3 == 2}, {x, y}]

Out[1]= {{x -> -1.09791 - 0.839887 I, y -> 1.09791  - 0.839887 I}, {x -> -1.09791 + 0.839887 I, y -> 1.09791  + 0.839887 I}, {x -> 1.22333  + 0.0729987 I, y -> 0.125423  - 0.712005 I}, {x -> 1.22333  - 0.0729987 I, y -> 0.125423  + 0.712005 I}, {x -> -0.125423 - 0.712005 I, y -> -1.22333 + 0.0729987 I}, {x -> -0.125423 + 0.712005 I, y -> -1.22333 - 0.0729987 I}}
```

``NSolveValues`` gives values of the solutions:

```wl
In[2]:= NSolveValues[{x ^ 2 + y ^ 2 == 1, x ^ 3 - y ^ 3 == 2}, {x, y}]

Out[2]= {{-1.09791 - 0.839887 I, 1.09791  - 0.839887 I}, {-1.09791 + 0.839887 I, 1.09791  + 0.839887 I}, {1.22333  + 0.0729987 I, 0.125423  - 0.712005 I}, {1.22333  - 0.0729987 I, 0.125423  + 0.712005 I}, {-0.125423 - 0.712005 I, -1.22333 + 0.0729987 I}, {-0.125423 + 0.712005 I, -1.22333 - 0.0729987 I}}
```

---

``NSolve`` is a global equation solver:

```wl
In[1]:= NSolve[{x ^ 2 + y ^ 3 == 1, x ^ 4 + y ^ 4 == 2}, {x, y}]

Out[1]= {{x -> 0.428653  - 1.42567 I, y -> -0.552329 - 1.34942 I}, {x -> 0.428653  + 1.42567 I, y -> -0.552329 + 1.34942 I}, {x -> -1.15363, y -> -0.691637}, {x -> 1.20097  - 0.0500217 I, y -> 0.324147  - 0.698088 I}, {x -> 1.20097  + 0.0500217 I, y -> 0.3 ... -> 0.324147  + 0.698088 I}, {x -> 0.  - 0.71621 I, y -> 1.148}, {x -> 0.  + 0.71621 I, y -> 1.148}, {x -> -0.428653 - 1.42567 I, y -> -0.552329 + 1.34942 I}, {x -> -0.428653 + 1.42567 I, y -> -0.552329 - 1.34942 I}, {x -> 1.15363, y -> -0.691637}}
```

``FindRoot`` is a local equation solver:

```wl
In[2]:= FindRoot[{x ^ 2 + y ^ 3 == 1, x ^ 4 + y ^ 4 == 2}, {{x, 1}, {y, -1}}]

Out[2]= {x -> 1.15363, y -> -0.691637}
```

---

``NSolve`` gives approximate results:

```wl
In[1]:= NSolve[{x ^ 2 + y ^ 2 == 1, x + y ^ 2 == 2}, {x, y}]

Out[1]= {{x -> 0.5  - 0.866025 I, y -> 1.27123  + 0.340625 I}, {x -> 0.5  + 0.866025 I, y -> 1.27123  - 0.340625 I}, {x -> 0.5  - 0.866025 I, y -> -1.27123 - 0.340625 I}, {x -> 0.5  + 0.866025 I, y -> -1.27123 + 0.340625 I}}
```

Use ``Solve`` to get exact solutions:

```wl
In[2]:= Solve[{x ^ 2 + y ^ 2 == 1, x + y ^ 2 == 2}, {x, y}]

Out[2]= {{x -> (1/2) + (I Sqrt[3]/2), y -> -Sqrt[(3/2) - (I Sqrt[3]/2)]}, {x -> (1/2) + (I Sqrt[3]/2), y -> Sqrt[(3/2) - (I Sqrt[3]/2)]}, {x -> (1/2) - (I Sqrt[3]/2), y -> -Sqrt[(3/2) + (I Sqrt[3]/2)]}, {x -> (1/2) - (I Sqrt[3]/2), y -> Sqrt[(3/2) + (I Sqrt[3]/2)]}}
```

Use ``FindInstance`` to get exact solution instances:

```wl
In[3]:= FindInstance[{x ^ 2 + y ^ 2 == 1, x + y ^ 2 == 2}, {x, y}]

Out[3]= {{x -> (1/2) (1 - I Sqrt[3]), y -> -Sqrt[2 + (1/2) (-1 + I Sqrt[3])]}}
```

---

Use ``NDSolve`` to solve differential equations numerically:

```wl
In[1]:= NDSolve[{y''[x] == -y[x], y[0] == 0, y'[0] == 1}, y[x], {x, 0, 7}]

Out[1]=
{{y[x] -> InterpolatingFunction[{{0., 7.}}, {5, 7, 2, {81}, {4}, 0, 0, 0, 0, Automatic, {}, {}, False}, 
 CompressedData["«965»"], 
 {Developer`PackedArrayForm, {0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 
   54, 57, 60, 63 ... 29, 132, 135, 138, 141, 144, 147, 150, 153, 156, 159, 162, 165, 168, 171, 174, 
   177, 180, 183, 186, 189, 192, 195, 198, 201, 204, 207, 210, 213, 216, 219, 222, 225, 228, 231, 
   234, 237, 240, 243}, CompressedData["«2392»"]}, {Automatic}][x]}}

In[2]:= Plot[y[x] /. %[[1]], {x, 0, 7}]

Out[2]= [image]
```

### Possible Issues (7)

Solutions obtained with machine-precision numeric computations may not be accurate:

```wl
In[1]:= poly = Expand[Product[x - i, {i, 30}]];

In[2]:= NSolve[poly == 0, x]

Out[2]= {{x -> 1.}, {x -> 2.}, {x -> 3.}, {x -> 4.}, {x -> 5.00001}, {x -> 5.99978}, {x -> 6.99303}, {x -> 8.1408}, {x -> 8.38502}, {x -> 9.12944}, {x -> 9.49271}, {x -> 10.6029}, {x -> 11.1054}, {x -> 12.1081}, {x -> 12.6104}, {x -> 14.3923}, {x -> 14.8177}, {x -> 16.8117}, {x -> 17.3941}, {x -> 19.7918}, {x -> 20.4594}, {x -> 23.1855}, {x -> 23.6605}, {x -> 26.5303}, {x -> 27.0209}, {x -> 28.9705}, {x -> 29.572}, {x -> 31.3375}, {x -> 31.7922}, {x -> 31.9712}}
```

With higher ``WorkingPrecision`` more accurate results are produced:

```wl
In[3]:= NSolve[poly == 0, x, WorkingPrecision -> 20]

Out[3]= {{x -> 1.0000000000000000000}, {x -> 2.0000000000000000000}, {x -> 3.0000000000000000000}, {x -> 4.0000000000000000000}, {x -> 5.0000000000000000000}, {x -> 6.0000000000000000000}, {x -> 7.0000000000000000000}, {x -> 8.0000000000000000000}, {x -> 9 ... 00000}, {x -> 23.000000000000000000}, {x -> 24.000000000000000000}, {x -> 25.000000000000000000}, {x -> 26.000000000000000000}, {x -> 27.000000000000000000}, {x -> 28.000000000000000000}, {x -> 29.000000000000000000}, {x -> 30.000000000000000000}}
```

---

Approximate solutions may not satisfy the equations due to numeric errors:

```wl
In[1]:=
eqns = {x ^ 2 + y ^ 2 == 1, x ^ 3 - 2x y == 2};
sols = NSolve[eqns, {x, y}]

Out[1]= {{x -> -0.316434 - 2.2779 I, y -> -2.48453 + 0.290118 I}, {x -> -0.316434 + 2.2779 I, y -> -2.48453 - 0.290118 I}, {x -> -0.67102 - 0.538425 I, y -> 0.986759  - 0.366142 I}, {x -> -0.67102 + 0.538425 I, y -> 0.986759  + 0.366142 I}, {x -> 0.987454  - 0.216136 I, y -> -0.50223 - 0.424954 I}, {x -> 0.987454  + 0.216136 I, y -> -0.50223 + 0.424954 I}}

In[2]:= eqns /. sols

Out[2]= {{False, False}, {False, False}, {False, False}, {False, False}, {False, False}, {False, False}}
```

The equations are satisfied up to a certain tolerance:

```wl
In[3]:= Norm /@ ({x ^ 2 + y ^ 2 - 1, x ^ 3 - 2x y - 2} /. sols)

Out[3]= {4.7152989951491104`*^-14, 4.7152989951491104`*^-14, 7.058434425944929`*^-15, 7.058434425944929`*^-15, 8.510286760425343`*^-15, 8.510286760425343`*^-15}
```

Using higher ``WorkingPrecision`` will give solutions with smaller tolerance:

```wl
In[4]:= sols = NSolve[eqns, {x, y}, WorkingPrecision -> 25]

Out[4]= {{x -> -0.316434365364369192813382 - 2.277904066211679373994553 I, y -> -2.484529090574296372146744 + 0.290118208028707343426932 I}, {x -> -0.316434365364369192813382 + 2.277904066211679373994553 I, y -> -2.484529090574296372146744 - 0.290118208028 ... 959002903195647583 - 0.216136251621252362317446 I, y -> -0.502230233578098316272820 - 0.424953702661281802067596 I}, {x -> 0.987453959002903195647583 + 0.216136251621252362317446 I, y -> -0.502230233578098316272820 + 0.424953702661281802067596 I}}

In[5]:= ({x ^ 2 + y ^ 2 - 1, x ^ 3 - 2x y - 2} /. sols)

Out[5]= {{0``22.904167768443667 + 0``23.343621616848647 I, 0``22.847044420855944 + 0``22.548605822325907 I}, {0``22.904167768443667 + 0``23.343621616848647 I, 0``22.847044420855944 + 0``22.548605822325907 I}, {0``23.744789304571793 + 0``23.90705320924002 I ...  0``23.600388723879263 + 0``23.61259251009149 I}, {0``23.81666188816252 + 0``24.053116272779445 I, 0``23.574493065434837 + 0``23.684625825246975 I}, {0``23.81666188816252 + 0``24.053116272779445 I, 0``23.574493065434837 + 0``23.684625825246975 I}}
```

---

If the solutions set of a polynomial system is infinite, ``NSolve`` gives its intersection with random hyperplanes:

```wl
In[1]:= NSolve[x ^ 2 + y ^ 2 == 1, {x, y}]
```

NSolve::infsolns: Infinite solution set has dimension at least 1. Returning intersection of solutions with -((92291 x)/87992)-(121001 y)/175984 == 1.

```wl
Out[1]= {{x -> -0.997714, y -> 0.0675708}, {x -> -0.335987, y -> -0.941867}}

In[2]:= NSolve[x ^ 2 + y ^ 2 + z ^ 2 == 1, {x, y, z}]
```

NSolve::infsolns: Infinite solution set has dimension at least 1. Returning intersection of solutions with -((69046 x)/57903)-(142003 y)/115806+(40299 z)/38602 == 1.

NSolve::infsolns: Infinite solution set has dimension at least 2. Returning intersection of solutions with (27178 x)/45687+(20993 y)/30458-(19857 z)/30458 == 1.

```wl
Out[2]= {{x -> -11.2304 + 6.3174 I, y -> 0.75537  - 12.3674 I, z -> -10.9825 - 7.31059 I}, {x -> -11.2304 - 6.3174 I, y -> 0.75537  + 12.3674 I, z -> -10.9825 + 7.31059 I}}
```

Use ``ContourPlot`` and ``ContourPlot3D`` to view the real part of solutions:

```wl
In[3]:= ContourPlot[x ^ 2 + y ^ 2 == 1, {x, -1, 1}, {y, -1, 1}]

Out[3]= [image]

In[4]:= ContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2 == 1, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[4]= [image]
```

---

``NSolve`` by default can claim multiple solutions when the actual count should be smaller:

```wl
In[1]:=
polys = {9 * y2 ^ 2 - 5.656854249492381 * y2 + z2, x3 ^ 2 + y3 ^ 2 + z3 ^ 2 - 1, x4 ^ 2 + y4 ^ 2 + z4 ^ 2 - 1, y5 ^ 2 + z5 ^ 2 - 0.888888888888889, x3 - 2.828427124746190 * y2 * x3 + y2 * y3 + z2 * z3 - 1 / 3, x3 * x4 + y3 * y4 + z3 * z4 - 1 / 3, 1 / 3 * x4 + y4 * y5 + z4 * z5 - 1 / 3, 8 / 3 - 2.828427124746190 * y2 + x3 + x4, y2 + y3 + y4 + y5 + 0.8888888888888889, z2 + z3 + z4 + z5};
vars = {x3, x4, y2, y3, y4, y5, z2, z3, z4, z5};
Length[solns = NSolve[polys, vars]]

Out[1]= 122

In[2]:= Length[Union[vars /. solns, SameTest -> (Norm[#1 - #2] < 10 ^ -9&)]]

Out[2]= 40
```

Compare to a nondefault method:

```wl
In[3]:= Length[NSolve[polys, vars, Method -> "Monodromy"]]

Out[3]= 40
```

Validate against another nondefault method:

```wl
In[4]:= Length[NSolve[polys, vars, Method -> "EndomorphismMatrix"]]

Out[4]= 40
```

---

Use a particular method to solve a polynomial system with large coefficients:

```wl
In[1]:=
polys = {-1 + a + b + c + d, -2772 a^2 - 4620 a b - 1980 b^2 - 3960 a c - 3465 b c - 1540 c^2 - 3465 a d - 3080 b d - 2772 c d - 1260 d^2 + 13860 r, 926640 a^3 + 2432430 a^2 b + 2116400 a b^2 + 617760 b^3 + 2230800 a^2 c + 3848130 a b c + 1684800 b^2 c + 1731600 a c^2 + 1526525 b c^2 + 462000 c^3 + 2108106 a^2 d + 3603600 a b d + 1573000 b^2 d + 3211065 a c d + 2836680 b c d + 1287000 c^2 d + 1474200 a d^2 + 1310400 b d^2 + 1192464 c d^2 + 368550 d^3 + 16216200 a r + 14414400 b r + 13513500 c r + 12972960 d r, 213840 a^2 + 374220 a b + 162800 b^2 + 343200 a c + 296010 b c + 133200 c^2 + 324324 a d + 277200 b d + 247005 c d + 113400 d^2 + 332640 a lambda + 277200 b lambda + 237600 c lambda + 207900 d lambda + 831600 mu + 1247400 r, 486486 a^2 + 846560 a b + 370656 b^2 + 769626 a c + 673920 b c + 305305 c^2 + 720720 a d + 629200 b d + 567336 c d + 262080 d^2 + 720720 a lambda + 617760 b lambda + 540540 c lambda + 480480 d lambda + 2162160 mu + 2882880 r, 2230800 a^2 + 3848130 a b + 1684800 b^2 + 3463200 a c + 3053050 b c + 1386000 c^2 + 3211065 a d + 2836680 b d + 2574000 c d + 1192464 d^2 + 3088800 a lambda + 2702700 b lambda + 2402400 c lambda + 2162160 d lambda + 10810800 mu + 13513500 r, 2108106 a^2 + 3603600 a b + 1573000 b^2 + 3211065 a c + 2836680 b c + 1287000 c^2 + 2948400 a d + 2620800 b d + 2384928 c d + 1105650 d^2 + 2702700 a lambda + 2402400 b lambda + 2162160 c lambda + 1965600 d lambda + 10810800 mu + 12972960 r};
vars = {r, a, b, c, d, lambda, mu};
Length[solmach = NSolve[polys, {r, a, b, c, d, lambda, mu}, Method -> "EndomorphismMatrix"]]

Out[1]= 21
```

Use the same method but with higher precision than default:

```wl
In[2]:= Length[solbig = NSolve[polys, {r, a, b, c, d, lambda, mu}, Method -> "EndomorphismMatrix", WorkingPrecision -> 100]]

Out[2]= 21
```

At machine precision some residuals are not so small:

```wl
In[3]:= Map[Max, Abs[polys /. solmach[[1 ;; 4]]]]

Out[3]= {0.189483, 0.189483, 0.0312843, 0.0312843}
```

The solution using higher precision, not surprisingly, gives smaller residuals:

```wl
In[4]:= Map[Max, Abs[polys /. solbig[[1 ;; 4]]]]

Out[4]= {0``73.97122773936566, 0``73.97122773936566, 0``74.36587395368046, 0``74.36587395368046}
```

Despite the disparities in residuals, the two solutions agree to all digits of ``MachinePrecision`` :

```wl
In[5]:= (vars /. solmach[[1 ;; 4]]) - (vars /. solbig[[1 ;; 4]])

Out[5]= {{0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I}, {0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I}, {0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I}, {0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I, 0.  + 0. I}}
```

---

With domain ``Reals`` specified, ``NSolve`` may not find solutions for which the function is not real-valued in any neighbourhood of the solution:

```wl
In[1]:= f = (x ^ 2 - 7 x + 11) ^ (x ^ 2 - 13 x + 42) - 1;

In[2]:= NSolve[f == 0, x, Reals]

Out[2]= {{x -> 2.}, {x -> 5.}, {x -> 6.}, {x -> 7.}}

In[3]:= Plot[{Abs[f], Im[f]}, {x, 1.5, 7.5}, PlotLegends -> "Expressions"]

Out[3]= [image]
```

This gives all real solutions:

```wl
In[4]:= NSolve[f == 0 && Element[x, Reals], x]

Out[4]= {{x -> 2.}, {x -> 3.}, {x -> 4.}, {x -> 5.}, {x -> 6.}, {x -> 7.}}
```

---

``NSolve`` may not give all solutions:

```wl
In[1]:= NSolve[Cos[x] == x, x]

Out[1]= {{x -> 0.739085}, {x -> -2.48689 + 1.80936 I}, {x -> -9.10999 + 2.95017 I}, {x -> -15.488 + 3.45661 I}, {x -> -21.819 + 3.79031 I}, {x -> -28.1316 + 4.03995 I}, {x -> -34.435 + 4.23954 I}, {x -> -40.7329 + 4.40585 I}, {x -> -47.0274 + 4.54842 I}, {x -> -53.3196 + 4.67319 I}, {x -> -59.6102 + 4.78411 I}, {x -> -65.8995 + 4.88396 I}, {x -> -72.1878 + 4.97474 I}, {x -> -78.4754 + 5.05797 I}, {x -> -84.7625 + 5.1348 I}, {x -> -91.0491 + 5.20615 I}}
```

Get $100$ solutions:

```wl
In[2]:= NSolve[Cos[x] == x, x, MaxRoots -> 100]//Length

Out[2]= 100
```

### Neat Examples (1)

Solve the equation $\sin (z+\sin (z+\sin (z)))=\cos (z+\cos (z+\cos (z)))$:

```wl
In[1]:= roots = NSolve[Sin[z + Sin[z + Sin[z]]] == Cos[z + Cos[z + Cos[z]]] && -3 < Re[z] < 3 && -3 < Im[z] < 3, z, MaxRoots -> Infinity];

In[2]:= ListPlot[{Re[z], Im[z]} /. roots, PlotLabel -> TraditionalForm[Sin[z + Sin[z + Sin[z]]] == Cos[z + Cos[z + Cos[z]]]]]

Out[2]= [image]
```

## See Also

* [`Solve`](https://reference.wolfram.com/language/ref/Solve.en.md)
* [`FindRoot`](https://reference.wolfram.com/language/ref/FindRoot.en.md)
* [`NSolveValues`](https://reference.wolfram.com/language/ref/NSolveValues.en.md)
* [`MaxRoots`](https://reference.wolfram.com/language/ref/MaxRoots.en.md)
* [`NDSolve`](https://reference.wolfram.com/language/ref/NDSolve.en.md)
* [`NMinimize`](https://reference.wolfram.com/language/ref/NMinimize.en.md)
* [`InterpolatingFunction`](https://reference.wolfram.com/language/ref/InterpolatingFunction.en.md)
* [`AsymptoticSolve`](https://reference.wolfram.com/language/ref/AsymptoticSolve.en.md)

## Tech Notes

* [Numerical Mathematics: Basic Operations](https://reference.wolfram.com/language/tutorial/NumericalCalculations.en.md)
* [Numerical Equation Solving](https://reference.wolfram.com/language/tutorial/NumericalOperationsOnFunctions.en.md#1863)
* [Equations in One Variable](https://reference.wolfram.com/language/tutorial/ManipulatingEquationsAndInequalities.en.md#16840)
* [Numerical Mathematics](https://reference.wolfram.com/language/tutorial/NumericalOperationsOnFunctions.en.md#20411)
* [Numerical Solution of Polynomial Equations](https://reference.wolfram.com/language/tutorial/NumericalOperationsOnFunctions.en.md#20638)
* [Implementation Notes: Numerical and Related Functions](https://reference.wolfram.com/language/tutorial/SomeNotesOnInternalImplementation.en.md#25940)

## Related Guides

* [Equation Solving](https://reference.wolfram.com/language/guide/EquationSolving.en.md)
* [Polynomial Systems](https://reference.wolfram.com/language/guide/PolynomialSystems.en.md)
* [Numerical Evaluation & Precision](https://reference.wolfram.com/language/guide/NumericalEvaluationAndPrecision.en.md)
* [Polynomial Equations](https://reference.wolfram.com/language/guide/PolynomialEquations.en.md)
* [Solvers over Regions](https://reference.wolfram.com/language/guide/GeometricSolvers.en.md)
* [Solid Geometry](https://reference.wolfram.com/language/guide/SolidGeometry.en.md)
* [Plane Geometry](https://reference.wolfram.com/language/guide/PlaneGeometry.en.md)
* [`Polygons`](https://reference.wolfram.com/language/guide/Polygons.en.md)
* [Geometric Computation](https://reference.wolfram.com/language/guide/GeometricComputation.en.md)
* [Symbolic Vectors, Matrices and Arrays](https://reference.wolfram.com/language/guide/SymbolicArrays.en.md)
* [`Polyhedra`](https://reference.wolfram.com/language/guide/Polyhedra.en.md)

## Related Links

* [NKS\|Online](http://www.wolframscience.com/nks/search/?q=NSolve)
* [A New Kind of Science](http://www.wolframscience.com/nks/)

## History

* Introduced in 1991 (2.0) \| [Updated in 2014 (10.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn100.en.md) ▪ [2024 (14.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn140.en.md)