Weekly paragraph from Yingfu

Ping Pong Model
This week Yingfu started polishing the Ping Pong model, so that it is a great example for teaching students. We also agreed to add some new features into this model, which include the bat's maximum speed, and maximum energy consumption for bat actuator . Yingfu also started implementing Ping Pong model using Java3D, and developing a comparison between the two different approaches(Acumen,Java3D), identifying in the process their advantages and disadvantages.

Bouncing ball in Yampa

As part of his study of AFRP, Adam has been working on how to idiomatically express the bouncing ball simulation in Yampa. While looking for inspiration online, Adam found a very helpful paper by Henrik Nilsson (Functional Automatic Differentiation with Dirac Impulses) which describes two such implementations in detail.

eXtensible MPEG-4 Textual Format

While Anil started reading The MPEG-4 BOOK and the Web Link,he finds an interesting framework which is presented in the chapter 6 called eXtensible MPEG-4 Textual Format, XMT is a framework for concise yet precisely for creation and maintenance of MPEG-4 multimedia content,by human or by automated machine programs. He finds this framework is an ideal way for creation of multimedia content from  a machine like an Acumen,  XMT uses XML standard as basis for textual representation.He copied the below image from the above given weblink, the image is overview of the MP4 file generated from an XMT framework.

Anil in future planning to figure out does  this XMT framework work's out for the Acumen? If yes how could this be achieved?

Test-driven language design

While making a survey of QuickCheck related papers and property-based testing conferences Jan had the idea of test-driven language design. In essence it applies the test driven development process to language design by having the designers express high-level properties of the language as testable properties that then drive the language specification and implementation work. For example, it would be interesting to see how one could apply this idea in developing a formal specification for Acumen and to then checking for compliance of the current implementations.

The status of testing in Acumen as it is today

The testing suite for the latest Acumen release uses generator-driven property checks for the parser-pretty printer functionality and unit tests for the interpreter implementations. The reference interpreter unit tests check that differential equations are correctly simulated and the parallel interpreter tests check that both implementations produce equal simulations. As shown by Walid and Corky the test code coverage is fairly complete, in particular for the interpreter codes. Jan is investigating the potential for automatically generating acumen models that may be used to complement the interpreter tests with property-based checks.

Floating in Scala

We continued to work on the numeric type classes in Scala. We have implemented instances of Floating (that includes arithmetic operations, trascendental functions, trigonometric functions and the number Pi) for the Scala type Double, for the constructive reals implemented in Java as distributed by Hans Boehm, for symbolic numbers as described by Lennart Augustsson for Haskell, and for the data type that implements automatic differentiation with towers of derivatives as described by Jerzy Karczmarczuk and Lennart Augustsson for Haskell.
The coming week we plan to parameterize the Acumen interpreter on the type of numbers so that we can compare simulations that use Double with simulations that use constructive reals. Later on we would like to explore in what way we can use automatic differentiation in Acumen.

First steps in Arrowized FRP

This week Adam started looking at Arrowized FRP by reading The Yampa Arcade by Courtney, Nilsson and Peterson. Initial efforts to apply the framework by implementing a simple bouncing ball simulation proved to be a challenge. Specifically, an attempt at representing the speed and position of the ball as individual signal functions (arrows mapping signals to signals) was unsuccessful. Adam suspects a mutually recursive relation between speed and position led to an infinite loop upon execution. Judging by the patterns presented in The Yampa Arcade, a better approach is to represent the entire state of the simulation as a data type, making this the input and output of a single signal function.

During the coming week, Adam plans to read Functional Reactive Programming, Continued by Courtney, Nilsson and Peterson, in order to get a broader view of the signal function switching combinators provided by Yampa.