Vectors in Drasil

[BilalM04]

Moving the vector content from #3892 here, so it doesn't get lost.

Current State of Vectors

There is currently some vector support in drasil-lang:

• You can declare vectors: vec2D, rowVec, and columnVec.
• Support for some vector operations as well: dim, norm, negVec, cross, vScale, vAdd, vSub, and dot product.

There also seems to be some support for vectors in GOOL, implementing vectors and their operations. This vector test file shows that some vector features are operational in GOOL.

My Work

As a start, I changed the calculation of landing time instance model for projectile to use vectors. I changed it to the following:

flightDur' = exactDbl 2 $* (vec2D (sy launSpeed $* cos (sy launAngle)) (sy launSpeed $* sin (sy launAngle)) $. vec2D (exactDbl 0) (exactDbl 1)) $/ sy gravitationalAccelConst

$${t_{\text{flight}}}=\frac{2\,\begin{bmatrix} {v_{\text{launch}}}\,\cos\left(θ\right)\\ {v_{\text{launch}}}\,\sin\left(θ\right) \end{bmatrix}\cdot{} \begin{bmatrix} 0\\ 1 \end{bmatrix}}{g}$$

From #3892, it was suggested to incorporate vector scaling:

flightDur' = ((exactDbl 2 $/ sy gravitationalAccelConst) `vScale` vec2D (sy launSpeed $* cos (sy launAngle)) (sy launSpeed $* sin (sy launAngle))) $. vec2D (exactDbl 0) (exactDbl 1)

$${t_{\text{flight}}}=\frac{2}{g} \begin{bmatrix} {v_{\text{launch}}}\,\cos\left(θ\right)\\ {v_{\text{launch}}}\,\sin\left(θ\right) \end{bmatrix}\cdot{}\begin{bmatrix} 0\\ 1 \end{bmatrix}$$

---

My approach was to modify one of the instance models using the current vector support. Then, follow the propagation of errors in order to find where it is lacking. I ran into problems at convExpr, which converts Exprs to GOOL values. Here, column vectors and vector operations error out.

From speaking with @B-rando1, my understanding is that GOOL (somewhat?) supports vectors; however, we are lacking the support for converting vectors to GOOL. Additionally convExpr converts Exprs to SValue; however, the vector operations in GOOL expect vectors to be of type VSThunk, which I'm not entirely sure what it is, it has something to do with variables. It doesn't seem to be used for anything in GOOL other than vectors.

Question

How should I go about converting vectors and vector operations into GOOL's representation of them?

[smiths]

Thank you for the summary @BilalM04. We now have a better idea of what has been done and what must be done. The display looks much nice in Projectile with the scalar multiple version of the equation. However, this appears to just be for the display. Do you have a variable of type vector in the revised Projectile?

[BilalM04]

This was briefly discussed in #3913, I will summarize the main points here.

• The instance models for the display and the generated code are created from the same piece of code. So, changing the expression for one, will automatically change it for the other.
• Initially, I declared the entire expression together in one line; however, now I am extracting the vectors into their own models and variables.

[BilalM04]

Update

In Drasil, Instance Models get converted into Calculation functions. I found there to be some limitations in how the calculation functions are currently implemented. genCalFunc takes in a CodeDefinition, and based on its definition type, creates the calculation function.

Drasil/code/drasil-code/lib/Language/Drasil/Code/Imperative/Modules.hs

Lines 507 to 517 in eb5e8eb

	blcks <- case cdef ^. defType
	of Definition -> liftS $ genCalcBlock CalcReturn cdef
	(cdef ^. codeExpr)
	ODE -> maybe (error $ nm ++ " missing from ExtLibMap")
	(\el -> do
	defStmts <- mapM convStmt (el ^. defs)
	stepStmts <- mapM convStmt (el ^. steps)
	return [block (varDec v : defStmts),
	block stepStmts,
	block [returnStmt $ valueOf v]])
	(Map.lookup nm (extLibMap g))

Drasil/code/drasil-code/lib/Language/Drasil/Chunk/CodeDefinition.hs

Lines 13 to 14 in eb5e8eb

	-- | The definition may be specialized to use ODEs.
	data DefinitionType = Definition | ODE

In the code blocks above, there are two possible definition types, ODE and Definition. In the Definition case, the equation is converted to GOOL using convExpr (who's limitations are mentioned in the OP) and returned in a one-line return statement. For the ODE case, the steps for solving an ODE is followed.

The limitation here is that, since vector operations are done across multiple lines (using for loops), we need to be able to create intermediary variables, perform operations, then return the result, which is not currently supported. There is a genCalcBlock helper function, shown below, which has the ability to pattern match on the CodeExpr to provide differing behaviours based on the expression (i.e. a Case statement). However, doing that with vector operations will be difficult as vectors and vector operations are often mixed in with other operations.

Drasil/code/drasil-code/lib/Language/Drasil/Code/Imperative/Modules.hs

Lines 530 to 540 in eb5e8eb

	-- | Generates a calculation block for the given 'CodeDefinition', and assigns the
	-- result to a variable (if 'CalcAssign') or returns the result (if 'CalcReturn').
	genCalcBlock :: (OOProg r) => CalcType -> CodeDefinition -> CodeExpr ->
	GenState (MSBlock r)
	genCalcBlock t v (Case c e) = genCaseBlock t v c e
	genCalcBlock CalcAssign v e = do
	vv <- mkVar (quantvar v) local
	ee <- convExpr e
	l <- maybeLog vv local
	return $ block $ assign vv ee : l
	genCalcBlock CalcReturn _ e = block <$> liftS (returnStmt <$> convExpr e)

[BilalM04]

I was able to generate code for the following Instance Model involving vectors:

Here is the generated Java code:

public static ArrayList<ArrayList<Double>> func_v_launch_vect(InputParameters inParams) {
    return new ArrayList<ArrayList<Double>>(Arrays.asList(new ArrayList<Double>(Arrays.asList(inParams.v_launch * Math.cos(inParams.theta))), new ArrayList<Double>(Arrays.asList(inParams.v_launch * Math.sin(inParams.theta)))));
}

I did have to change the Space -> [CodeType] mapping for vectors from:

Drasil/code/drasil-code/lib/Language/Drasil/Code/Code.hs

Line 26 in eb5e8eb

spaceToCodeType (S.Vect s) = map List (spaceToCodeType s)

to the following:

spaceToCodeType (S.Vect s) = map (List . List) (spaceToCodeType s)

However, doing the above broke the dblpend example. I suspect it is because row vectors / matrices with a single row are implemented with a 1D list, rather than 2D. I am still quite unsure so more investigation is required for that.