# // IN F SHARP PLEASE //FINISH THE PROGRAM BY FILLING IN BLANKS //===================================

// **IN F SHARP PLEASE**

**//FINISH THE PROGRAM BY FILLING IN BLANKS**

//================================================

//There are 15 tests and 3 output prints from this example

//Each worth 0.5 pt in HW

//Submission is 1 pt in HW

//Correct output:

//T1…Test Success

//…

//T15…Test Success

//The top of the current stack is 3.000000

//The top of the current stack is 27.000000

//The top of the current stack is 6.000000

//================================================

let AssertEquality inputTuple =

match inputTuple with

|(a,b) when a=b -> printfn “Test Success”

|_ -> printfn “Test Fail”

//==============================================

//Build a stack based calculator

//==============================================

//==============================================

// Define types

// ==============================================

//name a stack — regular:

type Stacktest = float list

//Comment out the regular def (line 16)

//name a stack — better:

type Stack = StackContents of float list

//### now test your code

let testStack1=StackContents [1.0;2.0;3.0]

let (StackContents contents)=testStack1 //get the content from a stack using pattern matching

printf “T1…”

AssertEquality (contents, ___)

// ==============================================

// Stack primitives — push pop

// ==============================================

(*

//Push a value on the stack — regular

let push x aStack =

let (StackContents contents) = aStack

let newContents = x::contents

StackContents newContents

//list is immutable so you always add element to the head and return a new list

//Comment out the regular def

*)

// Push a value on the stack — better

//(StackContents contents) is a Stack var being passed over as func input (aStack in the regular version).

//The pattern matching line “let (…)=aStack” is condensed and happens at the input variable line

let push x (StackContents contents) =

StackContents (x::contents)

//### now test your code

let emptyStack = StackContents []

let stackWith1test = push 1.0 emptyStack

let stackWith2test = ___

printf “T2…”

AssertEquality (stackWith2test, StackContents [2.0;1.0])

//If you remember, in F#, we can pass over only 1 var and have a partial func as the return value

//like giving y=5 in f(x,y)=x+y returns function: f(x,5)=x+5

//push takes x and a stack as input variables. We can give x as input var only and have f (defined-x, stack) as return value

let ONE = push 1.0

let TWO = push 2.0

let THREE = ___

let FOUR = ___

let FIVE = ___

let EMPTY = StackContents []

//### now test your code

let stackWith1 = ONE EMPTY

let stackWith2 = ___

let stackWith3 = THREE stackWith2

//You might also remember that those partially defined functions are very useful when building pipes to make your code very concise and easy to read:

let result123 = EMPTY |> ONE |> TWO |> THREE

printf “T3…”

AssertEquality (stackWith3, result123)

//you can also do:

let result312 = ___

printf “T4…”

AssertEquality (result312,StackContents [2.0;1.0;3.0])

// Pop a value from the stack and return it

// and the new stack as a tuple

let pop (StackContents contents) =

match contents with

|top::rest ->

let newStack = StackContents rest

(___ , ___)

|[] ->

failwith “Stack underflow”

//### now test your code

let initialStack = EMPTY |> ONE |> TWO

let popped1, poppedStack = pop initialStack

let popped2, poppedStack2 = pop poppedStack

printf “T5…”

AssertEquality (initialStack,StackContents [2.0;1.0])

printf “T6…”

AssertEquality (poppedStack,___)

printf “T7…”

AssertEquality (popped2,___)

// ==============================================

// Operator core

// ==============================================

//let us do add first:

let ADDtest stack =

let x,s = pop stack //pop the top of the stack

let y,s2 = pop s //pop the result stack

let result = ___ //do the math

push result s2 //push back on the doubly-popped stack

//###test your code

let add12=ADDtest initialStack //list is immutable, so the initialStack is always [2.0;1.0]

printf “T8…”

AssertEquality (add12, StackContents [3.0])

//Similarly, we can define MUL

let MULtest stack =

let ___ //pop the top of the stack

let ___ //pop the result stack

let ___ //do the math

push ___ //push back on the doubly-popped stack

//###test your code

let mul12=MULtest initialStack //list is immutable, so the initialStack is always [2.0;1.0]

printf “T9…”

AssertEquality (mul12, StackContents [2.0])

//Now, you can see that ADD and MUL are super similar since they both use 2 numbers for calc

//We can merge ADD and MUL together to make the code even more concise.

//Define a generic binary math operator:

// pop the top two elements

// do a binary operation on them

// push the result

let binary mathFn stack =

let y,stack' = pop stack

let x,stack'' = pop stack'

let z = mathFn x y

push z stack''

//If we want to do add using this generic binary math func:

let genericBinaryMath12=binary (+) initialStack //This is same to: let ADD aStack = binary (fun x y -> x + y) aStack

//By using partical func, we have a new way of defining ADD and more:

let ADD = binary (+)

let SUB = binary (-)

let MUL = ___

let DIV = ___

//It is an amazingly concise and clear way of defining multiple similar functions sharing the same base func

//Does this sounds like class inherantance to you? Yes, but in a more concise way!

//###Now test your code:

let div3by2 = EMPTY |> THREE|> TWO |> DIV

let sub2from5 = EMPTY |> ___

let sub2from5thenadd1 = ___

printf “T10…”

AssertEquality(div3by2, StackContents [1.5])

printf “T11…”

AssertEquality(sub2from5, StackContents [3.0])

printf “T12…”

AssertEquality(sub2from5thenadd1, StackContents [4.0])

//Similar to the binary operators, we can define the generic unary operator for things like power **

// pop the top element

// do a unary operation on it

// push the result

let unary f stack =

let x,stack' = pop ___

push (f x) stack'

//We can define negative number or square with the unary operator and the partial function

let NEG = unary (fun x -> -x)

let SQUARE = unary (___)

//###Now test your code:

let neg3 = EMPTY |> THREE|> NEG

let square2 = ___

let squareneg3=___

printf “T13…”

AssertEquality(neg3, StackContents [-3.0])

printf “T14…”

AssertEquality(square2, StackContents [4.0])

printf “T15…”

AssertEquality(squareneg3, StackContents [9.0])

// ==============================================

// Other core

// ==============================================

/// Pop and show the top value on the stack

let SHOW stack =

let x,_ = pop stack

printfn “The top of the current stack is %f” x

___ // return the same stack

/// Drop the top value on the stack

let DROP stack =

let _,s = pop stack //pop the top of the stack

___ //return the rest

/// Duplicate the top value on the stack

let DUP stack =

// get the top of the stack

let x,_ = pop stack

// push it onto the stack again

___

/// Swap the top two values

let SWAP stack =

let x,s = pop stack

let y,s' = ___

push y (push x s')

let CUBE =

DUP >> DUP >> ___>> ___

let SUM_NUMBERS_UPTO =

DUP // n

>> ONE >> ADD // n+1

>> ___ // n(n+1)

>> TWO >> ___ // n(n+1) / 2

//Can you see how easy it is to build new functions from already defined functions? The code also looks very clearn and easy to read

//###now test your code

let myStack= EMPTY |> ONE |> TWO |> THREE

let stackTop= myStack |> SHOW

let stackTopEleCubed = myStack |> CUBE |> SHOW

let stackSum=myStack |> SUM_NUMBERS_UPTO |> SHOW

//Referenced F# for fun and profit

## Needs help with similar assignment?

We are available 24x7 to deliver the best services and assignment ready within 3-4 hours? Order a custom-written, plagiarism-free paper

Get Answer Over WhatsApp Order Paper Now