Another powerful Snow Leopard technology, OpenCL (Open Compute Library), makes it possible for developers to efficiently tap the vast gigaflops of computing power currently locked up in the graphics processing unit (GPU). With GPUs approaching processing speeds of a trillion operations per second, they’re capable of considerably more than just drawing pictures. OpenCL takes that power and redirects it for general-purpose computing.

As a matter of interest the Open Source Cryptographic Library — previous holder of the OpenCL name — has recently changed to Botan. Is this possibly at the request of Apple?

Also, an interesting link from MacResearch.org references Nvidia CEO, Jen-Hsun Huang stating Apple knows alot about CUDA are we going to see Apple writing a higher level API on top of CUDA? NSOperation meets the graphics card.

Download a GSL Example project ready for your own code:
XCode 3.0+ GSL Example Project
XCode 2.4+ GSL Example Project

1. Create a new project, I called mine, ‘GSL Project’.
   

2. Choose a default template, New Cocoa application will do nicely.
   

3. Select get info on the project icon. As we need to tell xcode where GSL is.
   

4. Select the native option in the architectures list. Xcode can build dual binaries (DB), however, GSL is only compiled for the native machine, so it it tried to make a DB is will FAIL!
   

5. Type header search paths into the search box. Editing the ‘Header Search Paths’ field, add the following paths.

   
   

6. Next we will do the same process as but for the ‘Library search paths’,

   

7. Now search for ‘other linker flags’ and set the following values,
   
   

8. We are done, but let’s do a test program. Select the main.m file in the File & Groups list. You may need to press the ‘Editor’ button in the button menu to see the contents of the file,
   

9. Select all and replace with some GSL test code, build and run.
   

Make sure that you have the DEBUG build settings active. Have your project in RELEASE mode won’t work (thanks for point that out Paul).

It has been quite slow going with the plotting framework as of late; the trouble with being in the fourth year of a three year PhD! I have decided to rely on Cocoa for as much as possible for the plot above (under the advice of Wil Shipley). I am using NSBezierPath to draw the red dashed line and the filled the circles. NSAffineTransform is used to convert data points from data to screen/view coordinates.

A lot for free

Using NSAffineTransform makes it very easy to position and also alter the points (which themselves are drawn with NSBezierPath) in the view, e.g. rotation of the data points by 23 degrees in the example below. One just needs to specify a ‘data’ coordinate rectangle which is made from the min, max and range of the experimental data set in x and y. A NSAffineTransform is made such that the ‘data’ rectangle is first translated and then scaled to fit into the view bounds. Hmmm I lke ‘tiny code’ …

Drawing lines is made very easy, using NSBezierPath’s setLineDash:count:phase: method. Also, drawing oval/circles comes for free with bezierPathWithOvalInRect: method. So the only really work I have actually done is added bezierPathWithCrossInRect: extension to aid drawing of crosses (shown above)!

Next step…

Next I will add a points-lines plotting style. This will be similar to drawing a dashed lines but will have ovals or crosses, and regular points along it’s length. A nice touch would be to have the rotation of the points follow the gradient of the line; think of the way loops in chain would rotate as of a chain changes direction.

Also, we will implement the code from the first few chocplot plots and have nicley spaced axis labels on the plot.

Now that Cocoa as garbage collection there if a real advantage to using it to allocate buffer. Where before I would have just made a quick malloc statement to get some dynamic memory:
// buffer/dynamic array that holds with 10 doubles
double *x;
x = (double*) malloc(sizeof(double) * 10);
//... sometime later ...
free(x);

Now I find myself doing,
double *x = [[NSMutableData dataWithCapacity:sizeof(double) * 10] mutableBytes];
NSMutableData *buffer = [NSMutableData dataWithCapacity:sizeof(double) * 10];
double *x = [buffer mutableBytes];

Garbage collected buffers; for the lazy at heart.

Tip of the hat to Infurious Blog for pointing out one possible meaning of this error; a missing @end in an Objective-C class header file.

Another possibility for this (this took me an hour to find!) is that you have a curly bracket somewhere in you header file. For example, from cut and pasting your method definition from the implementation file into your header file.

Print a graph from an X Y1 Y2 formatted data file straight from the command line using:

gracebat -nxy datafile.dat

As this is a subclass it still responds to the same methods defined in AxisModel; -interval, -spacing, -start, -stop, -representation, -description

MutableAxisModel adds additional methods designed to give the user some control over the axis properties. These new methods are: -setStart:, -setStop:, -moreIntervals, -fewerIntervals

As one might expect these allow the start and stop to be set exactly; these values will not be rounded like the -initWithStart:stop: values are with AxisModel. The interval positions are still placed at nice rounded intervals but inside these end-points. Using the last two methods in the list allows the number of axis interval (tic marks) can be increased or decreased.

The actual number of intervals afterwards is determined by MutableAxisModel, if it thinks that you have too many (such that adding more would just looked cluttered), it won’t add anymore! The same is true for the opposite case; having to fewer intervals.

There are a few more model classes left before moving on to the Graphical objects. The next post will be about LinkedAxisModel; a subclass of mutable axis model that uses a transform to display the same data but it different units.

Source Code with Documentation (104kB)

Update There were some problems with the original code, but they are all solved now. There were just silly bugs: one variable was a unsigned and should have been an int etc.

I have been quite bored recently so in a search for something to do that was potential useful I ‘wrote up’ some of my recent experiments with rounding axis values. The main problem to solve is how to place tic marks at nice interval along the axis, if your axis doesn’t start with nice rounded numbers. The solution, I hear you say, is to round the the axis start and top values. However this can only be done once the axis spacing is known! Moreover, we cannot find out how to round the axis start and stop values with out knowledge of how we have rounded them!

Axis Definitions

Before we continue let’s make some definitions:

The range is clearly the end minus the start value, NB this is assumed to always be positive, so start must always be less than stop. The spacing is the separation, in axis units, between tic marks. The interval is the number of tic marks placed along the axis.

We can then generate equations which describe; the axis spacing as a function of the range and interval number; and the number of intervals as a function of range and spacing. This is the interdependency that I refereed to previously.

Rounding

The example axis above is fortunate because we started with rounded values. However, what happens if the start value was 0.2 and the stop value was 3.7? We would still want exactly the same spacing. That is, we would want 0.2 to rounded down to 0 and 3.7 to be rounded up to 4.

This can be achieved using ceil() and floor() functions from math.h, along with a guess value for the axis spacing.

Algorithm to find spacing

The number of axis intervals should be some manageable mount, a number less than 4 is too few, while more than 11 is overkill. The basis for finding the rounded axis spacing is to try a few guess spacing and see which one produce intervals in the desired range. There are also a few clues that we can use to quickly find the spacing, and when this is done it takes no more than 6 iteration to acquire the result.

AxisRounding Source Code

The above algorithm is used below in the function MakeSpacing(). Here we get clues for the guess value from looking at the decade of the axis range,

Now we set the guess values. The trick is to scale the guess values to the same range as the axis. The axis decade has been rounded down using floor() and as such we start our search in the lower decade and then more through to the higher one. This range will cover all possible solutions that fall into our tic mark range.

Finally, calculate the number of intervals for the current guess spacing. If this falls into the our desired range for the number of intervals, we return the value.

Please find the source code and documentation of how to use the axis spacing functions in the links above.

Example Use

double start = 400;
double stop = 800;
double spacing = MakeSpacing(start, stop);
unsigned interval = MakeInterval(start, stop);
PrintDescription(start, stop, spacing, interval);

/*
Axis Description:
start = 400
stop = 800
spacing = 50
interval = 9
(400, 450, 500, 550, 600, 650, 700, 750, 800)
*/


Please read the on-line documentation and get the source . Alternatively, download the whole XCode Project.

Example


/*
axis with automatically positioned tic marks but with the number supplied by the user
*/
CPAxisModel *axis = [CPAxisModel axisWithStart:1 stop:10];
NSLog([axis description]);
// (0, 2, 4, 6, 8, 10)