Operators

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

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

(abs number)

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:

In these examples, abs returns the absolute value of the given numbers.

The + function performs addition for numbers, concatenation for strings/lists, or merging for objects.

To perform addition for numbers, use the following syntax:

(+ x y)

To concatenate strings/lists or merge objects, use the following syntax:

(+ x y)

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, concatenation for strings/lists, or merging for objects.

The following examples demonstrate the usage of the + function within a Pact REPL. They perform addition, concatenation, or merging:

These examples illustrate how to use the + function to perform addition for numbers, concatenation for strings/lists, or merging for objects in Pact, facilitating various types of operations.

Use and? to apply a logical AND operation to the results of applying a value to a and b, with short-circuiting.

To apply logical 'and' to the results of applying value to a and b, use the following syntax:

(and? a b value)

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 a and b with the logical AND operation.

The following example demonstrates the and? operation in the Pact REPL:

In this example, the and? function applies the functions > 20 and > 10 to the value 15, resulting in false because the second conditions 10 > 15 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 x and y, use the following syntax:

(and x y)

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 the and operation in the Pact REPL:

In this example, the and function performs a boolean AND operation between the values true and false, resulting in false.

The & function computes the bitwise AND operation between the first argument x and the second argument y.

To compute the bitwise AND operation between x and y, use the following syntax:

(& x y)

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 x and y.

The following examples demonstrate the usage of the & function within a Pact REPL. They perform bitwise AND operations:

These examples illustrate how to use the & function to compute bitwise AND operations in Pact, facilitating bitwise manipulation of integer values.

The | function computes the bitwise OR operation between two integers.

To compute the bitwise OR operation between two integers X and Y, use the following syntax:

(| X Y)

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 the usage of the | function within a Pact script. They compute the bitwise OR operation between two integers:

These examples illustrate how to use the | function to perform bitwise OR operations on integers in Pact, facilitating bitwise manipulation and logic operations.

The ~ function reverses all bits in the provided integer.

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

(~ x)

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 the usage of the ~ function within a Pact script. It reverses all bits in the integer 15:

This example illustrates how to use the ~ function to reverse all bits in an integer in Pact, facilitating bitwise manipulation.

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

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

(ceiling x)

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

(ceiling x prec)

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

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

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

In this example, ceiling rounds up the decimal value 3.5 to the nearest integer, resulting in 4.

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 cast an integer x to a decimal value.

To cast an integer x to a decimal value, use the following syntax:

(dec X)

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

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

The following example demonstrates the dec function:

In this example, (dec 3) is used to cast the integer 3 to a decimal value. The function returns 3.0 as a decimal. This can be useful when you need to work with decimal values in Pact but have integer inputs.

The / function divides the first argument x by the second argument y.

To divide x by y, use the following syntax:

(/ x y)

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

The / function returns the result of dividing x by y.

The following examples demonstrate the usage of the / function within a Pact REPL. They divide two values:

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

The = function returns true if the first argument x is equal to the second argument y.

To check if x is equal to y, use the following syntax:

(= x y)

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

The = function returns a boolean value indicating whether x is equal to y.

The following examples demonstrate the usage of the = function within a Pact REPL. They compare two values to check if the first value is equal to the second value:

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

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

(exp X)

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 the exp function:

In this example, (exp 3) is used to calculate the exponential function of 3. The result of this calculation is then rounded to 6 decimal places. The exp function provides a way to calculate exponential values in Pact contracts.

Use floor to round down the value of a decimal X to an integer, or to a specified precision PREC as a decimal.

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

(floor X)

or

(floor X PREC)

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 examples demonstrate the floor function:

In these examples, (floor 3.5) rounds down the decimal 3.5 to 3, and (floor 100.15234 2) rounds down the decimal 100.15234 to 100.15. The floor function is useful for situations where you need to round down decimal values in Pact contracts.

The >= function returns true if the first argument x is greater than or equal to the second argument y.

To check if x is greater than or equal to y, use the following syntax:

(>= x y)

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

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

The following examples demonstrate the usage of the >= function within a Pact REPL. They compare two values to check if the first value is greater than or equal to the second value:

These examples illustrate how to use the >= function to perform comparison operations in Pact, facilitating logical comparisons between different types of values.

The > function returns true if the first argument x is greater than the second argument y.

To check if x is greater than y, use the following syntax:

(> x y)

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

The > function returns a boolean value indicating whether x is greater than y.

The following examples demonstrate the usage of the > function within a Pact script. They compare two values to check if the first value is greater than the second value:

These examples illustrate how to use the > function to perform comparison operations in Pact, facilitating logical comparisons between different types of values.

The <= function returns true if the first argument x is less than or equal to the second argument y.

To check if x is less than or equal to y, use the following syntax:

(<= x y)

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

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

The following examples demonstrate the usage of the <= function within a Pact script. They compare two values to check if the first value is less than or equal to the second value:

These examples illustrate how to use the <= function to perform comparison operations in Pact, facilitating logical comparisons between different types of values.

Use ln to compute the natural logarithm of X.

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

(ln X)

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 the use of ln in the Pact REPL:

In this example, the natural logarithm of 60 is computed and rounded to 6 decimal places, resulting in approximately 4.094345.

Use log to compute the logarithm of Y with base X.

To compute the logarithm of Y with base X, use the following syntax:

(log X Y)

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

The log function returns the logarithm of Y with base X.

The following example demonstrates the use of log in the Pact REPL:

In this example, the logarithm of 256 with base 2 is computed, resulting in 8.

The < function returns true if the first argument x is less than the second argument y.

To check if x is less than y, use the following syntax:

(< x y)

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

The < function returns a boolean value indicating whether x is less than y.

The following examples demonstrate the usage of the < function within a Pact script. They compare two values to check if the first value is less than the second value:

These examples illustrate how to use the < function to perform comparison operations in Pact, facilitating logical comparisons between different types of values.

Use mod to compute the remainder of X divided by Y.

To compute the remainder of X divided by Y, use the following syntax:

(mod X Y)

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 X by Y.

The following example demonstrates the use of mod in the Pact REPL:

In this example, the remainder of 13 divided by 8 is computed, resulting in 5.

The * function multiplies the first argument x by the second argument y.

To multiply x by y, use the following syntax:

(* x y)

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

The * function returns the result of multiplying x by y.

The following examples demonstrate the usage of the * function within a Pact script. They perform multiplication:

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

The != function returns true if the first argument x does not equal the second argument y.

To check if x does not equal y, use the following syntax:

(!= x y)

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

The != function returns true if x does not equal y, otherwise false.

The following example demonstrates the usage of the != function within the Pact REPL. It checks if two strings are not equal:

This example illustrates how to use the != function to compare values for inequality in Pact, allowing for conditional logic based on whether two values are not equal.

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

To apply logical 'not' to the results of applying a value to an application function app, use the following syntax:

(not? app value)

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 the use of not? in the Pact REPL:

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

Use not to compute the boolean negation of a value.

To compute the boolean negation of X, use the following syntax:

(not X)

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 the use of not in the Pact REPL:

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

Use or? to apply logical 'or' with short-circuit evaluation to the results of applying a value to two application functions.

To apply logical 'or' with short-circuit evaluation to the results of applying a value to two application functions, use the following syntax:

(or? a b value)

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

The or? function returns a boolean value representing the logical 'or' operation with short-circuit evaluation applied to the results of applying the value to the two application functions.

The following example demonstrates the use of or? in the Pact REPL:

In this example, the value 15 is applied to the application functions >(20) and >(10). The logical 'or' operation with short-circuit evaluation is performed on the results, resulting in true.

Use or for boolean logic with short-circuit evaluation.

To perform boolean logic with short-circuit evaluation, use the following syntax:

(or x y)

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 the use of or in the Pact REPL:

In this example, the logical OR operation is performed between true and false, resulting in true.

The ^ function raises the first argument x to the power of the second argument y.

To raise x to the power of y, use the following syntax:

(^ x y)

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 x to the power of y.

The following example demonstrates the usage of the ^ function within a Pact REPL. It raises 2 to the power of 3:

This example illustrates how to use the ^ function to perform exponentiation in Pact, enabling mathematical operations involving powers.

The shift function performs a bitwise shift operation on the integer X by Y bits. If Y is positive, it shifts X to the left; otherwise, it shifts X to the right. Right shifts perform sign extension on signed number types, filling the top bits with 1 if X is negative and with 0 otherwise.

To shift the integer X by Y bits, use the following syntax:

(shift X Y)

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 X by Y bits.

The following examples demonstrate the usage of the shift function within a Pact script.

To shift the integer 255 8 bits to the left:

To shift the integer 255 1 bit to the right:

To shift the negative integer -255 8 bits to the left:

To shift the negative integer -255 1 bit to the right:

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.

The sqrt function computes the square root of the given value X.

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

(sqrt X)

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 matches the type of the input value, either an integer or a decimal.

The following example demonstrates the usage of the sqrt function within the Pact REPL. It calculates the square root of the value 25:

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.

The - function negates the argument x, or subtracts y from x.

To negate x, use the following syntax:

(- x)

To subtract y from x, use the following syntax:

(- x y)

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

The - function returns the negation of x, or the result of subtracting y from x.

The following examples demonstrate the usage of the - function within a Pact REPL. They negate values or perform subtraction:

These examples illustrate how to use the - function to negate values or perform subtraction operations in Pact, facilitating arithmetic calculations with both integer and decimal values.

The xor function computes the bitwise XOR (exclusive OR) operation between two integers.

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

(xor X Y)

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 the usage of the xor function within the Pact REPL. They compute the bitwise XOR operation between two integers:

These examples illustrate how to use the xor function to perform bitwise XOR operations on integers in Pact, facilitating bitwise manipulation and logic operations.