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.

Assuming you have a working installation of GNU Scientific Library either from source, Fink or MacPorts, this tutorial will show you how to getting a working XCode project. I am currently using XCode 3.1 but this process hasn’t changed much over the last few years, so will work on older systems.

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 (DBs), however, GSL is only compiled for the native machine, so otherwise it it tried to make a DB is this step 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. Try this test code (slightly modified from the code here):
   
   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.

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)


Line-Endings Xcode Project (24kb)

Un-zip the package on you Desktop, (I have hard coded the link to the test file relative to the users desktop), open the xcode project then build and run.

The code uses a CocoaDev.com NSStringCategory method, -occurencesOfSubstring:, to find the number of line-endings in the file. The file is read using standard NSString methods, queried for the number of times the UNIX, Mac and DOS line-endings occur and the data stored. The line-endings that occur the most is thought to be representative of the whole file and returned.

If you find this useful, please post a comment. Or if you have a better way (simpler way) let me know too!

-(unsigned) hash; and

-(BOOL)isEqual:.

Hashing is a method of increasing the efficiency of lookups for data in collections; this method is used by NSDictionary. The check for equality is also required as it is closely related to the value of the hash. Cocoa assumes that if two objects have the same hash then they must be equal.

In searching the net CocoaDev has a nice page on implementing hash and isEqual which will also point you in the direction of Apple’s original documentaion on the matter.

The basic premise of the above articles is to add 3 methods to your class; hash and isEqual which are overridden inherited methods and isEqualToYourClass:, which it your custom method specific to the class which will be called by the previous method. NB – obviously replace ‘…YourClass:’ with the name of your your class when naming this method!

Apple Conceptual Cocoa Documentation

If you want your objects to be become part of NSDictionary classes then you will need to add the -copyWithZone: method in your class. If your objects only contain primative types such as double, int, BOOL etc. then the copying is fairly straight forward. Override -copyWithZone: method in which you create a new object inside assign the current variables and return it.

However, it is more common to have objects in ones classes in this situation there are different ‘levels’ of copying; ‘shallow’ and ‘deep’. Both require that you return an new object. The difference arrives from how the instance variables are linked to the copy.

In a shallow copy one simply copies the pointers to the original object. This has the consequence of making the data shared.

A deep refers to the process of giving the copy allocating new copies for all (even those inherited) instance variables the object has. This technique is more a ‘snap-shot’ of the state of the object at that particular point in time.

Example Class

If I have an object representing a point in 3D space with primative data types,


@interface DJFPoint : NSObject {
unsigned int x,y,z;
}
- (unsigned int) x;
- (unsigned int) y;
- (unsigned int) z;

- (void) setX: (unsigned int) newX;
- (void) setY: (unsigned int) newY;
- (void) setZ: (unsigned int) newZ;


the most sensible copy is by value.

Override -copyWithZone:

- (id) copyWithZone:(NSZone*) zone{
DJFPoint *copy = [[DJFPoint alloc] init];
[copy setX:[self x]];
[copy setY:[self y]];
[copy setZ:[self z]];

return copy;
}

See the apple article for lots of useful examples on this.