Operators

Use abs to calculate the absolute value of a given number.

To calculate the absolute value of a number, use the following syntax:

Use the following argument to specify the number for which you want to calculate the absolute value using the abs Pact function.

The abs function returns the absolute value of the number as a decimal or integer, depending on the input type.

The following example calculates the absolute value of a decimal number in the Pact REPL:

The following example calculates the absolute value of an integer:

Use + to add numbers, concatenate strings and lists, or merge objects.

To add numbers, concatenate strings and lists, or merge objects, use the following syntax:

Use the following arguments to specify the values for addition, concatenation, or merging using the + Pact function.

The + function returns the result of addition for numbers, the concatenated string or list for strings and lists, or the resulting of merging for objects.

The following examples demonstrate how to use the + function to add two numbers in the Pact REPL:

The following examples demonstrate how to use the + function to concatenate strings and lists in the Pact REPL:

The following example demonstrates how to use the + function to merge objects in the Pact REPL:

In this example, merging the object fields using the + function results in the first operand value replacing the corresponding field in the second operand.

Use and? to apply a logical AND operation to the results of applying a specified value to application functions func1 and func2, with short-circuit evaluation.

You can use any data type for the value argument as long as the two functions take that same data type and return the resulting boolean value for the logical AND operation performed by the and? function.

By convention, the data type <a> is used if an argument represents a type-bound parameter like the value argument in this function:

To apply a logical AND operation to the results of applying a specified value to the functions func1 and func2, use the following syntax:

Use the following arguments to specify the functions and value for the and? operation.

The and? function returns a boolean value based on the result of applying value to func1 and func2 with the logical AND operation.

The following example demonstrates how to use the and? function in the Pact REPL:

In this example, the and? function applies the value 15 to the function (> 20), with the result being true because 20 > 15 is true. The function then applies the value of 15 to the (> 10) function, with the result being false because 10 > 15 is false. The result from the and? function, therefore, is false because the second condition is false.

Use and to perform a boolean logic AND operation with short-circuiting.

To perform a boolean logic AND operation between two boolean values oper1 and oper2, use the following syntax:

Use the following arguments to specify the boolean values for the and operation.

The and function returns a boolean value based on the result of the AND operation between the input boolean values.

The following example demonstrates how to use the and function to perform a boolean AND operation between the values true and false in the Pact REPL:

The following example illustrates using the and function to evaluate two expressions to determine whether an account string is valid:

In this example, both expressions must evaluate to true for an account string to be valid.

Use & to compute the bitwise AND operation between the first integer oper1 value and the second integer oper2 value.

To compute the bitwise AND operation between oper1 and oper2, use the following syntax:

Use the following arguments to specify the values for bitwise AND operation using the & Pact function.

The & function returns the result of the bitwise AND operation between oper1 and oper2.

The following examples demonstrate how to use the & function to perform bitwise AND manipulation of integer values in a Pact REPL:

Use | to compute the bitwise OR operation between the first integer oper1 value and the second integer oper2 value.

To compute the bitwise OR operation between the oper1 and oper2 integer values, use the following syntax:

Use the following arguments to specify the integers for the bitwise OR operation using the | Pact function.

The | function returns the result of the bitwise OR operation as an integer.

The following examples demonstrate how to use the | function to perform bitwise OR manipulation between two integers in a Pact REPL:

Use ~ to reverse all bits in the provided integer.

To reverse all bits in an integer x, use the following syntax:

Use the following argument to specify the integer for bit reversal using the ~ Pact function.

The ~ function returns the result of reversing all bits in the provided integer.

The following example demonstrates how to use the ~ function to reverse all bits in the integer 15:

Use ceiling to round up the value of a specified decimal value to the nearest integer or to a specified precision prec as a decimal.

To round up the value of a decimal value to the nearest integer, use the following syntax:

To round up the value of a decimal value to a specified precision as a decimal, use the following syntax:

Use the following arguments to specify the decimal value and optional precision for the ceiling Pact function.

The ceiling function returns the rounded-up value as an integer or as a decimal based on the input and precision.

The following example rounds up a decimal value to the nearest integer in the Pact REPL:

The following example rounds up a decimal value to a precision of 2 decimal places:

In this example, ceiling rounds up the decimal value 100.15234 to a precision of 2 decimal places, resulting in 100.16.

Use dec to convert a specified integer value to a decimal value. This function can be useful if you need to work with decimal values in Pact but have integer inputs.

To convert a specified integer value to a decimal value, use the following syntax:

Use the following argument to specify the integer for the dec Pact function.

The dec function returns the specified integer as a decimal value.

The following example demonstrates how to use the dec function:

Use / to divide the first argument oper1 by the second argument oper2. Note that you can use this function to divide integer values or decimal values. However, you should use the same type for both oper1 and oper2 values.

To divide oper1 by oper2, use the following syntax:

Use the following arguments to specify the values for division using the / Pact function.

The / function returns the result of dividing oper1 by oper2.

The following examples demonstrate how to use the / function to divide two values in a Pact REPL:

Use = to return true if the first argument oper1 is equal to the second argument oper2.

To check if oper1 is equal to oper2, use the following syntax:

(= oper1 oper2)

Use the following arguments to specify the values for comparison using the = Pact function.

The = function returns a boolean value indicating whether oper1 is equal to oper2.

The following example demonstrates how to use the = function to compare two integer values to check if the first value is equal to the second value:

The following example demonstrates how to use the = function to compare two decimal values to check if the first value is equal to the second value:

The following example demonstrates how to use the = function to compare two string values to check if the first string is equal to the second string:

The following example demonstrates how to use the = function to compare two time values to check if the first time is equal to the second time:

The following example demonstrates how to use the = function to compare two object values to check if the first object is equal to the second object:

The following example demonstrates how to use the = function to compare two list values to check if the first list is equal to the second list:

You can also the = function to evaluate variables and expressions. For example:

Use exp to calculate the exponential function of the specified value.

To calculate the exponential function of a value, use the following syntax:

(exp value)

Use the following argument to specify the value for the exp Pact function:

The exp function returns the exponential function of the specified value.

The following example demonstrates how to use the exp function to calculate the exponential value for three and round the result of this calculation to precision of six decimal places:

Use floor to round down the value of a decimal value to an integer, or to a specified precision number of decimal places. The floor function is useful for situations where you need to round down decimal values in Pact contracts.

To round down a decimal value to an integer, use the following syntax:

To round down a decimal value to a specified precision, use the following syntax:

Use the following arguments to specify the decimal value and precision for the floor Pact function:

The floor function returns the rounded-down value of the specified decimal:

The following example demonstrates how to use the floor function to round down the 3.5 decimal value to the nearest integer:

The following example demonstrates how to use the floor function to round down the decimal value 100.15234 to a decimal value with a precision of two decimal places:

The following example uses the floor function in an expression for calculating a royalty payout:

Use >= to returns true if the first argument oper1 is greater than or equal to the second argument oper2.

To check if oper1 is greater than or equal to oper2, use the following syntax:

Use the following arguments to specify the values for comparison using the >= Pact function.

The >= function returns a boolean value indicating whether oper1 is greater than or equal to oper2.

The following example demonstrates how to use the >= function to compare two integer values to check if the first value (1) is greater than or equal to the second value (3):

The following example demonstrates how to use the >= function to compare two decimal values to check if the first value (5.24) is greater than or equal to the second value (2.52):

The following example demonstrates how to use the >= function to compare two string values to check if the first value (abc) is greater than or equal to the second value (def):

Use > to return true if the first argument oper1 is greater than the second argument oper2.

To check if oper1 is greater than oper2, use the following syntax:

Use the following arguments to specify the values for comparison using the > Pact function.

The > function returns a boolean value indicating whether oper1 is greater than oper2.

The following example demonstrate how to use the > function to compare two integer values to check if the first value (1) is greater than the second value (3):

The following example demonstrates how to use the > function to compare two decimal values to check if the first value (5.24) is greater than the second value (2.52):

The following example demonstrates how to use the > function to compare two string values to check if the first value (abc) is greater than the second value (def):

Use <= to return true if the first oper1 argument is less than or equal to the second oper2 argument.

To check if oper1 is less than or equal to oper2, use the following syntax:

Use the following arguments to specify the values for comparison using the <= Pact function.

The <= function returns a boolean value indicating whether oper1 is less than or equal to oper2.

The following example demonstrates how to use the <= function to compare two integer values to check if the first value (1) is less than or equal to the second value (3):

The following example demonstrates how to use the >= function to compare two decimal values to check if the first value (5.24) is less than or equal to the second value (2.52):

The following example demonstrates how to use the >= function to compare two string values to check if the first value (abc) is less than or equal to the second value (def):

Use ln to compute the natural logarithm of a specified value.

To compute the natural logarithm of a value, use the following syntax:

Use the following argument to specify the value for which you want to compute the natural logarithm using the ln Pact function.

The ln function returns the natural logarithm of the specified value.

The following example demonstrates how to use the ln function to computer the natural logarithm for the value of 60 and round the result to 6 decimal places:

Use log to compute the logarithm of the specified value with the specified base.

To compute the logarithm of a specified value with the specified base, use the following syntax:

Use the following arguments to specify the base and value for which you want to compute the logarithm using the log Pact function.

The log function returns the logarithm of value with base base.

The following example demonstrates how to use the log function to computer the logarithm of 256 with base 2:

Use < to return true if the first oper1 argument is less than the second oper2 argument.

To check if oper1 is less than oper2, use the following syntax:

Use the following arguments to specify the values for comparison using the < Pact function.

The < function returns a boolean value indicating whether oper1 is less than oper2.

The following example demonstrates how to use the < function to compare two integer values to check if the first value (1) is less than the second value (3)::

The following example demonstrates how to use the < function to compare two decimal values to check if the first value (5.24) is less than the second value (2.52):

The following example demonstrates how to use the < function to compare two string values to check if the first value (abc) is less than the second value (def):

Use mod to compute the remainder of oper1 divided by oper2.

To compute the remainder of oper1 divided by oper2, use the following syntax:

Use the following arguments to specify the integers for which you want to compute the remainder using the mod Pact function.

The mod function returns the remainder of the division of oper1 by oper2.

The following example demonstrates how to use the mod function to compute the remainder when 13 is divided by 8:

Use * to multiply the first oper1 argument by the second oper12 argument. Note that you can use this function to multiply integer values or decimal values. However, you should use the same type for both oper1 and oper2 values.

To multiply oper1 by oper2, use the following syntax:

Use the following arguments to specify the values for multiplication using the * Pact function.

The * function returns the result of multiplying oper1 by oper2.

The following example demonstrates how to use the * function to multiply two decimal values:

The following example demonstrates how to use the * function to multiply two integer values:

These examples illustrate how to use the * function to perform multiplication operations in Pact, facilitating arithmetic calculations with both integer and decimal values.

Use != to return true if the first oper1 argument does not equal the second oper2 argument. This function allows you to write conditional logic based on whether two values are not equal.

To check if oper1 does not equal oper2, use the following syntax:

Use the following arguments to specify the values for comparison using the != Pact function.

The != function returns true if oper1 does not equal oper2, otherwise false.

The following example demonstrates how to use the != function to check whether two strings are not equal:

In the following example, the != function ensures that the sender and receiver accounts are not equal to prevent the sender initiating a transfer from also being the receiver of the transfer:

Use not? to apply a logical NOT operation to the results of applying a specified value to an application function.

You can use any data type for the value argument as long as the app function takes that same data type and returns the resulting boolean value for the logical NOT operation performed by the not? function.

By convention, the data type <a> is used if an argument represents a type-bound parameter like the value argument in this function:

To apply a logical NOT operation to the results of applying a specified value to an application function app, use the following syntax:

Use the following arguments to specify the application function and the value to be applied using the not? Pact function.

The not? function returns a boolean value representing the logical negation of the result of applying the value to the application function.

The following example demonstrates how to use the not? function in the Pact REPL:

In this example, the application function is (> 20) and the value is 15. Because the expression 20 > 15 evaluates to true, and not? negates this value, the not? function returns false.

Use not to compute the boolean negation of a specified value.

To compute the boolean negation of the specified value, use the following syntax:

Use the following argument to specify the boolean value for which you want to compute the negation using the not Pact function.

The not function returns the boolean negation of the input value.

The following example demonstrates how to use of the not function in the Pact REPL:

In this example, the expression (> 1 2) evaluates to false, and the not function negates this value, resulting in true.

Use or? to apply a logical OR operation to the results of applying a specified value to application functions func1 and func2, with short-circuit evaluation.

You can use any data type for the value argument as long as the two functions take that same data type and return the resulting boolean value for the logical OR operation performed by the or? function.

By convention, the data type <a> is used if an argument represents a type-bound parameter like the value argument in this function.

To apply a logical OR operation to the results of applying a value to two application functions, use the following syntax:

Use the following arguments to specify the functions and the value to be applied using the or? Pact function.

The or? function returns a boolean value representing the logical OR operation after evaluating the results from applying the specified value to the two application functions.

The following example demonstrates how to use the or? function in the Pact REPL:

In this example, the or? function applies the value 15 to the function (> 20), with the result being true because 20 > 15 is true. Because the function performs short-circuit evaluation on the results, the or? function returns true because the first condition is true.

Use or to apply a logical OR operation with short-circuit evaluation.

To perform a logical OR operation with short-circuit evaluation, use the following syntax:

Use the following arguments to specify the boolean values for which you want to perform the logical OR operation using the or Pact function.

The or function returns a boolean value based on the logical OR operation of the input values.

The following example demonstrates how to use the or function in the Pact REPL:

In this example, the or function evaluates the expressions (> 20 10) and (> 10 15). The boolean value returns for the first expression is true because 20 > 15 is true. Because the or function performs short-circuit evaluation on the results, the function returns true because the first expression is true.

Use ^ to raises the oper1 argument to the power of the oper2 argument.

To raise oper1 to the power of oper2, use the following syntax:

Use the following arguments to specify the base and exponent for raising to a power using the ^ Pact function.

The ^ function returns the result of raising oper1 to the power of oper2.

The following example demonstrates how to use the ^ function to raise 2 to the power of 3 in a Pact REPL:

Use shift to perform a bitwise shift operation on the integer oper1 by oper2 bits. If oper2 is positive, this function shifts oper1 to the left. If oper2 is negative, the function shifts oper1 to the right. Right shifts perform sign extension on signed number types, filling the top bits with 1 if oper1 is negative and with 0 otherwise.

To shift the integer oper1 by oper2 bits, use the following syntax:

Use the following arguments to specify the integer values to be shifted using the shift Pact function.

The shift function returns the result of shifting oper1 by oper2 bits.

The following example demonstrates how to use the shift function to shift the integer 255 to the left by 8 bits:

The following example demonstrates how to use the shift function to shift the integer 255 to the right by 1 bit:

The following example demonstrates how to use the shift function to shift the negative integer -255 to the left by 8 bits:

The following example demonstrates how to use the shift function to shift the negative integer -255 to the right by 1 bit:

These examples illustrate how to use the shift function to perform bitwise shift operations on integers in Pact, either to the left or to the right, with sign extension for right shifts on signed numbers.

Use sqrt to compute the square root of the given value.

To calculate the square root of a value, use the following syntax:

Use the following argument to specify the value for which to compute the square root using the sqrt Pact function.

The sqrt function returns the square root of the specified value. The return type depends on the type of the input value and whether the square root for the input value is a whole number.

The following example demonstrates how to use the sqrt function to calculate the square root of the integer value 25 that returns an integer value:

The following example calculates the square root of the decimal value 144.0 that returns a decimal value:

The following example calculates the square root for 48 and rounds the result to four decimal places:

This example illustrates how to use the sqrt function to compute the square root of a value in Pact, producing either an integer or a decimal result.

Use - to negate a value or to subtract oper2 from oper1.

To negate value, use the following syntax:

To subtract oper2 from oper1, use the following syntax:

Use the following arguments to specify the values for negation or subtraction using the - Pact function.

The - function returns the negation of the specified value, or the result of subtracting oper2 from oper1.

The following example demonstrates how to use the - function to negate a value in a Pact REPL:

The following example demonstrates how to use the - function to subtract integer values in a Pact REPL:

Use xor to compute the bitwise exclusive OR (xor) operation between two integer arguments.

To compute the bitwise XOR operation between two integers, use the following syntax:

Use the following arguments to specify the integers for the bitwise XOR operation using the xor Pact function.

The xor function returns the result of the bitwise XOR operation as an integer.

The following examples demonstrate how to use the xor function to compute the bitwise XOR operation between two integers: