Following Python script converts a SymPy expression to Postscript expression. It does this

Test expression is

import sympy

# define symbols and then test expression
x,y = sympy.symbols('x y')
e = sympy.exp( x**2*sympy.sin(x)-sympy.cos(x**2-x/2/y) )

# get MathML representation string
mml = sympy.printing.mathml(e)

# parse MathML representation of "e" using ElementTree module
import xml.etree.ElementTree as et
root = et.fromstring(mml)

# define routine to tranverse the XML ElementTree "root"
def traverseET(r,level):
    indent = "|  " # "\t"
    print (indent*level)+r.tag+'('+`r.text`+')'
    for c in r.getchildren():
        traverseET(c, level+1)

# define Postscript equivalents of MathML operator names
MathML2PSOP = {'times':'mul',
               'divide':'div',
               'power':'exp',
               'plus':'add',
               'minus':'sub',
               'cos':'cos',
               'sin':'sin',
               'exp':'exp',
               'cn':'#',
               'ci':'_'}

# routine to convert XML tree "r" of an expression to Postscript expression
def MathML2POSTSCRIPT(r,depth):
    if r.tag=="apply":
        children = r.getchildren()
        operator = children[0]
        opMathMLname = operator.tag
        opname = MathML2PSOP[ opMathMLname ]
        result = MathML2POSTSCRIPT( children[1], depth+1 )
        if (len(children)>2):
            for i in range(2,len(children)):
                result += ( MathML2POSTSCRIPT( children[i], depth+1 ) + opname )
        else:
            if opMathMLname=='minus':
                opname = 'neg'
                result = result + ' ' + opname
            elif opMathMLname=='exp':
                result = '2.7182818284590452354 ' + result + 'pow'
            else:
                result = result + ' ' + opname
        return result + ' '
    elif r.tag=='ci':
        return r.text + ' '
    elif r.tag=='cn':
        return r.text + ' '
    else:
        return '(?)'

print "_"*30
print "ElementTree Traversal"
traverseET(root, 0)

print MathML2INFIX(root,0)
print "_"*30
print "Postscript equivalent of <",e,">"
print MathML2POSTSCRIPT(root,0)

Output of code is

______________________________
ElementTree Traversal
apply(None)
|  exp(None)
|  apply(None)
|  |  plus(None)
|  |  apply(None)
|  |  |  minus(None)
|  |  |  apply(None)
|  |  |  |  cos(None)
|  |  |  |  apply(None)
|  |  |  |  |  plus(None)
|  |  |  |  |  apply(None)
|  |  |  |  |  |  minus(None)
|  |  |  |  |  |  apply(None)
|  |  |  |  |  |  |  divide(None)
|  |  |  |  |  |  |  ci('x')
|  |  |  |  |  |  |  apply(None)
|  |  |  |  |  |  |  |  times(None)
|  |  |  |  |  |  |  |  cn('2')
|  |  |  |  |  |  |  |  ci('y')
|  |  |  |  |  apply(None)
|  |  |  |  |  |  power(None)
|  |  |  |  |  |  ci('x')
|  |  |  |  |  |  cn('2')
|  |  apply(None)
|  |  |  times(None)
|  |  |  apply(None)
|  |  |  |  power(None)
|  |  |  |  ci('x')
|  |  |  |  cn('2')
|  |  |  apply(None)
|  |  |  |  sin(None)
|  |  |  |  ci('x')
______________________________
Postscript equivalent of < exp(-cos(-x/(2*y) + x**2) + x**2*sin(x)) >
2.7182818284590452354 x 2 y mul div  neg x 2 exp add  cos  neg x 2 exp x  sin mul add pow

Generated Postscript expression is verified by hand

2.718281 x [2 y mul] div  neg x 2 exp add  cos  neg x 2 exp x  sin mul add pow
2.718281 [x (2*y)] div]  neg x 2 exp add  cos  neg x 2 exp x  sin mul add pow
2.718281 [(x/(2*y)])  neg] x 2 exp add  cos  neg x 2 exp x  sin mul add pow
2.718281 -(x/(2*y)])  [x 2 exp] add  cos  neg x 2 exp x  sin mul add pow
2.718281 [-(x/(2*y)])  x**2 add]  cos  neg x 2 exp x  sin mul add pow
2.718281 [(-(x/(2*y)])+x**2 cos]  neg x 2 exp x  sin mul add pow
2.718281 [cos(-(x/(2*y)])+x**2  neg] x 2 exp x  sin mul add pow
2.718281 -cos(-(x/(2*y)])+x**2  [x 2 exp] x  sin mul add pow
2.718281 -cos(-(x/(2*y)])+x**2  x**2 [x  sin] mul add pow
2.718281 -cos(-(x/(2*y)])+x**2  [x**2 sin(x) mul] add pow
2.718281 [-cos(-(x/(2*y)])+x**2  x**2*sin(x)  add] pow
2.718281 (-cos(-(x/(2*y)])+x**2+x**2*sin(x)) pow
2.718281^(cos(-(x/(2*y)])+x**2+x**2*sin(x)))

If Postscript expressions are to be used within a PDF document for a Functiontype4 shading then a subset postscript commands are allowed. For a list of allowed commands see “Operators in Type 4 Functions” in “PDF Reference, sixth edition, Adobe Systems Incorporated“

Note that, instead of processing MathML nodes, SymPy (AST) nodes could be processed directly (without creating intermediate representations) but at the time writing this script, handling MathML nodes was easier for me.

Ketika kita bekerja dengan huruf entah itu untuk percetakan atau online publishing, komputer yang akan menjadi mediumnya, dimana kita akan mengumpulkan materi dan mengerjakan konsep dan desain yang akan dibuat. Oleh karena itu kebutuhan akan pengetahuan grafis pada tampilan layar dan reproduksi grafis sangat dibutuhkan untuk mendapatkan final output yang terlihat oleh target audiens sesuai seperti apa yang kita harapkan.

1. Bitmap
Dalam Tampilan layar monitor atau pun cetak digital, teks di render oleh ribuan kumpulan grid mosaik berwarna berbentuk seperti titik yang disebut pixel untuk membuat sebuah bentuk yang diinginkan. Susunan bentuk grid inilah yang disebut dengan Bitmap. Bitmap sangat intensif terhadap memory, sebuah file harus mengandung informasi tentang warna dan posisi dalam sebuah halaman di setiap pixelnya. Ketika sebuah gambar bitmap di perbesar, software hanya bisa memperbesar bentuk pixel pada gambar tersebut, sehingga mempengaruhi pixel asli dari gambar tersebut dan bagian pixel yang kecil dan bergerigi akan menjadi terlihat besar dan menjadikan gambar terlihat lebih bergerigi.

2. Vektor
Vektor mendeskripsikan sebuah bentuk sebagai sebuah garis seperti garis lurus atau garis melengkung yang saling menyatu dengan titik yang telah ditentukan. Garis-garis tersebut (vektor) di rekam dalam bentuk file sebagai formula matematika. Dan kemudian garis yang telah terbentuk di isi oleh pixel. Vektor sangat baik untuk kualitas pengskalaan, ketika sebuah gambar vektor diperbesar, posisi kordinat titik vektor di susun ulang dengan dikontrol oleh formula matematika agar garis lurus dan lengkung pada titik-titik tersebut tetap konstan, dan bentuk baru ini kemudian di isi oleh pixel sesuai dengan bentuk dari vektor tersebut tanpa ada cacat pixel. File gambar vektor memakan memory lebih kecil dibandingkan dengan file bitmap. Menggambar dengan vektor sangat efisien akan tetapi bagaimanapun juga gambar vektor ini ketika bertemu dengan layar monitor harus di render sebagai titik-titik matrix atau dengan kata lain garis vektor harus di konversi kedalam bentuk bitmap. Informasi garis vektor di konversi menjadi bitmap untuk dicetak, bedanya bitmap yang akan dicetak ini memiliki resolusi yang tinggi.

Huruf dan Layar Komputer
Gambar dihadirkan di layar komputer oleh kumpulan titik-titik berwarna yang disusun dalam grid yang rapat yang dinamakan pixel, kualitas on-screen rendering dari huruf digital dihambat oleh kecilnya resolusi dari layar komputer yaitu, 72 pixel per inch (ppi) di layar Macintosh dan 96 ppi di layar PC. Ukuran huruf yang kecil akan tampil buruk dilayar dan sangat mengganggu dan masalahnya huruf berukuran kecil sering digunakan dalam penkerjaan desktop publishing. Ukuran resolusi yang rendah dari layar komputer tidak bisa menghadirkan detail yang baik, sehingga ketika huruf berukuran kecil di raster dan disesuaikan dengan grid pixel, detail dengan ukuran lebih kecil dari 1 pixel harus dibesarkan atau dihilangkan, ini menyebabkan fitur seperti ketebalan stroke atau serif menjadi tidak konsisten atau mungkin menjadi hilang dan akhirnya membentuk huruf dan ruang yang tidak baik. Beberapa teknik diperlukan untuk mengatasi permasalahan tersebut, teknik tersebut dinamakan Hinting, font-font yang berkualitas tinggi telah melewati proses ini dan mengandung informasi hinting. Saat meraster, software mengusahakan untuk meratakan outline gambar terhadap grid pixel, hanya pixel yang jatuh di outline gambar yang digunakan secara normal. Jika terdapat sedikit pixel untuk menghadirkan huruf berukuran kecil dengan benar, perintah hinting digunakan untuk membuat penyesuaian yang akan memberikan bentuk yang lebih baik secara optis.

Huruf dan Media Cetak
Untuk melihat detail font dengan jelas bisa di capai dengan mencetaknya diatas kertas, mesin cetak menggunakan titik kecil hitam atau berwarna untuk membentuk sebuah gambar. Jumlah dot per inch (dpi) / titik per inci sangatlah jauh lebih baik dibandingkan layar komputer dan oleh sebab itu gambar yang lebih detail bisa dibentuk. Kebanyakan mesin cetak inkjet atau laserjet memiliki output resolusi 300 hingga 600 dpi, dan bahkan imagesetter memiliki output resolusi hingga 3000 dpi. Saat ini mesin cetak inkjet dan laserjet sudah bisa menghasilkan kualitas cetak yang sangat baik, tetapi jika diteliti lebih dekat akan terlihat formasi titik-titik yang membentuk area gambar, mesin cetak tersebut tetap memiliki keterbatasan resolusi, pembentukan gradasi dan warna. Secara kontras, titik-titik yang digunakan oleh imagesetter sangatlah kecil hingga sulit dideteksi oleh visual, sehingga sudut-sudut pada gambar dan huruf terlihat sempurna.

1. Postscript
Adalah bahasa deskripsi halaman yang dipatenkan oleh Adobe. Mengkonversi informasi vektor menjadi bitmap beresolusi tinggi untuk rendering berkualitas tinggi. Adobe Type Manager (ATM) menggunakan postscript untuk menghasilkan bitmap superior dari outline di pencitraan layar komputer.
2. Inkjet Printer
Titik-titik mikroskopik dari tinta disemprotkan ke atas kertas dengan resolusi 300 hingga 1500 dpi. Dengan keterbatasan resolusi dan kualitas kertas banyak mesin cetak inkjet murahan tidak mampu memaksimalkan postscript hingga tidak bisa merender bentuk huruf dengan tepat. Tapi inkjet-inkjet keluaran terbaru yang dilengkapi oleh postscript atau postscript simulation bisa menghasilkan output yang sangat baik.
3. Laser Printer
Kebanyakan Laser Printer sudah dilengkapi oleh software postscript, yang akan bisa dengan baik menerjemahkan bentuk huruf dan pengaturan jarak dengan akurat, walaupun mereka membuat tampilan yang ‘crisp’, laser printer mengalami hambatan ketika ukuran ukuran gambar yang akan di cetak kecil. Karena partikel dari bubuk toner digunakan untuk membuat gambar lebih lebih kecil dan huruf-huruf berstroke tipis tampil lebih tebal ketika tercetak.
4. Imagesetter
Imagesetter berbasis postscript, dengan menggunakan cermin putar dan sinar laser, memberikan hasil gambar dengan kualitas tinggi, pemanfaatan eksposur fotografi dikombinasikan dengan resolusi yang sangat tinggi untuk mendapatkan detail yang sangat baik. Imagesetter mengarahkan cahaya keatas film, yang akan digunakan untuk menyinarkan cahaya ke atas pelat cetakan. Gambar sekarang sudah berpindah ke atas pelat yang sudah ditintakan dan gambar inilah yang akan dipindahkan keatas kertas atau media cetak lainnya.
5. Online Viewing
Online viewing adalah istilah aplikasi desain yang dibuat dengan tampilan yang terlihat dilayar komputer adalah hasil akhir yang akan dilihat oleh pemirsa desain contohnya, desain website atau multimedia interaktif. Permasalahan yang kerap hadir dalam pengaplikasian online viewing adalah keterbatasan resolusi yang dimiliki oleh layar monitor komputer yaitu 72 ppi untuk Macintosh dan 96 ppi untuk PC sehingga memberikan efek yang tidak baik untuk penampilan-penampilan huruf dalam ukuran kecil, oleh karena itu banyak desain-desain website yang menggunakan huruf dengan ukuran besar untuk aplikasi text dan ini sangat mengganggu untuk kenyamanan komposisi layout, dan juga permasalahan online viewing yang berhubungan dengan resolusi belum terpecahkan. Untuk mengatasi permasalahan resolusi ini hadirlah sebuah teknik yang dinamakan Antialiasing.

a. Antialiasing
Terkadang menggunakan font dengan ukuran kecil adalah satu-satunya cara yang memungkinkan untuk mendisplay text dengan ukuran kolom yang terbatas. Agar font tetap terlihat baik di ukuran kecil tanpa kehilangan legibility nya, para pembuat software membuat teknik antialiasing, teknik ini bekerja membandingkan garis vektor dengan grid bitmap dan membaca bagian dari gambar atau huruf yang hilang atau terdistorsi, lalu dengan kecanggihan teknologi, software memasukan pixel berbentuk bayangan warna abu-abu yang bervariasi disekeliling bentuk huruf untuk menciptakan ilusi mata bentuk stroke yang halus. Kekurangan dari teknik antialiasing adalah teks dengan font berukuran kecil akan terlihat kurang hitam akan tetapi kekurangan ini cukup terbayar dengan kehalusan dan integritas atas bentuk huruf yang ditampilkan.
[IMG]http://i21.photobucket.com/albums/b266/ritchienedhansel/Untitled5.png[/IMG] gambar diambil dari http://www.newcottage.com

Sumber:
1. http://id.wikipedia.org/wiki/Huruf_Digital_(Font)

Grungy, nasty circles vector with drips and removable ants

by Freevectors.com

Encapsulated PostScript

DOWNLOAD(0.97Mb)

Today we’re moving things from design programs into PostScript files into PDFs, to print out proofs. Or, we’re trying to . . . .

We’ve been attempting to follow LSI’s instructions, but it just didn’t pan out.  There seems to be some missing information.

Apparently when you choose Print Preset: Custom and Printer: PostScript, you can’t then choose Adobe PDF as your PDD.  You can only choose Device Independent, and about 200 models of printer.

Unfortunately the instruction LSI gives is to select PDD: Adobe PDF.

Since this is the very first step in the process.  We haven’t really got much further than contacting LSI,  to ask if there was anything they left out.

There’s nothing about this in any of the “How to use InDesign” books. So we kind of have to wait and see.

LSI does offer to let publishers send in the books in .indd format, but the closer we can come to the final product, the better.

For one thing, the final proof of a PDF is way more likely to catch a flaw than a proof of an .indd file. And so . . . PS  we’re moving on to another pot, while this one simmers.

I write about drawing graphics with PSTricks in TeX here. PSTricks is a collection of PosrScript-based TeX macros that is compatible with most TeX macro packages, including Plain TeX, LaTeX and ConTeXt. PSTricks gives you colour, graphics, rotation, trees and overlays.

PSTricks means “PostScript Tricks” and it combines two powerful languages (PostScript for drawing and TeX for typesetting).

I start with basics and then I develop it for drawing more complex graphics. I try to have at least one post per day and you can try asking your questions at the comment section of each post.

I wrote a simple script recently for a user who was having trouble getting certain PDFs to print properly from his linux box (Fedora 10). I first suggested that he try converting the pdfs to ps and printing the resulting file. That worked but he found the process a bit tedious. Here’s the script I wrote to take care of the tediousness. It relies on the standard (in Fedora, at least) pdf2ps package. It should be pretty self-explanatory.

#!/bin/bash

# grab first argument as pdf filename and generate ps filename
thePDF=$1
thePS=$(echo $thePDF.ps)
queueName=$2

usage()
{
    echo ""
    echo "Usage: psprint [your pdf] [lpr queue]*"
    echo ""
    echo "This command does three things:"
    echo "  1. Converts the specified pdf file to ps"
    echo "  2. Prints the ps file to your default lpr queue *(unless you specify another queue)"
    echo "  3. Deletes the ps file"
    echo ""
    exit 1
}

if [ $# == 0 ]; then usage; fi
if [ $# == 1 ]; then
    echo "Converting $thePDF ..."
    pdf2ps "$thePDF" "$thePS"
    echo "Sending to default printer ..."
    lpr "$thePS"
    echo "Cleaning up ..."
    rm "$thePS"
    exit 1
fi
if [ $# == 2 ]; then
    echo "Converting $thePDF ..."
    pdf2ps "$thePDF" "$thePS"
    echo "Sending to $2 ..."
    lpr -P "$queueName" "$thePS"
    echo "Cleaning up ..."
    rm "$thePS"
    exit 1
fi
if [ $# > 2 ]; then usage; fi

Save the script to a location in your path (/usr/local/bin works) and you’re off.

Postscript magazine is a termly magazine at Imperial College produced by the Graduate Students’ Association for the postgraduate students.

Postscript- Summer 2009

Postscript- Spring 2009.

Recently, I saw a spirograph kit for sale in an art museum bookstore. I remember using a spirograph kit when I was younger to make intricate patterns, but I haven’t seen one in years. Inspired by the art museum bookstore (I’d be lying if I said that I didn’t often enjoy a museum’s bookstore at least as much as the museum itself) I started working on a new PostScript project: I wanted to make a spirograph in PostScript. Here are some example designs that the program produced:

A few figures

The mathematical name for curves of this sort is hypotrochoid. Hypotrochoids include all of the figures that can be made with a spirograph. The following figure should be helpful in understanding how the curves are constructed:

Hypotrochoid construction

In order to define a particular hypotrochoid, we need to pick three numbers. The first number, is the radius of the black circle in the above figure. The second number, , is the radius of the red inner circle. In order for the hypotrochoid to eventually close back onto itself, needs to be a ratio of , and should be less than . That is, for some positive integers and . Later we will see why needs to be a ratio of . Finally, we must choose the radius of the red arm attached to the inner circle.

Once the numbers and are chosen, we have pinned down a particular hypotrochoid. To construct the curve, we imagine the inner (red) circle placed against the inside wall of the larger (black) circle. The red arm of radius is rigidly attached to the red circle. The Red circle is then allowed to roll without slipping along the interior of the larger circle. The hypotrochoid is the shape traced out by the end of the red arm that isn’t attached to the center of the red circle.

Using math jargon, we can parametrize the hypotrochoid by

Here is the angle that the center of the red circle has moved with respect to the center of the black circle.

We would like to draw a closed hypotrochoid, meaning that the curve ends at the same point as it begins. As I noted earlier, in order for this to happen, and must be ratios of one another. To see why this is true, consider the following diagram:

Angles of rotation

The angle is the angle through which the center of the inner circle rotates around the center of the black circle. The angle is the angle through which the red circle rotates as it rolls along the inside of the larger circle. The angles and are related by the condition that the inner circle rolls without slipping inside the larger circle. This means that the arc length the red circle sweeps out as it rolls through an angle must equal the arc length of the outer circle through an angle . For the big circle, the arc length is given by

.

For the inner circle,

.

The second term of this expression is due to the fact that the inner circle is rolling around a circle rather than rolling on a line. Equating the two expressions for the length and solving for gives

.

If the hypotrochoid is to be closed, for some sufficiently large value of , the inner circle will have to be back in its initial position. This means that and are both integer multiples of radians (or equivalently 360 degrees). When this occurs we can write

for some integers and . Combining this with the previous result gives

.

Equivalently

.

Since and are integers, this requires that is a rational number, hence must be a ratio of . Further, given and , we can find the smallest value of (and hence ) so that the hypotrochoid is closed. The requirement that be the smallest integer such that

means that is in lowest terms. Therefore the greatest common denominator of and is 1, so we can solve for ,

.

So now we know how big we need to make to close our hypotrochoid.

Well, I think that is quite enough math for tonight. But I will leave you with a few more hypotrochoids that I made.

Design in color

Another color design

Fill pattern

]]> http://livedby.com/2009/07/19/week-2-day-3/ Sun, 19 Jul 2009 07:37:36 +0000 livedby http://livedby.com/2009/07/19/week-2-day-3/

Well, I just got back from a party.  I think it takes me three days to master a routine.  The first day I’m always a mess, but by day three I have enough free time that I’m done everything by 6 & have time to relax.

The party was strange because I wasn’t allowed to drink.  Also, I don’t tend to make a good first impression on anarchists.  I met some really interesting people, however, & I may have found an excellent new participant (wait & see, maybe she’ll turn up in the future).  There was also a cute dog.

(No Bella, I’ll admit.)

Today after a breakfast of trout & (1a) dried apricots (during which I listened to [1b] “The Tennessee Waltz”) I unpacked & alphabetized my bookshelves (made it through O).

Bella & Chance helped.

Then I bought a comic book & a frozen (2a) coca-cola.  Making plans on the phone with my friend I said: (1c) “Everything’s getting terrible”   and (2c) “I’m doing all right by myself.”  Then I went to her house where I made a (3a) peanut butter sandwich.  I took a picture with my iPhone & showed her how pretty it was.

Doesn’t it look like a detail from a Vermeer painting? I asked.  (3c) “If I could paint, I’d paint that picture.”  I ate my sandwich in the elevator.  Then, in the car before the party, I (2b) flipped through my comic book.

Now all I have left to do is (3b) pray.  I’ll do that before I go to bed.  The only thing that’s missing is a nightcap.  It is after midnight, but I know that would be cheating.

I’m saving most of my “deep thoughts” for my end of week essay, but I will share an interesting little “deep fact.”  Since I’ve started the project, it has infiltrated all my dreams, & at least once a night the week’s participant has appeared, if only peripherally, as a character in my dreams (talking to me on the phone, providing feedback on my execution of tasks, etc.)  There’s a particularly peculiar effect this week, as my authors & their characters have appeared consistently too.

I’ll see you all after my day off.  Participants should be expecting week assignments/requests soon.

p.s. I’ve figured out how to see when people do that @ me thing on Twitter!  So now I will actually be able to respond, I think!

First and foremost, I would like to welcome you to my new blog. My other blog (Photangeles Nuevo) is dedicated solely to photography, so I figured I would start a new blog where I can talk about everything else that I’m doing. Before getting started, here is some eye candy:

This summer, I decided to start learning the PostScript programming language. PostScript is an interesting language because the output of the program is (typically) an image. Right now, I don’t want to get too technical into the specifics of the PostScript language, but I’ve really enjoyed learning the language. It is very different from other languages that I’ve used in the past (C/C++, Ruby, Java, Mathematica).

The project that I have been working on involves sorting algorithms. The basic idea is this: given an array (or list) of numbers, how do you organize the array into increasing (or decreasing) numerical order? There are many, many algorithms that solve this problem. The real test of a sorting algorithm is how quickly it sorts a list of n numbers.

As a first example of a sorting algorithm, I’ll describe a straightforward and naive sorting algorithm. It works like this: Look at each element in the array and find the smallest number. Then swap the smallest number with the first entry in the array. Then find the second smallest number in the array and swap that number with the second entry. Repeat this procedure until you fill the last entry in the array, and the array will be in increasing numerical order.

Let’s work an example of sorting with this algorithm. Start with the array [ 3 4 2 5 1 ]. We can see that 1 is the smallest entry, so we swap 1 with the first entry, 3. We get [ 1 4 2 5 3 ]. Now we look for the next smallest entry (2) and swap that with the second entry (4) and get [1 2 4 5 3]. Continuing on, we get [ 1 2 3 5 4 ], [1 2 3 4 5] and we are done.

This algorithm works fine for small arrays, but it is impractical for sorting large arrays. In order to find the smallest element not yet in order, we have to look at every element in the array (or at least every element that hasn’t already been sorted). Therefore, we have to make n – i comparisons between numbers just to find the smallest element in the array, where i is the number of elements already sorted. But we have to find the smallest element n times in order to complete the algorithm. So I calculate that we need to make (1/2) (n^2 – n) comparisons to sort an array of n elements. So if we wanted to sort an array of 10 numbers, we would need to make 45 comparisons. For 100 numbers we would need to make 4,950 comparisons! Clearly, this naive sorting algorithm gets out of hand very quickly for large arrays.

I examined four sorting algorithms that are significantly more efficient than the naive sort described above. I used heap-sort, gnome-sort, bubble-sort and quick-sort. I don’t want to go into too much depth explaining how these algorithms work (see the links to Wikipedia if you want an explanation of them). Each of these algorithms has the advantage of sorting an array “in place.” This means that a computer doesn’t need to save any extra data while sorting. In contrast, the naive sorting algorithm described above does not sort in place, because each time the algorithm finds the smallest element in the array, it needs to store the value (or at least the index of the smallest entry). On average, heap-sort and quick-sort are allegedly the fastest algorithms, while gnome-sort and bubble-sort are considerably slower. Allegedly.

The aim of my project was three-fold. First, I wanted test the various algorithms and see which was truly the most efficient. Second, I wanted to come up with a way of visualizing how the algorithms actually operate on an array. And finally, I wanted to learn enough PostScript to implement the project.

In order to visualize an array of numbers, I decided to use colored squares. Each square represents a number. Forest green represents the smallest number in the array, while ultramarine is the largest element in the array. I printed the unsorted array as a horizontal block of colored squares, and applied the various sorting algorithms. I printed an updated row each time two entries in the array were swapped until the array was sorted. Here are the results of the race of the algorithms. Each algorithm was given the same initial unsorted array.

And they’re off!

the race of the sorting algorithms

As expected, heap-sort and quick-sort are the fastest, with gnome-sort and bubble-sort lagging behind. Additionally, quick-sort seems to have the array partially ordered sooner than heap-sort. I would say that, true to its name, quick-sort is the all around sorting champion of this competition. But I like the visualization of heap-sort the best.

I’ll leave you with some additional images of quick-sort and heap-sort at work:

quick-sort operating on a larger array

heap-sort operating on a larger array

PostScript ist eine Seitenbeschreibungssprache, die seit 1984 von Adobe entwickelt wird und in den 90-er Jahren zum weltweiten Standard in der Druckindustrie für die Ausgabe bei der Film- und Plattenbelichtung wurde, aber nun teilweise vom PDF-Format verdrängt wird, das ebenfalls von Adobe stammt.

PostScript arbeitet system-, größen- und auflösungsunabhängig – die Qualität des Ausdrucks oder der Belichtung richtet sich nach den technischen Möglichkeiten des Ausgabegerätes.

PostScript-Dateien können nahezu ohne Verlust grafischer Informationen in PDF-Dateien umgewandelt werden.