JMP

https://origin-www.jmp.com/support/help/en/18.0/
Admin
JMP is a statistical discovery software that provides tools for data analysis, visualization,...
Tokens:48,562
Snippets:452
Trust Score:7.5
Update:8 months ago
Show doc for...
Tokens:
Raw
### Custom Transform Example in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Provides a concrete example of implementing a custom transform for a column in JMP using JSL. This demonstrates how to apply user-defined calculations.

```JSL
dt = Open("Sample Data.jmp");
// Define a custom transform function
MyTransform = Function( {x}, If(x > 10, x * 1.1, x * 0.9) );

// Apply the custom transform to a new column
dt << Add Column("Adjusted Value", Numeric, "Continuous", Formula(MyTransform(Column("Original Value"))));
```

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

### Scripting a Platform Example in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Provides a basic example of how to script a JMP analysis platform using JSL. This involves launching the platform with specific data and options.

```JSL
dt = Open("Sample Data.jmp");

// Launch the Distribution platform for a column
Distribution(Numeric(Y(Column(dt, "Response"))));

// Launch Fit Y by X platform
Fit Y by X(Y(Column(dt, "Response")), X(Column(dt, "Predictor")));
```

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

### Interpret the Show Properties List in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Guides users on how to interpret the output of the 'Show Properties' message in JSL, which lists the configurable properties of JMP objects.

```JSL
// The 'Show Properties' list is typically viewed interactively or by capturing output.
// Example: Getting properties of a column
dt = Open("Sample Data.jmp");
col = Column(dt, "MyColumn");
Show(col << Show Properties);

// Interpretation involves understanding the property names and their possible values.
```

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

### Get Calculator Formulas in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Demonstrates how to retrieve the formulas used in JMP's calculator functions using JSL. This allows for programmatic access to calculation logic.

```JSL
// This is a conceptual example, as direct retrieval of 'calculator formulas' as a distinct entity
// might not be exposed in a simple Get() message. Often, formulas are associated with columns.
// If referring to formulas within a specific platform's calculator:
// You would typically interact with the platform's scripting interface.

// Example: Getting a formula from a column
dt = Open("Sample Data.jmp");
col = Column(dt, "Formula Column");
formula_text = col << Get Property("Formula");
Show(formula_text);
```

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

### Add Several Columns at Once in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Provides an example of adding multiple columns to a JMP data table simultaneously using JSL. This improves efficiency when setting up new data structures.

```JSL
dt = Open("Sample Data.jmp");
dt << Add Columns({"Col1", "Col2", "Col3"}, Numeric, "Continuous");
```

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

### Get JMP Product Information in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Retrieve the name and version of the JMP product currently running. This information can be useful for script compatibility checks or for displaying version-specific messages to the user.

```JSL
JMP Product Name();
JMP Version();
```

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

### Set or Get Column Properties in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Illustrates how to set and retrieve properties of columns in a JMP data table using JSL. Properties include things like data type, format, and formula.

```JSL
dt = Open("Sample Data.jmp");
col = Column(dt, "MyColumn");

// Set a property (e.g., data type)
col << Set Property("Data Type", "Numeric");

// Get a property (e.g., formula)
formula = col << Get Property("Formula");
Show(formula);
```

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

### Get Column Names in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Demonstrates how to retrieve a list of all column names from a JMP data table using JSL. This is useful for iterating through columns or referencing them programmatically.

```JSL
dt = Open("Sample Data.jmp");
column_names = dt << Get Column Names("String");
Show(column_names);
```

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

### JSL File and Directory Operations

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Provides JSL functions for interacting with the file system, including selecting directories or files, getting lists of filenames, and connecting to network directories. Essential for data import/export and script management.

```JSL
selectedFile = Pick File();
fileList = Files("*.jsl");
// Example for network directory (syntax may vary based on OS and network setup)
// networkDir = Connect to Network Directory("\\server\share");
```

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

### File Operations: Creating and Deleting Directories

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Functions for managing directories. `Create Directory` creates a new directory at the specified path. `Delete Directory` removes a directory and optionally allows undo.

```javascript
Create Directory("new/directory/path");
Delete Directory("directory/to/delete", Allow Undo(1));
```

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

### Save Platform Settings as a Platform Preset in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Demonstrates how to save the current settings of a JMP analysis platform as a reusable preset using JSL. Presets streamline repeated analyses with consistent configurations.

```JSL
dt = Open("Sample Data.jmp");
my_dist = Distribution(Numeric(Y(Column(dt, "Response"))));

// Save the current settings as a preset named 'My Distribution Preset'
my_dist << Save Preset("My Distribution Preset");
my_dist <<
```

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

### JSL Character Functions

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Provides examples of JSL character functions for string manipulation, conversion, and analysis. These functions are crucial for text processing within JMP scripts.

```jsl
BLOB To Char(blob, <Encoding="enc">);
BLOB To Matrix(blob, type, bytes, endian, <nCols>);
Char(x, <width>, <decimal>, <<Use Locale(Boolean)>);
Char To BLOB(string, <encoding="enc">);
Char To Hex(value, <integer|encoding="enc">);
Collapse Whitespace(text);
Concat(a, b);
Concat Items;
Concat To(a, b);
Contains(whole, part, <start>);
Contains Item(x, <item | {list} | pattern>, <delimiter>);
Ends With(string, substring);
Hex(value, <integer|encoding="enc"|Base(number)|Pad To(number)>);
Hex To BLOB(string);
Hex To Char(string, <encoding>);
Hex To Number(string, <Base(number)>);
Insert;
Insert Into;
Item(n|[first last], string, <delimiter>, <Unmatched(result string)>, <Include Boundary Delimiters(Boolean)>);
Left(string, n, <filler>);
Length(string);
Lowercase(string);
Matrix to BLOB(matrix, type, bytesEach, endian(value));
Munger(string, start position, find|length, <replacement string>);
Num(string);
Regex(source, pattern, (<replacement string>, <format, "GLOBALREPLACE", "IGNORECASE">>);
Remove;
Remove From;
Repeat(source, a);
Reverse;
Reverse Into;
Right(string, n, <filler>);
Shift;
Shift Into;
```

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

### Enable User Input in JMP Platforms in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Demonstrates techniques for allowing users to provide input directly within JMP platform dialogs when scripting with JSL. This enhances script flexibility.

```JSL
// This often involves creating custom dialogs or using platform-specific scripting hooks.
// Example: Using a dialog to get a threshold value for an analysis
dt = Open("Sample Data.jmp");
threshold = Input("Enter threshold value:", 100);

// Use the threshold in a platform launch
// Example: Filter data based on user input before launching platform
filtered_dt = dt << Subset(Rows(Where(Column("Value") > threshold)));
Distribution(Numeric(Y(Column(filtered_dt, "Response"))));
```

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

### Enable Users to Specify Columns in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Demonstrates how to create dialogs or prompts in JSL that allow users to select columns for analysis. This makes scripts more interactive and user-friendly.

```JSL
dt = Open("Sample Data.jmp");

// Use a dialog to get column selections
choose_cols = Pick Columns(dt, "Select columns for analysis:");

// Check if the user made a selection
If(Is(choose_cols), 
  Show("User selected columns:", choose_cols)
);
```

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

### Send Messages to an Object in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

A general example of sending messages to various JMP objects (data tables, columns, platforms) using JSL. This is the core mechanism for scripting interactions.

```JSL
dt = Open("Sample Data.jmp");

// Message to data table
dt << New Column("Calculated", Numeric);

// Message to column
Column(dt, "Calculated") << Set Formula(Column(dt, "A") + Column(dt, "B"));

// Message to platform (example - requires platform to be open)
// my_platform << Some Message;
```

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

### Open Datafeed and Help Resources in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Functions to open data feeds and JMP's help system. 'Open Datafeed' initiates a data connection, while 'Open Help' can open the main help documentation or the scripting index.

```JSL
Open Datafeed();
Open Help("Help" | "Scripting Index", ...);
```

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

### MATLAB Control and Execution Functions

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Functions to initialize, control, and execute MATLAB sessions or code from within JMP. These include starting and terminating MATLAB, sending commands, and submitting scripts.

```MATLAB
MATLAB Control( <named arguments> )
MATLAB Execute( { list of inputs }, { list of outputs }, mCode, <named arguments> )
MATLAB Get( name )
MATLAB Get Graphics( format )
MATLAB Get Version
MATLAB Init( <named arguments> )
MATLAB Is Connected()
MATLAB JMP Name To MATLAB Name( name )
MATLAB Send( name, <named arguments> )
MATLAB Send File(filename, <MATLAB Name(name)>)
MATLAB Submit File( pathname, <named arguments> )
MATLAB Submit( mCode, <named arguments> )
MATLAB Term();
```

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

### Send Messages to a Platform in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Shows how to send messages (commands) to an open JMP analysis platform using JSL. This allows for dynamic control and customization of platform outputs.

```JSL
dt = Open("Sample Data.jmp");
// Launch a platform and store a reference to its window
my_dist = Distribution(Numeric(Y(Column(dt, "Response"))));

// Send a message to the platform (e.g., add a histogram)
my_dist << Histogram;
```

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

### Set or Get Values by Column Name in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Shows how to access and modify data values in a JMP data table using column names in JSL. This is a common method for data manipulation.

```JSL
dt = Open("Sample Data.jmp");
// Get value from a specific cell
value = Column(dt, "MyColumn")[5]; // Value from row 5, MyColumn
Show(value);

// Set value in a specific cell
Column(dt, "MyColumn")[10] = 99.9;
```

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

### Create Columns in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Shows how to create new columns in a JMP data table using JSL. This includes specifying column names, data types, and initial values.

```JSL
dt = Open("Sample Data.jmp");
dt << Add Column("New Numeric Column", Numeric, "Continuous", Formula(10));
dt << Add Column("New Text Column", Character, "Nominal");
```

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

### Set or Get Column Attributes in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Explains how to set and retrieve various attributes of columns in a JMP data table using JSL. Attributes provide metadata about columns, such as their role or modeling type.

```JSL
dt = Open("Sample Data.jmp");
col = Column(dt, "MyColumn");

// Set an attribute
col << Set Attribute("Modeling Role", "Predictor");

// Get an attribute
role = col << Get Attribute("Modeling Role");
Show(role);
```

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

### File Operations: Checking File and Directory Existence

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Functions to verify the existence of files and directories. `Directory Exists` returns true if the directory exists, and `File Exists` returns true if the file exists.

```javascript
If(Directory Exists("path/to/check"),
	Print("Directory exists."));
If(File Exists("path/to/file.txt"),
	Print("File exists."));
```

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

### JSL Exception Handling (Throw and Catch)

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Demonstrates how to implement exception handling in JSL using Throw and Catch statements. This allows for robust error management by gracefully handling unexpected situations during script execution.

```JSL
Try(
  Throw("An error occurred!");
, Catch(e),
  Show(e)
);
```

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

### Group Columns in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Demonstrates how to group columns in a JMP data table using JSL. Grouping helps organize columns, especially in wide data tables.

```JSL
dt = Open("Sample Data.jmp");
dt << Group Columns({"Col1", "Col2"});
```

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

### JMP Keyboard Shortcuts - Common Clicks and Special Functions

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Lists shortcuts for common mouse clicks and special function keys used within the JMP environment.

```N/A
# Common Clicks
# Special Functions
```

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

### JMP Keyboard Shortcuts - File and Window Management

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Details keyboard shortcuts for working with files (opening, saving) and managing JMP windows (navigating, closing).

```N/A
# Working with Files
# Window Commands
```

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

### Create Column References in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Shows how to create references to columns in JSL, which can then be used in various JMP functions and messages. This is essential for robust scripting.

```JSL
dt = Open("Sample Data.jmp");

// Create a column reference by name
ref_col_A = Column(dt, "Column A");

// Create a column reference by index
// ref_col_B = Column(dt, 2);

// Use the reference in a message
ref_col_A << Set Name("Renamed Column A");
```

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

### Load Dynamic Link Libraries (DLLs) in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Allows JSL scripts to load external Dynamic Link Libraries (DLLs). The 'path' argument specifies the DLL to load. Optional arguments control the declaration behavior (AutoDeclare) and verbosity of the loading process.

```JSL
Load DLL("path" <,AutoDeclare(Boolean | Quiet | Verbose)>);
```

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

### File Operations: Copying Directories and Files

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Functions for copying directories and files. `Copy Directory` can recursively copy a directory and its contents. `Copy File` copies a single file.

```javascript
Copy Directory("source/path", "destination/path", Recursive(1));
Copy File("source/file.txt", "destination/file.txt");
```

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

### Make the Platform Analysis Invisible in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Illustrates how to run JMP analyses using JSL without displaying the platform window to the user. This is useful for background processing or creating custom reports.

```JSL
dt = Open("Sample Data.jmp");

// Launch a platform invisibly
New Window("Invisible Analysis", // Title for the hidden window
  Outline Box("Analysis Results",
    // Launch platform here, it won't show by default
    Distribution(Invisible, Numeric(Y(Column(dt, "Response"))))
  )
);

// Results might be captured or used in subsequent steps.
```

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

### Configure Platform and General Preferences in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Allows modification of JMP preferences. 'Platform Preferences' sets preferences specific to a JMP platform, while 'Preferences' sets general JMP preferences. 'Set Platform Preference' and 'Set Preference' are also available for setting individual preferences.

```JSL
Platform Preferences(platform(option(value)), ...);
Preferences(pref1(value1), ...);
Set Platform Preference();
Set Preference();
```

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

### Create Custom Functions, Transforms, and Formats in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Explains the process of creating custom functions, transforms, and formats within JMP using JSL. This allows for highly specialized data processing and display.

```JSL
// Example of a custom function
my_custom_function = Function( {x}, x * 2 + 5 );

// Example of a custom transform (used in a formula)
dt = Open("Sample Data.jmp");
dt << Add Column("Transformed", Numeric, "Continuous", Formula(my_custom_function(Column("Original"))));

// Example of a custom format (requires more setup, often involves a dialog)
// This is a conceptual example, actual implementation is more complex.
```

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

### Assign Colors and Markers to Rows in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Illustrates how to assign colors and markers to rows in a JMP data table using JSL. This is useful for visual data exploration and highlighting specific observations.

```JSL
dt = Open("Sample Data.jmp");
// Assign color to selected rows
dt << Select Where(Column("Status") == "High");
dt << Set Row Color("Red");

// Assign marker to specific rows
// dt << Set Row Marker(Rows({1, 2, 3}), "Star");
```

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

### Execute Embedded Red Triangle Options in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Shows how to programmatically execute the options found in the red triangle menus of JMP platforms using JSL. This allows for automation of common analysis steps.

```JSL
dt = Open("Sample Data.jmp");
// Launch a platform and get a reference
my_dist = Distribution(Numeric(Y(Column(dt, "Response"))));

// Execute a red triangle option (e.g., add a Quantiles report)
my_dist << Quantiles;
```

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

### JSL String Comparison and Scheduling

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Includes functions for identifying differences between strings, lines, or sequences, and for scheduling actions to occur at specific times or intervals. Useful for data validation and automated tasks.

```JSL
// Placeholder for string comparison and scheduling examples
// Functions for comparing strings and scheduling tasks would be implemented here.
```

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

### Import Multiple Files in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Initiates the process of importing multiple files into JMP. The 'arguments' parameter would typically specify the files or a pattern to match files for import.

```JSL
Multiple File Import(arguments);
```

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

### JMP Project and Window Management Functions

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Functions for retrieving and manipulating projects and windows within the JMP environment. These are essential for automating workflows, managing multiple analyses, and organizing JMP sessions.

```JSL
Get Project(title|index|display box|window)
Get Project List()
Get Window(<Project(title|index|display box|window)>, <Type(string)>, title|index|display box)
Get Window List(<Project(title|index|display box|window),><Type(string)>)
Move to Project(<Source(project)|Destination(project)>, <Windows({list of windows to move})>)
New Project(arguments)
New Window(title, <optional arguments>, displayBox | script)
```

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

### JSL Associative Array Operations

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Explains how to create and utilize associative arrays (hash maps) in JSL. Covers working with key-value pairs, and their applications in graph theory and set operations. Useful for efficient data lookups.

```JSL
myAssocArray = (:name = "Alice", :age = 30);
print(myAssocArray:name);
myAssocArray:city = "New York";
```

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

### Specify Engineering SI Units in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Shows how to specify engineering SI units for columns in JMP using JSL. This ensures correct interpretation and display of measurements.

```JSL
dt = Open("Sample Data.jmp");
col = Column(dt, "Measurement");
col << Set Units("meters"); // Example: setting units to meters
```

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

### Specify Multiple Column Names at Once in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Illustrates how to provide a list of column names to JMP functions or messages in JSL, enabling operations on multiple columns simultaneously.

```JSL
dt = Open("Sample Data.jmp");
columns_to_process = {"Col1", "Col2", "Col3"};

// Example: Setting modeling role for multiple columns
dt << Set Modeling Role(columns_to_process, "Predictor");

// Example: Removing multiple columns
// dt << Remove Columns(columns_to_process);
```

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

### Cauchy Distribution Functions

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Functions for the Cauchy distribution, known for its heavy tails. This includes calculating the probability density (Cauchy Density), the cumulative distribution function (Cauchy Distribution), and the quantile function (Cauchy Quantile). Optional parameters for the location (center) and scale are provided.

```JSL
Cauchy Density(q, <center=0>, <scale=1>)
Cauchy Distribution(q, <center=0>, <scale=1>)
Cauchy Quantile(p, <center=0>, <scale=1>)
```

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

### Select Rows in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Illustrates how to select rows in a JMP data table programmatically using JSL. Selection is often a precursor to other row operations.

```JSL
dt = Open("Sample Data.jmp");
// Select rows based on a condition
dt << Select Where(Column("Value") > 100);

// Select specific rows by index
// dt << Select Rows({2, 4, 6});
```

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

### File Operations: Loading and Saving Text Files

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Handles reading from and writing to text files. `Load Text File` allows specifying character set, error handling, and line separators. `Save Text File` can replace or append content.

```javascript
text_content = Load Text File("input.txt");
Save Text File("output.txt", text_content);
Save Text File("log.txt", "New log entry.", Mode("Append"));
```

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

### Financial Functions: Time Value of Money Calculations

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Provides functions for common financial calculations. Includes `Future Value`, `Net Present Value`, and `Interest Rate` calculations based on provided financial parameters.

```javascript
fv = Future Value(0.05, 10, -100);
nv = Net Present Value(0.05, [100, 100, 100]);
rate = Interest Rate(10, -100, 1000);
```

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

### Data Summarization and Aggregation in JMP Scripting Language

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Functions to summarize and aggregate data, including calculating maximum, minimum, mean, median, standard deviation, and quantiles. The 'Summarize' and 'Summarize YByX' functions offer flexible options for grouping and calculating various statistics.

```JSL
Max()
Maximum(var1, var2, ...)
Mean(var1, var2, ...)
Median(var1, var2, ...)
Min()
Minimum(var1, var2, ...)
N Missing(expression)
Number(var1, var2, ...)
Product(i=initialValue, limitValue, bodyExpr)
Quantile(p, arguments)
Range(var1, var2, ...)
Robust PCA(X, <Lambda(2/sqrt(max(nrow, ncol)))>, <tolerance=1e-10>, <maxit(75)>, <Center(1)>, <Scale(1)>)
Std Dev(var1, var2, ...)
Sum(var1, var2, ...)
SSQ(x1, ...)
Summarize(<dt>, <by>, <count>, <sum>, <mean>, <min>, <max>, <stddev>, <corr>, <quantile>, <first>)
Summarize YByX(X(<x columns>, Y (<y columns>), Group(<grouping columns>), Freq(<freq column>), Weight(<weight column>))
Summation(init, limitvalue, body)
Tolerance Limit(1-alpha, p, n)
```

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

### Statistical Distributions in JMP

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Provides functions for calculating probabilities, quantiles, and general distribution properties for several common statistical distributions. These functions are essential for statistical analysis and modeling within JMP.

```JSL
Gamma Poisson Distribution(k, lambda, sigma)
Gamma Poisson Probability(k, lambda, sigma)
Gamma Poisson Quantile(lambda, sigma, cumprob)
Hypergeometric Distribution(N, K, n, x, <r>)
Hypergeometric Probability(N, k, n, x, <r>)
Neg Binomial Distribution(p, n, k)
Neg Binomial Probability(p, n, k)
Poisson Distribution(lambda, k)
Poisson Probability(lambda, k)
Poisson Quantile(lambda, cumprob)
```

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

### JMP Windows Menu Descriptions

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Provides descriptions of the menus available in the JMP application window, including File, Edit, Tables, Rows, Cols, Analyze, Graph, Tools, Project, View, Window, and Help menus.

```N/A
# File Menu
# Edit Menu
# Tables Menu
# Rows Menu
# Cols Menu
# DOE Menu
# Analyze Menu
# Graph Menu
# Tools Menu
# Project Menu
# View Menu
# Window Menu
# Help Menu
```

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

### Evaluate Formulas in Data Tables in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Shows how to trigger the evaluation of formulas in JMP data table columns using JSL. This ensures that calculated columns are up-to-date.

```JSL
dt = Open("Sample Data.jmp");
// Evaluate all formulas in the data table
dt << Evaluate Formulas;

// Evaluate formulas for specific columns
// dt << Evaluate Formulas(Column("Calculated Column"));
```

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

### JMP Keyboard Shortcuts - Scripting and Tools

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Includes keyboard shortcuts relevant to the Script Editor, Formula Editor, JMP Tools, and project management.

```N/A
# Script Editor
# Projects
# Formula Editor
# JMP Tools
```

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

### JSL Data Table Operations (Basic)

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Covers the essential scripting operations for data tables in JSL, including opening, creating, saving, naming, hiding, printing, resizing, closing, and setting/getting data table properties. Also includes journal and Excel workbook creation.

```JSL
dt = Open("data.jmp");
new_dt = New Table("MyData", Add Columns({"ID"("Numeric")}));
Save(dt, "backup.jmp");
Close(dt);
```

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

### JMP Keyboard Shortcuts - Data Table Actions

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Lists keyboard shortcuts related to common actions performed within JMP data tables, such as selecting, editing, and navigating data.

```N/A
# Data Table Actions
```

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

### Find Messages for Objects in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Explains how to discover available messages (commands) that can be sent to JMP objects (like platforms or data tables) using JSL. This is crucial for scripting.

```JSL
dt = Open("Sample Data.jmp");

// Find messages for the data table object
Show(dt << Get Messages);

// Find messages for a specific platform (e.g., Distribution)
my_dist = Distribution(Numeric(Y(Column(dt, "Response"))));
Show(my_dist << Get Messages);
my_dist << Close;
```

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

### Compress Selected Columns in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Shows how to compress selected columns in a JMP data table using JSL. This can save memory and disk space by optimizing data storage.

```JSL
dt = Open("Sample Data.jmp");
selected_cols = {"Column X", "Column Y"};
dt << Set Selected(selected_cols);
dt << Compress Selected Columns;
```

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

### JSL System and Utility Functions

Source: https://origin-www.jmp.com/support/help/en/18.0/index

This section covers JSL functions for interacting with the JMP environment, system preferences, and external resources like DLLs and mail.

```APIDOC
## JSL System and Utility Functions

### Description
These JSL functions allow for interaction with the JMP platform, including managing preferences, handling clipboard data, interacting with DLLs, and sending emails.

### Method
N/A (These are function calls within JSL scripts)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```jsl
// Example: Get JMP version information
version = JSL JMP Version();

// Example: Set a platform preference
JSL Set Platform Preference("language", "English");

// Example: Load a DLL
JSL Load DLL("my_library.dll");
```

### Response
N/A (Results are returned as JSL variables or modify system state)

#### Success Response (N/A)
N/A

#### Response Example
N/A
```

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

### Color Cells in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Demonstrates how to color individual cells within a JMP data table using JSL. This provides fine-grained visual control over data presentation.

```JSL
dt = Open("Sample Data.jmp");
// Color a specific cell
cell_ref = Cell(dt, 5, "Value Column");
cell_ref << Set Cell Color("Yellow");

// Color cells based on a condition
dt << Color Cells(Formula(If(Column("Value") < 0, "Light Blue", "White")));
```

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

### Execute External Programs in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Launches an external executable file. It allows specifying the executable path, command-line options, and functions to handle the program's output and input.

```JSL
Run Program(Executable("path/filename.exe"), Options({"/a", "/b", "..."}), Read Function(expression), Write Function(expression), Parameter(expression));
```

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

### Table Scripts in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Demonstrates how to add and manage scripts directly associated with a JMP data table using JSL. These scripts can be executed automatically or manually.

```JSL
dt = Open("Sample Data.jmp");
script_code = "
  // This script runs when the table is opened
  Show("Data table opened!");
";
dt << Add Script("OnOpen Script", script_code);

// To execute a script manually
// dt << Run Script("OnOpen Script");
```

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

### JSL Pattern Matching Functions

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Enables pattern matching within strings using fixed fields and case sensitivity options. Includes troubleshooting tips for pattern-related issues. Useful for parsing structured text data.

```JSL
// Placeholder for Pattern Matching function examples
// Specific functions like Parse Strings in Fixed Fields would be used here.
```

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

### Open Web Content in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Opens a specified URL in a JMP window or the system's default web browser. This allows for displaying web content directly within or alongside JMP.

```JSL
Web(string, <JMP Window>);
```

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

### Gamma Distribution Functions

Source: https://origin-www.jmp.com/support/help/en/18.0/index

This group of functions covers the Gamma distribution, used for modeling waiting times or continuous positive random variables. It includes density (Gamma Density), distribution (Gamma Distribution), log cumulative distribution (Gamma Log CDistribution), log density (Gamma Log Density), log distribution (Gamma Log Distribution), and quantile (Gamma Quantile) calculations. Parameters include shape (alpha), scale, and an optional threshold.

```JSL
Gamma Density(x, <alpha=1>, <scale=1>, <threshold=0>)
Gamma Distribution(x, <alpha=1>, <scale=1>, <threshold=0>)
Gamma Log CDistribution(x, <alpha=1>, <scale=1>, <threshold=0>)
Gamma Log Density(x, <alpha=1>, <scale=1>, <threshold=0>)
Gamma Log Distribution(x, <alpha=1>, <scale=1>, <threshold=0>)
Gamma Quantile(p, <alpha=1>, <scale=1>, threshold>)
```

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

### Add a Column Switcher in JSL

Source: https://origin-www.jmp.com/support/help/en/18.0/index

Demonstrates how to add a column switcher to a JMP data table using JSL. A column switcher allows users to easily change which columns are displayed.

```JSL
dt = Open("Sample Data.jmp");
dt << Add Column Switcher;
```
Tokens:
Raw