The most socially useful communication technology

Text is the most socially useful communication technology. It works well in 1:1, 1:N, and M:N modes. It can be indexed and searched efficiently, even by hand. It can be translated. It can be produced and consumed at variable speeds. It is asynchronous. It can be compared, diffed, clustered, corrected, summarized and filtered algorithmically. It permits multiparty editing. It permits branching conversations, lurking, annotation, quoting, reviewing, summarizing, structured responses, exegesis, even fan fic.

I read the post “Always bet on text” today and, I must say, it is a beautiful way to look at the process of communicating by writing. :)

Excel trying to take over the world

Intuitively, it is not just the limited capability of ordinary software that makes it safe: it is also its lack of ambition. There is no subroutine in Excel that secretly wants to take over the world if only it were smart enough to find a way.
— Nick Bostrom, *Superintelligence *

I wouldn’t be so certain about it.

There are “scientists” (economists) who think it is OK to use Excel for making predictions that affect several people, as you can see from this article in The Guardian. Essentially, they didn’t add four years of data from New Zealand to a spreadsheet. Other methodological factors were in effect as well. And all of this contributed to lots of people losing their jobs in various countries when the recommended austerity measures were put in place. Imagine if Excel wanted to take over the world.

The paper that discusses in depth about Reinhart & Rogoff’s mistake is “Does High Public Debt Consistently Stifle Economic Growth? A Critique of Reinhart and Rogo ff“.

Completeness and incomputability

It is notable that completeness and incomputability are complementary properties: It is easy to prove that any complete prediction method must be incomputable. Moreover, any computable prediction method cannot be complete — there will always be a large space of regularities for which the predictions are catastrophically poor.

— Ray Solomonoff, “Algorithmic Probability — Its Discovery — Its Properties and Application to Strong AI”

This quote is a paragraph from the book Randomness Through Computation, an amazing work I was reading this morning.

The idea that any computable prediction method can’t be complete is profound for those of us that work with machine learning; it implies we always have to deal with trade-offs. Explicitly considering this makes for a better thought process when designing applications.

References

  1. Ray Solomonoff — Wikipedia.
  2. Solomonoff’s Lightsaber — Wikipedia, LessWrong

Books so far in 2014

I have a lot of books.

I’ve finally decided to organize my collection and keep track of what I read. In this post, I’ll list the books I read since January — or at least an approximation given by the email confirmations of the ebooks I bought, my memory and the ones in my bookshelf. I also divided them in sections. Papers are included as well.

Continue reading

Updates on NMatrix and SciRuby development

For the last couple of days, I’ve been thinking about what I wrote two weeks ago regarding SciRuby and the whole Ruby scientific computing scene. I still believe that the sciruby gem can be used as an integrated environment, but there are some problems that must be solved before:

  1. We need a reasonably feature complete and easy to install version of NMatrix.
  2. A good plotting tool. Right now, Naoki is working on this as part of GSoC 2014.
  3. Statistics. Lots of things are already implemented in Statsample, but both Statsample::DataFrame and Statsample::Vector should use NMatrix behind the hood. Supporting JRuby can be problematic here…
  4. Given 1 and 2, it’s possible to implement a lot of other interesting and useful things. For example: linear regression methods, k-means clustering, neural networks, use NMatrix as a matrix type for OpenCV images. There are lots of possibilities.
  5. Minimization, integration and others.

With that in mind, my objective for the following weeks is to improve NMatrix. First, there are BLAS routines (mainly from level II, but some stuff from level I and III as well) that aren’t implemented in NMatrix and/or that aren’t available for the rational and ruby objects dtypes. There’s also LAPACK.

Another benefit of having complete C/C++ implementations is that we’ll eventually have to generalize these interfaces to allow other implementations (e.g. Mac OSX vecLib’s LAPACK, Intel’s MKL), thus making it much easier to install NMatrix. As Collin (and, I think, Pjotr) said in the sciruby-dev mailing list, it should be as easy as gem install nmatrix.

BLAS and LAPACK general implementations

  • HAVE_CBLAS_H being derived from mkmf‘s have_header
  • Many more routines are implemented. Ideally, BLAS level 1 and 2 should be complete by the end of May.

An important next step is to be able to link against arbitrary BLAS and LAPACK implementations, given that they obey the standard. Issue #188 started some ideas; issue #22 is the original (and very old) one.

After that…

When NMatrix support both BLAS and LAPACK without a problem — i.e. have its own implementation and can also link against arbitrary ones (OSX’s vecLib, GSL, ATLAS, Intel’s MKL, AMD’s Core Math Library) — we’ll be able to build on top of it. There are some routines in NMatrix that are already working with every dtype, but most of them aren’t. When we know exactly which routines can’t work with which dtypes, we’ll reach a very good standpoint to talk about what we support.

Alright, we have determinants for rational matrices, but not “other operation”, etc. What else? STYPES! We also need to have good support for Yale matrices. (obs: maybe add “old Yale” format?)

There isn’t much to do: we have to support the whole BLAS/LAPACK standard, almost everything linear algebra-wise is in these. After that, it’s mostly improvements to the interface, better method naming, better documentation and examples, better IO, etc.

Another point that would be good to adress is to remove the dependency of g++ > 4.6. We should strive to remove everything that depends on C++11 features, thus allowing normal Mac OSX users to install NMatrix without having to first install another compiler.

Better documentation

We need to refactor our documentation. Oh, how we need to!

First, remove everything that shouldn’t be in the facing API — the classes and modules used in NMatrix::IO shouldn’t be available in the public API anyway, only the outside-facing stuff: how to save and load to/from each format. Probably more things as well.

Second, do a better job of being consistent with docs. There are some methods without a return type or stuff like that. Lots of methods in the C/C++ world aren’t documented as well. We can do better!

Finally, a really good documentation template. Fivefish is a good choice — it provides a very pretty, searchable and clean interface. (create NMatrix’s docs with it and host on my own server, see what happens).

Solving linear systems in NMatrix

I’m writing some guides for NMatrix, so in the following weeks there should be some posts similar to this one, but more complex.

Linear systems are one of the most useful methods from “common algebra”. Various problems can be represented by them: systems of linear ODEs, operations research optimizations, linear electrical circuits and a lot of the “wording problems” from basic algebra. We can represent these systems as

Ax = b

Where A is a matrix of coefficients and b a vector representing the other side of the equation.

Continue reading

Gems for scientific computing

UPDATE (20/04): User centrx from #ruby-lang at freenode warned me that I forgot about RSRuby/RinRuby, so I added them to projects.yml.

In Wicked Good Ruby 2013, Bryan Liles made a presentation about Machine Learning with Ruby. It’s a good introduction to the subject and he presents some useful tricks (I didn’t know about Grapher.app, for example). But the best advise I could get is that there’s a lot of room for improvement in the Ruby scientific computing scene.

Having contributed to some SciRuby projects in the last year, I’ve seen it first-hand. With NMatrix, it’s possible to do a lot of vector and matrix calculations easily, if you know how to install it — a task that’s much easier today. There are statsample for statistics, distribution for probability distributions, minimization, integration, the GSL bindings and others. But if you need plotting, it can be pretty hard to use (e.g. Rubyvis) or depend on external programs (Plotrb outputs SVG files). Do you want an integrated environment, like MATLAB or Pylab? There isn’t one.

Searching for more instances of people interested in the subject, I found a presentation about neural networks by Matthew Kirk from Ruby Conf 2013, an Eurucamp 2013 presentation by Juanjo Bazán and slides from a presentation by Shahrooz Afsharipour at a German university. If we needed any confirmation that there are folks looking for SciRuby, here’s the evidence.

What can be done

In order to address these problems, I’m trying to come up with concrete steps towards creating a scientific community around Ruby. It’s obvious we need “more scientific libraries”, but what do we already have? What is easy to install and what isn’t? Should we create something new or improve what we have?

Also, I’m mapping the Ruby scientific computing landscape. I’ve compiled a YAML file with a list of the projects that I’ve found so far. In the future, this could be transformed in a nice visualization on sciruby.org to help scientists find the libraries they need.

If you know how to use the R programming language, both RSRuby and RinRuby can be used. They’re libraries that run R code inside of Ruby, so you can technically do anything you’d do with R in Ruby. This is suboptimal and R isn’t known for its speed.

For an integrated environment, we can revive the sciruby gem. For example:

I’m updating the SciRuby repository in this branch. Before creating the above DSL, it’s necessary to remove a lot of cruft (e.g. should use bundler/gem_tasks instead of hoe) and add some niceties (e.g. Travis CI support). Most importantly, adding dependency to the main SciRuby projects — NMatrix, statsample, minimization, integration, etc — in order to have a real integrated environment without require’ing everything manually. I’ll probably submit a pull request by next week.

We also need to improve our current selection: NMatrix installation shouldn’t depend on ATLAS, plotrb (or other solution) needs to be more usable, show how IRuby can be used to write scripts with nice graphics and LaTeX-support and create a list of all the applications that use our libraries for reference.

The Ruby Science Foundation was selected for Google Summer of Code 2014, thus some very bright students will help us fix some of these problems during the summer. However, there’s a lot to be done in every SciRuby project, if you’ve got the time. :)

Conclusion

We still have a long way before having a full-fledged scientific community — but there’s hope! Some areas to look at:

  • Good numerical libraries: NMatrix, mdarray.
  • Algorithms for data mining, modeling and simulations: AI4R, ruby-fann, ruby-libsvm, statsample, distribution, etc.
  • Plotting: Rubyvis is a port of Protovis, which was deprecated in favor of
    D3js. Thus, we should create some plotting library around a C backend or
    around D3, like Plotrb.
  • Integrated environment: IRuby together with SciRuby.

Except for plotting, an area that really needs a lot of love and care, most of these are already working, but with usability problems (installation, mostly).

If you think that it’d be cool to have a scientific community centered around Ruby and you do have some time available, please please please:

  1. Take a look at the SciRuby repositories.
  2. If there’s a subject you’re interested in, see if you can refactor something, add more tests, well, anything.
  3. Open issues about new features or pull requests improving the current ones.
  4. If you don’t understand much about the subject, but see something that could be improved, do it: is there Travis CI support? Something wrong with the gemspec? Is it still using some gem to generate gemspecs?
  5. There’s the sciruby-dev mailing list and the #sciruby channel on Freenode if there’s something you want to ask or discuss.

You can find me as agarie on freenode or @carlos_agarie on twitter.

References

  1. SciRuby. SiteGitHub
  2. List of scientific computing projects in Ruby. projects.yml
  3. Wicked Good Ruby 2013. Site
  4. Bryan Liles: Machine Learning with Ruby. bryan
  5. Matthew Kirk: Test-driven neural networks with Ruby. neural
  6. Shahrooz Afsharipour: Ruby in the context of scientific computing. slides in PDF
  7. Juanjo Bazán: presentation in Eurucamp 2013. juanjo-slides

A PNG showing differently in Firefox and Chrome

I was chatting with some friends on IM when someone posted an URL to a Psyduck image. In it said “Now open this in Firefox” when opened in Google Chrome or Safari and “Now open this in IE (or Chrome/Safari)” when opened in Firefox.

Psyduck

What.

At first, I though it would be a simple use of pattern matching against HTTP’s User-Agent on the server to send two different PNG files depending on the browser. However, both files had the same size and I couldn’t reproduce it with curl. Worse: I downloaded the file and the same behavior was present, so it should be something with the image itself.

I never really studied or read about binary file formats before, so I googled a bit and installed the chunkypng gem. After playing a bit with its documentation, I could see which blocks it had.

>> require 'chunky_png'
>> q = ChunkyPNG::Datastream.from_file "psyduck.png"
>> q.each_chunk {|chunk| p chunk.type}
"IHDR"
"acTL"
"fcTL"
"fdAT"
"fdAT"
"fdAT"
"fdAT"
"fdAT"
"fdAT"
"fdAT"
"fdAT"
"IDAT"
"IDAT"
"IDAT"
"IDAT"
"IDAT"
"IDAT"
"IDAT"
"IDAT"
"IEND"
>> q.each_chunk { |chunk| if chunk.type == "acTL" then p chunk end }
#<ChunkyPNG::Chunk::Generic:0x0000010160f570 @type="acTL",
  @content="\x00\x00\x00\x01\x00\x00\x00\x01">

Can you see the acTL block? It isn’t in the PNG specification. Why is it there? After some more searching, it was clear that this block is only available in APNG files, an extension to PNG enabling animated images similar to GIF.

The first byte @content of the acTL block is the number of frames (only 1) and the second one is how many times to loop the APNG
(source). From the spec, there’s always a “default image” (described by the IDAT blocks, exactly like a normal PNG file), thus this extra frame should be the second Psyduck image.

To confirm this hypothesis, I installed pngcrush with Homebrew and removed the acTL block:

$ brew install pngcrush

# Remove the `acTL` block from psyduck-original.png.
$ pngcrush -rem acTL psyduck-original.png psyduck-no-animation.png

I ended up with an image that will look the same independent of the host browser:

Altered Psyduck

Search a bit more lead me to the cause of the discrepancy: only Firefox and Opera have support for APNG files! From this post in Google’s Products forum and this ticket in Chromium’s issue tracker, WebKit/Chrome doesn’t support the format and probably won’t for some time. Also, from the spec:

APNG is backwards-compatible with PNG; any PNG decoder should be able to ignore the APNG-specific chunks and display a single image.

Take all that and the mystery is solved: when that image is opened in Firefox (or Opera), it’s treated as an APNG and the second frame is shown. In Chrome/Safari (WebKit), the extra blocks are ignored and the default image is shown.

That was fun.

References

  1. PNG specification
  2. APNG specification

Cross validation in Ruby

These days I had some data mining problems in which I wanted to use Ruby instead of Python. One of the problems I faced is that I wanted to use k-fold cross validation, but couldn’t find a sufficiently simple gem (or gist or whatever) for it. I ended up creating my own version.

A review of k-fold cross validation

A common way to study the performance of a model is to partition a dataset into training and validation sets. Cross validation is a method to assess if a model can generalize well independent of how this separation is decided.

The method of k-fold cross validation is to divide the dataset into k partitions, select one at a time for the validation set and use the other k – 1 partitions for training. So you end up with k different models, and respective performance measures against the validation sets.

The image below is an example of one fold: the k-th partition is left out for validation and partitions 1, …, k-1 are used for training.

k-fold cross validation

E.g., if k = 5, you end up with 80% of the dataset for training and 20% for validation.

The implementation

My solution is a function that receives the dataset, the number of partitions and a block, responsible for training and using the classifier in question. Most of it is straightforward, just keep in mind that the last partition (k-1-th) should encompass all the remaining elements when dataset.size isn’t divisible by k. Obviously, the training set is defined by the elements not in the validation set.

def cross_validate(dataset, k)
  partition_size = (dataset.size / k.to_f).floor

  partitions = (0 .. k-1).to_a.map do |i|
    if i == k-1
      (partition_size * i) .. dataset.size - 1
    else
      (partition_size * i) .. (partition_size * (i + 1) - 1)
    end
  end

  partitions.each_with_index do |partition, i|
    validation = dataset[partition]
    training = (partitions - [partition]).reduce([]) do |acc, part|
      acc + dataset[part]
    end

    # Let the classifier do its work...
    yield training, validation
  end
end

The last part is to yield both sets to the given block. Some information regarding the functionality of the yield keyword can be seen in another post and in Ruby core’s documentation.

Now suppose you have a CSV file called “dataset.csv” and you have a classifier you want to train. It’s as easy as:

require 'csv'

DATASET = CSV.read("dataset.csv")

cross_validation(DATASET, 5) do |training, validation|
  # Train your classifier with `training`.
  # Calculate the performance of the classifier on `validation`.
end

And your classifier’s code is totally decoupled from the cross validation function. I like it.

Conclusion

I found a gem on GitHub the other day unsurprisingly called cross validation. Its API is similar to scikit-learn‘s, which I find particularly strange. Too object oriented for me.

This code isn’t a full-blown gem and I don’t think there should be one just for cross validation. It fits in a whole machine learning library, though–and I hope to build one based on NMatrix… eventually.

MATLAB in OS X Mountain Lion

I needed to write an optimization function for college and came across this problem today: if you use OS X Mountain Lion (I think the problem also happens in Lion and < 10.6), your MATLAB should stop working correctly after a Java update that occurred in June. Well, Java.

The problem lies with a bug packed in the Java Security Update released by Apple. For some reason, the corresponding fix isn’t automatically downloaded by the App Store, so we must do it manually1. This bug interferes with MATLAB’s graphical user interface, making it unusable.

It’s pretty easy: go to support.apple.com/kb/DL1572 and download the update. Then, just install and open MATLAB.

Another “solution” is to run MATLAB without its GUI by using:

$MATLAB/bin/matlab -nodesktop

Where $MATLAB is the installation directory, for example in /Applications/MATLAB_R2009b.app/.

Moral: don’t leave some computer-based homework for the last day when it depends on Java.

  1. http://www.mathworks.com/matlabcentral/answers/79489#answer_89629

On the verge of procrastination

Procrastination is… jumping from an idea to another.
Johnny Kelly

I’m currently procrastinating. And it hurts, much more than it should.

This post is the result of my shallow research on the topic of procrastination mixed with the desire to avoid doing something else (like writing my dissertation).

Counterproductive, needless and delaying tasks

This triad of adjectives is the constant companion of college students. You try to focus, but an invincible foe keeps pushing you against a wall. Nothing works. You realize you should’ve studied more for that test, and to all the other ones you had since your freshman year.

Inside this whirlpool, you begin to wonder why you were allowed to continue. And then you get anxious because the job market is fucked up and no one is there to help you besides yourself. Competition against your peers. Mostly unfinished tasks multiply. And you miss your first deadline, then you have to talk to a bad mooded professor without a drop of consideration.

Finally, you begin to do something entirely different. Facebook, Twitter, Tumblr — those islands of pure ego — or anything else, really, in order to avoid what you ought to do. At this stage you’re writing lists, large lists, gigantic lists, and then you realize none of them is going to get completed. Ever. And panic strikes.

You feel weak. Now you’ve graduated, and no better situation awaits. Your naïve notion of perfectionism attained nothing but frustration and sleepless nights.

What should you do?

Some researchers1 suggest that counterproductive, needless and delaying tasks are the necessary and sufficient conditions to categorize some comportament as procrastination. I disagree. Sometimes, it’s necessary to “procrastinate” (by doing these tasks) in order to create interesting things. So, when is it bad?

Misery

A common attribute among procrastinators is perfectionism.

Generally, one is taken as a perfectionist if s/he “tries to do everything right”. A more descriptive set of variables3 include: high standards, orderliness and discrepancy between her/his achievements and standards. The last item is mostly responsible for the problems attributed to perfectionism.

In fact, people who rate high on our discrepancy scale also rate high on scales measuring depression, shame, anxiety, and other negative psychological states.

Robert B. Slaney3

So the troubling situation is if you want to achieve more but can’t actually do it. Then you begin to realize that if you do nothing until the last minute, you won’t be blamed for not having skills, but for being lazy. And you begin thinking this is alright. “I feel more productive doing it the night before, overloaded with coffee”. As far as coping mechanisms goes, this is bullshit.

Can someone escape from this spiral after entering it? Or s/he is condemned to a life of self-hatred, unsatisfied in every waking hour? That’s… a good question. The answer might be in identifying what kind of “mindset” typically generates procrastination.

Losing yourself in doubts

With important and potentially negative outcomes linked to procrastination, why would a student choose to procrastinate?

Jeannetta G. Williams et al2

I and most of the procrastinators I know of are students, so restricting this discussion to this group isn’t so bad an assumption. (as a matter of fact, we’re pretty good at it).

There are two opposite mindsets2, each very (negative or positively) correlated with procrastination tendency. The first, called mastery-oriented, is defined by a strong desire of learning for its own sake, unconcerned with grades. The second, performance-oriented, is marked by studying to “win”, as the name implies. The latter is obviously much more afraid of failing than the former.

This situation is unsustainable. Getting anxious over the fact — an immutable one, considering a student — that you won’t understand or be good at something is painful.

Another problematic factor is the “big push effect” before a deadline: if you have a semester to do it, why the heck did you wait until the last week?! Coffee, awful nights and a constant fear of not being able to finish, all this due to some afternoons and nights on the Internet, doing nothing.

On the other hand, doing things for their intrinsic value is so much better that there’s a whole area of research devoted to it — the so-called [Optimal Experience or simply Flow](http://en.wikipedia.org/wiki/Flow_(psychology).

Conclusion

My first impulse to write this article appeared right after I finished “What are BLAS and LAPACK“. Considering that I still have to write lots of things for my senior dissertation, I was procrastinating by writing about procrastination. Wonderful.

I don’t have much to say before turning this into an autobiographic “I was a much worse procrastinator, now I’m just an average one!” or a self-help post. However, I’ve learned a good deal about the subject and it might be useful in some parts of my work. I hope you learned something as well.

During my research, one of the best resources I found was the video below. While not scientific, its rhythm, images and words are stunning.

Procrastination from Johnny Kelly on Vimeo.

It’s unsettlingly precise.

References

  1. Schraw, Gregory; Wadkins, Theresa; Olafson, Lori. Doing the things we do: A grounded theory of academic procrastination. Journal of Educational Psychology, Vol 99(1). link.
  2. Jeannetta G. Williams et al. Start Today or the Very Last Day? The Relationships Among Self-Compassion, Motivation, and Procrastination. American Journal of Psychological Research, Volume 4, Number 1. October 20, 2008. link
  3. McGarvey, Jason. The Almost Perfect Definition. Seen on 08/24/2013. link.

: http://vimeo.com/9553205

What are BLAS and LAPACK

I wanted to write about this subject since I started reading about NMatrix.

At the beginning, the names BLAS, LAPACK and ATLAS confused me — imagine a young programmer, without formal training, trying to understand what’s a “de facto application programming interface standard” with lots of strangely-named functions and some references to the ancient FORTRAN language.

As of now, I think my understanding is sufficient to write about them.

Meaning, definitions and madness

BLAS (Basic Linear Algebra Subroutine) is a standard that provides 3 levels of functions for different kinds of linear algebra operations. Consider \alpha and \beta as scalars, x and y as vectors and A, B and T (triangular) as matrices. The levels are divided in the following way:

  1. Scalar and vector operations of the form y = \alpha * x + y, dot product and vector norms.
  2. Matrix-vector operations of the form y = \alpha * A * x + \beta * y and solving T * x = y.
  3. Matrix-matrix operations of the form C = \alpha * A * B + \beta * C and solving B = \alpha * T^{-1} * B. GEMM (GEneral Matrix Multiply) is contained in this level.

There are several functions in LAPACK (Linear Algebra PACKage), from solving linear systems to eigenvalues and factorizations. It’s much better to take a look at its documentation when you’re looking for something specific.

A bit of history

BLAS was first published in 1979, as can be seen in this paper. An interesting part of it is the section named Reasons for Developing the Package:

  1. It can serve as a conceptual aid in both the design and coding stages of a programming effort to regard an operation such as the dot product as a basic building block.

  2. It improves the self-documenting quality of code to identify an operation such as the dot product by a unique mnemonic name.

  3. Since a significant amount of the execution time in complicated linear algebraic programs may be spent in a few low level operations, a reduction of the execution time spent in these operations may be reflected in cost savings in the running of programs. Assembly language coded subprograms for these operations provide such savings on some computers.

  4. The programming of some of these low level operations involves algorithmic and implementation subtleties that are likely to be ignored in the typical applications programming environment. For example, the subprograms provided for the modified Givens transformation incorporate control of the scaling terms, which otherwise can drift monotonically toward underflow.

So it seems we still use BLAS for the reasons it was created. The paper’s a pretty good read if you have the time. (and if you don’t know what’s a Givens transformation, read this)

LAPACK was first published in 1992, as can be seen in the release history. By reading the LAWNs (LAPACK Working Notes), we can get a pretty good picture of its beginning, e.g. papers that presented techniques which were later added to it and installation notes (with sayings of the sort “[…] by sending the authors a hard copy of the output files or by returning the distribution tape with the output files stored on it”).

Implementations

There are various implementations of the BLAS API, e.g. by Intel, AMD, Apple and the GNU Scientific Library. The one supported by NMatrix is ATLAS (Automatically Tuned Linear Algebra Software), a very cool project that uses a lot of heuristics to determine optimal compilation parameters to maximize its BLAS & LAPACK implementations’ performance.

As for LAPACK, its original goal was “to make the widely used EISPACK and LINPACK libraries run efficiently on shared-memory vector and parallel processors” (source). Simply put, it’s a library for speeding up various matrix-related routines by taking advantage of each architecture’s memory hierarchy. The trick is that it uses block algorithms for dealing with matrices instead of an element-by-element approach. This way, less time is spent moving data around. It’s written in Fortran 90.

Another important point regarding LAPACK is that it requires a good BLAS implementation — it assumes there’s one already made for the system at hand — by calling the level 3 operations as much as possible.

Function naming conventions

One of the strangest things about BLAS and LAPACK is how their functions are named. In LAPACK, a subroutine name is of the form pmmaaa, where:

  • p is the type of the numbers used, e.g. S for single-precision floating-point and Z for double-precision complex.
  • mm is the kind of matrix used in the algorithm, e.g. GE for GEneral matrices, SY for SYmmetric and TB for Triangular Band.
  • aaa is the algorithm implemented by the subroutine, e.g. QRF for QR factorization, TRS for solving linear equations with factorization.

BLAS functions are named as <character><name><mod>, which, although similar to LAPACK’s, have differences depending on the specific level. In level 1, <name> is the operation type, while is level 2 and 3 it’s the matrix argument type. For each level, there are some specific values that <mod> (if present) can take, each providing additional information of the operation. <character> is the data type regardless of the level.

These arcane names are derived from the fact that FORTRAN’s identifiers were limited to 6 characters in length. This was solved by FORTRAN90 by allowing up to 31 characters, but the names used in BLAS and LAPACK remain to this day.

Use in NMatrix

NMatrix has bindings to both BLAS and LAPACK. Let me show you:

NMatrix::BLAS.methods.select { |s| s =~ /cblas/ }
# => [:cblas_nrm2, :cblas_asum, :cblas_rot, :cblas_rotg, 
      :cblas_gemm, :cblas_gemv, :cblas_trsm, :cblas_trmm,
      :cblas_syrk, :cblas_herk]

NMatrix::LAPACK.methods.select { |s| s =~ /clapack/ }
# => [:clapack_getrf, :clapack_potrf, :clapack_getrs, 
      :clapack_potrs, :clapack_getri, :clapack_potri,
      :clapack_laswp, :clapack_scal, :clapack_lauum,
      :clapack_gesv, :clapack_posv]

If you want to take a look at the low-level bindings, grab some coffee and read the ext/nmatrix/math/ directory. Since 8f129f, it has been greatly simplified and can actually be understood.

References

Below you can find a list of the main resources used in this post.

The Measurable Gem

I updated the Measurable gem yesterday with documentation and corrections to the methods.

It’s a module packed with lots of methods that calculate the distance between two vectors, u and v. They’re pretty useful for machine learning tasks and can be used in various apps whenever you need to estimate the similarity of two things — strings, sets, etc.

Just a reminder that some of the methods aren’t metrics in the mathematical sense, that is, given a function d(x, y), it is a metric if and only if the following properties hold:

  • Symmetry: d(x, y) == d(y, x).
  • Non-negative: d(x, y) >= 0, for every (x, y).
  • Coincidence axiom: d(x, y) == 0 if, and only if, x == y.
  • Triangular inequality: d(x, y) <= d(x, z) + d(z, y).

In any case, there are still many methods that I want to add to Measurable (which you can find in the README). As I’m learning about them while I write this gem, it’s hard to know in advance what’s useful and what isn’t. Any help with references and examples (and feature requests) are appreciated.

Another point is that I want to rewrite some methods in C (e.g. Euclidean distance) to get to know Ruby’s C API and to speed some things up. This would be a pretty good reason to use the gem also — speed — as most of the methods are very straightforward and succint to write.

I plan on releasing versions 0.0.6 up to 0.1 very rapidly, just by adding new method definitions, updating documentation and probably adding some examples.

Well, that’s it.