Antievolution.org :: Antievolution.org Discussion BoardThe Critic's Resource on Antievolution

 Antievolution.org Discussion Board > From the Panda's Thumb > After the Bar Closes... > Evolutionary Computation

 Pages: (14) < [1] 2 3 4 5 6 ... >
 Topic: Evolutionary Computation, Stuff that drives AEs nuts < Next Oldest | Next Newest >
Wesley R. Elsberry

Posts: 4953
Joined: May 2002

While I was looking up use of PyQtGraph in PySide, I ran across an example program in an unfamiliar language. A little probing led me to the website for Julia, a new (2013 FOSS release) programming language for scientific and technical computing. The language is dynamic, but uses just-in-time (JIT) compiler technology to achieve benchmark tests within 2x the time C code takes. There's an IDE, Julia Studio, that I am finding useful. Emacs and the command line work just fine as well.

As an initial exercise, I ported my "minimal weasel" program from Python to Julia. The result is a 46-line program. This is slightly longer than the Python version because I'm using a line each for the Julia convention of closing a block with "end". Python uses indentation to indicate block closure.

 Code Sample # Minimum Weasel in Julia  -- Wesley R. Elsberryt = "METHINKS IT IS LIKE A WEASEL"    # Target phraseb = " ABCDEFGHIJKLMNOPQRSTUVWXYZ"     # Base pooln = 178                          # Population sizeu = (1.0 / length(t))              # Mutation rate@printf("Popsize=%d, Mutrate=%f, Bases=%s, Target=%s\n", n,u,b,t)p = ""                        # Parent stringfor ii in [1:length(t)]            # Compose random parent string    p = p * string(b[rand(1:length(b))])end@printf("                        Parent=%s\n",p)done = false                    # Loop control variableg = 0                          # Generation counterbmcnt = 0                        # Base match count (max. in pop.)bc = ""                        # Best candidate variablewhile (done == false)      pop = ASCIIString[]            # Population of strings      bmcnt = 0                  # Start with no bases matched      bcindex = 1                  # Point to first candidate in pop. by default      for ii in [1:n]              # For size of population          push!(pop,"")            # Add an empty candidate          mcnt = 0                # Initialize candidate base match count to zero          for jj in [1:length(t)]     # Compose a new candidate possibly mutated from the parent              if u >= rand()        # We have a mutated base                 pop[ii] = pop[ii][1:jj-1] * string(b[rand(1:length(b))])              else                # No mutation, just copy this base                 pop[ii] = pop[ii][1:jj-1] * string(p[jj])              end              if pop[ii][jj] == t[jj] # Candidate matches target at this base                 mcnt += 1          # Increment candidate base match count              end              if mcnt > bmcnt        # Candidate is better than current best match                 bmcnt = mcnt        # Change best match count                 bcindex = ii        # Store index of best candidate              end              if mcnt >= (length(t) - 0)    # Do enough bases match the target?                 done = true        # Yes, so set loop control for exit              end          end      end      bc = pop[bcindex]            # Set best candidate as candidate at index      g += 1                    # Increment generation count      @printf("Gen=%05d, %02d/%d matched, Best=%s, Total=%06d\n", g, bmcnt, length(t), bc, g*n)      p = bc                    # Parent for next generation is the best candidate from this oneendprintln("weasel done.")

There are a few noteworthy differences from Python. First, Julia is a base-1 language. Arrays start with index 1. Second, Julia's dynamic variable creation requires that a type be provided for declaration of empty arrays. Julia can figure out the type itself for an array that is assigned at least one element, but the programmer has to give a type in order to start with no elements at all. The type system in Julia is apparently one big reason why the developers are able to obtain the good benchmark results. Third, while I have not taken advantage of it here, Julia's syntax allows for expressions to be closer to mathematical notation. "1 + 2x" in Julia is legal, where in Python one would have to have, "1 + 2*x".

I'm planning on porting a more complex program to Julia to see how it performs compared to PyPy.

--------------
"You can't teach an old dogma new tricks." - Dorothy Parker

 405 replies since Mar. 17 2009,11:00 < Next Oldest | Next Newest >

 Pages: (14) < [1] 2 3 4 5 6 ... >

 Forum Jump -----------   >All About Antievolution   -----------------------    +- Antievolution, Politics, and the Law    +- Intelligent Design    +- Young-Earth Antievolution    +- Old-Earth Antievolution    +- Collaborations   >Specifically About Intelligent Design   -------------------------------------    +- Intelligent Design News    +- Not a Book to Be Tossed Aside Lightly...    +- Cabbages and Kings    +- The ID-files   >Evolutionary Biology   --------------------    +- News & Events   >From the Panda's Thumb   --------------------------    +- After the Bar Closes...   >The TalkOrigins Archive   -----------------------    +- Feedback

 Track this topic Email this topic Print this topic

[ Read the Board Rules ] | [Useful Links] | [Evolving Designs]