• ## Tournament computation in one dimension

In the post on factorial, the following code appears:

```var f = tournamentOp₁.d.n.times (default₁.d.1.n.1 (#!d)) ;;
```

What is going on? Let us look at the definitions from the TransLucid Standard Header:

```fun default₁.d.m.n.val X = Y
where
var Y [d : m..n] = X ;;
var Y [d : nat] = val ;;
end ;;

fun tournamentOp₁.d.n.g X = Y @ [d <- 0]
where
dim t <- ilog.n ;;
var Y = fby.t X (g.(LofPair.d Y).(RofPair.d Y)) ;;
end ;;
```

The default₁ function creates a stream Y varying in dimension d such that in the interval [m,n], the result will be the value of X. Everywhere else, the value of Y is the default val.

As for tournamentOp₁, when #!t ≡ 0, the value of Y is X. When #!t > 0, each element of Y is the result of applying the binary function g to a pair of elements from Y when #!t was one less. This process is completed until there is just one element left. Since the number n is not necessarily a power of 2, we use default₁ to fill in the slots of X with the neutral element of g.

This form of computation is called tournament computation, and writing programs this way encourages parallel implementations.

• ## The intension as first-class value

The origins of Cartesian Programming came from what was called Intensional Programming, in which the behavior of a program was context-dependent: a context is a set of (dimension,ordinate) pairs,
and the program can change behavior if some of the ordinates are changed. Formally, a variable in an intensional programming language is an intension, i.e., a mapping from contexts to values.

In TransLucid, after several failed attempts at defining the semantics of functions over these intensions, it finally dawned on us that the intension itself needs to be a first-class value. What this means is that
the context in which an intension is created is as important as the context in which it is evaluated. Consider:

```var tempAtLocation = ↑{location} temperature ;;
var tempInInuvik = tempAtLocation @ [location ← "Inuvik"] ;;
```

What this means is that whatever the value of the location-ordinate, variable tempInInuvik would always give the temperature in Inuvik, allowing any other dimensions to vary freely. Hence

```↓tempInInuvik @ [location ← "Paris", date ← #!date - 1] ;;
```

would give the temperature in Inuvik yesterday, not in Paris yesterday.

• ## Programming with infinite arrays: Factorial

Here we give an example of programming with infinite arrays. We take the well-known factorial function, and calculate using tournament computation. The TransLucid source code is found below.

We build an array f which varies with respect to dimensions t and d, effectively creating a computation tree. For example, to compute the factorial of 3, the variable f becomes

```    d
t 1 1 2 3 1 1 ...
1 6 1 1 1 1 ...
6 1 1 1 1 1 ...
```

and the answer is 6, picked up when t=2 and d=0.

Similarly, for the factorial of 6, f becomes

```      d
t   1   1   2   3   4   5   6   1   1 ...
1   6  20   6   1   1   1   1   1 ...
6 120   1   1   1   1   1   1   1 ...
720   1   1   1   1   1   1   1   1 ...
```

and the answer is 720, picked up when t=3 and d=0.

When t = 0, the value of f is a d-stream such that f is the current d-index if it is between 1 to n, and 1 otherwise. When t > 0, the value of f is a d-stream such that f is the product of pairs from the (t-1) d-stream.

```fun fact.n = f
where
dim d <- 0 ;;
var f = tournamentOp₁.d.n.times (default₁.d.1.n.1 (#!d)) ;;
end ;;
```

• ## TransLucid preamble

There are now a number of TransLucid examples available at the TransLucid Web site.
All of these examples use the declarations found in the preamble.

• ## Publication archive

To help gather the open problems related to implementing TransLucid,
a publication archive has been prepared. It is available at
http://plaice.web.cse.unsw.edu.au/archive
Included in that archive are the collected works of John Plaice,
Blanca Mancilla and Bill Wadge, along with all of the papers
presented at the International Symposia on Lucid and
Intensional Programming
and the Conferences on
Distributed Communities on the Web
.

• ## The first release of TransLucid is out!

It has taken a long time to come, but the first release of TransLucid,
version 0.1.0, is out. It is available at the following link.

• ## The new C++

The TransLucid interpreter is being written using the new standard C++, called C++11.
For interesting discussions about C++11, I recommend the http://thenewcpp.wordpress.com blog.
For a summary of the current C++11 implementation of the GNU gcc compiler suite, go to http://gcc.gnu.org/projects/cxx0x.html

• ## TransLucid is live and online

The TransLucid interpreter is coming alive. It now implements a full functional programming language. It can be used online at http://translucid.web.cse.unsw.edu.au

• The Go programming Language:

• ## Pretty-printing

How hard is it to have pretty-printing of the header components? All the operators, delimiters and libraries already loaded? Is is reasoble to ask the same for equations?

• It’s all pretty straight forward. It’s just a matter of determining correct interfaces. Is this for tlcore or for the C++ interface?

• The C++ interface.

• #### jarro2783 22:44 on 2010/09/20 Permalink

Printing is pretty easy, I’ll come up with something.

• I’ve done pretty printing of equations in the translator. I haven’t been able to test it though. Have a look at Translator::beginEquation and Translator::endEquation. They return an object which acts like an iterator but also has a print and id function allowing you to print the equation and retrieve the uuid.

c
Compose new post
j
Next post/Next comment
k
Previous post/Previous comment
r