2.3.2.2.3 $( ) Substitution - Numeric to String Conversion Syntax The$() notation is used for numeric to string conversion. This notation evaluates the given expression at run-time, converts the result to a numeric string, and then substitutes the string for itself.

The notation has the following form:

$(expression [, format]) where the format is optional or can be Origin format, C-language format, or combined Origin and C-Language format as described in the following sections. Expression can be one of the following: Expression Format Example Description number NA type$(4.567); //ANS: 4.567

Display the number with up to 14 significant digits
numeric variable .3
xx=1.2345678;
type $(xx, .3); //ANS: 1.235  Display the variable xx with 3 decimal places numeric object property NA //if a 2-column workbook is active type "there are$(wks.ncols) columns";
//ANS: there are 2 columns

Display wks.ncols value
dataset variable NA
dataset ds1={2,4,6}; //dataset variable
type $(ds1); //ANS: 2 4 6  Display ds1 with space separated list range variable *3 //fill column A with 0.00012345, 6.789, 20.2 range ra=col(A); //range variable type$(ra, *3); //ANS: 1.23E-4 6.79, 20.2

Display ra with 3 significant digits
math expression .0,
xx = 1234.5678;
type $(xx*4, .0,); //ANS: 4,938  Display expression result with 0 decimal places and comma separator Format We use type command to show effect of all formats. Default Format The square brackets indicate that format is an optional argument for the$() substitution notation. No no format is specified, Origin will carry expression to the number of decimal digits or significant digits specified by the @SD system variable (which default value is 14). For example:

double aa =  3.14159265358979323846;
type $(aa); // ANS: 3.1415926535898 Origin Formats Origin supports custom formatting of numeric values in the worksheet or in text labels. For a full list of numeric format options, see Reference Tables: Origin Formats. Format Description Example *n Display n significant digits xx=1.23456; type "xx =$(xx, *2)"; //ANS: xx=1.2

.n Display n decimal places
xx=1.23456;
type "xx = $(xx, .2)"; //ANS: xx=1.23  *n* Display n significant digits, truncating trailing zeros xx = 1.10001; type "xx =$(xx, *4*)"; //ANS: xx=1.1

.n, Display n decimal places, using comma separator (US, UK, etc.)
xx = 1234.5678;
type "xx = $(xx, .2,)"; //ANS: xx=1,234.57 xx= 10000; type "$(xx, .0,)"; //ANS: 10,000

E.n Display n decimal places, in engineering format
xx=203465987;
type "xx = $(xx, E*3)"; //ANS: xx=203M  S*n Display n significant digits in scientific notation of the form 1E3 xx=203465987; type "xx =$(xx, S*3)"; //ANS: xx=2.03E+08

D<format> Display in custom date format, where <format> is either the index number (counting from 0) of the format, starting from the top of the Column Properties Display list; or a string built using these date and time format specifiers.
type "$(date(7/20/2009), D1)"; // ANS: Monday, July 20, 2009 type "$(date(7/20/2009), Dyyyy'-'MM'-'dd)";  //ANS: 2009-07-20
DT=2459858.6946202; //assign a julian date to DT
type "DT = $(DT, D1)"; // ANS: DT = Thursday, October 6, 2022 type "Now=$(@D, DMM-dd-yyyy h:mm:ss tt)"; // @D: current date&time

T<format> Display in custom time format, where <format> is either the index number (counting from 0) of the format, starting from the top of the Column Properties Display list; or a string built using these time format specifiers.
type "$(time(14:31:04), T4)"; //ANS: 02 PM type "$(time(14:31:04), Thh'.'mm'.'ss)";  //ANS: 02.31.04
DT=2459858.6946202;
type "DT = $(DT, T0)"; // ANS: DT = 16:40 type "Now =$(@D, THH:mm:ss.##)"; // @D: current date&time

C<format> Display month or day of week in Calendar format. <format> is either M# (month), or D#=day of the week. # can be 0 (3 characters), 1 (full characters) or 2 (1 character)
type "$(12, CM0)"; // ANS: Dec type "$(3, CD1)";  // ANS: Wednesday

#n or ## Display an integer to n places, zero padding where necessary. Or use n number of #'s to refer to nth places
xx=45;
type "xx=$(xx, #5)"; //ANS: 00045 type "xx=$(xx, ###)"; //AnS: 045

<prefix>##<sep>###<suffix> Display a number by specifying a separator (<sep>) between digits and optionally add prefix(<prefix>) and/or suffix (<suffix>). One # symbol indicates one digit. The last # in this expression always refers to the unit digit. The numbers of # in both first and second parts can be varied.
xx=56000;
type "xx=$(xx, ##+###)"; //ANS: xx=56+000 xx=4000; type "xx=$(xx, ##+##M)"; //ANS: xx=40+00M

# #/n Round and display a number as a fraction with specified n as denominator. The numerator and denominator are separated by a forward slash /. The number of digits of numerator is adjusted accordingly.
AA = 0.334;
type "AA = $(AA, # ##/##)"; //ANS: AA = 1/3 type "AA =$(AA, # #/8)"; //ANS: AA = 3/8

D[<space>]M[S][F][n] Display a degree number in the format of Degree° Minute' Second", where 1 degree = 60 minutes, and 1 minute = 60 seconds. Space can be inserted to separate each part. n indicates decimal places for fractions. F displays degree number without symbols and inserting spaces as separator.
DD = 37.34255;
type "DD = $(DD, DMS)"; //ANS: DD = 37°20'33" type "DD =$(DD, D MS)"; //ANS: DD = 37° 20' 33"
type "DD = $(DD, DMSF)"; //ANS: DD = 37 20 33 type "DD =$(DD, DMF1)"; //ANS: DD = 37 20.6


C-Language Formats

The format portion of the $() notation also supports C-language formatting statements. Option Un/Signed Output Input Range Example d, i SIGNED Integer values (of decimal or integer value) -2^31 -- 2^31 -1 double nn = -247.56; type "Value:$(nn,%d)"; // ANS: -247

f, e, E, g, G SIGNED Decimal, scientific, decimal-or-scientific +/-1e290 -- +/-1e-290
double nn = 1.23456e5;
type "Values: $(nn, %9.4f),$(nn, %9.4E), $(nn, %g)"; // ANS: 123456.0000, 1.2346E+005, 123456 double nn = 1.23456e6; type "Values:$(nn, %9.4f), $(nn, %9.4E),$(nn, %g)";
// ANS: 123456.0000, 1.2346E+006, 1.23456e+006

o, u, x, X UNSIGNED Octal, Integer, hexadecimal, HEXADECIMAL -2^31 -- 2^32 - 1
double nn = 65551;

Display Negative Values

Most of Origin's LabTalk command statements take options and options are always preceded by the dash "-" character. Therefore the following command will not work

k=-5;
type $(k); //intepret as type -5 and think -5 is an option of ''type'' command Therefore you must protect the - by enclosing the substitution in quotes or parentheses. For example: K = -5; type "$(K)"; // This works
type ($(K)); // This works Variable Naming with$()

In assignment statements, the $() notation is substitution-processed and resolved to a value regardless of which side of the assignment operator it is located. //create variable A with value 2 A = 2; //Define variable A with value 2. //Create a variable A2 with the value 3 A$(A) = 3; $(A) is resolved first so LHS is A2 //verify the result A2=; A$(A)=;

Also when variable names are used for range or dataset type argument in functions, $() substitution is needed to resolve it first. //fill column 1 to 5 with values col(1)=data(1,100); int nn = 5; loop(ii,2,nn) { wcol(ii)=normal(100); } //Example of using variable in X Function smooth loop(ii,2,nn) { //smooth on the iith column$(ii)
smooth $(ii) method:=aav npts:=10; } //Example of using variable in LabTalk function sum() lastcolumn=wks.ncols; //add a column after last one and set the value to be sum of last column col($(lastcolumn+1))= sum($(lastcolumn)); col($(lastcolumn+1))[L]$= sum; //set long name of column --- For more examples of$() substitution, see Numeric to String conversion.