Name: [SOLVED] Csci 3155 : project 2 (lettuce with figs)
Brand: Assignment Chef
SKU: 45701
Price: 25 USD
Availability: InStock
Rating: 5 (1 reviews)

5/5 - (1 vote)

5/5 – (1 vote)

This project extends the Lettuce language with arithmetic, let bindings, function calls and recursive functions with an extra value type: figures. We will augment the language with operations that can allow us to

Draw figures made up of rectangles, lines, triangles and circles.
Place these figures besides each other
Rotate these figures

Your assigment for this project will include:

Complete the interpreter for this language based on the semantics that are provided.
Write some programs to generate some of the example figures shown.

As previously, you are given some code that includes code we have written for Lettuce with arithmetic and Booleans from the notebooks. Your job is to write the missing code. Please read this documentation properly.

Beta Notice: As always, we make up things as we go along. Please feel free to point out ambiguities/ask for clarifications on piazza.

Running the code and submitting

Environment setup is the same as for project 1.

Submission instructions are same as for project 1. Run the command checkAndZipSubmission to create a submission.zip file.

The Language Extension

We will extend Lettuce to allow us to write programs like thus

let a = rectangle(1) in
   let b = circle(0.5) in
      a/b

a is assigned to a rectangle of side length 1 (it will be a square) and b to a circle of radius 0.5. Thus a,b are of type Figures

We will define the division of two figures as placing the figure a on top of figure b.

The result should place a rectangle on top of a circle like thus.

We are using the / operator to operate both on numbers or figures. This is an example of operator overloading.

Likewise we will overload other operators as follows:

Operator	Argument 1 Type	Argument 2 Type	Meaning
+	Number	Number	Add two numbers
+	Figure(f1)	Figure(f2)	Make a composite figure by overlapping the two figures f1, f2
*	Number	Number	Multiply two numbers
*	Figure(f1)	Figure(f2)	Make a composite figure by placing figure f2 to the right of figure f1
/	Number	Number	Division
/	Figure(f1)	Figure(f2)	Place figure f1 on top of figure f2
/	Figure(f1)	Number (d)	Rotate figure f1 around (0,0) by angle d in radians
–	Number	Number	Subtract

Note that all other operations are meaningless. For instance, trying to subtract one figure from other leads to error. Likewise, adding a number to a figure leads to an error.

The table above is going to be very important. Please refer back to it when you interpret the programs below.

What does the program below do?

let f1 = triangle(1) in 
  (f1 * f1)/f1

The star operator places two triangles one besides other and the / operator places a new triangle on top.

The language allows functions as well:

let f = function (x) 
      rectangle(x) * ((triangle(x)/triangle(x)) * circle(x))
      in 
    f(1) + f(2) / f(3)

Can you try interpreting what figure will be generated by the program above?

We will also include recursion and now interesting things happen.


letrec serp = function (x)
       if (x <= 1)
       then (triangle(x)*triangle(x))/triangle(x)
       else (
           let f = serp(x-1) in
               (f * f) / f
            ) in
       serp(5)

Or try this one

letrec mandala = function (x)
    let ang = 3.1415/10 in
    if (x <= 1)
    then rectangle(2)+triangle(2)
    else (rectangle(2)+triangle(2))+(mandala(x-1)/ang)
  in
  mandala(20)

Intrigued? Interested in bringing this language to life? March on forward.

Abstract Syntax of LettuceWithFig

We will have the following abstract syntax borrowed from the language with recursive calls. Note that the key extensions are shown in red.

A program is simply a expression wrapped around the TopLevel constructor.

P r o g r a m \to T o p L e v e l (E x p r)

Expressions are given as follows:

E x p r \to \to \to \to \to \to \to \to \to \to \to \to \to \to \to \to \to \to \to \to \to \to \to C o n s t (D o u b l e) C o n s t B o o l (B o o l e a n) I d e n t (S t r i n g) R e c t a n g l e (E x p r) T r i a n g l e (E x p r) C i r c l e (E x p r) L i n e (E x p r) P l u s (E x p r, E x p r) M i n u s (E x p r, E x p r) M u l t (E x p r, E x p r) D i v (E x p r, E x p r) G e q (E x p r, E x p r) G t (E x p r, E x p r) E q (E x p r, E x p r) N e q (E x p r, E x p r) A n d (E x p r, E x p r) O r (E x p r, E x p r) N o t (E x p r) I f T h e n E l s e (E x p r, E x p r, E x p r) L e t (S t r i n g, E x p r, E x p r) L e t R e c (S t r i n g, S t r i n g, E x p r, E x p r) F u n D e f (S t r i n g, E x p r) F u n C a l l (E x p r, E x p r) Creation of Basic Shapes for Figures Arithmetic Operators are overloaded for figures as discussed previously let bindings recursive definition anonymous function function call

Canvas: A value type for representing figures.

We are first going to define a value type called Canvas. A canvas is going to collect a bunch of shapes with coordinates. We will define some basic operations on canvases:

creating a canvas with a single shape.
bounding box for a canvas.
overlap of two canvases.
placing one canvas on top of another to yield a new canvas.
placing one canvas to the left of another to yield a new canvas.
rotation of a canvas.

A canvas is of the form $C a n v a s ({o_{1}, \dots, o_{n}})$ , wherein $o_{1}, \dots, o_{n}$ are the objects in the canvas. Each object $o_{i}$ is itself one of the following:

$P o l y g o n ({(x_{0}, y_{0}), \dots, (x_{k - 1}, y_{k - 1})})$ : A polygon whose vertex coordinates are specified.
$C i r c l e ((x_{c}, y_{c}), r)$ : A circle with the specified center $(x_{c}, y_{c})$ and radius.

Example of Canvas

Consider a canvas

Canvas ( { 
    Polygon( { (0,0), (1,0), (0.5,0.5) } ) , 
    Circle ( (1,1), 1) , 
    Polygon( { (1,1), (2,1), (2,2), (1,2) }  ) 
    } )

Canvases are going to be a value type for our interpreter along with numbers, booleans, closures and (nominally) error.

Operations on canvas.

Bounding Box of a canvas.

A bounding box for a canvas $c$ is given by $boundingBox (c)$ which is a tuple of $4$ numbers of the form $(x_{min}, x_{max}, y_{min}, y_{max})$ where

$x_{m i n}$ is the smallest $x$ coordinate for any object in the canvas.
$x_{m a x}$ is the largest $x$ coordinate for any object in the canvas.
$y_{m i n}$ is the smallest $y$ coordinate for any object in the canvas.
$y_{m a x}$ is the largest $y$ corrdinate for any object in the canvas.

Once again consider the example canvas from before:

Canvas ( { 
    Polygon( { (0,0), (1,0), (0.5,0.5) } ) , 
    Circle ( (1,1), 1) , 
    Polygon( { (1,1), (2,1), (2,2), (1,2) }  ) 
    } )

Its bounding box is given by $(0, 2, 0, 2)$ with $x_{min} = y_{min} = 0$ and $x_{max} = y_{max} = 2$ .

Translate operation on a canvas

Given a Canvas object $c$ , its translation by $(x S h i f t, y S h i f t)$ is denoted $translate (c, x S h i f t, y S h i f t)$ and yields a new canvas.

The translate operation adds the value xShift to all x coordinates of the object in the canvas and yShift to all y coordinates of the object in the canvas.

Once again consider the example canvas from before:

Canvas ( { 
    Polygon( { (0,0), (1,0), (0.5,0.5) } ) , 
    Circle ( (1,1), 1) , 
    Polygon( { (1,1), (2,1), (2,2), (1,2) }  ) 
    } )

We wish to perform a translation by $(2, 3)$ where xShift = 2 and yShift = 3. The result will be the canvas.

Canvas ( { 
    Polygon( { (2,3), (3,3), (2.5,3.5) } ) , 
    Circle ( (3,4), 1) , 
    Polygon( { (3,4), (4,4), (4,5), (3,5) }  ) 
    } )

Rotation Operation on a canvas.

Given a Canvas object $c$ , its rotation by $θ$ in radians is denoted $rotate (c, θ)$ and yields a new canvas.

Recall from your calculus class that rotating a point $(x, y)$ by angle $θ$ in radians yields

$x^{'} = x \cos (θ) - y \sin (θ), y^{'} = x \sin (θ) + y \cos (θ)$

As an example, let us rotate the canvas from before:

Canvas ( { 
    Polygon( { (0,0), (1,0), (0.5,0.5) } ) , 
    Circle ( (1,1), 1) , 
    Polygon( { (1,1), (2,1), (2,2), (1,2) }  ) 
    } )

by $30^{\circ}$ or $\frac{π}{6}$ radians.

Rotating a canvas is given by rotating each object in the canvas.

Rotating a polygon is given by applying rotation by $θ$ to each vertex
Rotating a circle is given by applying rotation by $θ$ to the center of the circle. Radius is unchanged.

Overlapping one canvas with other.

Let $c 1 : C a n v a s (O_{1})$ with objects in set $O_{1}$ and likewise $c_{2} : C a n v a s (O_{2})$ . We define the canvas

$overlap (c 1, c 2) = C a n v a s (O_{1} \cup O_{2})$

The new canvas has objects which are simply the union of objects from canvases c1 and c2.

Placing one canvas on top of another

The placeTop operator will place one canvas on top of another. Let us consider the operation of placing canvas c2 on top of canvas c1. To achieve this, we are going to first

translate the objects in canvas c2 by a shiftX and shiftY that we will compute.
next we will make a new canvas that combines the objects in both.

Let $c_{1} : C a n v a s (O_{1})$ and $c_{2} : C a n v a s (O_{2})$ be the two canvases. The operation $placeTop (c_{1}, c_{2})$ is defined as follows:

Let $(x_{min, 1}, x_{max, 1}, y_{min, 1}, y_{max, 1})$ be the result of $boundingBox (c_{1})$ .
Let $(x_{min, 2}, x_{max, 2}, y_{min, 2}, y_{max, 2})$ be the result of $boundingBox (c_{2})$ .
Define $x S h i f t = (x_{max, 1} - x_{min, 1}) / 2 - (x_{max, 2} - x_{min, 2}) / 2$ .
Define $y S h i f t = (y_{max, 1} - y_{min, 1})$ .
Let ${\hat{c}}_{2}$ be the canvas obtained by $transate (c_{2}, x S h i f t, y S h i f t)$
Define the result of $placeTop (c_{1}, c_{2}) = overlap (c_{1}, {\hat{c}}_{2})$ .

The calculations above sound somewhat arbitrary but can be easily justified if you look at the figure above.

Placing one canvas to the right of another

The placeRight operator will place one canvas on top of another. Let us consider the operation of placing canvas c2 to the right of canvas c1. To achieve this, we are going to first

translate the objects in canvas c2 by a shiftX and shiftY that we will compute.
next we will make a new canvas that combines the objects in both.

Let $c_{1} : C a n v a s (O_{1})$ and $c_{2} : C a n v a s (O_{2})$ be the two canvases. The operation $placeRight (c_{1}, c_{2})$ is defined as follows:

Let $(x_{min, 1}, x_{max, 1}, y_{min, 1}, y_{max, 1})$ be the result of $boundingBox (c_{1})$ .
Let $(x_{min, 2}, x_{max, 2}, y_{min, 2}, y_{max, 2})$ be the result of $boundingBox (c_{2})$ .
Define $x S h i f t = (x_{max, 1} - x_{min, 1})$ .
Define $y S h i f t = (y_{max, 1} - y_{min, 1}) / 2 - (y_{max, 2} - y_{min, 2}) / 2$ .
Let ${\hat{c}}_{2}$ be the canvas obtained by $transate (c_{2}, x S h i f t, y S h i f t)$
Define the result of $placeRight (c_{1}, c_{2}) = overlap (c_{1}, {\hat{c}}_{2})$ .

The calculations above sound somewhat arbitrary but can be easily justified if you look at the figure above.

Task 1

Implement the canvas operations using the data structures defined in the file MyCanvas.scala. Please follow the given scheme and do not modify existing code.

Your results must pass the unit tests provided under CanvasTests

Interpreting Lettuce With Figs.

We will interpret our language now. We will have the following value types:

NumValue(Double)
BoolValue(Boolean)
Closure(String, Expression, Environment)
FigValue(Canvas)
Error

Note that we will not really consider error and just throw an exception whenever we encounter error.

For your convenience the operations over values are defined in the file Value.scala. Notice some refactoring is happening to help out with implementing the operator.

You may want to modify the functions
- ValueOps.plus, ValueOps.mult, ValueOps.divide, ValueOps.minus and so on.

The semantics of Lettuce with Figs are going to inherit all the existing semantic rules used for handling

arithmetic
booleans
comparisons
function calls
let bindings
recursion
The additional rules need to deal with operations over figures. We provide these rules below.

Semantics of Figs.

The first few rules specify the creation of basic figures.

The rule for a rectangle is as follows:

$\begin{matrix} e v a l E x p r (e, σ) = v, v \in R \\ e v a l E x p r (Rectangle(e), σ) = C a n v a s ({P o l y g o n ({(0, 0), (0, v), (v, v), (v, 0)})}) \end{matrix} (rectangle-ok)$

The rule tells us how to create a rectangle whose side length is given by the expression e. The error rules for this is simple and left to the reader.

The rule for a triangle is as follows:

$\begin{matrix} e v a l E x p r (e, σ) = v, v \in R \\ e v a l E x p r (Triangle(e), σ) = C a n v a s ({P o l y g o n ({(0, 0), (v, 0), (\frac{v}{2}, \frac{\sqrt{3} v}{2})})}) \end{matrix} (triangle-ok)$

Note that the vertex $(\frac{v}{2}, \frac{\sqrt{3} v}{2})$ ensures that the triangle is equilateral.

The rules for a circle and line are as follows:

$\begin{matrix} e v a l E x p r (e, σ) = v, v \in R \\ e v a l E x p r (Circle(e), σ) = C a n v a s ({C i r c l e ((v, v), v)}) \end{matrix} (circle-ok)$

$\begin{matrix} e v a l E x p r (e, σ) = v, v \in R \\ e v a l E x p r (Line(e), σ) = C a n v a s ({P o l y g o n ({(0, 0), (v, 0)})}) \end{matrix} (line-ok)$

The rule for error is simple:

$\begin{matrix} e v a l E x p r (e, σ) = v, v \notin R, T \in {Line, Circle, Rectangle, Triangle} \\ e v a l E x p r (T(e), σ) = e r r o r \end{matrix} (basic-shape-error)$

Overloading Arithmetic Operators on Figures

We will talk about the semantics of arithmetic operators on figures. Here is the helpful table from before.

Operator	Argument 1 Type	Argument 2 Type	Meaning
+	Number	Number	Add two numbers
+	Figure(f1)	Figure(f2)	Make a composite figure by overlapping the two figures f1, f2
*	Number	Number	Multiply two numbers
*	Figure(f1)	Figure(f2)	Make a composite figure by placing figure f2 to the right of figure f1
/	Number	Number	Division
/	Figure(f1)	Figure(f2)	Place figure f1 on top of figure f2
/	Figure(f1)	Number (d)	Rotate figure f1 around (0,0) by angle d in radians
–	Number	Number	Subtract

Rules for arithmetic opertations:

Rule for Plus

$\begin{matrix} e v a l E x p r (e1, σ) = v_{1}, v_{1} \in R, e v a l E x p r (e1, σ) = v_{2}, v_{2} \in R, \\ e v a l E x p r (Plus(e1, e2), σ) = v_{1} + v_{2} \end{matrix} (plus-numbers-ok)$

The rule above is the usual rule for plus. We also have a rule for plus involving figures.

$\begin{matrix} e v a l E x p r (e1, σ) = v_{1}, v_{1} = C a n v a s (O_{1}) e v a l E x p r (e1, σ) = v_{2}, v_{2} = C a n v a s (O_{2}) \\ e v a l E x p r (Plus(e1, e2), σ) = overlap (v_{1}, v_{2}) \end{matrix} (plus-figures-ok)$

We are not writing the error rules. But note that adding any other combination of values other than a number plus number or figure plus figure results in an error.

Rule For Multiplication

$\begin{matrix} e v a l E x p r (e1, σ) = v_{1}, v_{1} \in R, e v a l E x p r (e1, σ) = v_{2}, v_{2} \in R, \\ e v a l E x p r (Mult(e1, e2), σ) = v_{1} \times v_{2} \end{matrix} (mult-numbers-ok)$

The rule above is the usual rule for multiplication of numbers. We also have a rule involving figures.

$\begin{matrix} e v a l E x p r (e1, σ) = v_{1}, v_{1} = C a n v a s (O_{1}) e v a l E x p r (e1, σ) = v_{2}, v_{2} = C a n v a s (O_{2}) \\ e v a l E x p r (Plus(e1, e2), σ) = placeRight (v_{1}, v_{2}) \end{matrix} (mult-figures-ok)$

Note Place the figure generated by e2 to the right of that generated by e1.

Similarly we are skipping error rules that cover all other combinations (other than multiplying a number by a number or multiplying a figure by a figure)

Rule for Division

Division of two numbers (usual rule):

$\begin{matrix} e v a l E x p r (e1, σ) = v_{1}, v_{1} \in R, e v a l E x p r (e1, σ) = v_{2}, v_{2} \in R, v_{2} \neq 0 \\ e v a l E x p r (Div(e1, e2), σ) = v_{1} / v_{2} \end{matrix} (div-numbers-ok)$

Division of one figure by another:

$\begin{matrix} e v a l E x p r (e1, σ) = v_{1}, v_{1} = C a n v a s (O_{1}) e v a l E x p r (e1, σ) = v_{2}, v_{2} = C a n v a s (O_{2}) \\ e v a l E x p r (Div(e1, e2), σ) = placeTop (v_{2}, v_{1}) \end{matrix} (div-figures-ok)$

Note Place the figure generated by e1 on top of that generated by e2.

Division of a figure by a number:

$\begin{matrix} e v a l E x p r (e1, σ) = v_{1}, v_{1} = C a n v a s (O_{1}) e v a l E x p r (e1, σ) = v_{2}, v_{2} \in R \\ e v a l E x p r (Div(e1, e2), σ) = rotate (v_{1}, v_{2}) \end{matrix} (div-figure-number)$

Note Rotate the figure generated by e1 using the angle in radians that expression e2 evaluates to.

Rule for Other Operations

The rules for the other operations, let bindings, function definitions, function calls and recursion remain unchanged.

Task 2: Write the Interpreter

Your job is to fill in the missing code for the interpreter.

The interpreter is defined in the file Interpreter.scala.

The value types are in Value.scala

The environment (for handling recursion as well) is defined in Environment.scala.

You can throw an IllegalArgumentException whenever you encounter an error. A string message should be added to the exception to indicate why you fail.

Reviews

There are no reviews yet.

Only logged in customers who have purchased this product may leave a review.

Whatsapp Us

[SOLVED] Csci 3155 : project 2 (lettuce with figs)