Columns | JMP 12

Columns

This section covers actions that you can perform on columns in a data table, such as creating, grouping, setting and getting attributes and properties, and so on.

Note: JMP can display math symbols and Greek letters (controlled in Preferences in the Font category). This means that if you save a column (such as T square limits), the column name could either be “T Square Limits” (no special characters) or “T2 Limits” (with special characters). Any reference using the column name must match the name exactly, or it fails.

Send Messages to Data Column Objects

Just as you send data table messages to a data table reference, you can send column messages to a reference to a data column object. The Column function returns a data column reference. Its argument is either a name in quotation marks, something that evaluates to a name in quotation marks, or a number.

Column("age"); // a reference to the age column

col = Column(2); // assigns a reference to the second column

This book uses col to represent data column references. To see the messages that you can send to data column objects, refer to the Scripting Index (Data Tables > Column Scripting). Alternatively, you can use the Show Properties command, as follows:

Show Properties(col);

Note: With column references, you must include a subscript to refer to the individual data values. Without a subscript, the reference is to the column object as a whole.

Once you have stored a data column reference in a global variable, to modify columns, you send messages to the data column reference.

Sending messages to columns is comparable to sending messages to data tables. Either state the object, a double-angle operator <<, and then the message with its arguments in parentheses, or use the Send() function with the object and then the message. In some cases the messages themselves need no arguments, so the trailing parentheses are optional.

col << message(arg, arg2, ...);

Send(col, message(arg, arg2, ...));

As with data tables and other types of objects, you can stack or list messages, as follows:

col << message << message2 << ...

col << {message, message2, ...};

Tip: To delete a column, you must send the message to a data table reference, because objects cannot delete themselves, only their containers can delete them.

Access Cell Values through Column References

Always use a subscript on a column reference to access the values in the cells of columns. Without a subscript, the reference is to the column object as a whole.

x = col[irow] // specific row

x = col[] // current row

col[irow] = 2; // as an l-value for assignment

currentDataTable()<<Select Where(col[]<14); // in a WHERE clause

Access Cell Values that have Value Labels

If the column whose values you want to access has a Value Label property, you might want to access the value label (formatted value) instead of the actual data value. To do this, use the formatted option. Consider the following example:

dt=open("$SAMPLE_DATA\Big Class.jmp");

dt << Run Script("Set Age Value Labels");

x = column(current data table(), "age", formatted)[1];

show (x);

y = column(current data table(), "age")[1];

show (y);

The log returns the formatted value for x, which is twelve, and the actual data value for y, which is 12.

Create Columns

To add a new column to a data table, send a New Column message to a data table reference. The first argument, the column’s name, is required. Either enclose the name in quotation marks or specify an expression evaluating to the name.

dt = Current Data Table();

dt << New Column("wafer");

a = "wafer";

dt << New Column(a);

If the table already includes a column by the same name, a sequential numeric value is appended to the new column name (wafer, wafer 2, wafer 3, and so on).

Unless otherwise specified, columns are numeric, continuous, and 10 characters wide.

•	Data type (numeric, character, or row state)

•	Analysis type (continuous, nominal, or ordinal)

•	Column width (only for numeric columns)

•	Numeric format

The following example creates a new column whose data type is numeric, analysis type is continuous, width is set to 5, and numeric format is set to Best:

dt << New Column("wafer", Numeric, "Continuous", Format("Best",5));

The following example creates a character column and automatically assigns the nominal analysis type.

dt << New Column("Last Name", Character);

You can also add formulas and other script messages appropriate to the column.

dt << New Column("Ratio", Numeric, "Continuous", Formula(Height/Weight));

dt << New Column("myMarkers", Row State, Set Formula(Marker State(age-12)));

If you plan to work with specific columns later (for example, grouping or changing data types), create a column reference, as follows:

myCol = dt << New Column("Part Number");

Fill a Column with Data

To fill the column with data, use Values or its equivalent, Set Values. Include the value for each cell in a list.

The following example adds a new column called Last Name to the current data table. Three values are added: Smith, Jones, and Anderson.

dt = Current Data Table();

dt << New Column("Last Name", Character, Values({"Smith", "Jones", "Anderson"}));

The column can also be filled with numeric values. The following example adds a new column called Row Number to the current data table. The function N Row returns the number of rows in the table, and numeric values populate all of the rows in the column, beginning with 1.

dt = Current Data Table();

dt << New Column("Row Number", Numeric, Values(1::NRow()), Format("Best",5));

To add a column of random numbers, insert a formula along with the random function.

dt = Current Data Table();

dt << New Column("Random", Numeric, Formula(Random Uniform()));

Another option is to add a constant numeric value to each cell. In the following example, the number 5 is added to each cell.

New Column("Number");

:Number << Set Each Value(5);

New Column can also be used as a built-in function, in other words, without the << (Send) command applied to the data table reference. When used in this way, the column is added to the current data table.

dt << New Column("logHt"); // command is sent to the data table reference

New Column("logHt"); // column is added to the current data table

Add Several Columns at Once

The Add Multiple Columns message creates several columns at once. Arguments include the column name prefix, the number of columns, where to insert them (Before First, After Last, or After(col)), and the data type (Numeric, Row State, or Character(width)). An additional argument, field width, is optional for a numeric column.

dt = Current Data Table();

dt << Add Multiple Columns("beginning", 2, Before First, Row State);

// adds two row state columns named "beginning <n>" before the first column

dt = Current Data Table();

dt << Add Multiple Columns("middle", 3, After(:height), Numeric);

// adds three numeric columns named "middle <n>" after the height column

dt = Current Data Table();

dt << Add Multiple Columns("end", 4, After Last, Character(4));

// adds four character columns named "end <n>" after the last column

The column name is a prefix. If multiple columns with the same name are added, a sequential number is appended to each column name (beginning 1, beginning 2, and so on).

Group Columns

You can group columns by sending the data table the Group Columns message, which takes a list of columns to group as an argument. For example, the following code opens the Big Class.jmp sample data table and groups the age and sex columns.

dt = Open("$SAMPLE_DATA\Big Class.jmp");

dt << Group Columns( {:age, :sex} );

"age etc."

You can also send a column name followed by the number of columns to include in the group. The group includes the first column named and the n-1 columns that follow it. This line is equivalent to the line above, which groups age and sex:

dt << Group Columns( :age, 2 );

The group name is based on the first column specified in the argument. So in the preceding example, the group is automatically named age etc. To customize the name, include the group name as the first argument.

dt << Group Columns( “My group”, :age, 2 );

To ungroup grouped columns, use the Ungroup Columns message, which takes a list of columns in a group as an argument. For example, the following line ungroups the two columns grouped in the previous example.

dt << Ungroup Columns( {:age, :sex} );

Note the following about grouping and ungrouping columns:

•	Both messages take a single list as an argument. The list must be enclosed in braces.

•	You cannot create more than one group in a single message (for example, by giving the Group Columns message two lists of columns). Instead, you must send the data table two separate Group Columns messages.

•	The Ungroup Columns message takes a list of columns to ungroup, not the name of a group of columns. You can remove a partial list of columns from a group. For example, this line creates a group of four columns:

dt << Group Columns( {:age, :sex, :height, :weight} );

And this line removes two of the columns, while leaving the other two in the group:

dt << Ungroup Columns( {:age, :sex} );

Notice that the grouped columns are now height and weight, but the group name still contains age. Once a group is created, its name does not change, even if you remove the first column that was originally grouped.

Get Column Groups or Names

To get column groups or names, use Get Column Group or Get Column Groups Names. The first part of this example creates two sets of grouped columns as shown in the previous section. Get Column Group() returns the column names in the specific group. Get Column Groups Names() returns the names of the column groups.

dt = Open( "$sample_data/big class.jmp" );

dt << Group Columns( {:age, :sex} );

"age etc."

dt << Group Columns( {:weight, :height} );

"height etc."

dt << Get Column Group( "age etc." );

{:age, :sex}

dt << Get Columns Groups Names();

{"age etc.", "height etc."}

Select a Column Group

To select or deselect a column group, use the following messages:

dt << Select Column Group ("name"); //selects the columns in the group

dt << Deselect Column Group ("name"); //deselects the columns in the group

The following example groups columns X and Y and groups columns Ozone through Lead, and then selects those columns in the data table:

dt = Open( "$SAMPLE_DATA/Cities.jmp" );

dt << group columns( "xy", {:X, :y} );

dt << select column group( "xy", "pollutants" );

Rename a Column Group

To rename a column group, use the following message:

dt << Rename Column Group ("name", "toname");

The following example renames the column group from xy to coordinates:

dt = Open( "$SAMPLE_DATA/Cities.jmp" );

dt << group columns( "xy", {:X, :y} );

dt << rename column group( "xy", "coordinates" );

Move a Column Group

To move a column group, use the following message:

dt << Move Column Group (To First | To Last | After (col) "name")

The following example moves the columns in the pollutants group to the end:

dt = Open( "$SAMPLE_DATA/Cities.jmp" );

dt << group columns( "xy", {:X, :y} );

dt << move column group( to last, "pollutants" );

Select Columns

To select a column, use the Set Selected message.

col << Set Selected(1);

For example, to select all continuous variables in the Big Class.jmp sample data table, use the following script:

dt=Open("$SAMPLE_DATA/Big Class.jmp");

cc=dt << Get Column Names("Continuous");

ncols = N Items(cc);

for(i=1,i<=ncols,i++,

cc[i]<<Set Selected(1);

);

Get Selected Columns

To get a list of currently selected columns, use the Get Selected Columns message.

dt << Get Selected Columns();

{:age, :sex, :height}

Return the list of selected columns as a string using the string argument:

dt << Get Selected Columns( "string" );

{"age", "sex", "height"}

Once you know what columns are selected, you can then write a script that acts upon these columns. Or your script can iteratively select columns and act upon them one at a time.

To actually select the columns before getting the columns, send the Set Selected() message to a column. For more information, see Column Attributes.

Go To Column

To select and move to a specific column, use the Go To message.

dt << Go To (column name | column number);

For data tables with many columns, you can use this message to scroll the data table all the way to the left, so that the first column comes into view and is selected:

dt=Open("$SAMPLE_DATA/Tiretread.jmp");

dt << Go To (1)

Rearrange and Move Columns

These messages enable you to rearrange columns in a data table:

dt << Reorder By Name; // alphanumeric order

dt << Reverse Order; // reverse current order

dt << Reorder By Data Type; // row state, character, and then numeric

dt << Reorder By Modeling Type; // continuous, ordinal, nominal

dt << Original Order; // saved order

These commands move the currently selected columns to the indicated destination point.

dt << Move Selected Columns(To First);

dt << Move Selected Columns(To Last);

dt << Move Selected Columns(After(“name”));

You can also move columns without first selecting them in the data table by using the following syntax.

dt << Move Selected Columns({“name”}, To First);

dt << Move Selected Columns({“name”}, To Last);

dt << Move Selected Columns({“name”}, After(“name”));

Add a Column Switcher

Use JSL to add a Column Switcher panel to a report window. The Column Switcher lets you quickly analyze different variables without having to re-create your analysis.

obj << Column Switcher(<default_col>(<col1>, <col2>, ...); //adds a Column Switcher to the report

obj << Remove Column Switcher(); //removes the Column Switcher from a report

For example, add the Column Switcher to a Contingency report for the Car Poll.jmp data as follows:

dt = Open( "$SAMPLE_DATA/Car Poll.jmp" );

ColumnSwitcherObject = obj <<

Column Switcher(

:marital status,

{:sex, :country, :marital status}

);

ColumnSwitcherObject<<setsize(200); //number of pixels for the switcher width

ColumnSwitcherObject<<setnlines(6); //number of columns to display in switcher

For more details about the Column Switcher, see the Using JMP book.

Compress Selected Columns

To minimize the size of a large data table, use the Compress Selected Columns message. Each column is compressed into the most compact form.

dt << Compress Selected Columns( {column name, column name} );

For example, compress the age, sex, height, and weight columns in Big Class.jmp as follows:

dt = Open( "$SAMPLE_DATA/Big Class.jmp" );

dt << Compress Selected Columns(

{:age, :sex, :height, :weight}

);

For more information about this feature, see the Using JMP book.

Delete Columns

To delete columns, send a Delete Columns message and specify which column or columns to delete. To delete more than one column, list the columns as multiple arguments or as a list. The following examples use the Big Class.jmp sample data table:

dt << Delete Columns("weight");

dt << Delete Columns("weight", "age", "sex");

dt << Delete Columns({"weight", "age", "sex"});

Without an argument, Delete Columns deletes columns that were previously selected. See Column Attributes for more information.

Obtain Column Names

Column Name(n) returns the name of the n th column. The examples in this section use the Big Class.jmp sample data table.

column name(2); // returns age

The returned value is a name value, not a quoted string. What this means is you can use it anywhere you would normally use the actual name in a script. For example, you could subscript it:

column name(2)[1];

If you want the name as a text string, quote it with Char:

char(column name(2));

"age"

To retrieve a list of the names of all columns in a data table, submit Get Column Names.

dt << Get Column Names(argument);

where the optional argument controls the output of the Get Column Names function, as follows:

•	Specify Numeric, Character, or Row State to include only those column data types.

•	Specify "Continuous", "Ordinal", or "Nominal" to include only those modeling types.

•	Specify String to return a list of strings rather than column names.

For example, if you want to get numeric and continuous columns in the Big Class.jmp sample data table, proceed as follows:

dt=Open("$SAMPLE_DATA/Big Class.jmp");

names=dt << Get Column Names (Numeric, "Continuous")

{height, weight}

Column Attributes

Use a collection of message pairs for data table columns to control all of the various attributes or characteristics of a column, including its name, data, states, and metadata. The messages come in pairs, one to “set” or assign each attribute and one to “get” or query the current setting of each attribute.

For example, you can hide, exclude, label, and turn on or off the scroll lock for a column through scripting. The value is Boolean; enter a one to turn the column attribute on, and a zero to turn it off.

In the following examples, the name column is unhidden, unexcluded, labeled, and locked from horizontal scrolling.

column("name") << hide(0);

column("name") << exclude(0);

column("name") << label(1);

column("name") << set scroll locked(1);

Note: All the messages to set various arguments (for example, Set Name, Set Values, Set Formula) start with Set. The word Set is optional for all messages except Set Name (recall that Name is already used for something else, the command that lets you use unusual characters in a name). Use whichever form you prefer or find easier to remember. The corresponding messages to retrieve the current value of an argument (for example, Get Formula) are the same, except that they start with Get instead of Set, and the word Get is not optional.

To deselect all selected columns, send a Clear Column Selection message to the data table object.

dt << Clear Column Selection;

Set or Get a Column Name

Set Name lets you name or rename a column, and Get Name returns the name for a column. The following example uses the Big Class.jmp sample data table, and changes column 2 (age) to ratio. It then returns the current column name to the log.

col = Column(2);

col << Set Name("ratio");

col << Get Name;

Set or Get Column Values

Similarly, Set Values sets values for a column. If the variable is character, the argument should be a list. If the variable is numeric, the argument should be a matrix (vector). If the number of values is greater than the current number of rows, the necessary rows are added to the data table. Get Values returns the values in list or matrix form. Get As Matrix is similar to Get Values but returns values in the numeric columns.

col << Set Values(myMatrix); // for a numeric variable

col << Set Values(myList); // for a character variable

col << Get Values; // returns a matrix, or list if character

col << Get Matrix(<list of column names>|<list of column numbers>|<column range>; // returns the specified columns as a matrix

The following example returns a list and a matrix of values:

dt=Open("$SAMPLE_DATA/Big Class.jmp");

column("name") << values({Fred, Wilma, Fred, Ethel, Fred, Lamont});

myList = :name << get values; //returns list

column("age") << values([28,27,51,48,60,30]);

myVector = :age<<get values;

[28, 27, 51, ... ]

myMatrix = :weight<<get as matrix;

[95, 123, 74, ... ]

Set or Get Value Labels

Note: For complete details about value labels, see the Using JMP book.

Value labels provide a method of displaying a descriptive label for abbreviated data. For example, you might have a column of 0 and 1 values, where 0 represents a male and 1 represents a female. The value label "male" for 0 and "female" for 1 are more readable.

You can specify value labels in any one of the following three ways. Using the Big Class.jmp sample data table, assume that M maps to Male, and F maps to Female.

:sex << Value Labels({“F”, “M”}, {“Female”, “Male”}); // uses two lists

:sex << Value Labels({"F", "Female", "M", "Male"}); // uses a list of pairs

:sex << Value Labels({"F" = "Female", "M" = "Male"}) // uses a list of assignments

You can activate value labels by sending Use Value Labels as a message to the column.

:sex << Use Value Labels(1);

To revert back to showing the column’s actual values, proceed as follows:

:sex << Use Value Labels(0);

The same message can be used for the data table to turn value labels on and off for all columns.

Current Data Table()<<Use Value Labels(1);

Set or Get Data and Modeling Types

You can set or get the data type of a column using JSL. The choices are character, numeric, and row state. The following example adds a new column to the Big Class.jmp sample data table that has a data type of character.

dt = Open( "$SAMPLE_DATA/Big Class.jmp" );

dt << New Column( "New" );

Column( "New" ) << Data Type( Character );

Column( "New" ) << Get Data Type;

"Character"

To set or get the modeling type of a column:

dt=Open("$SAMPLE_DATA/Big Class.jmp");

col = New Column( "New" );

col << Modeling Type( "Continuous" );

col << Get Modeling Type;

"Ordinal"

You can specify the format of a column when changing its data type as follows:

dt = Open( "$SAMPLE_DATA/Big Class.jmp" );

col = New Column( "Date" );

Column( "Date" ) << Data Type( Numeric, Format( "ddMonYYYY" ) );

Set or Get Formats

The Format message controls numeric and date/time formatting. The first argument is a quoted string from the list of format choices shown in the Column Info window. Subsequent arguments depend on the format choice. You can also set the field width by itself.

col << Format("best",5); // width is 5

col << Format("Fixed Dec",9,3); // width is 9, with 3 decimal places

col << Format("PValue",6);

col << Format("d/m/y",10);

col << set fieldwidth(30);

For date formats, the Format message sets how dates appear in a data table column. To set the format that you use for entering data, or for displaying the current cell when you have it selected for entry or editing, use the Input Format message.

col << Format("d/m/y",10); // display the date in day-month-year order

col << Input Format("m/d/y"); // enter the date in month-day-year order

For more information about date/time formatting choices, see Date-Time Functions and Formats in Types of Data.


Note: Do not confuse the Format message for columns with the Format function for converting numeric values to strings according to the format specified (typically used for date/time notation as described in Date-Time Functions and Formats in Types of Data). Sending a message to an object has a very different effect from using a function that might happen to have the same name.

To get the current format of a column, submit a Get Format message, as follows:

col << Get Format;

Set, Get, or Evaluate a Formula

To set, get, and evaluate a formula for a column, proceed as follows:

col=New Column("Ratio"); // creates column and stores its reference

col << Set Formula(:height/:weight); // sets formula

col << EvalFormula; // evaluates the formula

col << Get Formula; // returns the expression :height/ :weight

To use the values from columns in scripts, be sure to add commands to evaluate the formula. Formula evaluation timing can differ between different versions of JMP. Note the following:

•	When formulas are added, they are scheduled to be evaluated in a background task. This can be a problem for scripts if they depend on the column having the values while the script is running.

•	To force a single column to evaluate, you can send an Eval Formula command to the column. You can do this inside the command to create the column, right after the Formula clause:

dt << NewColumn("Ratio",Numeric,Formula(:height/:weight),EvalFormula);

where Formula is an alias for Set Formula.

However, it is best to wait until you are finished adding a set of formulas, and then use the command Run Formulas to evaluate all of the formulas in their proper order, as follows:

Current Data Table()<<Run Formulas;

•

The Run Formulas command is preferable to the Eval Formula command, because while it is evaluating the formulas, Eval Formula does not suppress the background task from evaluating them again. The formula dependency system background task takes great care to evaluate the formulas in the right order, and RunFormulas simply calls this task until all the formulas are finished evaluating.

•	If you use random numbers and use the Random Reset(seed) feature to make a replicable sequence, then you have another reason to use Run Formulas, in order to avoid a second evaluation in the background.

Set and Get Range and List Checks

You can manipulate list and range check properties using JSL. The following examples use the Big Class.jmp sample data table.

Set and clear the list check property in the sex column:

column("Sex") << List Check({"M", "F"}); // sets it

column("Sex") << List Check(); // clears it

Range checks require the specification of a range using the syntax in Range Check Syntax.

Range Check Syntax
To specify this range	Use this function
a ≤ x ≤b	LELE(a, b)
a ≤ x <b	LELT(a,b)
a < x ≤b	LTLE(a,b)
a < x < b	LTLT(a,b)

The following example specifies that the values in the age column must be greater than zero and less than 120:

Column("age") << Range Check(LTLT(0, 120));

All of the operators can be preceded by Not and one of them can be missing. The following example specifies that the values in the age column should be greater than or equal to 12:

Column("age") << Range Check(not(lt(12)));

To clear a range check state, submit an empty range check(), as follows:

Column("age") << Range Check();

To retrieve the list or range check assigned to a column, send a Get List Check or Get Range Check message to the column:

Column("sex") << Get List Check;

Column("age") << Get Range Check;

For example, if you sent a Get Range Check for the age column in the example above (where values should be greater than zero and less than 120), the following output appears:

Range Check(LTLT(0, 120))

Note that you can also use Set Property, Get Property, and Delete Property to set, retrieve, and remove list checks and range checks. See Column Properties for more information.

Note: Operations sent through JSL that involve range check columns show any warnings in the log rather than in interactive windows.

Get a Column Script

Get Script returns a script to create the column.

New Column("Ratio",Set Formula( :height/ :weight));

Column("ratio") << Get Script;

New Column( "Ratio",

Numeric,

"Continuous",

Format( "Best", 10 ),

Formula( :height / :weight )

)

Preselect Roles

To preselect a role on a column, use the Preselect Roles message. Choices include No Role, X, Y, Weight, and Freq. The Get Role message returns the current setting.

col = New Column( "New" );

col << Preselect Role( X );

col << Get Role;

Lock a Column

To lock or unlock a column, use Lock or Set Lock with a Boolean argument. Get Lock returns the current setting.

col << Lock(1); // lock

col << Set Lock(0); // unlock

col << Get Lock; // show current state

Column Properties

Tip: JSL choices for properties are the same as those in the Column Properties menu in the Column Info window. The arguments for each property correspond to the settings in the Column Info window. An easy way to learn the syntax is to establish the property that you want in the Column Info window first, and then use Get Property to view the JSL.

Data columns have numerous optional metadata attributes that can be set, queried, or cleared using the messages Get Property, Set Property, and Delete Property.

col << Set Property( "propertyName", {argument list} );

col << Get Property( "propertyName" );

col << Delete Property( "propertyName" );

The name of the property in question is always the first argument for Set Property, and what is expected for subsequent arguments depends on which property you set:

•	Get Property and Delete Property always take a single argument, which is the name of the property.

•	Get Property returns the property’s settings. Delete Property completely removes the property from the column.

•	To get a list of all column property names for a column, specify the column and then use Get Properties List.

If you want to set several properties, you need to send several separate Set Property messages. You can stack several messages in a single JSL statement if you want.

col << Set Property("Axis",{Min(50), Max(180)})<<Set Property("Notes", "to get proportions");

To get a property’s value, send a Get Property message whose argument is the name of the property that you want:

Column("ratio")<<Get Property("axis"); // returns axis settings

To set columns as label columns:

dt << Set Label Columns(col1, col2, col3);

To clear all label columns:

dt << Set Label Columns();

The same syntax works for Set Scroll Lock Columns, and Scroll Lock.

Properties for Data Table Columns shows examples for setting and getting column properties. See The Column Info Window chapter in Using JMP for more information on each property.

Properties for Data Table Columns
Property	Description	Example Using Arguments
Notes	Stores notes about a column. Is a quoted text string.	col<<Set Property("Notes", "Extracted from Fisher iris data"); col<<Get Property("Notes");
List Check Range Check	Prescribes the possible values that can be entered in a column.	col<<Set Property(List Check,{"F","M"}); col<<Set Property("Range Check",LTLT(0, 120)); col<<Get Property("List Check"); col<<Delete Property("Range Check");
Missing Value Codes	Specifies column values that should be treated as missing.	col<<Set Property( "Missing Value Codes", {0, 1} );
Value Labels	Specifies labels to be displayed in place of the values.	col<<Value Labels( {0 = "Male", 1 = "Female"} ); Use Boolean values to turn value labels on or off: col<<Use Value Labels( 1 );.
Value Ordering	Specifies the order in which you want the data to appear in reports.	col<<Set Property("Value Ordering", {"Spring", "Summer", "Fall", "Winter"});
Value Colors and Color Gradient	Specifies colors for either categorical or continuous data, respectively.	Specify the color by assigning a JMP number to each value: col<<Set Property( "Value Colors", {"Female" = 3, "Male" = 5} ); Specify a color theme: col<<Set Property( "Value Colors", Color Theme( "White to Blue" )); If you omit the color theme, JMP uses the color theme preferences. Specify the gradient and the range and midpoint for Value Gradient: col<<Set Property( "Color Gradient", {"White to Blue", Range( {18, 60, 25} )});
Axis	Most platforms use this (if it exists) when constructing axes. Mostly Boolean.	col<<Set Property("Axis",{Min(50), Max(180), Inc(0), Minor Ticks(10), Show Major Ticks(1), Show Minor Ticks(1), Show Major Grid(0), Show Labels(1), Scale(Linear)});
Units	Provided for custom uses. Specify the units of measure.	col<<Set Property("units", "grams"); col<<Get Property("units");
Coding	Used for DOE and fitting. List with low and high values.	col<<Set Property("Coding",{59,172}); col<<Get Property("Coding");
Mixture	Used for DOE, fitting, and profiling. Specifies the Mixture column properties in a list.	col<<Set Property("Mixture", {0.2, 0.8, 1, L PseudoComponent Coding} ); col<<Get Property("Mixture");
Row Order Levels	Specify to sort levels by their occurrence in the data instead of by value.	col<<Set Property( "Row Order Levels", 1 );
Spec Limits	Used for capability analysis and variability charts.	col<<Set Property("Spec Limits", {LSL(-1), USL(1), Target(0)}); col<<Get Property("Spec Limits");
Control Limits	Used for control charts.	col<<Set Property("Control Limits", {XBar(Avg(44), LCL(29), UCL(69))}); col<<Get Property("Control Limits");
Response Limits	Set in DOE and used in desirability profiling.	col<<Set Property("Response Limits", {Goal("Match Target"), Lower(1,1), Middle(2,2), Upper(3,3)}); col<<Get Property("Response Limits"); Choices for Goal are Maximize, Match Target, Minimize, None. Other arguments take numeric value and desirability arguments.
Design Role	Used for DOE. Specify a single role.	col<<Set Property("Design Role", "Covariate"); col<<Get Property("Design Role"); Choices for role are Continuous, Discrete Numeric, Categorical, Blocking, Covariate, Mixture, Constant, Uncontrolled, Random Block, Signal, and Noise.
Factor Changes	Sets the difficulty of changing a factor (Easy, Hard, or Very Hard).	col<<Set Property("Factor Changes", Hard); col<<Get Property("Factor Changes");
Sigma	Used for control charts. Specify known sigma value.	col<<Set Property("Sigma",1.332); col<<Get Property("Sigma"); Each type of chart uses a different sigma calculation.
Distribution	Set the distribution type to fit to the column.	col<<Set Property( "Distribution", Distribution( GLog ) ); col<<Get Property("Distribution");
Time Frequency	Set the type of time frequency.	col<<Set Property( "Time Frequency", Time Frequency( "Annual" ) ); col<<Get Property("Time Frequency");
Map Role	Set how the column is used to connect map shape data with name data. Specify the role and other information as necessary.	col<<Set Property("Map Role", Map Role( Shape Name Use( "filepath to data table", "column name" ) ) ); col<<Get Property("Map Role");
Supercategories	Groups specific categories into one category. Supported only in the Categorical platform.	col<<Set Property( "Supercategories", {Group( "Genders", {"F", "M"} )} ); col<<Get Property( "Supercategories" );
Multiple Response	Specifies the character that separates the responses within a cell.	col<<Set Property( "Multiple Response", Multiple Response( Separator( "," ) ) ); col<<Get Property( "Multiple Response" ) );
Profit Matrix	Converts a predictive model to a decision model and assigns weights to outcomes. Specify a list that contains the weights in a matrix and categories in another list. In the matrix, each row shows the consequences if you predicted the specified response. Each column shows the consequences if the actual response if the specified response.	col<<Set Property( "Profit Matrix", {[5 - 1, -1 4, -2 - 2], {"M", "F", "Others"}} ); col<<Get Property( "Profit Matrix" );
Expression Role	Applies to columns that contain expressions. Specifies whether the expression should be interpreted as a Picture, a Matrix, or an Expression.	col<<Set Property( "Expression Role", Expression Role( "Picture", MaxSize( 640, 480 ), StretchToMaxSize( 1 ), PreserveAspectRatio( 1 ), Frame( 0 ) )
[Custom property]	Provided for custom uses. Corresponds to Column Properties > Other in the Column Info window. The first argument is a name for the custom property, and the second argument is an expression.	col<<Set Property("Date recorded",12Dec1999); long date(col<<Get Property("Date recorded"));