- Lazy streams
- Simplified and expanded lazy calculations

ShapeLogic 0.9 letter recognition example is still using a different system for declarative programming. More on that later in this post.

To test lazy streams in pure form I tried them on the 10 first mathematical problems in Project Euler. I think that ShapeLogic streams provided for simple solutions to the mathematical problems.

However they are more verbose that say solutions in the Scala language:

http://scala-blogs.org/2007/12/project-euler-fun-in-scala.html

### Solutions to a few of the Project Euler mathematical problems

Project Euler is a list of 178, mathematical problems, that can be solved by computers.#### 1 Add all the natural numbers below 1000 that are multiples of 3 or 5

NaturalNumberStream naturalNumberStream = new NaturalNumberStream(1,999);

ListFilterStream<Integer> filter = new BaseListFilterStream<Integer>(naturalNumberStream) {

public boolean evaluate(Integer object) {return object % 3 == 0 || object % 5 == 0;}

};

SumAccumulator accumulator = new SumAccumulator(filter);

System.out.println(accumulator.getValue());

#### 2 Find the sum of all the even-valued terms in the Fibonacci sequence which do not exceed one million

BaseListStream1<Object,Integer>fibonacci = new BaseListStream1<Object,Integer>(){

{ _list.add(1); _list.add(2);}

public Integer invoke(Object input, int index) {return get(index-2) + get(index-1);}

};

ListFilterStream<Integer> filter = new BaseListFilterStream<Integer>(fibonacci) {

public boolean evaluate(Integer object) { return object % 2 == 0; }

};

SumAccumulator accumulator = new SumAccumulator(filter) {

{_inputElement = 0;}

public boolean hasNext(){ return _inputElement <= theNumber; }

};

System.out.println(accumulator.getValue());

#### More solutions to Project Euler

Here are the next 8 solutions:

10 first solutions to Project Euler in ShapeLogic

10 first solutions to Project Euler as Java unit tests

### Comparison between streams and old declarative constructs

In ShapeLogic 0.8 a cornerstone in declarative programming was a goal driven system of tasks with sub tasks. The letter recognition example reads in a rule database and translated it into goals/tasks with sub tasks. Somewhat like the programming language Prolog.In case of uncertainty the different choices would live in an artificial intelligence choice tree that is tied to the tree of tasks and sub tasks.

### Integrating old declarative constructs with lazy streams

Based on what is needed in the current letter match example. It seems like the stream based approach is simpler and able to handle all the problem that the goal driven approach could.I expect the stream approach to supersede the goal approach.

The rule database will be read and translated to streams. So the rule for the letter A would be translated into a filter that could filter a stream of polygons into a stream of polygons that represent the letter A.

Also currently the rules now are using JEXL to translate a text rule into something executable.

Example:

Rule for letter A: polygon.holeCount == 1.

In ShapeLogic 1.0, you should be able to use Java 6 Scripting, JSR 223, to be able to define these rules, in one of the 25 supported scripting languages. In ShapeLogic 0.9: Groovy, JRuby, and JavaScript was tested with streams, but not with the rule databases.

### Using streams for concurrent programming

Streams can also support parallel or concurrent programming, which is important with the CPU intensive operations in image processing and computer vision. Especially with the advent of cheap multi processor machines.#### Example: Find polygons in a stack of images

You define a lazy data stream for this and set a stream propertyrandomAccess = true

This indicates that individual elements can be calculated independently. The factory creating the stream could create a parallel version of the stream and assign each operation its own thread. Note that the result would be a stream of polygons for each image.

-Sami Badawi