Sample Literals in Visual Basic .NET

Generation Data Matrix 2d barcode in Visual Basic .NET Sample Literals

0us, 19us, 0x0800us 0, 19, 0x0800, 0b0001 0u, 19u, 0x0800u 0L, 19L, 0x0800L 0UL, 19UL, 0x0800UL 0n, 19n, 0x0800n 0un, 19un, 0x0800un 0.0f, 19.7f, 1.3e4f 0.0, 19.7, 1.3e4 0M, 19M, 19.03M 0I, 19I 0N, 19N ()

System.UInt16 System.Int32 System.UInt32 System.Int64 System.UInt64 System.IntPtr System.UIntPtr System.Single System.Double System.Decimal Math.BigInt Math.BigNum Core.Unit

Table 3-2 lists the most commonly used arithmetic operators. These are overloaded to work with all the numeric types listed in Table 3-1. Table 3-2. Arithmetic Operators and Examples

+ * / % -

1 + 2 12 - 5 2 * 3 5 / 2 5 % 2 -(5+2)

1.0 + 2.0 12.3 - 5.4 2.4 * 3.9 5.0 / 2.0 5.4 % 2.0 -(5.4+2.4)

The behavior of these and other operators can be extended for user-defined types, a topic covered in 6. In F#, addition, subtraction, and multiplication over integers are unchecked; that is, if overflow or underflow occurs beyond the representable range, then wraparound occurs. For example, 2147483647 is the largest representable 32-bit integer of the int type: > 2147483647+1;; val it : int = -2147483648 You can access checked versions of arithmetic operators that raise System.OverflowException exceptions by opening the Microsoft.FSharp.Core.Operators.Checked module. If avoiding overflow is a priority, then using the decimal, bigint, and bignum types is recommended. Division by zero raises a System.DivideByZeroException exception, except in the case of floating-point numbers, where it returns one of the special floating-point numbers Infinity and -Infinity. Operator overloading interacts with type inference if a use of an overloaded operator isn t otherwise constrained to work on a particular type, then F# assumes it works on 32-bit integers. To constrain a use of an operator to a particular type, you must give a type annotation that has the effect of telling the compiler the type on the left of the two arguments to the binary operator. For example, in the absence of additional type information, the following function is assumed to work with integers: > let squareAndAdd a b = a * a + b;; val squareAndAdd : int -> int -> int A single type annotation on a is sufficient to indicate that a * a is an operation on float values and thus returns a float value, and that a * a + b is also an operation on float: > let squareAndAdd (a:float) b = a * a + b;; val squareAndAdd : float -> float -> float If you want, you can also give full type annotations for the arguments and return type of a function: > let squareAndAdd (a:float) (b:float) : float = a * a + b;; val squareAndAdd : float -> float -> float

All the integer types listed in Table 3-1 support bitwise manipulations on their underlying representations. Table 3-3 shows the bitwise manipulation operators.

Bitwise and Bitwise or Bitwise exclusive or Bitwise negation Left shift Right shift (arithmetic if signed)

The following sample shows how to use these operators to encode 32-bit integers into 1, 2, or 5 bytes, represented by returning a list of integers. Integers in the range 0 to 127 return a list of length 1: let encode (n: int32) = if (n >= 0 && n <= 0x7F) then [ n ] elif (n >= 0x80 && n <= 0x3FFF) then [ (0x80 ||| (n >>> 8)) &&& 0xFF; (n &&& 0xFF) ] else [ 0xC0; ((n >>> 24) &&& 0xFF); ((n >>> 16) &&& 0xFF); ((n >>> 8) &&& 0xFF); (n &&& 0xFF) ] Here s an example of the function in action: > encode 32;; val it : int32 list = [32] > encode 320;; val it : int32 list = [129; 64] > encode 32000;; val it : int32 list = [192; 0; 0; 125; 0]