Net (f#) array

.NET (F#) : Array
Dr. Rajeshree Khande

Array Creation
 Arrays are fixed-size, zero-based, mutable collections of
consecutive data elements that are all of the same type
 There are three syntactical ways of creating arrays without
functions −
1. Adding consecutive values between [| and |] and separated
by semicolons.
2. Putting each element on a separate line, in which case the
semicolon is optional.
3. By using sequence expressions.
 Aarray elements are accessed by using a dot operator (.)
and brackets ([ and ])

Array Creation (Method 1 ): using semicolon
separator
Let arr= [| 1; 2; 3; 4; 5; 6 |]
for i in 0 .. arr.Length - 1 do
printf "%d " arr.[i]
Printfn " "

Array Creation (Method 2 ): Without Semincolon
separator
let arr =
[|
1
2
3
|]
printfn " "

Array Creation (Method 3 ): using sequence
let arr = [| for i in 1 .. 10 -> i * i |]
Let arr1=[| for i in 1..20->i*i*i |]
Printfn " "

Accessing Elements from Array
Using a dot operator (.) and brackets ([ and ]).
Example : array1.[0]
 Using slice notation, which allow you to
specify a subrange of the array.

Accessing Elements from Array : Using slice notation,
// Accesses elements from 0 to 2.
arr.[0..2]
// Accesses elements from the beginning of the array to 2.
arr.[..2] default begin pos that is 0
// Accesses elements from 2 to the end of the array
arr.[2..] specify the begin /start pos but
end is default that till the end of array
With slice notation, a
new copy of the array
is created.

Accessing Elements from Array : Using slice notation,
Let arr1 =[|1;2;3;4;5;6;|]
printf “%d” arr.[0..2]
output : [|1; 2; 3;|]
printf “%d” arr.[..4]
arr.[2..]

Array Types and Modules
Library module
Microsoft.FSharp.Collections.Array
supports operations on one-dimensional
arrays.

Array Types and Modules
Simple Functions
1. Array.get gets an element.
2. Array.length gives the length of an
array.
3. Array.set sets an element to a specified
value.
4. Array.Creat

Array Types and Modules :Simple Function
Example
let arr1 = Array.create 10 “ ” //empty array
for i in 0 .. arr1.Length - 1 do
Array.set arr1 i (i.ToString()) //0,1,3,4…
for i in 0 .. arr1.Length - 1 do
printf "%s " (Array.get arr1 ) //retrieve

Functions That Create Arrays
1. Array.empty
2. Array.create
3. Array.init
4. Array.zeroCreate
5. Array.copy
6. Array.sub
7. Array.append
8. Array.chooe
9. Array.concat
10. Array.filter
11.Array.rev

1. Array.empty -- Creates Empty array
2. Array.create ---- Create array with some size &
with default values
3. Array.init : Create an array with size and
inilialised array element with some value ,
generic function/sequence expression
4. Array.zeroCreate : creates an array with 0
inilialization

1. Array.empty creates a new empty array
2. Array.create creates an array of a specified size and
sets all the elements
3. Array.init creates an array, given a dimension and a
function to generate the elements.
4. Array.zeroCreate creates an array in which all the
elements are initialized to the zero value for the
array's type. functions.

Functions That Create Arrays :Example
let myArray = Array.empty
printfn "Length of empty array: %d"
myArray.Length
printfn "Array of floats set to 5.0: %A" (Array.create 10 5.0)
printfn "Array of squares: %A" (Array.init 10 (fun index ->
index * index))
let (myZeroArray : float array) = Array.zeroCreate 10

Functions That Create Arrays :Example
>Array.create 5 "Juliet";;
> val it : string [] = [|"Juliet"; "Juliet"; "Juliet"; "Juliet";
"Juliet"|]

Functions That Create Arrays :Example Output
Length of empty array: 0
Area of floats set to 5.0:
[|5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0|]
Array of squares:
[|0; 1; 4; 9; 16; 25; 36; 49; 64; 81|]

 Array.zeroCreate does allocate the memory, it will
create the array with each item initialized to the
default value,
 whereas Array.init enables you to set the value of
each item.

 Array.zeroCreate makes array of elements of type's
default value
 while Array.init makes array of elements using a
provided generator function to create each.
 You can always implement semantics of
Array.zeroCreate by using a correspondent generator
function of Array.init

Functions That Create Arrays : Array.copy
Array.copy creates a new array and copies the
elements from an existing array.
copy is a shallow copy, means, if
the element type is a reference
type, only the reference is copied,
not the underlying object

Functions That Create Arrays : Array.copy
open System.Text
let firstArray: StringBuilder array = Array.init 3 (fun index -> new StringBuilder(""))
----[| “ “; “ “; “ “;|]
let secondArray = Array.copy firstArray
// Reset an element of the first array to a new value.
firstArray.[0] <- new StringBuilder("Test1") // [| “Test1 “; “ “; “ ;|]
// Change an element of the first array.
firstArray.[1].Insert(0, "Test2") |> ignore
printfn "%A" firstArray
printfn "%A" secondArray

Array.copy Output
[|Test1; Test2; |] firstArray
[|; Test2; |] -----secondArray
• Test1 appears only in the first array, because the operation of
creating a new element overwrites the reference in firstArray but
does not affect the original reference to an empty string that is still
present in secondArray.
• Test2 appears in both arrays because the Insert operation on the
System.Text.StringBuilder type affects the underlying
System.Text.StringBuilder object, which is referenced in both arrays.

Array.sub function
 Array.sub generates a new array from a subrange of
an array.
 Specify the subrange by providing the starting index
and the length.
 Example
let a1 = [| 0 .. 99 |]
let a2 = Array.sub a1 5 10
printfn "%A" a2
[|5; 6; 7; 8; 9; 10; 11; 12; 13; 14|]

Array.sub function
A1
A2
Let A2= Array.copy A1

1. Array.append
2. Array.map
3. Array.mapi
4. Array.filter
5. Array.choose
6. Array.concat
7. Array.rev

Array.append function
 This Method is used to combine two array.
 Example
let arr1 = [| 4; 5; 6; 7; 8; |]
let arr2 = [| 4; 5; 6; 7; 8; |]
printfn " Array3 :%A" (Array.append [| arr1|] [| arr2|])

Array.append function
 Example
let array3 = [| 1; 2; 3; 4|]
let array4 = [| 5 .. 9 |]
printfn "Appended Array:"
let array5 = Array.append array3 array4
printfn "%A" array5

Array.concat function
 Takes a sequence of arrays and combines them into a
single array. The following code demonstrates
Array.concat.
 Example
Array.concat [ [|0..3|] ; [|4|] ]
//output [|0; 1; 2; 3; 4|]
Array.concat [| [|0..3|] ; [|4|] |]
//output [|0; 1; 2; 3; 4|]

What is Difference between
Array.append & Array.concat
?

Array.append Array.concat
Concatenates two array Concatenates list of array
Array.append arr1 arr2 Array.concat [arr1; arr2; arr3;]
Complexity o(n) Complexity o(n + m)
Where
n : length of resulting array
m : length of supplied list

Array.map function
 Takes an array and returns another array of the same
length with the result of applying a function to each
element.
Input A Output B
Length A = Length B

Array.map function
 Takes an array and returns another array of the same
length with the result of applying a function to each
element.
let numbers = [|1..5|]
let squares =
numbers
|> Array.map (fun i -> i * i)
printfn "%A" square

Array.map function
1 2 3 4 5
Fun i -> i * i
1 4 9 16 25

Array.mapi function
 It is similar to map but provide the index of each element.
 Example
let letters = [|'a';'b';'c';'d'|]
letters |> Array.mapi (fun i char -> sprintf "The
letter at index %i is %c" i char)

Array.filter function
 Only returns those elements on which the function
applied returns true.
 Example
let evenNumbers =
numbers
|> Array.filter (fun n -> n % 2 = 0)

Array.choose function
 Only returns those elements on wich the function
applied returns a ‘Some’ result.
Filters and maps an array, returning a new array
consisting of all elements which returned Some
Note : the element type of the array does not
have to match the type of the value returned in
the option type

 Example 1:
let evenNum =
numbers
|> Array.choose (fun n -> if ( n % 2 = 0 ) then
Some(n)
else
None)
printfn “%A” evenNum

 Example 2:
let Num =
numbers
|> Array.choose (fun elem -> if elem % 2 = 0 then
Some(float (elem*elem - 1))
else
None)
printfn “%A” Num
Output
[|3.0; 15.0; 35.0; 63.0; 99.0|]

Array.rev function
 Generates a new array by reversing the order of an
existing array.
 Example 2:
let arr1 = "rohatash".ToCharArray()
printfn " Array3 :%A" (Array.rev( arr1))

type OccupancyStatus =
| Other = 0
| Available = 1
| Occupied = 2
| NeedsRepair = 3
| NotReady = 4
type Apartment = {
UnitNumber : string
Bedrooms : int
Bathrooms : float
SecurityDeposit : int
MonthlyRate : int
Status : OccupancyStatus }

let apartments = [|
{ UnitNumber = "101"; Bedrooms = 2; Bathrooms = 2.00; SecurityDeposit = 650; MonthlyRate = 1150; Status =
OccupancyStatus.Available }
OccupancyStatus.NeedsRepair }
OccupancyStatus.Occupied }
OccupancyStatus.NotReady }
|]
let reversedOrder = Array.rev apartments

Net (f#) array

More Related Content

What's hot (18)

Similar to Net (f#) array (20)

More from DrRajeshreeKhande (19)

Recently uploaded (20)

Net (f#) array