To use an integral variable, declare the variable and initialyze it with a natural number of your choice. Here is an example:
let salary = 68000
To use an integral value in a string format when calling sprintf, use either %d or %i in the placeholder. Here is an example:
open System open System.Windows.Forms let exercise = new Form() exercise.Text <- "Exercise" let lblSalary = new Label() lblSalary.Left <- 12 lblSalary.Top <- 18 lblSalary.Width <- 328 let salary = 68000 let result = sprintf "Employee Salary: %d" salary lblSalary.Text <- result exercise.Controls.Add(lblSalary) Application.Run(exercise)
To convert a value to an integer, you can use the int built-in function. Here is an example:
let hourlySalary = int "25"
Remember that, to convert an integral value to a string, call the string function. Here is an example:
open System open System.Windows.Forms let exercise = new Form() exercise.Width <- 235 exercise.Height <- 108 exercise.Text <- "Salary Evaluation" let lblHourlySalary = new Label() lblHourlySalary.Left <- 12 lblHourlySalary.Top <- 22 lblHourlySalary.Width <- 82 lblHourlySalary.Text <- "Hourly Salary:" exercise.Controls.Add(lblHourlySalary) let txtHourlySalary = new TextBox() txtHourlySalary.Left <- 95 txtHourlySalary.Top <- 18 txtHourlySalary.Width <- 40 txtHourlySalary.Text <- "0"- exercise.Controls.Add(txtHourlySalary) let lblYearlySalary = new Label() lblYearlySalary.Left <- 12 lblYearlySalary.Top <- 45 lblYearlySalary.Width <- 82 lblYearlySalary.Text <- "Yearly Salary:" exercise.Controls.Add(lblYearlySalary) let txtYearlySalary = new TextBox() txtYearlySalary.Left <- 95 txtYearlySalary.Top <- 45 txtYearlySalary.Width <- 110 txtYearlySalary.Text <- "0" exercise.Controls.Add(txtYearlySalary) let btnCalculate = new Button() btnCalculate.Left <- 140 btnCalculate.Top <- 16 btnCalculate.Width <- 65 btnCalculate.Text <- "Calculate" let btnCalculateClick e = let hourlySalary = int txtHourlySalary.Text let weeklySalary = hourlySalary * 40 let monthlySalary = weeklySalary * 4 let yearlySalary = monthlySalary * 12 txtYearlySalary.Text <- string yearlySalary btnCalculate.Click.Add(btnCalculateClick) exercise.Controls.Add(btnCalculate) Application.Run(exercise)
Here is an example of executing the program:
When using sprintf, if you want to use the hexadecimal version of any integer, if you want the letters of the number to display in lo wercase, use %x in the placeholder. If you want the letters to display in uppercase, use %X. Here is an example:
open System open System.Windows.Forms let exercise = new Form() exercise.Text <- "Exercise" exercise.Width <- 140 exercise.Height <- 80 let lblNumber = new Label() lblNumber.Left <- 28 lblNumber.Top <- 18 lblNumber.Width <- 228 let number : int = 49298754 let strNumber = sprintf "Number: %X" number lblNumber.Text <- strNumber exercise.Controls.Add(lblNumber) Application.Run(exercise)
This would produce:
To get the number in octal format, use %o.
You may want a variable that can hold small to (very) large negative or positive numbers, such as values between 2,147,483,648 and 2,147,484,647. Such numbers are referred to as signed integers. To indicate this when declaring a variable, specify its data type as int.
When initializing an integral variable, instead of a decimal number, you can also initialize it with a hexadecimal value whose decimal equivalent is less than 2,147,484,647. Here is an example:
let number = 0xF0488EA
When declaring the variable, to indicate that it is an integral type, you can use the int data type. Here is an example:
let salary : int = 68000
An alternative it to call a function named int32.
You may need a variable that can hold a value from -32768 to 32767. When declaring and initialyzing a variable for such a value, add an s on the right side of the value. Here is an example:
let schoolEffective = 1400s
To indicate that your variable will hold values between -32768 to 32767, you can specify its data type as int16. Here are two examples:
let numberOfPages : int16 = 842s let temperature : int16 = -1544s
Because a short integer handles numbers that are larger than the signed byte, any variable you can declare for a signed byte can also be declared using int16.
To convert a value to a short integer, call the int16() function.
A long integer is a small to very large natural number between -9,223,372,036,854,775,808 and 9,223,372,036,854,775,807. To declare a variable that can hold large values, initialize the variable with the desired value. Here is an example:
let population = 72394475
When initializing the variable, to indicate that it represents a long integer, add L to its value. Here is an example:
let population = 72394475L
To indicate the data type of a long integer variable, you can use the int64 data type. Here is an example:
let population : int64 = 72394475L;
If you want to convert a number to a long integer, use the int64() function. To convert a number to an unsigned long integer, call the uint64() function.
A native integer is F#'s own interpretation of natural numbers. To support this, the language has a type named nativeint. To apply that type to a value, when initialydeclaring a variable that will hold values as a native integer. When initializing the variable, add an n suffix to its value.
let number : nativeint = 16n;
To use its value in sprintf, use %d. To convert a value to native integer, call the nativeint() function.
To convert the number an unsigned native integer, call the unativeint() function.
An unsigned native integer is a positive F# integer. To declare a variable for an unsigned native integer, when initializing the variable, add a un suffix to its value. To include the value in sprintf, use %d.
To indicate that a number or a variable is positive, either don't add any operator to it or add + to its left.
To indicate that a number is negative, add a - sign to its left.
Infinity is the highest number that exists. To support it, the F# language provides the infinity keyword. Here is an example of accessing it:
let population = infinity
Integral numbers support all the regular arithmetic operators learned in elementary school:
The F# language supports operations that consist of moving the values, namely 0 or 1, stored in the bits of the computer memory:
A bitwise operation consists of adding or removing (actually replacing or switching) the 1 and 0 values stored in the computer memory: