Column 1
Column 2
Column 1
Column 2
` tags and adding blank lines:
```md
# Heading 1
# Heading 2
Heading 1 Heading 2 Heading 1 Heading 2
```
Apply Lock and Hide properties of a cell group to keep the banner visible but uneditable.
This is column 1
This is column 2
This is column 3
` tags are substituted as a sequence of arguments to `Columns` function, that iterates over them and forms a wrapper HTML structure. Then the result is substituted into the bottom `div col` structure. Here is another way to build lists from raw data: ``` .wlx With[{ TableList = Table[ With[{SomeField = item["Field"]},
`
or
`
```
More examples [#more-examples]
Embed Figures into a Custom Layout [#embed-figures-into-a-custom-layout]
Plot a function and assign it to a symbol:
```
Figure = Plot[Sinc[5x], {x, -5, 5}]
```
Then, in a new cell, type:
```
.wlx
```
Now your plot will shake infinitely 😉
Creating Components [#creating-components]
Let's define a hybrid WL function:
```
Heading[Text_, OptionPattern[]] := With[{color = OptionValue["Color"]},
;
]
Options[Heading] = {"Color" -> "black"};
```
You can now use it in your layout:
```
.wlx
]
```
# Wolfram Language
An input cell is a multi-tool. By default, it assumes Wolfram Language as input if no other patterns are found in the first line:
```
1+1
```
```
2
```
Read our fast-track introduction on Wolfram Language at [that page](./../Wolfram-Language)
If an output is too large, it may be truncated or converted into a temporary symbol to reduce editor load. This can be adjusted in the editor's settings.
Morph Output Cell into Input [#morph-output-cell-into-input]
If you modify a Wolfram Language **output cell**, it will automatically be converted into a new **input cell**.
Auto-upload Files [#auto-upload-files]
Drag and drop files into the editor or paste media from the clipboard
Syntax Highlighting & Symbol Tracking [#syntax-highlighting--symbol-tracking]
Wolfram Language autocomplete and highlighting can be extended using external packages.
Once a symbol is defined in the \`Global\`\` context of a Wolfram Kernel session, it appears in the autocomplete window and is shared across open notebooks.
At startup, the Wolfram Kernel loads all imported packages, reads `::usage` directives for defined symbols.
Autocomplete for loaded packages [#autocomplete-for-loaded-packages]
You can enable periodic checking in the editor's settings for newly loaded packages (not user-defined symbols) information upon `Get` or `Needs` commands.
Access to Documentation [#access-to-documentation]
Click the 🔎 icon in the autocomplete window to open the documentation for a symbol in a new tab.
Opening documentation for another symbol will not create an extra window, but it will refresh the existing one. Therefore you can safely arrange the windows
**in a fixed layout**
# Beep
```wolfram
Beep[]
```
make a sound notification. It does not require any context or window object.
```wolfram
Beep["Your Message"]
```
make a sound notification and pops up a message dialog window with your message.
*Only for desktop application*
To make system beep sound use
```wolfram
Beep["System"]
```
Example [#example]
Click on this button to make sound
```wolfram
EventHandler[InputButton[], Beep]
```
# CellPrint
```wolfram
CellPrint[expr_] _RemoteCellObj
```
```wolfram
CellPrint[cellExpr_] _RemoteCellObj
```
Inserts a new cell directly below the currently evaluated one. The expression `expr` is automatically converted to a [StandardForm](../Formatting/StandardForm) output cell.
Alternatively, `cellExpr` can be any of the following cell types:
* `Cell[expr_String, "Input"]`
* `Cell[expr_String, "Output"]`
* `Cell[expr_String, "Input"]`
* `Cell[expr_String, "Output", subtype_String]`
* `TextCell[expr_String]`
* `TextCell[expr_String, "Title"]`
* `TextCell[expr_String, "Section"]`
* `TextCell[expr_String, "Subsection"]`
* `ExpressionCell[expr_, "Input"]`
* `ExpressionCell[expr_, "Output"]`
where the `subtype` property can be any view component from the available cell types:
* `"WLX"` or `"wlx"`
* `"HTML"` or `"html"`
* `"JS"` or `"js"` or `"javascript"`
* `"MERMAID"` or `"mermaid"`
* ...
`CellPrint` returns the created [RemoteCellObj](./RemoteCellObj), which can be further manipulated.
See also the more comprehensive functions [NotebookWrite](./NotebookWrite) and [CreateWindow](./CreateWindow) for generating cells.
Examples [#examples]
Basic usage [#basic-usage]
Print a cell after the current one, displaying the current date:
```wolfram
cell = CellPrint[Now];
```
Then remove it:
```wolfram
NotebookDelete[cell];
```
Using different renderers [#using-different-renderers]
You can use [WLX](frontend/Cell-types/WLX) view components as well. First, create a template in a separate cell:
```jsx
.wlx
wlTest[P_] :=
```
Then wrap it in the corresponding cell representation:
```wolfram
CellPrint[Cell[wlTest[Plot[x, {x,0,1}]], "Output", "wlx"]];
```
# Cells
```wolfram
Cells[]
Cells[notebook]
```
return all cells in the `notebook` or evaluation notebook.
To read all cells of the notebook **fast** use:
```wolfram
NotebookRead[Cells[]]
```
# CreateDocument
```wolfram
CreateDocument[{cell1, cell2, ...}, opts___] _RemoteNotebook
```
creates a notebook in memory and populates it with cells, where `celli` can be:
* `_` any expressions (automatically converted to the input cell)
* `_String` expression (automatically converted to text cells aka markdown)
* `ExpressionCell[expr_, "Input"]`
* `ExpressionCell[expr_, "Output"]`
* `TextCell[expr_]`
* `TextCell[expr_, "Title"]`
* `TextCell[expr_, "Section"]`
* `TextCell[expr_, "Subsection"]`
* `CellGroup[{cells...}]` a group of cells (it will be flattened and it is kept only for compatibility with Mathematica)
The expression returns [RemoteNotebook](../Cells-and-Notebook/RemoteNotebook)
For example:
```wolfram
CreateDocument[{"Here is a plot example", Plot[x, {x,0,1}]}, Visible->False] // NotebookOpen
```
Specify the cells style:
```wolfram
CreateDocument[{TextCell["S1", "Section"], ExpressionCell[x^2, "Input"]}];
```
Use `Defer`
```wolfram
CreateDocument[Defer[1 + 1]];
```
Options [#options]
Visible [#visible]
By the default is `True`, that opens a notebook automatically after using provided `"Window"`
"Window" [#window]
For the case if `Visible->True` it will use [CurrentWindow](../Frontend-IO/CurrentWindow) by the default to pop up a new window
# CreateWindow
```wolfram
CreateWindow[notebook_RemoteNotebook]
```
opens a notebook in a new window
```wolfram
CreateWindow[expr, opts]
```
creates a new window with `expr` shown in `StandardForm`. `CreateWindow` returns [RemoteCellObj](./RemoteCellObj).
```wolfram
CreateWindow[cellExpr, opts]
```
creates a new window with `cellExpr` rendered:
* `Cell[expr_String, "Input"]`
* `Cell[expr_String, "Output"]`
* `Cell[expr_String, "Input"]`
* `Cell[expr_String, "Output", subtype_String]`
* `TextCell[expr_String]`
* `TextCell[expr_String, "Title"]`
* `TextCell[expr_String, "Section"]`
* `TextCell[expr_String, "Subsection"]`
* `ExpressionCell[expr_, "Input"]`
* `ExpressionCell[expr_, "Output"]`
`subtype` property can be any view-component provided by known cell types:
* `"WLX"` or `"wlx"`
* `"HTML"` or `"html"`
* `"JS"` or `"js"` or `"javascript"`
* `"MERMAID"` or `"mermaid"`
* ...
here `CreateWindow` also returns [RemoteCellObj](./RemoteCellObj).
Options [#options]
WindowSize [#windowsize]
Sets size `{w,h}` of the created window in pixels.
WindowTitle [#windowtitle]
Sets the name of created window.
"Notebook" [#notebook]
Specify the notebook (optional) associated with a created window.
Examples [#examples]
Basic examples [#basic-examples]
Print graphics to a new window:
```wolfram
win = CreateWindow[Graphics3D[Cuboid[]]];
```
then close it:
```wolfram
NotebookClose[win];
```
Print HTML content to a new window:
```wolfram
CreateWindow[Cell["Hello World
", "Output", "HTML"]];
```
A window that opens another window [#a-window-that-opens-another-window]
This is possible if you provide the notebook in [Options](#Options); otherwise, the system does not know where to open it:
```wolfram
man := ManipulatePlot[Sin[x w], {x,-1,1}, {w,1,5}];
open[n_] := CreateWindow[man];
CreateWindow[EventHandler[InputButton[], Function[Null, open[n]]]]
```
This will continue to work even if you close the original notebook.
Tracking created window [#tracking-created-window]
You can assign handlers to events from the window:
```wolfram
state = "";
TextView[state // Offload, "Label"->"State"]
win = CreateWindow[ExpressionCell[Plot[x,{x,0,1}], "Output"]];
EventHandler[win, {
"Mounted" -> Function[Null, state = "Mounted"],
"Closed" -> Function[Null, state = "Closed"]
}];
```
The `Mounted` event provides `WindowObj`, which can be used together with `FrontSubmit` and `FrontFetch` to trigger actions in the created window.
# CurrentNotebookImage
Generates a raster image of the current notebook
```wolfram
CurrentNotebookImage[]
```
This is a blocking function. Avoid using it with buttons or async events
This feature requires running WLJS Notebook as desktop app
# EvaluateCell
```wolfram
EvaluateCell[cell_RemoteCellObj, opts___]
```
evaluates interactively a cell in current notebook given by [RemoteCellObj](../Cells-and-Notebook/RemoteCellObj)
This only tells a UI to evaluate a given cell interactively if a user would click to evaluate
Options [#options]
"Target" [#target]
Specifies where to output the result. Default is `"Notebook"`, possible values
* `"Notebook"` or `Null`
* `"Window"` or `_` makes the output to be projected to a new window
# EvaluationCell
returns a source input-cell as a [RemoteCellObj](../Cells-and-Notebook/RemoteCellObj) from the evaluation context
```wolfram
EvaluationCell[] _RemoteCellObj
```
# EvaluationNotebook
returns a [RemoteNotebook](../Cells-and-Notebook/RemoteNotebook) object of a current notebook from the evaluation context
```wolfram
EvaluationNotebook[] _RemoteNotebook
```
# HapticFeedback
Only for MacOS users and desktop application
```wolfram
HapticFeedback[]
```
produces vibrations on native trackpad or external one. The same function is called on a slider from [InputRange](../GUI/InputRange)
For example:
```wolfram
Module[{balls1, balls2, balls3, ev = CreateUUID[]},
balls1 = balls2 = balls3 = {RandomReal[{-0.5,0.5}, 2]};
balls2 = balls2 + {0.01 RandomReal[{-1,1}, 2]};
EventHandler[ev, Function[Null,
balls3 = balls2;
balls2 = balls1;
balls1 = Map[Function[p,
If[Norm[p] > 1,
HapticFeedback[];
Normalize[p] 0.99
,
p
]
], (2 balls2 - balls3)];
]];
Graphics[{
LightBlue, EventHandler[Disk[], {"click" -> Function[xy,
AppendTo[balls1, xy];
AppendTo[balls2, xy + 0.01 RandomReal[{-1,1}, 2]];
AppendTo[balls3, xy];
]}], Black, PointSize[0.08], Point[balls1 // Offload],
AnimationFrameListener[balls1 // Offload, "Event"->ev]
}, "Controls"->False, TransitionType->None
]
]
```
Each time a ball bounces off the wall, it produces a vibration.
# NotebookClose
```wolfram
NotebookClose[_RemoteNotebook]
NotebookClose[_RemoteCellObj]
```
closes (if opened) a notebook represented by [RemoteNotebook](../Cells-and-Notebook/RemoteNotebook) or removes cell
# NotebookDelete
Deletes the content from notebook
Syntax [#syntax]
**Delete cell or projected cell:**
```wolfram
NotebookDelete[cell_RemoteCellObj]
```
**Delete multiple items:**
```wolfram
NotebookDelete[{item1, item2, ...}]
```
# NotebookDirectory
```wolfram
NotebookDirectory[] _String
```
returns a file path to the current notebook.
Use it in a multiuser environment, where you cannot rely on `Directory[]`
Blocking function. Avoid using it in timers like `SetTimeout`, external event handlers such as `InputButton` or `Button`, or within `AsyncFunction`.
# NotebookEvaluate
```wolfram
NotebookEvaluate[_RemoteNotebook, opts___]
NotebookEvaluate[path_String | File[path_String], opts___]
```
evaluates all content of provided [RemoteNotebook](../Cells-and-Notebook/RemoteNotebook) or by file path following the rules:
* all initialization cells are evaluated once for this notebook object
* the rest of the remianing cells are evaluated for every call
Options [#options]
"ContextIsolation" [#contextisolation]
By the default is `False`, i.e. all notebook content is placed to `Global` and will be available globally on Kernel. Set to `True` to isolate notebook in generated context.
"EvaluationContext" [#evaluationcontext]
Allows to manually provide evaluation context, i.e. `System`\$EvaluationContext\`.
Blocking function. Avoid using it in timers like `SetTimeout`, external event handlers such as `InputButton` or `Button`, or within `AsyncFunction`. Use [NotebookEvaluateAsync](./NotebookEvaluateAsync) instead.
Use [NotebookEvaluateAsModule](./NotebookEvaluateAsModule) if you need to get the output from the evaluated notebook
# NotebookEvaluateAsModule
```wolfram
NotebookEvaluateAsModule[path_String | f_File]
NotebookEvaluateAsModule[notebook_RemoteNotebook]
```
imports WLJS notebook as an isolated module/library:
```wolfram
{exports} = NotebookEvaluateAsModule["mySecondNotebook.wln"];
```
This breaks the evaluation order. The caller cell will be evaluated last in the queue. Consider using the
**safer**
async version
[NotebookEvaluateAsModuleAsync](./NotebookEvaluateAsModuleAsync)
instead.
The following rules apply:
* Initialization cells **are evaluated once** for a given notebook object
* The last **Wolfram input cell** is evaluated on every call and its result is exported
* All other cells are ignored
This allows you to create reusable components using plain notebooks. For example:
*Notebook-1.wln*
```jsx title="Initialization cell"
.wlx
BigHeader[Text_String] :=
;
```
```wolfram title="Last cell"
{BigHeader}
```
Then in the host notebook we can import the result of the previous notebook as a component:
*Notebook-2.wln*
```wolfram title="Cell 1"
{HeaderComponent} = NotebookEvaluateAsModule["Notebook-1.wln"];
```
```markdown title="Cell 2"
.slide
Hello World
", "Output", "HTML"]]
```
# ParentCell
fetches [RemoteCellObj](../Cells-and-Notebook/RemoteCellObj) for a parent input cell of a given cell
```wolfram
ParentCell[cell_RemoteCellObj] _CellObj
```
Blocking function. Avoid using it in timers like `SetTimeout`, external event handlers such as `InputButton` or `Button`, or within `AsyncFunction`.
# RemoteCellObj
a remote representation of a notebook cell for evaluation Kernel
```wolfram
RemoteCellObj[uid_String] _RemoteCellObj
```
Methods [#methods]
NotebookDelete [#notebookdelete]
NotebookWrite [#notebookwrite]
NotebookRead [#notebookread]
NotebookReadAsync [#notebookreadasync]
EventHandler [#eventhandler]
You can listen a cell's events from the evaluation Kernel
```wolfram
With[{cell = EvaluationCell[]},
EventHandler[cell, {any_ :> (Print[any, ": ", #]&)}];
]
```
*listen all events from the input cell*
Possible events [#possible-events]
Normal cells [#normal-cells]
* `"Destroy"` when a cell was removed
Expression Windows [#expression-windows]
* `"Mounted"` fired once cell is mounted and is ready, returns [WindowObj](../Frontend-IO/WindowObj);
`"Mounted"` can be fired multiple times in the case if a window was refreshed (or reconnected)
* `"Closed"` fired when user closes window (or connection breaks), returns [WindowObj](../Frontend-IO/WindowObj)
# RemoteNotebook
represents notebook object for a evaluation Kernel
```wolfram
RemoteNotebook[uid_String] _RemoteNotebook
```
Methods [#methods]
* [NotebookEvaluate](../Cells-and-Notebook/NotebookEvaluate)
* [NotebookEvaluateAsync](../Cells-and-Notebook/NotebookEvaluateAsync)
* [NotebookOpen](../Cells-and-Notebook/NotebookOpen)
* [NotebookClose](../Cells-and-Notebook/NotebookClose)
* [NotebookSave](../Cells-and-Notebook/NotebookSave)
* [NotebookRead](./NotebookRead.mdx)
* [NotebookWrite](./NotebookWrite.mdx)
* [NotebookEvaluateAsModule](./NotebookEvaluateAsModule.mdx)
# ResultCell
returns an future output cell identifier as an [RemoteCellObj](../Cells-and-Notebook/RemoteCellObj) *even if it was not yet created* from the evaluation context
```wolfram
ResultCell[] _RemoteCellObj
```
Works in all output cells
# Speak
```wolfram
Speak[expr_, opts___]
```
speaks a spoken representation of the expression `expr`
For example
```wolfram
Speak[Red]
```
Options [#options]
"Window" [#window]
By the default is [CurrentWindow](../Frontend-IO/CurrentWindow)
Audio object [#audio-object]
To get an audio object (see [Audio](../Sound/Audio))
```wolfram
SpeechSynthesize[SpokenString[Red], GeneratedAssetLocation -> None]
```
# AbelianGroup
`AbelianGroup[{n1, n2, ...}]` represents the direct product of the cyclic groups of degrees n1, n2, ....
Example [#example]
Define an abelian group and get its elements:
```wolfram
g = AbelianGroup[{2, 3}];
GroupElements[g]
(* {{0, 0}, {0, 1}, {0, 2}, {1, 0}, {1, 1}, {1, 2}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AbelianGroup.html) for more details.
# AlgebraicIntegerQ
`AlgebraicIntegerQ[a]` yields `True` if a is an algebraic integer, and yields `False` otherwise.
Examples [#examples]
Test if a number is an algebraic integer:
```wolfram
AlgebraicIntegerQ[Sqrt[2]]
(* True *)
```
Rational numbers that aren't integers are not algebraic integers:
```wolfram
AlgebraicIntegerQ[1/2]
(* False *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AlgebraicIntegerQ.html) for more details.
# AlgebraicNumberDenominator
`AlgebraicNumberDenominator[a]` gives the smallest positive integer n such that n\*a is an algebraic integer.
Examples [#examples]
Find the denominator of an algebraic number:
```wolfram
AlgebraicNumberDenominator[Sqrt[2]/3]
(* 3 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AlgebraicNumberDenominator.html) for more details.
# AlgebraicNumberNorm
`AlgebraicNumberNorm[a]` gives the norm of the algebraic number a.
Examples [#examples]
Find the norm of an algebraic number:
```wolfram
AlgebraicNumberNorm[Sqrt[2]]
(* -2 *)
```
Norm of a complex algebraic number:
```wolfram
AlgebraicNumberNorm[1 + I]
(* 2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AlgebraicNumberNorm.html) for more details.
# AlgebraicNumberPolynomial
`AlgebraicNumberPolynomial[a, x]` gives the polynomial in x corresponding to the `AlgebraicNumber` object a.
Examples [#examples]
Get the minimal polynomial:
```wolfram
AlgebraicNumberPolynomial[AlgebraicNumber[Sqrt[2], {1, 1}], x]
(* 1 + x *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AlgebraicNumberPolynomial.html) for more details.
# AlgebraicNumberTrace
`AlgebraicNumberTrace[a]` gives the trace of the algebraic number a.
Examples [#examples]
Find the trace of an algebraic number:
```wolfram
AlgebraicNumberTrace[Sqrt[2]]
(* 0 *)
```
Trace of a root of unity:
```wolfram
AlgebraicNumberTrace[Root[#^3 - 2 &, 1]]
(* 0 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AlgebraicNumberTrace.html) for more details.
# AlgebraicUnitQ
`AlgebraicUnitQ[a]` yields `True` if a is an algebraic unit, and yields `False` otherwise.
Examples [#examples]
Test if a number is an algebraic unit:
```wolfram
AlgebraicUnitQ[1 + Sqrt[2]]
(* True *)
```
An integer other than ±1 is not an algebraic unit:
```wolfram
AlgebraicUnitQ[2]
(* False *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AlgebraicUnitQ.html) for more details.
# AlternatingGroup
`AlternatingGroup[n]` represents the alternating group of degree n.
Examples [#examples]
```wolfram
AlternatingGroup[4]
(* AlternatingGroup[4] *)
```
```wolfram
GroupOrder[AlternatingGroup[5]]
(* 60 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AlternatingGroup.html) for more details.
# Antihermitian
`Antihermitian[{1, 2}]` represents the symmetry of an antihermitian matrix.
Examples [#examples]
Define a tensor with antihermitian symmetry:
```wolfram
TensorSymmetry[{{0, I}, {-I, 0}}]
(* Antihermitian[{1, 2}] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Antihermitian.html) for more details.
# Antisymmetric
`Antisymmetric[{s1, ..., sn}]` represents the symmetry of a tensor that is antisymmetric in the slots si.
Examples [#examples]
Define an antisymmetric tensor:
```wolfram
TensorSymmetry[LeviCivitaTensor[3]]
(* Antisymmetric[{1, 2, 3}] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Antisymmetric.html) for more details.
# Apart
`Apart[expr]` rewrites a rational expression as a sum of terms with minimal denominators.
Examples [#examples]
Partial fraction decomposition:
```wolfram
Apart[1/(x^2 - 1)]
(* 1/(2(-1 + x)) - 1/(2(1 + x)) *)
```
```wolfram
Apart[(x + 1)/(x (x + 2))]
(* 1/(2 x) + 1/(2 (2 + x)) *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Apart.html) for more details.
# ApartSquareFree
`ApartSquareFree[expr]` rewrites a rational expression as a sum of terms whose denominators are powers of square-free polynomials.
`ApartSquareFree[expr, var]` treats all variables other than var as constants.
Examples [#examples]
Decompose a rational expression:
```wolfram
ApartSquareFree[1/((x - 1)^2 (x + 1)), x]
```
Compare with standard Apart:
```wolfram
ApartSquareFree[x/((x^2 - 1)^2), x]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ApartSquareFree.html) for more details.
# Assuming
`Assuming[assum, expr]` evaluates expr with assum appended to \$Assumptions, so that assum is included in the default assumptions used by functions such as Refine, Simplify, and Integrate.
Examples [#examples]
```wolfram
Assuming[x > 0, Simplify[Sqrt[x^2]]]
(* x *)
```
```wolfram
Assuming[n ∈ Integers, Integrate[Sin[n x], {x, 0, 2 Pi}]]
(* 0 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Assuming.html) for more details.
# BabyMonsterGroupB
`BabyMonsterGroupB[]` represents the sporadic simple baby monster group B.
Examples [#examples]
Get the order of the baby monster group:
```wolfram
GroupOrder[BabyMonsterGroupB[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/BabyMonsterGroupB.html) for more details.
# Cancel
`Cancel[expr]` cancels out common factors in the numerator and denominator of expr.
Examples [#examples]
Cancel common factors:
```wolfram
Cancel[(x^2 - 1)/(x - 1)]
(* x + 1 *)
```
```wolfram
Cancel[(x^2 + 2x + 1)/(x + 1)]
(* x + 1 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Cancel.html) for more details.
# ChineseRemainder
`ChineseRemainder[{r1, r2, ...}, {m1, m2, ...}]` gives the smallest non-negative x that satisfies all the integer congruences x ≡ ri (mod mi).
`ChineseRemainder[{r1, r2, ...}, {m1, m2, ...}, d]` gives the smallest x ≥ d that satisfies all congruences.
Examples [#examples]
Solve a system of congruences:
```wolfram
ChineseRemainder[{2, 3, 2}, {3, 5, 7}]
(* 23 *)
```
Verify the result:
```wolfram
Mod[23, {3, 5, 7}]
(* {2, 3, 2} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ChineseRemainder.html) for more details.
# Coefficient
`Coefficient[expr, form]` gives the coefficient of form in the polynomial expr. `Coefficient[expr, form, n]` gives the coefficient of form^n in expr.
Examples [#examples]
Get coefficient of x^2:
```wolfram
Coefficient[3x^3 + 5x^2 + 2x + 1, x, 2]
(* 5 *)
```
Coefficient of a linear term:
```wolfram
Coefficient[a*x + b*y + c, x]
(* a *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Coefficient.html) for more details.
# CoefficientArrays
`CoefficientArrays[polys, vars]` gives the arrays of coefficients of the variables vars in the polynomials polys.
Examples [#examples]
```wolfram
CoefficientArrays[{a x + b y, c x + d y}, {x, y}]
(* {{0, 0}, {{a, b}, {c, d}}} *)
```
```wolfram
CoefficientArrays[x^2 + 2 x + 1, x]
(* {1, {2}, {{1}}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/CoefficientArrays.html) for more details.
# CoefficientList
`CoefficientList[poly, var]` gives a list of coefficients of powers of var in poly, starting with power 0.
Examples [#examples]
Get all coefficients:
```wolfram
CoefficientList[3x^3 + 2x^2 + x + 5, x]
(* {5, 1, 2, 3} *)
```
For a quadratic:
```wolfram
CoefficientList[x^2 - 3x + 2, x]
(* {2, -3, 1} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/CoefficientList.html) for more details.
# CoefficientRules
`CoefficientRules[poly, {x1, x2, ...}]` gives exponent vectors and coefficients for monomials in poly.
Examples [#examples]
Get exponent-coefficient rules:
```wolfram
CoefficientRules[x^2 + 3x*y + y^2, {x, y}]
(* {{2, 0} -> 1, {1, 1} -> 3, {0, 2} -> 1} *)
```
Single variable:
```wolfram
CoefficientRules[2x^3 + 5x + 1, {x}]
(* {{3} -> 2, {1} -> 5, {0} -> 1} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/CoefficientRules.html) for more details.
# Collect
`Collect[expr, x]` collects together terms involving the same powers of objects matching x.
Examples [#examples]
Collect terms in x:
```wolfram
Collect[a*x + b*x + c*x^2, x]
(* c x^2 + (a + b) x *)
```
Collect with multiple variables:
```wolfram
Collect[Expand[(x + y + 1)^3], {x, y}]
(* 1 + 3 y + 3 y^2 + y^3 + (3 + 6 y + 3 y^2) x + (3 + 3 y) x^2 + x^3 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Collect.html) for more details.
# Complex
`Complex` is the head used for complex numbers.
Examples [#examples]
Create a complex number:
```wolfram
Complex[3, 4]
(* 3 + 4 I *)
```
Check the head of a complex number:
```wolfram
Head[2 + 3 I]
(* Complex *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Complex.html) for more details.
# ComplexExpand
`ComplexExpand[expr]` expands expr assuming that all variables are real.
`ComplexExpand[expr, {x1, x2, ...}]` expands expr assuming that variables matching any of the xi are complex.
Examples [#examples]
Expand assuming real variables:
```wolfram
ComplexExpand[Re[a + b I]]
(* a *)
```
Expand with complex variable:
```wolfram
ComplexExpand[Abs[z]^2, {z}]
(* Re[z]^2 + Im[z]^2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ComplexExpand.html) for more details.
# ComposeSeries
`ComposeSeries[series1, series2, ...]` composes several power series.
Examples [#examples]
Compose two series:
```wolfram
s1 = Series[Exp[x], {x, 0, 3}];
s2 = Series[Sin[y], {y, 0, 3}];
ComposeSeries[s1, s2]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ComposeSeries.html) for more details.
# CompositeQ
`CompositeQ[n]` yields True if n is a composite number, and yields False otherwise.
Examples [#examples]
Check if a number is composite:
```wolfram
CompositeQ[15]
(* True *)
CompositeQ[7]
(* False *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/CompositeQ.html) for more details.
# Convergents
`Convergents[list]` gives a list of the convergents corresponding to the continued fraction terms list.
`Convergents[x, n]` gives the first n convergents for a number x.
`Convergents[x]` gives if possible all convergents leading to the number x.
Examples [#examples]
Convergents from continued fraction terms:
```wolfram
Convergents[{3, 7, 15, 1, 292}]
(* {3, 22/7, 333/106, 355/113, 103993/33102} *)
```
Convergents of Pi:
```wolfram
Convergents[Pi, 5]
(* {3, 22/7, 333/106, 355/113, 103993/33102} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Convergents.html) for more details.
# ConwayGroupCo1
`ConwayGroupCo1[]` represents the sporadic simple Conway group Co1.
Examples [#examples]
Create the Conway group Co1:
```wolfram
ConwayGroupCo1[]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ConwayGroupCo1.html) for more details.
# ConwayGroupCo2
`ConwayGroupCo2[]` represents the sporadic simple Conway group Co2.
Examples [#examples]
Create the Conway group Co2:
```wolfram
ConwayGroupCo2[]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ConwayGroupCo2.html) for more details.
# ConwayGroupCo3
`ConwayGroupCo3[]` represents the sporadic simple Conway group Co3.
Examples [#examples]
Create the Conway group Co3:
```wolfram
ConwayGroupCo3[]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ConwayGroupCo3.html) for more details.
# CoprimeQ
`CoprimeQ[n1, n2]` yields True if n1 and n2 are relatively prime, and yields False otherwise.
`CoprimeQ[n1, n2, ...]` yields True if all pairs of the ni are relatively prime, and yields False otherwise.
Examples [#examples]
Check if two numbers are coprime:
```wolfram
CoprimeQ[8, 15]
(* True *)
```
Numbers with common factor:
```wolfram
CoprimeQ[12, 18]
(* False *)
```
Multiple numbers:
```wolfram
CoprimeQ[3, 5, 7]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/CoprimeQ.html) for more details.
# CountRoots
`CountRoots[f, x]` gives the number of real roots of the univariate function f in x.
`CountRoots[f, {x, a, b}]` gives the number of roots between a and b.
Examples [#examples]
Count roots of a polynomial:
```wolfram
CountRoots[x^3 - x, x]
(* 3 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/CountRoots.html) for more details.
# Cycles
`Cycles[{cyc1, cyc2, ...}]` represents a permutation with disjoint cycles cyci.
Examples [#examples]
Create a permutation from cycles:
```wolfram
Cycles[{{1, 3, 2}}]
(* Cycles[{{1, 3, 2}}] *)
```
Convert to list:
```wolfram
PermutationList[Cycles[{{1, 3, 2}}], 4]
(* {3, 1, 2, 4} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Cycles.html) for more details.
# CyclicGroup
`CyclicGroup[n]` represents the cyclic group of degree n.
Examples [#examples]
Create a cyclic group:
```wolfram
CyclicGroup[4]
```
Get elements of the group:
```wolfram
GroupElements[CyclicGroup[4]]
(* {Cycles[{}], Cycles[{{1, 2, 3, 4}}], Cycles[{{1, 3}, {2, 4}}], Cycles[{{1, 4, 3, 2}}]} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/CyclicGroup.html) for more details.
# Cyclotomic
`Cyclotomic[n, x]` gives the nth cyclotomic polynomial in x.
Examples [#examples]
First few cyclotomic polynomials:
```wolfram
Cyclotomic[1, x]
(* x - 1 *)
Cyclotomic[2, x]
(* x + 1 *)
Cyclotomic[6, x]
(* x^2 - x + 1 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Cyclotomic.html) for more details.
# CylindricalDecomposition
`CylindricalDecomposition[expr, {x1, x2, ...}]` finds a decomposition of the region represented by the statement expr into cylindrical parts whose directions correspond to the successive xi.
`CylindricalDecomposition[expr, {x1, x2, ...}, op]` finds a decomposition of the result of applying the topological operation op to the region represented by the statement expr.
`CylindricalDecomposition[expr, {x1, x2, ...}, "Function"]` represents the result as `CylindricalDecompositionFunction[...][x1, x2, ...]` that can be efficiently used in further computation.
Examples [#examples]
Decompose a circular region:
```wolfram
CylindricalDecomposition[x^2 + y^2 < 1, {x, y}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/CylindricalDecomposition.html) for more details.
# CylindricalDecompositionFunction
`CylindricalDecompositionFunction[data][x1,x2,…]` represents a cylindrical algebraic formula in x1,x2,….
Examples [#examples]
Create a cylindrical decomposition function:
```wolfram
CylindricalDecomposition[x^2 + y^2 < 1, {x, y}, "Function"]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/CylindricalDecompositionFunction.html) for more details.
# DihedralGroup
`DihedralGroup[n]` represents the dihedral group of order 2n.
Examples [#examples]
Create the dihedral group of a triangle:
```wolfram
DihedralGroup[3]
(* DihedralGroup[3] *)
```
Get group elements:
```wolfram
GroupElements[DihedralGroup[4]]
```
Group order:
```wolfram
GroupOrder[DihedralGroup[5]]
(* 10 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DihedralGroup.html) for more details.
# Discriminant
`Discriminant[poly, var]` computes the discriminant of the polynomial poly with respect to var.
Examples [#examples]
Discriminant of a quadratic:
```wolfram
Discriminant[a*x^2 + b*x + c, x]
(* b^2 - 4 a c *)
```
Numeric example:
```wolfram
Discriminant[x^2 - 5x + 6, x]
(* 1 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Discriminant.html) for more details.
# Eliminate
`Eliminate[eqns, vars]` eliminates variables between a set of simultaneous equations.
Examples [#examples]
Eliminate y from two equations:
```wolfram
Eliminate[{x + y == 3, x - y == 1}, y]
(* x == 2 *)
```
Eliminate multiple variables:
```wolfram
Eliminate[{a == b + c, b == 2c, c == 3}, {b, c}]
(* a == 9 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Eliminate.html) for more details.
# ExtendedGCD
`ExtendedGCD[n1, n2, ...]` gives the extended greatest common divisor of the integers ni, including coefficients for expressing the GCD as a linear combination.
Examples [#examples]
Find extended GCD:
```wolfram
ExtendedGCD[12, 8]
(* {4, {1, -1}} *)
```
This means 4 = 12×1 + 8×(-1).
Multiple arguments:
```wolfram
ExtendedGCD[15, 10, 6]
(* {1, {1, -1, -1}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ExtendedGCD.html) for more details.
# Factor
`Factor[poly]` factors a polynomial over the integers.
Examples [#examples]
Factor a polynomial:
```wolfram
Factor[x^2 - 1]
(* (x - 1)(x + 1) *)
```
Factor a cubic:
```wolfram
Factor[x^3 - 1]
(* (x - 1)(x^2 + x + 1) *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Factor.html) for more details.
# FactorInteger
`FactorInteger[n]` gives a list of the prime factors of the integer n, together with their exponents.
`FactorInteger[n, k]` does partial factorization, pulling out at most k distinct factors.
Examples [#examples]
Factor an integer into primes:
```wolfram
FactorInteger[120]
(* {{2, 3}, {3, 1}, {5, 1}} *)
```
This means 120 = 2³ × 3¹ × 5¹.
Factor a larger number:
```wolfram
FactorInteger[1000]
(* {{2, 3}, {5, 3}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FactorInteger.html) for more details.
# FactorList
`FactorList[poly]` gives a list of the factors of a polynomial, together with their exponents.
Examples [#examples]
Factor list of a polynomial:
```wolfram
FactorList[x^2 - 1]
(* {{1, 1}, {-1 + x, 1}, {1 + x, 1}} *)
```
With repeated factors:
```wolfram
FactorList[(x - 1)^3 (x + 1)]
(* {{1, 1}, {-1 + x, 3}, {1 + x, 1}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FactorList.html) for more details.
# FactorSquareFree
`FactorSquareFree[poly]` pulls out any multiple factors in a polynomial, giving a product of square-free factors.
Examples [#examples]
Square-free factorization:
```wolfram
FactorSquareFree[x^4 - 2x^2 + 1]
(* (x^2 - 1)^2 *)
```
Separate repeated factors:
```wolfram
FactorSquareFree[(x - 1)^3 (x + 2)]
(* (x - 1)^3 (x + 2) *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FactorSquareFree.html) for more details.
# FactorSquareFreeList
`FactorSquareFreeList[poly]` gives a list of square-free factors of a polynomial, together with their exponents.
Examples [#examples]
List square-free factors:
```wolfram
FactorSquareFreeList[x^4 - 2x^2 + 1]
(* {{1, 1}, {-1 + x^2, 2}} *)
```
With multiple factors:
```wolfram
FactorSquareFreeList[(x - 1)^3 (x + 2)^2]
(* {{1, 1}, {2 + x, 2}, {-1 + x, 3}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FactorSquareFreeList.html) for more details.
# FactorTerms
`FactorTerms[poly]` pulls out any overall numerical factor in poly.
`FactorTerms[poly, x]` pulls out any overall factor that does not depend on x.
Examples [#examples]
Pull out numerical factor:
```wolfram
FactorTerms[2x + 4y]
(* 2 (x + 2 y) *)
```
Factor out terms not depending on x:
```wolfram
FactorTerms[a x + a y, x]
(* a (x + y) *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FactorTerms.html) for more details.
# FactorTermsList
`FactorTermsList[poly]` gives a list where the first element is the overall numerical factor and the second is the polynomial with the factor removed.
Examples [#examples]
Get numerical factor and remainder:
```wolfram
FactorTermsList[6x + 12y]
(* {6, x + 2 y} *)
```
With multiple variables:
```wolfram
FactorTermsList[a b x + a b y, {x, y}]
(* {1, a b, x + y} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FactorTermsList.html) for more details.
# FareySequence
`FareySequence[n]` generates the Farey sequence of order n.
`FareySequence[n,k]` gives the kth element of the Farey sequence of order n.
Examples [#examples]
```wolfram
(* Generate Farey sequence of order 4 *)
FareySequence[4]
(* {0, 1/4, 1/3, 1/2, 2/3, 3/4, 1} *)
(* Get a specific element *)
FareySequence[5, 3]
(* Length of Farey sequence *)
Length[FareySequence[10]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FareySequence.html) for more details.
# FindRoot
`FindRoot[f, {x, x0}]` searches for a numerical root of f, starting from x = x0.
`FindRoot[lhs == rhs, {x, x0}]` searches for a numerical solution to the equation.
Examples [#examples]
Find a root:
```wolfram
FindRoot[Cos[x] == x, {x, 0.5}]
(* {x -> 0.739085} *)
```
Multivariate:
```wolfram
FindRoot[{x + y == 3, x - y == 1}, {{x, 1}, {y, 1}}]
(* {x -> 2., y -> 1.} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FindRoot.html) for more details.
# FiniteField
`FiniteField[p, d]` gives a finite field with p^d elements.
* `FiniteField[p, f]` gives the finite field defined by the irreducible polynomial f.
* `FiniteField[p, ..., rep]` uses field element representation rep, either "Polynomial" or "Exponential".
Examples [#examples]
Create a finite field with 8 elements:
```wolfram
ff = FiniteField[2, 3]
```
Get elements of a finite field:
```wolfram
ff = FiniteField[3, 2];
ff["Elements"]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FiniteField.html) for more details.
# FiniteFieldElementPrimitiveQ
`FiniteFieldElementPrimitiveQ[a]` tests whether a is a primitive element of its ambient field.
Examples [#examples]
Test if an element is primitive:
```wolfram
ff = FiniteField[2, 3];
a = ff["PrimitiveElement"];
FiniteFieldElementPrimitiveQ[a]
```
Test another element:
```wolfram
FiniteFieldElementPrimitiveQ[a^2]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FiniteFieldElementPrimitiveQ.html) for more details.
# FiniteFieldEmbedding
`FiniteFieldEmbedding[ff1, ff2]` gives an embedding of the finite field ff1 in the finite field ff2.
* `FiniteFieldEmbedding[e1 -> e2]` represents the embedding of the ambient field of e1 in the ambient field of e2, which maps e1 to e2.
Examples [#examples]
Create an embedding between finite fields:
```wolfram
ff1 = FiniteField[2, 2];
ff2 = FiniteField[2, 4];
emb = FiniteFieldEmbedding[ff1, ff2]
```
Apply the embedding to an element:
```wolfram
a = ff1["PrimitiveElement"];
emb[a]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FiniteFieldEmbedding.html) for more details.
# FiniteFieldIndex
`FiniteFieldIndex[u]` gives the index of the FiniteFieldElement object u.
Examples [#examples]
Get the index of a finite field element:
```wolfram
ff = FiniteField[2, 3];
a = ff["PrimitiveElement"];
FiniteFieldIndex[a]
```
Get indices for powers of the primitive element:
```wolfram
Table[FiniteFieldIndex[a^k], {k, 0, 6}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FiniteFieldIndex.html) for more details.
# FischerGroupFi22
`FischerGroupFi22[]` represents the sporadic simple Fischer group Fi22.
Examples [#examples]
Create the Fischer group Fi22:
```wolfram
FischerGroupFi22[]
```
Get the group order:
```wolfram
GroupOrder[FischerGroupFi22[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FischerGroupFi22.html) for more details.
# FischerGroupFi23
`FischerGroupFi23[]` represents the sporadic simple Fischer group Fi23.
Examples [#examples]
Get the order of the Fischer group Fi23:
```wolfram
GroupOrder[FischerGroupFi23[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FischerGroupFi23.html) for more details.
# FischerGroupFi24Prime
`FischerGroupFi24Prime[]` represents the sporadic simple Fischer group Fi24′.
Examples [#examples]
Get the order of the Fischer group Fi24′:
```wolfram
GroupOrder[FischerGroupFi24Prime[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FischerGroupFi24Prime.html) for more details.
# FromCoefficientRules
`FromCoefficientRules[list, {x1, x2, ...}]` constructs a polynomial from a list of rules for exponent vectors and coefficients.
Examples [#examples]
Construct a polynomial from coefficient rules:
```wolfram
FromCoefficientRules[{{2, 1} -> 3, {0, 0} -> 1}, {x, y}]
```
Create a multivariate polynomial:
```wolfram
FromCoefficientRules[{{1, 0} -> a, {0, 1} -> b, {0, 0} -> c}, {x, y}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FromCoefficientRules.html) for more details.
# FromContinuedFraction
`FromContinuedFraction[list]` reconstructs a number from the list of its continued fraction terms.
Examples [#examples]
Reconstruct a number from continued fraction:
```wolfram
FromContinuedFraction[{3, 7, 15, 1}]
```
Verify with Pi:
```wolfram
FromContinuedFraction[ContinuedFraction[Pi, 10]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FromContinuedFraction.html) for more details.
# FromFiniteField
`FromFiniteField[a, ff]` converts the element a of the prime subfield of the finite field ff to an integer.
`FromFiniteField[expr, ff, t]` converts the elements of the finite field ff in the coefficients of the rational expression expr to polynomials in t, where t represents the field generator.
Examples [#examples]
```wolfram
ff = FiniteField[5];
FromFiniteField[ff[3], ff]
(* 3 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FromFiniteField.html) for more details.
# FromFiniteFieldIndex
`FromFiniteFieldIndex[ind,ff]` gives the element of the finite field ff with index ind.
Examples [#examples]
Get an element from a finite field by index:
```wolfram
FromFiniteFieldIndex[5, GF[7]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FromFiniteFieldIndex.html) for more details.
# FullSimplify
`FullSimplify[expr]` tries a wide range of transformations involving elementary and special functions to find the simplest form.
Examples [#examples]
Simplify with special functions:
```wolfram
FullSimplify[Sin[x]^2 + Cos[x]^2]
(* 1 *)
```
Simplify complex expressions:
```wolfram
FullSimplify[Gamma[n + 1]/Gamma[n], n > 0]
(* n *)
```
With assumptions:
```wolfram
FullSimplify[Log[Exp[x]], x \[Element] Reals]
(* x *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FullSimplify.html) for more details.
# FunctionExpand
`FunctionExpand[expr]` tries to expand out special and certain other functions in expr, when possible reducing compound arguments to simpler ones.
* `FunctionExpand[expr, assum]` expands using assumptions.
Examples [#examples]
Expand a logarithm of a product:
```wolfram
FunctionExpand[Log[a b], a > 0 && b > 0]
```
Expand special functions:
```wolfram
FunctionExpand[Gamma[n + 1/2], n ∈ Integers && n >= 0]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FunctionExpand.html) for more details.
# GenericCylindricalDecomposition
`GenericCylindricalDecomposition[ineqs,{x1,x2,...}]` finds the full-dimensional part of the decomposition of the region represented by the inequalities ineqs into cylindrical parts whose directions correspond to the successive xi, together with any hypersurfaces containing the rest of the region.
Examples [#examples]
Decompose a simple region:
```wolfram
GenericCylindricalDecomposition[x^2 + y^2 < 1, {x, y}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GenericCylindricalDecomposition.html) for more details.
# GroebnerBasis
`GroebnerBasis[{poly1,poly2,…},{x1,x2,…}]` gives a list of polynomials that form a Gröbner basis for the set of polynomials polyi.
`GroebnerBasis[{poly1,poly2,…},{x1,x2,…},{y1,y2,…}]` finds a Gröbner basis in which the yi have been eliminated.
Examples [#examples]
Find a Gröbner basis for two polynomials:
```wolfram
GroebnerBasis[{x^2 + y^2 - 1, x - y}, {x, y}]
(* {-1 + 2 y^2, -y + x} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GroebnerBasis.html) for more details.
# GroupCentralizer
`GroupCentralizer[group, g]` returns the centralizer of the element `g` in `group`.
Examples [#examples]
```wolfram
GroupCentralizer[SymmetricGroup[4], Cycles[{{1, 2}}]]
```
```wolfram
GroupCentralizer[AlternatingGroup[5], Cycles[{{1, 2, 3}}]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GroupCentralizer.html) for more details.
# GroupElementFromWord
`GroupElementFromWord[group, w]` returns the element of `group` determined by the word `w` in the generators of `group`.
Examples [#examples]
```wolfram
GroupElementFromWord[SymmetricGroup[4], {1, 2, 1}]
```
```wolfram
GroupElementFromWord[DihedralGroup[6], {1, -1, 2}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GroupElementFromWord.html) for more details.
# GroupElementPosition
`GroupElementPosition[group, g]` returns the position of the element `g` in the list of elements of `group`.
* `GroupElementPosition[group, {g1, …, gn}]` returns the list of positions of the elements `g1, …, gn` in `group`.
Examples [#examples]
```wolfram
GroupElementPosition[SymmetricGroup[3], Cycles[{{1, 2}}]]
```
```wolfram
GroupElementPosition[CyclicGroup[6], {Cycles[{}], Cycles[{{1, 2, 3, 4, 5, 6}}]}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GroupElementPosition.html) for more details.
# GroupElementQ
`GroupElementQ[group, g]` returns `True` if the object `g` is an element of `group` and `False` otherwise.
Examples [#examples]
```wolfram
GroupElementQ[SymmetricGroup[4], Cycles[{{1, 2, 3}}]]
```
```wolfram
GroupElementQ[AlternatingGroup[4], Cycles[{{1, 2}}]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GroupElementQ.html) for more details.
# GroupElementToWord
`GroupElementToWord[group, g]` decomposes the group element g as a product of generators of group.
Examples [#examples]
Decompose a permutation into generators:
```wolfram
GroupElementToWord[SymmetricGroup[3], Cycles[{{1, 2, 3}}]]
(* {1, 2} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GroupElementToWord.html) for more details.
# GroupElements
`GroupElements[group]` returns the list of all elements of `group`.
* `GroupElements[group, {r1, …, rk}]` returns the elements numbered `r1, …, rk` in `group` in the standard order.
Examples [#examples]
```wolfram
GroupElements[SymmetricGroup[3]]
```
```wolfram
GroupElements[CyclicGroup[4], {1, 3}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GroupElements.html) for more details.
# GroupGenerators
`GroupGenerators[group]` returns a list of generators of group.
Examples [#examples]
Get generators of the symmetric group:
```wolfram
GroupGenerators[SymmetricGroup[4]]
(* {Cycles[{{1, 2}}], Cycles[{{1, 2, 3, 4}}]} *)
```
Get generators of the alternating group:
```wolfram
GroupGenerators[AlternatingGroup[5]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GroupGenerators.html) for more details.
# GroupMultiplicationTable
`GroupMultiplicationTable[group]` gives the multiplication table of `group` as an array.
Examples [#examples]
```wolfram
GroupMultiplicationTable[SymmetricGroup[3]]
```
```wolfram
GroupMultiplicationTable[CyclicGroup[4]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GroupMultiplicationTable.html) for more details.
# GroupOrbits
`GroupOrbits[group, {p1, …}]` returns the orbits of the points `pi` under the action of the elements of `group`.
* `GroupOrbits[group, {p1, …}, f]` finds the orbits under the group action given by a function `f`.
Examples [#examples]
```wolfram
GroupOrbits[SymmetricGroup[4], {1, 2, 3, 4}]
```
```wolfram
GroupOrbits[CyclicGroup[3], Range[6]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GroupOrbits.html) for more details.
# GroupOrder
`GroupOrder[group]` returns the number of elements of `group`.
Examples [#examples]
```wolfram
GroupOrder[SymmetricGroup[5]]
```
```wolfram
GroupOrder[AlternatingGroup[4]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GroupOrder.html) for more details.
# HaradaNortonGroupHN
`HaradaNortonGroupHN[]` represents the sporadic simple Harada–Norton group HN.
Examples [#examples]
```wolfram
HaradaNortonGroupHN[]
```
```wolfram
GroupOrder[HaradaNortonGroupHN[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/HaradaNortonGroupHN.html) for more details.
# HeldGroupHe
`HeldGroupHe[]` represents the sporadic simple Held group He.
Examples [#examples]
Get the order of the Held group:
```wolfram
GroupOrder[HeldGroupHe[]]
(* 4030387200 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/HeldGroupHe.html) for more details.
# Hermitian
`Hermitian[{1, 2}]` represents the symmetry of a Hermitian matrix.
Examples [#examples]
Define a Hermitian matrix:
```wolfram
m = {{1, 2 + I}, {2 - I, 3}};
HermitianMatrixQ[m]
(* True *)
```
Use Hermitian symmetry in tensor operations:
```wolfram
TensorSymmetry[{{a, b}, {Conjugate[b], c}}, Hermitian[{1, 2}]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Hermitian.html) for more details.
# HigmanSimsGroupHS
`HigmanSimsGroupHS[]` represents the sporadic simple Higman–Sims group HS.
Examples [#examples]
Get the Higman-Sims group:
```wolfram
HigmanSimsGroupHS[]
```
Get the group order:
```wolfram
GroupOrder[HigmanSimsGroupHS[]]
(* 44352000 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/HigmanSimsGroupHS.html) for more details.
# Integer
`Integer` is the head used for integers.
Examples [#examples]
Check if a value is an integer:
```wolfram
Head[42]
(* Integer *)
```
Test for integer type:
```wolfram
IntegerQ[42]
(* True *)
```
```wolfram
IntegerQ[3.14]
(* False *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Integer.html) for more details.
# IntegerExponent
`IntegerExponent[n, b]` gives the highest power of b that divides n.
Examples [#examples]
Power of 2 in 24:
```wolfram
IntegerExponent[24, 2]
(* 3 *)
```
Power of 5 in 1000:
```wolfram
IntegerExponent[1000, 5]
(* 3 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/IntegerExponent.html) for more details.
# IntegerLength
`IntegerLength[n]` gives the number of digits in the base 10 representation of n.
`IntegerLength[n, b]` gives the number of digits in base b.
Examples [#examples]
Decimal digits:
```wolfram
IntegerLength[12345]
(* 5 *)
```
Binary digits:
```wolfram
IntegerLength[255, 2]
(* 8 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/IntegerLength.html) for more details.
# IntegerName
`IntegerName[n]` gives a string containing the full English name of the integer `n`.
* `IntegerName[n, qualifier]` gives a string conforming to the given qualifications.
Examples [#examples]
```wolfram
IntegerName[42]
```
```wolfram
IntegerName[1000000, "Ordinal"]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/IntegerName.html) for more details.
# IntegerReverse
`IntegerReverse[n]` gives the integer whose digits are reversed with respect to those of the integer n.
* `IntegerReverse[n, b]` gives the integer whose digits in base b are reversed with respect to those of n.
* `IntegerReverse[n, b, len]` gives the integer with reversed digits after padding n with zeros on the left to have len digits.
Examples [#examples]
```wolfram
IntegerReverse[12345]
```
```wolfram
IntegerReverse[12, 2]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/IntegerReverse.html) for more details.
# IntegerString
`IntegerString[n]` gives a string consisting of the decimal digits in integer n.
`IntegerString[n, b]` gives a string in base b.
`IntegerString[n, b, len]` pads with zeros to length len.
Examples [#examples]
Decimal string:
```wolfram
IntegerString[255]
(* "255" *)
```
Hexadecimal string:
```wolfram
IntegerString[255, 16]
(* "ff" *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/IntegerString.html) for more details.
# IrreduciblePolynomialQ
`IrreduciblePolynomialQ[poly]` tests whether poly is an irreducible polynomial over the rationals.
`IrreduciblePolynomialQ[poly,Modulus->p]` tests whether poly is irreducible modulo a prime p.
`IrreduciblePolynomialQ[poly,Extension->{a1,a2,…}]` tests whether poly is irreducible over the field extension generated by the algebraic numbers ai.
`IrreduciblePolynomialQ[poly,Extension->All]` tests whether poly is absolutely irreducible over the complex numbers.
Examples [#examples]
```wolfram
IrreduciblePolynomialQ[x^2 + 1]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/IrreduciblePolynomialQ.html) for more details.
# IsolatingInterval
`IsolatingInterval[a]` gives a rational isolating interval for the algebraic number a.
* `IsolatingInterval[a, dx]` gives an isolating interval of width at most dx.
Examples [#examples]
```wolfram
IsolatingInterval[Sqrt[2]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/IsolatingInterval.html) for more details.
# JankoGroupJ1
`JankoGroupJ1[]` represents the sporadic simple Janko group J1.
Examples [#examples]
```wolfram
JankoGroupJ1[]
```
```wolfram
GroupOrder[JankoGroupJ1[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/JankoGroupJ1.html) for more details.
# JankoGroupJ2
`JankoGroupJ2[]` represents the sporadic simple Janko group J2.
Examples [#examples]
```wolfram
JankoGroupJ2[]
```
```wolfram
GroupOrder[JankoGroupJ2[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/JankoGroupJ2.html) for more details.
# JankoGroupJ3
`JankoGroupJ3[]` represents the sporadic simple Janko group J3.
Examples [#examples]
```wolfram
JankoGroupJ3[]
```
```wolfram
GroupOrder[JankoGroupJ3[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/JankoGroupJ3.html) for more details.
# JankoGroupJ4
`JankoGroupJ4[]` represents the sporadic simple Janko group J4.
Examples [#examples]
Get the order of the Janko group J4:
```wolfram
GroupOrder[JankoGroupJ4[]]
(* 86775571046077562880 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/JankoGroupJ4.html) for more details.
# LatticeReduce
`LatticeReduce[{v1, v2, ...}]` gives a reduced basis for the set of vectors v\_i using the LLL algorithm.
Examples [#examples]
Reduce a lattice basis:
```wolfram
LatticeReduce[{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}]
```
2D example:
```wolfram
LatticeReduce[{{1, 0}, {3, 4}}]
(* {{1, 0}, {0, 4}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/LatticeReduce.html) for more details.
# LyonsGroupLy
`LyonsGroupLy[]` represents the sporadic simple Lyons group Ly.
Examples [#examples]
Get the order of the Lyons group:
```wolfram
GroupOrder[LyonsGroupLy[]]
(* 51765179004000000 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/LyonsGroupLy.html) for more details.
# MantissaExponent
`MantissaExponent[x]` gives a list containing the mantissa and exponent of a number x.
`MantissaExponent[x,b]` gives the base-b mantissa and exponent of x.
Examples [#examples]
Get the mantissa and exponent of a number:
```wolfram
MantissaExponent[1234.5]
(* {0.12345, 4} *)
```
Use base 2:
```wolfram
MantissaExponent[8, 2]
(* {0.5, 4} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/MantissaExponent.html) for more details.
# McLaughlinGroupMcL
`McLaughlinGroupMcL[]` represents the sporadic simple McLaughlin group McL.
Examples [#examples]
Create the McLaughlin group:
```wolfram
McLaughlinGroupMcL[]
```
Get the group order:
```wolfram
GroupOrder[McLaughlinGroupMcL[]]
(* 898128000 *)
```
Check properties:
```wolfram
FiniteGroupData["McLaughlinGroup", "SimpleGroupQ"]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/McLaughlinGroupMcL.html) for more details.
# MixedFractionParts
`MixedFractionParts[expr]` gives the list `{IntegerPart[expr], FractionalPart[expr]}`.
Examples [#examples]
Get the integer and fractional parts of a number:
```wolfram
MixedFractionParts[7/3]
(* {2, 1/3} *)
```
Works with negative numbers:
```wolfram
MixedFractionParts[-7/3]
(* {-3, 2/3} *)
```
With real numbers:
```wolfram
MixedFractionParts[3.75]
(* {3, 0.75} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/MixedFractionParts.html) for more details.
# MixedRadix
`MixedRadix[{b1,…,bn}]` represents the list of bases of a numerical system in which different digits have different bases.
Examples [#examples]
Convert a number using mixed radix (hours, minutes, seconds):
```wolfram
MixedRadix[{24, 60, 60}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/MixedRadix.html) for more details.
# MixedRadixQuantity
`MixedRadixQuantity[{value1, …, valuen}, {unit1, …, unitn}]` yields a single `Quantity` expression representing the addition of compatible units with magnitude values.
Examples [#examples]
```wolfram
MixedRadixQuantity[{5, 10, 30}, {"Hours", "Minutes", "Seconds"}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/MixedRadixQuantity.html) for more details.
# MonomialList
`MonomialList[poly]` gives the list of all monomials in the polynomial poly.
* `MonomialList[poly, {x1, x2, ...}]` gives the list of monomials with respect to the variables xi in poly.
* `MonomialList[poly, {x1, x2, ...}, order]` puts the monomials in the specified order.
Examples [#examples]
```wolfram
MonomialList[x^2 + 3x*y + y^2, {x, y}]
```
```wolfram
MonomialList[a + b x + c x^2, {x}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/MonomialList.html) for more details.
# MonsterGroupM
`MonsterGroupM[]` represents the sporadic simple monster group M.
Examples [#examples]
Get the order of the monster group:
```wolfram
GroupOrder[MonsterGroupM[]]
(* 808017424794512875886459904961710757005754368000000000 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/MonsterGroupM.html) for more details.
# NBernoulliB
`NBernoulliB[n]` gives the numerical value of the nth Bernoulli number.
`NBernoulliB[n, d]` gives the result to d-digit precision.
Examples [#examples]
```wolfram
NBernoulliB[10]
(* 0.0757576 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NBernoulliB.html) for more details.
# NRoots
`NRoots[lhs == rhs, var]` yields numerical approximations to the roots of a polynomial equation.
Examples [#examples]
Numeric roots:
```wolfram
NRoots[x^3 - 2 == 0, x]
(* x == 1.26 || x == -0.63 - 1.09 I || x == -0.63 + 1.09 I *)
```
Quadratic roots:
```wolfram
NRoots[x^2 - 5x + 3 == 0, x]
(* x == 0.697 || x == 4.303 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NRoots.html) for more details.
# NSolve
`NSolve[expr, vars]` attempts to find numerical approximations to the solutions of the system.
`NSolve[expr, vars, Reals]` finds solutions over the real numbers.
Examples [#examples]
Numerical solutions:
```wolfram
NSolve[x^3 - 2 == 0, x]
(* {{x -> 1.2599}, {x -> -0.62996 - 1.0911 I}, {x -> -0.62996 + 1.0911 I}} *)
```
Real solutions only:
```wolfram
NSolve[x^3 - 2 == 0, x, Reals]
(* {{x -> 1.2599}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NSolve.html) for more details.
# NSolveValues
`NSolveValues[expr, vars]` attempts to find numerical approximations to the values of *vars* determined by the solutions of the system *expr*.
* `NSolveValues[expr, vars, Reals]` finds solutions over the domain of real numbers.
Examples [#examples]
```wolfram
NSolveValues[x^2 - 2 == 0, x]
(* {-1.41421, 1.41421} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NSolveValues.html) for more details.
# NonCommutativeMultiply
`a ** b ** c` is a general associative, but non-commutative, form of multiplication.
Examples [#examples]
Non-commutative product:
```wolfram
a ** b ** c
(* a ** b ** c *)
```
Not automatically reordered:
```wolfram
b ** a
(* b ** a *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NonCommutativeMultiply.html) for more details.
# NumberCompose
`NumberCompose[{c1, ..., cn}, {u1, ..., un}]` returns the quantity c₁u₁ + ... + cₙuₙ.
Examples [#examples]
Compose a number from units:
```wolfram
NumberCompose[{3, 2, 5}, {100, 10, 1}]
(* 325 *)
```
Time composition:
```wolfram
NumberCompose[{2, 30, 45}, {3600, 60, 1}]
(* 9045 seconds *)
```
With unit objects:
```wolfram
NumberCompose[{5, 3}, {Quantity[1, "Meters"], Quantity[1, "Centimeters"]}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NumberCompose.html) for more details.
# NumberDecompose
`NumberDecompose[x, {u1, ..., un}]` returns a list of coefficients \{c1, ..., cn} of a decomposition of the number x in the basis \{u1, ..., un}.
Examples [#examples]
Decompose into hours, minutes, seconds:
```wolfram
NumberDecompose[3723, {3600, 60, 1}]
(* {1, 2, 3} *)
```
Money decomposition:
```wolfram
NumberDecompose[87, {20, 10, 5, 1}]
(* {4, 0, 1, 2} *)
```
Time units:
```wolfram
NumberDecompose[90061, {86400, 3600, 60, 1}]
(* {1, 1, 1, 1} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NumberDecompose.html) for more details.
# NumberFieldClassNumber
`NumberFieldClassNumber[θ]` gives the class number for the algebraic number field ℚ\[θ] generated by θ.
Examples [#examples]
Class number for a quadratic field:
```wolfram
NumberFieldClassNumber[Sqrt[-5]]
(* 2 *)
```
A field with class number 1:
```wolfram
NumberFieldClassNumber[Sqrt[2]]
(* 1 *)
```
Cyclotomic field:
```wolfram
NumberFieldClassNumber[Exp[2 Pi I/7]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NumberFieldClassNumber.html) for more details.
# NumberFieldDiscriminant
`NumberFieldDiscriminant[a]` gives the discriminant of the field ℚ\[a] generated by the algebraic number a.
Examples [#examples]
```wolfram
NumberFieldDiscriminant[Sqrt[5]]
(* 5 *)
```
```wolfram
NumberFieldDiscriminant[2^(1/3)]
(* -108 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NumberFieldDiscriminant.html) for more details.
# NumberFieldFundamentalUnits
`NumberFieldFundamentalUnits[a]` gives a list of fundamental units for the field ℚ\[a] generated by the algebraic number a.
Examples [#examples]
Find fundamental units for a quadratic field:
```wolfram
NumberFieldFundamentalUnits[Sqrt[2]]
(* {1 + Sqrt[2]} *)
```
For a cubic field:
```wolfram
NumberFieldFundamentalUnits[2^(1/3)]
(* {-1 + 2^(1/3)} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NumberFieldFundamentalUnits.html) for more details.
# NumberFieldIntegralBasis
`NumberFieldIntegralBasis[a]` gives an integral basis for the field ℚ\[a] generated by the algebraic number a.
Examples [#examples]
```wolfram
NumberFieldIntegralBasis[Sqrt[5]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NumberFieldIntegralBasis.html) for more details.
# NumberFieldNormRepresentatives
`NumberFieldNormRepresentatives[a, m]` gives a list of representatives of classes of algebraic integers of norm ±m in the field ℚ\[a] generated by the algebraic number a.
Examples [#examples]
```wolfram
NumberFieldNormRepresentatives[Sqrt[5], 4]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NumberFieldNormRepresentatives.html) for more details.
# NumberFieldRegulator
`NumberFieldRegulator[a]` gives the regulator of the field ℚ\[a] generated by the algebraic number a.
The regulator is an important invariant in algebraic number theory.
Examples [#examples]
```wolfram
NumberFieldRegulator[Sqrt[2]]
```
```wolfram
NumberFieldRegulator[2^(1/3)]
```
```wolfram
NumberFieldRegulator[GoldenRatio]
```
\*See the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NumberFieldRegulator.html) for more details.
# NumberFieldRootsOfUnity
`NumberFieldRootsOfUnity[a]` gives the roots of unity for the field ℚ\[a] generated by the algebraic number a.
Examples [#examples]
```wolfram
NumberFieldRootsOfUnity[Sqrt[5]]
(* {2, -1} *)
```
```wolfram
NumberFieldRootsOfUnity[Exp[2 Pi I/6]]
(* {6, E^(I Pi/3)} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NumberFieldRootsOfUnity.html) for more details.
# NumberFieldSignature
`NumberFieldSignature[a]` gives the signature of the field ℚ\[a] generated by the algebraic number a.
Examples [#examples]
Get the signature of a number field:
```wolfram
NumberFieldSignature[Sqrt[2]]
(* {2, 0} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NumberFieldSignature.html) for more details.
# Numerator
`Numerator[expr]` gives the numerator of expr.
Examples [#examples]
Get numerator of a fraction:
```wolfram
Numerator[3/4]
(* 3 *)
```
From rational expression:
```wolfram
Numerator[(a + b)/(c + d)]
(* a + b *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Numerator.html) for more details.
# NumeratorDenominator
`NumeratorDenominator[expr]` gives the list `{Numerator[expr], Denominator[expr]}` of expr.
Examples [#examples]
```wolfram
NumeratorDenominator[3/4]
```
```wolfram
NumeratorDenominator[(a + b)/(c + d)]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NumeratorDenominator.html) for more details.
# ONanGroupON
`ONanGroupON[]` represents the sporadic simple O'Nan group O'N.
This is one of the 26 sporadic simple groups in the classification of finite simple groups.
Examples [#examples]
```wolfram
ONanGroupON[]
```
```wolfram
GroupOrder[ONanGroupON[]]
```
```wolfram
FiniteGroupData["ONan", "Order"]
```
\*See the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ONanGroupON.html) for more details.
# PadeApproximant
`PadeApproximant[expr,{x,x0,{m,n}}]` gives the Padé approximant to expr about the point x=x0, with numerator order m and denominator order n.
`PadeApproximant[expr,{x,x0,n}]` gives the diagonal Padé approximant to expr about the point x=x0 of order n.
Examples [#examples]
Compute a Padé approximant of Exp\[x]:
```wolfram
PadeApproximant[Exp[x], {x, 0, {2, 2}}]
(* (1 + x/2 + x^2/12)/(1 - x/2 + x^2/12) *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PadeApproximant.html) for more details.
# PalindromeQ
`PalindromeQ[list]` returns True if the given list is identical to Reverse\[list], and False otherwise.
`PalindromeQ[n]` returns True if the integer n is identical to IntegerReverse\[n], and False otherwise.
`PalindromeQ[string]` returns True if the given string is identical to StringReverse\[string], and False otherwise.
Examples [#examples]
Check if a string is a palindrome:
```wolfram
PalindromeQ["racecar"]
(* True *)
```
Check a number:
```wolfram
PalindromeQ[12321]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PalindromeQ.html) for more details.
# PascalBinomial
`PascalBinomial[n, m]` gives the binomial coefficient C(n, m) that preserves Pascal's identity.
Examples [#examples]
```wolfram
PascalBinomial[5, 2]
```
```wolfram
Table[PascalBinomial[n, k], {n, 0, 5}, {k, 0, n}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PascalBinomial.html) for more details.
# PerfectNumber
`PerfectNumber[n]` gives the nth perfect number.
Examples [#examples]
```wolfram
PerfectNumber[1]
(* 6 *)
```
```wolfram
PerfectNumber[4]
(* 8128 *)
```
```wolfram
Table[PerfectNumber[n], {n, 1, 5}]
(* {6, 28, 496, 8128, 33550336} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PerfectNumber.html) for more details.
# PerfectNumberQ
`PerfectNumberQ[n]` returns `True` if n is a perfect number, and `False` otherwise.
Examples [#examples]
Test for perfect number:
```wolfram
PerfectNumberQ[6]
(* True *)
```
Non-perfect number:
```wolfram
PerfectNumberQ[10]
(* False *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PerfectNumberQ.html) for more details.
# PermutationCycles
`PermutationCycles[perm]` gives a disjoint cycle representation of permutation perm.
Examples [#examples]
Get the cycle representation of a permutation list:
```wolfram
PermutationCycles[{3, 1, 4, 2}]
(* Cycles[{{1, 3, 4, 2}}] *)
```
Convert a cycle representation to a permutation list:
```wolfram
PermutationList[Cycles[{{1, 3, 4, 2}}]]
(* {3, 1, 4, 2} *)
```
Find cycles for the identity permutation:
```wolfram
PermutationCycles[{1, 2, 3, 4}]
(* Cycles[{}] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PermutationCycles.html) for more details.
# PermutationCyclesQ
`PermutationCyclesQ[expr]` returns True if expr is a permutation in disjoint cyclic form, and False otherwise.
Examples [#examples]
```wolfram
PermutationCyclesQ[Cycles[{{1, 2, 3}}]]
```
```wolfram
PermutationCyclesQ[{1, 2, 3}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PermutationCyclesQ.html) for more details.
# PermutationGroup
`PermutationGroup[{perm1, …, permn}]` represents the group generated by multiplication of the permutations perm1, …, permn.
Examples [#examples]
```wolfram
PermutationGroup[{Cycles[{{1, 2}}], Cycles[{{2, 3}}]}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PermutationGroup.html) for more details.
# PermutationList
`PermutationList[perm]` returns a permutation list representation of permutation perm.
`PermutationList[perm, len]` returns a permutation list of length len.
Examples [#examples]
Convert a permutation to list form:
```wolfram
PermutationList[Cycles[{{1, 3, 2}}]]
(* {3, 1, 2} *)
```
Specify the length:
```wolfram
PermutationList[Cycles[{{1, 3}}], 5]
(* {3, 2, 1, 4, 5} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PermutationList.html) for more details.
# PermutationListQ
`PermutationListQ[expr]` returns `True` if expr is a valid permutation list and `False` otherwise.
Examples [#examples]
```wolfram
PermutationListQ[{2, 3, 1}]
```
```wolfram
PermutationListQ[{1, 2, 4}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PermutationListQ.html) for more details.
# PermutationMatrix
`PermutationMatrix[permv]` represents the permutation matrix given by permutation vector permv as a structured array.
* `PermutationMatrix[pmat]` converts a permutation matrix pmat to a structured array.
Examples [#examples]
```wolfram
PermutationMatrix[{3, 1, 2}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PermutationMatrix.html) for more details.
# PermutationMax
`PermutationMax[perm]` returns the largest integer moved by the permutation perm.
Examples [#examples]
Find the largest moved element:
```wolfram
PermutationMax[Cycles[{{1, 3, 5}}]]
```
For a permutation involving larger indices:
```wolfram
PermutationMax[Cycles[{{2, 7}, {4, 10, 6}}]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PermutationMax.html) for more details.
# PermutationMin
`PermutationMin[perm]` returns the smallest integer moved by the permutation perm.
Examples [#examples]
Smallest moved element:
```wolfram
PermutationMin[Cycles[{{1, 3, 5}}]]
(* 1 *)
```
Larger cycle:
```wolfram
PermutationMin[Cycles[{{4, 7, 9}}]]
(* 4 *)
```
Identity has no minimum:
```wolfram
PermutationMin[Cycles[{}]]
(* Infinity *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PermutationMin.html) for more details.
# PermutationOrder
`PermutationOrder[perm]` gives the order of permutation perm.
Examples [#examples]
Find the order of a permutation:
```wolfram
PermutationOrder[Cycles[{{1, 2, 3}}]]
```
Order of a transposition:
```wolfram
PermutationOrder[Cycles[{{1, 2}}]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PermutationOrder.html) for more details.
# PermutationPower
`PermutationPower[perm, n]` gives the nth permutation power of the permutation perm.
Examples [#examples]
Square of a permutation:
```wolfram
PermutationPower[Cycles[{{1, 2, 3}}], 2]
(* Cycles[{{1, 3, 2}}] *)
```
Cube returns identity:
```wolfram
PermutationPower[Cycles[{{1, 2, 3}}], 3]
(* Cycles[{}] *)
```
Negative power:
```wolfram
PermutationPower[Cycles[{{1, 2, 3}}], -1]
(* Cycles[{{1, 3, 2}}] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PermutationPower.html) for more details.
# PermutationProduct
`PermutationProduct[a, b, c]` gives the product of permutations a, b, c.
Examples [#examples]
```wolfram
PermutationProduct[Cycles[{{1, 2}}], Cycles[{{2, 3}}]]
```
```wolfram
PermutationProduct[{2, 3, 1}, {3, 1, 2}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PermutationProduct.html) for more details.
# PermutationSupport
`PermutationSupport[perm]` returns the support of the permutation perm.
Examples [#examples]
Get the support of a permutation (elements that are moved):
```wolfram
PermutationSupport[Cycles[{{1, 3, 5}}]]
(* {1, 3, 5} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PermutationSupport.html) for more details.
# PiecewiseExpand
`PiecewiseExpand[expr]` expands nested piecewise functions in expr to give a single piecewise function.
* `PiecewiseExpand[expr, assum]` expands piecewise functions using assumptions.
* `PiecewiseExpand[expr, assum, dom]` does the expansion over the domain dom.
Examples [#examples]
Expand Abs:
```wolfram
PiecewiseExpand[Abs[x]]
(* Piecewise[{{-x, x < 0}}, x] *)
```
With assumptions:
```wolfram
PiecewiseExpand[Abs[x], x > 0]
(* x *)
```
Nested piecewise:
```wolfram
PiecewiseExpand[Max[x, Min[y, z]]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PiecewiseExpand.html) for more details.
# PolynomialExpressionQ
`PolynomialExpressionQ[expr, x]` gives `True` if expr is structurally a polynomial expression in x, and `False` otherwise.
* `PolynomialExpressionQ[expr, {x, y, ...}]` gives `True` if expr is structurally a polynomial expression in x, y, ..., and `False` otherwise.
* `PolynomialExpressionQ[expr, {x, y, ...}, test]` gives `True` if expr is structurally a polynomial expression in x, y, ... with coefficients satisfying test.
Examples [#examples]
Test if an expression is a polynomial in x:
```wolfram
PolynomialExpressionQ[x^2 + 3x + 1, x]
(* True *)
```
Non-polynomial expressions:
```wolfram
PolynomialExpressionQ[Sin[x] + x^2, x]
(* False *)
```
Test for integer coefficients:
```wolfram
PolynomialExpressionQ[2x^2 + 3x + 1, {x}, IntegerQ]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PolynomialExpressionQ.html) for more details.
# PolynomialExtendedGCD
`PolynomialExtendedGCD[poly1, poly2, x]` gives the extended GCD of poly1 and poly2 treated as univariate polynomials in x.
* `PolynomialExtendedGCD[poly1, poly2, x, Modulus -> p]` gives the extended GCD over the integers modulo the prime p.
Examples [#examples]
Compute the extended GCD of two polynomials:
```wolfram
PolynomialExtendedGCD[x^2 - 1, x^3 - 1, x]
```
With modular arithmetic:
```wolfram
PolynomialExtendedGCD[x^2 + 1, x^3 + 1, x, Modulus -> 7]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PolynomialExtendedGCD.html) for more details.
# PolynomialGCD
`PolynomialGCD[poly1, poly2, ...]` gives the greatest common divisor of the polynomials.
Examples [#examples]
Find GCD of two polynomials:
```wolfram
PolynomialGCD[x^2 - 1, x^3 - x]
(* x^2 - 1 *)
```
Polynomials with common factor:
```wolfram
PolynomialGCD[(x + 1)^2 * (x - 1), (x + 1) * (x - 2)]
(* 1 + x *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PolynomialGCD.html) for more details.
# PolynomialLCM
`PolynomialLCM[poly1, poly2, …]` gives the least common multiple of the polynomials.
`PolynomialLCM[poly1, poly2, …, Modulus -> p]` evaluates the LCM modulo the prime p.
Examples [#examples]
LCM of polynomials:
```wolfram
PolynomialLCM[x^2 - 1, x^2 - x]
(* -x + x^2 + x^3 - x^4 *)
```
Simplified:
```wolfram
Factor[PolynomialLCM[x^2 - 1, x^2 - x]]
(* x (1 + x) (-1 + x)^2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PolynomialLCM.html) for more details.
# PolynomialMod
`PolynomialMod[poly, m]` gives the polynomial poly reduced modulo m.
`PolynomialMod[poly, {m1, m2, …}]` reduces modulo all of the mi.
Examples [#examples]
Reduce coefficients modulo:
```wolfram
PolynomialMod[5 x^2 + 7 x + 3, 3]
(* 2 x^2 + x *)
```
Multiple moduli:
```wolfram
PolynomialMod[12 x^2 + 15 x + 9, {2, 3}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PolynomialMod.html) for more details.
# PolynomialQ
`PolynomialQ[expr, var]` yields `True` if expr is a polynomial in var, and `False` otherwise.
`PolynomialQ[expr, {var1, …}]` tests whether expr is a polynomial in the vari.
Examples [#examples]
Test for polynomial:
```wolfram
PolynomialQ[x^2 + 2x + 1, x]
(* True *)
```
Not a polynomial:
```wolfram
PolynomialQ[1/x + x, x]
(* False *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PolynomialQ.html) for more details.
# PolynomialQuotient
`PolynomialQuotient[p, q, x]` gives the quotient of p and q, treated as polynomials in x, with any remainder dropped.
Examples [#examples]
Polynomial division:
```wolfram
PolynomialQuotient[x^3 + 2x^2 + x + 1, x + 1, x]
(* x^2 + x *)
```
Divide higher degree polynomial:
```wolfram
PolynomialQuotient[x^4 - 1, x^2 - 1, x]
(* x^2 + 1 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PolynomialQuotient.html) for more details.
# PolynomialQuotientRemainder
`PolynomialQuotientRemainder[p, q, x]` gives a list of the quotient and remainder of p and q, treated as polynomials in x.
Examples [#examples]
Get quotient and remainder:
```wolfram
PolynomialQuotientRemainder[x^3 + 2x^2 + x + 1, x + 1, x]
(* {x^2 + x, 1} *)
```
Verify:
```wolfram
{quot, rem} = PolynomialQuotientRemainder[x^4 - 1, x^2 - 1, x]
(* {x^2 + 1, 0} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PolynomialQuotientRemainder.html) for more details.
# PolynomialReduce
`PolynomialReduce[poly, {poly1, poly2, ...}, {x1, x2, ...}]` yields a list representing a reduction of poly in terms of the polyi. The list has the form `{{a1, a2, ...}, b}`, where b is minimal and `a1*poly1 + a2*poly2 + ... + b` is exactly poly.
Examples [#examples]
Reduce a polynomial:
```wolfram
PolynomialReduce[x^2 + y^2, {x + y, x - y}, {x, y}]
(* {{x/2 - y/2, x/2 + y/2}, 0} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PolynomialReduce.html) for more details.
# PolynomialRemainder
`PolynomialRemainder[p, q, x]` gives the remainder from dividing p by q, treated as polynomials in x.
Examples [#examples]
Get remainder after division:
```wolfram
PolynomialRemainder[x^3 + 2x^2 + x + 1, x + 1, x]
(* 1 *)
```
Another example:
```wolfram
PolynomialRemainder[x^4 + x^2, x^2 + x + 1, x]
(* 1 + x *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PolynomialRemainder.html) for more details.
# PrimitivePolynomialQ
`PrimitivePolynomialQ[poly, p]` tests whether poly is a primitive polynomial modulo a prime p.
Examples [#examples]
```wolfram
PrimitivePolynomialQ[x^4 + x + 1, 2]
```
```wolfram
PrimitivePolynomialQ[x^2 + 1, 3]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PrimitivePolynomialQ.html) for more details.
# PrimitiveRoot
`PrimitiveRoot[n]` gives a primitive root of n.
`PrimitiveRoot[n, k]` gives the smallest primitive root of n greater than or equal to k.
Examples [#examples]
```wolfram
PrimitiveRoot[7]
(* 3 *)
```
```wolfram
PrimitiveRoot[13, 5]
(* 6 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PrimitiveRoot.html) for more details.
# PrimitiveRootList
`PrimitiveRootList[n]` gives a list of primitive roots of n.
Examples [#examples]
```wolfram
PrimitiveRootList[7]
```
```wolfram
PrimitiveRootList[23]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PrimitiveRootList.html) for more details.
# QBinomial
`QBinomial[n, m, q]` gives the q-binomial coefficient (Gaussian binomial).
Examples [#examples]
Compute a q-binomial coefficient:
```wolfram
QBinomial[5, 2, q]
```
Evaluate at a specific q value:
```wolfram
QBinomial[4, 2, 2]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/QBinomial.html) for more details.
# QFactorial
`QFactorial[n, q]` gives the q-factorial \[n]\_q!.
Examples [#examples]
```wolfram
QFactorial[5, q]
```
```wolfram
QFactorial[4, 2]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/QFactorial.html) for more details.
# QGamma
`QGamma[z, q]` gives the q-gamma function Γq(z).
Examples [#examples]
Evaluate q-gamma:
```wolfram
QGamma[3, 0.5]
```
Symbolic form:
```wolfram
QGamma[n, q]
```
Limit as q→1:
```wolfram
Limit[QGamma[3, q], q -> 1]
(* 2 (= Gamma[3] = 2!) *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/QGamma.html) for more details.
# QHypergeometricPFQ
`QHypergeometricPFQ[{a1, ..., ar}, {b1, ..., bs}, q, z]` gives the basic hypergeometric series rϕs(a;b;q;z).
Examples [#examples]
```wolfram
QHypergeometricPFQ[{a}, {b}, q, z]
```
```wolfram
QHypergeometricPFQ[{1/2, 1/3}, {1/4}, 1/5, 1/10]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/QHypergeometricPFQ.html) for more details.
# QPochhammer
`QPochhammer[a, q, n]` gives the q-Pochhammer symbol (a;q)ₙ.
* `QPochhammer[a, q]` gives the q-Pochhammer symbol (a;q)∞.
* `QPochhammer[q]` gives the q-Pochhammer symbol (q;q)∞.
Examples [#examples]
Compute finite q-Pochhammer:
```wolfram
QPochhammer[1/2, 1/3, 5]
```
Infinite product:
```wolfram
N[QPochhammer[1/2, 1/2]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/QPochhammer.html) for more details.
# QPolyGamma
`QPolyGamma[z, q]` gives the q-digamma function ψ\_q(z).
* `QPolyGamma[n, z, q]` gives the nth derivative of the q-digamma function ψ\_q^(n)(z).
Examples [#examples]
```wolfram
QPolyGamma[2, 0.5]
```
```wolfram
QPolyGamma[1, 3, 0.8]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/QPolyGamma.html) for more details.
# QuadraticIrrationalQ
`QuadraticIrrationalQ[x]` gives `True` if x is a quadratic irrational and `False` otherwise.
Examples [#examples]
```wolfram
QuadraticIrrationalQ[Sqrt[2]]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/QuadraticIrrationalQ.html) for more details.
# Rational
`Rational` is the head used for rational numbers.
Examples [#examples]
Check head of a fraction:
```wolfram
Head[3/4]
(* Rational *)
```
Pattern matching:
```wolfram
MatchQ[5/7, _Rational]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Rational.html) for more details.
# RationalExpressionQ
`RationalExpressionQ[expr,x]` gives True if expr is structurally a rational expression in x, and False otherwise.
`RationalExpressionQ[expr,{x,y,…}]` gives True if expr is structurally a rational expression in x,y,…, and False otherwise.
`RationalExpressionQ[expr,{x,y,…},test]` gives True if expr is structurally a rational expression in x,y,… with coefficients satisfying test, and False otherwise.
Examples [#examples]
Test if an expression is rational in x:
```wolfram
RationalExpressionQ[(x^2 + 1)/(x - 1), x]
(* True *)
```
```wolfram
RationalExpressionQ[Sin[x]/x, x]
(* False *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/RationalExpressionQ.html) for more details.
# Reduce
`Reduce[expr, vars]` reduces the statement expr by solving equations or inequalities for vars.
`Reduce[expr, vars, dom]` does the reduction over the specified domain.
Examples [#examples]
Solve an equation:
```wolfram
Reduce[x^2 - 4 == 0, x]
(* x == -2 || x == 2 *)
```
With domain:
```wolfram
Reduce[x^2 == 2, x, Reals]
(* x == -Sqrt[2] || x == Sqrt[2] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Reduce.html) for more details.
# Refine
`Refine[expr, assum]` gives the form of expr that would be obtained if symbols in it were replaced by explicit numerical expressions satisfying the assumptions.
`Refine[expr]` uses default assumptions specified by any enclosing `Assuming` constructs.
Examples [#examples]
Simplify with assumptions:
```wolfram
Refine[Sqrt[x^2], x > 0]
(* x *)
```
Without assumptions:
```wolfram
Refine[Abs[x], x < 0]
(* -x *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Refine.html) for more details.
# Resultant
`Resultant[poly1, poly2, var]` computes the resultant of two polynomials with respect to var.
Examples [#examples]
Compute resultant:
```wolfram
Resultant[x^2 - 1, x^2 - 4, x]
(* 9 *)
```
Resultant of linear polynomials:
```wolfram
Resultant[a*x + b, c*x + d, x]
(* a d - b c *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Resultant.html) for more details.
# RootApproximant
`RootApproximant[x]` converts the number x to one of the "simplest" algebraic numbers that approximates it well.
* `RootApproximant[x, n]` finds an algebraic number of degree at most n that approximates x.
Examples [#examples]
Find an algebraic approximation:
```wolfram
RootApproximant[1.41421356]
```
Find a cubic root approximation:
```wolfram
RootApproximant[1.2599210498, 3]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/RootApproximant.html) for more details.
# RootIntervals
`RootIntervals[{poly1, poly2, ...}]` gives a list of isolating intervals for the real roots of any of the polyi, together with a list of which polynomials actually have each successive root.
* `RootIntervals[poly]` gives isolating intervals for real roots of a single polynomial.
* `RootIntervals[polys, Complexes]` gives bounding rectangles for complex roots.
Examples [#examples]
```wolfram
RootIntervals[x^2 - 2]
```
```wolfram
RootIntervals[{x^2 - 2, x^2 - 3}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/RootIntervals.html) for more details.
# RootReduce
`RootReduce[expr]` attempts to reduce expr to a single Root object.
Examples [#examples]
Reduce a sum of roots:
```wolfram
RootReduce[Sqrt[2] + Sqrt[3]]
(* Root[1 - 10 #1^2 + #1^4 &, 4] *)
```
Simplify a root expression:
```wolfram
RootReduce[Sqrt[2]^3]
(* 2 Sqrt[2] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/RootReduce.html) for more details.
# RootSum
`RootSum[f, form]` represents the sum of form\[x] for all x that satisfy the polynomial equation f\[x]==0.
Examples [#examples]
```wolfram
RootSum[#^3 - 1 &, #^2 &]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/RootSum.html) for more details.
# Roots
`Roots[lhs == rhs, var]` yields a disjunction of equations which represent the roots of a polynomial equation.
Examples [#examples]
Find polynomial roots:
```wolfram
Roots[x^2 - 4 == 0, x]
(* x == -2 || x == 2 *)
```
Cubic roots:
```wolfram
Roots[x^3 - 1 == 0, x]
(* x == 1 || x == -1/2 - I Sqrt[3]/2 || x == -1/2 + I Sqrt[3]/2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Roots.html) for more details.
# RudvalisGroupRu
`RudvalisGroupRu[]` represents the sporadic simple Rudvalis group Ru.
Examples [#examples]
```wolfram
RudvalisGroupRu[]
```
```wolfram
GroupOrder[RudvalisGroupRu[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/RudvalisGroupRu.html) for more details.
# SemialgebraicComponentInstances
`SemialgebraicComponentInstances[ineqs, {x1, x2, …}]` gives at least one sample point in each connected component of the semialgebraic set defined by the inequalities ineqs in the variables x1, x2, ….
Examples [#examples]
```wolfram
SemialgebraicComponentInstances[x^2 + y^2 < 1, {x, y}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SemialgebraicComponentInstances.html) for more details.
# Simplify
`Simplify[expr]` performs algebraic transformations on expr and returns the simplest form it finds.
`Simplify[expr, assum]` simplifies using assumptions.
Examples [#examples]
Simplify expressions:
```wolfram
Simplify[x^2 - 1 - (x - 1)(x + 1)]
(* 0 *)
```
With assumptions:
```wolfram
Simplify[Sqrt[x^2], x > 0]
(* x *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Simplify.html) for more details.
# Solve
`Solve[expr, vars]` attempts to solve the system expr of equations or inequalities for the variables vars.
`Solve[expr, vars, dom]` solves over the domain dom. Common choices are `Reals`, `Integers`, and `Complexes`.
Examples [#examples]
Solve a linear equation:
```wolfram
Solve[x + 2 == 5, x]
(* {{x -> 3}} *)
```
Solve a quadratic equation:
```wolfram
Solve[x^2 - 4 == 0, x]
(* {{x -> -2}, {x -> 2}} *)
```
Solve a system of equations:
```wolfram
Solve[{x + y == 3, x - y == 1}, {x, y}]
(* {{x -> 2, y -> 1}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Solve.html) for more details.
# SolveAlways
`SolveAlways[eqns, vars]` gives the values of parameters that make the equations eqns valid for all values of the variables vars.
Examples [#examples]
Find parameters that make an equation always true:
```wolfram
SolveAlways[a x^2 + b x + c == (x - 1)(x - 2), x]
(* {{a -> 1, b -> -3, c -> 2}} *)
```
Solve for coefficients of a polynomial identity:
```wolfram
SolveAlways[a + b x + c x^2 == 3 + 2 x - x^2, x]
(* {{a -> 3, b -> 2, c -> -1}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SolveAlways.html) for more details.
# SolveDelayed
`SolveDelayed` is an obsolete option to `NDSolve`. The option `"EquationSimplification"` should be used instead.
Examples [#examples]
```wolfram
(* Use "EquationSimplification" instead *)
NDSolve[{y'[x] == y[x], y[0] == 1}, y, {x, 0, 1},
Method -> {"EquationSimplification" -> "Residual"}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SolveDelayed.html) for more details.
# SolveValues
`SolveValues[expr, vars]` gives the values of vars determined by the solutions of the system expr.
`SolveValues[expr, vars, dom]` uses solutions over the domain dom. Common choices are Reals, Integers, and Complexes.
Examples [#examples]
Get solution values directly:
```wolfram
SolveValues[x^2 == 4, x]
(* {-2, 2} *)
```
Solve over integers:
```wolfram
SolveValues[x^2 < 10, x, Integers]
(* {-3, -2, -1, 0, 1, 2, 3} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SolveValues.html) for more details.
# SquareFreeQ
`SquareFreeQ[expr]` gives True if expr is a square-free polynomial or number, and False otherwise.
`SquareFreeQ[expr, vars]` gives True if expr is square free with respect to the variables vars.
Examples [#examples]
Test if a number is square-free:
```wolfram
SquareFreeQ[30]
(* True *)
```
Test a non-square-free number:
```wolfram
SquareFreeQ[12]
(* False *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SquareFreeQ.html) for more details.
# SquaresR
`SquaresR[d, n]` gives the number of ways to represent the integer n as a sum of d squares.
Examples [#examples]
Number of ways to write 5 as sum of 2 squares:
```wolfram
SquaresR[2, 5]
(* 8 *)
```
Number of ways to write 10 as sum of 4 squares:
```wolfram
SquaresR[4, 10]
(* 120 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SquaresR.html) for more details.
# SubresultantPolynomialRemainders
`SubresultantPolynomialRemainders[poly1, poly2, var]` gives the subresultant polynomial remainder sequence of the polynomials poly1 and poly2 with respect to the variable var.
* `SubresultantPolynomialRemainders[poly1, poly2, var, Modulus -> p]` computes the sequence modulo the prime p.
Examples [#examples]
```wolfram
SubresultantPolynomialRemainders[x^3 + x + 1, x^2 + 1, x]
```
```wolfram
SubresultantPolynomialRemainders[x^4 - 1, x^2 - 1, x]
```
```wolfram
SubresultantPolynomialRemainders[x^3 + 2 x + 1, x^2 + x, x, Modulus -> 5]
```
\*See the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SubresultantPolynomialRemainders.html) for more details.
# SubresultantPolynomials
`SubresultantPolynomials[poly1, poly2, var]` generates a list of subresultant polynomials of the polynomials poly1 and poly2 with respect to the variable var.
* `SubresultantPolynomials[poly1, poly2, var, Modulus -> p]` computes the subresultant polynomials modulo the prime p.
Examples [#examples]
```wolfram
SubresultantPolynomials[x^3 - 1, x^2 - 1, x]
```
```wolfram
SubresultantPolynomials[x^4 + x + 1, x^2 + 1, x]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SubresultantPolynomials.html) for more details.
# Subresultants
`Subresultants[poly1, poly2, var]` generates a list of the principal subresultant coefficients of the polynomials poly1 and poly2 with respect to the variable var.
* `Subresultants[poly1, poly2, var, Modulus -> p]` computes the principal subresultant coefficients modulo the prime p.
Examples [#examples]
```wolfram
Subresultants[x^3 + 2 x + 1, x^2 - 1, x]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Subresultants.html) for more details.
# SuzukiGroupSuz
`SuzukiGroupSuz[]` represents the sporadic simple Suzuki group Suz.
Examples [#examples]
```wolfram
SuzukiGroupSuz[]
```
```wolfram
GroupOrder[SuzukiGroupSuz[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SuzukiGroupSuz.html) for more details.
# Symmetric
`Symmetric[{s1, ..., sn}]` represents the symmetry of a tensor that is symmetric in the slots *si*.
Examples [#examples]
```wolfram
TensorSymmetry[{{a, b}, {b, c}}]
(* Symmetric[{1, 2}] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Symmetric.html) for more details.
# SymmetricDifference
`SymmetricDifference[list1, list2, ...]` gives the symmetric difference of the lists listi.
Examples [#examples]
Find elements in one list but not both:
```wolfram
SymmetricDifference[{1, 2, 3, 4}, {3, 4, 5, 6}]
```
With multiple lists:
```wolfram
SymmetricDifference[{a, b, c}, {b, c, d}, {c, d, e}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SymmetricDifference.html) for more details.
# SymmetricGroup
`SymmetricGroup[n]` represents the symmetric group of degree n.
Examples [#examples]
Get the order of the symmetric group S4:
```wolfram
GroupOrder[SymmetricGroup[4]]
(* 24 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SymmetricGroup.html) for more details.
# Symmetrize
`Symmetrize[tensor, sym]` returns the symmetrization of tensor under the symmetry sym.
Examples [#examples]
Symmetrize a matrix:
```wolfram
Symmetrize[{{a, b}, {c, d}}]
(* {{a, (b + c)/2}, {(b + c)/2, d}} *)
```
Antisymmetrize:
```wolfram
Symmetrize[{{a, b}, {c, d}}, Antisymmetric[{1, 2}]]
(* {{0, (b - c)/2}, {(-b + c)/2, 0}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Symmetrize.html) for more details.
# SymmetrizedArray
`SymmetrizedArray[{pos1 -> val1, pos2 -> val2, ...}, dims, sym]` yields an array of dimensions dims whose entries are given by those in the rules posi -> vali or through the symmetry sym.
* `SymmetrizedArray[list]` yields a symmetrized array version of list.
Examples [#examples]
```wolfram
SymmetrizedArray[{{1, 2} -> a, {2, 1} -> a}, {3, 3}, Symmetric[{1, 2}]]
```
```wolfram
SymmetrizedArray[{{1, 0}, {0, 1}}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SymmetrizedArray.html) for more details.
# SymmetrizedArrayRules
`SymmetrizedArrayRules[sa]` returns a list of rules posi -> vali of the symmetrized array sa.
* `SymmetrizedArrayRules[a, sym]` returns a list of rules posi -> vali of the array a after being symmetrized with symmetry sym.
Examples [#examples]
```wolfram
sa = SymmetrizedArray[{{1, 2} -> a, {2, 1} -> b}, {3, 3}, Symmetric[{1, 2}]];
SymmetrizedArrayRules[sa]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SymmetrizedArrayRules.html) for more details.
# SymmetrizedDependentComponents
`SymmetrizedDependentComponents[comp, sym]` gives the list of components that are equivalent to the component comp by the symmetry sym.
Examples [#examples]
Find equivalent components:
```wolfram
SymmetrizedDependentComponents[{1, 2}, Symmetric[{1, 2}]]
```
With antisymmetric tensors:
```wolfram
SymmetrizedDependentComponents[{1, 2}, Antisymmetric[{1, 2}]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SymmetrizedDependentComponents.html) for more details.
# SymmetrizedIndependentComponents
`SymmetrizedIndependentComponents[dims, sym]` gives the list of independent components of an array of dimensions *dims* with the symmetry *sym*.
Examples [#examples]
```wolfram
SymmetrizedIndependentComponents[{3, 3}, Symmetric[{1, 2}]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SymmetrizedIndependentComponents.html) for more details.
# SymmetrizedReplacePart
`SymmetrizedReplacePart[sa,{pos1->val1,pos2->val2,…}]` replaces independent values of the symmetrized array sa as given by the rules posi->vali.
Examples [#examples]
Replace a value in a symmetric array:
```wolfram
sa = SymmetrizedArray[{{1, 2} -> a, {2, 1} -> a}, {2, 2}, Symmetric[{1, 2}]];
SymmetrizedReplacePart[sa, {{1, 2} -> b}]
```
Modify an antisymmetric array:
```wolfram
asa = SymmetrizedArray[{{1, 2} -> x}, {3, 3}, Antisymmetric[{1, 2}]];
SymmetrizedReplacePart[asa, {{1, 3} -> y}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SymmetrizedReplacePart.html) for more details.
# ThompsonGroupTh
`ThompsonGroupTh[]` represents the sporadic simple Thompson group Th.
Examples [#examples]
Create the Thompson group:
```wolfram
ThompsonGroupTh[]
```
Get group order:
```wolfram
GroupOrder[ThompsonGroupTh[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ThompsonGroupTh.html) for more details.
# TitsGroupT
`TitsGroupT[]` represents the simple Tits group T.
Examples [#examples]
```wolfram
TitsGroupT[]
```
```wolfram
GroupOrder[TitsGroupT[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/TitsGroupT.html) for more details.
# ToFiniteField
`ToFiniteField[k,ff]` converts the integer k to an element of the prime subfield of the finite field ff.
`ToFiniteField[expr,ff]` converts the coefficients of the rational expression expr to elements of the finite field ff.
`ToFiniteField[expr,ff,t]` converts the coefficients of the rational expression expr to elements of the finite field ff, with t representing the field generator.
Examples [#examples]
Convert an integer to a finite field element:
```wolfram
ToFiniteField[5, GF[7]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ToFiniteField.html) for more details.
# ToNumberField
`ToNumberField[a, θ]` expresses the algebraic number a in the number field generated by θ.
* `ToNumberField[{a1, a2, ...}, θ]` expresses the ai in the field generated by θ.
* `ToNumberField[{a1, a2, ...}]` expresses the ai in a common extension field generated by a single algebraic number.
Examples [#examples]
```wolfram
ToNumberField[Sqrt[2], Sqrt[2]]
```
```wolfram
ToNumberField[{Sqrt[2], Sqrt[3]}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ToNumberField.html) for more details.
# Together
`Together[expr]` puts terms in a sum over a common denominator, and cancels factors in the result.
Examples [#examples]
Combine fractions:
```wolfram
Together[1/x + 1/y]
(* (x + y)/(x y) *)
```
```wolfram
Together[a/b + c/d]
(* (a d + b c)/(b d) *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Together.html) for more details.
# Variables
`Variables[poly]` gives a list of all independent variables in a polynomial.
Examples [#examples]
Find variables in polynomial:
```wolfram
Variables[x^2 + 3x*y + z]
(* {x, y, z} *)
```
Single variable expression:
```wolfram
Variables[a*t^2 + b*t + c]
(* {a, b, c, t} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Variables.html) for more details.
# ArcCurvature
`ArcCurvature[{x1, ..., xn}, t]` gives the curvature of the parametrized curve whose Cartesian coordinates xi are functions of t.
`ArcCurvature[{x1, ..., xn}, t, chart]` interprets the xi as coordinates in the specified coordinate chart.
Examples [#examples]
Find the curvature of a circle:
```wolfram
ArcCurvature[{Cos[t], Sin[t]}, t]
(* 1 *)
```
Curvature of a helix:
```wolfram
ArcCurvature[{Cos[t], Sin[t], t}, t]
(* 1/2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ArcCurvature.html) for more details.
# ArcLength
`ArcLength[reg]` gives the length of a one-dimensional region (curve).
Examples [#examples]
Length of a line:
```wolfram
ArcLength[Line[{{0, 0}, {3, 4}}]]
(* 5 *)
```
Circumference of a circle:
```wolfram
ArcLength[Circle[{0, 0}, r]]
(* 2 Pi r *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ArcLength.html) for more details.
# Area
`Area[reg]` gives the area of a two-dimensional region.
Examples [#examples]
Area of a disk:
```wolfram
Area[Disk[{0, 0}, r]]
(* Pi r^2 *)
```
Area of a polygon:
```wolfram
Area[Polygon[{{0, 0}, {1, 0}, {1, 1}, {0, 1}}]]
(* 1 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Area.html) for more details.
# ArgMax
`ArgMax[f, x]` gives a position xmax at which f is maximized.
`ArgMax[f, {x, y, ...}]` gives a position \{xmax, ymax, ...} at which f is maximized.
`ArgMax[{f, cons}, {x, y, ...}]` gives a position at which f is maximized subject to the constraints cons.
Examples [#examples]
Find where a function is maximized:
```wolfram
ArgMax[Sin[x], x]
(* Pi/2 *)
```
With constraints:
```wolfram
ArgMax[{x + y, x^2 + y^2 <= 1}, {x, y}]
(* {1/Sqrt[2], 1/Sqrt[2]} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ArgMax.html) for more details.
# ArgMin
`ArgMin[f, x]` gives a position xmin at which f is minimized.
`ArgMin[f, {x, y, ...}]` gives a position \{xmin, ymin, ...} at which f is minimized.
`ArgMin[{f, cons}, {x, y, ...}]` gives a position at which f is minimized subject to the constraints cons.
Examples [#examples]
Find where a function is minimized:
```wolfram
ArgMin[x^2 + 2x + 1, x]
(* -1 *)
```
With constraints:
```wolfram
ArgMin[{x^2 + y^2, x + y == 1}, {x, y}]
(* {1/2, 1/2} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ArgMin.html) for more details.
# Asymptotic
`Asymptotic[expr, x -> x0]` gives an asymptotic approximation for expr near x0.
`Asymptotic[expr, {x, x0, n}]` gives an asymptotic approximation for expr near x0 to order n.
Examples [#examples]
Asymptotic approximation near infinity:
```wolfram
Asymptotic[Sqrt[1 + 1/x], x -> Infinity]
(* 1 + 1/(2 x) *)
```
With specified order:
```wolfram
Asymptotic[Gamma[x], {x, Infinity, 2}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Asymptotic.html) for more details.
# AsymptoticDSolveValue
`AsymptoticDSolveValue[eqn, f, x -> x0]` computes an asymptotic approximation to the differential equation eqn for f\[x] centered at x0.
`AsymptoticDSolveValue[{eqn1, eqn2, ...}, {f1, f2, ...}, x -> x0]` computes an asymptotic approximation to a system of differential equations.
`AsymptoticDSolveValue[eqn, f, x, ε -> ε0]` computes an asymptotic approximation of f\[x, ε] for the parameter ε centered at ε0.
Examples [#examples]
Find asymptotic solution to a differential equation:
```wolfram
AsymptoticDSolveValue[y''[x] + y[x] == 0, y, x -> 0]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AsymptoticDSolveValue.html) for more details.
# AsymptoticEqual
`AsymptoticEqual[f, g, x -> x*]` gives conditions for f(x) ≍ g(x) or f(x) ∈ Θ(g(x)) as x -> x\*.
`AsymptoticEqual[f, g, {x1, ..., xn} -> {x1*, ..., xn*}]` gives conditions for the multivariate case.
Examples [#examples]
Test asymptotic equality:
```wolfram
AsymptoticEqual[x^2 + x, x^2, x -> Infinity]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AsymptoticEqual.html) for more details.
# AsymptoticEquivalent
`AsymptoticEquivalent[f, g, x -> x*]` gives conditions for f(x) \~ g(x) as x -> x\*.
`AsymptoticEquivalent[f, g, {x1, ..., xn} -> {x1*, ..., xn*}]` gives conditions for the multivariate case.
Examples [#examples]
Test asymptotic equivalence:
```wolfram
AsymptoticEquivalent[x^2 + x, x^2, x -> Infinity]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AsymptoticEquivalent.html) for more details.
# AsymptoticExpectation
`AsymptoticExpectation[expr, x \[Distributed] dist, a -> a0]` computes an asymptotic approximation for the expectation of expr centered at a0, under the assumption that x follows the probability distribution dist.
`AsymptoticExpectation[expr, vars, {a, a0, n}]` computes the asymptotic expectation to order n.
Examples [#examples]
Asymptotic expectation:
```wolfram
AsymptoticExpectation[x^2, x \[Distributed] NormalDistribution[a, 1],
a -> Infinity]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AsymptoticExpectation.html) for more details.
# AsymptoticGreater
`AsymptoticGreater[f, g, x -> x*]` gives conditions for f(x) ≻ g(x) or f(x) ∈ ω(g(x)) as x -> x\*.
`AsymptoticGreater[f, g, {x1, ..., xn} -> {x1*, ..., xn*}]` gives conditions for the multivariate case.
Examples [#examples]
Test if one function dominates another:
```wolfram
AsymptoticGreater[x^3, x^2, x -> Infinity]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AsymptoticGreater.html) for more details.
# AsymptoticGreaterEqual
`AsymptoticGreaterEqual[f, g, x->x*]` gives conditions for f(x)⪰g(x) or f(x)∈Ω(g(x)) as x->x\*.
`AsymptoticGreaterEqual[f, g, {x1, ..., xn}->{x1*, ..., xn*}]` gives conditions for f(x1,...,xn)⪰g(x1,...,xn) as \{x1,...,xn}->\{x1\*,...,xn\*}.
Examples [#examples]
Check asymptotic inequality:
```wolfram
AsymptoticGreaterEqual[x^2, x, x -> Infinity]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AsymptoticGreaterEqual.html) for more details.
# AsymptoticLess
`AsymptoticLess[f,g,x->x*]` gives conditions for f(x)≺g(x) or f(x)∈o(g(x)) as x->x\*.
`AsymptoticLess[f,g,{x1,…,xn}->{x1*,…,xn*}]` gives conditions for f(x1,…,xn)≺g(x1,…,xn) or f(x1,…,xn)∈o(g(x1,…,xn)) as \{x1,…,xn}->\{x1\*,…,xn\*}.
Examples [#examples]
Check if x grows slower than x^2 as x approaches infinity:
```wolfram
AsymptoticLess[x, x^2, x -> Infinity]
(* True *)
```
Compare growth rates:
```wolfram
AsymptoticLess[Log[x], x, x -> Infinity]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AsymptoticLess.html) for more details.
# AsymptoticLessEqual
`AsymptoticLessEqual[f, g, x -> x*]` gives conditions for f(x) ⪯ g(x) or f(x) ∈ O(g(x)) as x -> x\*.
`AsymptoticLessEqual[f, g, {x1, ..., xn} -> {x1*, ..., xn*}]` gives conditions for the multivariate case.
Examples [#examples]
Check big-O notation:
```wolfram
AsymptoticLessEqual[x + Log[x], x, x -> Infinity]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AsymptoticLessEqual.html) for more details.
# AsymptoticProbability
`AsymptoticProbability[pred, x \[Distributed] dist, a -> a0]` computes an asymptotic approximation for the probability of pred centered at a0, under the assumption that x follows the probability distribution dist.
`AsymptoticProbability[pred, vars, {a, a0, n}]` computes the asymptotic probability to order n.
Examples [#examples]
Asymptotic probability:
```wolfram
AsymptoticProbability[x > 0, x \[Distributed] NormalDistribution[a, 1],
a -> Infinity]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AsymptoticProbability.html) for more details.
# AsymptoticRSolveValue
`AsymptoticRSolveValue[eqn,f,x->∞]` computes an asymptotic approximation to the difference equation eqn for f\[x] near ∞.
`AsymptoticRSolveValue[{eqn1,eqn2,…},{f1,f2,…},x-> ∞]` computes an asymptotic approximation to a system of difference equations.
`AsymptoticRSolveValue[eqn,f,x,ϵ->ϵ0]` computes an asymptotic approximation of f\[x,ϵ] for the parameter ϵ centered at ϵ0.
`AsymptoticRSolveValue[eqn,f,…,{ξ,ξ0,n}]` computes the asymptotic approximation to order n.
Examples [#examples]
Find asymptotic solution to a recurrence:
```wolfram
AsymptoticRSolveValue[f[x + 1] == 2 f[x] + 1, f, x -> Infinity]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AsymptoticRSolveValue.html) for more details.
# AsymptoticSolve
`AsymptoticSolve[eqn, y -> b, x -> a]` computes asymptotic approximations of solutions y\[x] of the equation eqn passing through \{a, b}.
`AsymptoticSolve[eqn, {y}, x -> a]` computes asymptotic approximations of solutions y\[x] of the equation eqn for x near a.
`AsymptoticSolve[eqns, {y1, y2, ...} -> {b1, b2, ...}, {x1, x2, ...} -> {a1, a2, ...}]` computes asymptotic approximations for a system of equations.
Examples [#examples]
Find asymptotic solutions:
```wolfram
AsymptoticSolve[y^2 + x y + x^2 == 0, y -> 0, x -> 0]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/AsymptoticSolve.html) for more details.
# BilateralLaplaceTransform
`BilateralLaplaceTransform[expr, t, s]` gives the bilateral Laplace transform of expr.
`BilateralLaplaceTransform[expr, {t1, t2, ..., tn}, {s1, s2, ..., sn}]` gives the multidimensional bilateral Laplace transform of expr.
Examples [#examples]
Bilateral Laplace transform:
```wolfram
BilateralLaplaceTransform[Exp[-Abs[t]], t, s]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/BilateralLaplaceTransform.html) for more details.
# BilateralZTransform
`BilateralZTransform[expr,n,z]` gives the bilateral Z transform of expr.
`BilateralZTransform[expr,{n1,…,nk},{z1,…,zk}]` gives the multidimensional bilateral Z transform of expr.
Examples [#examples]
```wolfram
BilateralZTransform[n UnitStep[n], n, z]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/BilateralZTransform.html) for more details.
# CaputoD
`CaputoD[f, {x, α}]` gives the Caputo fractional differintegral of the function f(x).
Examples [#examples]
Caputo fractional derivative:
```wolfram
CaputoD[x^2, {x, 0.5}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/CaputoD.html) for more details.
# CirclePoints
`CirclePoints[n]` gives the positions of n points equally spaced around the unit circle.
`CirclePoints[r, n]` gives the positions of n points equally spaced around a circle of radius r.
`CirclePoints[{r, θ1}, n]` starts at angle θ1 with respect to the x axis.
Examples [#examples]
Points on a unit circle:
```wolfram
CirclePoints[6]
(* {{1, 0}, {1/2, Sqrt[3]/2}, ...} *)
```
Visualize circle points:
```wolfram
Graphics[Point[CirclePoints[12]]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/CirclePoints.html) for more details.
# CompleteIntegral
`CompleteIntegral[pde, u, {x1, ..., xn}]` gives a complete integral u for the first-order partial differential equation pde, with independent variables \{x1, ..., xn}.
Examples [#examples]
Find complete integral of a PDE:
```wolfram
CompleteIntegral[D[u[x, y], x] + D[u[x, y], y] == 1, u[x, y], {x, y}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/CompleteIntegral.html) for more details.
# ConicOptimization
`ConicOptimization[f, cons, vars]` finds values of variables vars that minimize the linear objective f subject to conic constraints cons.
`ConicOptimization[..., "prop"]` specifies what solution property "prop" should be returned.
Examples [#examples]
Solve a conic optimization problem:
```wolfram
ConicOptimization[x + y, {x^2 + y^2 <= 1}, {x, y}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ConicOptimization.html) for more details.
# ConservativeConvectionPDETerm
`ConservativeConvectionPDETerm[vars, α]` represents a conservative convection term ∇\{x1,…,xn}·(-α u) with conservative convection coefficient α and model variables vars.
`ConservativeConvectionPDETerm[vars, α, pars]` uses model parameters pars.
Examples [#examples]
```wolfram
ConservativeConvectionPDETerm[{u[x, y], {x, y}}, {{1, 0}, {0, 1}}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ConservativeConvectionPDETerm.html) for more details.
# ContourIntegrate
`ContourIntegrate[f, z ∈ cont]` gives the integral of f along the contour defined by cont in the complex plane.
Examples [#examples]
Integrate along a circle contour:
```wolfram
ContourIntegrate[1/z, z ∈ Circle[0, 1]]
(* 2 π I *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ContourIntegrate.html) for more details.
# ConvectionPDETerm
`ConvectionPDETerm[vars, β]` represents a convection term β·∇u with convection coefficient β and model variables vars.
`ConvectionPDETerm[vars, β, pars]` uses model parameters pars.
Examples [#examples]
```wolfram
ConvectionPDETerm[{u[x, y], {x, y}}, {1, 2}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ConvectionPDETerm.html) for more details.
# ConvexOptimization
`ConvexOptimization[f, cons, vars]` finds values of variables vars that minimize the convex objective function f subject to convex constraints cons.
`ConvexOptimization[..., "prop"]` specifies what solution property "prop" should be returned.
Examples [#examples]
Solve a convex optimization problem:
```wolfram
ConvexOptimization[x^2 + y^2, {x + y >= 1}, {x, y}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ConvexOptimization.html) for more details.
# Convolve
`Convolve[f, g, x, y]` gives the convolution of expressions f and g with respect to x.
Examples [#examples]
Convolve two functions:
```wolfram
Convolve[Exp[-x^2], Exp[-x^2], x, y]
(* Sqrt[Pi/2] E^(-y^2/2) *)
```
Box convolution:
```wolfram
Convolve[UnitBox[x], UnitBox[x], x, y]
(* UnitTriangle[y] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Convolve.html) for more details.
# Curl
`Curl[{f1, f2, f3}, {x1, x2, x3}]` gives the curl of a 3D vector field.
Examples [#examples]
Curl of a vector field:
```wolfram
Curl[{y, -x, 0}, {x, y, z}]
(* {0, 0, -2} *)
```
2D curl (scalar):
```wolfram
Curl[{-y, x}, {x, y}]
(* 2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Curl.html) for more details.
# D
`D[f, x]` gives the partial derivative of f with respect to x.
`D[f, {x, n}]` gives the nth derivative.
Examples [#examples]
First derivative:
```wolfram
D[x^3, x]
(* 3 x^2 *)
```
Second derivative:
```wolfram
D[Sin[x], {x, 2}]
(* -Sin[x] *)
```
Partial derivative:
```wolfram
D[x^2 y, x]
(* 2 x y *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/D.html) for more details.
# DEigensystem
`DEigensystem[ℒ[u[x, y, ...]], u, {x, y, ...} ∈ Ω, n]` gives the n smallest magnitude eigenvalues and eigenfunctions for the linear differential operator ℒ over the region Ω.
`DEigensystem[eqns, u, t, {x, y, ...} ∈ Ω, n]` gives the eigenvalues and eigenfunctions for solutions u of the time-dependent differential equations eqns.
Examples [#examples]
Find eigenvalues and eigenfunctions:
```wolfram
DEigensystem[-Laplacian[u[x, y], {x, y}], u, {x, y} ∈ Rectangle[], 3]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DEigensystem.html) for more details.
# DEigenvalues
`DEigenvalues[ℒ[u[x, y, ...]], u, {x, y, ...} ∈ Ω, n]` gives the n smallest magnitude eigenvalues for the linear differential operator ℒ over the region Ω.
`DEigenvalues[eqns, u, t, {x, y, ...} ∈ Ω, n]` gives the eigenvalues for solutions u of the time-dependent differential equations eqns.
Examples [#examples]
Find eigenvalues of a differential operator:
```wolfram
DEigenvalues[-Laplacian[u[x, y], {x, y}], u, {x, y} ∈ Disk[], 5]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DEigenvalues.html) for more details.
# DFixedPoints
`DFixedPoints[eqn, x[t], t]` gives the fixed points for a differential equation.
`DFixedPoints[{eqn1, eqn2, ...}, {x1[t], x2[t], ...}, t]` gives the fixed points for a system of differential equations.
Examples [#examples]
Find fixed points of a differential equation:
```wolfram
DFixedPoints[x'[t] == x[t] (1 - x[t]), x[t], t]
(* {0, 1} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DFixedPoints.html) for more details.
# DMSList
`DMSList[θ]` converts an angle θ given in decimal degrees to a DMS list \{degree, minute, second}.
`DMSList["dms"]` converts a DMS string to a DMS list \{degree, minute, second}.
`DMSList["latlon"]` converts a latitude-longitude string to a pair of DMS lists.
`DMSList[GeoPosition[...]]` converts `GeoPosition` data to a pair or array of pairs of DMS lists.
Examples [#examples]
Convert decimal degrees to DMS list:
```wolfram
DMSList[40.7128]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DMSList.html) for more details.
# DMSString
`DMSString[θ]` converts an angle θ given in decimal degrees to a degrees-minutes-seconds string.
`DMSString[{ϕ, λ}]` converts latitude and longitude given in decimal degrees to a DMS latitude-longitude string.
`DMSString[{d, m, s}]` converts a DMS list to a DMS string.
Examples [#examples]
Convert decimal degrees to DMS string:
```wolfram
DMSString[40.7128]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DMSString.html) for more details.
# DSolve
`DSolve[eqn, u, x]` solves a differential equation for the function u with independent variable x.
Examples [#examples]
Solve a first-order ODE:
```wolfram
DSolve[y'[x] == y[x], y, x]
(* {{y -> Function[{x}, E^x C[1]]}} *)
```
Solve with initial condition:
```wolfram
DSolve[{y'[x] == y[x], y[0] == 1}, y, x]
(* {{y -> Function[{x}, E^x]}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DSolve.html) for more details.
# DSolveChangeVariables
`DSolveChangeVariables[dsolve, u, t, trans]` changes the solution function in dsolve to u(t) using the transformation trans.
`DSolveChangeVariables[dsolve, {u1, u2, ...}, t, trans]` changes the solution functions in the system to \{u1(t), ..., un(t)}.
`DSolveChangeVariables[dsolve, u, {t1, ..., tn}, trans]` changes the solution function in the partial differential equation to u(t1, ..., tn).
Examples [#examples]
Change variables in a DSolve solution:
```wolfram
DSolveChangeVariables[DSolve[y'[x] == y[x], y, x], u, t, {y -> u, x -> t}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DSolveChangeVariables.html) for more details.
# DSolveValue
`DSolveValue[eqn, expr, x]` gives the value of expr determined by a symbolic solution to the differential equation.
Examples [#examples]
Solve ODE and get function:
```wolfram
DSolveValue[{y'[x] == y[x], y[0] == 1}, y[x], x]
(* E^x *)
```
Second order ODE:
```wolfram
DSolveValue[y''[x] + y[x] == 0, y[x], x]
(* C[1] Cos[x] + C[2] Sin[x] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DSolveValue.html) for more details.
# DStabilityConditions
`DStabilityConditions[eqn, x[t], t]` gives the fixed points and stability conditions for a differential equation.
`DStabilityConditions[{eqn1, eqn2, ...}, {x1[t], x2[t], ...}, t]` gives the fixed points and stability conditions for a system of differential equations.
`DStabilityConditions[{eqn1, eqn2, ...}, {x1[t], x2[t], ...}, t, {pnt1, pnt2, ...}]` gives the stability conditions for the given fixed points.
Examples [#examples]
Find stability conditions:
```wolfram
DStabilityConditions[x'[t] == x[t] (1 - x[t]), x[t], t]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DStabilityConditions.html) for more details.
# DamerauLevenshteinDistance
`DamerauLevenshteinDistance[u, v]` gives the Damerau–Levenshtein distance between strings or vectors u and v.
Examples [#examples]
Distance between strings:
```wolfram
DamerauLevenshteinDistance["hello", "hallo"]
(* 1 *)
```
With transposition:
```wolfram
DamerauLevenshteinDistance["ab", "ba"]
(* 1 *)
```
Compare to edit distance:
```wolfram
EditDistance["ab", "ba"]
(* 2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DamerauLevenshteinDistance.html) for more details.
# DataStructure
`DataStructure["type",data]` represents a data structure.
Examples [#examples]
Create a stack data structure:
```wolfram
DataStructure["Stack", {1, 2, 3}]
(* DataStructure["Stack", ...] *)
```
Create a hash map:
```wolfram
DataStructure["HashTable", {"a" -> 1, "b" -> 2}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DataStructure.html) for more details.
# DataStructureQ
`DataStructureQ[ds]` yields `True` if ds is a valid data structure and `False` otherwise.
`DataStructureQ[ds, type]` yields `True` if ds is a valid data structure of the specified type and `False` otherwise.
Examples [#examples]
Check if something is a data structure:
```wolfram
ds = CreateDataStructure["Stack"];
DataStructureQ[ds]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DataStructureQ.html) for more details.
# DayHemisphere
`DayHemisphere[]` is a two-dimensional GeoGraphics primitive that represents the half of the Earth that is currently in daylight.
`DayHemisphere[datespec]` represents the daylight half of the Earth for the specified date.
Examples [#examples]
Show the current daylight hemisphere:
```wolfram
GeoGraphics[DayHemisphere[]]
```
Show daylight for a specific date:
```wolfram
GeoGraphics[DayHemisphere[DateObject[{2024, 6, 21}]]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DayHemisphere.html) for more details.
# DayMatchQ
`DayMatchQ[date, daytype]` returns True if the date matches the daytype specification and returns False otherwise.
Examples [#examples]
Check if a date is a weekend:
```wolfram
DayMatchQ[{2024, 1, 6}, "Weekend"]
(* True - Saturday *)
```
Check if it's a business day:
```wolfram
DayMatchQ[{2024, 1, 5}, "BusinessDay"]
(* True - Friday *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DayMatchQ.html) for more details.
# DayNightTerminator
`DayNightTerminator[]` is a one-dimensional GeoGraphics primitive that represents the separation line between the halves of the Earth currently in daytime and nighttime.
`DayNightTerminator[datespec]` represents the separation line between day and night for the specified date.
Examples [#examples]
Show the day/night boundary:
```wolfram
GeoGraphics[{Red, DayNightTerminator[]}]
```
For a specific date:
```wolfram
GeoGraphics[DayNightTerminator[DateObject[{2024, 6, 21}]]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DayNightTerminator.html) for more details.
# Decompose
`Decompose[poly, x]` decomposes a polynomial, if possible, into a composition of simpler polynomials.
Examples [#examples]
Decompose a polynomial:
```wolfram
Decompose[x^4 + 2x^2 + 1, x]
(* {1 + x^2, x^2} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Decompose.html) for more details.
# Decrement
`x--` decreases the value of x by 1, returning the old value of x.
Examples [#examples]
Decrement a variable:
```wolfram
x = 5;
x--
(* 5 *)
x
(* 4 *)
```
In a loop:
```wolfram
i = 3;
While[i-- > 0, Print[i]]
(* prints 2, 1, 0 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Decrement.html) for more details.
# Del
`Del[x]` displays as ∇x.
Examples [#examples]
Display the del operator:
```wolfram
Del[f]
(* ∇f *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Del.html) for more details.
# DelimitedSequence
`DelimitedSequence[form]` represents a delimited sequence of elements of the specified form in Interpreter and related functions.
`DelimitedSequence[form,sep]` assumes a separator that matches sep.
`DelimitedSequence[form,{left,sep,right}]` assumes left and right delimiters matching left and right, respectively.
Examples [#examples]
Parse a comma-separated list of integers:
```wolfram
Interpreter[DelimitedSequence["Integer"]]["1, 2, 3, 4"]
(* {1, 2, 3, 4} *)
```
Use a custom separator:
```wolfram
Interpreter[DelimitedSequence["Word", ";"]]["apple;banana;cherry"]
(* {"apple", "banana", "cherry"} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DelimitedSequence.html) for more details.
# Denominator
`Denominator[expr]` gives the denominator of expr.
Examples [#examples]
Get the denominator of a fraction:
```wolfram
Denominator[3/4]
(* 4 *)
```
From a rational expression:
```wolfram
Denominator[(a + b)/(c + d)]
(* c + d *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Denominator.html) for more details.
# DensityGraphics
`DensityGraphics[array]` is a representation of a density plot.
Examples [#examples]
Create density graphics:
```wolfram
DensityGraphics[Table[Sin[x] Cos[y], {x, 0, 2Pi, 0.1}, {y, 0, 2Pi, 0.1}]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DensityGraphics.html) for more details.
# Derivative
`f'` represents the derivative of a function f of one argument.
`Derivative[n1, n2, ...][f]` represents a function obtained from f by differentiating n1 times with respect to the first argument, n2 times with respect to the second argument, and so on.
Examples [#examples]
First derivative:
```wolfram
f'[x]
(* f'[x] *)
```
Compute derivative of sine:
```wolfram
Sin'[x]
(* Cos[x] *)
```
Second derivative:
```wolfram
Derivative[2][f][x]
(* f''[x] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Derivative.html) for more details.
# DerivativeFilter
`DerivativeFilter[data, {n1, n2, ...}]` computes the nith derivative of data at level i.
`DerivativeFilter[data, {n1, n2, ...}, σ]` computes the derivative at a Gaussian scale of standard deviation σ.
`DerivativeFilter[data, {der1, der2, ...}, ...]` computes several derivatives der1, der2, ....
Examples [#examples]
Compute derivative of an image:
```wolfram
DerivativeFilter[image, {1, 0}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DerivativeFilter.html) for more details.
# DerivativePDETerm
`DerivativePDETerm[vars, γ]` represents a load derivative term ∇\{x1,...,xn}·(γ) with load derivative coefficient γ and model variables vars.
`DerivativePDETerm[vars, γ, pars]` uses model parameters pars.
Examples [#examples]
Create a derivative PDE term:
```wolfram
DerivativePDETerm[{x, y}, f[x, y]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DerivativePDETerm.html) for more details.
# DerivedKey
`DerivedKey[assoc]` represents a derived key generated by GenerateDerivedKey.
Examples [#examples]
```wolfram
key = GenerateDerivedKey["password"]
(* DerivedKey[...] *)
```
```wolfram
VerifyDerivedKey[key, "password"]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DerivedKey.html) for more details.
# DiagonalizableMatrixQ
`DiagonalizableMatrixQ[m]` gives True if m is diagonalizable, and False otherwise.
Examples [#examples]
```wolfram
DiagonalizableMatrixQ[{{1, 2}, {0, 3}}]
(* True *)
```
```wolfram
DiagonalizableMatrixQ[{{1, 1}, {0, 1}}]
(* False *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiagonalizableMatrixQ.html) for more details.
# DiceDissimilarity
`DiceDissimilarity[x,y]` gives the Dice dissimilarity between Boolean vectors x and y.
Examples [#examples]
```wolfram
DiceDissimilarity[{1, 0, 1, 1}, {0, 1, 1, 0}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiceDissimilarity.html) for more details.
# Diff
`Diff[first, second]` returns a representation of the diffs between first and second.
`Diff[first, second, format]` represents the diffs in the indicated format.
Examples [#examples]
```wolfram
Diff["hello world", "hello there"]
```
```wolfram
Diff[{1, 2, 3, 4}, {1, 3, 4, 5}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Diff.html) for more details.
# Diff3
`Diff3[ancestor, first, second]` returns a representation of the three-way diff between ancestor and two independently changed versions of ancestor.
`Diff3[ancestor, first, second, format]` represents the diffs in the indicated format.
Examples [#examples]
Three-way diff of strings:
```wolfram
Diff3["abc", "ab", "acd"]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Diff3.html) for more details.
# DiffApply
`DiffApply[diffobj, expr]` returns the result of applying the given `DiffObject` to the expression expr.
`DiffApply[diffobj, expr, File["file"]]` writes the result of changing expr to file.
Examples [#examples]
Apply a diff to an expression:
```wolfram
diff = Diff["abc", "aXc"];
DiffApply[diff, "abc"]
(* "aXc" *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiffApply.html) for more details.
# DifferenceQuotient
`DifferenceQuotient[f, {x, h}]` gives the difference quotient (f(x+h)-f(x))/h.
`DifferenceQuotient[f, {x, n, h}]` gives a multiple difference quotient with step h.
`DifferenceQuotient[f, {x1, n1, h1}, {x2, n2, h2}, ...]` computes the partial difference quotient.
Examples [#examples]
Simple difference quotient:
```wolfram
DifferenceQuotient[f[x], {x, h}]
(* (f[h + x] - f[x])/h *)
```
Second-order quotient:
```wolfram
DifferenceQuotient[x^2, {x, 2, h}]
(* 2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DifferenceQuotient.html) for more details.
# DifferenceRoot
`DifferenceRoot[lde][k]` gives the holonomic sequence h(k), specified by the linear difference equation lde\[h, k].
`DifferenceRoot[lde]` represents a pure holonomic sequence h.
Examples [#examples]
Define a sequence via difference equation:
```wolfram
DifferenceRoot[Function[{y, n}, {y[n + 2] == y[n + 1] + y[n], y[0] == 0, y[1] == 1}]][10]
(* 55 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DifferenceRoot.html) for more details.
# DifferenceRootReduce
`DifferenceRootReduce[expr,n]` attempts to reduce expr to a single DifferenceRoot object as a function of n.
Examples [#examples]
```wolfram
DifferenceRootReduce[Fibonacci[n], n]
(* DifferenceRoot[...] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DifferenceRootReduce.html) for more details.
# Differences
`Differences[list]` gives the successive differences between consecutive elements: `{e2-e1, e3-e2, ...}`.
Examples [#examples]
Compute differences:
```wolfram
Differences[{1, 4, 9, 16, 25}]
(* {3, 5, 7, 9} *)
(* Second differences *)
Differences[{1, 4, 9, 16, 25}, 2]
(* {2, 2, 2} *)
(* Inverse of Accumulate *)
Differences[Accumulate[{1, 2, 3, 4, 5}]]
(* {2, 3, 4, 5} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Differences.html) for more details.
# DifferentialD
`DifferentialD[x]` displays as dx, representing a differential.
Examples [#examples]
Display differential:
```wolfram
DifferentialD[x]
(* Displays as dx *)
```
In integrals:
```wolfram
Integrate[f[x], DifferentialD[x]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DifferentialD.html) for more details.
# DifferentialRoot
`DifferentialRoot[lde][x]` gives the holonomic function h(x), specified by the linear differential equation lde\[h, x].
`DifferentialRoot[lde]` represents a pure holonomic function h.
Examples [#examples]
```wolfram
DifferentialRoot[Function[{y, x}, {y''[x] + y[x] == 0, y[0] == 0, y'[0] == 1}]][x]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DifferentialRoot.html) for more details.
# DifferentialRootReduce
`DifferentialRootReduce[expr, x]` attempts to reduce expr to a single `DifferentialRoot` object as a function of x.
`DifferentialRootReduce[expr, {x, x0}]` takes the initial conditions to be specified at x=x0.
Examples [#examples]
Reduce a holonomic expression:
```wolfram
DifferentialRootReduce[Sin[x] + Cos[x], x]
(* DifferentialRoot[...] *)
```
With initial point:
```wolfram
DifferentialRootReduce[Exp[x], {x, 0}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DifferentialRootReduce.html) for more details.
# DifferentiatorFilter
`DifferentiatorFilter[data,ωc]` applies a differentiator filter with a cutoff frequency ωc to an array of data.
`DifferentiatorFilter[data,ωc,n]` uses a filter kernel of length n.
`DifferentiatorFilter[data,ωc,n,wfun]` applies a smoothing window wfun to the filter kernel.
Examples [#examples]
Apply a differentiator filter to data:
```wolfram
data = Table[Sin[x], {x, 0, 2 Pi, 0.1}];
DifferentiatorFilter[data, 0.5]
```
Use a specific kernel length:
```wolfram
DifferentiatorFilter[data, 0.5, 21]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DifferentiatorFilter.html) for more details.
# DiffusionPDETerm
`DiffusionPDETerm[vars]` represents a diffusion term ∇\{x1,…,xn}·(-∇\{x1,…,xn}u) with model variables vars.
`DiffusionPDETerm[vars,c]` represents a diffusion term ∇\{x1,…,xn}·(-c∇\{x1,…,xn}u) with diffusion coefficient c.
`DiffusionPDETerm[vars,c,pars]` uses model parameters pars.
Examples [#examples]
Create a diffusion term for a 2D problem:
```wolfram
DiffusionPDETerm[{u[x, y], {x, y}}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiffusionPDETerm.html) for more details.
# DigitCount
`DigitCount[n, b, d]` gives the number of d digits in the base-b representation of n.
`DigitCount[n, b]` gives a list of the numbers of 1, 2, ..., b-1, 0 digits in base b.
`DigitCount[n]` gives counts of 1, 2, ..., 9, 0 digits in base 10.
Examples [#examples]
Count 1s in binary:
```wolfram
DigitCount[255, 2, 1]
(* 8 *)
```
Digit frequency in base 10:
```wolfram
DigitCount[123456789]
(* {1, 1, 1, 1, 1, 1, 1, 1, 1, 0} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DigitCount.html) for more details.
# DigitSum
`DigitSum[n]` gives the sum of the decimal digits in the integer n.
`DigitSum[n, b]` gives the sum of the base b digits in the integer n.
`DigitSum[n, b, k]` gives the sum of the first k base b digits in the integer n.
`DigitSum[n, b, -k]` gives the sum of the last k base b digits in the integer n.
Examples [#examples]
Sum digits of a number:
```wolfram
DigitSum[12345]
(* 15 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DigitSum.html) for more details.
# DimensionReduction
`DimensionReduction[{example1,example2,…}]` generates a `DimensionReducerFunction[…]` that projects from the space defined by the examplei to a lower-dimensional approximating manifold.
`DimensionReduction[examples,n]` generates a `DimensionReducerFunction[…]` for an n-dimensional approximating manifold.
`DimensionReduction[examples,n,props]` generates the specified properties of the dimensionality reduction.
Examples [#examples]
Reduce dimensionality of data:
```wolfram
data = RandomReal[1, {100, 10}];
reducer = DimensionReduction[data, 2]
(* DimensionReducerFunction[...] *)
```
Apply the reducer:
```wolfram
reducer[data[[1]]]
(* {0.123, 0.456} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DimensionReduction.html) for more details.
# DimensionalCombinations
`DimensionalCombinations[{pq1, pq2, ...}]` returns possible combinations of physical quantities that are dimensionless.
`DimensionalCombinations[{pq1, pq2, ...}, dim]` returns combinations matching dimensions of dim.
Examples [#examples]
Find dimensionless combinations:
```wolfram
DimensionalCombinations[{Quantity["Length"], Quantity["Time"], Quantity["Speed"]}]
```
Match specific dimensions:
```wolfram
DimensionalCombinations[{Quantity["Mass"], Quantity["Speed"]}, Quantity["Energy"]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DimensionalCombinations.html) for more details.
# DimensionalMeshComponents
`DimensionalMeshComponents[mr]` gives a list \{r0,r1,…} of regions such that rd has dimension d for a mesh region mr.
Examples [#examples]
Get components of different dimensions:
```wolfram
mesh = BoundaryMeshRegion[{{0,0},{1,0},{1,1},{0,1}}, Line[{1,2,3,4,1}]];
DimensionalMeshComponents[mesh]
```
Extract 1D components:
```wolfram
DimensionalMeshComponents[mesh][[2]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DimensionalMeshComponents.html) for more details.
# DiracComb
`DiracComb[x]` represents the Dirac comb function giving a delta function at every integer point.
`DiracComb[x1, x2, ...]` represents the multidimensional Dirac comb function.
Examples [#examples]
Fourier transform of Dirac comb:
```wolfram
FourierTransform[DiracComb[x], x, k]
```
Sampling with DiracComb:
```wolfram
DiracComb[x] Sin[2 Pi x]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiracComb.html) for more details.
# DiracDelta
`DiracDelta[x]` represents the Dirac delta function δ(x).
`DiracDelta[x1,x2,…]` represents the multidimensional Dirac delta function δ(x1,x2,…).
Examples [#examples]
Integrate a function with DiracDelta:
```wolfram
Integrate[f[x] DiracDelta[x - a], {x, -Infinity, Infinity}]
(* f[a] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiracDelta.html) for more details.
# DirectedEdge
`DirectedEdge[u, v]` or `u -> v` represents a directed edge from u to v.
Examples [#examples]
Create directed edges:
```wolfram
DirectedEdge[1, 2]
(* 1 \[DirectedEdge] 2 *)
```
Build a directed graph:
```wolfram
Graph[{DirectedEdge[1, 2], DirectedEdge[2, 3]}]
(* same as Graph[{1 -> 2, 2 -> 3}] *)
```
With tags:
```wolfram
DirectedEdge["A", "B", "route1"]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DirectedEdge.html) for more details.
# DirichletCharacter
`DirichletCharacter[k, j, n]` gives the Dirichlet character χk,j(n) with modulus k and index j.
Examples [#examples]
Compute a Dirichlet character:
```wolfram
DirichletCharacter[5, 2, 3]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DirichletCharacter.html) for more details.
# DirichletCondition
`DirichletCondition[beqn, pred]` represents a Dirichlet boundary condition given by equation beqn, satisfied on the part of the boundary of the region given to `NDSolve` and related functions where pred is `True`.
Examples [#examples]
Set a Dirichlet boundary condition:
```wolfram
DirichletCondition[u[x, y] == 0, x == 0]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DirichletCondition.html) for more details.
# DirichletConvolve
`DirichletConvolve[f, g, n, m]` gives the Dirichlet convolution of expressions f and g.
Examples [#examples]
Convolve arithmetic functions:
```wolfram
DirichletConvolve[1, MoebiusMu[n], n, m]
(* DiscreteDelta[m - 1] *)
```
Identity convolution:
```wolfram
DirichletConvolve[f[n], DiscreteDelta[n - 1], n, m]
(* f[m] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DirichletConvolve.html) for more details.
# DirichletTransform
`DirichletTransform[expr, n, s]` gives the Dirichlet transform of expr with respect to n.
Examples [#examples]
Transform of a constant:
```wolfram
DirichletTransform[1, n, s]
(* Zeta[s] *)
```
Transform of n^k:
```wolfram
DirichletTransform[n^2, n, s]
(* Zeta[s - 2] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DirichletTransform.html) for more details.
# DiscreteAsymptotic
`DiscreteAsymptotic[expr, n -> ∞]` gives an asymptotic approximation for expr as n tends to infinity over the integers.
`DiscreteAsymptotic[expr, {n, ∞, m}]` gives an asymptotic series approximation for expr to order m.
Examples [#examples]
Find discrete asymptotic:
```wolfram
DiscreteAsymptotic[n!, n -> Infinity]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiscreteAsymptotic.html) for more details.
# DiscreteChirpZTransform
`DiscreteChirpZTransform[list]` gives the chirp Z transform of list.
`DiscreteChirpZTransform[list, n]` returns a length n chirp Z transform.
`DiscreteChirpZTransform[list, n, w]` uses a spiral path on the complex z plane defined by w.
`DiscreteChirpZTransform[list, n, w, a]` uses a as the complex starting point.
Examples [#examples]
Compute chirp Z transform:
```wolfram
DiscreteChirpZTransform[{1, 2, 3, 4}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiscreteChirpZTransform.html) for more details.
# DiscreteConvolve
`DiscreteConvolve[f, g, n, m]` gives the convolution with respect to n of the expressions f and g.
`DiscreteConvolve[f, g, {n1, n2, ...}, {m1, m2, ...}]` gives the multidimensional convolution.
Examples [#examples]
Convolve two sequences:
```wolfram
DiscreteConvolve[UnitStep[n], UnitStep[n], n, m]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiscreteConvolve.html) for more details.
# DiscreteDelta
`DiscreteDelta[n1, n2, ...]` gives the discrete delta function δ(n1, n2, ...), equal to 1 if all ni are zero, and 0 otherwise.
Examples [#examples]
Single argument:
```wolfram
DiscreteDelta[0]
(* 1 *)
DiscreteDelta[5]
(* 0 *)
```
Multiple arguments:
```wolfram
DiscreteDelta[0, 0, 0]
(* 1 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiscreteDelta.html) for more details.
# DiscreteHadamardTransform
`DiscreteHadamardTransform[list]` gives the discrete Hadamard transform of list.
Examples [#examples]
Compute the discrete Hadamard transform of a list:
```wolfram
DiscreteHadamardTransform[{1, 2, 3, 4}]
(* {5, -1, -2, 0} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiscreteHadamardTransform.html) for more details.
# DiscreteIndicator
`DiscreteIndicator[x, x1, {u1, u2, ...}]` yields the discrete indicator function, equal to 1 if x=x1 and, otherwise, to 0 if x=ui for some i.
Examples [#examples]
```wolfram
DiscreteIndicator[a, a, {a, b, c}]
(* 1 *)
```
```wolfram
DiscreteIndicator[b, a, {a, b, c}]
(* 0 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiscreteIndicator.html) for more details.
# DiscreteRatio
`DiscreteRatio[f, i]` gives the discrete ratio f(i+1)/f(i).
`DiscreteRatio[f, {i, n}]` gives the multiple discrete ratio.
`DiscreteRatio[f, {i, n, h}]` gives the multiple discrete ratio with step h.
Examples [#examples]
Basic ratio:
```wolfram
DiscreteRatio[f[i], i]
(* f[1 + i]/f[i] *)
```
Factorial ratio:
```wolfram
DiscreteRatio[i!, i]
(* 1 + i *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DiscreteRatio.html) for more details.
# DisjointQ
`DisjointQ[list1, list2]` yields `True` if list1 and list2 do not share any common elements, and `False` otherwise.
Examples [#examples]
Test disjoint lists:
```wolfram
DisjointQ[{1, 2, 3}, {4, 5, 6}]
(* True *)
```
Lists with common elements:
```wolfram
DisjointQ[{1, 2, 3}, {3, 4, 5}]
(* False *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DisjointQ.html) for more details.
# Disjunction
`Disjunction[expr, {a1, a2, ...}]` gives the disjunction of expr over all choices of the Boolean variables ai.
Examples [#examples]
Disjunction over Boolean variables:
```wolfram
Disjunction[a && b, {a, b}]
(* a || b *)
```
Expand logical expression:
```wolfram
Disjunction[a || b, {a}]
(* True *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Disjunction.html) for more details.
# Div
`Div[{f1, ..., fn}, {x1, ..., xn}]` gives the divergence ∂f1/∂x1 + ... + ∂fn/∂xn.
Examples [#examples]
Divergence of a vector field:
```wolfram
Div[{x^2, y^2, z^2}, {x, y, z}]
(* 2x + 2y + 2z *)
```
2D divergence:
```wolfram
Div[{x, y}, {x, y}]
(* 2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Div.html) for more details.
# Divisible
`Divisible[n, m]` yields `True` if n is divisible by m, and `False` otherwise.
Examples [#examples]
Check divisibility:
```wolfram
Divisible[12, 4]
(* True *)
```
```wolfram
Divisible[13, 4]
(* False *)
```
Filter divisible numbers:
```wolfram
Select[Range[20], Divisible[#, 3] &]
(* {3, 6, 9, 12, 15, 18} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Divisible.html) for more details.
# DualPlanarGraph
`DualPlanarGraph[g]` gives the dual of the planar graph g.
Examples [#examples]
Get the dual of a planar graph:
```wolfram
DualPlanarGraph[GridGraph[{3, 3}]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DualPlanarGraph.html) for more details.
# DualPolyhedron
`DualPolyhedron[poly]` gives the dual polyhedron of the polyhedron poly.
Examples [#examples]
Get the dual of a cube (octahedron):
```wolfram
DualPolyhedron[PolyhedronData["Cube", "Polyhedron"]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DualPolyhedron.html) for more details.
# DumpGet
`DumpGet["filename"]` reads in a file saved with `DumpSave`.
Examples [#examples]
Load a previously saved dump file:
```wolfram
DumpGet["mydata.mx"]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/DumpGet.html) for more details.
# Duration
`Duration[expr]` returns the duration of expr.
`Duration[expr, unit]` returns the result in the specified unit.
Examples [#examples]
Get the duration of an audio object:
```wolfram
audio = ExampleData[{"Audio", "Apollo11SmallStep"}];
Duration[audio]
(* 5.4 seconds *)
```
Get duration in a specific unit:
```wolfram
Duration[audio, "Milliseconds"]
(* 5400. *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Duration.html) for more details.
# ElectricCurrentPDEComponent
`ElectricCurrentPDEComponent[vars,pars]` yields an electric current PDE term with variables vars and parameters pars.
Examples [#examples]
Create an electric current PDE component:
```wolfram
ElectricCurrentPDEComponent[{V[x, y], {x, y}}, <|"ElectricConductivity" -> 1|>]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ElectricCurrentPDEComponent.html) for more details.
# ElectrostaticPDEComponent
`ElectrostaticPDEComponent[vars, pars]` yields an electrostatic PDE term with variables vars and parameters pars.
Examples [#examples]
Create electrostatic PDE component:
```wolfram
ElectrostaticPDEComponent[{V[x, y], {x, y}}, <|"Permittivity" -> 1|>]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ElectrostaticPDEComponent.html) for more details.
# Element
`Element[x, dom]` or `x ∈ dom` asserts that x is an element of the domain dom.
`Element[x, reg]` asserts that x is an element of the region reg.
Examples [#examples]
Assert integer domain:
```wolfram
Simplify[Sin[n Pi], Element[n, Integers]]
(* 0 *)
```
Real assumption:
```wolfram
Integrate[1/(1 + x^2), {x, -Infinity, Infinity}, Assumptions -> Element[x, Reals]]
(* Pi *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Element.html) for more details.
# FindArgMax
`FindArgMax[f,x]` gives the position xmax of a local maximum of f.
* `FindArgMax[f,{x,x0}]` gives the position xmax of a local maximum of f, found by a search starting from the point x=x0.
* `FindArgMax[f,{{x,x0},{y,y0},…}]` gives the position \{xmax,ymax,…} of a local maximum of a function of several variables.
* `FindArgMax[{f,cons},{{x,x0},{y,y0},…}]` gives the position of a local maximum subject to the constraints cons.
* `FindArgMax[{f,cons},{x,y,…}]` starts from a point within the region defined by the constraints.
Examples [#examples]
```wolfram
(* Find the position of maximum *)
FindArgMax[Sin[x] Exp[-x^2], x]
(* Start from a specific point *)
FindArgMax[x^4 - 3x^2 + x, {x, 1}]
(* Multivariate function *)
FindArgMax[-(x^2 + y^2), {{x, 1}, {y, 1}}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FindArgMax.html) for more details.
# FindArgMin
`FindArgMin[f,x]` gives the position xmin of a local minimum of f.
* `FindArgMin[f,{x,x0}]` gives the position xmin of a local minimum of f, found by a search starting from the point x=x0.
* `FindArgMin[f,{{x,x0},{y,y0},…}]` gives the position \{xmin,ymin,…} of a local minimum of a function of several variables.
* `FindArgMin[{f,cons},{{x,x0},{y,y0},…}]` gives the position of a local minimum subject to the constraints cons.
* `FindArgMin[{f,cons},{x,y,…}]` starts from a point within the region defined by the constraints.
Examples [#examples]
```wolfram
(* Find the position of minimum *)
FindArgMin[x^2 + 2x + 1, x]
(* Start from a specific point *)
FindArgMin[x^4 - 3x^2 + x, {x, 0}]
(* Multivariate function *)
FindArgMin[(x - 1)^2 + (y - 2)^2, {{x, 0}, {y, 0}}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FindArgMin.html) for more details.
# FindMaxValue
`FindMaxValue[f,x]` gives the value at a local maximum of f.
* `FindMaxValue[f,{x,x0}]` gives the value at a local maximum of f, found by a search starting from the point x=x0.
* `FindMaxValue[f,{{x,x0},{y,y0},…}]` gives the value at a local maximum of a function of several variables.
* `FindMaxValue[{f,cons},{{x,x0},{y,y0},…}]` gives the value at a local maximum subject to the constraints cons.
* `FindMaxValue[{f,cons},{x,y,…}]` starts from a point within the region defined by the constraints.
Examples [#examples]
```wolfram
(* Find the maximum value *)
FindMaxValue[Sin[x] Exp[-x^2], x]
(* Start from a specific point *)
FindMaxValue[x^4 - 3x^2 + x, {x, 1}]
(* Multivariate maximum *)
FindMaxValue[-(x^2 + y^2), {{x, 1}, {y, 1}}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FindMaxValue.html) for more details.
# FindMaximum
`FindMaximum[f, {x, x0}]` searches for a local maximum in f, starting from the point x=x0.
Examples [#examples]
Find local maximum:
```wolfram
FindMaximum[-x^2 + 4x + 5, {x, 0}]
(* {9., {x -> 2.}} *)
```
With constraints:
```wolfram
FindMaximum[{x + y, x^2 + y^2 <= 1}, {{x, 0.5}, {y, 0.5}}]
(* {1.414, {x -> 0.707, y -> 0.707}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FindMaximum.html) for more details.
# FindMaximumCut
`FindMaximumCut[g]` gives the maximum cut of the graph g.
Examples [#examples]
Find the maximum cut of a graph:
```wolfram
FindMaximumCut[CycleGraph[5]]
(* {{1, 3}, {2, 4, 5}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FindMaximumCut.html) for more details.
# FindMinValue
`FindMinValue[f,x]` gives the value at a local minimum of f.
* `FindMinValue[f,{x,x0}]` gives the value at a local minimum of f, found by a search starting from the point x=x0.
* `FindMinValue[f,{{x,x0},{y,y0},…}]` gives the value at a local minimum of a function of several variables.
* `FindMinValue[{f,cons},{{x,x0},{y,y0},…}]` gives the value at a local minimum subject to the constraints cons.
* `FindMinValue[{f,cons},{x,y,…}]` starts from a point within the region defined by the constraints.
Examples [#examples]
```wolfram
(* Find the minimum value *)
FindMinValue[x^2 + 2x + 1, x]
(* Start from a specific point *)
FindMinValue[x^4 - 3x^2 + x, {x, 0}]
(* Multivariate minimum *)
FindMinValue[(x - 1)^2 + (y - 2)^2, {{x, 0}, {y, 0}}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FindMinValue.html) for more details.
# FindMinimum
`FindMinimum[f, {x, x0}]` searches for a local minimum in f, starting from the point x=x0.
Examples [#examples]
Find local minimum:
```wolfram
FindMinimum[x^2 - 4x + 5, {x, 0}]
(* {1., {x -> 2.}} *)
```
Multivariable:
```wolfram
FindMinimum[x^2 + y^2 + x*y, {{x, 1}, {y, 1}}]
(* {0., {x -> 0., y -> 0.}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FindMinimum.html) for more details.
# FindMinimumCostFlow
`FindMinimumCostFlow[g,{sd1,sd2,…}]` finds the minimum cost flow in the graph g with sd1, sd2, … vertex supplies or demands.
* `FindMinimumCostFlow[g,s,t]` finds the minimum cost maximum flow between source vertex s and target vertex t in a graph g.
* `FindMinimumCostFlow[g,s,t,d]` finds the minimum cost flow between source s and target t, with the required flow d.
* `FindMinimumCostFlow[m,…]` finds the minimum cost flow in a graph with cost matrix m.
* `FindMinimumCostFlow[data,…,"property"]` returns the value of "property".
* `FindMinimumCostFlow[{v->w,…},…]` uses rules v->w to specify the graph g.
Examples [#examples]
```wolfram
(* Find minimum cost flow *)
g = Graph[{1 -> 2, 2 -> 3, 1 -> 3},
EdgeWeight -> {1, 2, 4}, EdgeCapacity -> {5, 3, 2}];
FindMinimumCostFlow[g, 1, 3]
(* Get the cost *)
FindMinimumCostFlow[g, 1, 3, "Cost"]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FindMinimumCostFlow.html) for more details.
# FluidFlowPDEComponent
`FluidFlowPDEComponent[vars,pars]` yields a flow PDE term with variables vars and parameters pars.
Examples [#examples]
```wolfram
FluidFlowPDEComponent[{u[x, y], v[x, y], p[x, y]}, {x, y}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FluidFlowPDEComponent.html) for more details.
# Fourier
`Fourier[list]` finds the discrete Fourier transform of a list of complex numbers.
Examples [#examples]
DFT of a simple signal:
```wolfram
Fourier[{1, 1, 1, 1, 0, 0, 0, 0}]
(* {1.41421, 0.5 + 0.5 I, 0, 0.5 - 0.5 I, 0, ...} *)
```
Sinusoidal signal:
```wolfram
data = Table[Sin[2 Pi k / 8], {k, 0, 7}];
Abs[Fourier[data]]
(* {0, 0, 1.41, 0, 0, 0, 1.41, 0} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Fourier.html) for more details.
# FourierCoefficient
`FourierCoefficient[expr, t, n]` gives the nth coefficient in the Fourier series expansion of expr.
* `FourierCoefficient[expr, {t1, t2, ...}, {n1, n2, ...}]` gives a multidimensional Fourier coefficient.
Examples [#examples]
Compute the 3rd Fourier coefficient:
```wolfram
FourierCoefficient[Cos[3 t], t, 3]
```
Get Fourier coefficients for a square wave:
```wolfram
FourierCoefficient[SquareWave[t], t, 1]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FourierCoefficient.html) for more details.
# FourierCosCoefficient
`FourierCosCoefficient[expr,t,n]` gives the nth coefficient in the Fourier cosine series expansion of expr.
`FourierCosCoefficient[expr,{t1,t2,…},{n1,n2,…}]` gives a multidimensional Fourier cosine coefficient.
Examples [#examples]
Find the first Fourier cosine coefficient:
```wolfram
FourierCosCoefficient[t^2, t, 1]
(* -4/Pi^2 *)
```
Compute higher-order coefficients:
```wolfram
FourierCosCoefficient[Sin[t]^2, t, 2]
(* -1/2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FourierCosCoefficient.html) for more details.
# FourierCosSeries
`FourierCosSeries[expr,t,n]` gives the nth-order Fourier cosine series expansion of expr in t.
`FourierCosSeries[expr,{t1,t2,…},{n1,n2,…}]` gives the multidimensional Fourier cosine series of expr.
Examples [#examples]
Compute a 3rd-order Fourier cosine series:
```wolfram
FourierCosSeries[t^2, t, 3]
(* Pi^2/3 - 4 Cos[t] + Cos[2 t] - 4/9 Cos[3 t] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FourierCosSeries.html) for more details.
# FourierCosTransform
`FourierCosTransform[expr, t, ω]` gives the symbolic Fourier cosine transform of expr.
* `FourierCosTransform[expr, {t1, t2, ...}, {ω1, ω2, ...}]` gives the multidimensional Fourier cosine transform of expr.
Examples [#examples]
Compute the Fourier cosine transform:
```wolfram
FourierCosTransform[Exp[-t^2], t, ω]
```
Transform a Gaussian function:
```wolfram
FourierCosTransform[Exp[-a t] UnitStep[t], t, ω, Assumptions -> a > 0]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FourierCosTransform.html) for more details.
# FourierSequenceTransform
`FourierSequenceTransform[expr,n,ω]` gives the Fourier sequence transform of expr.
`FourierSequenceTransform[expr,{n1,n2,…},{ω1,ω2,…}]` gives the multidimensional Fourier sequence transform.
Examples [#examples]
Compute the Fourier sequence transform:
```wolfram
FourierSequenceTransform[a^n, n, ω]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FourierSequenceTransform.html) for more details.
# FourierSeries
`FourierSeries[expr, t, n]` gives the nth-order Fourier series expansion of expr in t.
`FourierSeries[expr, {t1, t2, …}, {n1, n2, …}]` gives the multidimensional Fourier series.
Examples [#examples]
Compute a Fourier series:
```wolfram
FourierSeries[t, t, 3]
```
Fourier series of a square wave:
```wolfram
FourierSeries[Sign[Sin[t]], t, 5]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FourierSeries.html) for more details.
# FourierSinCoefficient
`FourierSinCoefficient[expr, t, n]` gives the nth coefficient in the Fourier sine series expansion of expr.
* `FourierSinCoefficient[expr, {t1, t2, ...}, {n1, n2, ...}]` gives a multidimensional Fourier sine coefficient.
Examples [#examples]
Compute the Fourier sine coefficient:
```wolfram
FourierSinCoefficient[Sin[3 t], t, 3]
```
Get coefficients for a sawtooth wave:
```wolfram
FourierSinCoefficient[t, t, n]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FourierSinCoefficient.html) for more details.
# FourierSinSeries
`FourierSinSeries[expr, t, n]` gives the nth-order Fourier sine series expansion of expr in t.
* `FourierSinSeries[expr, {t1, t2, ...}, {n1, n2, ...}]` gives the multidimensional Fourier sine series of expr.
Examples [#examples]
Compute a Fourier sine series:
```wolfram
FourierSinSeries[t, t, 5]
```
Expand a function as a sine series:
```wolfram
FourierSinSeries[t (Pi - t), t, 3]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FourierSinSeries.html) for more details.
# FourierSinTransform
`FourierSinTransform[expr, t, ω]` gives the symbolic Fourier sine transform of expr.
* `FourierSinTransform[expr, {t1, t2, ...}, {ω1, ω2, ...}]` gives the multidimensional Fourier sine transform of expr.
Examples [#examples]
Compute the Fourier sine transform:
```wolfram
FourierSinTransform[Exp[-t^2], t, ω]
```
Transform an exponential function:
```wolfram
FourierSinTransform[Exp[-a t], t, ω, Assumptions -> a > 0]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FourierSinTransform.html) for more details.
# FourierTransform
`FourierTransform[expr, t, ω]` gives the symbolic Fourier transform of expr.
Examples [#examples]
Fourier transform of a Gaussian:
```wolfram
FourierTransform[Exp[-t^2], t, ω]
(* E^(-ω^2/4)/Sqrt[2] *)
```
Rectangular function:
```wolfram
FourierTransform[UnitBox[t], t, ω]
(* Sinc[ω/2]/Sqrt[2 Pi] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FourierTransform.html) for more details.
# FourierTrigSeries
`FourierTrigSeries[expr, t, n]` gives the nth-order Fourier trigonometric series expansion of expr in t.
* `FourierTrigSeries[expr, {t1, t2, ...}, {n1, n2, ...}]` gives the multidimensional Fourier trigonometric series of expr.
Examples [#examples]
Compute a Fourier trigonometric series:
```wolfram
FourierTrigSeries[t^2, t, 3]
```
Expand a periodic function:
```wolfram
FourierTrigSeries[SquareWave[t], t, 5]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FourierTrigSeries.html) for more details.
# FrobeniusSolve
`FrobeniusSolve[{a1, ..., an}, b]` gives a list of all solutions of the Frobenius equation a1*x1 + ... + an*xn = b.
* `FrobeniusSolve[{a1, ..., an}, b, m]` gives at most m solutions.
Examples [#examples]
Find all ways to make 10 using 3 and 5:
```wolfram
FrobeniusSolve[{3, 5}, 10]
```
Find at most 3 solutions:
```wolfram
FrobeniusSolve[{2, 3, 5}, 15, 3]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FrobeniusSolve.html) for more details.
# FromPolarCoordinates
`FromPolarCoordinates[{r,θ}]` gives the \{x,y} Cartesian coordinates corresponding to the polar coordinates \{r,θ}.
`FromPolarCoordinates[{r,θ1,…,θn-2,ϕ}]` gives the coordinates corresponding to the hyperspherical coordinates \{r,θ1,…,θn-2,ϕ}.
Examples [#examples]
Convert polar to Cartesian coordinates:
```wolfram
FromPolarCoordinates[{1, Pi/4}]
(* {1/Sqrt[2], 1/Sqrt[2]} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FromPolarCoordinates.html) for more details.
# FromSphericalCoordinates
`FromSphericalCoordinates[{r, θ, ϕ}]` gives the \{x, y, z} Cartesian coordinates corresponding to the spherical coordinates \{r, θ, ϕ}.
Examples [#examples]
Convert spherical to Cartesian coordinates:
```wolfram
FromSphericalCoordinates[{1, Pi/4, Pi/3}]
```
Convert a unit vector:
```wolfram
FromSphericalCoordinates[{1, Pi/2, 0}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/FromSphericalCoordinates.html) for more details.
# Grad
`Grad[f, {x1, ..., xn}]` gives the gradient (∂f/∂x1, ..., ∂f/∂xn).
Examples [#examples]
Gradient of a scalar field:
```wolfram
Grad[x^2 + y^2 + z^2, {x, y, z}]
(* {2x, 2y, 2z} *)
```
2D gradient:
```wolfram
Grad[x*y, {x, y}]
(* {y, x} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Grad.html) for more details.
# GradientFilter
`GradientFilter[data, r]` gives the magnitude of the gradient of `data`, computed using discrete derivatives of a Gaussian of sample radius `r`.
* `GradientFilter[data, {r, σ}]` uses a Gaussian with standard deviation `σ`.
* `GradientFilter[data, {{r1, r2, …}, …}]` uses a Gaussian with radius `ri` at level `i` in `data`.
Examples [#examples]
```wolfram
GradientFilter[ExampleData[{"TestImage", "Lena"}], 2]
```
```wolfram
GradientFilter[image, 3]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GradientFilter.html) for more details.
# GradientFittedMesh
`GradientFittedMesh[{p1,p2,…}]` gives a MeshRegion whose gradient best fits the normals at points p1,p2,….
Examples [#examples]
```wolfram
GradientFittedMesh[{{0, 0, 0}, {1, 0, 1}, {0, 1, 0}}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GradientFittedMesh.html) for more details.
# GradientOrientationFilter
`GradientOrientationFilter[data, r]` gives the local orientation parallel to the gradient of `data`, computed using discrete derivatives of a Gaussian of pixel radius `r`, returning values between -π/2 and π/2.
* `GradientOrientationFilter[data, {r, σ}]` uses a Gaussian with standard deviation `σ`.
Examples [#examples]
```wolfram
GradientOrientationFilter[ExampleData[{"TestImage", "Lena"}], 2]
```
```wolfram
GradientOrientationFilter[image, 5]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GradientOrientationFilter.html) for more details.
# GreenFunction
`GreenFunction[{ℒ[u[x]], ℬ[u[x]]}, u, {x, xmin, xmax}, y]` gives a Green's function for the linear differential operator ℒ with boundary conditions ℬ in the range xmin to xmax.
`GreenFunction[{ℒ[u[x1, x2, ...]], ℬ[u[x1, x2, ...]]}, u, {x1, x2, ...} ∈ Ω, {y1, y2, ...}]` gives a Green's function for the linear partial differential operator ℒ over the region Ω.
`GreenFunction[{ℒ[u[x, t]], ℬ[u[x, t]]}, u, {x, xmin, xmax}, t, {y, τ}]` gives a Green's function for the linear time-dependent operator ℒ in the range xmin to xmax.
`GreenFunction[{ℒ[u[x1, ..., t]], ℬ[u[x1, ..., t]]}, u, {x1, ...} ∈ Ω, t, {y1, ..., τ}]` gives a Green's function for the linear time-dependent operator ℒ over the region Ω.
Examples [#examples]
```wolfram
GreenFunction[{y''[x] - y[x], y[0] == 0, y[1] == 0}, y, {x, 0, 1}, s]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/GreenFunction.html) for more details.
# HeatTransferPDEComponent
`HeatTransferPDEComponent[vars,pars]` yields a heat transfer PDE term with variables vars and parameters pars.
Examples [#examples]
Create a heat transfer PDE component:
```wolfram
HeatTransferPDEComponent[{T[t, x, y], t, {x, y}}, <|"ThermalConductivity" -> 1|>]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/HeatTransferPDEComponent.html) for more details.
# HeatTransferValue
`HeatTransferValue[pred, vars, pars]` represents a thermal transfer boundary condition for PDEs with predicate `pred` indicating where it applies, with model variables `vars` and global parameters `pars`.
* `HeatTransferValue[pred, vars, pars, lkey]` represents a thermal transfer boundary condition with local parameters specified in `pars[lkey]`.
Examples [#examples]
```wolfram
HeatTransferValue[x == 0, {T, {x}}, <|"AmbientTemperature" -> 300|>]
```
```wolfram
HeatTransferPDEComponent[{T[x, t], t}, {x}, <|"ThermalConductivity" -> 1|>]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/HeatTransferValue.html) for more details.
# HeavisideLambda
`HeavisideLambda[x]` represents the triangle distribution Λ(x) which is nonzero for |x| \< 1.
* `HeavisideLambda[x1, x2, …]` represents the multidimensional triangle distribution Λ(x1, x2, …) which is nonzero for |xi| \< 1.
Examples [#examples]
```wolfram
HeavisideLambda[0.5]
```
```wolfram
Plot[HeavisideLambda[x], {x, -2, 2}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/HeavisideLambda.html) for more details.
# HeavisidePi
`HeavisidePi[x]` represents the box distribution Π(x), equal to 1 for |x| \< 1/2 and 0 for |x| > 1/2.
* `HeavisidePi[x1, x2, ...]` represents the multidimensional box distribution which is 1 if all |xi| \< 1/2.
Examples [#examples]
```wolfram
HeavisidePi[0.3]
```
```wolfram
Plot[HeavisidePi[x], {x, -1, 1}]
```
```wolfram
HeavisidePi[0.2, 0.3]
```
\*See the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/HeavisidePi.html) for more details.
# HeavisideTheta
`HeavisideTheta[x]` represents the Heaviside theta function θ(x), equal to 0 for x \< 0 and 1 for x > 0.
* `HeavisideTheta[x1, x2, …]` represents the multidimensional Heaviside theta function, which is 1 only if all of the `xi` are positive.
Examples [#examples]
```wolfram
HeavisideTheta[1]
```
```wolfram
Plot[HeavisideTheta[x], {x, -2, 2}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/HeavisideTheta.html) for more details.
# HelmholtzPDEComponent
`HelmholtzPDEComponent[vars,pars]` yields a Helmholtz PDE term ∇2\{x1,…,xn}u+k2u with model variables vars and model parameters pars.
Examples [#examples]
```wolfram
HelmholtzPDEComponent[{u[x, y], {x, y}}, {k}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/HelmholtzPDEComponent.html) for more details.
# Integrate
`Integrate[f, x]` gives the indefinite integral.
`Integrate[f, {x, xmin, xmax}]` gives the definite integral.
Examples [#examples]
Indefinite integral:
```wolfram
Integrate[x^2, x]
(* x^3/3 *)
```
Definite integral:
```wolfram
Integrate[Sin[x], {x, 0, Pi}]
(* 2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Integrate.html) for more details.
# IntegrateChangeVariables
`IntegrateChangeVariables[integral, u, trans]` changes the variable in integral to the new variable u using the transformation trans.
`IntegrateChangeVariables[integral, {u, v, ...}, trans]` changes the variables to the new variables u, v, ....
Examples [#examples]
```wolfram
IntegrateChangeVariables[Integrate[Sin[x]^2, x], u, u == Sin[x]]
```
```wolfram
IntegrateChangeVariables[Integrate[x^2 Exp[x^3], x], u, u == x^3]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/IntegrateChangeVariables.html) for more details.
# InverseFourierTransform
`InverseFourierTransform[expr, ω, t]` gives the symbolic inverse Fourier transform of expr.
Examples [#examples]
Inverse transform:
```wolfram
InverseFourierTransform[E^(-ω^2/4)/Sqrt[2], ω, t]
(* E^(-t^2) *)
```
Round-trip verification:
```wolfram
InverseFourierTransform[FourierTransform[f[t], t, ω], ω, t]
(* f[t] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/InverseFourierTransform.html) for more details.
# InverseHankelTransform
`InverseHankelTransform[expr, s, r]` gives the inverse Hankel transform of order 0 for expr.
* `InverseHankelTransform[expr, s, r, ν]` gives the inverse Hankel transform of order ν for expr.
Examples [#examples]
Inverse Hankel transform of order 0:
```wolfram
InverseHankelTransform[1/(1 + s^2), s, r]
```
With a specific order:
```wolfram
InverseHankelTransform[s, s, r, 1]
```
Verify round-trip:
```wolfram
f = Exp[-r^2];
InverseHankelTransform[HankelTransform[f, r, s], s, r]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/InverseHankelTransform.html) for more details.
# InverseMellinTransform
`InverseMellinTransform[expr, s, x]` gives the inverse Mellin transform of expr.
Examples [#examples]
Inverse Mellin transform of Gamma:
```wolfram
InverseMellinTransform[Gamma[s], s, x]
(* Exp[-x] *)
```
Round-trip verification:
```wolfram
f = Exp[-x];
InverseMellinTransform[MellinTransform[f, x, s], s, x]
```
Transform of a product:
```wolfram
InverseMellinTransform[Gamma[s] Gamma[1 - s], s, x]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/InverseMellinTransform.html) for more details.
# InverseZTransform
`InverseZTransform[expr, z, n]` gives the inverse Z transform of expr.
Examples [#examples]
Inverse Z transform:
```wolfram
InverseZTransform[z/(z - a), z, n]
(* a^n *)
```
Round-trip:
```wolfram
InverseZTransform[ZTransform[f[n], n, z], z, n]
(* f[n] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/InverseZTransform.html) for more details.
# KnapsackSolve
`KnapsackSolve[{cost1,cost2,…},maxtotalcost]` solves the knapsack problem of finding the maximum number of items associated with each of the costi, subject to the constraint that the total cost is not larger than maxtotalcost.
`KnapsackSolve[{{payoff1,cost1},{payoff2,cost2},…},maxtotalcost]` finds a number of items that maximizes the total payoff, while satisfying the constraint on the total cost.
`KnapsackSolve[{{payoff1,cost1,maxcount1},…},maxtotalcost]` allows at most maxcounti copies of item i.
`KnapsackSolve[items,{maxtotalpayoff,maxtotalcost}]` finds a result that gives a total payoff not larger than maxtotalpayoff.
`KnapsackSolve[items,{maxtotalpayoff,maxtotalcost,maxtotalcount}]` adds the constraint of having no more than maxtotalcount items in total.
`KnapsackSolve[<|label1->itemspec1,…|>,maxtotals]` labels each type of item and gives the result as an association.
Examples [#examples]
```wolfram
KnapsackSolve[{2, 3, 5}, 10]
(* {5, 0, 0} *)
```
```wolfram
KnapsackSolve[{{10, 5}, {6, 4}, {3, 2}}, 9]
(* {1, 1, 0} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/KnapsackSolve.html) for more details.
# Laplacian
`Laplacian[f, {x1, ..., xn}]` gives the Laplacian ∂²f/∂x1² + ... + ∂²f/∂xn².
Examples [#examples]
Laplacian of a function:
```wolfram
Laplacian[x^2 + y^2 + z^2, {x, y, z}]
(* 6 *)
```
2D Laplacian:
```wolfram
Laplacian[Sin[x] Cos[y], {x, y}]
(* -2 Cos[y] Sin[x] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Laplacian.html) for more details.
# LaplacianFilter
`LaplacianFilter[data, r]` convolves data with a radius-r Laplacian kernel.
* `LaplacianFilter[data, {r1, r2, ...}]` uses radius ri at level i in data.
Examples [#examples]
```wolfram
LaplacianFilter[ExampleData[{"TestImage", "Lena"}], 2]
```
```wolfram
LaplacianFilter[{1, 2, 5, 2, 1}, 1]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/LaplacianFilter.html) for more details.
# LaplacianGaussianFilter
`LaplacianGaussianFilter[data, r]` convolves data with a Laplacian of Gaussian kernel of pixel radius r.
* `LaplacianGaussianFilter[data, {r, σ}]` convolves data with a Laplacian of Gaussian kernel of radius r and standard deviation σ.
Examples [#examples]
Apply Laplacian of Gaussian filter to an image:
```wolfram
LaplacianGaussianFilter[ExampleData[{"TestImage", "Lena"}], 2]
```
Edge detection with custom radius:
```wolfram
LaplacianGaussianFilter[ExampleData[{"TestImage", "Mandrill"}], 5]
```
Specify radius and standard deviation:
```wolfram
LaplacianGaussianFilter[ExampleData[{"TestImage", "Peppers"}], {3, 1.5}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/LaplacianGaussianFilter.html) for more details.
# LaplacianPDETerm
`LaplacianPDETerm[vars]` represents a Laplacian term ∇²u with model variables vars.
`LaplacianPDETerm[vars, pars]` uses model parameters pars.
Examples [#examples]
```wolfram
LaplacianPDETerm[{u[x, y], {x, y}}]
(* LaplacianPDETerm[{u[x, y], {x, y}}] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/LaplacianPDETerm.html) for more details.
# Limit
`Limit[f, x -> x0]` gives the limit of f as x approaches x0.
Examples [#examples]
Limit at a point:
```wolfram
Limit[Sin[x]/x, x -> 0]
(* 1 *)
```
Limit at infinity:
```wolfram
Limit[1/x, x -> Infinity]
(* 0 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Limit.html) for more details.
# LineIntegrate
`LineIntegrate[f, {x, y, ...} ∈ curve]` computes the scalar line integral of the function f\[x, y, ...] over the curve.
* `LineIntegrate[{p, q, ...}, {x, y, ...} ∈ curve]` computes the vector line integral of the vector function \{p\[x, y, ...], q\[x, y, ...], ...}.
Examples [#examples]
```wolfram
LineIntegrate[x^2 + y^2, {x, y} ∈ Circle[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/LineIntegrate.html) for more details.
# LinearFractionalOptimization
`LinearFractionalOptimization[f, cons, vars]` finds values of variables vars that minimize the linear fractional objective f subject to linear constraints cons.
* `LinearFractionalOptimization[{α, β, γ, δ}, {a, b}]` finds a vector x that minimizes the linear fractional function (α.x+β)/(γ.x+δ) subject to the linear inequality constraints a.x+b⪰0.
* `LinearFractionalOptimization[{α, β, γ, δ}, {a, b}, {aeq, beq}]` includes the linear equality constraints aeq.x+beq=0.
* `LinearFractionalOptimization[{α, β, γ, δ}, ..., {dom1, dom2, ...}]` takes xi to be in the domain domi, where domi is Integers or Reals.
* `LinearFractionalOptimization[..., "prop"]` specifies what solution property "prop" should be returned.
Examples [#examples]
Minimize a linear fractional function:
```wolfram
LinearFractionalOptimization[(x + 1)/(2 x + 3), {x >= 0, x <= 10}, {x}]
```
With matrix constraints:
```wolfram
LinearFractionalOptimization[{c1, d1, c2, d2}, {A, b}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/LinearFractionalOptimization.html) for more details.
# LinearFractionalTransform
`LinearFractionalTransform[m]` gives a TransformationFunction that represents a linear fractional transformation defined by the homogeneous matrix m.
* `LinearFractionalTransform[{a, b, c, d}]` represents a linear fractional transformation that maps r to (a.r+b)/(c.r+d).
Examples [#examples]
Simple transformation:
```wolfram
LinearFractionalTransform[{{1, 2}, {0, 1}}][x]
```
Möbius transformation:
```wolfram
LinearFractionalTransform[{1, 0, 1, 1}][z]
(* z/(z + 1) *)
```
Apply to a point:
```wolfram
LinearFractionalTransform[{{2, 1}, {1, 1}}][{3}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/LinearFractionalTransform.html) for more details.
# LinearModelFit
`LinearModelFit[data, {f1, f2, ...}, x]` creates a linear regression model with statistical analysis.
Examples [#examples]
Perform linear regression:
```wolfram
data = {{1, 2.1}, {2, 3.9}, {3, 6.2}, {4, 7.8}}
lm = LinearModelFit[data, {1, x}, x]
(* Get the fitted function *)
lm["BestFit"]
(* 0.1 + 1.98 x *)
(* R-squared *)
lm["RSquared"]
(* 0.9973 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/LinearModelFit.html) for more details.
# LinearProgramming
`LinearProgramming[c, m, b]` finds a vector x that minimizes the quantity c.x subject to the constraints m.x ≥ b and x ≥ 0.
`LinearProgramming[c, m, {{b1, s1}, {b2, s2}, ...}]` finds x that minimizes c.x subject to constraints where s\_i = 1 means ≥, s\_i = 0 means =, and s\_i = -1 means ≤.
Examples [#examples]
Simple linear program:
```wolfram
LinearProgramming[{1, 1}, {{1, 0}, {0, 1}}, {2, 3}]
(* {2, 3} *)
```
With equality constraint:
```wolfram
LinearProgramming[{-1, -1}, {{1, 1}}, {{5, 0}}]
(* {5, 0} or equivalent *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/LinearProgramming.html) for more details.
# ListZTransform
`ListZTransform[list, z]` gives the Z transform of list as a function of z.
* `ListZTransform[list, z, k]` places the first element of list at integer time k on the infinite time axis.
* `ListZTransform[list, {z1, z2, ...}, {k1, k2, ...}]` gives the multidimensional Z transform.
Examples [#examples]
```wolfram
ListZTransform[{1, 2, 3, 4}, z]
```
```wolfram
ListZTransform[{a, b, c}, z, 0]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ListZTransform.html) for more details.
# MassTransportPDEComponent
`MassTransportPDEComponent[vars, pars]` yields a mass transport PDE term with variables vars and parameters pars.
This is used for modeling mass transport in partial differential equations.
Examples [#examples]
```wolfram
MassTransportPDEComponent[{c[x, t], {x}}, {D, v}]
```
```wolfram
MassTransportPDEComponent[{u[x, y, t], {x, y}}, params]
```
```wolfram
pde = MassTransportPDEComponent[vars, {diffusion, velocity}]
```
\*See the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/MassTransportPDEComponent.html) for more details.
# MellinConvolve
`MellinConvolve[f, g, x, y]` gives the Mellin convolution with respect to x of the expressions f and g.
* `MellinConvolve[f, g, {x1, x2, ...}, {y1, y2, ...}]` gives the multidimensional Mellin convolution.
Examples [#examples]
```wolfram
MellinConvolve[Exp[-x], Exp[-x], x, y]
```
```wolfram
MellinConvolve[x^2, x^3, x, y]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/MellinConvolve.html) for more details.
# MellinTransform
`MellinTransform[expr, x, s]` gives the Mellin transform of expr.
* `MellinTransform[expr, {x1, x2, ...}, {s1, s2, ...}]` gives the multidimensional Mellin transform of expr.
Examples [#examples]
Mellin transform of a simple function:
```wolfram
MellinTransform[Exp[-x], x, s]
(* Gamma[s] *)
```
Transform of power function:
```wolfram
MellinTransform[x^a Exp[-x], x, s]
```
Multidimensional transform:
```wolfram
MellinTransform[Exp[-x - y], {x, y}, {s, t}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/MellinTransform.html) for more details.
# NeumannValue
`NeumannValue[val, pred]` represents a Neumann boundary value val, specified on the part of the boundary of the region given to `NDSolve` and related functions where pred is True.
Examples [#examples]
```wolfram
NDSolve[{Laplacian[u[x, y], {x, y}] == 0,
NeumannValue[1, x == 0], DirichletCondition[u[x, y] == 0, x == 1]},
u, {x, 0, 1}, {y, 0, 1}]
```
```wolfram
NeumannValue[0, y == 0 || y == 1]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/NeumannValue.html) for more details.
# O
`O[x]^n` represents a term of order x^n in power series, indicating omitted higher-order terms.
Examples [#examples]
In series expansion:
```wolfram
Series[Sin[x], {x, 0, 3}]
(* x - x^3/6 + O[x]^4 *)
```
Remove O terms with Normal:
```wolfram
Normal[Series[Exp[x], {x, 0, 3}]]
(* 1 + x + x^2/2 + x^3/6 *)
```
Arithmetic with O:
```wolfram
(1 + O[x]^2) * (x + O[x]^3)
(* x + O[x]^2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/O.html) for more details.
# ParametricConvexOptimization
`ParametricConvexOptimization[f, cons, vars, pars]` gives a ParametricFunction object that finds values of variables vars that minimize the convex objective function f subject to convex constraints cons with parameters pars.
* `ParametricConvexOptimization[..., "prop"]` specifies what solution property "prop" should be returned by the ParametricFunction object.
Examples [#examples]
Create a parametric optimizer:
```wolfram
pf = ParametricConvexOptimization[x^2 + p x, {x >= 0}, {x}, {p}];
pf[2]
```
Get minimum value:
```wolfram
ParametricConvexOptimization[obj, cons, vars, pars, "PrimalMinimumValue"]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ParametricConvexOptimization.html) for more details.
# ParametricNDSolve
`ParametricNDSolve[eqns, u, {x, xmin, xmax}, pars]` finds a numerical solution to the ordinary differential equations eqns for the function u with the independent variable x in the range xmin to xmax with parameters pars.
* `ParametricNDSolve[eqns, u, {x, xmin, xmax}, {y, ymin, ymax}, pars]` solves the partial differential equations eqns over a rectangular region.
* `ParametricNDSolve[eqns, u, {x, y} ∈ Ω, pars]` solves the partial differential equations eqns over the region Ω.
* `ParametricNDSolve[eqns, {u1, u2, ...}, ...]` solves for the functions ui.
Examples [#examples]
Solve an ODE with a parameter:
```wolfram
sol = ParametricNDSolve[{y'[x] == a y[x], y[0] == 1}, y, {x, 0, 1}, {a}];
Plot[Evaluate[Table[y[a][x] /. sol, {a, {-1, 0, 1, 2}}]], {x, 0, 1}]
```
Access the parametric solution:
```wolfram
y[2][0.5] /. sol
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ParametricNDSolve.html) for more details.
# ParametricNDSolveValue
`ParametricNDSolveValue[eqns,expr,{x,xmin,xmax},pars]` gives the value of expr with functions determined by a numerical solution to the ordinary differential equations eqns with the independent variable x in the range xmin to xmax with parameters pars.
`ParametricNDSolveValue[eqns,expr,{x,xmin,xmax},{y,ymin,ymax},pars]` solves the partial differential equations eqns over a rectangular region.
`ParametricNDSolveValue[eqns,expr,{x,y}∈Ω,pars]` solves the partial differential equations eqns over the region Ω.
`ParametricNDSolveValue[eqns,expr,{t,tmin,tmax},{x,y}∈Ω,pars]` solves the time-dependent partial differential equations eqns over the region Ω.
Examples [#examples]
Solve an ODE with a parameter:
```wolfram
f = ParametricNDSolveValue[{y'[x] == a y[x], y[0] == 1}, y, {x, 0, 10}, {a}];
Plot[f[-0.5][x], {x, 0, 10}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ParametricNDSolveValue.html) for more details.
# Perimeter
`Perimeter[reg]` gives the perimeter of the two-dimensional region reg.
`Perimeter[{x1,x2},{s,smin,smax},{t,tmin,tmax}]` gives the perimeter of the parametrized region whose Cartesian coordinates xi are functions of s and t.
`Perimeter[{x1,x2},{s,smin,smax},{t,tmin,tmax},chart]` interprets the xi as coordinates in the specified coordinate chart.
Examples [#examples]
Compute the perimeter of a disk:
```wolfram
Perimeter[Disk[]]
(* 2 Pi *)
```
Compute the perimeter of a rectangle:
```wolfram
Perimeter[Rectangle[{0, 0}, {3, 4}]]
(* 14 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Perimeter.html) for more details.
# PeriodicBoundaryCondition
`PeriodicBoundaryCondition[u[x1, ...], pred, f]` represents a periodic boundary condition u(xtarget) = u(f(xtarget)) for all xtarget on the boundary of the region given to NDSolve where pred is True.
* `PeriodicBoundaryCondition[a + b u[x1, ...], pred, f]` represents a generalized periodic boundary condition a + b u(xtarget) = u(f(xtarget)).
Examples [#examples]
Solve a PDE with periodic boundary conditions on a square:
```wolfram
NDSolveValue[{
Laplacian[u[x, y], {x, y}] == 1,
PeriodicBoundaryCondition[u[x, y], x == 1,
Function[{x, y}, {x - 1, y}]],
DirichletCondition[u[x, y] == 0, y == 0 || y == 1]
}, u, {x, y} \[Element] Rectangle[]]
```
Periodic boundary on both sides:
```wolfram
PeriodicBoundaryCondition[u[x], x == L,
TranslationTransform[{-L}]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/PeriodicBoundaryCondition.html) for more details.
# Product
`Product[f, {i, imin, imax}]` evaluates the product of f as i ranges from imin to imax.
Examples [#examples]
Factorial as a product:
```wolfram
Product[i, {i, 1, 5}]
(* 120 *)
```
Symbolic product:
```wolfram
Product[x + i, {i, 0, 3}]
(* x (1 + x) (2 + x) (3 + x) *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Product.html) for more details.
# ProductDistribution
`ProductDistribution[dist1,dist2,…]` represents the joint distribution with independent component distributions dist1, dist2, ….
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ProductDistribution.html) for more details.
# QuadraticOptimization
`QuadraticOptimization[f, cons, vars]` finds values of variables vars that minimize the quadratic objective f subject to linear constraints cons.
* `QuadraticOptimization[{q, c}, {a, b}]` finds a vector x that minimizes the quadratic objective ½x.q.x + c.x subject to the linear inequality constraints a.x + b ≥ 0.
* `QuadraticOptimization[{q, c}, {a, b}, {aeq, beq}]` includes the linear equality constraints aeq.x + beq = 0.
* `QuadraticOptimization[{q, c}, ..., {dom1, dom2, ...}]` takes xi to be in the domain domi, where domi is `Integers` or `Reals`.
* `QuadraticOptimization[..., "prop"]` specifies what solution property "prop" should be returned.
Examples [#examples]
```wolfram
QuadraticOptimization[x^2 + y^2, {x + y >= 1}, {x, y}]
```
```wolfram
QuadraticOptimization[(x - 1)^2 + (y - 2)^2, {x >= 0, y >= 0}, {x, y}]
```
```wolfram
QuadraticOptimization[{{{2, 0}, {0, 2}}, {-1, -1}}, {{{1, 1}}, {-1}}]
```
\*See the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/QuadraticOptimization.html) for more details.
# RSolve
`RSolve[eqn, a[n], n]` solves a recurrence equation for a\[n].
`RSolve[{eqn1, eqn2, ...}, {a1[n], a2[n], ...}, n]` solves a system of recurrence equations.
`RSolve[eqn, a[n1, n2, ...], {n1, n2, ...}]` solves a partial recurrence equation.
Examples [#examples]
Solve a simple recurrence:
```wolfram
RSolve[a[n] == 2 a[n - 1], a[n], n]
(* {{a[n] -> 2^n C[1]}} *)
```
Solve with initial condition:
```wolfram
RSolve[{a[n] == a[n - 1] + 1, a[0] == 0}, a[n], n]
(* {{a[n] -> n}} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/RSolve.html) for more details.
# RSolveValue
`RSolveValue[eqn,expr,n]` gives the value of expr determined by a symbolic solution to the ordinary difference equation eqn with independent variable n.
`RSolveValue[{eqn1,eqn2,…},expr,…]` uses a symbolic solution for a list of difference equations.
`RSolveValue[eqn,expr,{n1,n2,…}]` uses a solution for the partial recurrence equation eqn.
Examples [#examples]
Solve a recurrence relation:
```wolfram
RSolveValue[{a[n] == a[n - 1] + a[n - 2], a[0] == 1, a[1] == 1}, a[n], n]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/RSolveValue.html) for more details.
# ReactionBalance
`ReactionBalance[rxn]` returns a version of the reaction rxn in which the stoichiometric coefficients for elements in the reactants and products are balanced.
Examples [#examples]
```wolfram
ReactionBalance["H2 + O2 -> H2O"]
```
```wolfram
ReactionBalance["Fe + O2 -> Fe2O3"]
```
```wolfram
ReactionBalance["C6H12O6 + O2 -> CO2 + H2O"]
```
\*See the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ReactionBalance.html) for more details.
# ReactionBalancedQ
`ReactionBalancedQ[rxn]` returns True if the given chemical reaction is balanced, and False otherwise.
Examples [#examples]
```wolfram
ReactionBalancedQ["2H2 + O2 -> 2H2O"]
```
```wolfram
ReactionBalancedQ[Molecule["CH4"] + Molecule["O2"] -> Molecule["CO2"] + Molecule["H2O"]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ReactionBalancedQ.html) for more details.
# ReactionPDETerm
`ReactionPDETerm[vars, a]` represents a reaction term a u with reaction coefficient a and with model variables vars.
`ReactionPDETerm[{u, {x1, …, xn}}, a, pars]` uses model parameters pars.
Examples [#examples]
Create a reaction term:
```wolfram
ReactionPDETerm[{u[t, x], {t, x}}, k]
```
Use in a PDE system:
```wolfram
eq = ReactionPDETerm[{c[t, x], {t, x}}, -k c[t, x]];
NDSolve[{eq == 0, c[0, x] == Exp[-x^2]}, c, {t, 0, 1}, {x, -5, 5}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ReactionPDETerm.html) for more details.
# RecurrenceTable
`RecurrenceTable[eqns, expr, {n, nmax}]` generates a list of values of expr for successive n based on solving the recurrence equations eqns.
`RecurrenceTable[eqns, expr, nspec]` generates a list of values of expr over the range of n values specified by nspec.
`RecurrenceTable[eqns, expr, {n1, ...}, {n2, ...}, ...]` generates an array of values of expr for successive n1, n2, ... .
Examples [#examples]
Generate the first 10 Fibonacci numbers:
```wolfram
RecurrenceTable[{a[n] == a[n - 1] + a[n - 2], a[1] == 1, a[2] == 1}, a[n], {n, 1, 10}]
(* {1, 1, 2, 3, 5, 8, 13, 21, 34, 55} *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/RecurrenceTable.html) for more details.
# Residue
`Residue[expr, {z, z0}]` finds the residue of expr at the point z = z0.
Examples [#examples]
Find the residue of a simple pole:
```wolfram
Residue[1/z, {z, 0}]
(* 1 *)
```
Residue at a higher-order pole:
```wolfram
Residue[1/z^3, {z, 0}]
(* 0 *)
Residue[1/(z - 1)^2, {z, 1}]
(* 0 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Residue.html) for more details.
# ResidueSum
`ResidueSum[f, z]` finds the sum of residues of the meromorphic function f with the variable z.
* `ResidueSum[{f, cons}, z]` finds the sum of residues of f within the solution set of the constraints cons.
Examples [#examples]
Sum of all residues:
```wolfram
ResidueSum[1/(z^2 - 1), z]
(* 0 *)
```
With constraints:
```wolfram
ResidueSum[{1/z, Im[z] > 0}, z]
```
For a rational function:
```wolfram
ResidueSum[1/((z - 1)(z - 2)), z]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ResidueSum.html) for more details.
# RobustConvexOptimization
`RobustConvexOptimization[f, ForAll[pars, pcons, vcons], vars]` finds values of vars that give the minimum value of f for vars that satisfy the constraints vcons for all possible values of the parameters pars that satisfy the parametric constraints pcons.
* `RobustConvexOptimization[..., "prop"]` specifies what solution property "prop" should be returned.
This function solves optimization problems with uncertainty in parameters.
Examples [#examples]
```wolfram
RobustConvexOptimization[x + y,
ForAll[{a}, -1 <= a <= 1, x + a*y >= 1], {x, y}]
```
```wolfram
RobustConvexOptimization[x,
ForAll[{p}, Abs[p] <= 1, x + p >= 0], {x}]
```
```wolfram
RobustConvexOptimization[x^2 + y^2,
ForAll[{a, b}, a^2 + b^2 <= 1, a*x + b*y <= 1], {x, y}]
```
\*See the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/RobustConvexOptimization.html) for more details.
# SchrodingerPDEComponent
`SchrodingerPDEComponent[vars, pars]` yields a Schrödinger PDE term with model variables vars and model parameters pars.
Examples [#examples]
Schrödinger equation component:
```wolfram
SchrodingerPDEComponent[{ψ[x, t], t}, {x}]
```
Time-independent Schrödinger equation:
```wolfram
SchrodingerPDEComponent[{ψ, x}, <|"Mass" -> 1, "PlanckConstant" -> 1|>]
```
In NDSolve:
```wolfram
NDSolve[{SchrodingerPDEComponent[{u[x, t], t}, {x}] == 0,
u[x, 0] == Exp[-x^2]}, u, {x, -5, 5}, {t, 0, 1}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SchrodingerPDEComponent.html) for more details.
# Series
`Series[f, {x, x0, n}]` generates a power series expansion for f about the point x=x0 to order n.
Examples [#examples]
Taylor series of Sin:
```wolfram
Series[Sin[x], {x, 0, 5}]
(* x - x^3/6 + x^5/120 + O[x]^6 *)
```
Series of Exp:
```wolfram
Series[Exp[x], {x, 0, 4}]
(* 1 + x + x^2/2 + x^3/6 + x^4/24 + O[x]^5 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Series.html) for more details.
# SeriesCoefficient
`SeriesCoefficient[series, n]` finds the coefficient of the nth-order term in a power series in the form generated by Series.
`SeriesCoefficient[f, {x, x0, n}]` finds the coefficient of (x-x0)^n in the expansion of f about the point x=x0.
Examples [#examples]
Coefficient from a series:
```wolfram
SeriesCoefficient[Series[Sin[x], {x, 0, 5}], 3]
(* -1/6 *)
```
Direct computation:
```wolfram
SeriesCoefficient[Exp[x], {x, 0, 4}]
(* 1/24 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SeriesCoefficient.html) for more details.
# SeriesData
`SeriesData[x, x0, {a0, a1, ...}, nmin, nmax, den]` represents a power series in the variable x about the point x0. The ai are the coefficients in the power series.
Examples [#examples]
Construct a series manually:
```wolfram
SeriesData[x, 0, {1, 1, 1/2, 1/6}, 0, 4, 1]
(* 1 + x + x^2/2 + x^3/6 + O[x]^4 *)
```
Extract series data:
```wolfram
s = Series[Sin[x], {x, 0, 3}];
SeriesData[s]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SeriesData.html) for more details.
# SolidMechanicsPDEComponent
`SolidMechanicsPDEComponent[vars,pars]` yields solid mechanics PDE terms with variables vars and parameters pars.
Examples [#examples]
```wolfram
SolidMechanicsPDEComponent[{u[x, y], {x, y}}, <|"YoungsModulus" -> 1, "PoissonRatio" -> 0.3|>]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SolidMechanicsPDEComponent.html) for more details.
# SolidMechanicsStrain
`SolidMechanicsStrain[vars, pars, displ]` yields a solid mechanics total strain with variables vars, parameters pars, and displacements displ.
Examples [#examples]
```wolfram
SolidMechanicsStrain[{x, y}, <||>, {u[x, y], v[x, y]}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SolidMechanicsStrain.html) for more details.
# SolidMechanicsStress
`SolidMechanicsStress[vars, pars, strain]` yields solid mechanics internal stress with variables vars, parameters pars and total strain strain.
* `SolidMechanicsStress[vars, pars, strain, displacement]` yields solid mechanics stress for nonlinear material laws.
Examples [#examples]
Compute stress:
```wolfram
SolidMechanicsStress[{u[x, y], v[x, y]}, <|"YoungModulus" -> 200*^9, "PoissonRatio" -> 0.3|>, strain]
```
Linear elastic material:
```wolfram
vars = {u, {x, y}};
pars = <|"YoungModulus" -> 1, "PoissonRatio" -> 0.25|>;
SolidMechanicsStress[vars, pars, Automatic]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SolidMechanicsStress.html) for more details.
# SourcePDETerm
`SourcePDETerm[vars, f]` represents a source term f with source coefficient f and model variables vars.
* `SourcePDETerm[vars, f, pars]` uses model parameters pars.
Examples [#examples]
Create a simple source term:
```wolfram
SourcePDETerm[{u[x, y], {x, y}}, 1]
```
Use a source term in a PDE system:
```wolfram
op = SourcePDETerm[{u[x, y], {x, y}}, x^2 + y^2];
NDSolveValue[{op == 0, DirichletCondition[u[x, y] == 0, True]}, u, {x, y} \[Element] Disk[]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SourcePDETerm.html) for more details.
# SpherePoints
`SpherePoints[n]` gives the positions of n uniformly distributed points on the surface of a unit sphere.
This function generates approximately evenly spaced points on a sphere.
Examples [#examples]
```wolfram
SpherePoints[10]
```
```wolfram
Graphics3D[Point[SpherePoints[100]]]
```
```wolfram
ListPointPlot3D[SpherePoints[50]]
```
\*See the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SpherePoints.html) for more details.
# Sum
`Sum[f, {i, imax}]` evaluates the sum from i=1 to imax.
`Sum[f, {i, imin, imax}]` starts with i=imin.
`Sum[f, {i, imin, imax, di}]` uses steps di.
Examples [#examples]
Sum of integers:
```wolfram
Sum[i, {i, 1, 10}]
(* 55 *)
```
Sum of squares:
```wolfram
Sum[i^2, {i, 1, 5}]
(* 55 *)
```
Symbolic sum:
```wolfram
Sum[i, {i, 1, n}]
(* n(n+1)/2 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Sum.html) for more details.
# SumConvergence
`SumConvergence[f,n]` gives conditions for the sum ∑f to be convergent.
`SumConvergence[f,{n1,n2,…}]` gives conditions for the multiple sum to be convergent.
`SumConvergence[f,{n,a,∞}]` gives conditions for the sum to be convergent on the interval \[a,∞).
`SumConvergence[f,{n,a,∞},…,{m,b,∞}]` gives conditions for the multiple sum to be convergent.
Examples [#examples]
Test convergence of 1/n^2:
```wolfram
SumConvergence[1/n^2, n]
(* True *)
```
Test convergence with a parameter:
```wolfram
SumConvergence[1/n^p, n]
(* p > 1 *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SumConvergence.html) for more details.
# SummationLayer
`SummationLayer[]` represents a net layer that sums all of its input elements.
Examples [#examples]
```wolfram
SummationLayer[]
```
```wolfram
SummationLayer[][{1, 2, 3, 4, 5}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SummationLayer.html) for more details.
# SurfaceArea
`SurfaceArea[reg]` gives the surface area of the three-dimensional region reg.
* `SurfaceArea[{x1, ..., xn}, {s, smin, smax}, {t, tmin, tmax}, {u, umin, umax}]` gives the surface area of the parametrized region whose Cartesian coordinates xi are functions of s, t, u.
* `SurfaceArea[{x1, ..., xn}, {s, smin, smax}, {t, tmin, tmax}, {u, umin, umax}, chart]` interprets the xi as coordinates in the specified coordinate chart.
Examples [#examples]
```wolfram
SurfaceArea[Sphere[]]
```
```wolfram
SurfaceArea[Cylinder[{{0, 0, 0}, {0, 0, 1}}, 1]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SurfaceArea.html) for more details.
# SurfaceIntegrate
`SurfaceIntegrate[f, {x, y, ...} ∈ surface]` computes the scalar surface integral of the function f\[x, y, ...] over the surface.
* `SurfaceIntegrate[{p, q, ...}, {x, y, ...} ∈ surface]` computes the vector surface integral of the vector field \{p\[x, y, ...], q\[x, y, ...], ...}.
Examples [#examples]
Surface area of a sphere:
```wolfram
SurfaceIntegrate[1, {x, y, z} ∈ Sphere[]]
(* 4 π *)
```
Flux through a hemisphere:
```wolfram
SurfaceIntegrate[{x, y, z}, {x, y, z} ∈
ImplicitRegion[x^2 + y^2 + z^2 == 1 && z >= 0, {x, y, z}]]
```
Integrate a scalar field over a surface:
```wolfram
SurfaceIntegrate[x^2, {x, y, z} ∈ Sphere[{0, 0, 0}, 2]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/SurfaceIntegrate.html) for more details.
# ToPolarCoordinates
`ToPolarCoordinates[{x, y}]` gives the \{r, θ} polar coordinates corresponding to the Cartesian coordinates \{x, y}.
* `ToPolarCoordinates[{x1, x2, …, xn}]` gives the hyperspherical coordinates corresponding to the Cartesian coordinates \{x1, x2, …, xn}.
Examples [#examples]
```wolfram
ToPolarCoordinates[{1, 1}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ToPolarCoordinates.html) for more details.
# ToRadicals
`ToRadicals[expr]` attempts to express all Root objects in expr in terms of radicals.
Examples [#examples]
Convert roots to radicals:
```wolfram
ToRadicals[Root[#^2 - 2 &, 1]]
(* -Sqrt[2] *)
```
Solve and convert:
```wolfram
ToRadicals[Solve[x^3 - 2 == 0, x]]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ToRadicals.html) for more details.
# ToSphericalCoordinates
`ToSphericalCoordinates[{x, y, z}]` gives the \{r, θ, ϕ} spherical coordinates corresponding to the Cartesian coordinates \{x, y, z}.
Examples [#examples]
```wolfram
ToSphericalCoordinates[{1, 1, 1}]
```
```wolfram
ToSphericalCoordinates[{0, 0, 5}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ToSphericalCoordinates.html) for more details.
# UnilateralConvolve
`UnilateralConvolve[f, g, u, t]` gives the unilateral convolution with respect to u of the expressions f and g.
`UnilateralConvolve[f, g, {u1, ..., un}, {t1, ..., tn}]` gives the multidimensional unilateral convolution.
Examples [#examples]
Convolve two functions:
```wolfram
UnilateralConvolve[Exp[-a u], Exp[-b u], u, t]
(* (E^(-b t) - E^(-a t))/(a - b) *)
```
Convolve with unit step:
```wolfram
UnilateralConvolve[1, Sin[u], u, t]
(* 1 - Cos[t] *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/UnilateralConvolve.html) for more details.
# UnitStep
`UnitStep[x]` represents the unit step function, equal to `0` for x \< 0 and `1` for x ≥ 0.
`UnitStep[x1, x2, ...]` is 1 only if none of the xi are negative.
Examples [#examples]
Evaluate the unit step:
```wolfram
UnitStep[-1]
(* 0 *)
UnitStep[0]
(* 1 *)
UnitStep[5]
(* 1 *)
```
Plot the unit step function:
```wolfram
Plot[UnitStep[x], {x, -2, 2}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/UnitStep.html) for more details.
# UnitTriangle
`UnitTriangle[x]` represents the unit triangle function on the interval |x| ≤ 1.
`UnitTriangle[x1,x2,…]` represents the multidimensional unit triangle function on the interval |xi| ≤ 1.
Examples [#examples]
Evaluate the unit triangle function:
```wolfram
UnitTriangle[0.5]
(* 0.5 *)
```
Plot the unit triangle:
```wolfram
Plot[UnitTriangle[x], {x, -2, 2}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/UnitTriangle.html) for more details.
# Volume
`Volume[reg]` gives the volume of a three-dimensional region.
Examples [#examples]
Volume of a ball:
```wolfram
Volume[Ball[{0, 0, 0}, r]]
(* (4 Pi r^3)/3 *)
```
Volume of a cylinder:
```wolfram
Volume[Cylinder[{{0, 0, 0}, {0, 0, 1}}, 1]]
(* Pi *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/Volume.html) for more details.
# WavePDEComponent
`WavePDEComponent[vars, pars]` yields a wave equation PDE term ∂²u/∂t² - c²∇²u with model variables vars and model parameters pars.
Examples [#examples]
```wolfram
WavePDEComponent[{u[t, x, y], t, {x, y}}, {{"WaveSpeed" -> 1}}]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/WavePDEComponent.html) for more details.
# WienerFilter
`WienerFilter[data,r]` removes noise from data by applying a range-r Wiener filter.
`WienerFilter[data,r,ns]` assumes an additive noise power value ns.
`WienerFilter[data,{r1,r2,…},…]` uses radius ri at level i in data.
Examples [#examples]
Apply a Wiener filter to noisy data:
```wolfram
data = Table[Sin[x] + RandomReal[{-0.2, 0.2}], {x, 0, 10, 0.1}];
WienerFilter[data, 3]
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/WienerFilter.html) for more details.
# ZTransform
`ZTransform[expr, n, z]` gives the Z transform of expr.
Examples [#examples]
Z transform of a sequence:
```wolfram
ZTransform[a^n, n, z]
(* z/(z - a) *)
```
Unit step:
```wolfram
ZTransform[UnitStep[n], n, z]
(* z/(z - 1) *)
```
Something isn't working? [Report](https://github.com/WLJSTeam/wljs-notebook/issues) an issue.
Please visit the official [Wolfram Language Reference](https://reference.wolfram.com/language/ref/ZTransform.html) for more details.
# Architecture
WLJS Notebook is an application built on top of the Wolfram Engine (a freeware distribution of Wolfram Language) with a web-based GUI. Naturally, we isolate evaluation to a separate process of the Wolfram Engine, similar to Mathematica or Jupyter. Both can directly interact with the content rendered on the page directly for the sake of performance and low-latency.
GUI [#gui]
We use a superset of Wolfram Language and HTML—[WLX](./../Cell-types/WLX)—to build app components (similar to JSX) and the entire GUI. Together with a small UI framework, it allows seamless integration of JS with WL, which is why we do not explicitly separate backend and frontend parts in the architecture. The state is not stored on the client; all UI updates are performed by the main Wolfram Engine process.
Notebooks [#notebooks]
The notebook interface is simply a separate view-component of the app that loads a notebook file, renders it, and evaluates its cells using specialized evaluators. The evaluator to use is determined by the cell type via special patterns at the beginning of the cell content. Evaluators vary significantly, from [JavaScript](./../Cell-types/Javascript) cells that do not involve the Wolfram Kernel to [Slides](./../Cell-types/Slide) and [Wolfram Language](./../Cell-types/Wolfram-Language) input cells. All notebooks are stored as associations, with input/output expressions presented as plain strings, that the main kernel (server) does not interpret a cell's content.
WLJS Interpreter [#wljs-interpreter]
A key component of WLJS Notebook is its deep integration with JavaScript. Unlike most notebook solutions, we do not convert cell content into a special format before rendering it on the page. To display a graph, code, or button, we send the Wolfram Expression directly to the browser and let JavaScript interpret it in place. To enable this, we implemented a compact (\~3 kB) JavaScript-based WL interpreter called the *WLJS Interpreter*. In fact, our API also relies on Wolfram Expressions—handling all dynamics, graphics, sound, and even GUI management through the WLJS Interpreter. There is a 1:1 correspondence between most JavaScript objects and Wolfram Expressions.
Communication [#communication]
We use as much SSR (Server-Side Rendering) as possible via a basic HTTP channel. The *main kernel* establishes a WebSocket connection to provide interactivity and avoid long polling. Each *evaluation kernel* (limited to one by the freeware license) has its own dedicated WebSocket connection to the page. This approach ensures optimal performance for dynamic evaluations involving real-time video streaming or updating $10^6$ polygons in a 3D plot. We use a binary protocol instead of a text-based one to update data within expressions.
Wolfram Paclets [#wolfram-paclets]
Despite differences between Mathematica and WLJS Notebook, both share the same Wolfram Language with its standard library set. Consequently, we support standard WL packages in any form.
Extensions (Plugins) [#extensions-plugins]
Extensions or plugins are a significant part of WLJS Notebook and are supersets of Wolfram Paclets. They function as composite packages, which may include:
* Features for the main kernel
* Features for the evaluation kernel
* JavaScript libraries
* UI elements for the notebook interface
* Implementations of new cell types
Each package has its own context name, which can be required by other extensions. WLJS Notebook is split into more than ten such modules.
# Expression rendering
The WLJS Notebook integrates a wide range of Web APIs to maximize performance and render complex, decorated Wolfram expressions—including nested elements such as:
* SVG graphics
* Canvas
* WebGL shaders
* Basic HTML elements
Here are a few examples showing how we compose these elements to render Wolfram expressions:
```wolfram
Plot[{x, x^2}, {x, 0, 1}, PlotLegends -> Automatic]
```
In this example, we have a typical scenario where SVG graphics are overlaid with an HTML element inset—specifically, a `SwatchLegend`. The `CodeMirror` elements represent truncated versions of the code editor found in every input cell. While this might seem excessive, we use this setup only when the expression is not plain text and it is unclear how to render it. This universal approach allows us to embed full expressions, including nested plots, within other plots and more.
```wolfram
Legended[
Grid[Partition[
Table[If[PrimeQ[n], Item[n, Background -> LightBlue], n], {n, 100}],
10], Frame -> All], SwatchLegend[{LightBlue}, {"prime numbers"}]]
```
In this example, we render a grid of 100 editors, where all *prime* number cells have a different background color.
Most importantly, this matrix remains a fully **editable expression**. You can copy and paste it into other cells without issues, even in `wolframscript`. WLJS Notebook treats `StandardForm` as a decorated version of `InputForm`, making it compatible with other editors outside the Wolfram ecosystem.
```wolfram
ContourPlot[Cos[x] + Sin[y], {x,0,4Pi}, {y, 0, 4Pi}, PlotLegends->Automatic]
```
This is one of our favorite examples. SVG graphics are not ideal for rendering shaded triangles generated by `Polygon` elements within a `GraphicsComplex`. To address performance issues, we developed a custom WebGL renderer. It renders all *heavy* graphics using low-level GPU calls into a static image, which is then embedded inside an SVG element and overlaid with elements that are tricky to render correctly—such as lines.
> Line rendering in WebGL is particularly problematic. On some platforms, you can't change line thickness—unless you render them using triangles, but that's another story.
Here is another example: a complex canvas of `Inset` inside `Graphics` inside other `Inset`, which is typically the case when you need to assemble multiple figures (5) into 1 using another `Graphics`:
# HTTP API
Overview [#overview]
The HTTP API provides a programmatic interface to interact with the Wolfram notebook application. It allows external clients to manage notebooks, cells, evaluate code, and query the kernel without direct user interaction.
The API uses **HTTP POST requests with JSON payloads** for all operations. Responses are returned as JSON with appropriate HTTP status codes:
* **200** - Success
* **409** - Failure (returned with error message)
Response Format [#response-format]
All responses follow this structure:
**Success Response:**
```json
{
"Body":