↓OH-Script

Introduction

↓Syntax

Comments

// This is a C-style-comment
// till the end of the line.
​
/* 
   and this is a C++-style
   multi-line-comment.
*/

Data Types

↓Rounding Errors

↓Boolean Logic

↓Operators

• Exponentiation Power ** (not ANSI-C) a ** b Standard algebraic exponentiation on a and b. a is raised to the power of b.
• Natural Log ln (not ANSI-C) ln a Standard algebraic natural log of a a == e ** (ln a)
• Natural Log Base e (not ANSI-C) e == 2.71828182845905
• Unary A unary operator takes a single operand.
• Logical NOT ! False when the operand is true. True when the operand is false. a  !a false true true false 0 1
• Bitwise NOT ~ Logical NOT operation on a bit by bit basis.
  

  expression	binary result
  a	11001001011101010110010101111010
  ~a	00110110100010101001101010000101

• Negation - A good example is the minus sign when it is used to alter the sign of a value. Example: "a + b / -4" The minus sign in front of the 4 is a unary minus.
• Bit Count ‘ (not ANSI-C) Provides a count of the number of bits set in any integer value. Here are 3 examples of the number of bits that are set in some 32-bit integer numbers.
  

  a	‘a
  0000000000000000000000000000000	0
  0000000000000100000000000000000	1
  0000010000000100000000000010000	3
  1111111111111111111111111111111	32

• Multiplicative Multiply * a * b Standard algebraic multiplication on a and b.
• Divide / a / b Standard algebraic division on a and b.
• Modulo % a % b Standard algebraic modulo on a and b.
• Percentage % a % b The result will be (a / 100) * b. The percentage operator got introduced with OpenPPL. OpenHoldem will assume that “%” inside an OH-script function means the modulo-operator and that “%” inside an OpenPPL-function (with WHEN-conditions) means the percentage-operator.
• Additive Add + a + b Standard algebraic addition on a and b.
• Subtract - a - b Standard algebraic subtraction on a and b.
• Bitwise Shift Left << Slides the entire bit pattern to the left by N bits. Note that the leftmost bits are simply dropped and that the rightmost bits are filled with 0’s. The shift magnitude is used as modulo 32, meaning that any shift N that is specified in excess of 32 bits has a N%32 operation performed prior to the shift.
  

  expression	binary result
  a	11001001011101010110010101111010
  a<<1	10010010111010101100101011110100
  a<<7	10111010101100101011110100000000
  a<<31	00000000000000000000000000000000
  a<<32	11001001011101010110010101111010

• Bitwise Shift Right >> Slide the entire bit pattern to the right by N bits. Note that the rightmost bits are dropped and that the leftmost bits are filled with 0’s. The shift magnitude is used as modulo 32, meaning that any shift N that is specified in excess of 32 bits has a N%32 operation performed prior to the shift. expression binary result.
  

  expression	binary result
  a	11001001011101010110010101111010
  a>>1	01100100101110101011001010111101
  a>>7	00000001100100101110101011001010
  a>>31	00000000000000000000000000000001
  a>>32	11001001011101010110010101111010

• Relational Less Than < a b a < b -1 0 true 0 0 false +1 0 false
• Greater Than > a b a > b -1 0 false 0 0 false +1 0 true
• Less Than Or Equal <= a b a <= b -1 0 true 0 0 true +1 0 false
• Greater Than or Equal >= a b a >= b -1 0 false 0 0 true +1 0 true
• Equality Equal == a b a == b -1 0 false 0 0 true +1 0 false
• Not Equal != a b a != b -1 0 true 0 0 false +1 0 true
• Approximately Equal ~~ this operator rounds both sides to integer numbers before comaring. It is especially to support betsize and stacksize comparisons of converted PPL profiles, as Shanky PPL works with integers only.
• Bitwise AND & Logical AND operation on a bit by bit basis.
  

  expression	binary
  a	11001001011101010110010101111010
  b	01001010010100101110001010101111
  a&b	01001000010100000110000000101010

• Bitwise OR | Logical OR operation on a bit by bit basis.
  

  expression	binary
  a	11001001011101010110010101111010
  b	01001010010100101110001010101111
  a | b	11001011011101111110011111111111

• Bitwise XOR ^ Logical XOR operation on a bit by bit basis.
  

  expression	binary
  a	11001001011101010110010101111010
  b	01001010010100101110001010101111
  a^b	10000011001001111000011111010101

• Logical AND && False when any operand is false. True when both operands are true.
  

  a	b	a && b
  false	false	false
  false	true	false
  true	false	false
  true	true	true

• Logical XOR ^^ (not ANSI-C) False when operands are boolean equal. True when operands are not boolean equal. Note that "a^^b" is equivalent to "(a!=0)^(b!=0)".
  

  a	b	a ^^ b
  false	false	false
  false	true	true
  true	false	true
  true	true	false

• Logical OR || False when both operands are false. True when any operand is true.
  

  a	b	a || b
  false	false	false
  false	true	true
  true	false	true
  true	true	true

• Conditional ?: Standard algorithmic if then else. "a ? b : c" means "If a then b else c".
  

  a	b	c	a ? b : c
  true	any	any	b
  false	any	any	c

• Grouping Operators ()[]{} Note that [] and {} are not ANSI-C. These grouping operators are used to either visibly separate sections of your code for readability and maintainability purposes, or to affect the precedence of logical operation. Note that unlike WinHoldem’s grouping syntax, there is no limitation on how the various grouping operators can be nested.

Numeric Constants Floating point constants