Fun with conditional logic...

so I'm playing around with some scripts today, trying to rebuild them a bit more efficiently and I hit two common problems in the same script...

first problem: possible divide by zero.
obvious way to handle it?

if (x) {
  llOwnerSay( (string)( y / x ) ); //-- return (y / x)
}else{
  llOwnerSay( "error, undefined" ); //-- if x = 0, return error.
}

fun way to handle it? replacing zero automatically to get default values

llOwnerSay( (string)( y / (x | !x) );       //-- if x = 0, returns y.
llOwnerSay( (string)( y / (x | (!x * y)) ); //-- if x = 0, returns 1.

problem two: three way switch (negative,, zero, positive)
obvious way to handle it?

if (x) {
  if (x > 0) {
    llOwnerSay( "Positive" );
  }else{
    llOwnerSay( "Negative" );
  }
}else{
  llOwnerSay( "Zero" );
}

fun way?

llOwnerSay( llList2String( ["Zero", "Positive", "Negative"], (x > 0) - (0 > x) ) );

like that little trick with the list2String? it works with llGetSubstring too!

llOwnerSay( llGetSubString( "UNTRUE" , (x != 0) * 2, - 1  );

an old one that relies on an oddity of the implementation of != for lists (thanks strife)

x = (myList != []);
x = ([] != myList);
//--same as
x = llGetListLength( myList );
x = -llGetListLength( myList );

key validity?

if (vKeyTest){
  //-- true if vKeyTest, Type = Key, and has a valid key
}else{
  //-- false if vKeyTest has NULL_KEY or is invalid
}

index found?

if (!FindSomeIndex( thing2search, thing2look4 )){}
if (~FindSomeIndex( thing2search, thing2look4 )){}
if (!~FindSomeIndex( thing2search, thing2look4 )){}
//-- same thing as
if (FindSomeIndex( thing2search, thing2look4 ) == 0){}
if (FindSomeIndex( thing2search, thing2look4 ) != -1){}
if (FindSomeIndex( thing2search, thing2look4 ) == -1){}

have any fun tricks with conditionals that you use alot? share!

Ohhh... I like the llList2String construct... almost a replacement for inline conditionals.

the 3 way logic construct is probably one of the more useful in there (although I really love the inline if functionality)

you can tell if a number is positive negative or 0
((0 < X) - (0 > X))

if a number is above, below, or at another number
((Y < X) - (Y > X))

if a number is outside a range, and which direction (A high end , B low end)
((A < X) - (B > X))

inside a Range
!((A < X) - (B > X))

return positive or negative for TRUE FALSE switches
((FALSE < X) - (TRUE > X))
also works as
(2 * (X > FALSE) - 1)
or
(-2 * !X + 1)

speaking of which, there's a few math shorcuts....
X * llPow( 2, Y ) == X << Y;
//-- faster: works to replace any number where Y is an integer
X / llPow( 2, Y ) == X >> Y;
//-- same idea... making y negative reverses the operation
//-- eg
X * 8 == X << 3

X % llPow( 2, Y ) == X & llPow( 2, Y ) - 1;
//-- eg
X % 8 == x & 7

and I'm not sure of the speed difference, but...
-~x == ++x
~-x == --x