The third way: Xcode templates

When creating an XCode project there are various templates which you use as the basis of you project. For example, if you are doing a command line application but want to you Cocoa foundation classes (NSArray and NSString etc) then you would pick the ‘Command Line Utility -> Foundation Tool’ template. Here we will make a ‘Cocoa Application + GNU Scientific Library’ template, thus solving all the tedium, redundant spotlight searches and cluttered ‘Open Recent File’ menu.

• Download Hogbay Software’s XCode Template Factory
• Download Hogbay Software’s XCode Template Factory (boyfarrell.com link)
• Download my GNU Scientific Library XCode project. Or follow the instructions there and make you own project (this is probably a better idea because the comments section has many helpful instructions on how to fix any problems that my arise).

Assuming that you have extracted the fully functional (Ahh… Natasha Yar, how I miss you late 80s hair styles) XCode project to the Desktop, this screen shot shows you all that needs to be done…

Thank you Hogbay Software!

Duh-mac the new cloud computing service from Apple.

MobileMe sync failed today. I’m sure you’ll want to know why, well the reason was because there was an error. Phew I’m glad we got that one sorted.

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.

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)