BAM Docs — Programming Reference and User Guide for BASIC Anywhere Machine.

Home

Charlie Veniot 18th June 2023 at 5:32pm

New: Main Menu
Old: Menu

References

Other References

Personal Computing on the VIC-20

Some resources to help put this reference together

Google Search "basic structure of programs"
- Learn the Basic Structure of C Program in 7 Mins

https://en.wikipedia.org/wiki/Comparison_of_programming_languages

Google Search "components of a programming language"

Primitive Data Types

In computer programming, a data type is a grouping of data values that share the same characteristics, the same rules, the same types of operations.

(Read more about Data Types ^W and Primitive Data Types ^W.)

BASIC Anywhere Machine programs are a sequence of instructions that tell the computer to do something (or many things) and usually involves data (maybe real-world values for the program to process, and/or internal data generated by the program to keep track of what it is doing, and/or data generated for output.)

Whatever the purpose, whether input for the program, or output from the program, or something internal to the program, and however it relates to the real world, BASIC Anywhere Machine recognises and knows how to process data of the following types:

String Data Type

A string (aka "character" string, aka "text" string) is enclosed in double quotes and can contain any number and combination of letters, numbers, special characters, punctuation marks, graphic symbols, or cursor control characters.

The maximum length of a string: (2⁵³) - 1

NOTE: The only character than cannot be included within the double-quotes: a double-quote. However, a double-quote can be used in a string with the help of the function.

Integer Number Types

An integer is a "whole" number, i.e. a number with no fractional part, so no decimal point. The integer may have a sign, negative (-) or (+), or may be unsigned (i.e. non-negative integer).

BYTE Data Type

unsigned 8-bit (1-byte) integers that range in value from 0 through 255

SHORT Data Type

Integer numbers in the range of -32768 to 32767.

The "Short" and "Integer" data types are aliases of each other.
- "Integer" is also the group name of for the types BYTE, SHORT, and LONG.
- To make things a little confusing, "INTEGER" is an alias the SHORT data type
- So if you were to tell BASIC Anywhere Machine "Hey, this number I'm giving you is an INTEGER", BASIC Anywhere Machine will take that as meaning it is a SHORT.

LONG Data Type

Integer numbers in the range of -2147483648 to 2147483647.

INTEGER Data Type

Integer numbers in the range of -32768 to 32767.

The "Short" and "Integer" data types are aliases of each other.
- "Integer" is also the group name of for the types BYTE, SHORT, and LONG.
- To make things a little confusing, "INTEGER" is an alias the SHORT data type
- So if you were to tell BASIC Anywhere Machine "Hey, this number I'm giving you is an INTEGER", BASIC Anywhere Machine will take that as meaning it is a SHORT.

Note:

June 2023: Previously, "Integer" was synonymous with the

Floating-Point Number Types

Floating-point numbers (also called "decimal" numbers and "real" numbers) can be any kind of number, including:

positive and negative numbers
whole numbers
numbers with fractional parts (i.e. decimals)
numbers expressed in
- the exponent can be either positive or negative

SINGLE Data Type

The SINGLE Data Type is buggy ???

Related to this?

For example, see the results of the following snippets of code:

DIM a AS SINGLE
a = 1.23
PRINT a

gives the following result: 1.23000001907344863

That's probably not horrible in most scenarios, but it annoys me.

So until I find myself in a scenario in which DOUBLE creates a problem (like too much memory?) that SINGLE solves. I personally stick with DOUBLE:

DIM a AS DOUBLE
a = 1.23
PRINT a

gives the following result: 1.23

Floating-point numbers from -8.0 * 10^10 to 8.0 * 10^10

Double Data Type

Floating-point numbers from -9.99999977457469 * 10^191 to 9.99999977457469 * 10^191

Literals: Value Notations

A literal ^W is a notation, a way of representing a data value (for one of the ) in a program.

String Literals

PRINT "Hello World!"

Hello World! is a string literal.

BASIC Anywhere Machine recognises it as a string literal because it is wrapped in double-quotes (the pair of double-quotes can be called "bracketed delimiters".)

A string, all of the stuff between the double-quotes, can consist of any number and any type of keyboard character: alphabetic (upper and lowercase), number, punctuation, and any other symbol.

For example:

"" (this is an empty, or null, string)
"ABC abc 123 $%^"

Some Difficult Characters

`"`

Because a double-quote is a reserved special character (reserved for the purpose of identifying string literals), that character cannot be included in a literal string as-is. Including this character in a literal string will cause a program to not run.

To get around this problem, we have to use the BASIC function and string concatenation operators to include double-quotes in a string literal. For example:

CHR$(34) + "concatenation" + CHR$(34) + " means joining two strings together"

this is an "expression" involving functions, literals, and operators
CHR$(34) is a function which results in BASIC Anywhere Machine replacing it with the result: a "
- the function is saying "give me the character matching the character code 34"
- We discuss this and other BASIC functions later in the documentation
+ is an operator that, in the case of strings, tells BASIC Anywhere Machine to concatenate (or "string together") the two strings on either side of the operator
- We discuss this and other BASIC operators later in the documentation
"concatenation"
- This is the literal that represents the concatenation string value

The resulting string:

"concatenation" means joining two strings together

`\`

Although the backslash character has no special meaning to this BASIC programming language, it does have special meaning to the interpreter. A backslash is a delimiter for an "escape sequence" ^W. Including this character in a literal string will cause a program to not run.

To get around this problem like for ", we can use the BASIC function and string concatenation operators to include backslashes in a string literal. For example:

a$ = chr$(92) + "concatenation" + chr$(92) + " means joining strings together"

The resulting string:

\concatenation\ means joining two strings together

Alternatively, we can use the escape sequence \\ which will get translated by the interpreter as a single backslash.

a$ = "\\concatenation\\ means joining strings together"

The resulting string:

\concatenation\ means joining two strings together

Integer Literals

BASIC Anywhere Machine accepts integer numbers represented in any of the four number systems:

decimal ^W (the primary number system)
binary ^W
hexadecimal ^W
octal ^W

Decimal number literals

Decimal number literals contain on digits (i.e. {0,1,2,3,4,5,6,7,8,9} ...

, not allowed
% not allowed
(blank space) not allowed

Binary number literals

Binary numbers contain only the digits from the set {0,1} and must be prefixed with either &b or &B.

For example:

PRINT &B1010 prints the decimal number 10
PRINT &b11111010prints the decimal number 250

Later in this documentation, we'll see how to represent binary numbers as string values which can be converted to the integer data type.

Hexadecimal number literals

Hexadecimal numbers contain only digits and characters from the set {0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G} (or the lowercase letters, since case does not matter to BASIC Anywhere Machine) and must be prefixed with either &h or &H

For example:

print &ha prints the decimal number 10
print &hfaprints the decimal number 250

Later in this documentation, we'll see how to represent hexadecimal numbers as string values which can be converted to the integer data type.

Octal number literals

Octal numbers contain only digits and characters from the set {0,1,2,3,4,5,6,7} and must be prefixed with either &o or &O

For example:

print &o12 prints the decimal number 10
print &o372prints the decimal number 250

Later in this documentation, we'll see how to represent octal numbers as string values which can be converted to the integer data type.

Floating-Point Literals

Scientific E Notation

In (scientific) E Notation ^W, a number is reduced to its simplest form of a floating-point number with one-whole-digit, however many decimal places, and the missing digits is represented by an exponent. The format for representing numbers in scientific notation is as follows:

mantissa E sign exponent

mantissa		a floating-point number with one whole digit (example: 1.55)
E		the letter `e`, either uppercase or lowercase, which is the operator for scientific notation, indicating "times the number 10 raised to the specified power.
Power	sign	`+` or `-`, indicating whether the exponent is negative or positive
Power	exponent	the value of the power to which the number 10 is raised

2.36958E15 is equal to 2.36958 times 10¹⁵ or 2,369,580,000,000,000

8.254689E-12 is equal to 8.254689 times 10^-12 or 0.000000000008254689

A positive exponent indicates that the decimal point is moved xx digits to the right; a negative exponent value indicates that the decimal point should be moved xx positions to the left.

Using scientific notation in numeric expressions

print 5e+2

result: 500

print 5e-2

result: 0.05

Arrays

Preface

From Commodore 128 BASIC Training Guide^IA :

One of the biggest problems facing the beginning programmer is programming and handling arrays. The more complicated the array, the harder it is to manage. Even accomplished programmers have trouble handling arrays.

From Commodore PC GW-BASIC Interpreter Users Guide^IA :

An array is a group or table of values referenced by the same variable name. Each element in an array is referenced by an array variable that is a subscripted integer or an integer expression. The subscript is enclosed within parentheses. An array variable name has as many subscripts as there are dimensions in the array.

Description

Whereas a variable stores a single value of a specified data type, an array^W is a data structure that is used to store a group of single values of the same specified data type: a block of STRING values, or a block of BYTE values, etc. etc.

An array consists of consecutive storage areas (one storage area per value) and each value in an array is called an element.

An array may have one, two, three, or more dimensions. One dimension is like one column with many rows (or one row with many columns!) Two dimensions is like a grid with many rows and many columns. Three dimensions is like a cube! Beyond three dimensions, it gets a little bit hard to visualise.

A four-dimension array could be visualised as: Row, column, depth, time - Michael Clark
A five-dimension array could be, in a game: health, attack, defense, damage, speed - GoodChipmunk8662

The entire array has one name assigned for it and all of the elements in it, and each element in the array is referenced via its position in the array. The reference to an array element is made via the name of the array followed by the position of the element in parentheses.

Depending on an array's number of dimensions, the position of an element may involve one or more positive integer numbers (a literal, or a constant, or variable, a function, or any expression resulting in a positive integer). Each of these numbers is an index (aka subscript) for a dimension.

Each positioned element in an array is like a variable. It is a storage area for one value of the type allowed for the array.

Each dimension in an array has a lower index limit (aka lower bound) and an upper index limit (aka upper bound), and these bounds indicate the index numbers of the first element, the last element, and all of the other elements in between. (Upper bound - lower bound + 1 = total number of elements in the dimension of the array.)

TI-99/4A BASIC Reference Manual^IA :

An array is a tabular collection of data elements of the same data type all of which are accessible through a single variable name. An array variable name follows the same rules that apply to simple variable names. The type of data stored in an array (numeric or character), is determined by the variable name just as it is for simple variables. If the array name ends in a dollar sign ($), it is a character string array; otherwise, it is a numeric variable array.

DIM for Declaring Arrays

The DIM statement is used to declare an (optionally: many arrays with the one statement) without assigning any value(s) to the array(s).

An identifier can only appear with the DIM statement once in a program.

Syntax

DIM id_Ⓣ(array_spec) , id_Ⓣ(array_spec)^🔁

DIM id(array_spec) AS type , id(array_spec) AS type^🔁

DIM AS type id(array_spec) , id(array_spec)^🔁

Each instance of [array_spec] can be any one of the following:

```
exprUpperBound% , exprUpperBound%^🔁
```

exprLowerBound% TO exprUpperBound% , exprLowerBound% TO exprUpperBound%^🔁

Descriptions

id_Ⓣ
- An identifier: a valid name including an optional data type suffix Ⓣ (see )
  - A data type suffix is a part of the identifier.
  - If no data type suffix is specified, the constant will default to being a single data type, regardless of the expression provided.
id
- An identifier: a valid name
type
- one of the data type keywords (see )
exprUpperBound%
- an expression that results in an integer and defines the upper bound of, i.e. the last indexed item in, and array for the specified dimension
  - the expression can be as simple as a literal, a constant, a variable, or the results of a function, or a complex combination of these things with whatever operators
exprUpperBound% (required)
- an expression that results in an integer and defines the upper bound of, i.e. the last indexed item in, and array for the specified dimension
  - the expression can be as simple as a literal, a constant, a variable, or the results of a function, or a complex combination of these things with whatever operators
exprLowerBound% (optional)
- an expression that results in an integer and defines the lower bound of, i.e. the first indexed item in, and array for the specified dimension
  - the expression can be as simple as a literal, a constant, a variable, or the results of a function, or a complex combination of these things with whatever operators
- when not specified, the lower bound is assumed to be "0" (the default) unless an has altered the default to be "1".

Options for Comments in Programs

For single line comment (as per any BASIC implementation)

REM This line will be ignored during program execution.

For multi-line comment

REM Sometimes, we want a comment _
    to span multiple lines.  The _
    "continuation" mark _
    (space followed by underscore) _
    is really good for this.

`'` ^{(Single Quote)}

' Although the single-quote is also an option for comments,
' it is best for short comments, especially those that are added at the end of, and on the same line as, a line of code.

PRINT "Hello World!"  ' The single quote is very convenient for this

PRINT "Hello World!" : REM We can use REM instead of a single quote, but it does require a colon to separate the "REM" statement from the previous statement

`` ^{(HTML Comment tags)}

Note: Use this for "internal comments" only. Upon export of a program, the process removes these types of comments.

<!-- BASIC Anywhere Machine being a browser-based implementation of BASIC,
     we can take advantage of the HTML way of adding comments if and when
     compatibility with other BASIC implementations is of no concern -->

wwwBASIC Keyword Reference Original

Keyword Reference - Alphabetical

(function)

(statement)

Keyword Reference - By Groups

Number Operators and Functions

Operators

(aka "Arithmetic Operators")

Every numeric operator can be used with every one of the , and the operands can be any possible mix and match of numeric data types. A numeric expression always results in a number of the double data type (except for integer division, which results in a long data type).

The Order of Operations, Table of Numeric Operators

Numeric Expression Syntax

For all numeric operators except for negation

exprNum operator exprNum operator exprNum^🔁

exprNum:
- A literal number can be presented in any of the recognised value notations for integer and floating-point numbers (see )
operator
- Any one of the recognised numeric operators except for the negation operator (see )

For the negation operator

- exprNum

Examples

Single Operator Examples

Addition Examples

Example Program
`PRINT 1 + 2 PRINT 1 + 2.5 PRINT 1.25 + 2.5 PRINT 1.25 + &b1010 PRINT 1.25 + &ha PRINT 1.25 + &o12 PRINT 1.25 + 5e+2`

Try Your Own Program

About Running Programs and Entering Your Own Running Programs Rules for Coding BAM Programs Case Insensitive are optional

Subtraction Examples

Example Program
`PRINT 2 - 1 PRINT 1 - 2.5 PRINT 2.5 - 1.25 PRINT 1.25 - &b1010 PRINT &ha - 1.25 PRINT 1.25 - &o12 PRINT 1.25 - 5e+2`

Try Your Own Program

About Running Programs and Entering Your Own Running Programs Rules for Coding BAM Programs Case Insensitive are optional

Multiplication Examples

Example Program
`PRINT 2 * 1 PRINT 1 * 2.5 PRINT 2.5 * 1.25 PRINT 1.25 * &b1010 PRINT &ha * 1.25 PRINT 1.25 * &o12 PRINT 1.25 * 5e+2`

Try Your Own Program

About Running Programs and Entering Your Own Running Programs Rules for Coding BAM Programs Case Insensitive are optional

Division Examples

Example Program
`PRINT 2 / 1 PRINT 1 / 2.5 PRINT 2.5 / 1.25 PRINT 1.25 / &b1010 PRINT &ha / 1.25 PRINT 1.25 / &o12 PRINT 1.25 / 5e+2`

Try Your Own Program

About Running Programs and Entering Your Own Running Programs Rules for Coding BAM Programs Case Insensitive are optional

Exponentiation Examples

Example Program
`PRINT 2 ^ 3 PRINT 2 ^ 2.5 PRINT 2.5 ^ 1.25 PRINT 1.25 ^ &b1010 PRINT &ha ^ 1.25 PRINT 1.25 ^ &o12 PRINT 5e+2 ^ 1.25`

Try Your Own Program

About Running Programs and Entering Your Own Running Programs Rules for Coding BAM Programs Case Insensitive are optional

Modulo Examples

Example Program
`PRINT 2 ^ 3 PRINT 2 ^ 2.5 PRINT 2.5 ^ 1.25 PRINT 1.25 ^ &b1010 PRINT &ha ^ 1.25 PRINT 1.25 ^ &o12 PRINT 5e+2 ^ 1.25`

Try Your Own Program

About Running Programs and Entering Your Own Running Programs Rules for Coding BAM Programs Case Insensitive are optional

Negation Examples

Example Program
`PRINT - 3 PRINT -2.5 PRINT - &b1010 PRINT -&ha PRINT - &o12 PRINT -5e+2`

Try Your Own Program

About Running Programs and Entering Your Own Running Programs Rules for Coding BAM Programs Case Insensitive are optional

Multiple Operator Examples

The Order of Operations

The order of operations ^W is:

a collection of rules that reflect conventions about which procedures to perform first in order to evaluate a given mathematical expression.

Parentheses,( and ), can be used to override precedence conventions, or simply to emphasise intent (a good idea when expressions get very complicated.

In order of precedence:

Innermost operations between ( and )
Exponentiation
Negation
Multiplication, Division, Integer Division, Modulo (all four operators are equals in order of precedence)
Addition and Subtraction (the two operators are equals in order of precedence)

When two or more operations are at the same order of precedence, the operations are evaluated using the left-to-right rule.

For more info, see Order of Operations (PEMDAS) by Mometrix Test Preparation

Examples: Parentheses and Exponentiation

In these examples, we see that exponentiation takes precedence over all other operations except for operations within parentheses:

Example Program
`PRINT 1 + 2 ^ 3 PRINT (1 + 2) ^ 3 PRINT 2 * 2 ^ 3 PRINT (2 * 2) ^ 3 PRINT 2 / 2 ^ 3 PRINT (2 / 2) ^ 3 PRINT 20.5 \ 2 ^ 3 PRINT (20.5 \ 2) ^ 3 PRINT 53 MOD 3 ^ 3 PRINT (53 MOD 3) ^ 3`

Try Your Own Program

About Running Programs and Entering Your Own Running Programs Rules for Coding BAM Programs Case Insensitive are optional

Examples: Negation

Although Negation seems to work directly in most circumstances, it seems safest to always wrap in parentheses anything that is being negated:

Example Program
`PRINT - 2 * - 2 REM "For readability, it might be a good idea to remove spaces between a negation operator and the operand" PRINT -2 * -2 REM For readability, it might be worth considering parentheses PRINT (-2) * (-2) REM Exponentiation takes precedence over negation PRINT -2 ^ 4 PRINT (-2) ^ 4 PRINT - 2 + - 2 PRINT - 2 + 2 REM Exponents can be negated PRINT 2 ^ - 2 REM For readability, it might be worth putting exponents, especially those with negation operators, in parentheses PRINT 2 ^(-2)`

Try Your Own Program

About Running Programs and Entering Your Own Running Programs Rules for Coding BAM Programs Case Insensitive are optional

Notes

From I speak BASIC to my Commodore 64^IA :

EMDAS Order (Echo My Dear Aunt Sally)
1. Exponentiation
2. Multiplication
3. Division
4. Addition
5. Subtraction
When parentheses are used
- the innermost set of parentheses is simplified first, followed by each successive set outward
- EMDAS order is followed inside all sets of parentheses

Functions

Relational Operators

(aka "Comparison Operators")

From Wikipedia's "Relational operator" article:

a relational operator is a [...] construct or operator that tests or defines some kind of relation between two entities.
An expression created using a relational operator forms what is termed a relational expression or a condition.

The relational operators are used mainly in (TODO: list statements: ) statements. Relational operators always result in a TRUE (-1) or FALSE (0) numeric value. (In BASIC Anywhere Machine, you have the option of using the literals -1 and 0, or you can use the system constants.)

List of Relational Operators

Operator		Example
=	Equal to (the values on both sides of the operator are equal)
<	Less than (the left-side value is less than the right-side value)
>	Greater than (the left-side value is greater than the right-side value)
<=	Less than or equal to (the left-side value is less than or equal to the right-side value)
>=	Greater than or equal to (the left-side value is greater than or equal to the right-side value)
<>	Not equal to (the values on both sides of the operator are not equal)
For the "two-symbols" operators (<=, >=,<>), BASIC Anywhere Machine allows spaces between the symbols

A relational expression evaluates as either TRUE or FALSE. In BASIC Anywhere Machine, wwwbasic does not have a boolean datatype, and uses the number 0 (i.e. zero) to mean FALSE and non-zero to mean TRUE

In this Basic Programming Language Reference, the ◊ symbol, as part of a programming statement, indicates the use of a condition in the programming statement.

Conditions are used in:

Logical Operators

(aka "Boolean Operators", after English mathematician George Boole)

Operator		Example	Notes



			Logical XOR in JavaScript - How To Create

Keyword Reference - String Functions

Functions

(function)

(statement)

Graphics

Functions

Keyboard Input

Functions

Data Storage

Functions

Declaration Keywords

Data Types

Definitions

Line Identifiers

In BASIC Anywhere Machine, Line Identifiers include:

(an unsigned and non-formatted integer)
(a string of characters of any kind, excluding spaces and reserved characters)

BASIC Anywhere Machine, like all modern BASIC dialects, supports line identifiers of either kind, and line identifiers are optional except when required for "branching."

A line identifier is declared when it first appears at the beginning of a line. Let's call this the line identifier declaration ("lineIdentifierDeclare" in syntax diagrams.)

A line identifier is referenced when the line identifier appears as a parameter in a branching statement. Let's call this line identifier reference ("lineIdRefer" in syntax diagrams.)

Line Numbers

One of the two types of in BASIC Anywhere Machine.

From Wikipedia:

[...] BASIC made line numbers a required element of syntax. The primary reason for this is that most operating systems at the time lacked interactive text editors; since the programmer's interface was usually limited to a line editor, line numbers provided a mechanism by which specific lines in the source code could be referenced for editing, and by which the programmer could insert a new line at a specific point
Line numbers also provided a convenient means of distinguishing between code to be entered into the program and direct mode commands to be executed immediately when entered by the user (which do not have line numbers).
Largely due to the prevalence of interactive text editing in modern operating systems, line numbers are not a feature of most programming languages, [including modern BASIC and BASIC-like/inspired implementations.]

Also worth reading in that article:

History (BASIC)
Line numbers and style
Line numbers and GOTO's
Line numbers and syntax errors

Syntax

Valid non-formatted integer number of any length
Can be prefixed with any number of zeroes, and then can be prefixed with any number of spaces
When declared, it can be suffixed with a colon (i.e. :)
- Note: other BASIC implementations may not support the colon on line numbers; you might want to avoid the colons to create programs in BAM that work with other implementations

Line Labels

One of the two types of in BASIC Anywhere Machine.

From Wikipedia:

In programming languages, a label is a sequence of characters that identifies a location within source code. In most languages, labels take the form of an identifier, often followed by a punctuation character (e.g., a colon). In many high-level languages, the purpose of a label is to act as the destination [when branching.]

Syntax

When declared, must be suffixed with a colon (i.e. :)
Otherwise follow the

Starting Notes on Functions

From QB64, seems to be same for wwwBasic:

FUNCTION procedureName[type-suffix] [(parameters)] {code} 'variable definitions and procedure statements ⋮ procedureName[type-suffix] = returnValue END FUNCTION

however, in wwwBasic, functions MUST be declared at the start of the program !!!

(TODO: Add examples: I'm thinking one example per data type)

declare function Howdy$( ThisMsg as string )
dim MyMsg as string
Input "Enter a Message: ", MyMsg
Print Howdy$(MyMsg)
end
function Howdy$( ThisMsg as string )
Howdy$ = "Your message is: " + ThisMsg
end function

A function can be defined anywhere in a program. The only caveat: it must be either defined or declared before being referenced.
If it is defined before being referenced, it does not need to be declared.
If the function it declared, it must be declared before being defined.
Commonly (?) function declarations happen at the beginning of a program, and function definitions happen at the end of a program

Sub Procedure Sample

Programming Tasks

Compatibility

	n/a
	n/a
	n/a
	n/a

Notes:

These rows of info tell us how compatible BAM is with an implementation of BASIC.
wwwBASIC is the exception. This tells us how compatible wwwBASIC is with BAM. Where compatibility is less than 100%, this indicates an improvement made to BAM's internal copy of wwwBASIC.
n/a means a feature that does not apply to the particular BASIC implementation

Home

Subject: Topic:

Description:

Some Difficult Characters

`"`

`\`

Using scientific notation in numeric expressions

Syntax

Descriptions

`'` ^{(Single Quote)}

`` ^{(HTML Comment tags)}

Operators

Numeric Expression Syntax

For all numeric operators except for negation

For the negation operator

Examples

Single Operator Examples

Multiple Operator Examples

Notes

Functions

Functions

Functions

Functions

Functions

Data Types

Definitions

Syntax

Syntax

Home

Some Difficult Characters

"

\

Using scientific notation in numeric expressions

Syntax

Descriptions

REM

' (Single Quote)

(HTML Comment tags)

Operators

Numeric Expression Syntax

For all numeric operators except for negation

For the negation operator

Examples

Single Operator Examples

Multiple Operator Examples

Notes

Functions

Functions

Functions

Functions

Functions

Data Types

Definitions

Syntax

Syntax

`"`

`\`

`'` ^{(Single Quote)}

`` ^{(HTML Comment tags)}