@sasjs/sas-language 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SASjs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,122 @@
+# SAS language support for editors
+
+`@sasjs/sas-language` provides completions, hover documentation and signatures for SAS.
+
+The data is resolved from the [SAS extension for Visual Studio Code](https://github.com/sassoftware/vscode-sas-extension)
+and refreshed on a schedule, so this package owns the vocabulary rather than
+depending on a language server bundle. It carries no runtime dependencies and
+uses no Node built-ins, so it runs unchanged in a browser, in Node, and in an
+editor extension.
+
+## Why this exists
+
+An editor needs to know SAS. The alternatives were to bundle a 28 MB language
+server that also carries Python tooling, or to hand-maintain keyword lists. This
+package takes the third option: take the authoritative data, transform it into
+something cheap to load, and keep it current with a scheduled job.
+
+## Install
+
+```
+npm install @sasjs/sas-language
+```
+
+Until the package is on the registry it can be taken from git, pinned to a
+commit:
+
+```
+npm install git+https://github.com/sasjs/sas-language.git#<commit>
+```
+
+That works because `dist/` is committed, not built on install. It has to be: a
+consumer that sets `ignore-scripts=true` - as sasjs/server does - never runs the
+package's `prepare` script, so a git install would otherwise arrive with no
+compiled API at all.
+
+## Use
+
+The data is split so that a completion provider loads something small and hover
+text is fetched only when the user actually hovers.
+
+    data/<group>.index.json    completion index, ~76 KB across all groups
+    data/<group>.docs.json     hover documentation, ~1.2 MB across all groups
+
+```ts
+import functionsIndex from '@sasjs/sas-language/data/functions.index.json'
+import { completionItems, docsFor, groupDocsPath } from '@sasjs/sas-language'
+
+// Eager: completion items, ready for monaco.languages.registerCompletionItemProvider
+const items = completionItems(functionsIndex)
+// [{ label: 'ABS', kind: 1, detail: 'SAS function (SAS_FUNCTION)', insertText: 'ABS' }, ...]
+
+// Lazy: the documentation only when a hover happens
+const docs = await fetch(groupDocsPath('functions')).then((r) => r.json())
+const doc = docsFor(docs, 'abs')
+// { help: 'Returns the absolute value. ...' }
+```
+
+Every group is a separate path, so a bundler emits only the groups you import and
+the documentation as its own chunk.
+
+### Groups
+
+`GROUPS` lists every group with its label, completion kind and entry count.
+Group names are stable; entries are refreshed from upstream.
+
+| group                                                | contents                                   |
+| ---------------------------------------------------- | ------------------------------------------ |
+| `statements`                                         | global, procedure and DATA step statements |
+| `procNames`                                          | procedures                                 |
+| `functions`                                          | SAS functions                              |
+| `callRoutines`                                       | CALL routines                              |
+| `macroStatements`                                    | macro statements                           |
+| `macroFunctions`                                     | macro functions, autocall and ARM macros   |
+| `formats`, `informats`                               | formats and informats                      |
+| `options`                                            | data set options                           |
+| `systemOptions`                                      | system options                             |
+| `odsTagsets`                                         | ODS destinations                           |
+| `styleElements`, `styleAttributes`, `styleLocations` | ODS style parts                            |
+| `sqlKeywords`                                        | PROC SQL keywords                          |
+| `whereOperators`                                     | WHERE operators                            |
+| `automaticVariables`                                 | automatic variables                        |
+| `macroDefinitionOptions`                             | macro definition options                   |
+| `hashMethods`                                        | hash package methods                       |
+| `statisticsKeywords`                                 | statistics keywords                        |
+| `ds2Keywords`, `ds2Functions`                        | DS2 language                               |
+
+### API
+
+| export                            | purpose                                                        |
+| --------------------------------- | -------------------------------------------------------------- |
+| `GROUPS`                          | the group catalogue: name, label, completion kind, counts      |
+| `toEntries(index)`                | unpacks a group's index into `{ name, type, takesValue }`      |
+| `words(index)`                    | every word in a group, for matching                            |
+| `completionItems(index)`          | completion items, inserting the trailing `=` for value options |
+| `docsFor(docs, name)`             | one word's documentation, case-insensitively                   |
+| `groupIndexPath(group)`           | the package path of a group's index                            |
+| `groupDocsPath(group)`            | the package path of a group's documentation                    |
+| `UPSTREAM_REF`, `UPSTREAM_SOURCE` | which upstream commit the data came from                       |
+
+## How the data is refreshed
+
+`npm run refresh` fetches the upstream files at a pinned commit and rebuilds. The
+scheduled workflow in `.github/workflows/refresh.yml` runs this weekly and opens a
+pull request when the data changes, so an upstream change is reviewed rather than
+absorbed silently.
+
+`provenance.json` records the upstream repository, the resolved commit, and a
+sha256 per generated file. Tests assert the published data matches those hashes,
+which means hand-edited data or a stale `.upstream/` fails the build.
+
+The build fails when upstream changes the shape of a file, rather than publishing
+a quietly empty group. That is deliberate: a shape change should break a build,
+not degrade somebody's editor.
+
+    npm run fetch     # download at the latest upstream commit
+    npm run build     # transform into data/ and compile
+    npm test          # validate the data and the transforms
+
+## Licence
+
+The package is MIT. The data is derived from the SAS extension for Visual Studio
+Code, which is Apache-2.0; see `NOTICE`.

package/data/automaticVariables.docs.json

@@ -0,0 +1 @@
+{"group":"automaticVariables","count":60,"entries":{"SYSBUFFR":{"help":"Contains text that is entered in response to a %INPUT statement when there is no \ncorresponding macro variable."},"SYSLOGAPPLNAME":{"help":"Contains the value of the LOGAPPLNAME= system option."},"SYSODSPATH":{"help":"Contains the current Output Delivery System (ODS) pathname."},"SYSERRORTEXT":{"help":"Contains the text of the last error message formatted for display in the SAS log."},"SYSHOSTNAME":{"help":"Contains the host name of a computer."},"SYSTCPIPHOSTNAME":{"help":"Contains the host names of the local and remote computers when multiple TCP/IP stacks \nare supported."},"SYSWARNINGTEXT":{"help":"Contains the text of the last warning message formatted for display in the SAS log."},"SYSENCODING":{"help":"Contains the name of the current session encoding."},"SYSBUFFER":{"help":"Unmatched text from %INPUT."},"SYSCC":{"help":"The current condition code that SAS returns to your operating environment (the operating \nenvironment condition code)."},"SYSCMD":{"help":"Last unrecognized command from the command line of a macro window."},"SYSDEVIC":{"help":"Name of current graphics device."},"SYSDMG":{"help":"Return code that reflects an action taken on a damaged data set."},"SYSDSN":{"help":"Name of most recent SAS data set in two fields."},"SYSFILRC":{"help":"Return code set by the FILENAME statement."},"SYSLAST":{"help":"Name of most recent SAS data set in one field."},"SYSLCKRC":{"help":"Return code set by the LOCK statement."},"SYSLIBRC":{"help":"Return code set by the LIBNAME statement."},"SYSMSG":{"help":"Message for display in macro window."},"SYSPARM":{"help":"Value specified with the SYSPARM= system option."},"SYSPBUFF":{"help":"Text of macro parameter values."},"SYSRC":{"help":"Various system-related return codes."},"SYSCHARWIDTH":{"help":"The character width value."},"SYSDATE":{"help":"The character value representing the date a SAS job or session began executing \n(two-digit year)."},"SYSDATE9":{"help":"The character value representing the date a SAS job or session began executing \n(four-digit year)."},"SYSDAY":{"help":"Day of week SAS job or session began executing."},"SYSENV":{"help":"Foreground or background indicator."},"SYSERR":{"help":"Return code set by SAS procedures and the DATA step."},"SYSINDEX":{"help":"Number of macros that have begun execution during this session."},"SYSINFO":{"help":"Return code information."},"SYSJOBID":{"help":"Name of current batch job or userid (varies by host environment)."},"SYSMACRONAME":{"help":"Name of current executing macro."},"SYSMENV":{"help":"Current macro execution environment."},"SYSNCPU":{"help":"The current number of processors that SAS may use in computation."},"SYSPROCESSID":{"help":"The process id of the current SAS process."},"SYSPROCESSNAME":{"help":"The process name of the current SAS process."},"SYSPROCNAME":{"help":"Name of current procedure being processed."},"SYSSCP":{"help":"The abbreviation of an operating system."},"SYSSCPL":{"help":"The name of an operating system."},"SYSSITE":{"help":"The number assigned to your site."},"SYSSTARTID":{"help":"The id generated from the last STARTSAS statement."},"SYSSTARTNAME":{"help":"The process name generated from the last STARTSAS statement."},"SYSTIME":{"help":"The character value of the time a SAS job or session began executing."},"SYSUSERID":{"help":"The userid or login of the current SAS process."},"SYSVER":{"help":"Release or version number of SAS software executing."},"SYSVLONG":{"help":"Contains the release number and maintenance level of SAS software that is running."},"SYSVLONG4":{"help":"Contains the release number and maintenance level of SAS software that is running and \nhas a four digit year."},"SYSADDRBITS":{"help":"Contains the number of bits of an address."},"SYSENDIAN":{"help":"Contains an indication of the byte order of the current session. \n    \nThe possible values are LITTLE or BIG"},"SYSNOBS":{"help":"Contains the number of observations read from the last data set that was closed by the previous \nprocedure or DATA step."},"SYSODSESCAPECHAR":{"help":"Displays the value of the ODS ESCAPECHAR= from within the program."},"SYSSIZEOFLONG":{"help":"Contains the length in bytes of a long integer in the current session."},"SYSSIZEOFPTR":{"help":"Contains the size in bytes of a pointer."},"SYSSIZEOFUNICODE":{"help":"Contains the length in bytes of a Unicode character in the current session."},"SYSDATASTEPPHASE":{"help":"Indicates the current running phase of the DATA step. \n    \nEnsures that the macro is being executed as part of the proper phase of a DATA step. \n\nType: Automatic macro variable (read only)"},"SYSHOSTINFOLONG":{"help":"Contains the operating environment information that is displayed when the HOSTINFOLONG option is specified. \n    \nType: Automatic macro variable (read only)"},"SYSPROCESSMODE":{"help":"Contains the name of the current SAS session run mode or server type. \n    \nType: Automatic macro variable (read only)"},"SYSTIMEZONE":{"help":"Contains the time zone name based on TIMEZONE option. \n    \nType: Automatic macro variable (read only)"},"SYSTIMEZONEIDENT":{"help":"Contains the time zone ID based on TIMEZONE option. \n    \nType: Automatic macro variable (read only)"},"SYSTIMEZONEOFFSET":{"help":"Contains the current time zone offset based on TIMEZONE option."}}}

package/data/automaticVariables.index.json

@@ -0,0 +1 @@
+{"group":"automaticVariables","label":"SAS automatic variable","kind":6,"count":60,"entries":[["SYSADDRBITS","AUTOMATIC_VARIABLE"],["SYSBUFFER","AUTOMATIC_VARIABLE"],["SYSBUFFR","AUTOMATIC_VARIABLE"],["SYSCC","AUTOMATIC_VARIABLE"],["SYSCHARWIDTH","AUTOMATIC_VARIABLE"],["SYSCMD","AUTOMATIC_VARIABLE"],["SYSDATASTEPPHASE","AUTOMATIC_VARIABLE"],["SYSDATE","AUTOMATIC_VARIABLE"],["SYSDATE9","AUTOMATIC_VARIABLE"],["SYSDAY","AUTOMATIC_VARIABLE"],["SYSDEVIC","AUTOMATIC_VARIABLE"],["SYSDMG","AUTOMATIC_VARIABLE"],["SYSDSN","AUTOMATIC_VARIABLE"],["SYSENCODING","AUTOMATIC_VARIABLE"],["SYSENDIAN","AUTOMATIC_VARIABLE"],["SYSENV","AUTOMATIC_VARIABLE"],["SYSERR","AUTOMATIC_VARIABLE"],["SYSERRORTEXT","AUTOMATIC_VARIABLE"],["SYSFILRC","AUTOMATIC_VARIABLE"],["SYSHOSTINFOLONG","AUTOMATIC_VARIABLE"],["SYSHOSTNAME","AUTOMATIC_VARIABLE"],["SYSINDEX","AUTOMATIC_VARIABLE"],["SYSINFO","AUTOMATIC_VARIABLE"],["SYSJOBID","AUTOMATIC_VARIABLE"],["SYSLAST","AUTOMATIC_VARIABLE"],["SYSLCKRC","AUTOMATIC_VARIABLE"],["SYSLIBRC","AUTOMATIC_VARIABLE"],["SYSLOGAPPLNAME","AUTOMATIC_VARIABLE"],["SYSMACRONAME","AUTOMATIC_VARIABLE"],["SYSMENV","AUTOMATIC_VARIABLE"],["SYSMSG","AUTOMATIC_VARIABLE"],["SYSNCPU","AUTOMATIC_VARIABLE"],["SYSNOBS","AUTOMATIC_VARIABLE"],["SYSODSESCAPECHAR","AUTOMATIC_VARIABLE"],["SYSODSPATH","AUTOMATIC_VARIABLE"],["SYSPARM","AUTOMATIC_VARIABLE"],["SYSPBUFF","AUTOMATIC_VARIABLE"],["SYSPROCESSID","AUTOMATIC_VARIABLE"],["SYSPROCESSMODE","AUTOMATIC_VARIABLE"],["SYSPROCESSNAME","AUTOMATIC_VARIABLE"],["SYSPROCNAME","AUTOMATIC_VARIABLE"],["SYSRC","AUTOMATIC_VARIABLE"],["SYSSCP","AUTOMATIC_VARIABLE"],["SYSSCPL","AUTOMATIC_VARIABLE"],["SYSSITE","AUTOMATIC_VARIABLE"],["SYSSIZEOFLONG","AUTOMATIC_VARIABLE"],["SYSSIZEOFPTR","AUTOMATIC_VARIABLE"],["SYSSIZEOFUNICODE","AUTOMATIC_VARIABLE"],["SYSSTARTID","AUTOMATIC_VARIABLE"],["SYSSTARTNAME","AUTOMATIC_VARIABLE"],["SYSTCPIPHOSTNAME","AUTOMATIC_VARIABLE"],["SYSTIME","AUTOMATIC_VARIABLE"],["SYSTIMEZONE","AUTOMATIC_VARIABLE"],["SYSTIMEZONEIDENT","AUTOMATIC_VARIABLE"],["SYSTIMEZONEOFFSET","AUTOMATIC_VARIABLE"],["SYSUSERID","AUTOMATIC_VARIABLE"],["SYSVER","AUTOMATIC_VARIABLE"],["SYSVLONG","AUTOMATIC_VARIABLE"],["SYSVLONG4","AUTOMATIC_VARIABLE"],["SYSWARNINGTEXT","AUTOMATIC_VARIABLE"]]}

package/data/callRoutines.docs.json

@@ -0,0 +1 @@
+{"group":"callRoutines","count":107,"entries":{"PRXCHANGE":{"help":"Performs a pattern-matching replacement."},"PRXDEBUG":{"help":"Enables Perl regular expressions in a DATA step to send debug output to the SAS log."},"PRXFREE":{"help":"Frees unneeded memory that was allocated for a Perl regular expression."},"PRXNEXT":{"help":"Returns the position and length of a substring that matches a pattern and iterates \nover multiple matches within one string."},"PRXPOSN":{"help":"Returns the start position and length for a capture buffer."},"PRXSUBSTR":{"help":"Returns the position and length of a substring that matches a pattern."},"RXCHANGE":{"help":"Changes one or more substrings that match a pattern."},"RXFREE":{"help":"Frees memory allocated by other regular expression (RX) functions and routines."},"RXSUBSTR":{"help":"Finds the position, length, and score of a substring that matches a pattern."},"CATS":{"help":"Concatenates character strings and removes leading and trailing blanks."},"CATT":{"help":"Concatenates character strings and removes trailing blanks."},"CATX":{"help":"Concatenates character strings, removes leading and trailing blanks, and inserts separators."},"COMPCOST":{"help":"Sets the costs of operations for later use by the COMPGED function."},"MISSING":{"help":"Assigns a missing value to the specified character or numeric variables.."},"SCAN":{"help":"Returns the position and length of a given word from a character expression."},"SCANQ":{"help":"Returns the position and length of a given word from a character expression, and \nignores delimiters that are enclosed in quotation marks."},"MODULE":{"help":"Calls the external routine without any return code. \n    \nInteraction:\nWhen a SAS server is in a locked-down state, the CALL MODULE routine does not execute. \n\nSyntax: CALL MODULE(<control-string,> module-name <, argument-1, ..., argument-n>);\n\nRequired Argument:\nmodule-name - is the name of the external module to use.\n\nOptional Arguments:\ncontrol-string\n  is an optional control string whose first character must be an asterisk (*), followed by any \n  combination of the following characters:\n    I\n    prints the hexadecimal representations of all arguments to the CALL MODULE routine. You can use \n    this option to help diagnose problems that are caused by incorrect arguments or attribute tables. \n    If you specify the I option, the E option is implied.\n    E\n    prints detailed error messages. Without the E option (or the I option, which supersedes it), \n    the only error message that the CALL MODULE routine generates is \"Invalid argument to function,\" \n    which is usually not enough information to determine the cause of the error. The E option is \n    useful for a production environment, whereas the I option is preferable for a development or \n    debugging environment.\n    H\n    provides brief information about the syntax of the CALL MODULE routine, the attribute file format, \n  and suggested SAS formats and informats. \n\nargument - is one or more arguments to pass to the requested routine."},"EXECUTE":{"help":"Resolves an argument and issues the resolved value for execution ."},"SYMPUT":{"help":"Assigns DATA step information to a macro variable."},"SYMPUTX":{"help":"Assigns a value to a macro variable and removes both leading and trailing blanks."},"ALLPERM":{"help":"Generates all permutations of the values of several variables ."},"LOGISTIC":{"help":"Returns the logistic value."},"SOFTMAX":{"help":"Returns the softmax value."},"STDIZE":{"help":"Standardizes the values of one or more variables."},"TANH":{"help":"Returns the hyperbolic tangent."},"RANBIN":{"help":"Returns a random variate from a binomial distribution."},"RANCAU":{"help":"Returns a random variate from a Cauchy distribution."},"RANEXP":{"help":"Returns a random variate from an exponential distribution."},"RANGAM":{"help":"Returns a random variate from a gamma distribution."},"RANNOR":{"help":"Returns a random variate from a normal distribution."},"RANPERK":{"help":"Randomly permutes the values of the arguments, and returns a permutation of \nk out of n values."},"RANPERM":{"help":"Randomly permutes the values of the arguments."},"RANPOI":{"help":"Returns a random variate from a Poisson distribution."},"RANTBL":{"help":"Returns a random variate from a tabled probability distribution ."},"RANTRI":{"help":"Returns a random variate from a triangular distribution."},"RANUNI":{"help":"Returns a random variate from a uniform distribution."},"STREAMINIT":{"help":"Specifies a seed value to use for subsequent random number generation by the RAND function ."},"POKE":{"help":"Writes a value directly into memory on a 32-bit platform . \n    \nInteraction:\nWhen a SAS server is in a locked-down state, the CALL POKE routine does not execute. \n\nSyntax: CALL POKE(source, pointer <, length> <, floating-point>);\n\nRequired Arguments:\nsource\n  specifies a constant, variable, or expression that contains a value to write into memory \npointer\n  specifies a numeric expression that contains the virtual address of the data that the CALL POKE routine alters.\n\nOptional Arguments:\nlength\n  specifies a numeric constant, variable, or expression that contains the number of bytes to write from the source \n  to the address that is indicated by pointer. If you omit length, the action that the CALL POKE routine takes depends \n  on whether source is a character value or a numeric value:\n    •If source is a character value, the CALL POKE routine copies the entire value of source to the specified memory location.\n    •If source is a numeric value, the CALL POKE routine converts source to a long integer and writes into memory the number \n      of bytes that constitute a pointer.\n\n  z/OS Specifics\n  Under z/OS, pointers are 3 or 4 bytes long, depending on the situation. \n\nfloating-point\n  specifies that the value of source is stored as a floating-point number. The value of floating-point can be any number."},"POKELONG":{"help":"Writes a value directly into memory on 32-bit and 64-bit platforms. \n    \nInteraction:\nWhen a SAS server is in a locked-down state, the CALL POKELONG routine does not execute. \n\nSyntax: CALL POKELONG(source, pointer <, length> <, floating-point>);\nRequired Arguments:\nsource\n  specifies a character constant, variable, or expression that contains a value to write into memory. \npointer\n  specifies a character string that contains the virtual address of the data that the CALL POKELONG routine alters.\n\nOptional Arguments:\nlength\n  specifies a numeric SAS expression that contains the number of bytes to write from the source to the address \n  that is indicated by the pointer. If you omit length, the CALL POKELONG routine copies the entire value of \n  source to the specified memory location. \nfloating-point\n  specifies that the value of source is stored as a floating-point number. The value of floating-point can be any number."},"SLEEP":{"help":"Suspends the execution of a program that invokes this call routine for a specified \nperiod of time."},"SYSTEM":{"help":"Submits an operating environment command for execution."},"LABEL":{"help":"Assigns a variable label to a specified character variable."},"SET":{"help":"Links SAS data set variables to DATA step or macro variables that have the same \nname and data type."},"VNAME":{"help":"Assigns a variable name as the value of a specified variable."},"VNEXT":{"help":"Returns the name, type, and length of a variable that is used in a DATA step."},"ALLCOMB":{"help":"Generates all combinations of the values of n variables taken k at a time in a \nminimal change order."},"ALLCOMBI":{"help":"Generates all combinations of the indices of n objects taken k at a time in a \nminimal change order."},"GRAYCODE":{"help":"Generates all subsets of n items in a minimal change order."},"IS8601_CONVERT":{"help":"Converts an ISO 8601 interval to datetime and duration values, or converts datetime \nand duration values to an ISO 8601 interval. \n\nSyntax: CALL IS8601_CONVERT(convert-from, convert-to, <from-variables>, <to-variables>,<date-time-replacements>);"},"LEXCOMB":{"help":"Generates all distinct combinations of the non-missing values of n variables taken \nk at a time in lexicographic order."},"LEXCOMBI":{"help":"Generates all combinations of the indices of n objects taken k at a time in \nlexicographic order."},"LEXPERK":{"help":"Generates all distinct permutations of the non-missing values of n variables taken \nk at a time in lexicographic order."},"LEXPERM":{"help":"Generates all distinct permutations of the non-missing values of several variables \nin lexicographic order."},"SORTC":{"help":"Sorts the values of character arguments."},"SORTN":{"help":"Sorts the values of numeric arguments."},"DQSCHEMEAPPLY":{"help":"Applies a scheme and returns a transformed value and a transformation flag."},"DQPARSE":{"help":"Returns a parsed character value and a status flag."},"DEFINE":{"help":"Sets the value of an attribute for a particular column in the current row."},"INSERT_CATALOG":{"help":"Inserts a SAS catalog into a package. \n    \nSyntax: \nCALL INSERT_CATALOG(packageId, libname, memname, desc, nameValue, rc); "},"INSERT_DATASET":{"help":"Inserts a SAS data set into a package. \n    \nSyntax:\nCALL INSERT_DATASET(packageId, libname, memname, desc, nameValue, rc <, properties, propValue1, ...propValueN>); "},"INSERT_FDB":{"help":"Inserts a financial database into a package. \n    \nSyntax: \nCALL INSERT_FDB(packageId, libname, memname, desc, nameValue, rc);"},"INSERT_FILE":{"help":"Inserts a file into a package. \n    \nSyntax \nCALL INSERT_FILE(packageId, filename, filetype, mimeType, desc, nameValue, rc<, properties, propValue1, ...propValueN>);"},"INSERT_HTML":{"help":"Inserts HTML files into a package. \n    \nSyntax:\nCALL INSERT_HTML(packageId, body, bodyUrl, frame, frameUrl, contents, contentsUrl, page, pageUrl, desc, nameValue, rc<, properties, propValue1, ...propValueN>);"},"INSERT_MDDB":{"help":"Inserts a SAS multidimensional database into a package. \n    \nSyntax:\nCALL INSERT_MDDB(packageId, libname, memname, desc, nameValue, rc);"},"INSERT_PACKAGE":{"help":"Inserts a package into another package."},"INSERT_REF":{"help":"Inserts a reference into a package. \n    \nSyntax:  \nCALL INSERT_REF(packageId, referenceType, reference, desc, nameValue, rc);"},"INSERT_SQLVIEW":{"help":"Inserts a PROC SQL view into a package. \n    \nSyntax \nCALL INSERT_SQLVIEW(packageId, libname, memname, desc, nameValue, rc);"},"INSERT_VIEWER":{"help":"Inserts a viewer into a package. \n    \nSyntax: \nCALL INSERT_VIEWER(packageId, filename, mimeType, desc, nameValue, rc<, properties, propValue1, ...propValueN>);"},"PACKAGE_BEGIN":{"help":"Initializes a package and returns a unique package identifier. \n    \nSyntax: \nCALL PACKAGE_BEGIN(packageId, desc, nameValue, rc<, properties, propValue1, ...propValueN>);"},"PACKAGE_END":{"help":"Frees the resources that are associated with a package. \n   \nSyntax \nCALL PACKAGE_END(packageId, rc);"},"PACKAGE_PUBLISH":{"help":"Publishes the specified package. The method of publication depends on the type of delivery transport."},"COMPANION_NEXT":{"help":"Retrieves the next companion HTML file in the ODS HTML set. \n    \nSyntax \nCALL COMPANION_NEXT(entryId, path, filename, url, rc <, properties, propValue1, ...propValueN>);"},"ENTRY_FIRST":{"help":"Returns header information for the first entry in a package. \n    \nSyntax: \nCALL ENTRY_FIRST(packageId, entryId, entryType, userSpecString, desc, nameValue, rc<, properties, propValue1, ...propValueN>);"},"ENTRY_NEXT":{"help":"Returns header information from the next entry in a package. \n    \nSyntax: \nCALL ENTRY_NEXT(packageId, entryId, entryType, userSpecString, desc, nameValue, rc<, properties, propValue1, ...propValueN>);"},"PACKAGE_DESTROY":{"help":"Deletes a package. \n    \nSyntax \nCALL PACKAGE_DESTROY(packageId, rc);"},"PACKAGE_FIRST":{"help":"Returns the header information for the first package in the package list. \n    \nSyntax \nCALL PACKAGE_FIRST(pkgListId, packageId, numEntries, desc, dateTime, nameValue, channel, rc<, properties, propValue1, ...propValueN>);"},"PACKAGE_NEXT":{"help":"Returns the header information for the next package in the package list. \n    \nSyntax:\nCALL PACKAGE_NEXT(pkgListId, packageId, numEntries, desc, dateTime, nameValue, channel, rc<, properties, propValue1, ...propValueN>);"},"PACKAGE_TERM":{"help":"Frees all resources associated with the package list identifier. \n    \nSyntax \nCALL PACKAGE_TERM(pkgListId, rc);"},"RETRIEVE_CATALOG":{"help":"Retrieves a catalog from a package. \n    \nSyntax \nCALL RETRIEVE_CATALOG(entryId, libname, memname, rc);"},"RETRIEVE_DATASET":{"help":"This CALL routine retrieves a data set entry from a package. \n    \nSyntax: \nCALL RETRIEVE_DATASET(entryId, libname, memname, rc<, properties, propValue1, ...propValueN>);"},"RETRIEVE_FDB":{"help":"Retrieves a financial database entry from a package. \n    \nSyntax: \nCALL RETRIEVE_FDB(entryId, libname, memname, rc); "},"RETRIEVE_FILE":{"help":"Retrieves an external binary or text file from a package. \n    \nSyntax: \nCALL RETRIEVE_FILE(entryId, filename, rc);"},"RETRIEVE_HTML":{"help":"Retrieves an HTML entry from a package. \n    \nSyntax: \nCALL RETRIEVE_HTML(entryId, path, body, bodyUrl, frame, frameUrl, contents, contentsUrl, pages, pagesUrl, rc<, properties, propValue1, ...propValueN>);"},"RETRIEVE_MDDB":{"help":"Retrieves an MDDB entry from a package. \n    \nSyntax: \nCALL RETRIEVE_MDDB(entryId, libname, memname, rc);"},"RETRIEVE_NESTED":{"help":"Retrieves the descriptive header information for a nested package entry.\n    \nSyntax: \nCALL RETRIEVE_NESTED(entryId,packageId, numEntries, desc, dateTime, nameValue, rc);"},"RETRIEVE_PACKAGE":{"help":"This CALL routine retrieves descriptive header information for all packages. \n    \nSyntax \nCALL RETRIEVE_PACKAGE(pkgListId, retrievalType, retrievalInfo, totalPackages, rc<, properties, propValue1, propValueN>);"},"RETRIEVE_REF":{"help":"Retrieves a reference from a package. \n    \nSyntax: \nCALL RETRIEVE_REF(entryId, referenceType, reference, rc);"},"RETRIEVE_SQLVIEW":{"help":"Retrieves a PROC SQL view from a package. \n    \nSyntax: \nCALL RETRIEVE_SQLVIEW(entryId, libname, memname, rc);"},"RETRIEVE_VIEWER":{"help":"Retrieves a viewer entry from a package.\n\nSyntax:\nCALL RETRIEVE_VIEWER(entryId, filename, rc<, properties, propValue1, ...propValueN>);"},"RANCOMB":{"help":"Permutes the values of the arguments, and returns a random combination of \nk out of n values.\n\nSyntax: \nCALL RANCOMB(seed, k, variable-1<, variable–2, ...> ); \n\nRequired Arguments:\nseed \n  is a numeric variable that contains the random number seed. \nk \n  is the number of values that you want to have in the random combination. \n  variable specifies all numeric variables, or all character variables that have the same length. \n  K values of these variables are randomly permuted."},"ADDMATRIX":{"help":"Performs an elementwise addition of two matrices or a matrix and a scalar.\n\n[Valid for PROC FCMP  only!]\n\nSyntax:\nCALL ADDMATRIX(X, Y, Z); \n\nRequired Arguments:\nX \n  specifies an input matrix with dimensions m x n (that is, X[m, n]) or a scalar. \nY \n  specifies an input matrix with dimensions m x n (that is, Y[m, n]) or a scalar. \nZ \n  specifies an output matrix with dimensions m x n (that is, Z[m, n]), such that Z= X + Y"},"CHOL":{"help":"Calculates the Cholesky decomposition for a given symmetric matrix.\n    \nSyntax: [Valid for PROC FCMP  only!]\nCALL CHOL(X, Y <, validate>); \n\nRequired Arguments:\nX \n  specifies a symmetric positive-definite input matrix with dimensions m x m (that is, X[m, m]). \nY \n  specifies an output matrix with dimensions m x m (that is, Y[m, m]). This variable contains \n  the Cholesky decomposition, such that \n  \n      Z = YY*\n\n  where Y is a lower triangular matrix with strictly positive diagonal entries and Y* denotes the \n  conjugate transpose of Y. \n  Note: If X is not symmetric positive-definite, then Y will be filled with missing values. \n\nOptional Argument:\nvalidate \n  specifies an optional argument that can increase the processing speed by avoiding error checking. \n  The argument can take the following values: \n  \n    0 the matrix X will be checked for symmetry. This is the default if the validate argument is omitted.  \n    1 the matrix is assumed to be symmetric."},"DET":{"help":"Calculates the determinant of a specified matrix that should be square.\n\n[Valid for PROC FCMP  only!]\n\nSyntax:\nCALL DET(X, a); \n\nRequired Arguments:\nX \n  specifies an input matrix with dimensions m x n (that is, X[m, m]). \na \n  specifies the returned determinate value, such that \n  \n    a = |X|"},"DYNAMIC_ARRAY":{"help":"Enables an array that is declared within a function to change size in an efficient manner.\n\n[Valid for PROC FCMP  only!]\n\nSyntax:\nCALL DYNAMIC_ARRAY(array–name, new-dim1–size, ...,, new-dimN-size); \n\nRequired Arguments:\narray-name \n  specifies the name of a temporary array. \nnew-dim-size \n  specifies a new size for the temporary array."},"ELEMMULT":{"help":"Performs an elementwise multiplication of two matrices.\n\nSyntax:\nCALL ELEMMULT(X, Y, Z); \n\nRequired Arguments \nX \n  specifies an input matrix with dimensions m x n (that is, X[m, n]). \nY \n  specifies an input matrix with dimensions m x n (that is, Y[m, n]). \nZ \n  specifies an output matrix with dimensions m x n (that is, Z[m, n])."},"EXPMATRIX":{"help":"Returns a matrix e**tA given the input matrix A and a multiplier t. \n    \n[Valid for PROC FCMP  only!]\n\nSyntax:\nCALL EXPMATRIX(X, t, Y); \n\nRequired Arguments:\nX \n  specifies an input matrix with dimensions m x m (that is, X[m, m]). \nt \n  specifies a double scalar value. \nY \n  specifies an output matrix with dimensions m x m (that is, Y[m, m]), such that \n\n      Y = Ԑ**tẊ where Ẋ is the mean of X"},"FILLMATRIX":{"help":"Replaces all of the element values of the input matrix with the specified value.\n \n[Valid for PROC FCMP  only!]\n\nSyntax:\nCALL FILLMATRIX(X, Y); \n\nRequired Arguments:\nX \n  specifies an input numeric matrix. \nY \n  specifies the numeric value that will fill the matrix."},"IDENTITY":{"help":"Converts the input matrix to an identity matrix.\n\n[Valid for PROC FCMP  only!]\n\nSyntax:\nCALL IDENTITY(X); \n\nRequired Argument:\nX \n  specifies an input matrix with dimensions m x m (that is, X[m, m])."},"INV":{"help":"Calculates a matrix that is the inverse of the provided input matrix that should \nbe a square, non-singular matrix.\n \n[Valid for PROC FCMP  only!] \n\nSyntax:\nCALL INV(X, Y); \n\nRequired Arguments:\nX \n  specifies an input matrix with dimensions m x m (that is, X[m, m]). \nY \n  specifies an output matrix with dimensions m x m (that is, Y[m, m]), such that \n  \n    Y[m.m] = X'[m,m]\n\n  where ' denotes inverse \n  \n    X x Y = Y x X = I\n  \nand I is the identity matrix."},"INVERSE":{"help":"Calculates a matrix that is the inverse of the provided input matrix that should \nbe a square, non-singular matrix.\n \n[Valid for PROC FCMP  only!] \n\nSyntax:\nCALL INV(X, Y); \n\nRequired Arguments:\nX \n  specifies an input matrix with dimensions m x m (that is, X[m, m]). \nY \n  specifies an output matrix with dimensions m x m (that is, Y[m, m]), such that \n  \n    Y[m.m] = X'[m,m]\n\n  where ' denotes inverse \n  \n    X x Y = Y x X = I\n  \nand I is the identity matrix."},"MULT":{"help":"Calculates the multiplicative product of two input matrices.\n\n[Valid for PROC FCMP  only!]\n\nSyntax:\nCALL MULT(X, Y, Z); \n\nRequired Arguments \nX \n  specifies an input matrix with dimensions m x n (that is, X[m, n]). \nY \n  specifies an input matrix with dimensions n x p (that is, Y[n, p]). \nZ \n  specifies an output matrix with dimensions m x p (that is, Z[m, p]), such that \n\n    Z[m,p] = X[m,n] x Y[n,p]"},"POWER":{"help":"Raises a square matrix to a given scalar value.\n \n[Valid for PROC FCMP  only!]\n\nSyntax:\nCALL POWER(X, a, Y); \n\nRequired Arguments:\nX \n  specifies an input matrix with dimensions m x m (that is, X[m, m]). \na \n  specifies an integer scalar value (power). \nY \n  specifies an output matrix with dimensions m x m (that is, Y[m, m]), such that \n\n    Y = X**a"},"SETNULL":{"help":"Sets a pointer element of a structure to null.\n\n[Valid for PROC FCMP  only!]\n\nSyntax:\nCALL SETNULL(pointer-element); \n\nRequired Argument:\npointer-element \n  is a pointer to a structure."},"STRUCTINDEX":{"help":"Enables you to access each structure element in an array of structures.\n    \nSyntax:\nCALL STRUCTINDEX(struct_array, index, struct_element); \n\nRequired Arguments:\nstruct_array \n  specifies an array.\nindex \n  is a 1–based index as used in most SAS arrays. \nstruct_element \n  points to an element in the array."},"SUBTRACTMATRIX":{"help":"Performs an element-wide subtraction of two matrices or a matrix and a scalar.\n\n[Valid for PROC FCMP  only!]\n\nSyntax:\nCALL SUBTRACTMATRIX(X, Y, Z); \n\nRequired Arguments:\nX \n  specifies an input matrix with dimensions m x n (that is, X[m, n]) or a scalar. \nY \n  specifies an input matrix with dimensions m x n (that is, Y[m, n]) or a scalar. \nZ \n  specifies an output matrix with dimensions m x n (that is, Z[m, n]), such that \n    \n      Z = X - Y"},"TRANSPOSE":{"help":"Returns the transpose of a matrix.\n\n[Valid for PROC FCMP  only!]\n\nSyntax: \nCALL TRANSPOSE(X, Y); \n\nRequired Arguments:\nX \n  specifies an input matrix with dimensions m x n (that is, X[m, n]). \nY \n  specifies an output matrix with dimensions n x m (that is, Y[n, m])"},"ZEROMATRIX":{"help":"Replaces all of the element values of the numeric input matrix with 0.\n    \n[Valid for PROC FCMP  only!]\n\nSyntax:\nCALL ZEROMATRIX(X); \n\nRequired Argument \nX \n  specifies a numeric input matrix."}}}

package/data/callRoutines.index.json

@@ -0,0 +1 @@
+{"group":"callRoutines","label":"SAS call routine","kind":1,"count":107,"entries":[["ADDMATRIX","CALL_ROUTINE"],["ALLCOMB","CALL_ROUTINE"],["ALLCOMBI","CALL_ROUTINE"],["ALLPERM","CALL_ROUTINE"],["CATS","CALL_ROUTINE"],["CATT","CALL_ROUTINE"],["CATX","CALL_ROUTINE"],["CHOL","CALL_ROUTINE"],["COMPANION_NEXT","CALL_ROUTINE"],["COMPCOST","CALL_ROUTINE"],["DEFINE","CALL_ROUTINE"],["DET","CALL_ROUTINE"],["DQPARSE","CALL_ROUTINE"],["DQSCHEMEAPPLY","CALL_ROUTINE"],["DYNAMIC_ARRAY","CALL_ROUTINE"],["ELEMMULT","CALL_ROUTINE"],["ENTRY_FIRST","CALL_ROUTINE"],["ENTRY_NEXT","CALL_ROUTINE"],["EXECUTE","CALL_ROUTINE"],["EXPMATRIX","CALL_ROUTINE"],["FILLMATRIX","CALL_ROUTINE"],["GRAYCODE","CALL_ROUTINE"],["IDENTITY","CALL_ROUTINE"],["INSERT_CATALOG","CALL_ROUTINE"],["INSERT_DATASET","CALL_ROUTINE"],["INSERT_FDB","CALL_ROUTINE"],["INSERT_FILE","CALL_ROUTINE"],["INSERT_HTML","CALL_ROUTINE"],["INSERT_MDDB","CALL_ROUTINE"],["INSERT_PACKAGE","CALL_ROUTINE"],["INSERT_REF","CALL_ROUTINE"],["INSERT_SQLVIEW","CALL_ROUTINE"],["INSERT_VIEWER","CALL_ROUTINE"],["INV","CALL_ROUTINE"],["INVERSE","CALL_ROUTINE"],["IS8601_CONVERT","CALL_ROUTINE"],["LABEL","CALL_ROUTINE"],["LEXCOMB","CALL_ROUTINE"],["LEXCOMBI","CALL_ROUTINE"],["LEXPERK","CALL_ROUTINE"],["LEXPERM","CALL_ROUTINE"],["LOGISTIC","CALL_ROUTINE"],["MISSING","CALL_ROUTINE"],["MODULE","CALL_ROUTINE"],["MULT","CALL_ROUTINE"],["PACKAGE_BEGIN","CALL_ROUTINE"],["PACKAGE_DESTROY","CALL_ROUTINE"],["PACKAGE_END","CALL_ROUTINE"],["PACKAGE_FIRST","CALL_ROUTINE"],["PACKAGE_NEXT","CALL_ROUTINE"],["PACKAGE_PUBLISH","CALL_ROUTINE"],["PACKAGE_TERM","CALL_ROUTINE"],["POKE","CALL_ROUTINE"],["POKELONG","CALL_ROUTINE"],["POWER","CALL_ROUTINE"],["PRXCHANGE","CALL_ROUTINE"],["PRXDEBUG","CALL_ROUTINE"],["PRXFREE","CALL_ROUTINE"],["PRXNEXT","CALL_ROUTINE"],["PRXPOSN","CALL_ROUTINE"],["PRXSUBSTR","CALL_ROUTINE"],["RANBIN","CALL_ROUTINE"],["RANCAU","CALL_ROUTINE"],["RANCOMB","CALL_ROUTINE"],["RANEXP","CALL_ROUTINE"],["RANGAM","CALL_ROUTINE"],["RANNOR","CALL_ROUTINE"],["RANPERK","CALL_ROUTINE"],["RANPERM","CALL_ROUTINE"],["RANPOI","CALL_ROUTINE"],["RANTBL","CALL_ROUTINE"],["RANTRI","CALL_ROUTINE"],["RANUNI","CALL_ROUTINE"],["RETRIEVE_CATALOG","CALL_ROUTINE"],["RETRIEVE_DATASET","CALL_ROUTINE"],["RETRIEVE_FDB","CALL_ROUTINE"],["RETRIEVE_FILE","CALL_ROUTINE"],["RETRIEVE_HTML","CALL_ROUTINE"],["RETRIEVE_MDDB","CALL_ROUTINE"],["RETRIEVE_NESTED","CALL_ROUTINE"],["RETRIEVE_PACKAGE","CALL_ROUTINE"],["RETRIEVE_REF","CALL_ROUTINE"],["RETRIEVE_SQLVIEW","CALL_ROUTINE"],["RETRIEVE_VIEWER","CALL_ROUTINE"],["RXCHANGE","CALL_ROUTINE"],["RXFREE","CALL_ROUTINE"],["RXSUBSTR","CALL_ROUTINE"],["SCAN","CALL_ROUTINE"],["SCANQ","CALL_ROUTINE"],["SET","CALL_ROUTINE"],["SETNULL","CALL_ROUTINE"],["SLEEP","CALL_ROUTINE"],["SOFTMAX","CALL_ROUTINE"],["SORTC","CALL_ROUTINE"],["SORTN","CALL_ROUTINE"],["STDIZE","CALL_ROUTINE"],["STREAMINIT","CALL_ROUTINE"],["STRUCTINDEX","CALL_ROUTINE"],["SUBTRACTMATRIX","CALL_ROUTINE"],["SYMPUT","CALL_ROUTINE"],["SYMPUTX","CALL_ROUTINE"],["SYSTEM","CALL_ROUTINE"],["TANH","CALL_ROUTINE"],["TRANSPOSE","CALL_ROUTINE"],["VNAME","CALL_ROUTINE"],["VNEXT","CALL_ROUTINE"],["ZEROMATRIX","CALL_ROUTINE"]]}

package/data/ds2Functions.docs.json

@@ -0,0 +1 @@
+{"group":"ds2Functions","count":136,"entries":{"ABS":{"help":"Returns the absolute value of a numeric value expression.\n    \nReturn value data type: BIGINT if all argument data types are BIGINT, otherwise, DOUBLE  \n    \nSyntax: ABS (expression)  \n\nArguments:\nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE, BIGINT \n \nDetails:\nIf the result is a number that does not fit into the range of the argument's data type, \nthe ABS function fails."},"ARCOS":{"help":"Returns the arccosine in radians. \n   \nReturn value data type: DOUBLE \n\nSyntax: ARCOS (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Range: -1 to 1 \n  Valid data types: DOUBLE \n \nDetails:\nThe ARCOS function returns the arccosine (inverse cosine) of the argument. The value \nthat is returned is specified in radians."},"ARSIN":{"help":"Returns the arcsine in radians. \n    \nReturn value data type: DOUBLE  \n\nSyntax: ARSIN (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Range: -1 to 1 \n  Valid data types: DOUBLE \n \nDetails:\nThe ARSIN function returns the arcsine (inverse sine) of the argument. The value that \nis returned is specified in radians."},"ATAN":{"help":"Returns the arctangent in radians. \n    \nReturn value data type: DOUBLE  \n\nSyntax: ATAN (expression)  \n\nArguments:\nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe ATAN function returns the 2-quadrant arctangent (inverse tangent) of the argument. \nThe value that is returned is the angle (in radians) whose tangent is x and whose value \nranges from -π/2 to π/2. \n\nComparisons:\nThe ATAN function is similar to the ATAN2 function except that ATAN2 calculates the \narctangent of the angle from the ratio of two arguments rather than from one argument."},"ARTAN":{"help":"Returns the arctangent in radians. \n    \nReturn value data type: DOUBLE  \n\nSyntax: ATAN (expression)  \n\nArguments:\nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe ATAN function returns the 2-quadrant arctangent (inverse tangent) of the argument. \nThe value that is returned is the angle (in radians) whose tangent is x and whose value \nranges from -π/2 to π/2. \n\nComparisons:\nThe ATAN function is similar to the ATAN2 function except that ATAN2 calculates the \narctangent of the angle from the ratio of two arguments rather than from one argument."},"ATAN2":{"help":"Returns the arctangent of the x and y coordinates of a right triangle, in radians. \n    \nReturn value data type: DOUBLE  \n\nATAN2 (expression-1, expression-2,)  \n\nArguments: \nexpression-1 \n  specifies any valid expression that evaluates to a numeric value. expression-1 specifies \n  the x coordinate of the end of the hypotenuse of a right triangle. \n  Valid data types: DOUBLE \n\nexpression-2 \n  specifies any valid expression that evaluates to a numeric value. expression-2 specifies \n  the y coordinate of the end of the hypotenuse of a right triangle.\n  Valid data types: DOUBLE \n \nDetails:\nThe ATAN2 function returns the arctangent (inverse tangent) of two numeric variables. \nThe result of this function is similar to the result of calculating the arc tangent \nof expression-1 / expression-2, except that the signs of both arguments are used to \ndetermine the quadrant of the result. \n \nComparisons:\nThe ATAN2 function is similar to the ATAN function except that ATAN calculates the \narctangent of the angle from the value of one argument rather than from two arguments."},"BAND":{"help":"Returns the bitwise logical AND of two arguments.\n    \nReturn value data type: DOUBLE  \n\nSyntax: BAND(expression-1, expression-2)  \n\nArguments: \nexpression-1, expression-2 \n  specifies any valid expression that evaluates to a numeric value. \n\n  Range: between 0 and (2³²)-1 inclusive ³²\n  Valid data types: DOUBLE"},"BLSHIFT":{"help":"Returns the bitwise logical left shift of two arguments. \n    \nReturn value data type: DOUBLE  \n\nSyntax: BLSHIFT(expression-1, expression-2)  \n\nArguments: \nexpression-1 \n  specifies any valid expression that evaluates to a numeric value.\n\n  Range: between 0 and (2³²)-1 inclusive \n  Valid data types: DOUBLE \n\nexpression-2 \n  specifies any valid expression that evaluates to a numeric value.\n\n  Range: 0 to 31, inclusive \n  Valid data types: DOUBLE"},"BNOT":{"help":"Returns the bitwise logical NOT of an argument. \n    \nReturn value data type: DOUBLE  \n\nSyntax: BNOT(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n\n  Range: between 0 and (2³²)-1 inclusive \n  Valid data types: DOUBLE"},"BOR":{"help":"Returns the bitwise logical OR of two arguments. \n    \nReturn value data type: DOUBLE  \n\nSyntax: BOR(expression-1, expression-2)  \n\nArguments:\nexpression-1, expression-2 \n  specifies any valid expression that evaluates to a numeric value.\n\n  Range: between 0 and (2³²)-1 inclusive \n  Valid data types: DOUBLE"},"BRSHIFT":{"help":"Returns the bitwise logical right shift of two arguments. \n    \nReturn value data type: DOUBLE  \n\nSyntax: BRSHIFT(expression-1, expression-2)  \n\nArguments: \nexpression-1 \n  specifies any valid expression that evaluates to a numeric value.\n\n  Range: between 0 and (2³²)-1 inclusive \n  Valid data types: DOUBLE \n\nexpression-2 \n  specifies any valid expression that evaluates to a numeric value. \n\n  Range: 0 to 31, inclusive \n  Valid data types: DOUBLE"},"BXOR":{"help":"Returns the bitwise logical EXCLUSIVE OR of two arguments. \n    \nReturn value data type: DOUBLE  \n\nSyntax: BXOR(expression-1, expression-2)  \n\nArguments: \nexpression-1, expression-2 \n  specifies any valid expression that evaluates to a numeric value.\n\n  Range: between 0 and (2³²)-1 inclusive \n  Valid data types: DOUBLE"},"BYTE":{"help":"Returns one character in the ASCII or the EBCDIC collating sequence. \n    \nReturn value data type: VARCHAR  \n\nSyntax: BYTE (n)  \n\nArguments: \nn \n  specifies an integer that represents a specific ASCII or EBCDIC character. \n\n  Range: 0-255 \n  Valid data types: NCHAR \n \nDetails: \nFor EBCDIC collating sequences, n is between 0 and 255. For ASCII collating sequences, \nthe characters that correspond to values between 0 and 127 represent the standard character \nset. Other ASCII characters that correspond to values between 128 and 255 are available on \ncertain ASCII operating environments, but the information those characters represent varies \nwith the operating environment."},"CEIL":{"help":"Returns the smallest integer greater than or equal to a numeric value expression. \n    \nReturn value data type: DOUBLE  \n\nSyntax: CEIL (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n   \nDetails:\nIf the result is a number that does not fit into the range of the argument's data type, \nthe CEIL function fails.\n \nComparisons: \nUnlike the CEILZ function, the CEIL function fuzzes the result. If the argument is within \n1E-12 of an integer, the CEIL function fuzzes the result to be equal to that integer. The \nCEILZ function does not fuzz the result. Therefore, with the CEILZ function you might get \nunexpected results."},"CEILZ":{"help":"Returns the smallest integer that is greater than or equal to the argument, \nusing zero fuzzing.   \n\nReturn value data type: DOUBLE  \n\nSyntax: CEILZ (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nComparisons:\nUnlike the CEIL function, the CEILZ function uses zero fuzzing. If the argument \nis within 1E-12 of an integer, the CEIL function fuzzes the result to be equal \nto that integer. The CEILZ function does not fuzz the result. Therefore, with \nthe CEILZ function you might get unexpected results."},"COALESCE":{"help":"Returns the first non-null or non-missing value from a list of numeric arguments. \n    \nReturn value data type: DOUBLE  \n\nSyntax: COALESCE(expression [ ,...expression ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nDetails:\nCOALESCE accepts one or more numeric expressions. The COALESCE function checks the value \nof each expression in the order in which they are listed and returns the first non-null \nor non-missing value. If only one value is listed, then the COALESCE function returns the \nvalue of that argument. If all the values of all expressions are null or missing, then the \nCOALESCE function returns a null or a missing value depending on whether you are in ANSI \nmode or SAS mode."},"COALESCEC":{"help":"Returns the first non-null or non-missing value from a list of character arguments. \n    \nReturn value data type: NCHAR  \n\nSyntax: COALESCEC(expression [ ,...expression ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character value. \n\n  Valid data types: NCHAR \n \nDetails:\nCOALESCEC accepts one or more character expressions. The COALESCEC function checks the \nvalue of each expression in the order in which they are listed and returns the first \nnon-null or non-missing value. If only one value is listed, then the COALESCEC function \nreturns the value of that expression. If all the values of all expressions are null or \nmissing, then the COALESCEC function returns a null or missing value depending on whether \nyou are in ANSI mode or SAS mode."},"COLLATE":{"help":"Returns a character string in ASCII or EBCDIC collating sequence. \n    \nValid for Data Types: NCHAR \n\nSyntax: COLLATE (start-position [, end-position ] )  \n\nArguments: \nstart-position \n  specifies the numeric position in the collating sequence of the first character to be returned. \n\n  Interaction: If you specify only start-position, COLLATE returns consecutive characters from \n  that position to the end of the collating sequence or up to 255 characters, whichever comes first. \n  Valid data types: NCHAR \n\nend-position \n  specifies the numeric position in the collating sequence of the last character to be returned.\n\n  The maximum end-position for the EBCDIC collating sequence is 255. For ASCII collating sequences, \n  the characters that correspond to end-position values between 0 and 127 represent the standard \n  character set. Other ASCII characters that correspond to end-position values between 128 and 255 \n  are available on certain ASCII operating environments, but the information that those characters \n  represent varies with the operating environment.\n\n  Requirement: end-position must be larger than start-position  \n  Valid data types: NCHAR \n  Tip: If you specify end-position, COLLATE returns all character values in the collating sequence \n  between start-position and end-position, inclusive. \n \nDetails: \nIf you request a string longer than the remainder of the sequence, COLLATE returns a \nstring through the end of the sequence."},"COMPBL":{"help":"Removes multiple blanks from a character string. \n    \nReturn value data types: NCHAR  \n\nDetails: \nThe COMPBL function removes multiple blanks in a character string by translating each \noccurrence of two or more consecutive blanks into a single blank.\n \nComparisons: \nThe COMPRESS function removes every occurrence of the specific character from a string. \nIf you specify a blank as the character to remove from the source string, the COMPRESS \nfunction is similar to the COMPBL function. However, the COMPRESS function removes all \nblanks from the source string, while the COMPBL function compresses multiple blanks to \na single blank and has no effect on a single blank."},"COMPRESS":{"help":"Returns a character string with specified characters removed from the original string. \n    \nReturn value data type: CHAR, NCHAR  \n\nSyntax: COMPRESS(character-expression [ , character-list-expression ] )  \n\nArguments: \ncharacter-expression \n  specifies any valid expression that evaluates to a character expression and \n  from which specified characters will be removed. \n\n  Requirement: Enclose a literal string of characters in single quotation marks. \n  Valid data types: CHAR, NCHAR \n\ncharacter-list-expression \n  specifies a variable or any valid expression that initializes a list of characters.\n\n  By default, the characters in this list are removed from character-expression. \n\n  Requirement: Enclose a literal string of characters in single quotation marks. \n  Valid data types: CHAR, NCHAR \n \nDetails: \nThe COMPRESS function allows null arguments. A null argument is treated as a string \nthat has a length of zero."},"COS":{"help":"Returns the cosine in radians. \n    \nReturn value data type: DOUBLE \n\nSyntax: COS (expression)  \n\nArguments: \nexpression \n  is any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE"},"COSH":{"help":"Returns the hyperbolic cosine in radians. \n    \nReturn value data type: DOUBLE  \n \nSyntax: COSH (expression)  \n\nArguments: \nexpression \n  is any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe COSH function returns the hyperbolic cosine of the argument, given by\n\n(ϵ^argument + ϵ^-argument)/2"},"CSS":{"help":"Returns the corrected sum of squares. \n    \nReturn value data type: DOUBLE  \n\nSyntax: CSS(expression [, ...expression] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n\n  Requirement: At least one non-null or non-missing expression is required. \n  Valid data types: DOUBLE"},"CV":{"help":"Returns the coefficient of variation. \n    \nReturn value data type: DOUBLE \n\nSyntax: CV(expression [, ...expression ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n\n  Requirement: At least two arguments are required. \n  Valid data types: DOUBLE"},"DATE":{"help":"Returns the current date as a SAS date value. \n\nReturn value data type: DOUBLE  \n\nSyntax: DATE()  \n \nDetails: \nThe DATE function does not take any arguments. The SAS date value returned is the number \nof days from January 1, 1960 to the current date."},"TODAY":{"help":"Returns the current date as a numeric SAS date value. \n    \nReturn value data type: DOUBLE  \n\nSyntax: TODAY()  \n \nDetails: \nThe TODAY function does not take any arguments. It produces the current date in the \nform of a SAS date value, which is the number of days since January 1, 1960."},"DATEJUL":{"help":"Converts a Julian date to a SAS date value. \n    \nReturn value data type: DOUBLE  \n \nSyntax: DATEJUL(julian-date)  \n\nArguments:\n  julian-date \n  specifies any valid expression that evaluates to a numeric value and that represents a Julian date. A Julian date is a date in the form yyddd or yyyyddd, where yy or yyyy is a two-digit or four-digit integer that represents the year and ddd is the number of the day of the year. The value of ddd must be between 1 and 365 (or 366 for a leap year).\n\n  Valid data types: DOUBLE \n \nDetails: \nA SAS date value is the number of days from January 1, 1960 to a specified date. The \nDATEJUL function returns the number of days from January 1, 1960 to the Julian date \nspecified in julian-date."},"DATEPART":{"help":"Extracts the date from a SAS datetime value. \n    \nReturn value data type: DOUBLE  \n\nSyntax: DATEPART(datetime)  \n\nArguments: \ndatetime \n  specifies any valid expression that represents a SAS datetime value.\n\n  Valid data types: DOUBLE \n \nDetails:\nA SAS datetime value is the number of seconds between January 1, 1960 and the hour, \nminute, and seconds within a specific date. The DATEPART function determines the date \nportion of the SAS datetime value and returns the date as a SAS date value, which is \nthe number of days from January 1, 1960."},"DATETIME":{"help":"Returns the current date and time of day as a SAS datetime value. \n    \nReturn value data type: DOUBLE  \n\nSyntax: DATETIME()  \n\nDetails: \nThe DATETIME function does not take any arguments. The SAS datetime value returned \nis the number of seconds from January 1, 1960 to the current date and time."},"DAY":{"help":"Returns the day of the month from a SAS date value. \n    \nReturn value data type: DOUBLE  \n\nSyntax: DAY(date)  \n\nArguments: \ndate \n  specifies any valid expression that represents a SAS date value.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe DAY function produces an integer from 1 to 31 that represents the day of the month.\n\nA SAS date value is the number of days from January 1, 1960 to a specific date."},"DEQUOTE":{"help":"Removes matching single quotation marks from a character string that begins with \na single quotation mark, and deletes all characters to the right of the closing \nquotation mark.  \n\nReturn value data types: NCHAR  \nSyntax: DEQUOTE(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. \n  Valid data types: NCHAR \n \nDetails:\nThe value that is returned by the DEQUOTE function depends on the first character or the \nfirst two characters in expression:\n\n  o If the first character of expression is not a quotation mark, DEQUOTE returns a syntax error.\n  o If the first character of expression is a single quotation mark, the DEQUOTE function removes \n    that single quotation mark from the result. DEQUOTE then scans expression from left to right, \n    looking for more single quotation marks or double quotation marks . \n\n    All paired single quotation marks are reduced to a single quotation mark. \n    All paired double quotation marks are retained.\n\n    If a double quotation mark is the second character, DEQUOTE removes the double quotation mark \n    from the result. DEQUOTE then scans expression from left to right. If a matching double quotation \n    mark is found, the text between the double quotation marks is returned. Any text to the right of \n    the closing double quotation mark, to the end of expression is removed from the result.\n\n    The first non-paired single quotation mark in expression is the closing single quotation mark and \n    is removed. \n\n    If a close parentheses follows the close single quotation mark, the function returns the dequoted \n    string. If characters exist to the right of the close single quotation mark, the function results \n    in a syntax error and the error is printed in the SAS log.\n\n  o If expression is enclosed in double quotation marks, the DEQUOTE function returns a null or missing value.\n\nNote: If expression is a constant enclosed by quotation marks, those quotation marks are not part \nof the value of expression. Therefore, you do not need to use DEQUOTE to remove the quotation marks \nthat denote a constant."},"DHMS":{"help":"Returns a SAS datetime value from date, hour, minute, and second values. \n    \nReturn value data type: DOUBLE  \n\nSyntax: DHMS(date,hour,minute,second)  \n\nArguments:\n\n  date \n    specifies any valid expression that represents a SAS date value.\n    Valid data types: DOUBLE \n  \n  hour \n    specifies a numeric expression that represents an integer from 1 through 12.\n    Valid data types: DOUBLE \n\n  minute \n    specifies a numeric expression that represents an integer from 1 through 59. \n    Valid data types: DOUBLE \n\n  second \n    specifies a numeric expression that represents an integer from 1 through 59. \n    Valid data types: DOUBLE \n \nDetails: \nThe DHMS function returns a numeric value that represents a SAS datetime value. \nThis numeric value can be either positive or negative."},"DIGAMMA":{"help":"Returns the value of the digamma function. \n    \nReturn value data type: DOUBLE  \n\nSyntax: DIGAMMA(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n\n  Restriction: Zero and negative integers are not valid. \n  Valid data types: DOUBLE \n\nDetails:\nThe DIGAMMA function returns the ratio that is given by\n\nΨ(x) = Γ΄(x)/ Γ(x)\n\nwhere Γ() and Γ΄() denote the Gamma function and its derivative, respectively. For expression > 0, \nthe DIGAMMA function is the derivative of the LGAMMA function."},"EXP":{"help":"Returns the value of the e constant raised to a specified power. \n    \nReturn value data type: DOUBLE  \n\nSyntax: EXP (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nDetails:\nThe EXP function raises the constant e, which is approximately given by 2.71828, \nto the power that is supplied by the argument. The result is limited by the maximum \nvalue of a double decimal value on the computer."},"FLOOR":{"help":"Returns the largest integer less than or equal to a numeric value expression. \n    \nReturn value data type: DOUBLE  \n\nSyntax: FLOOR (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nDetails:\nIf expression is within 1E-12 of an integer, the function returns that integer. If the \nresult is a number that does not fit into the range of a DOUBLE, the FLOOR function fails.\n\nComparisons: \nThe FLOOR function fuzzes the results so that if the results are within 1E-12 of an integer, \nthe FLOOR function returns that integer. The FLOORZ function uses zero fuzzing. Therefore, \nwith the FLOORZ function you might get unexpected results."},"FLOORZ":{"help":"Returns the largest integer that is less than or equal to the argument, using zero fuzzing. \n    \nReturn value data type: DOUBLE  \n\nSyntax: FLOORZ (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nComparisons: \nUnlike the FLOOR function, the FLOORZ function uses zero fuzzing. If the argument is within \n1E-12 of an integer, the FLOOR function fuzzes the result to be equal to that integer. The \nFLOORZ function does not fuzz the result. Therefore, with the FLOORZ function you might get \nunexpected results."},"FUZZ":{"help":"Returns the nearest integer if the argument is within 1E-12 of that integer. \n    \nReturn value data type: DOUBLE  \n\nSyntax: FUZZ(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe FUZZ function returns the nearest integer value if the expression is within 1E-12 of the \ninteger (that is, if the absolute difference between the integer and argument is less than \n1E-12). Otherwise, the expression is returned."},"GAMMA":{"help":"Returns the value of the gamma function. \n    \nReturn value data type: DOUBLE  \n\nSyntax: GAMMA(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n\n  Restriction: Nonpositive integers are invalid. \n  Valid data types: DOUBLE \n \nDetails:\nThe GAMMA function returns the integral, which is given by\n\nGAMMA(x)=∫t^(x-1) ϵ^(-t) dt\n\nFor positive integers, GAMMA(x) is (x - 1)!. This function is commonly denoted by Γ(x).\n\n"},"GCD":{"help":"Returns the greatest common divisor for a set of integers. \n    \nReturn value data type: DOUBLE  \n\nSyntax: GCD (expression-1, expression-2 [, ... expression-n ] )  \n\nArguments:\nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Requirements: At least two arguments are required. \n  Valid data types: DOUBLE \n \nDetails:\nThe GCD (greatest common divisor) function returns the greatest common divisor of one \nor more integers. For example, the greatest common divisor for 30 and 42 is 6. The \ngreatest common divisor is also called the highest common factor."},"GEOMEAN":{"help":"Returns the geometric mean. \n    \nReturn value data type: DOUBLE  \n\nSyntax: GEOMEAN(expression [, ....expression ] )  \n\nArguments: \nexpression \n  is any valid expression that evaluates to a non-negative numeric value.\n\n  Valid data types: DOUBLE \n \nDetails:\nIf any argument is negative, then the result is a null or missing value. A message \nappears in the log that the negative argument is invalid. If any argument is zero, \nthen the geometric mean is zero. If all the arguments are null or missing values, \nthen the result is a null or missing value. Otherwise, the result is the geometric \nmean of the non-null or non-missing values."},"GEOMEANZ":{"help":"Returns the geometric mean, using zero fuzzing. \n    \nReturn value data type: DOUBLE \n\nSyntax: GEOMEANZ(expression [, ... expression ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a non-negative numeric value.\n\n  Valid data types: DOUBLE \n \nDetails: \nIf any argument is negative, then the result is a null or missing value. A message \nappears in the log that the negative argument is invalid. If any argument is zero, \nthen the geometric mean is zero. If all the arguments are null or missing values, \nthen the result is a null or missing value. Otherwise, the result is the geometric \nmean of the non-null or non-missing values."},"HARMEAN":{"help":"Returns the harmonic mean. \n    \nReturn value data type: DOUBLE  \n\nSyntax: HARMEAN(expression [, ...expression ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a non-negative numeric value.\n\n  Valid data types: DOUBLE \n \nDetails:\nIf any argument is negative, then the result is a null or missing value. A message \nappears in the log that the negative argument is invalid. If all the arguments are \nnull or missing values, then the result is a null or missing value. Otherwise, the \nresult is the harmonic mean of the non-null or non-missing values. \n\nIf any argument is zero, then the harmonic mean is zero. Otherwise, the harmonic \nmean is the reciprocal of the arithmetic mean of the reciprocals of the values."},"HARMEANZ":{"help":"Returns the harmonic mean, using zero fuzzing. \n    \nReturn value data type: DOUBLE  \n\nSyntax: HARMEANZ(expression [, ...expression ] ) \n\nArguments: \n  expression \n  specifies any valid expression that evaluates to a non-negative numeric value.\n\n  Valid data types: DOUBLE \n \nDetails:\nIf any argument is negative, then the result is a null or value. A message appears \nin the log that the negative argument is invalid. If all the arguments are null or \nvalues, then the result is a null or value. Otherwise, the result is the harmonic \nmean of the non-null or non-missing values. \n\nIf any argument is zero, then the harmonic mean is zero. Otherwise, the harmonic \nmean is the reciprocal of the arithmetic mean of the reciprocals of the values."},"HMS":{"help":"Returns a SAS time value from hour, minute, and second values. \n    \nReturn value data type: DOUBLE  \n\nSyntax: HMS (hour, minute, second)  \n\nArguments: \nhour \n  specifies a numeric expression that represents an integer from 1 through 12.\n\n  Valid data types: DOUBLE \n  \nminute \n  specifies a numeric expression that represents an integer from 1 through 59. \n\n  Valid data types: DOUBLE \n\nsecond \n  specifies a numeric expression that represents an integer from 1 through 59.\n\n  Valid data types: DOUBLE \n \nDetails:\nThe HMS function returns a numeric value that represents a SAS time value. A SAS time \nvalue is a number that represents the number of seconds since midnight of the current day."},"HOUR":{"help":"Returns the hour from a SAS time or datetime value. \n    \nReturn value data type: DOUBLE  \n\nSyntax: HOUR( [time | datetime ] )  \n\nArguments: \ntime \n  specifies any valid expression that represents a SAS time value.\n\n  Valid data types: DOUBLE \n\ndatetime\n  specifies any valid expression that represents a SAS datetime value.\n\n  Valid data types: DOUBLE \n  \nDetails:\nThe HOUR function returns a numeric value that represents the hour from a SAS time \nor datetime value. Numeric values can range from 0 through 23. HOUR always returns \na positive number."},"INDEX":{"help":"Searches a character expression for a string of characters, and returns the \nposition of the string's first character for the first occurrence of the string.   \n\nReturn value data type: DOUBLE  \n\nSyntax: INDEX(target-expression, search-expression)  \n\nArguments: \ntarget-expression \n  specifies any valid expression that evaluates to a character string.\n\n  Valid data types: NCHAR \n  \nsearch-expression \n  specifies any valid expression that evaluates to a character string to search for in target-expression.\n\n  Valid data types: NCHAR \n  Tip: Enclose a literal string of characters in single quotation marks. \n \nDetails:\nThe INDEX function searches target-expression, from left to right, for the first \noccurrence of the string specified in search-expression, and returns the position \nin target-expression of the string's first character. If the string is not found \nin target-expression, INDEX returns a value of 0. If there are multiple occurrences \nof the string, INDEX returns only the position of the first occurrence. \n \nComparisons:\nThe VERIFY function returns the position of the first character in target-expression \nthat does not contain search-expression where the INDEX function returns the position \nof the first occurrence of search-expression that is present in target-expression."},"INDEXC":{"help":"Searches a character expression for specified characters and returns the position \nof the first occurrence of any of the characters. \n\nReturn value data type: DOUBLE  \n\nSyntax: INDEXC(target-expression, search-expression [, ...search-expression ] )  \n\nArguments: \ntarget-expression \n  specifies any valid expression that evaluates to a character string that is searched.\n\n  Valid data types: NCHAR \n\nsearch-expression \n  specifies the characters to search for in target-expression.\n\n  Valid data types: NCHAR \n  Tip: Enclose a literal string of characters in single quotation marks. \n \nDetails:\nThe INDEXC function searches target-expression, from left to right, for the first \noccurrence of any character present in the search expressions and returns the position \nin target-expression of that character. If none of the characters in the search \nexpressions are found in target-expression, INDEXC returns a value of 0.\n \nComparisons:\nThe INDEXC function searches for the first occurrence of any individual character that \nis present within the search expression, whereas the INDEX function searches for the \nfirst occurrence of the search expression as a pattern."},"INDEXW":{"help":"Searches a character expression for a string that is specified as a word, and \nreturns the position of the first character in the word. \n\nReturn value data type: DOUBLE  \nSyntax: INDEXW(target-expression, search-expression [, delimiter] )  \n\nArguments:\ntarget-expression \n  specifies any valid expression that evaluates to a character string that is searched. \n  Valid data types: NCHAR \n  \nsearch-expression \n  specifies any valid expression that evaluates to a character string and that is searched \n  for in target-expression. SAS removes the leading and trailing delimiters from search-expression.\n  Valid data types: NCHAR \n  Tip: INDEXW has the following behavior when search-expression contains blank spaces or \n  has a length of 0: \n  If both target-expression and search-expression contain only blank spaces or have a length \n  of 0, then INDEXW returns a value of 1. \n\n  If search-expression contains only blank spaces or has a length of 0, and target-expression \n  contains character or numeric data, then INDEXW returns a value of 0.  \n\ndelimiter \n  specifies a character expression that you want INDEXW to use as a word separator in the \n  character strings. The default delimiter is the blank character. \n  Tip: If the blank character is a delimiter, order it so that it is not the last character \n  in delimiter. Trailing blanks are ignored because delimiter is trimmed of trailing blanks. \n  Valid data types: NCHAR \n  \nDetails:\nThe INDEXW function searches target-expression, from left to right, for the first occurrence \nof search-expression and returns the position in target-expression of the substring's first \ncharacter. If the substring is not found in target-expression, then INDEXW returns a value \nof 0. If there are multiple occurrences of the string, then INDEXW returns only the position \nof the first occurrence.\n\nThe substring pattern must begin and end on a word boundary. For INDEXW, word boundaries are \ndelimiters, the beginning of target-expression, and the end of target-expression.\n \nComparisons: \nThe INDEXW function searches for strings that are words, whereas the INDEX function searches \nfor patterns as separate words or as parts of other words. INDEXC searches for any characters \nthat are present in the excerpts."},"INT":{"help":"Returns the integer value, fuzzed to avoid unexpected floating-point results. \n    \nReturn value data type: DOUBLE  \n\nSyntax: INT(expression)  \n\nArguments: \nexpression \n  specifies any expression that evaluates to a numeric value. \n  Valid data types: DOUBLE \n \nDetails: \nThe INT function returns the integer portion of the argument (truncates the decimal portion). \nIf the argument's value is within 1E-12 of an integer, the function results in that integer. \nIf the value of expression is positive, the INT function has the same result as the FLOOR \nfunction. If the value of expression is negative, the INT function has the same result as \nthe CEILING function. \n \nComparisons:\nUnlike the INTZ function, the INT function fuzzes the result. If the argument is within \n1E-12 of an integer, the INT function fuzzes the result to be equal to that integer. The \nINTZ function does not fuzz the result. Therefore, with the INTZ function you might get \nunexpected results."},"INTZ":{"help":"Returns the integer portion of the argument, using zero fuzzing. \n    \nReturn value data type: DOUBLE  \n\nSyntax: INTZ (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe following rules apply: \n\n  o If the value of the argument is an exact integer, INTZ returns that integer.\n\n  o If the argument is positive and not an integer, INTZ returns the largest integer that is less than the argument. \n\n  o If the argument is negative and not an integer, INTZ returns the smallest integer that is greater than the argument.\n \nComparisons: \nUnlike the INT function, the INTZ function uses zero fuzzing. If the argument is within 1E-12 \nof an integer, the INT function fuzzes the result to be equal to that integer. The INTZ function \ndoes not fuzz the result. Therefore, with the INTZ function you might get unexpected results."},"IQR":{"help":"Returns the interquartile range. \n    \nReturn value data type: DOUBLE \n\nSyntax: IQR(expression [, ...expression ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nDetails: \nIf all arguments have null or missing values, the result is a null or missing value \ndepending on whether you are in ANSI mode or SAS mode.\n\nOtherwise, the result is the interquartile range of the non-null or non-missing values. \nThe formula for the interquartile range is the same as the one that is used in the\nBase SAS UNIVARIATE procedure."},"JULDATE":{"help":"Returns the Julian date from a SAS date value. \n    \nReturn value data type: DOUBLE  \nSyntax: JULDATE(date)  \n\nArguments: \ndate \n  specifies any valid expression that represents a SAS date value. \n  Valid data types: DOUBLE \n \nDetails:\nA SAS date value is a number that represents the number of days from January 1, 1960 \nto a specific date. The JULDATE function converts a SAS date value to a Julian date. \nIf date falls within the 100-year span defined by the system option YEARCUTOFF=, the \nresult has three, four or five digits: In a five digit result, the first two digits \nrepresent the year, and the next three digits represent the day of the year (1 to 365, \nor 1 to 366 for leap years). As leading zeros are dropped from the result, the year \nportion of a Julian date can be omitted (for years ending in 00) or it can have only \none digit (for years ending 01 - 09). Otherwise, the result has seven digits: the \nfirst four digits represent the year, and the next three digits represent the day \nof the year.\n\nFor years that end between 00 - 09, you can format the five digit Julian date by \nusing the Z5. format. \n\nComparisons: \nThe function JULDATE7 is similar to JULDATE except that JULDATE7 always returns a \nfour digit year. Thus JULDATE7 is year 2000 compliant because it eliminates the need \nto consider the implications of a two digit year."},"JULDATE7":{"help":"Returns a seven-digit Julian date from a SAS date value. \n    \nReturn value data type: DOUBLE  \n\nSyntax: JULDATE7(date)  \n\nArguments: \ndate \n  specifies any valid expression that represents a SAS date value. \n  Valid data types: DOUBLE \n \nDetails:\nA SAS date value is a number that represents the number of days from January 1, 1960 \nto a specific date. The JULDATE7 function returns a seven digit Julian date from a SAS \ndate value. The first four digits represent the year, and the next three digits represent \nthe day of the year. \n\nComparisons: \nThe function JULDATE7 is similar to JULDATE except that JULDATE7 always returns a four \ndigit year. Thus JULDATE7 is year 2000 compliant because it eliminates the need to consider \nthe implications of a two digit year."},"KURTOSIS":{"help":"Returns the kurtosis. \n    \nReturn value data type: DOUBLE  \n\nSyntax \nKURTOSIS(expression-1, expression-2, expression-3, expression-4 [ ,...expression-n ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Requirement: At least four non-null or non-missing arguments are required. Otherwise, \n  the function returns a null or missing value.  \n  Valid data types: DOUBLE \n \nDetails: \nKurtosis is primarily a measure of the heaviness of the tails of a distribution. Large \nkurtosis values indicate that the distribution has heavy tails. \n\nNull values and missing values are ignored and are not included in the computation.\n\nIf all non-null or non-missing arguments have equal values, the kurtosis is mathematically \nundefined and the KURTOSIS function returns a null or missing value."},"LARGEST":{"help":"Returns the kth largest non-null or non-missing value. \n    \nReturn value data type: DOUBLE  \nSyntax: LARGEST (k, expression [, ...expression] )  \n\nArguments: \nk \n  specifies any valid expression that evaluates to a numeric value that represents \n  the largest value to return. For example, if k is 2, the LARGEST function returns \n  the second largest value from the list of expressions.\n\n  Valid data types: DOUBLE \n  See: TSPL Expressions \n\nexpression \n  specifies any valid expression that evaluates to a numeric value and that is to be searched. \n  Valid data types: DOUBLE \n  See: TSPL Expressions \n \nDetails:\nIf k is null or missing, less than zero, or greater than the number of values, the result \nis a null or missing value. Otherwise, if k is greater than the number of non-null or \nnon-missing values, the result is a null or missing value."},"LCM":{"help":"Returns the least common multiple for a set of integers. \n    \nReturn value data type: DOUBLE \n\nSyntax \nLCM (expression-1, expression-2 [ ,...expression-n ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to an integer.\n\n  Requirements: At least two arguments are required. \n  Valid data types: DOUBLE \n \nDetails: \nThe least common multiple is the smallest number that two or more numbers will \ndivide into evenly."},"LEFT":{"help":"Left aligns a character expression. \n    \nReturn value data type: VARCHAR, NVARCHAR  \n\nSyntax: LEFT(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. \n  Valid data types: CHAR, NCHAR \n \nDetails: \nLEFT returns a character string with leading blanks moved to the end of the value."},"LENGTH":{"help":"Returns the length of a character string, excluding trailing blanks, and returns a 0 \nfor a blank character string. \n\nReturn value data type: DOUBLE  \n\nSyntax: LENGTH(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. \n  Valid data types: CHAR, NCHAR \n \nDetails:\nThe LENGTH function returns an integer that represents the position of the rightmost \nnon-blank character or number in expression. If the value of expression is a blank \ncharacter, LENGTH returns a value of 0. If expression is a numeric expression, LENGTH \nconverts and processes the expression as a character expression. \n\nComparisons: \nThe LENGTH function returns the length of a character string, excluding trailing blanks, \nwhereas the LENGTHC function returns the length of a character string, including trailing blanks.\n\nThe LENGTH function returns the length of a character string, excluding trailing blanks,\nwhereas the LENGTHM function returns the amount of memory in bytes that is allocated for \na character string."},"LENGTHN":{"help":"Returns the length of a character string, excluding trailing blanks, and returns a 0 \nfor a blank character string. \n\nReturn value data type: DOUBLE  \n\nSyntax: LENGTH(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. \n  Valid data types: CHAR, NCHAR \n \nDetails:\nThe LENGTH function returns an integer that represents the position of the rightmost \nnon-blank character or number in expression. If the value of expression is a blank \ncharacter, LENGTH returns a value of 0. If expression is a numeric expression, LENGTH \nconverts and processes the expression as a character expression. \n\nComparisons: \nThe LENGTH function returns the length of a character string, excluding trailing blanks, \nwhereas the LENGTHC function returns the length of a character string, including trailing blanks.\n\nThe LENGTH function returns the length of a character string, excluding trailing blanks,\nwhereas the LENGTHM function returns the amount of memory in bytes that is allocated for \na character string."},"LENGTHC":{"help":"Returns the length of a character string, including trailing blanks. \n    \nReturn value data type: DOUBLE  \nSyntax: LENGTHC(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. \n  Valid data types: NCHAR \n  \nDetails:\nThe LENGTHC function returns an integer that represents the position of the rightmost \nblank or non-blank character in expression. For fixed-length variables, LENGTHC returns \nthe declared length of the variable. If the value of expression is missing and contains \nblanks, LENGTHC returns the number of blanks in expression. If expression is a numeric \nexpression, LENGTHC converts and processes the numeric expression as a character expression. \n\nComparisons: \n  o The LENGTHC function returns the length of a character string, including trailing blanks, \n    whereas the LENGTH function returns the length of a character string, excluding trailing \n    blanks. LENGTHC always returns a value that is greater than or equal to the value returned \n    by LENGTH.\n\n  o The LENGTHC function returns the length of a character string, including trailing blanks, \n    whereas the LENGTHM function returns the amount of memory in bytes that is allocated for \n    a character string. For fixed-length character strings, LENGTHC and LENGTHM always return \n    the same value. For varying-length character strings, LENGTHC always returns a value that \n    is less than or equal to the value returned by LENGTHM."},"LENGTHM":{"help":"Returns the amount of memory, in characters, that is allocated for a character string. \n    \nReturn value data type: DOUBLE  \nSyntax: LENGTHM(character-expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. \n  Valid data types: NCHAR \n \nDetails: \nThe LENGTHM function returns an integer that represents the amount of memory in bytes \nthat is allocated for the expression. If expression is a numeric expression (either \ninitialized or uninitialized), SAS automatically converts the numeric value to a right-\njustified character string by using the BEST12. format. In this case, LENGTHM returns \na value of 12 and writes a note in the SAS log stating that the numeric values have \nbeen converted to character values.\n \nComparisons: \nThe LENGTHM function returns the amount of memory in characters that is allocated for \na character string, whereas the LENGTH and LENGTHC functions return the length of a \ncharacter string. LENGTHM always returns a value that is greater than or equal to the \nvalues returned by LENGTH and LENGTHC."},"LGAMMA":{"help":"Returns the natural logarithm of the Gamma function. \n    \nReturn value data type: DOUBLE  \n\nSyntax: LGAMMA(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Requirement: Must be a positive number. \n  Valid data types: DOUBLE"},"LOG":{"help":"Returns the natural logarithm (base e) of a numeric value expression. \n    \nReturn value data type: DOUBLE \n \nSyntax: LOG (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE"},"LOG10":{"help":"Returns the base-10 logarithm of a numeric value expression. \n    \nReturn value data type: DOUBLE  \n\nSyntax: LOG10 (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Requirement: Must be a positive number. \n  Valid data types: DOUBLE"},"LOG2":{"help":"Returns the base 2 logarithm of a numeric value expression. \n    \nReturn value data type: DOUBLE  \n\nSyntax: LOG2 (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Requirement: Must be a positive number. \n  Valid data types: DOUBLE"},"LOWCASE":{"help":"Converts all letters in a character expression to lowercase. \n    \nReturn value data type: VARCHAR, NVARCHAR  \nSyntax: LOWCASE(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. \n  Requirement: Literal character expressions must be enclosed in single quotation marks. \n  Valid data types: CHAR, NCHAR \n  \nDetails: \nThe LOWCASE function copies a character expression, converts all uppercase letters to \nlowercase letters, and returns the altered value as a result.\n \nComparisons: \nThe UPCASE function converts all letters in an argument to uppercase letters. The LOWCASE \nfunction converts all letters in an argument to lowercase letters."},"MAX":{"help":"Returns the largest value from a list of arguments. \n    \nReturn value data type: BIGINT if all argument data types are BIGINT, otherwise, DOUBLE  \nSyntax: MAX(expression-1, expression-2 [ ,...expression-n ] )  \n\nArguments: \nexpression \n  is any valid expression that evaluates to a numeric value. \n  Requirement: At least two arguments are required. \n  Valid data types: DOUBLE, BIGINT \n  \nComparisons: \nThe MAX function returns the largest value from a list of arguments. The MAX operator (<>) \nreturns the largest of two operands. \n\nThe MAX function returns a null or missing value only if all arguments are null or missing. \nThe MAX operator (<>) returns a null or missing value only if both operands are null or \nmissing. In this case, it returns the value of the operand that is higher in the sort order \nfor null or missing values."},"MDY":{"help":"Returns a SAS date value from month, day, and year values. \n    \nReturn value data type: DOUBLE  \n\nSyntax: MDY(month, day, year)  \n\nArguments: \nmonth \n  specifies a numeric expression that represents an integer from 1 through 12. \n  Valid data types: DOUBLE \n\nday \n  specifies a numeric expression that represents an integer from 1 through 31. \n  Valid data types: DOUBLE \n  \nyear \n  specifies a numeric expression that represents a two-digit or four-digit year. \n  The YEARCUTOFF= system option defines the year value for two-digit dates. \n  Valid data types: DOUBLE"},"MEAN":{"help":"Returns the arithmetic mean (average) of the non-null or non-missing arguments. \n    \nReturn value data type: DOUBLE  \n\nSyntax: MEAN(expression [, ...expression] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n\n  Requirement: At least one non-null or non-missing argument is required. Otherwise, \n  the function returns a null or missing value.  \n  Valid data types: DOUBLE \n \nComparisons:\nThe GEOMEAN function returns the geometric mean, the HARMEAN function returns the harmonic \nmean, and the MEDIAN function returns the median of the non-null or non-missing values, \nwhereas the MEAN function returns the arithmetic mean (average)."},"MIN":{"help":"Returns the smallest value. \n    \nReturn value data type: BIGINT if all argument data types are BIGINT, otherwise, DOUBLE  \n\nSyntax: MIN(expression-1, expression-2 [, ...expression-n ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n  Requirement: At least two arguments are required.  \n  Valid data types: DOUBLE, BIGINT \n  \nComparisons: \nThe MIN function returns the smallest value from a list of values. The MIN operator (><) \nreturns the smallest value of two operands. \n\nThe MIN function returns a null or missing value only if all arguments are null or missing. \nThe MIN operator returns a null or missing value only if either operand is null or missing. \nIn this case, it returns the value of the operand that is lower in the sort order for null \nor missing values."},"MINUTE":{"help":"Returns the minute from a SAS time or datetime value. \n    \nReturn value data type: DOUBLE  \n\nSyntax: MINUTE(time | datetime)  \n\nArguments: \ntime \n  specifies any valid expression that represents a SAS time value.\n  Valid data types: DOUBLE \n\ndatetime \n  specifies any valid expression that represents a SAS datetime value.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe MINUTE function returns an integer that represents a specific minute of the hour. \nMINUTE always returns a positive number in the range of 0 through 59. Null or missing \nvalues are ignored."},"MISSING":{"help":"Returns a number that indicates whether the argument contains a missing value. \n    \nReturn value data type INTEGER  \n\nnumeric-expression \n  specifies any valid expression that evaluates to a numeric value. \n  Valid data types: DOUBLE \n\ncharacter-expression \n  specifies any valid expression that evaluates to a character value. \n  Valid data types: CHAR, NCHAR \n \nDetails:\nThe MISSING function checks a numeric or character expression for a null or missing value, \nand returns a numeric result. If the argument does not contain a null or missing value, SAS \nreturns a value of 0. If the argument contains a null or missing value, SAS returns a value of 1. \n\ncharacter-expression is defined as having a missing value if the result of the expression \ncontains all blank spaces.\n\nnumeric-expression is defined as having a missing value if the result of the expression is\nnull or missing ( . ), or if the expression contains special missing values that you used \nto differentiate among missing values. The special missing values are the letters A through \nZ and the underscore, preceded by a period.\n \nComparisons: \nThe MISSING function can have only one argument. The NMISS function requires numeric arguments \nand returns the number of missing values in the list of arguments."},"MOD":{"help":"Returns the remainder from the division of the first argument by the second argument, \nfuzzed to avoid most unexpected floating-point results. \n\nReturn value data type: DOUBLE  \nSyntax: MOD (dividend-expression, divisor-expression)  \n\nArguments: \ndividend-expression \n  specifies a dividend that is any valid expression that evaluates to a numeric value. \n  Valid data types: DOUBLE \n\ndivisor-expression \n  specifies a divisor that is any valid expression that evaluates to a numeric value. \n  Restriction: divisor-expression cannot be 0 \n  Valid data types: DOUBLE \n  See: TSPL Expressions \n  \nDetails: \nThe MOD function returns the remainder from the division of dividend-expression by divisor-expression. \nWhen the result is non-zero, the result has the same sign as the first argument. The sign of the second \nargument is ignored.\n\nThe computation that is performed by the MOD function is exact if both of the following conditions are true: \n  o Both arguments are exact integers. \n  o All integers that are less than either argument have exact 8-byte floating-point representations.\n\nIf either of the above conditions is not true, a small amount of numerical error can occur in the \nfloating-point computation. In this case \n  o MOD returns zero if the remainder is very close to zero or very close to the value of the second argument. \n  o MOD returns a null or missing value if the remainder cannot be computed to a precision of approximately \n    three digits or more. In this case, SAS also writes an error message to the log."},"MODZ":{"help":"Returns the remainder from the division of the first argument by the second argument, \nusing zero fuzzing.\n\nReturn value data type: DOUBLE  \nSyntax: MODZ (dividend-expression, divisor-expression)  \n\nArguments: \ndividend-expression \n  specifies a dividend that is any valid expression that evaluates to a numeric value. \n  Valid data types: DOUBLE \n\ndivisor-expression \n  specifies a divisor that is any valid expression that evaluates to a numeric value. \n  Restriction: divisor-expression cannot be 0 \n \nDetails: \nThe MODZ function returns the remainder from the division of dividend-expression by \ndivisor-expression. When the result is non-zero, the result has the same sign as the \nfirst argument. The sign of the second argument is ignored.\n\nThe computation that is performed by the MODZ function is exact if both of the following \nconditions are true: \n  o Both arguments are exact integers. \n  o All integers that are less than either argument have exact 8-byte floating-point representation. \n\nIf either of the above conditions is not true, a small amount of numerical error can occur in the \nfloating-point computation. For example, when you use exact arithmetic and the result is zero, \nMODZ might return a very small positive value or a value slightly less than the second argument."},"MONTH":{"help":"Returns a number that represents the month from a SAS date value. \n    \nReturn value data type: DOUBLE \n\nSyntax: MONTH(date)  \n\nArguments:\ndate \n  specifies any valid expression that represents a SAS date value.\n\n  Range: 1 - 12 \n  Valid data types: DOUBLE"},"N":{"help":"Returns the number of non-null or non-missing numeric values.   \n    \nReturn value data type: DOUBLE  \n\nSyntax: N(expression [, ...expression ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n\n  Requirements: At least one argument is required. \n  Valid data types: DOUBLE \n \nDetails:\nNull values are converted to missing values and are counted as missing values.\n\nComparisons: \nThe N function counts non-null and non-missing values, whereas the NMISS function \ncounts missing values. The N function requires numeric arguments."},"NMISS":{"help":"Returns the number of null and SAS missing numeric values. \n    \nReturn value data type: INTEGER  \n\nSyntax: NMISS(expression [, ...expression ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n\n  Requirements: At least one argument is required. \n  Valid data types: DOUBLE \n \nDetails: \nNull values are converted to SAS missing values and are counted as missing values.\n \nComparisons: \nThe NMISS function returns the number of null or SAS missing values, whereas the N \nfunction returns the number of non-null and non-missing values. NMISS requires numeric \nvalues and works with multiple numeric values, whereas MISSING works with only one value \nthat can be either numeric or character."},"NULL":{"help":"Returns a 1 if the argument is null and a 0 if the argument is not null. \n    \nReturn value data type: DOUBLE  \n\nSyntax: NULL (expression)  \n\nArguments: \nexpression \n  specifies any valid expression.\n\n  Valid data types: CHAR, DOUBLE. \n   \nDetails:\nThe NULL function returns a 1 only for a null value. It returns a 0 for a SAS missing value."},"ORDINAL":{"help":"Orders a list of values, and returns a value that is based on a position in the list. \n    \nReturn value data type: DOUBLE  \n\nSyntax: ORDINAL(position, expression-1, expression-2 [ , ...expression-n ] )  \n\nArguments: \n  position \n  specifies an integer that is less than or equal to the number of elements in the list of arguments. \n  Requirements: position must be a positive number. \n  Valid data types: DOUBLE \n\nexpression\n  specifies any valid expression that evaluates to a numeric value. \n  Requirements: At least two arguments are required. \n  Valid data types: DOUBLE \n \nDetails: \nThe ORDINAL function sorts the list and returns the argument in the list that is specified \nby position. Missing values are sorted low and are placed before any numeric values.\n \nComparisons: \nThe ORDINAL function counts both null, missing, non-null, and non-missing values, whereas \nthe SMALLEST function counts only non-null and non-missing values."},"PCTL":{"help":"Returns the percentile that corresponds to the percentage. \n    \nReturn value data type: DOUBLE \nSyntax: PCTL[ n ](percentage, expression[, ...expression ] )  \n\nArguments: \nn \n  is a digit from 1 to 5 which specifies the definition of the percentile to be computed. \n  Default: definition 5 \n  Valid data types: DOUBLE    \n\npercentage \n  specifies the percentile to be computed. \n  Requirement: is numeric where, 0 percentage 100. \n  Valid data types: DOUBLE \n\nexpression \n  specifies any valid expression that evaluates to a numeric value, whose value is computed \n  in the percentile calculation.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe PCTL function returns the percentile of the non-null or non-missing values corresponding \nto the percentage. If percentage is null or missing, less than zero, or greater than 100, the \nPCTL function generates an error message."},"POWER":{"help":"Returns the value of a numeric value expression raised to a specified power. \n    \nReturn value data type: DOUBLE  \n\nSyntax: POWER (numeric-expression, integer-expression) \n\nArguments: \nnumeric-expression \n  specifies any valid expression that evaluates to a numeric value. \n  Valid data types: DOUBLE \n\ninteger-expression \n  specifies any valid expression that evaluates to an integer value. \n  Valid data types: INTEGER, DOUBLE \n   \nDetails: \nIf numeric_expression is null, then the POWER function returns null. If the result \nis a number that does not fit into the range of the argument's data type, the POWER \nfunction fails."},"PUT":{"help":"Returns a value using a specified format. \n    \nReturn value data type: NVARCHAR  \nSyntax: PUT(expression, format.)  \n\nArguments:\nexpression \n  specifies any valid expression. \n  Valid data types: DOUBLE, DATE, TIME, TIMESTAMP, CHAR, NCHAR \n\nformat. \n  specifies either a TSPL format or a user-defined format that you want applied to expression. \n  To override the default alignment, you can add an alignment specification to a format: \n\n  -L left aligns the value  \n  -C centers the value  \n  -R right aligns the value\n  \nDetails: \nIf a value is not specified for the format width or decimal specification, TSPL uses the default \nvalues for that format.\n\nIf expression is not a valid data type for the format type (either numeric or character), TSPL \nconverts expression to a valid data type for format., with these exceptions:\n\n  o date and time expressions are converted to a SAS date, time, or datetime DOUBLE value for \n    numeric formats, and converted to NCHAR for character string formats \n  o when the format is a binary character format such as $BINARY, $HEX or $OCTAL, expressions \n    with a data type of DOUBLE are converted to NCHAR \n  o an error is issued when an expression with a data type of VARBINARY is used with a numeric \n    format that does not produce a data type of VARBINARY\n\nWhen TSPL converts an expression's data type in an assignment statement, the result is left-aligned. \nYou can use the PUT function to convert a numeric value to a character value and to convert a date, \ntime, or timestamp value to a SAS date/time value."},"QTR":{"help":"Returns the quarter of the year from a SAS date value. \n    \nReturn value data type: DOUBLE  \n\nSyntax: QTR(date)  \n\nArguments: \ndate \n  specifies any valid expression that represents a SAS date value.\n\n  Valid data types: DOUBLE \n  See: TSPL Expressions \n \nDetails: \nThe QTR function returns a value of 1, 2, 3, or 4 from a SAS date value to indicate \nthe quarter of the year in which a date value falls."},"QUOTE":{"help":"Adds double quotation marks to a character value. \n    \nReturn value data type: NCHAR \nSyntax: QUOTE(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. \n  Valid data types: NCHAR \n \nDetails: \nThe QUOTE function adds double quotation marks, the default character, to a character value. If \ndouble quotation marks are found within the argument, they are doubled in the output.\n\nThe length of the receiving variable must be long enough to contain the argument (including \ntrailing blanks), leading and trailing quotation marks, and any embedded quotation marks that \nare doubled. For example, if the argument is ABC followed by three trailing blanks, then the \nreceiving variable must have a length of at least eight to hold \"ABC###\". (The character # \nrepresents a blank space.) If the receiving field is not long enough, the QUOTE function \nreturns a blank string, and writes an invalid argument note to the SAS log.\n\nA string of characters enclosed in double quotation marks is a TSPL identifier and not a \ncharacter constant. The double quotation marks become part of the identifier. Quoted \nidentifiers cannot be used to create column names in an output table."},"RANGE":{"help":"Returns the difference between the largest and the smallest values. \n    \nReturn value data type: DOUBLE  \n\nSyntax: RANGE(expression [, ...expression ) ] \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n\n  Requirements: At least one non-null or non-missing argument is required. Otherwise, \n  the function returns a null or missing value.  \n  Valid data types: DOUBLE \n \nDetails: \nThe RANGE function returns the difference between the largest and the smallest of the \nnon-null or non-missing arguments."},"RANK":{"help":"Returns the position of a character in the ASCII or EBCDIC collating sequence. \n    \nReturn value data type: DOUBLE  \n\nSyntax: RANK(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. \n  Valid data types: NCHAR \n \nDetails: \nThe RANK function returns an integer that represents the position of the first character \nin the character expression."},"REPEAT":{"help":"Repeats a character expression. \n    \nReturn value data type: VARCHAR, NVARCHAR  \n\nSyntax: REPEAT(expression, n)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string.\n  Valid data types: CHAR, NCHAR \n\nn \n  specifies the number of times to repeat expression.\n  Restriction: n must be greater than or equal to 0. \n  Valid data types: INTEGER \n \nDetails: \nThe REPEAT function returns a character value consisting of the first argument repeated \nn times. Thus, the first argument appears n+1 times in the result."},"REVERSE":{"help":"Reverses a character expression. \n    \nReturn value data type: NCHAR  \n\nSyntax: REVERSE(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string.\n\n  Valid data types: NCHAR \n  See: TSPL Expressions \n \nDetails: \nThe REVERSE function returns a character value with the last character in the expression \nis the first character in the result, the next-to-last character in the expression is the \nsecond character in the result, and so on. \n\nNote: Trailing blanks in the expression become leading blanks in the result."},"RIGHT":{"help":"Right aligns a character expression. \n    \nReturn value data type: NCHAR  \n\nSyntax: RIGHT(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string.\n\n  Valid data types: NCHAR \n\nDetails: \nThe RIGHT function returns an argument with trailing blanks moved to the start of the \nvalue. The argument's length does not change."},"RMS":{"help":"Returns the root mean square. \n    \nReturn value data type: DOUBLE  \n\nSyntax: RMS(expression [, ...expression ) ]  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe root mean square is the square root of the arithmetic mean of the squares of \nthe values. If all the arguments are null or missing values, then the result is \na null or missing value. Otherwise, the result is the root mean square of the \nnon-null or non-missing values."},"ROUND":{"help":"Rounds the first argument to the nearest multiple of the second argument, or to \nthe nearest integer when the second argument is omitted. \n\nReturn value data type: DOUBLE  \n\nSyntax: ROUND (expression [, rounding-unit ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value, to be rounded.\n\n  Valid data types: DOUBLE \n  \nrounding-unit \n  specifies a positive numeric expression that specifies the rounding unit.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe ROUND function rounds the first argument to a value that is very close to a multiple \nof the second argument. The results might not be an exact multiple of the second argument."},"ROUNDE":{"help":"Rounds the first argument to the nearest multiple of the second argument, and returns \nan even multiple when the first argument is halfway between the two nearest multiples. \n\nReturn value data type: DOUBLE  \n\nSyntax: ROUNDE (expression [, rounding-unit] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value and that is to be rounded. \n  Valid data types: DOUBLE \n\nrounding-unit \n  is a positive, numeric expression that specifies the rounding unit. \n  Default: 1 \n  Valid data types: DOUBLE \n  \nDetails: \nThe ROUNDE function rounds the first argument to the nearest multiple of the second argument. \n \nComparisons: \nThe ROUNDE function is the same as the ROUND function except that when the first argument \nis halfway between the two nearest multiples of the second argument, ROUNDE returns an even\nmultiple. ROUND returns the multiple with the larger absolute value."},"ROUNDZ":{"help":"Rounds the first argument to the nearest multiple of the second argument, using \nzero fuzzing. \n\nReturn value data type: DOUBLE  \n\nSyntax: ROUNDZ (expression [, rounding-unit ] ) \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n  Valid data types: DOUBLE \n\nrounding-unit \n  specifies any valid expression that evaluates to a numeric expression and that specifies \n  the rounding unit. \n\n  Requirements: Only positive values are valid. \n  Valid data types: DOUBLE \n  Default value: 1 \n \nDetails: \nThe ROUNDZ function rounds the first argument to the nearest multiple of the second argument."},"SCAN":{"help":"Returns the nth word from a character expression. \n    \nReturn value data type: NCHAR  \nSyntax: SCAN( expression, n [, delimiters ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. \n  Valid data types: NCHAR \nn \n  is a non-zero numeric expression that specifies the number of the word in the character \n  expression that you want SCAN to select. The following rules apply: \n\n    o If n is positive, SCAN counts words from left to right in the character string. \n    o If n is negative, SCAN counts words from right to left in the character string. \n    o If n is greater than the number of words in expression, SCAN returns a blank value.\n\ndelimiters \n  specifies any valid expression that evaluates to a character string and that SCAN \n  uses as word separators in the expression.\n\n  Requirement: If delimiter is a constant, enclose delimiter in single quotation marks. \n  ASCII default delimiters: blank . , ( + & ! $ * ) ; ^ -- / % | \n  In environments without the ^ character, SCAN uses the ~ character instead.\n \n  EBCDIC default delimiters: blank . < ( + | & ! $ * ) ; ¬ -- / , % ¢ \n  Valid data types: NCHAR \n \nDetails:\nLeading delimiters before the first word in the expression do not effect SCAN. If there \nare two or more contiguous delimiters, SCAN treats them as one."},"SECOND":{"help":"Returns the second from a SAS time or datetime value. \n    \nReturn value data type: DOUBLE  \n\nSyntax: SECOND(time | datetime)  \n\nArguments: \ntime \n  specifies any valid expression that represents a SAS time value.\n  Valid data types: DOUBLE \n\ndatetime \n  specifies any valid expression that represents a SAS datetime value. \n  Valid data types: DOUBLE \n \nDetails: \nThe SECOND function produces a numeric value that represents a specific second of \nthe minute. The result can be any number that is >= 0 and < 60."},"SIGN":{"help":"Returns a number that indicates the sign of a numeric value expression. \n    \nReturn value data type: DOUBLE  \n\nSyntax: SIGN (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe SIGN function returns the following values: \n\n  -1 if expression < 0 \n \n  0 if expression = 0 \n \n  1  if expression > 0."},"SIN":{"help":"Returns the trigonometric sine. \n    \nReturn value data type: DOUBLE  \n\nSyntax: SIN (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE"},"SINH":{"help":"Returns the hyperbolic sine. \n    \nReturn value data type: DOUBLE  \n\nSyntax: SINH (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe SINH function returns the hyperbolic sine of the argument, which is given by\n\n(ϵ^argument - ϵ^-argument)/2"},"SKEWNESS":{"help":"Returns the skewness. \n    \nReturn value data type: DOUBLE  \n\nSyntax: SKEWNESS(expression-1, expression-2, expression-3 [, ...expression-n ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n\n  Requirements: At least three non-null or non-missing arguments are required. \n  Otherwise, the function returns a null or missing value. \n  Valid data types: DOUBLE \n \nDetails: \nIf all non-null or non-missing arguments have equal values, the skewness is mathematically \nundefined and the SKEWNESS function returns a null or missing value."},"SLEEP":{"help":"For a specified period of time, suspends the execution of a program that invokes \nthis function. \n\nReturn value data type: DOUBLE  \n\nSyntax: SLEEP(number-of-time-units [, time- unit ] )  \n\nArguments: \nnumber-of-time-units \n  specifies any valid expression that evaluates to a numeric value and that specifies the \n  number of units of time for which you want to suspend execution of a program.\n\n  Range: n ≥ 0 \n\ntime-unit \n  specifies the unit of time, as a power of 10, which is applied to number-of-time-units. \n  For example, 1 corresponds to a second, and .001 to a millisecond. \n\n  Default: 1 in a Windows PC environment, .001 in other environments \n \nDetails: \nThe SLEEP function suspends the execution of a program that invokes this function for \na period of time that you specify. The maximum sleep period for the SLEEP function is \n46 days."},"SMALLEST":{"help":"Returns the kth smallest non-null or non-missing value. \n    \nReturn value data type: DOUBLE  \n\nSyntax: SMALLEST (k, expression [, ...expression ] )  \n\nArguments: \nk \n  specifies any valid expression that evaluates to a numeric value to return. \n  Valid data types: DOUBLE \n\nexpression \n  specifies any valid expression that evaluates to a numeric value to be processed. \n  Valid data types: DOUBLE \n \nDetails: \nIf k is null or missing, less than zero, or greater than the number of values, the result \nis a null or missing value. \n \nComparisons: \nThe SMALLEST function differs from the ORDINAL function in that SMALLEST ignores null \nand missing values, but ORDINAL counts null and missing values."},"SQRT":{"help":"Returns the square root of a value. \n    \nReturn value data type: DOUBLE  \n\nSyntax: SQRT (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a nonnegative numeric value.\n\n  Valid data types: DOUBLE"},"STD":{"help":"Returns the standard deviation. \n    \nReturn value data type: DOUBLE  \n\nSyntax: STD(expression-1, expression-2 [, ...expression-n ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n\n  Requirements: At least two non-null or non-missing arguments are required. Otherwise, \n  the function returns a null or missing value. \n  Valid data types: DOUBLE"},"STDERR":{"help":"Returns the standard error of the mean. \n    \nReturn value data type: DOUBLE  \n\nSyntax: STDERR(expression-1, expression-2 [, ...expression-n ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Requirements: At least two non-null or non-missing arguments are required. Otherwise, \n  the function returns a null or missing value.  \n  Valid data types: DOUBLE"},"STRIP":{"help":"Returns a character string with all leading and trailing blanks removed. \n    \nReturn value data type: NCHAR  \n\nSyntax: STRIP(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. \n  Valid data types: NCHAR \n \nDetails: \nThe STRIP function returns the argument with all leading and trailing blanks removed. \nIf the argument is blank, STRIP returns a string with a length of zero. \n\nIf the value that is trimmed is shorter than the length of the receiving variable, \nSAS pads the value with new trailing blanks.\n\nNote: The STRIP function is useful for concatenation because the concatenation \noperator does not remove trailing blanks."},"SUBSTR":{"help":"Returns a substring, allowing a result with a length of zero. \n    \nReturn value data type: VARCHAR, NVARCHAR  \nSyntax: SUBSTR(character-expression, position-expression [, length-expression ] )  \n\nArguments: \ncharacter-expression \n  specifies any valid expression that evaluates to a character string. \n  Valid data types: CHAR, NCHAR \n\nposition-expression \n  specifies any valid expression that evaluates to an integer and that specifies the \n  position of the first character in the substring. \n  Valid data types: INTEGER \n\nlength-expression \n  specifies any valid expression that evaluates to an integer and that specifies the length \n  of the substring. If you do not specify length-expression, the SUBSTR function returns  \n  the substring that extends from the position that you specify to the end of the string. \n  Valid data types: INTEGER \n \nDetails: \nThe following information applies to the SUBSTR function: \n\n  o The SUBSTR function returns a string with a length of zero if either position-expression or  \n    length-expression has a missing or null value, or if position-expression is a non-positive value. \n  o If the value for length-expression is non-positive, the SUBSTR function ignores length-expression. \n  o If the length that you specify extends beyond the end of the string, the result is truncated \n    at the end, so that the last character of the result is the last character of the string."},"SUM":{"help":"Returns the sum of the non-null or non-missing arguments. \n    \nReturn value data type: BIGINT if all argument data types are BIGINT, otherwise, DOUBLE  \n\nSyntax: SUM(expression-1, expression-2 [, ...expression-n ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Requirements: At least two arguments are required. \n  Valid data types: DOUBLE, BIGINT \n \nDetails: \nNull and missing values are ignored and not included in the computation. If all of the \narguments have missing values, the result is a missing value. If all the arguments have \na null value, the result is a null value."},"TAN":{"help":"Returns the tangent. \n    \nReturn value data type: DOUBLE  \n\nSyntax: TAN (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value in radians.\n\n  Restriction: expression cannot be an odd multiple of π/2 \n  Valid data types: DOUBLE"},"TANH":{"help":"Returns the hyperbolic tangent. \n    \nReturn value data type: DOUBLE  \n\nSyntax: TANH (expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Restriction: expression cannot be an odd multiple of π/2 \n  Valid data types: DOUBLE \n \nDetails: \nThe TANH function returns the hyperbolic tangent of the argument, which is given by\n\n(ϵ^argument - ϵ^-argument)/(ϵ^argument + ϵ^-argument)"},"TIME":{"help":"Returns the current time of day as a numeric SAS time value. \n    \nReturn value data type: DOUBLE \n\nSyntax: TIME()  \n\nDetails: \nThe TIME function does not take any arguments. It produces the current time in the form \nof a SAS time value."},"TIMEPART":{"help":"Extracts a time value from a SAS datetime value. \n    \nReturn value data type: DOUBLE  \n\nSyntax: TIMEPART(datetime)  \n\nArguments: \ndatetime \n  specifies any valid expression that represents a SAS datetime value.\n\n  Valid data types: DOUBLE"},"TRANSLATE":{"help":"Replaces specific characters in a character expression. \n    \nReturn value data type: NCHAR  \nSyntax: TRANSLATE(expression, to-characters, from-characters)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. expression \n  contains the original character value. \n  Valid data types: CHAR \n\nto-characters \n  specifies the characters that you want TRANSLATE to use as substitutes. \n  Valid data types: NCHAR \n\nfrom-characters \n  specifies the characters that you want TRANSLATE to replace. \n  Valid data types: NCHAR \n \nDetails: \nValues of to-characters and from-characters correspond on a character-by-character basis; \nTRANSLATE changes the first character in from-characters to the first character in to-characters, \nand so on. If to-characters has fewer characters than from-characters, TRANSLATE changes the \nextra from-characters to blanks. If to-characters has more characters than \nfrom-characters, TRANSLATE ignores the extra to-characters."},"TRANWRD":{"help":"Replaces or removes all occurrences of a word in a character string. \n    \nReturn value data type: NCHAR  \n\nSyntax: TRANWRD(source-expression, target-expression, replacement-expression)  \n\nArguments:\nsource-expression \n  specifies any valid expression that evaluates to a character string, whose characters \n  you want to replace. \n  Valid data types: NCHAR \n\ntarget-expression \n  specifies any valid expression that evaluates to a character string and that is searched \n  for in source-expression. \n  Valid data types: NCHAR \n  Requirement: The length of the target-expression must be greater than zero. \n\nreplacement-expression \n  specifies any valid expression that evaluates to a character string and that replaces \n  target-expression. \n  Valid data types: NCHAR \n \nDetails: \nThe TRANWRD function replaces or removes all occurrences of a given word (or a pattern of \ncharacters) within a character string. The TRANWRD function does not remove trailing blanks \nin the target-expression string and the replacement-expression string."},"TRIGAMMA":{"help":"Returns the value of the trigamma function. \n    \nReturn value data type: DOUBLE  \n\nSyntax: TRIGAMMA( expression )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n\n  Restriction: Nonpositive integers are invalid. \n  Valid data types: DOUBLE \n  \nDetails: \nThe TRIGAMMA function returns the derivative of the DIGAMMA function. For expression > 0, \nthe TRIGAMMA function is the second derivative of the LGAMMA function."},"TRIM":{"help":"Removes trailing blanks from a character expression. \n    \nReturn value data type: VARCHAR, NVARCHAR  \n\nSyntax: TRIM ( expression )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string.\n  Valid data types: CHAR, NCHAR \n \nDetails:\nThe TRIM function removes trailing blanks from expression and returns the trimmed value \nas a result. If the resulting string is blank, TRIM returns a zero length string. TRIM \nis useful for concatenating because concatenation does not remove trailing blanks."},"TRIMN":{"help":"Removes trailing blanks from a character expression. \n    \nReturn value data type: VARCHAR, NVARCHAR  \n\nSyntax: TRIM ( expression )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string.\n  Valid data types: CHAR, NCHAR \n \nDetails:\nThe TRIM function removes trailing blanks from expression and returns the trimmed value \nas a result. If the resulting string is blank, TRIM returns a zero length string. TRIM \nis useful for concatenating because concatenation does not remove trailing blanks."},"TRUNC":{"help":"Truncates a numeric value to a specified length. \n    \nReturn value data type: DOUBLE \nSyntax: TRUNC(expression, length-expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. \n  Valid data types: DOUBLE \n\nlength-expression \n  specifies any valid expression that evaluates to a numeric value. \n  Range: 3 - 8 \n  Valid data types: DOUBLE \n \nDetails: \nThe TRUNC function truncates a full-length numeric expression (stored as a DOUBLE) \nto a smaller number of bytes, as specified in length-expression and pads the truncated \nbytes with 0s. The truncation and subsequent expansion duplicate the effect of storing \nnumbers in less than full length and then reading them."},"UPCASE":{"help":"Converts all letters in an argument to uppercase. \n    \nReturn value data type: VARCHAR, NVARCHAR  \n\nSyntax: UPCASE(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a character string. \n  Valid data types: CHAR, NCHAR \n \nDetails: \nThe UPCASE function copies a character expression, converts all lowercase letters to \nuppercase letters, and returns the altered value as a result. \n \nComparisons: \nThe LOWCASE function converts all letters in an argument to lowercase letters. The \nUPCASE function converts all letters in an argument to uppercase letters."},"USS":{"help":"Returns the uncorrected sum of squares. \n    \nReturn value data type: DOUBLE  \n\nSyntax: USS(expression [, ...expression ] )  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value.\n\n  Requirement: At least one non-null or non-missing argument is required. Otherwise, \n  the function returns a null or missing value.  \n  Valid data types: DOUBLE"},"VAR":{"help":"Returns the variance. \n    \nReturn value data type: DOUBLE  \n\nSyntax: VAR(expression-1, expression-2 [ ,...expression-n])  \n\nArguments: \nexpression \n  specifies any valid expression that evaluates to a numeric value. The argument list \n  can consist of a variable list. \n\n  Requirements: At least two non-null or non-missing arguments are required. Otherwise, \n  the function returns a null or missing value.  \n  \n  Valid data types: DOUBLE"},"VERIFY":{"help":"Returns the position of the first character that is unique to an expression. \n    \nReturn value data type: DOUBLE  \nSyntax: VERIFY(target-expression, search-expression)  \n\nArguments: \ntarget-expression \n  specifies any valid expression that evaluates to a character string that is to be searched. \n\n  Requirements: Literal character strings must be enclosed in single quotation marks. \n  Valid data types: NCHAR \n\nsearch-expression \n  specifies any valid expression that evaluates to a character string.\n\n  Requirements: Literal character strings must be enclosed in single quotation marks. \n  Valid data types: NCHAR \n \nDetails: \nThe VERIFY function returns the position of the first character in target-expression that \nis not present in search-expression. If there are no characters in target-expression that \nare unique from those in search-expression, VERIFY returns a 0."},"WEEKDAY":{"help":"From a SAS date value, returns an integer that corresponds to the day of the week. \n    \nReturn value data type: DOUBLE \n\nSyntax: WEEKDAY(expression)  \n\nArguments: \nexpression \n  specifies any valid expression that represents a SAS date value.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe WEEKDAY function produces an integer that represents the day of the week, where 1 = Sunday, \n2 = Monday, ..., 7 = Saturday."},"WHICHC":{"help":"Returns the first position of a character string from a list of character strings. \n    \nReturn value data type:  DOUBLE  \nSyntax: WHICHC(search-expression, expression-list-item-1, expression-list-item-2 [, ...expression-list-item-n ] )  \n\nArguments: \nsearch-expression \n  specifies any valid expression that evaluates to a character string that is compared with \n  a list of character string expressions. \n\n  Requirements: Literal character strings must be enclosed in single quotation marks. \n  Valid data types: NCHAR \n  \nstring-expression-list-item \n  specifies any valid expression that evaluates to a character string and that is a member of a list of character string expressions. \n\n  Requirements: Literal character strings must be enclosed in single quotation marks. \n  At least two expressions are required in the list. \n  Valid data types: NCHAR \n \nDetails: \nThe WHICHC function searches the character expression list, from left to right, for the \nfirst expression that matches the search expression. If a match is found, WHICHC returns \nits position in the expression list. If none of the expressions match the search expression, \nWHICHC returns a value of 0."},"WHICHN":{"help":"Returns the first position of a number from a list of numbers. \n    \nReturn value data type: DOUBLE  \nSyntax: WHICHN(search-expression, expression-list-item-1, expression-list-item-2 \n  [, ...expression-list-item-n ] )  \n\nArguments: \nsearch-expression \n  specifies any valid expression that evaluates to a number and that is compared with \n  a list of numeric expressions. \n  Valid data types: DOUBLE \n\nexpression-list-item \n  specifies any valid expression that evaluates to a number and is part of a list. \n  Requirements: At least two expressions are required in the list. \n  Valid data types: DOUBLE \n \nDetails: \nThe WHICHN function searches the numeric expression list, from left to right, for the \nfirst expression that matches the search expression. If a match is found, WHICHN returns \nits position in the expression list. If none of the expressions match the search expression, \nWHICHN returns a value of 0. Arguments for the WHICHN functions can be any numeric data type."},"YEAR":{"help":"Returns the year from a SAS date value. \n    \nReturn value data type DOUBLE  \n\nSyntax: YEAR(date)  \n\nArguments: \ndate \n  specifies any valid expression that represents a SAS date value.\n\n  Valid data types: DOUBLE \n \nDetails: \nThe YEAR function produces a four-digit numeric value that represents the year."},"YYQ":{"help":"Returns a SAS date value from year and quarter year values. \n    \nReturn value data type: DOUBLE  \n\nSyntax: YYQ(year,quarter)  \n\nArguments: \nyear \n  specifies any valid expression that evaluates to a two-digit or four-digit integer \n  that represents the year. The YEARCUTOFF= system option defines the year value for \n  two-digit dates.\n\n  Valid data types: DOUBLE \n  \nquarter \n  specifies the quarter of the year (1, 2, 3, or 4). \n  Valid data types: DOUBLE \n \nDetails: \nThe YYQ function returns a SAS date value that corresponds to the first day of the \nspecified quarter. If either year or quarter is null or missing, or if the quarter \nvalue is not valid, the result is a null or missing value."},"PRXCHANGE":{"help":"Performs a pattern-matching replacement. \n    \nReturned data type: CHAR\n\nSyntax: PRXCHANGE(perl-regular-expression | regular-expression-id, times, source)\n\nArguments:\nperl-regular-expression\n  specifies a character constant, variable, or expression with a value that is a Perl regular expression.\n  Data type: CHAR\nregular-expression-id\n  specifies a numeric variable with a value that is a pattern identifier that is returned from the PRXPARSE function.\n  Restriction: If you use this argument, you must also use the PRXPARSE function.\n  Data type: INTEGER\ntimes\n  is a numeric constant, variable, or expression that specifies the number of times to search for a match and \n  replace a matching pattern.\n  Data type: INTEGER\n  Tip: If the value of times is –1, then matching patterns continue to be replaced until the end of source is reached. \nsource\n  specifies a character constant, variable, or expression that you want to search.\n  Data type: CHAR"},"PRXPAREN":{"help":"Returns the last bracket match for which there is a match in a pattern. \n    \nSyntax: PRXPAREN(regular-expression-id) \n\nArguments:\nregular-expression-id\n  specifies a numeric variable with a value that is an identification number that is returned by the PRXPARSE function."},"PRXPARSE":{"help":"Compiles a Perl regular expression (PRX) that can be used for pattern matching of a character value.\n\nReturned data type: INTEGER\n\nSyntax: regular-expression-id=PRXPARSE(perl-regular-expression)\n\nArguments:\nregular-expression-id\n  is a numeric pattern identifier that is returned by the PRXPARSE function.\n  Data type: INTEGER\nperl-regular-expression\n  specifies a character, constant, variable, or expression with a value that is a Perl regular expression.\n  Data type: CHAR"},"PRXPOSN":{"help":"Returns a character string that contains the value for a capture buffer.\n\nReturned data type: CHAR\n\nSyntax: PRXPOSN(regular-expression-id, capture-buffer, source)\n\nArguments:\nregular-expression-id\n  specifies a numeric variable with a value that is a pattern identifier that is returned by the PRXPARSE function.\n\n  Data type: INTEGER\ncapture-buffer\n  is a numeric constant, variable, or expression that identifies the capture buffer for which to retrieve a value:\n  •If the value of capture-buffer is zero, PRXPOSN returns the entire match.\n  •If the value of capture-buffer is between 1 and the number of open parentheses in the regular expression, then PRXPOSN returns the value for that capture buffer.\n  •If the value of capture-buffer is greater than the number of open parentheses, then PRXPOSN returns a missing value.\n  Data type: INTEGER \n  \nsource\n  specifies the text from which to extract capture buffers.\n  Data type: CHAR"},"KCOUNT":{"help":"Returns the number of double-byte characters in an expression. \n    \nSyntax: KCOUNT([']source['])\n\nArguments:\n'source'\n  specifies any valid expression that evaluates to a character string.\n  Data type: NCHAR\n  Tip: Enclose a literal string of characters in quotation marks."},"KSTRCAT":{"help":"Concatenates two or more character expressions.\n\nReturned data type: NCHAR\n\nSyntax: KSTRCAT(expression-1, expression-2[, … expression-n] ) \n\nArguments: \nexpression\n  specifies any single-byte or double-byte character expression.\n\n  Requirement: At least two expressions are required.\n  Data type: NCHAR"},"KSTRIP":{"help":"Returns a character string with all leading and trailing blanks removed.\n\nReturned data type: NCHAR\nSyntax: KSTRIP([']string['])\n\nArguments:\n[']string[']\n  specifies any valid expression that evaluates to a character string.\n  Data type: NCHAR\n  Tip: Enclose a literal string of characters in quotation marks."},"KUDPATE":{"help":"Inserts, deletes, and replaces character value contents.\n\nReturned data type: NCHAR \n\nSyntax: \nKUPDATE([']expression['], position, n [, [']characters-to-replace[']] ) \nKUPDATE([']expression['], position [, n], [']characters-to-replace['])\n\nArguments:\n[']expression[']\n  specifies any valid expression that evaluates to a character string.\n  Data type: NCHAR\n  Tip: Enclose a literal string of characters in quotation marks.\n\nposition\n  specifies a numeric expression that is the beginning character position.\n  Data type: INTEGER\nn\n  specifies a numeric expression that is the length of the substring to be replaced.\n  Restrictions: n cannot be larger than the length of the expression that remains in expression after \n  position.n is optional, but you cannot omit both n and characters-to-replace from the function.\n  Data type: INTEGER\n  Tip: If you omit n, SAS uses all of the characters in characters-to-replace to replace the values of expression.\n\n[']characters-to-replace[']\n  specifies an expression which evaluates to a character string that replaces the contents of expression.\n  Restriction: characters-to-replace is optional, but you cannot omit both characters-to-replace and n from the function.\n  Data type: NCHAR\n  Tip: Enclose a literal string of characters in quotation marks."},"KUPDATES":{"help":"Inserts, deletes, and replaces the contents of the character value according to the byte position of the \ncharacter value in the argument. \n\nReturned data type: NCHAR\nSyntax:\nKUPDATES([']expression['], position, n [, [']characters-to-replace[']] ) \nKUPDATES([']expression['], position [, n], [']characters-to-replace['])\n\nArguments:\n[']expression[']\n  specifies any valid expression that evaluates to a character string.\n  Data type: NCHAR\n  Tip: Enclose a literal string of characters in quotation marks. \nposition\n  specifies a numeric expression that is the beginning character position in bytes.\n  Data type: INTEGER\nn\n  specifies the length of the substring to be replaced in bytes.\n  Restrictions: n cannot be larger than the length (in bytes) of the expression that remains in expression after position.\n  n is optional, but you cannot omit both n and characters-to-replace from the function.\n  Data type: INTEGER\n  Tip: If you omit n, SAS uses all of the characters in characters-to-replace to replace the values of expression.\n\n[']characters-to-replace[']\n  specifies an expression which evaluates to a character string that replaces the contents of expression.\n  Restriction: characters-to-replace is optional, but you cannot omit both characters-to-replace and n from the function.\n  Data type: NCHAR\n  Tip: Enclose a literal string of characters in quotation marks."},"UUIDGEN":{"help":"Returns the short form of a Universal Unique Identifier (UUID).\n\nReturned data type: CHAR \n\nSyntax: UUIDGEN( )\n\nWithout Arguments\n  The UUIDGEN function has no arguments."}}}

package/data/ds2Functions.index.json

@@ -0,0 +1 @@
+{"group":"ds2Functions","label":"DS2 function","kind":1,"count":136,"entries":[["ABS","SAS_FUNCTION"],["ARCOS","SAS_FUNCTION"],["ARSIN","SAS_FUNCTION"],["ARTAN","SAS_FUNCTION"],["ATAN","SAS_FUNCTION"],["ATAN2","SAS_FUNCTION"],["BAND","SAS_FUNCTION"],["BLSHIFT","SAS_FUNCTION"],["BNOT","SAS_FUNCTION"],["BOR","SAS_FUNCTION"],["BRSHIFT","SAS_FUNCTION"],["BXOR","SAS_FUNCTION"],["BYTE","SAS_FUNCTION"],["CEIL","SAS_FUNCTION"],["CEILZ","SAS_FUNCTION"],["COALESCE","SAS_FUNCTION"],["COALESCEC","SAS_FUNCTION"],["COLLATE","SAS_FUNCTION"],["COMPBL","SAS_FUNCTION"],["COMPRESS","SAS_FUNCTION"],["COS","SAS_FUNCTION"],["COSH","SAS_FUNCTION"],["CSS","SAS_FUNCTION"],["CV","SAS_FUNCTION"],["DATE","SAS_FUNCTION"],["DATEJUL","SAS_FUNCTION"],["DATEPART","SAS_FUNCTION"],["DATETIME","SAS_FUNCTION"],["DAY","SAS_FUNCTION"],["DEQUOTE","SAS_FUNCTION"],["DHMS","SAS_FUNCTION"],["DIGAMMA","SAS_FUNCTION"],["EXP","SAS_FUNCTION"],["FLOOR","SAS_FUNCTION"],["FLOORZ","SAS_FUNCTION"],["FUZZ","SAS_FUNCTION"],["GAMMA","SAS_FUNCTION"],["GCD","SAS_FUNCTION"],["GEOMEAN","SAS_FUNCTION"],["GEOMEANZ","SAS_FUNCTION"],["HARMEAN","SAS_FUNCTION"],["HARMEANZ","SAS_FUNCTION"],["HMS","SAS_FUNCTION"],["HOUR","SAS_FUNCTION"],["INDEX","SAS_FUNCTION"],["INDEXC","SAS_FUNCTION"],["INDEXW","SAS_FUNCTION"],["INT","SAS_FUNCTION"],["INTZ","SAS_FUNCTION"],["IQR","SAS_FUNCTION"],["JULDATE","SAS_FUNCTION"],["JULDATE7","SAS_FUNCTION"],["KCOUNT","SAS_FUNCTION"],["KSTRCAT","SAS_FUNCTION"],["KSTRIP","SAS_FUNCTION"],["KUDPATE","SAS_FUNCTION"],["KUPDATES","SAS_FUNCTION"],["KURTOSIS","SAS_FUNCTION"],["LARGEST","SAS_FUNCTION"],["LCM","SAS_FUNCTION"],["LEFT","SAS_FUNCTION"],["LENGTH","SAS_FUNCTION"],["LENGTHC","SAS_FUNCTION"],["LENGTHM","SAS_FUNCTION"],["LENGTHN","SAS_FUNCTION"],["LGAMMA","SAS_FUNCTION"],["LOG","SAS_FUNCTION"],["LOG10","SAS_FUNCTION"],["LOG2","SAS_FUNCTION"],["LOWCASE","SAS_FUNCTION"],["MAX","SAS_FUNCTION"],["MDY","SAS_FUNCTION"],["MEAN","SAS_FUNCTION"],["MIN","SAS_FUNCTION"],["MINUTE","SAS_FUNCTION"],["MISSING","SAS_FUNCTION"],["MOD","SAS_FUNCTION"],["MODZ","SAS_FUNCTION"],["MONTH","SAS_FUNCTION"],["N","SAS_FUNCTION"],["NMISS","SAS_FUNCTION"],["NULL","SAS_FUNCTION"],["ORDINAL","SAS_FUNCTION"],["PCTL","SAS_FUNCTION"],["POWER","SAS_FUNCTION"],["PRXCHANGE","SAS_FUNCTION"],["PRXPAREN","SAS_FUNCTION"],["PRXPARSE","SAS_FUNCTION"],["PRXPOSN","SAS_FUNCTION"],["PUT","SAS_FUNCTION"],["QTR","SAS_FUNCTION"],["QUOTE","SAS_FUNCTION"],["RANGE","SAS_FUNCTION"],["RANK","SAS_FUNCTION"],["REPEAT","SAS_FUNCTION"],["REVERSE","SAS_FUNCTION"],["RIGHT","SAS_FUNCTION"],["RMS","SAS_FUNCTION"],["ROUND","SAS_FUNCTION"],["ROUNDE","SAS_FUNCTION"],["ROUNDZ","SAS_FUNCTION"],["SCAN","SAS_FUNCTION"],["SECOND","SAS_FUNCTION"],["SIGN","SAS_FUNCTION"],["SIN","SAS_FUNCTION"],["SINH","SAS_FUNCTION"],["SKEWNESS","SAS_FUNCTION"],["SLEEP","SAS_FUNCTION"],["SMALLEST","SAS_FUNCTION"],["SQRT","SAS_FUNCTION"],["STD","SAS_FUNCTION"],["STDERR","SAS_FUNCTION"],["STRIP","SAS_FUNCTION"],["SUBSTR","SAS_FUNCTION"],["SUM","SAS_FUNCTION"],["TAN","SAS_FUNCTION"],["TANH","SAS_FUNCTION"],["TIME","SAS_FUNCTION"],["TIMEPART","SAS_FUNCTION"],["TODAY","SAS_FUNCTION"],["TRANSLATE","SAS_FUNCTION"],["TRANWRD","SAS_FUNCTION"],["TRIGAMMA","SAS_FUNCTION"],["TRIM","SAS_FUNCTION"],["TRIMN","SAS_FUNCTION"],["TRUNC","SAS_FUNCTION"],["UPCASE","SAS_FUNCTION"],["USS","SAS_FUNCTION"],["UUIDGEN","SAS_FUNCTION"],["VAR","SAS_FUNCTION"],["VERIFY","SAS_FUNCTION"],["WEEKDAY","SAS_FUNCTION"],["WHICHC","SAS_FUNCTION"],["WHICHN","SAS_FUNCTION"],["YEAR","SAS_FUNCTION"],["YYQ","SAS_FUNCTION"]]}

package/data/ds2Keywords.docs.json

@@ -0,0 +1 @@
+{"group":"ds2Keywords","count":21,"entries":{"ALTER":{"help":"Syntax: ALTER=alter-password \n    \nSyntax Description:\nalter-password \n  must be a valid SAS name.\n \nDetails \nThe ALTER= option applies only to a SAS data set. You can use this option to assign \na password or to access a read-protected, write-protected, or alter-protected file. \nWhen you replace a data set that is protected with an ALTER password, the new data \nset inherits the ALTER password. \n\nThe password is blotted out when the code is written in the SAS log. For example: \n\n  set a(alter=XXXXXXX);\n\nNote: A SAS password does not control access to a SAS file beyond the SAS system. \nYou should use the operating system-supplied utilities and file-system security \ncontrols in order to control access to SAS files outside of SAS."},"BUFNO":{"help":"Specifies the number of buffers to be allocated for processing a SAS data set. \n    \nSyntax: BUFNO= n | nK | hexX | MIN | MAX  \n\nSyntax Description:\n\nn | nK \n  specifies the number of buffers in multiples of 1 (bytes); 1,024 (kilobytes). For example, \n  a value of 8 specifies 8 buffers, and a value of 1k specifies 1024 buffers.\n\nhex \n  specifies the number of buffers as a hexadecimal value. You must specify the value beginning \n  with a number (0-9), followed by an X. For example, the value 2dx sets the number of buffers \n  to 45 buffers.\n\nMIN \n  sets the minimum number of buffers to 0, which causes SAS to use the minimum optimal value \n  for the operating environment. This is the default.\n\nMAX \n  sets the number of buffers to the maximum possible number in your operating environment, \n  up to the largest four-byte, signed integer, which is 2³¹-1, or approximately 2 billion.","values":{"@Value1":"n","@Value2":"nK","@Value3":"hexX","@Value4":"MIN","@Value5":"MAX"},"tooltips":{"@ToolTip1":"Specifies the number of buffers in multiples of 1 (bytes).  Replace n with an integer value.","@ToolTip2":"Specifies the number of buffers in multiples of 1,024 (kilobytes).  Replace n with an integer value.","@ToolTip3":"Specifies the number of buffers as a hexadecimal value.  Replace hex with an actual hexadecimal value.","@ToolTip4":"Sets the minimum number of buffers to 0, which causes SAS to use the minimum optimal value  for the operating environment. This is the default.","@ToolTip5":"Sets the number of buffers to the maximum possible number in your operating environment,  up to the largest four-byte, signed integer, which is 2³¹-1, or approximately 2 billion."}},"BUFSIZE":{"help":"Specifies the size of a permanent buffer page for an output SAS data set. \n    \nSyntax: BUFSIZE= n | nK | nM | nG | hexX | MAX  \n\nSyntax Description:\n\nn | nK | nM | nG \nspecifies the page size in multiples of 1 (bytes); 1,024 (kilobytes); 1,048,576 (megabytes); \nor 1,073,741,824 (gigabytes). For example, a value of 8 specifies a page size of 8 bytes, and \na value of 4k specifies a page size of 4096 bytes. \n\nhexX \nspecifies the page size as a hexadecimal value. You must specify the value beginning with a \nnumber (0-9), followed by an X. For example, the value 2dx sets the page size to 45 bytes.\n\nMAX \nsets the page size to the maximum possible number in your operating environment, up to the \nlargest four-byte, signed integer, which is 231-1, or approximately 2 billion bytes.","values":{"@Value1":"n","@Value2":"nK","@Value3":"nM","@Value4":"nG","@Value5":"hexX","@Value6":"MAX"},"tooltips":{"@ToolTip1":"Specifies the page size in multiples of 1 (bytes).  Replace n with an integer value.","@ToolTip2":"Specifies the page size in multiples of 1,024 (kilobytes).  Replace n with an integer value.","@ToolTip3":"Specifies the page size in multiples of 1,048,576 (megabytes).  Replace n with an integer value.","@ToolTip4":"Specifies the page size in multiples of 1,073,741,824 (gigabytes).  Replace n with an integer value.","@ToolTip5":"Specifies the page size as a hexadecimal value.  Replace hex with an actual hexadecimal value.","@ToolTip6":"Sets the page size to the maximum possible number in your operating environment,  up to the largest four-byte, signed integer, which is 2³¹-1, or approximately 2 billion bytes."}},"BULKLOAD":{"help":"Loads rows of data as one unit. Default value: NO  \n    \nSyntax: BULKLOAD=YES | NO  \n\nSyntax Description:\n\nYES \ncalls a DBMS-specific bulk load facility in order to insert or append rows to a DBMS table.\n\nNO \nuses the dynamic SAS/ACCESS engine to insert or append data to a DBMS table.","values":{"@Value1":"YES","@Value2":"NO"},"tooltips":{"@ToolTip1":"Calls a DBMS-specific bulk load facility in order to insert or append rows to a DBMS table.","@ToolTip2":"Uses the dynamic SAS/ACCESS engine to insert or append data to a DBMS table."}},"COMPRESS":{"help":"\n    \nSyntax: COMPRESS=NO | YES | CHAR | BINARY  \n\nSyntax Description:\nNO \nspecifies that the observations in a newly created SAS data set are uncompressed (fixed-length records).\n\nYES | CHAR \nspecifies that the observations in a newly created SAS data set are compressed (variable-length records) \nby SAS using RLE (Run Length Encoding). RLE compresses observations by reducing repeated consecutive \ncharacters (including blanks) to two-byte or three-byte representations. \n\n  Alias: ON \n  Tip: Use this compression algorithm for character data. \n  Note:   COMPRESS=CHAR is accepted by Version 7 and later versions.  \n\nBINARY \n  specifies that the observations in a newly created SAS data set are compressed (variable-length records) \n  by SAS using RDC (Ross Data Compression). RDC combines run-length encoding and sliding-window compression \n  to compress the file.\n\n  Tip: This method is highly effective for compressing medium to large (several hundred bytes or larger) \n  blocks of binary data (numeric variables). Because the compression function operates on a single record \n  at a time, the record length needs to be several hundred bytes or larger for effective compression.","values":{"@Value1":"NO","@Value2":"YES|ON","@Value3":"CHAR","@Value4":"BINARY"},"tooltips":{"@ToolTip1":"Specifies that the observations in a newly created SAS data set are uncompressed  (fixed-length records).","@ToolTip2":"Specifies that the observations in a newly created SAS data set are compressed  (variable-length records) by SAS using RLE (Run Length Encoding). RLE compresses  observations by reducing repeated consecutive characters (including blanks) to  two-byte or three-byte representations.","@ToolTip3":"Specifies that the observations in a newly created SAS data set are compressed  (variable-length records) by SAS using RLE (Run Length Encoding). RLE compresses  observations by reducing repeated consecutive characters (including blanks) to  two-byte or three-byte representations.   COMPRESS=CHAR is accepted by Version 7 and later versions.","@ToolTip4":"Specifies that the observations in a newly created SAS data set are compressed  (variable-length records) by SAS using RDC (Ross Data Compression). RDC combines  run-length encoding and sliding-window compression to compress the file."}},"DBCREATE_TABLE_OPTS":{"help":"Syntax: DBCREATE_TABLE_OPTS= 'DBMS-option(s)' \n\nSpecifies DBMS-specific options to be added to the DATA statement.\n\nArguments:\nDBMS-option(s)\n  specifies one or more valid DBMS-specific options. If more than one option is specified, \n  the options should be separated in the same way as options are separated in the DBMS."},"DBKEY":{"help":"Specifies a key column to optimize DBMS retrieval. Can improve performance when you \nare processing a join that involves a large DBMS table and a small SAS data set \nor DBMS table.\n    \nSyntax: DBKEY=([ ' ] column [ ' ] [... [ ' ] column [ ' ] ])  \n\nSyntax Description: \n\ncolumn \n  used by SAS to build an internal WHERE clause to search for matches in the DBMS table \n  based on the key column. For example:\n\n    select * from sas.a, dbms.b(dbkey=x) where a.x=b.x;\n    \nIn this example, DBKEY= specifies column x , which matches the key column designated in \nthe WHERE clause. However, if the DBKEY= column does NOT match the key column in the \nWHERE clause, then DBKEY= is not used."},"DBNULL":{"help":"Indicates whether NULL is a valid value for the specified columns when a table is created. \n    \nSyntax: DBNULL={ _ALL=YES | NO } | ( [column=YES | NO [ ... column=YES | NO ] ] )  \n\nSyntax Description: \n_ALL_ \n  specifies that the YES or NO applies to all columns in the table. (This is valid in \n  the interfaces to Informix, Oracle, Sybase, and Teradata only.)\n\nYES \n  specifies that the NULL value is valid for the specified columns in the DBMS table.\n\nNO \n  specifies that the NULL value is not valid for the specified columns in the DBMS table.\n\ncolumn \n  specifies the name of a column. \n\nDetails: \nThis option is valid only for creating DBMS tables. If you specify more than one column name, \nthe names must be separated with spaces.\n\nThe DBNULL= option processes values from left to right, so if you specify a column name twice, \nor if you use the _ALL_ value, the last value overrides the first value that is specified for \nthe column.","subOptions":"_ALL_"},"DROP":{"help":"For an input table, excludes the specified columns from processing; for an output table, excludes the specified columns from being written to the table.\n    \nSyntax: DROP= ( column-list );  \n\nArguments: \ncolumn-list \n  specifies the names of the columns to omit from the output table.\n\n  Restriction: Numbered range lists in the format col1-col5 and name prefix lists in the format \n  col: are not supported. \n \nDetails: \nThe DROP= table option specifies that all columns in the column-list should not be included \nin the creation of output rows. Normally, all columns in the program data vector are included \nin the output rows. If the drop attribute is specified, all columns not included in the drop \nstatement will be used to create columns in the output rows.\n\nIf the DROP= table option is associated with an input table, the columns are not available \nfor processing during program execution."},"ENCRYPT":{"help":"Specifies whether to encrypt an output SAS data set. \n    \nSyntax: ENCRYPT=YES | NO  \n\nSyntax Description:\nYES \n  encrypts the file. The encryption method uses passwords. At a minimum, you must specify \n  the READ= or the PW= table option at the same time that you specify ENCRYPT=YES. Because \n  the encryption method uses passwords, you cannot change any password on an encrypted data \n  set without re-creating the data set.\n\nNO \n  does not encrypt the file.\n\nCAUTION:\nRecord all passwords. \nIf you forget the password, you cannot reset it without assistance from SAS. The process \nis time-consuming and resource-intensive.","values":{"@Value1":"YES","@Value2":"NO"},"tooltips":{"@ToolTip1":"Encrypts the file. The encryption method uses passwords. At a minimum, you must specify  the READ= or the PW= table option at the same time that you specify ENCRYPT=YES. Because  the encryption method uses passwords, you cannot change any password on an encrypted data  set without re-creating the data set.","@ToolTip2":"Does not encrypt the file."}},"ENCRYPTKEY":{"help":"Syntax: ENCRYPTKEY=[\" | ']key-value[\" | '] \n\nSpecifies a key value for AES encryption.\n\nArguments:\nkey-value\n  assigns an encrypt key value. The key value can be up to 64-bytes long. You are able to create \n  an ENCRYPTKEY= key value with or without quotation marks using the following rules:\n  \n  no quotation marks\n    •alphanumeric characters and underscores only\n    •up to 64-bytes\n    •uppercase and lowercase letters\n    •must start with a letter\n    •no blank spaces\n    •is not case-sensitive\n\n  single quotation marks\n    •alphanumeric, special, and DBCS characters\n    •up to 64-bytes\n    •uppercase and lowercase letters\n    •blank spaces, but not all blanks\n    •is case-sensitive\n    \n  double quotation marks\n    •alphanumeric, special, and DBCS characters\n    •up to 64 bytes\n    •uppercase and lowercase letters\n    •enables macro resolution\n    •blank spaces, but not all blanks\n    •is case-sensitive"},"IN":{"help":"Syntax: IN=variable \n    \nArguments:\nvariable\n  names the new variable whose value indicates whether that input table contributed data to the \n  current row. Within a DS2 program, the value of the variable is 1 if the table contributed to \n  the current row, and 0 otherwise.\n\nInteraction:\n  If the variable is not explicitly declared, it is automatically declared in the local scope \n  of the SET or DATA statement as INTEGER.\nData type: BIGINT, INTEGER, SMALLINT, TINYINT"},"KEEP":{"help":"For an input table, specifies the columns to process; for an output table, specifies \nthe columns to write to the table. \n    \nSyntax: KEEP=( column-list );  \n\nArguments:\n\ncolumn-list \n  specifies the names of the columns to keep in the output table.\n\n  Restriction: Numbered range lists in the format col1-col5 and name prefix lists in the \n  format col: are not supported. \n  \nDetails: \nThe KEEP= table option specifies that all columns in the column-list should be included in \nthe creation of output rows. Normally, all columns in the program data vector are included \nin the output rows. If the keep attribute is specified, all columns not included in the KEEP \nstatement will be dropped from the output rows.\n\nIf the KEEP= table option is associated with an input table, only the columns that are \nspecified by the KEEP= table option are available for processing during program execution."},"LABEL":{"help":" \n    \nSyntax: LABEL='label'  \n\nSyntax Description: \n\n'label' \n  specifies a text string of up to 256 characters. If the label text contains single \n  quotation marks, use double quotation marks around the label, or use two single \n  quotation marks in the label text and surround the string with single quotation \n  marks. To remove a label from a table, assign a label that is equal to a blank \n  that is enclosed in quotation marks.\n \nDetails: \nYou can use the LABEL= option on both input and output tables. When you use LABEL= \non input tables, it assigns a label for the table for the duration of the TSPL program. \nWhen it is specified for an output table, the label becomes a permanent part of that \ntable."},"LOCKTABLE":{"help":"Places shared or exclusive locks on tables. \n    \nSyntax: LOCKTABLE=SHARE | EXCLUSIVE  \n\nSyntax Description:\n\nSHARE \n  locks a table in shared mode, allowing other users or processes to read data from the \n  tables, but preventing users from updating data.\n\nEXCLUSIVE \n  locks a table exclusively, preventing other users from accessing any table that you open. \n\nDetails: \nYou can lock tables only if you are the owner or have been granted the necessary privilege. \n\nIf you access the BASE table driver through PROC TSPL, the default value for the LOCKTABLE \noption is EXCLUSIVE. However, if you access the BASE table driver through a table server, \nor if you run your program locally with the SAS Table Server LIBNAME engine, the default \nvalue for the LOCKTABLE option is SHARE.","values":{"@Value1":"SHARE","@Value2":"EXCLUSIVE"},"tooltips":{"@ToolTip1":"Locks a table in shared mode, allowing other users or processes to read data from  the tables, but preventing users from updating data.","@ToolTip2":"Locks a table exclusively, preventing other users from accessing any table that you open."}},"OVERWRITE":{"help":"For a table, drops the output table before the replacement output table is populated \nwith rows; for packages and threads, drops the existing package or thread if a package \nor thread by the same name exists. \n    \nSyntax: OVERWRITE= YES | NO;  \n\nArguments: \n\nYES | NO \n  specifies whether the output table is deleted before a replacement output table \n  is created or whether a package or thread is dropped.\n\n  Default: NO \n\nCAUTION:\nFor tables, use the OVERWRITE=YES statement only with data that is backed up or \nwith data that you can reconstruct. Because the output table is deleted first, \ndata will be lost if a failure occurs while the output table is being written.","values":{"@Value1":"YES","@Value2":"NO"},"tooltips":{"@ToolTip1":"Specifies that the output table is deleted before a replacement output table    is created or a package or thread is dropped.","@ToolTip2":"Specifies that the output table is not deleted before a replacement output table    is created or a package or thread is dropped."}},"PW":{"help":"Assigns a READ, WRITE, and ALTER password to a SAS file, and enables access to a password-protected SAS file. \n    \nSyntax: PW=password  \n\nSyntax Description:\npassword \n  must be a valid SAS name.\n\nDetails:\nThe PW= option applies to all types of SAS files. You can use this option to assign \na password to a SAS file or to access a password-protected SAS file.\n\nWhen replacing a SAS data set that is protected by an ALTER password, the new data \nset inherits the ALTER password. When the code is written to the SAS log the password \nis blotted out, for example: \n\n  drop thread job2 (pw=xxxxxxx);\n\nNote:   A SAS password does not control access to a SAS file beyond the SAS system. \nYou should use the operating system-supplied utilities and file-system security \ncontrols in order to control access to SAS files outside of SAS."},"READ":{"help":"\n    \nSyntax: READ=read-password  \n\nSyntax Description: \nread-password \n  must be a valid SAS name. \n \nDetails: \nThe READ= option applies to all types of SAS files except catalogs. You can use this \noption to assign a password to a SAS file or to access a read-protected SAS file. When \nthe code is written to the SAS log, the password is blotted out, for example: \n\n  declare package sales (read=XXXXXXX);\n\nNote: A SAS password does not control access to a SAS file beyond the SAS system. You  \nshould use the operating system-supplied utilities and file-system security controls \nin order to control access to SAS files outside of SAS."},"RENAME":{"help":"\n    \nSyntax: RENAME= (old-name { = | AS } new-name [... old-name { = | AS } new-name ] ) ;  \n\nArguments: \nold-name \n  the column you want to rename.\n\nnew-name \n  the new name of the column. It must be a valid name for the data source.\n \nDetails: \nThe RENAME= table option allows you to change the names of one or more columns.\n\nIf you use RENAME= when you create a table, the new column name is included in the output \ntable. If you use RENAME= on an input table, the new name is used in TSPL programming statements.\n\nIf you use RENAME= in the same TSPL program with either the DROP= or the KEEP= table option, \nthe DROP= and the KEEP= table options are applied before RENAME=. You must use the old name in \nthe DROP= and KEEP= table options. You cannot drop and rename the same column in the same statement.\n\nIn addition to changing the name of a column, RENAME= also changes the label for the column.","subOptions":"AS"},"TYPE":{"help":"Specifies the data set type for a specially structured SAS data set. \n    \nSyntax: TYPE=data-set-type  \n\nSyntax Description: \ndata-set-type \n  specifies the special type of the data set.\n\nDetails: \nUse the TYPE= table option in a DATA step to create a special SAS data set in the proper \nformat, or to identify the special type of the SAS data set in a procedure statement. \n\nYou can use the CONTENTS procedure to determine the type of a data set."},"WRITE":{"help":"Assigns a WRITE password to a SAS file that prevents users from writing to a file, \nunless they enter the password. \n    \nSyntax: WRITE=write-password  \n\nSyntax Description: \nwrite-password \n  must be a valid SAS name. \n \nDetails: \nThe WRITE= option applies to all types of SAS files except catalogs. You can use this \noption to assign a password to a SAS file or to access a write-protected SAS file. When \nthe code is written to the SAS log, the password is blotted out, for example: \n\n  drop thread job2a (write=XXXXXXX);\n\nNote: A SAS password does not control access to a SAS file beyond the SAS system. You \nshould use the operating system-supplied utilities and file-system security controls \nin order to control access to SAS files outside of SAS."}}}

package/data/ds2Keywords.index.json

@@ -0,0 +1 @@
+{"group":"ds2Keywords","label":"DS2 keyword","kind":17,"count":21,"entries":[["ALTER","TABLE_OPTION",1],["BUFNO","TABLE_OPTION",1],["BUFSIZE","TABLE_OPTION",1],["BULKLOAD","TABLE_OPTION",1],["COMPRESS","TABLE_OPTION",1],["DBCREATE_TABLE_OPTS","TABLE_OPTION",1],["DBKEY","TABLE_OPTION",1],["DBNULL","TABLE_OPTION",1],["DROP","TABLE_OPTION",1],["ENCRYPT","TABLE_OPTION",1],["ENCRYPTKEY","TABLE_OPTION",1],["IN","TABLE_OPTION",1],["KEEP","TABLE_OPTION",1],["LABEL","TABLE_OPTION",1],["LOCKTABLE","TABLE_OPTION",1],["OVERWRITE","TABLE_OPTION",1],["PW","TABLE_OPTION",1],["READ","TABLE_OPTION",1],["RENAME","TABLE_OPTION",1],["TYPE","TABLE_OPTION",1],["WRITE","TABLE_OPTION",1]]}