# User:Toady Nakamura/Sandbox

# Operators

## Arithmatic Operators

LSL has arithmetic operators which can be used with integers, floats, vectors and rotations.

The order of operation is

result = left + right

The symbols, definition and examples of the operators:

= ... denotes equality ... 1 = 1 + ... addition ... 1 + 2 = 3 - ... subtraction ... 3 - 2 = 1 * ... multiplication ... 2 * 3 = 6 / ... division ... 6 / 3 = 2 % ... remainder operator ... (see explanation below)

Since integers are whole numbers, if you divide 15/2 the answer is not a whole number and if you did that in a script the extra *remainder* is discarded as the answer is rounded toward zero. If you need the remainder, use the *remainder operator*, written as % to get what was otherwise lost.

This script snippet shows how the remainder operator works <lsl>

integer i; i = 15 % 2; // 15/2 = 7.5; 0.5 + 0.5 (for the two halves which were discarded) =1; // the remainder i is assigned the value 1 i = 15 % 4; // 15/4 = 12; 15-12=3; // the remainder i is assigned the value 3 i = -15 % 4; // i is assigned the value -3

// remember to round toward zero not just "round down"! </lsl>

Vector data contains a set of three float values. In LSL adding vectors to vectors is done <x,y,z> + <x1,y1,z1> = the combined vector. The constant ZERO_VECTOR is equal to <0,0,0>. You can get to individual parts of a vector as shown in this snippet:

<lsl> vector vec; float x = vec.x; float y = vec.y; float z = vec.z; </lsl>

To combine rotations, you use the multiply and divide operators. Multiply * applies the rotation in the positive direction, the divide / does a negative rotation. The constant ZERO_ROTATION equals <0.0, 0.0, 0.0, 1.0>. Read the official wiki page for more on Rotations

### Assignment using Arithmatic operators

There is a handy shorthand for adding repetitive values as seen in this snippet: <lsl> integer x; integer y;

x += y; // means x = x + y; ... the new value of x is equal to x + y x -= y; // means x = x - y; ... the new value of x is equal to x - y x *= y; // means x = x * y; ... the new value of x is equal to x * y x /= y; // means x = x / y; ... the new value of x is equal to x / y

</lsl>

### Signed integers

Example: The plus integer (ex.: +1) is generally assumed. "It was -3 degrees today!" uses a negatively signed integer.

### Comparison Operators

The comparison operators seek to determine equality (TRUE, value 1) or inequality (FALSE, value 0).

!= ... not equal ... 3 != 2 + 2 < ... less than ... 3 < 4 > ... greater than ... 4 > 3 <= ... less than or equal ... 2 <= 3 >= ... greater than or equal ... 3 >= 2

The result of a comparison operator is either 0 (FALSE) or 1 (TRUE).

### Unary Operator

Because counting up or down by 1 is so common, a special *unary operator* has been created.

++ ... count up by one -- ... count down by one

There are two ways to use the unary operators, but be careful, they are not identical. <lsl>

integer i = 0; i++; // i now has the value of 1 - because i++ means " evaluate then increment " // contributes its value before incrementation ++i; // i now has the value of 2 -- because ++i means " increment then evaluate "

</lsl>

When used as part of a larger expression, i++ evaluates (values itself) and then increments but ++i counts up first, then adds its own value.

<lsl> *** NEEDS BETTER EXAMPLE >>>>> this has if/else and we havent' explained it yet

integer i = 0; if (i++ == 0) // Is evaluated then incremented. llSay( 0, "The value of i was 0 when the comparison was done" ) // Will be said even though i ends up with the value of 1. else llSay( 0, "The value of i was 1 when the comparison was done" )

</lsl> On the other hand, if we switch i++ to ++i, i.e. <lsl>

integer i = 0; if (++i == 0) // Is incremented then evaluated. llSay( 0, "The value of i was 0 when the comparison was done" ) // Will not be said. else llSay( 0, "The value of i was 1 when the comparison was done" )

</lsl> the chat output would be "The value of i was 1 when the comparison was done".

The operator minus-minus (written --) works similarly.

>>>> NEED BETTER EXAMPLE HERE

See for a list of all LSL operators and for a generalized discussion about Operators.

*Cautions*

- If you try to divide (/) or remainder (%) anything by zero, you will get a run-time error and script fail.

- If any arithmatic returns a value outside the range −2147483648 to 2147483647, different rules apply.

A good explanation can be foundhere.

- Hexadecimal is rarely used in LSL, if you desire to learn more about it, click here .

## Truth Values (Booleans)

Truth values (Booleans) are either 0 (FALSE) or 1 (TRUE).

### Truth Value Operators

! ... means "not" && ... means "and" || ... means "or"

These snippets show some of the ways statements evaluate to TRUE or FALSE <lsl> //The ! operator takes a single operand and evaluates to TRUE if the operand is false, and FALSE otherwise.

integer i; i = !(3 == 7); // 3 == 7 is FALSE, so i gets the value TRUE

//The && operator takes two operands and evaluates to TRUE if both its operands are true, and FALSE otherwise.

i = (3 < 7) && (3 > 7); // 3 < 7 is TRUE, but (3 > 7) is FALSE, so i gets the value FALSE

//The || operator takes two operands and evaluates to TRUE if either one of its operands are true, and FALSE otherwise.

i = (3 < 7) || (3 > 7); // one of the operands (3 < 7) is TRUE, so i gets the value TRUE

</lsl>

Like the binary arithmetic operators, && and || have a corresponding assignment type operator.

x &&= y; // Synonymous with x = x && y; x ||= y; // Synonymous with x = x || y;

### Statements Requiring Truth Values

There are four statement types that require a truth value condition:

- if
- for
- while
- do-while

There are three operators which look similar but have different meanings.

= ... assignment ... "equal to" == ... test for equality ... "exactly equal to" != ... test for inequality ... "not equal to"

#### if

An "if-then-else" command does a test (written inside parentheses), and if that test is TRUE, then the command will do something {written in brackets}, else the command will do something else - or nothing - when the test is FALSE. The command is formatted like these snippets:

<lsl> if (test)

{do this}

else

{do that}

</lsl> You can leave off the "else" part if there's nothing for it to do, instead write <lsl>

if (test) {do this}

</lsl>

Here's an example of how to set an integer as a switch, you can think of it as an iSwitch, and this script shows you how to use it.

<lsl> integer i = FALSE; // defined as off globally // and the value of off/on to FALSE (aka i=0;)

// notice one * = * equals sign above, because the value is being set

default {

state_entry() { llParticleSystem([ ]); // starts with particles off } touch_start(integer total_number) { if (i==FALSE) // notice two *==* because this is testing for // exact equality { llParticleSystem([ PSYS_PART_FLAGS, PSYS_PART_WIND_MASK | PSYS_PART_EMISSIVE_MASK, PSYS_SRC_PATTERN, PSYS_SRC_PATTERN_EXPLODE, PSYS_PART_START_COLOR, <1,0,0> ]); i=TRUE; // flip the iSwitch to the other setting & wait for next touch // notice one * = * because the value is being set } else // if the touch happened when particles were on { llParticleSystem([ ]); // turn particles off i=FALSE; // flip the iSwitch to the off position & wait for next touch // notice one * = * because the value is being set } }

} </lsl>

<lsl> integer Counter; // define an integer to hold a value later default {

state_entry() { llSay(0, "..I can count to myself, up to 10!.."); }

touch_start(integer total_number) { for (Counter=1; Counter<=10; ++Counter) //** { llOwnerSay((string)Counter); } } llOwnerSay("That wasn't so hard!");

} // ** This line contains the instructions for how many times to do this loop // First ... set initial value ... Counter = 1; // Second ... do the loop if the counter is less than or equal to 10 ... Counter <=10 // Third ... after each loop, add 1 to Counter ... ++Counter. </lsl>

These examples were originally on (http://wintermute.linguistics.ucla.edu/lsl/loop.html Ed Boost) which is unfortunately a dead link.

#### for

In programming, a "test" is something that comes out True or False (Yes or No and/or 1 & 0 ).