Greg's pick this week is cachedcall by Aslak Grinsted.

Aslak has created an ingenious utility that stores the results to a function call, so that if the same function is called again with the same inputs, it will return the stored results instead of recomputing the answer.

StandardCall FirstCacheCall SecondCacheCall SpeedUp ____________ ______________ _______________ _______ isprime 2.4633 2.4228 0.0036991 99.85 urlread 0.0048197 0.01007 0.0038378 20.372 sim 0.029784 0.034612 0.0038576 87.048

The definition is to store a resource for future use. In computing, it generally refers to storing data in memory in a fashion that it can be rapidly accessed at a later time.

In fact developing algorithms for implicitly creating caches is always one of those areas under research in development.

However, in this particular example, the creation of the cache is explicit.

The simplified version is, for unique instance of a function call, the results of that function call are stored in a file. A data table is developed to link the unique function calls to specific data files. When a function call is applied, CACHECALL determines if that particular function call situation has been performed before. If so, return the stored results, otherwise call the desired function and store the results for later use.

For me, the part I find most fascinating is Aslak is able to develop unique identifiers for each function call situation based on the function, inputs, classes, etc. He actually ends up leveraging another File Exchange entry DataHash by Jan Simon.

The DataHash uses MATLAB's inherent ability to call Java code to develop his hash tables and unique identifiers.

Yes, but generally not based on specific inputs. When a function is called the first time, if it hasn't been used yet in the current MATLAB session, then that function must be loaded into memory. Subsequent calls to the same function require less time because the function is already in memory, but it doesn't store the results of specific computations for future use.

The same thing applies if the function has been edited. It must be reloaded into memory the first time it is called.

Probably not. There is a penalty for the caching process. If the resulting cached results are never used, then that penalty is wasted. Also caching involves writing to disc, which causes the slowdown in the following results.

StandardCall FirstCacheCall SecondCacheCall SpeedUp ____________ ______________ _______________ _______ rand 1.0061 19.194 4.3404 -331.4 triangulation 3.7253e-05 0.0066531 0.0051827 -13812

It probably only makes sense in cases where there are a limited number of input scenarios that will occur multiple times, and takes longer than writing to disc.

That's not always predictable, so it may require some profiling to determine if it's worth the cost of caching.

This is a clever method to speed up repetitive computations when there are a relatively finite number of possible inputs.

I'm impressed that Aslak was able to figure out how to identify unique function calls. When I saw this entry, it was one of those "I wish I had thought of that!" moments.

In addition, Aslak does a nice job of architecting the software and documenting his public interface to the caching features.

Have you tried this out? What do you think about it? Should this type of caching be available in MATLAB?

You can leave your comments here.

Get
the MATLAB code

Published with MATLAB® 8.5

Matt Fig is one of MATLAB Central's top contributors. Even though he's been on hiatus for over two years, he's still the 10th highest contributor on Answers and the 14th most downloaded author on the File Exchange.

My pick today is a contribution of Matt's that made an appearance somewhere in the code base for my Master's thesis. I was working with large 3-dimensional CT images and computation speed was important. Here's what it does:

x = magic(3) xexpanded = expand(x,[3 2])

x = 8 1 6 3 5 7 4 9 2 xexpanded = 8 8 1 1 6 6 8 8 1 1 6 6 8 8 1 1 6 6 3 3 5 5 7 7 3 3 5 5 7 7 3 3 5 5 7 7 4 4 9 9 2 2 4 4 9 9 2 2 4 4 9 9 2 2

As you can see *x* has been expanded thrice along rows and twice along columns ([3 2]). Expand also works along N-dimensional arrays but does
have a limitation that the expansion must match the number of dimensions. This can be circumvented with a second call to
`repmat` to expand along higher dimensions.

The 2-dimensional expand operation has always been possible with `kron`, but it requires creating a ones matrix and, at least back in my grad school era, was slower than `expand`. Since I was working with 3-dimensional images, this was not an option.

xkron = kron(x,ones(3,2))

xkron = 8 8 1 1 6 6 8 8 1 1 6 6 8 8 1 1 6 6 3 3 5 5 7 7 3 3 5 5 7 7 3 3 5 5 7 7 4 4 9 9 2 2 4 4 9 9 2 2 4 4 9 9 2 2

Starting in R2015a, which shipped the first week of March, there is a new function that does the same thing as expand and
more built in to MATLAB: meet `repelem`.

xrep = repelem(x,3,2)

xrep = 8 8 1 1 6 6 8 8 1 1 6 6 8 8 1 1 6 6 3 3 5 5 7 7 3 3 5 5 7 7 3 3 5 5 7 7 4 4 9 9 2 2 4 4 9 9 2 2 4 4 9 9 2 2

And into three dimensions:

xrep3 = repelem(x,3,1,2)

xrep3(:,:,1) = 8 1 6 8 1 6 8 1 6 3 5 7 3 5 7 3 5 7 4 9 2 4 9 2 4 9 2 xrep3(:,:,2) = 8 1 6 8 1 6 8 1 6 3 5 7 3 5 7 3 5 7 4 9 2 4 9 2 4 9 2

`repelem` on a vector can also vary the number of repeats, very nice for building up a vector or run length encoding.

v123 = repelem([2 4 7],1:3)

v123 = 2 4 4 7 7 7

Browsing through the release notes for R2015a and having had the opportunity to beat on the R2015a Prerelease, here are a few of my other favorite new features:

`discretize`- similar to`histcounts`or`histc`but skips the histogram counting part.- Array Size Limitation - Helps accidentally creating large arrays that would cause you to run out of RAM.
- Tab Complete for Object Authoring - Finally!
`ismembertol`and`uniquetol`- ismember and unique with tolerance; these will save me a few calls to`discretize`.

Thanks Matt for providing the `expand` functionality; it has been very useful for nearly 6 years!

Give `expand`, `repelem`, and R2015a a try and let us know what you think about any of them here or leave a comment for Matt.

Get
the MATLAB code

Published with MATLAB® R2015a

Jiro's pick this week is `deploypcode` by Sven.

Sven's no stranger to Pick of the Week. This time, he has created a tool that allows you to easily deploy your MATLAB files
as P-files (protected files). P-files are obfuscated versions of your MATLAB files and are good for hiding the contents of your MATLAB
source code. Note, however, that P-files are not *encrypted* and should not be considered secure.

Sven's `deploypcode` can take the contents of a particular folder and P-code all of the MATLAB files, including files in subfolders. The function
provides a number of additional features, as well. Two of my favorites are the ability to keep the help text and the ability
to copy additional files for easy deployment. For example, let's say that I have some MATLAB files and a data file.

`dir analysis`

. MainAnalysis.m importEnergyFile.m .. createCustomFigure.m Data.csv createEnergyFit.m

I will P-code them and copy the additional data file (Data.csv) into a different folder.

deploypcode('analysis','distrib','copyDirectStrings','.csv')

Analysing "C:\MyStuff\Work\POTW\2015_03_13_DeployP\analysis": (4 .Ms, 1 COPYs, 0 sub-dirs) P-coding FILE: MainAnalysis.m ... MainAnalysis.m (0.000000) done. 424 chars written to help file P-coding FILE: createCustomFigure.m ... createCustomFigure.m (0.000000) done. 125 chars written to help file P-coding FILE: createEnergyFit.m ... createEnergyFit.m (0.000000) done. 324 chars written to help file P-coding FILE: importEnergyFile.m ... importEnergyFile.m (0.000000) done. 485 chars written to help file Copying: Data.csv ... done.

In my 'distrib' folder, I have the P-files, the corresponding MATLAB files (which contain the help text), and my CSV file.

`dir distrib`

. MainAnalysis.p createEnergyFit.p .. createCustomFigure.m importEnergyFile.m Data.csv createCustomFigure.p importEnergyFile.p MainAnalysis.m createEnergyFit.m

For those of you who want to learn some good coding practices, take a look at Sven's code. A few things to mention:

- Thorough help. Just type
`help deploypcode`and you'll learn everything you need to know about the function. - Plenty of error-checking. He guards against potential problems, such as missing source or target folders.
- Robust input parsing. He uses
`inputParser`to deal with various optional arguments. - Use of
`onCleanup`. To ensure that some clean up tasks are performed, even in the case of errors, he uses the`onCleanup`function.

Finally, be sure to check out App Packaging and Toolbox Distribution to learn about other ways to distribute your programs.

**Comments**

Give this a try and let us know what you think here or leave a comment for Sven.

Get
the MATLAB code

Published with MATLAB® R2014b

Posted by Richard Ruff , March 6, 2015 Richard is an Application Engineer at MathWorks focused on the Embedded Coder product for code generation, primarily in the ... read more >>

]]>Posted by **Richard Ruff** , March 6, 2015

*Richard is an Application Engineer at MathWorks focused on the Embedded Coder product for code generation, primarily in the
Aerospace industry.*

Richard's pick this week is plot_subfun by Christopher Pedersen.

My pick this week is the utility function plot_subfun for visualizing the subroutines in a file via a node map.

Have you ever been given a MATLAB file only to spend many hours reading through it to understand the calling structure? If so, this function can save a lot of time by providing a snapshot of the calling structure, thus allowing you to quickly see the interaction between the various subroutines. As the saying goes, a picture is worth a thousand words and this function gives you the picture from the thousand words or five thousand words or ...

The File Exchange submission includes an extensive demo script, 'demo_subfun.m', that provides very detailed examples for using plot_subfun. A basic example is shown here:

`plot_subfun('plot_subfun');`

There are a number of options that allow the user to customize the results generated by plot_subfun. These options are:

**-ends**:*hide functions with one parent and no kids***-ext**:*show calls to external functions in a separate list***-hide**:*hide named functions and their children***-kids**:*same as***-hide**, but only hides the children**-list**:*display list of all functions and their calls to command line***-nest**:*hide nested functions***-noplot**:*do not plot the figure***-trim**:*trims the output to just the visible functions***-unhide**:*hidden functions are shown in grey instead***-unused**:*also show functions that are not called***-unusedonly**:*only show functions that are not called*

I find plot_subfun particularly useful when developing custom UIs in MATLAB as I can quickly see what callbacks are being used and any utility routines that are shared. In addition, it can help point out where missing connections are such as needing to call a specific routine if the user selects an option such as switching between tabs on a UI and updating the data being displayed.

While there is an option to list the extenal functions that are called, I would like to see the option to include a set of files to analyze in order to see the dependency between the functions in multiple files. For Example, I have two files mainUI.m and fillUIPanel.m, I’d like to see this syntax work:

plot_subfun({'mainUI.m', 'fillUIPanel.m'});

Give it a try and let us know what you think here or leave a comment for Christopher.

Get
the MATLAB code

Published with MATLAB® R2015a

Sean's pick this week is For-Each by Jeremy Hughes. My pick this week is a toolbox from our development organization for a for-each loop construct in MATLAB. A for-each... read more >>

]]>Sean's pick this week is For-Each by Jeremy Hughes.

My pick this week is a toolbox from our development organization for a for-each loop construct in MATLAB. A for-each loop allows you to iterate over a set or dimension without having to worry about indexing.

MATLAB actually already has this built in for single elements of numeric arrays:

% Display each element in x for thisfile = [1 pi 8 -3] disp(thisfile) end

1 3.1416 8 -3

This could've course been written with an index like below.

% Display each element in x with an index thisfile = [1 pi 8 -3]; for ii = 1:numel(thisfile) disp(thisfile(ii)) end

1 3.1416 8 -3

But what if we want to traverse every column or slice of a three dimensional array? Or each element in a cell array? Or
each combination of two arrays? This is where Jeremy's `for-each` construct comes in handy since you won't need to worry about indexing.

Let's take a bunch of csv files and make copies of them with just the rows of data we care about. These files contain energy outage information for energy outages in America. Being from New England, I just want the records that correspond to the North East.

% Scrape the data directory for all csv files datadir = '.\Data\'; files = dir([datadir '*.csv']); filenames = {files.name}; disp(filenames)

Columns 1 through 4 '2002Data.csv' '2003Data.csv' '2004Data.csv' '2005Data.csv' Columns 5 through 8 '2006Data.csv' '2007Data.csv' '2008Data.csv' '2009Data.csv' Columns 9 through 12 '2010Data.csv' '2011Data.csv' '2012Data.csv' '2013Data.csv'

% Make a directory for output outputdir = 'NorthEastData'; mkdir(outputdir) % Loop over each filename, read, extract, write for thisfile = each(filenames) % Reach each file Temp = readtable([datadir thisfile]); Temp.Region = categorical(Temp.Region); % Convert to categorical % Identify and extract the northeast records northeast = Temp.Region == 'NorthEast'; Output = Temp(northeast,:); % Make new full file name [~,name,ext] = fileparts(thisfile); outputfile = fullfile(pwd,outputdir,[name '_NorthEast' ext]); % Write out writetable(Output,outputfile) end

Now we can check to make sure it did what we expect.

Personally, I see this being really useful for working with sets of files or images, like I have done above, or for needle in the haystack type problems where I want to find something in a bunch of combinations and stop as soon as I do.

And now for a challenge:

I used the informal interface to this toolbox, i.e. the `each` function, to traverse each file. There is also a formal interface that provides the ability to define your own iterators so that you can traverse objects of your own class or anything else. I will give some MathWorks goodies to anyone who will
write their own `eachFile` iterator that I could use above to recreate what I have.

Please post it below.

The development team is actively looking for feedback on this, so please leave them a comment with any thoughts you have.

Give it a try and let us know what you think here.

Get
the MATLAB code

Published with MATLAB® R2014b

Jiro's pick this week is Decimate Polygon by Anton Semechko. Just a little over a year ago, I wrote a blog post on downsampling polygons. I highlighted Peter's Polygon Simplification. His entry helped me out in one of my side projects I... read more >>

]]>Jiro's pick this week is Decimate Polygon by Anton Semechko.

Just a little over a year ago, I wrote a blog post on downsampling polygons. I highlighted Peter's Polygon Simplification. His entry helped me out in one of my side projects I was working on at the time. Soon after, I received an email from a File Exchange contributor letting me know about another entry for accomplishing the task of downsampling polygons. I appreciate people letting me know about these entries I've overlooked. When I select a file to highlight in my posts I try to do a search on similar entries, but I don't always catch them all.

Let's see how `DecimatePoly` works. I'm going to use the same image I used for my previous post.

```
im = imread('amoeba.png');
imshow(im)
```

As before, I will convert this to black and white and trace out the boundaries using `bwboundaries` from the Image Processing Toolbox. Then I will overlay the largest boundary onto the original image.

im2 = im2bw(im); boundaries = bwboundaries(~im2,'noholes') largest = boundaries{1}; hold on plot(largest(:,2),largest(:,1),'r','LineWidth',2) hold off

boundaries = [1696x2 double] [ 30x2 double] [ 33x2 double] [ 111x2 double] [ 31x2 double] [ 34x2 double]

Currently, the boundary has 1696 vertices.

size(largest)

ans = 1696 2

With `DecimatePoly`, I can downsample this polygon by specifying either the maximum acceptable offset from the original boundary or the fraction
of the total number of points to retain. For example, if I want to ensure the downsampled boundary to be off by maximum of
.1 pixels,

b1 = DecimatePoly(largest, [.1 1]);

# of verts perimeter area in 1695 1948.91 27992.50 out 926 1948.91 27992.50 ----------------------------------------------------- change -45.37% -0.00% 0.00 %

I can see that I have about 45% fewer points while maintaining the same perimeter and area. If I loosen my constraint,

b2 = DecimatePoly(largest, [1 1]);

# of verts perimeter area in 1695 1948.91 27992.50 out 473 1863.07 28046.00 ----------------------------------------------------- change -72.09% -4.40% 0.19 %

I have over 70% fewer points while not sacrificing much change in perimeter or area.

figure subplot(1,2,1) plot(largest(:,2),largest(:,1)) axis image ij subplot(1,2,2) plot(b2(:,2),b2(:,1)) axis image ij

So why is having fewer points preferred? Well, Anton has included a nice demo with his entry that shows improved performance in in-polygon tests. This is one of the plots from the demo.

He looked at how different number of polygon points affected the computation time and the accuracy of in-polygon tests. The horizontal axis (Percent simplification) represents the degree of downsampling. The lower the percent simplification, the greater the downsampling. The Dice coefficient (blue) shows how similar the results are between the downsampled polygon and the full polygon. The closer the value is to 1, the more similar the results. The right axis (red) shows the relative speed up of the computation time compared to the full polygon. We can see that even at around 10% simplification (downsampled by 90%), we are able to get over 98% similarity and 10x speed up.

**Comments**

Do you have a need to downsample polygons? What is your use case? Let us know here or leave a comment for Anton.

Get
the MATLAB code

Published with MATLAB® R2014b

Contact Modeling in SimMechanics Greg's pick this week is Rolling Ball on Plane by Janne Salomäki. Janne put together a nice example of modeling the interaction of a ball contacting a plane, rolling on the plane, and then falling off the plane. Janne uses SimMechanics to model the geometry and motion of the ball... read more >>

]]>Greg's pick this week is Rolling Ball on Plane by Janne Salomäki.

Janne put together a nice example of modeling the interaction of a ball contacting a plane, rolling on the plane, and then falling off the plane.

Janne uses SimMechanics to model the geometry and motion of the ball and the plane. And then applies C-code S-Function to model the interaction between the ball and the plane. Contact modeling isn’t something SimMechanics can do, so I’m excited to see an example that shows the basic concept. I also saw an opportunity to compare using C-code and MATLAB Code to solve this particular problem.

In this particular case, the joint between the ball and the plane has six degrees of freedom, which means there is no restriction on the relative motion between these two bodies. Using this joint enables measurement and actuation of the relative motions between the two bodies, which is essential for modeling the contact interaction.

- Interface Simulink models with other software running on your computer
- Compile an optimized block algorithm to improve performance
- Protect intellectual property
- Integrate existing code into a Simulink model

C-code S-Function |
MATLAB Function |
MATLAB Function (Debugging Disabled) |
---|---|---|

2.15 sec |
2.67 sec |
2.30 sec |

~ |
+24% |
+6.8% |

Leaving the debugging on certainly provides for a much bigger performance hit, but it also means you can step through the code using the MATLAB Debugger. This is a bit more difficult to do when you need to debug the C-code S-Function. I’ll leave it to you to decide if the convenience of the MATLAB Code is worth the hit in performance.

Let us know how you would use it. Do you create S-Functions? What’s one thing you like about them? What’s one thing you dislike about them? You can leave your comments here. Published with MATLAB® 8.4 ]]>

Sean's pick this week is CAD APPS by Larry Silverberg. For this week's pick I'm going to combine my grad school life in structural engineering with the two recent major... read more >>

]]>Sean's pick this week is CAD APPS by Larry Silverberg.

For this week's pick I'm going to combine my grad school life in structural engineering with the two recent major snow storms we've had in New England over the last few weeks. My house has seen about 42 inches of snow. So let's make a quick model of the snow load on my back deck.

I'm going to model this as a Frame. Although it's not an ideal frame by any means, the snow load is distributed on it and not just applied at the ends.

Larry's app allows me to draw the deck interactively (in meters, feet would be nice!)

First I needed to adjust the axes limits:

Next I need to draw the structure. There needs to be a node everywhere I apply a load because there doesn't seem to be a distributed load option. The deck is about 12ft wide with a 3ft cantilever resting about 8ft off the ground.

Then the hard part, figuring out what the load is in terms of Newtons per meter of deck. Being lazy, I only shoveled the outer half of the deck where it was easy to throw the snow off.

psf = 10; % Assume 10 pounds/square foot (lbf/ft^2) width = 2; % 24 inches on center joists = 2ft (ft) ftPerMeter = 3.28; % Feet per meter (ft/m) newtonsPerPound = 0.2248; % (N/m) weightPerMeter = width.*psf.*3.28.*newtonsPerPound; % ft*lbf/ft^2*ft/m*N/lbf = N/m disp(weightPerMeter)

14.7469

And now we simulate and look at the results!

- Max Shear:

- Max Bending Moment:

My wood structural design books are somewhere in my attic at home so I have no idea what percentage of capacity the current snow load is using. But with another 6:10in of snow coming Monday, I probably oughtta clear off the rest of it. Sigh.

Give it a try and let us know what you think here or leave a comment for Larry.

Get
the MATLAB code

Published with MATLAB® R2015a

Jiro's pick this week is findInM by our very own Brett Shoelson. If you know Brett, which you probably do if you've spent any time on MATLAB Central, you know about all the useful File Exchange entries he has contributed. It's no... read more >>

]]>Jiro's pick this week is `findInM` by our very own Brett Shoelson.

If you know Brett, which you probably do if you've spent any time on MATLAB Central, you know about all the useful File Exchange entries he has contributed. It's no surprise he's ranked number 8. Aside from many of the entries related to image processing, he
has uploaded a number of utility functions, and `findInM` is a must-have. The title of the File Exchange entry starts with "FAST, PROGRAMMATIC string searching...", and that's exactly
what it is. It searches for a string of text in MATLAB files, but it's fast and it's programmatic. There are already a number
of entries in File Exchange that searches for a text within files, including `mfilegrep`, `mgrep`, and `grep`. There is also an interactive way of searching from the toolstrip.

From the description of Brett's entry, `findInM` "can be much faster than any other method [he's] seen." The way Brett accomplishes this efficient search is by first creating
an index of the MATLAB files in the folders. This step takes some time, but afterwards, the search happens on the index file
and is very efficient.

In this example, I first created an index of my /toolbox folder (and its subfolders) of my MATLAB installation. Then searching for some text from over 20000 files took less than 10 seconds.

tic s = findInM('graph theory','toolbox') toc

SORTED BY DATE, MOST RECENT ON TOP: s = 'C:\Program Files\MATLAB\R2014b\toolbox\bioinfo\bioinfo\Contents.m' 'C:\Program Files\MATLAB\R2014b\toolbox\bioinfo\biodemos\graphtheorydemo.m' 'C:\Program Files\MATLAB\R2014b\toolbox\matlab\sparfun\Contents.m' 'C:\Program Files\MATLAB\R2014b\toolbox\matlab\sparfun\gplot.m' 'C:\Program Files\MATLAB\R2014b\toolbox\bioinfo\graphtheory\Contents.m' Elapsed time is 8.334972 seconds.

As a comparison, the interactive "Find Files" tool in MATLAB took over 5 minutes to do the same search.

Thanks for this great tool, Brett! I do have a couple of suggestions for improvement.

- Every 7 days, the function prompts the user to see if he/she wants to re-generate the index file. Perhaps this could be somewhat automated if the indexing process captured the state of the files (file sizes, modified dates). It could automatically recommend re-generating the index if it notices a change in the state.
- The index file is a DOC file. It's easy to open/edit a DOC file. It might be better to use a non-standard extension, so that
it can't be accidentally opened and is easily distinguished from a regular DOC file. For example, in Windows, some folders
with images have a thumbnail database called "Thumbs.db". Perhaps
`findInM`can create a file called "mIndex.mi" or something like that.

**Comments**

Give a try and let us know what you think here or leave a comment for Brett.

Get
the MATLAB code

Published with MATLAB® R2014b

Will's pick this week is Genetic Packman by Hanan Kavitz. Here we have a fun application of genetic algorithms. For those of you unfamiliar, a genetic algorithm mimics evolutionary biology by improving the performance of a population of candidate solutions for a particular problem. Candidates have their "fitness" evaluated by defining... read more >>

]]>Here we have a fun application of genetic algorithms. For those of you unfamiliar, a genetic algorithm mimics evolutionary biology by improving the performance of a population of candidate solutions for a particular problem. Candidates have their "fitness" evaluated by defining a quantitative metric for success...the higher (or often lower) the fitness value, the better the solution. Within any given set of possible solutions, some solutions will score better than others. A genetic algorithm seeks better solutions by applying natural selection: the weakest/worst solutions are eliminated while the strongest/best solutions are kept. In a sort of asexual breeding experiment, slight deviations of the best candidates (known as mutants) are created to see if they can be improved upon. By iterating on this strategy of pruning and mutating, the population evolves generation after generation.

Hanan has taken this technique and used it to evaluate paths for his "Packman." Packman is placed at the center of a grid. He can walk north, south, east, or west to the adjacent grid. Each square on the grid is randomly assigned a green or black color. Packman gets a point for every green square he walks over. If he can only make a fixed number of moves, what path should he take to maximize his score?

Hanan's contribution enables you to define the size of the board and number of moves Packman can take. It then evolves a population of 300 paths through 700 generations. It has the option to evaluate the results versus a "greedy" solution that applies a more basic path strategy.

I put Packman in a 40x40 grid and gave him 200 moves. After 5 generations, he scored about 62 points. 695 generations later, he was a lot smarter. The best solution in my population got 95 points. As you run the function, a figure window shows you how the population is doing each generation. In the figure below, the blue dot represents the average score of the entire population, while the black represents the performance of the best solution (scores are negative, so lower is better). As you can observe, pruning and mutating tends to yield better results each generation, but not always.

Let us know what you think here or leave a comment for Hanan.

]]>