Wolfram Language

https://reference.wolfram.com/language/
Admin
The Wolfram Language is a definitive computational language and system that integrates symbolic...
Tokens:28,501,312
Snippets:349,463
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Locate and install WSTP examples

Source: https://reference.wolfram.com/language/tutorial/WSTPDeveloperGuide-CMake.html

Commands to find the prebuilt examples directory and install the addtwo program.

```wolfram
FileNameJoin[{$InstallationDirectory, "SystemFiles", "Links", "WSTP", "DeveloperKit", $SystemID, "PrebuiltExamples"}]
```

```wolfram
link = Install["./addtwo"]
```

--------------------------------

### Install or Restore Database Examples

Source: https://reference.wolfram.com/language/DatabaseLink/tutorial/UsingTheExampleDatabases.html.zh?source=footer

Run DatabaseExamplesBuild[] to install the example databases for the first time or to restore them to their original state after modifications. This function ensures the examples are ready for use.

```Wolfram Language
DatabaseExamplesBuild[]
```

--------------------------------

### Install External WSTP Programs

Source: https://reference.wolfram.com/language/ref/%24CurrentLink.html

Installs two separate instances of the counter example program.

```Wolfram Language
link1 = Install["PrebuiltExamples/counter"]
```

```Wolfram Language
link2 = Install["PrebuiltExamples/counter"]
```

--------------------------------

### Install[name]

Source: https://reference.wolfram.com/language/ref/Install.html

Starts a WSTP-compatible external program and installs Wolfram Language definitions to call functions in it.

```APIDOC
## Install[name]

### Description
Starts a WSTP-compatible external program and installs Wolfram Language definitions to call functions in it. It returns a LinkObject representing the WSTP connection.

### Syntax
- Install["name"]
- Install[File["name"]]
- Install[link]
- Install[LinkConnect["port"]]

### Parameters
- **name** (String) - The name or path of the external program to execute.
- **link** (LinkObject) - An existing WSTP link object.
- **port** (Integer/String) - The port number or identifier for a remote or debugger-attached program.

### Returns
- **LinkObject** - A representation of the WSTP connection used for communication with the external program.
```

--------------------------------

### Load Database Examples Package

Source: https://reference.wolfram.com/language/DatabaseLink/tutorial/UsingTheExampleDatabases.html.zh?source=footer

Load the DatabaseLink`DatabaseExamples` package to access functions for managing example databases. This is a prerequisite for installing or restoring the examples.

```Wolfram Language
<<DatabaseLink`DatabaseExamples`;
```

--------------------------------

### Install["name"]

Source: https://reference.wolfram.com/language/ref/Install.html

Starts a WSTP-compatible external program and installs Wolfram Language definitions to call functions in it.

```APIDOC
## Install["name"]

### Description
Starts a WSTP-compatible external program and installs Wolfram Language definitions to call functions in it.

### Syntax
Install["name"]

### Parameters
- **name** (String) - Required - The name or path of the WSTP-compatible external program to be started.
```

--------------------------------

### Define and install an external WSTP program

Source: https://reference.wolfram.com/language/ref/Uninstall.html.en?source=footer

Locate the prebuilt 'addtwo' example program and install it to enable external function calls.

```Wolfram Language
addtwo = FileNameJoin[{$InstallationDirectory, "SystemFiles", "Links", "WSTP", "DeveloperKit", $SystemID, "PrebuiltExamples", "addtwo"}];
```

```Wolfram Language
link = Install[addtwo]
```

--------------------------------

### Run Example Server

Source: https://reference.wolfram.com/language/WolframNotebookEmbedder/docs/Development

Starts a local server to test embedded notebooks. Visit the provided localhost URL to interact with the embedder.

```bash
yarn run-examples

```

--------------------------------

### Navigate to WSTP Examples Directory

Source: https://reference.wolfram.com/language/tutorial/WSTPDeveloperGuide-Macintosh.html

Change the current directory to the location of the WSTP examples within the Wolfram System installation.

```bash
cd "/Applications/Mathematica.app/Contents/SystemFiles/Links/WSTP/DeveloperKit/MacOSX-x86-64/WSTPExamples"
```

--------------------------------

### Example JDK Path on Windows

Source: https://reference.wolfram.com/language/RLink/tutorial/ConfigureExternalRInstallation.html

This is an example path to an installed JDK on Windows. Record this path for the RLink configuration process.

```shell
C:\\Program Files\\Zulu\\zulu-17
```

--------------------------------

### Start a WSTP-compatible external program

Source: https://reference.wolfram.com/language/ref/CallPacket.html

Initializes a connection to an external program using the Install function.

```Wolfram Language
link = Install[FileNameJoin[{$InstallationDirectory, "SystemFiles", "Links", "WSTP", "DeveloperKit", $SystemID, "PrebuiltExamples", "addtwo"}]];
```

--------------------------------

### Build a single WSTP sample program

Source: https://reference.wolfram.com/language/tutorial/WSTPDeveloperGuide-CMake.html

Configure and build an individual example subdirectory while specifying the WSTP_ROOT_DIR.

```bash
mkdir build.addtwo   
cmake -S "<full path>/WSTP/DeveloperKit/<platform>/WSTPExamples/addtwo" -DWSTP_ROOT_DIR="<full path>/WSTP/DeveloperKit/<platform>/CompilerAdditions" -B "build.addtwo"  
cmake --build "build.addtwo"
```

--------------------------------

### Initialize project environment

Source: https://reference.wolfram.com/language/workflow/InstallTheWolframNotebookEmbedderLibrary.html

Commands to set up the project directory and install necessary dependencies.

```bash
$ mkdir wolfram-notebook-webpack && cd wolfram-notebook-webpack
```

```bash
$ npm init -y
```

```bash
$ npm install webpack --save-dev
```

```bash
$ npm install webpack-cli --save-dev
```

--------------------------------

### Build all WSTP sample programs

Source: https://reference.wolfram.com/language/tutorial/WSTPDeveloperGuide-CMake.html

Commands to create a build directory and compile all bundled WSTP examples.

```bash
mkdir build.wstp-examples   
cmake -S "<full path>/WSTP/DeveloperKit/<platform>/WSTPExamples" -B "build.wstp-examples"  
cmake --build "build.wstp-examples"
```

--------------------------------

### Open a Database Connection

Source: https://reference.wolfram.com/language/DatabaseLink/ref/CloseSQLConnection.html

Opens a connection to the 'demo' SQL database. Ensure the example database is installed.

```Wolfram Language
conn = OpenSQLConnection["demo"];
```

--------------------------------

### Install and Uninstall External Programs

Source: https://reference.wolfram.com/language/tutorial/IntroductionToWSTP.html

Use Install to start an external program and define its functions in the Wolfram Language, and Uninstall to terminate the connection.

```Wolfram Language
Install["simul"]
```

```Wolfram Language
Uninstall["simul"]
```

--------------------------------

### Install via pip

Source: https://reference.wolfram.com/language/workflow/InstallTheWolframClientLibraryForPython.html

Standard installation method for most users.

```bash
$ pip install wolframclient
```

--------------------------------

### Setup OrdinaryDiffEq in Julia

Source: https://reference.wolfram.com/language/ref/externalevaluationsystem/Julia.html

Starts a new Julia session and installs the OrdinaryDiffEq package.

```Wolfram Language
session = StartExternalSession["Julia"]; ExternalEvaluate[session, "using Pkg; Pkg.add(\"OrdinaryDiffEq\")"];
```

--------------------------------

### Example: Manual Link Establishment with Install.main

Source: https://reference.wolfram.com/language/JLink/ref/java/com/wolfram/jlink/Install.html

Demonstrates how to manually establish a link between Java and Mathematica using listen/connect modes via the Install.main method. This is useful for launching the Java runtime within a debugger.

```shell
On the command line, or in your Java development environment:
     java com.wolfram.jlink.Install -linkname 1234 -linkmode listen

 Then in Mathematica:
     InstallJava[LinkConnect["1234"]]
```

--------------------------------

### Example JDK Path on macOS

Source: https://reference.wolfram.com/language/RLink/tutorial/ConfigureExternalRInstallation.html

This is an example path to an installed JDK on macOS. Ensure your JDK installation directory is recorded for later steps.

```shell
/Library/Java/JavaVirtualMachines/zulu-17.jdk/Contents/Home
```

--------------------------------

### CreateUnityAudioReverbZone Examples

Source: https://reference.wolfram.com/language/UnityLink/ref/CreateUnityAudioReverbZone.html

Examples demonstrating the initialization of the UnityLink package, project opening, and the creation and attachment of audio reverb zone components.

```Wolfram Language
Needs["UnityLink`"]
```

```Wolfram Language
OpenUnityProject["C:\\Users\\user\\Documents\\UnityProject"]
```

```Wolfram Language
reverb = CreateUnityAudioReverbZone[]
```

```Wolfram Language
obj = CreateUnityGameObject["ReverbZoneObject"];
CreateUnityAudioReverbZone[obj]
```

```Wolfram Language
CreateUnityAudioReverbZone["MyReverbZone"]
```

--------------------------------

### Get Columns Matching Name Pattern (SQLColumn)

Source: https://reference.wolfram.com/language/DatabaseLink/ref/SQLColumns.html

Retrieves columns from any table whose names match the wildcard '%' and whose column names start with 'V', using the SQLColumn wrapper. This is an equivalent method to the previous example.

```Wolfram Language
SQLColumns[conn, SQLColumn[{"%", "V%"}]]
```

--------------------------------

### Retrieve usage examples

Source: https://reference.wolfram.com/language/ref/WordData.html

Get examples of how a word is used.

```Wolfram Language
WordData["grateful", "Examples"]
```

--------------------------------

### Documentation Installer Output

Source: https://reference.wolfram.com/language/tutorial/InstallingWolfram.html

Example output displayed during the documentation installation process.

```text
--------------------------------------------------------------------  
          Wolfram Language 15.0 Documentation 15.0 Installer   
--------------------------------------------------------------------  
  
Copyright (c) 1988-2026 Wolfram Research, Inc. All rights reserved.  
  
WARNING: Wolfram Language 15.0 Documentation is protected by copyright  
law and international treaties. Unauthorized reproduction or distribution  
may result in severe civil and criminal penalties and will be prosecuted to  
the maximum extent possible under law.  
  
All users of this computer will be able to use this software.  
  
Y  
  
  
Now installing...  
  
[*****************************************************************]
```

--------------------------------

### Running the SimpleFrontEnd Example

Source: https://reference.wolfram.com/language/JLink/tutorial/WritingJavaProgramsThatUseTheWolframLanguage.html

These commands demonstrate how to run the SimpleFrontEnd example program, which hosts a MathSessionPane. This example helps in understanding the features and customization options of MathSessionPane.

```Shell
(Windows)  
java -classpath SimpleFrontEnd.jar;..\..\..\JLink.jar SimpleFrontEnd  

(Linux, Mac OS X):  
java -classpath SimpleFrontEnd.jar:../../../JLink.jar SimpleFrontEnd
```

--------------------------------

### Create a WSTP link using command-line parameters

Source: https://reference.wolfram.com/language/ref/c/WSOpenArgcArgv.html

Demonstrates initializing the WSTP environment and using WSOpenArgcArgv to process command-line arguments for link creation.

```c
#include "wstp.h"  
  
/* create a link using command-line parameters */  
  
int main(int argc, char **argv)  
{  
	WSENV env;
	WSLINK link;
	int error;
  
	env = WSInitialize((WSEnvironmentParameter)0);
	if(env == (WSENV)0)
		{ /* unable to initialize the WSTP environment */ }
  
	/* let WSOpenArgcArgv process the command line */
	link = WSOpenArgcArgv(env, argc, argv, &error);
	if(link == (WSLINK)0 || error != WSEOK)
		{ /* unable to create the link */ }
  
	/* ... */
  
	WSClose(link);
	WSDeinitialize(env);
  
	return 0;
}
```

--------------------------------

### Get Parent of Installation Directory

Source: https://reference.wolfram.com/language/ref/ParentDirectory.html

Navigates to the parent or grandparent of the installation directory.

```Wolfram Language
ParentDirectory[$InstallationDirectory]
```

```Wolfram Language
ParentDirectory[$InstallationDirectory, 2]
```

--------------------------------

### Get Information for Columns Starting with 'V' (Simplified SQLColumn Syntax)

Source: https://reference.wolfram.com/language/DatabaseLink/ref/SQLColumnInformation.html

A simplified way to get column information for columns starting with 'V' using SQLColumn syntax. The output is presented as a table.

```Wolfram Language
SQLColumnInformation[conn, SQLColumn["V%"]] //TableForm
```

--------------------------------

### Create and Run a Simple Wizard

Source: https://reference.wolfram.com/language/GUIKit/ref/widget/Wizard.html

This example demonstrates how to create a basic one-page wizard with a 'Hello World' title and content, then run it using Widget["WizardFrame"].

```Wolfram Language
ref = GUIRun[
	Widget["WizardFrame", {
	"wizard" -> Widget["Wizard", {
	"title" -> "Hello World Wizard", 
	"pages" -> {
	Widget["WizardPage", {
	"navigationNames" -> {"Finish"},
	"title" -> "Hello World Wizard Page",
	"content" -> Widget["WizardHTMLPanel", {"text" -> "A simple one-page <b>Hello World</b> wizard."}]
	}, Name -> "myWizardPage"]
	}
	}, Name -> "myWizard"]
	}]
]
```

--------------------------------

### FrontEndToken["Install"]

Source: https://reference.wolfram.com/language/ref/frontendobject/Install.html

Invokes the Install dialog box, equivalent to the File > Install menu command.

```APIDOC
## FrontEndToken["Install"]

### Description
Opens the Install dialog box, allowing users to install a palette, .mx file, WSTP program, package, or stylesheet.

### Usage
FrontEndExecute[FrontEndToken["Install"]]
```

--------------------------------

### Get Wolfram Installation Directories

Source: https://reference.wolfram.com/language/WolframClientForPython/_modules/wolframclient/utils/environment.html

Yields potential Wolfram installation directories, checking environment variables and common installation locations for Windows, Linux, and macOS.

```python
def _installation_directories():
    env = os.environ.get("WOLFRAM_INSTALLATION_DIRECTORY", None)
    if env:
        yield env

    if six.WINDOWS:
        for p in _explore_paths(
            "C:\\Program Files\\Wolfram Research\\Wolfram Desktop",
            "C:\\Program Files\\Wolfram Research\\Mathematica",
            "C:\\Program Files\\Wolfram Research\\Wolfram Engine",
        ):
            yield p

    elif six.LINUX:
        for p in _explore_paths(
            "/usr/local/Wolfram/Desktop",
            "/usr/local/Wolfram/Mathematica",
            "/usr/local/Wolfram/WolframEngine",
        ):
            yield p

    elif six.MACOS:
        yield "/Applications/Wolfram Desktop.app/Contents"
        yield "/Applications/Mathematica.app/Contents"
        yield "/Applications/Wolfram Engine.app/Contents"
```

--------------------------------

### Initialize and use a WSTP environment

Source: https://reference.wolfram.com/language/ref/c/WSENV.html

Demonstrates the standard lifecycle of a WSTP program, including environment initialization, link creation, and cleanup.

```c
#include "wstp.h"  
  
int main(int argc, char **argv)  
{  
	WSENV env;  
	WSLINK link;  
	int error;  
  
	env = WSInitialize((WSEnvironmentParameter)0);  
	if(env == (WSENV)0)  
		{ /* unable to initialize the WSTP environment */ }  
  
	link = WSOpenArgcArgv(env, argc, argv, &error);  
	if(link == (WSLINK)0 || error != WSEOK)  
		{ /* unable to create the link */ }  
  
	/* ... */  
  
	WSClose(link);  
	WSDeinitialize(env);  
	return 0;  
}
```

--------------------------------

### Start and Connect to a Kernel

Source: https://reference.wolfram.com/language/ref/LinkActivate.html

Demonstrates starting a kernel process, connecting to it, activating the link, and closing it.

```Wolfram Language
StartProcess[{First[$CommandLine], "-wstp", "-linkprotocol", "TCPIP", "-linkcreate", "-linkname", "8000"}]
```

```Wolfram Language
link = LinkConnect["8000", LinkProtocol -> "TCPIP"]
```

```Wolfram Language
LinkActivate[link]
```

```Wolfram Language
LinkClose[link]
```

--------------------------------

### Example JDK Path on Linux

Source: https://reference.wolfram.com/language/RLink/tutorial/ConfigureExternalRInstallation.html

This is an example path to an installed JDK on Linux. This path is required for configuring RLink.

```shell
/usr/lib/jvm/java-17-openjdk
```

--------------------------------

### Navigate to WSTPExamples Directory

Source: https://reference.wolfram.com/language/tutorial/WSTPDeveloperGuide-Windows.html

Commands to change the working directory to the WSTP examples folder for 32-bit and 64-bit Windows installations.

```batch
C:  
cd "C:\Program Files\Wolfram Research\Mathematica\11.0\"  
cd SystemFiles\Links\WSTP\DeveloperKit\Windows\WSTPExamples\
```

```batch
C:  
cd "C:\Program Files\Wolfram Research\Mathematica\11.0\"  
cd SystemFiles\Links\WSTP\DeveloperKit\Windows-x86-64\WSTPExamples\
```

--------------------------------

### Install.main

Source: https://reference.wolfram.com/language/JLink/ref/java/com/wolfram/jlink/Install.html

This is the entry point called by the Mathematica function InstallJava. Users will not call this unless they are trying to manually establish a link between Java and Mathematica, instead of using the default launch behavior of InstallJava.

```APIDOC
## main

### Description
This is the entry point called by the Mathematica function InstallJava. Users will not call this unless they are trying to manually establish a link between Java and Mathematica, instead of using the default launch behavior of InstallJava. For example, here is how you could establish a link using listen/connect modes. You might do this if you wanted to launch the Java runtime inside a debugger such as the one provided in your Java development environment:
```
On the command line, or in your Java development environment:
    java com.wolfram.jlink.Install -linkname 1234 -linkmode listen

Then in Mathematica:
    InstallJava[LinkConnect["1234"]]
```

### Method
`static void main(java.lang.String[] args)`

### Parameters
#### Path Parameters
- **args** (java.lang.String[]) - Description not available
```

--------------------------------

### Navigate to WSTPExamples Directory

Source: https://reference.wolfram.com/language/tutorial/WSTPDeveloperGuide-Windows.html

Commands to change the working directory to the WSTP examples folder for 32-bit and 64-bit Windows installations.

```batch
C:  
cd "C:\Program Files\Wolfram Research\Mathematica\11.0"  
cd SystemFiles\Links\WSTP\DeveloperKit\Windows\WSTPExamples\
```

```batch
C:  
cd "C:\Program Files\Wolfram Research\Mathematica\11.0"  
cd SystemFiles\Links\WSTP\DeveloperKit\Windows-x86-64\WSTPExamples\
```

--------------------------------

### Basic logging setup for WolframLanguageSession

Source: https://reference.wolfram.com/language/WolframClientForPython/docpages/advanced_usages.html

Configure Python's logging module to display INFO level messages and start a WolframLanguageSession to observe kernel startup logs.

```python
from wolframclient.evaluation import WolframLanguageSession
import logging

# set the root level to INFO
logging.basicConfig(level=logging.INFO)

try:
    session = WolframLanguageSession()
    # this will trigger some log messages with the process ID, the sockets
    # address and the startup timer.
    session.start()
    # Warning: Infinite expression Power[0, -1] encountered.
    res = session.evaluate('1/0')
finally:
    session.terminate()
```

--------------------------------

### Create a New Example Resource

Source: https://reference.wolfram.com/language/ref/resourceobject/Example.html

Initialize a blank definition notebook to start creating a new example resource.

```Wolfram Language
CreateNotebook["ExampleResource"]
```

--------------------------------

### Initialize and open a WSTP link

Source: https://reference.wolfram.com/language/ref/c/WSLINK.html

Demonstrates the basic lifecycle of a WSTP link, including environment initialization, link creation using command-line arguments, and cleanup.

```c
#include "wstp.h"  
  
int main(int argc, char **argv)  
{  
	WSENV ep;
	WSLINK lp;
	long error;
  
	ep = WSInitialize((WSEnvironmentParameter)0);
	if(ep == (WSENV)0)
		{ /* unable to initialize environment */ }
  
	lp = WSOpenArgcArgv(ep, argv, argv + argc, &error);
	if(lp == (WSLINK)0 || error != WSEOK)
		{ /* unable to create link */ }
  
	/* ... */
  
	WSClose(lp);
	WSDeinitialize(ep);
	return 0;
}
```

--------------------------------

### Initialize Database Reference

Source: https://reference.wolfram.com/language/ref/externalevaluationsystem/SQL-JDBC.html

Sets up a database reference using a file path.

```Wolfram Language
db = DatabaseReference[FindFile["ExampleData/ecommerce-database.sqlite"]];
```

--------------------------------

### Create a Basic "Hello, world" Instant Web Form

Source: https://reference.wolfram.com/language/howto/CreateInstantWebForms.html

Sets up an instant form that calls a function to generate "Hello, world" at a specified size and returns a PNG. This is useful for simple text generation tasks.

```Wolfram Language
CloudDeploy[FormFunction[{"size" -> "Number"}, Style["Hello, world", #size]&, "PNG"]]
```

--------------------------------

### Access Triangle Installation Directory

Source: https://reference.wolfram.com/language/TriangleLink/ref/%24TriangleInstallationDirectory.html

After loading the TriangleLink package, you can access the $TriangleInstallationDirectory symbol to get the path to your Triangle installation. This variable holds the root directory of the installation.

```Wolfram Language
$TriangleInstallationDirectory
```

--------------------------------

### Initialize and use a link server on a specific port

Source: https://reference.wolfram.com/language//ref/c/WSNewLinkServerWithPort.html

Demonstrates creating a link server, waiting for an incoming connection, and shutting down the server. Ensure the environment is initialized and error codes are checked against WSEOK.

```c
#include "wstp.h"  
  
void operateLinkServerOnPort(WSENV env, unsigned short port)  
{  
		int error;  
		WSLinkServer linkServer;  
		WSLINK theLink;  
  
  
		linkServer = WSNewLinkServerWithPort(env, port,  
				NULL /* No context object for this example */, &error);  
		if(error != WSEOK)  
		{ /* Handle error */ }  
  
		theLink = WSWaitForNewLinkFromLinkserver(linkServer, &error);  
		if(theLink == (WSLINK)0 || error != WSEOK)  
		{ /* Handle error */ }  
  
		...  
  
		WSCLose(theLink);  
  
		WSShutdownLinkServer(linkServer);  
}    
```

--------------------------------

### Get Dimensions of an MTensor

Source: https://reference.wolfram.com/language/LibraryLink/ref/callback/MSparseArray_getDimensions.html

This example demonstrates how to get the dimensions of an MTensor using MSparseArray_getDimensions. The 'dims' pointer will hold the array of dimensions.

```c
MTensor T0;
 mint const* dims;
 ...
dims = libData->MSparseArray_getDimensions( T0);
```

--------------------------------

### Get Starting Vector Length

Source: https://reference.wolfram.com/language/FEMDocumentation/tutorial/FiniteElementBestPractice.html

Determines the number of degrees of freedom, which corresponds to the length of the starting vector for the iterative solver.

```Wolfram Language
Length[sv]
```

--------------------------------

### Initialize and open a WSTP link

Source: https://reference.wolfram.com/language/ref/c/WSLINK.html.en?source=footer

Demonstrates the basic lifecycle of a WSTP link, including environment initialization, link creation, and cleanup.

```c
#include "wstp.h"  
  
int main(int argc, char **argv)  
{  
	WSENV ep;  
	WSLINK lp;  
	long error;  
  
	ep = WSInitialize((WSEnvironmentParameter)0);  
	if(ep == (WSENV)0)  
		{ /* unable to initialize environment */ }  
  
	lp = WSOpenArgcArgv(ep, argv, argv + argc, &error);  
	if(lp == (WSLINK)0 || error != WSEOK)  
		{ /* unable to create link */ }  
  
	/* ... */  
  
	WSClose(lp);  
	WSDeinitialize(ep);  
	return 0;  
}
```

--------------------------------

### Numerically optimize a function with a starting range

Source: https://reference.wolfram.com/language/howto/DoConstrainedNonlinearOptimization.html

Use NMinimize with a specified starting range for the variable to guide the numerical optimization process.

```Wolfram Language
NMinimize[{f[q], q > 1}, {q, 1, 2}]
```

--------------------------------

### Run Calculator Example (Manual Release)

Source: https://reference.wolfram.com/language/GUIKit/tutorial/GUILifecycles.html

Creates a live GUIObject for the Calculator example, specifying that resources should be managed manually. This allows the GUIObject definition to persist after closing.

```Wolfram Language
ref = GUIRun["Wolfram/Example/Calculator", ReleaseMethod -> Manual]
```

--------------------------------

### Direct Link to Harmonic Resonance Example

Source: https://reference.wolfram.com/language/PDEModels/tutorial/StructuralMechanics/SolidMechanics.html.ja?source=footer

A direct link to a specific example demonstrating harmonic resonance setup from eigenmode analysis.

```Wolfram Language
https://wolfram.com/xid/0l2hl08n6dm4venxbhjudg3iznocafdp5f-xgf1my
```

--------------------------------

### Setup Variables and Parameters

Source: https://reference.wolfram.com/language/PDEModels/tutorial/Acoustics/AcousticsFrequencyDomain.html.ja?source=footer

Initializes physical constants and domain parameters for the acoustic model.

```Wolfram Language
L = 1; rho = 1.2; c = 343; f = 440; omega = 2 * Pi * f; p0 = 1;
```

--------------------------------

### Import and Plot Graph

Source: https://reference.wolfram.com/language/GraphUtilities/tutorial/GraphUtilities.html

Imports a graph from example data and plots it with specified vertex coordinates. This is a setup for neighborhood subgraph examples.

```Wolfram Language
g = ExampleData[{"Matrix", "CAN   61"}]; vr = Thread[VertexList[g] -> GraphCoordinates[g]]; GraphPlot[g, VertexCoordinateRules -> vr]
```

--------------------------------

### Get Start Dates for Storms in a Year

Source: https://reference.wolfram.com/language/ref/TropicalStormData.html

Retrieve and sort the start dates for all storms within a specific year using an entity association.

```Wolfram Language
Sort[TropicalStormData[["hurricanes in 1954"], EntityProperty["TropicalStorm", "StartDate"], "EntityAssociation"]]
```

--------------------------------

### Install WSTP-Installable Program

Source: https://reference.wolfram.com/language/guide/WSTPAPI.html

Use 'Install' to run a WSTP-installable external program. 'LinkPatterns' can find available functions, and 'wsprep' prepares the program.

```Wolfram Language
Install
LinkPatterns
wsprep
```

--------------------------------

### Get Database Examples Directory Path

Source: https://reference.wolfram.com/language/DatabaseLink/tutorial/UsingTheExampleDatabases.html.zh?source=footer

This code snippet shows the default location where database examples are stored within the user's base directory. Ensure this path is accessible for running examples.

```Wolfram Language
FileNameJoin[{$UserBaseDirectory, "DatabaseResources", "Examples"}]
```

--------------------------------

### Set Up Variables and Parameters

Source: https://reference.wolfram.com/language/PDEModels/tutorial/Acoustics/AcousticsFrequencyDomain.html.ja?source=footer

Initializes physical constants and domain parameters for the acoustic simulation.

```Wolfram Language
L = 1; rho = 1.2; c = 343; v0 = 1; omega = 2*Pi*100;
```

--------------------------------

### Launch the factor example with linklaunch

Source: https://reference.wolfram.com/language/tutorial/WSTPDeveloperGuide-Windows.html

Executes the factor program with the linklaunch flag to initiate a connection to the Wolfram kernel.

```shell
factor -linklaunch
```

--------------------------------

### Install via Git

Source: https://reference.wolfram.com/language/workflow/InstallTheWolframClientLibraryForPython.html

Installation method for developers requiring access to the full source code.

```bash
$ git clone git://github.com/WolframResearch/WolframClientForPython
```

```bash
$ cd WolframClientForPython
```

```bash
$ pip install .
```

--------------------------------

### Import and Plot Another Graph

Source: https://reference.wolfram.com/language/GraphUtilities/tutorial/GraphUtilities.html

Imports a different graph from example data and plots it with specified vertex coordinates. This is a setup for neighborhood vertices examples.

```Wolfram Language
g = ExampleData[{"Matrix", "CAN  292"}]; vr = Thread[VertexList[g] -> GraphCoordinates[g]]; GraphPlot[g, VertexCoordinateRules -> vr]
```

--------------------------------

### Initialize VideoReplace Data

Source: https://reference.wolfram.com/language/ref/VideoReplace?view=all

Setup code for video replacement examples.

```Wolfram Language
v = Video["ExampleData/fish.mp4"]; new = SlideShowVideo[{ConstantImage[GrayLevel[.2]] -> 1}];
```

```Wolfram Language
v = Video["ExampleData/fish.mp4"]; new = SlideShowVideo[{ConstantImage[GrayLevel[0.3]] -> 1}];
```

--------------------------------

### Install a Paclet

Source: https://reference.wolfram.com/language/tutorial/UpgradingFromMathematicaToWolfram.html

Use this command to install a specific paclet by name from the server.

```Wolfram Language
PacletInstall["PacletName"]
```

--------------------------------

### Initialize audio streams

Source: https://reference.wolfram.com/language/ref/AudioStreams.html

Examples showing the creation of audio streams for querying.

```Wolfram Language
a = Audio["ExampleData/rule30.wav"]; AudioPlay[a];
```

```Wolfram Language
a = Audio["ExampleData/rule30.wav"]; AudioStream[a]; b = Audio["ExampleData/rule30.wav"]; AudioStream[b];
```

--------------------------------

### Define Objective and Constraints

Source: https://reference.wolfram.com/language/ref/LinearOptimization.html

Common setup for linear optimization examples.

```Wolfram Language
obj = x + y; constr = {x + 2 y ≥ 3, -1 ≤ x ≤ 2, -1 ≤ y ≤ 1};
```

--------------------------------

### Test Example API from Browser

Source: https://reference.wolfram.com/language/CloudConnectorForExcel/tutorial/Setup.html.en?source=footer

Access an example API directly from a web browser to test its functionality. Ensure you use the correct cloud base and account for your installation.

```URL
https://www.mywolframcloud.com/objects/Documentation/Example/AddTwo?x=10&y=20
```

--------------------------------

### Install ZeroMQ for NodeJS on Windows

Source: https://reference.wolfram.com/language/workflow/ConfigureNodeJSForExternalEvaluate.html

Use npm to install the zeromq package in the user home directory on Windows.

```bash
**> cd %HOMEPATH%  
> npm install zeromq**
```

--------------------------------

### Install ffi-rzmq gem

Source: https://reference.wolfram.com/language/workflow/ConfigureRubyForExternalEvaluate.html

Commands to install the ZeroMQ Ruby binding for the current user or system-wide.

```bash
$ gem --user install ffi-rzmq
```

```bash
$ sudo gem install ffi-rzmq
```

--------------------------------

### Basic UnityNavMeshAgent Operations

Source: https://reference.wolfram.com/language/UnityLink/ref/UnityNavMeshAgent.html

Examples demonstrating package loading, project opening, agent creation, property retrieval, and agent deletion.

```wolfram
Needs["UnityLink`"]
```

```wolfram
UnityOpenProject["Path/To/Project"]
```

```wolfram
agent = UnityNavMeshAgentCreate[]
```

```wolfram
PropertyValue[agent, "Speed"]
```

```wolfram
UnityDelete[agent]
```

--------------------------------

### Get Information for Columns Starting with 'V' from All Tables

Source: https://reference.wolfram.com/language/DatabaseLink/ref/SQLColumnInformation.html

Fetches details for columns whose names start with 'V' across all tables in the database. The output is formatted as a table.

```Wolfram Language
SQLColumnInformation[conn, {"", "V%"}]//TableForm
```

--------------------------------

### Load Example Dataset

Source: https://reference.wolfram.com/language/workflow/SetUpAPersonalDataResource.html

Retrieves a sample dataset of planets and moons for use in a data resource.

```Wolfram Language
ExampleData[{"Dataset", "Planets"}]
```

--------------------------------

### Load and prepare example data

Source: https://reference.wolfram.com/language/ref/PivotFromColumns.html

Retrieves column headings and creates a Tabular object from example data.

```Wolfram Language
name = {"Statistics", "LakeMeadLevels"}; keys = ExampleData[name, "ColumnHeadings"];
```

```Wolfram Language
tab1 = Tabular[ExampleData[name], keys]
```

--------------------------------

### Launch MathLM Server

Source: https://reference.wolfram.com/language/tutorial/InstallingMathLM.html

Commands to navigate to the installation directory and start the MathLM server.

```bash
cd /usr/local/Wolfram/MathLM  
./mathlm
```

--------------------------------

### Factor application output example

Source: https://reference.wolfram.com/language/tutorial/WSTPDeveloperGuide-CMake.html

Example output showing prime factors returned by the Wolfram Language.

```text
Integer to factor: 123456789  
3 ^ 2  
3607 ^ 1  
3803 ^ 1
```

--------------------------------

### Handling Package Loading in Initialization

Source: https://reference.wolfram.com/language/ref/Initialization.html

Illustrates the correct way to load packages for use within dynamic initialization.

```Wolfram Language
DynamicModule[{x}, Dynamic[x], Initialization :> (Needs["PrimalityProving`"];x = ProvablePrimeQ[1093])]
```

```Wolfram Language
Needs["PrimalityProving`"]; DynamicModule[{}, DynamicModule[{x}, Dynamic[x], Initialization :> (x = ProvablePrimeQ[1093])], Initialization :> (Needs["PrimalityProving`"])]
```

--------------------------------

### Define Matrix for Arnoldi Examples

Source: https://reference.wolfram.com/language/ref/Eigensystem?view=all

Setup a matrix m for demonstrating Arnoldi criteria.

```Wolfram Language
d = DiagonalMatrix[{1, 0.8 + 0.8I, I}]; t = {{1, 2, 0}, {0, 3, 2}, {1, 0, 4}}; m = t.d.Inverse[t];
```

--------------------------------

### Use Initialization for setup

Source: https://reference.wolfram.com/language/ref/DynamicModule?view=all

Evaluates expressions before displaying the contents of the DynamicModule.

```Wolfram Language
DynamicModule[{x = .5}, Slider[Dynamic[x]], Initialization :> (SelectionMove[EvaluationNotebook[], All, EvaluationCell];SetOptions[NotebookSelection[], CellFrame -> 1, CellFrameColor -> Hue[x]])]
```

--------------------------------

### Select Data Matching a String Pattern (Starts With)

Source: https://reference.wolfram.com/language/DatabaseLink/ref/SQLSelect.html

Extracts data where a specific column's string value matches a pattern. This example selects IDs starting with 'C'.

```Wolfram Language
SQLSelect[conn, "ROYSCHED", {"TITLE_ID", "ROYALTY"}, SQLStringMatchQ[SQLColumn["TITLE_ID"], "C%"]]
```

--------------------------------

### Build factor.exe Example

Source: https://reference.wolfram.com/language/tutorial/WSTPDeveloperGuide-Windows.html

Commands to compile and link the factor.exe program, which calls the Wolfram Language kernel.

```batch
SET CL=/nologo /c /DWIN32 /D_CONSOLE /W3 /O2 /DNDEBUG  
SET LINK=/NOLOGO /SUBSYSTEM:console /INCREMENTAL:no /PDB:NONE kernel32.lib user32.lib  
CL factor.c  
LINK factor.obj wstp32i4m.lib /OUT:factor.exe
```

```batch
LINK factor.obj wstp64i4m.lib /OUT:factor.exe
```

--------------------------------

### Install ffi-rzmq on Windows

Source: https://reference.wolfram.com/language/workflow/ConfigureRubyForExternalEvaluate.html

Use the gem package manager to install the ffi-rzmq library required for Ruby integration on Windows.

```bash
> gem install ffi-rzmq
```

--------------------------------

### Initialize and verify a Wolfram Cloud session

Source: https://reference.wolfram.com/language/workflow/ConnectPythonToTheWolframCloud.html

Configure the session with credentials, start the connection, and verify authorization.

```python
key = SecuredAuthenticationKey( 'T2ghIEhpISDinIw=', 'VGhhdCdzIE1ZIHNlY3JldCE=')
session = WolframCloudSession(credentials=key) session.start()
session.authorized()
```

--------------------------------

### Use One Parameter Estimator to Get Starting Values for Another

Source: https://reference.wolfram.com/language/ref/FindDistributionParameters.html

Demonstrates using method of moments estimates as starting values for maximum likelihood estimation, and vice versa.

```Wolfram Language
data = {11.3, 19.2, 8.7, 17.5, 7., 17.1, 8.5, 9.8, 15.2, 10.4, 17.9, 20.3, 6.5, 7.9, 11.8, 8.5, 12.8, 14.2, 6.6, 9.};
```

```Wolfram Language
mm = FindDistributionParameters[data, ChiSquareDistribution[n], ParameterEstimator -> "MethodOfMoments"]
```

```Wolfram Language
FindDistributionParameters[data, ChiSquareDistribution[n], mm /. Rule -> List]
```

```Wolfram Language
mle = FindDistributionParameters[data, GammaDistribution[α, β]]
```

```Wolfram Language
FindDistributionParameters[data, GammaDistribution[α, β], mle /. Rule -> List, ParameterEstimator -> "MethodOfMoments"]
```

--------------------------------

### SystemInstall[system]

Source: https://reference.wolfram.com/language/ref/SystemInstall.html

Installs a specified system or software component on the local machine to enable its use within the Wolfram Language environment.

```APIDOC
## SystemInstall[system]

### Description
Installs a specified system or software component on the local machine. This is typically used to configure dependencies required by other Wolfram Language functions.

### Syntax
SystemInstall[system]

### Parameters
- **system** (String) - Required - The name of the system or software component to install (e.g., "Python", "WinPcap").

### Examples
```wolfram
SystemInstall["Python"]
SystemInstall["WinPcap"]
```
```

--------------------------------

### Build addtwo.exe Example

Source: https://reference.wolfram.com/language/tutorial/WSTPDeveloperGuide-Windows.html

Commands to compile and link the addtwo.exe program, which is called by the Wolfram Language kernel.

```batch
SET CL=/nologo /c /DWIN32 /D_WINDOWS /W3 /O2 /DNDEBUG  
SET LINK=/NOLOGO /SUBSYSTEM:windows /INCREMENTAL:no /PDB:NONE kernel32.lib user32.lib gdi32.lib  
WSPREP addtwo.tm -o addtwotm.c  
CL addtwo.c addtwotm.c  
LINK addtwo.obj addtwotm.obj wstp32i4m.lib /OUT:addtwo.exe
```

```batch
LINK addtwo.obj addtwotm.obj wstp64i4m.lib /OUT:addtwo.exe
```

--------------------------------

### Define Polynomials for Monomial Order Examples

Source: https://reference.wolfram.com/language/ref/PolynomialReduction.html

Setup for demonstrating different monomial orderings.

```Wolfram Language
polys = {3 x ^ 2 + y  - 5 x - 1, 2 x + 3 x y + y ^ 2}; poly = x y - 3 x y ^ 2  + 11y  + x  ^ 3;
```

--------------------------------

### Setup Dataset for Selection

Source: https://reference.wolfram.com/language/workflow/SelectElementsInADataset.html

Initializes the dataset from the Wolfram Data Repository for subsequent selection operations.

```Wolfram Language
data = ResourceData["Sample Data: Animal Weights"]
```

--------------------------------

### Initialize Network and Data

Source: https://reference.wolfram.com/language/ref/NetMeasurements.html

Common setup for MNIST-based neural network evaluation examples.

```Wolfram Language
net = NetModel["LeNet Trained on MNIST Data"] ; data = ResourceData["MNIST", "TestData"];
```

--------------------------------

### Execute Install Dialog

Source: https://reference.wolfram.com/language/ref/frontendobject/Install.html

Invokes the Install dialog box using the FrontEndExecute function.

```Wolfram Language
FrontEndExecute[FrontEndToken["Install"]]
```

--------------------------------

### Verify Node.js installation

Source: https://reference.wolfram.com/language/workflow/InstallTheWolframNotebookEmbedderLibrary.html

Check the installed version of Node.js from the command line.

```bash
$ node -v  
v9.11.1
```

--------------------------------

### Basic UnityCamera Operations

Source: https://reference.wolfram.com/language/UnityLink/ref/UnityCamera.html

Examples covering package loading, project opening, camera creation, property access, and deletion.

```Wolfram Language
Needs["UnityLink`"]
```

```Wolfram Language
UnityOpenProject["Path/To/Project"]
```

```Wolfram Language
cam = UnityCameraCreate[]
```

```Wolfram Language
UnityCameraProperty[cam, "Position"]
```

```Wolfram Language
UnityDeleteObject[cam]
```

--------------------------------

### Calculus Limit Proof

Source: https://reference.wolfram.com/language/ref/FunctionMonotonicity?view=all

Example setup for proving a limit exists using monotonicity.

```Wolfram Language
f = ArcTan[x] + Sin[x] / (2x ^ 2);
```

--------------------------------

### Setup Dataset for Column Extraction

Source: https://reference.wolfram.com/language/workflow/ExtractColumnsInADataset.html

Initializes a dataset of animal weights from the Wolfram Data Repository for subsequent extraction operations.

```wolfram
In[1]:=1
```

```wolfram
In[5]:=5
```

--------------------------------

### Install ZeroMQ for NodeJS on Mac

Source: https://reference.wolfram.com/language/workflow/ConfigureNodeJSForExternalEvaluate.html

Use npm to install the zeromq package in the home directory on macOS.

```bash
**$ cd ~  
$ npm install zeromq**
```

--------------------------------

### Initialize MathLink Environment

Source: https://reference.wolfram.com/language/ref/c/MLNewParameters.html

Demonstrates allocating parameters, setting custom allocation functions, and initializing the MathLink environment.

```c
#include <stdlib.h>  
#include "mathlink.h"  
  
/* initialize the MathLink environment */  
  
MLENV f(void)  
{  
	MLENV env;  
	MLEnvironmentParameter p;  
	unsigned long res;  
  
	p = MLNewParameters(MLREVISION, MLAPIREVISION);  
	if(p == (MLEnvironmentParameter)0)  
	{ /* Unable to initialize parameter object */ }  
  
	MLSetAllocParameter(p, malloc, free);  
  
	env = MLInitialize(p);  
	if(env == (MLENV)0)  
	{ /* Unable to initialize the MathLink environment */ }  
  
	MLReleaseParameters(p);  
  
	return env;  
}
```

--------------------------------

### Get Information About a Specific Data Source

Source: https://reference.wolfram.com/language/DatabaseLink/ref/DataSources.html

Query information for a specific named data source by providing its name as an argument to DataSources. For example, to get details about the 'demo' data source.

```Wolfram Language
DataSources["demo"]
```

--------------------------------

### Invoke Wolfram Kernel from External Program

Source: https://reference.wolfram.com/language/tutorial/WSTPDeveloperGuide-Macintosh.html

Commands to launch the factor example and interact with the Wolfram Kernel.

```bash
factor -linkmode launch -linkname '"/Applications/Mathematica.app/Contents/MacOS/WolframKernel" -wstp'
```

```text
Integer to factor:
```

```text
Integer to factor: 123456789  
3 ^ 2  
3607 ^ 1  
3803 ^ 1
```

--------------------------------

### Install WolframScript on Linux

Source: https://reference.wolfram.com/language/workflow/InstallWolframScript.html

Run the appropriate package manager command based on the Linux distribution.

```bash
~$ sudo rpm -Uvh WolframScript_12.0.0_LINUX64_x86_64.rpm
```

```bash
~$ sudo dpkg -i WolframScript_12.0.0_LINUX64_x86_64.deb
```

--------------------------------

### Testing Multistep Operations

Source: https://reference.wolfram.com/language/tutorial/UsingTheTestingFramework.html

Example of setting up a test sequence involving file I/O operations.

```Wolfram Language
expr = NumericArray[Range[10]]
```

```Wolfram Language
output = Export[CreateFile[], expr, "WXF"]
```

--------------------------------

### InstallNET[]

Source: https://reference.wolfram.com/language/NETLink/ref/InstallNET.html

Launches the .NET runtime and prepares it to be used from the Wolfram Language. Subsequent calls have no effect if the runtime is already launched.

```APIDOC
## InstallNET[]

### Description
Launches the .NET runtime and prepares it to be used from the Wolfram Language. This is the basic way to start the .NET integration.

### Method
Wolfram Language Function Call

### Endpoint
N/A (Local function call)

### Parameters
This function does not take any explicit parameters in its basic form.

### Request Example
```wolfram
Needs["NETLink`"]
InstallNET[]
```

### Response
### Success Response (200)
Indicates successful launch of the .NET runtime.

### Response Example
```wolfram
(* Output may vary, but typically indicates success or returns a representation of the link if already running *)
```
```

--------------------------------

### IncrementalFunction for Repeated Elements

Source: https://reference.wolfram.com/language/CompilerManual/tutorial/Examples.html

This IncrementalFunction example takes a packed array of integers and yields the positions of elements that are the same. It records the start value and position, then traverses the list, comparing each element to the start value. If values differ, it yields the start and end positions and updates the start value and position. Finally, it yields the remaining positions.

```Wolfram Language
IncrementalFunction[
  (If[#2 === #1[[1]],
    Append[#1, #2[[2]]],
    Append[#1, {#2[[1]], #2[[2]]}]
   ]) &, 
  {First[#], {Last[#], 1}} &, 
  Function[Null, 
   If[Last[#] === Last[#2[[1]]],
    Append[#2, Last[#]],
    Append[#2, {Last[#], Last[#2[[1]]]}]
   ]] &,
  Function[Null, 
   If[Last[#] === Last[#2[[1]]],
    Append[#2, Last[#]],
    Append[#2, {Last[#], Last[#2[[1]]]}]
   ]] &
 ]
```

--------------------------------

### Install Julia Packages

Source: https://reference.wolfram.com/language/workflow/ConfigureJuliaForExternalEvaluate.html

Use the Julia package manager to install the ZMQ and BSON packages required for external evaluation.

```julia
**julia> using Pkg  
  
julia> Pkg.add("ZMQ")  
  
julia> Pkg.add("BSON")**
```

--------------------------------

### Uninstall[link]

Source: https://reference.wolfram.com/language/ref/Uninstall.html.en?source=footer

Terminates an external program started by Install and removes Wolfram Language definitions set up by it.

```APIDOC
## Uninstall[link]

### Description
Terminates an external program started by Install and removes Wolfram Language definitions set up by it. The argument is a LinkObject representing a WSTP link as returned by Install.

### Syntax
- **Uninstall[link]** - Terminates the program associated with the specified LinkObject.
- **Uninstall["name"]** - Terminates the program with the specified name if only one such program is linked.

### Parameters
- **link** (LinkObject or String) - Required - The LinkObject returned by Install or the name of the linked program.
```

--------------------------------

### Basic usage of WSDeinitialize

Source: https://reference.wolfram.com/language/ref/c/WSDeinitialize.html

Demonstrates the standard lifecycle of a WSTP environment, including initialization and deinitialization.

```c
#include "wstp.h"  
  
int main(int argc, char **argv)  
{  
	WSENV ep;  
  
	ep = WSInitialize((WSEnvironmentParameter)0);  
  
	...  
  
 	WSDeinitialize(ep);
	return 0;  
}
```
Tokens:
Raw