pokemon-types: org/lpsolve.org comparison

comparison org/lpsolve.org @ 16:7698e9bdff2b

upgraded pokemon-types to clojure version 1.3

author	Robert McIntyre <rlm@mit.edu>
date	Mon, 06 Aug 2012 17:22:39 -0400
parents	ecb6e3f9b7d6
children	0f6ace87343a

comparison

equal deleted inserted replaced

-:da4c47650d38
+:7698e9bdff2b
 :
 : Actual values of the variables:
 : wheat                      21.875
 : barley                     53.125
 This shows that the farmer can maximize his profit by planting 21.875
 of the available acres with wheat and the remaining 53.125 acres with
 barley; by doing so, he will make $6315.62(5) in profit.
 * Incorporating  =lp_solve= into Clojure
 ** The Farmer's Problem in Clojure
 We are going to solve the same problem involving wheat and barley,
 that we did above, but this time using clojure and the =lp_solve= API.
-#+srcname: intro
+#+name: intro
 #+begin_src clojure :results silent
 (ns pokemon.lpsolve
-(:use [clojure.contrib def set [seq :only [indexed]] pprint])
+;;(:use [clojure.contrib def set [seq :only [indexed]] pprint])
 (:import lpsolve.LpSolve)
 (:require pokemon.types)
-(:require incanter.core trans)
+(:require incanter.core)
 (:require rlm.map-utils))
 #+end_src
 The =lp_solve= Java interface is available from the same site as
 =lp_solve= itself, http://lpsolve.sourceforge.net/ Using it is the
 libraries to your export =LD_LIBRARY_PATH= if you are using Linux. For
 example, in my =.bashrc= file, I have the line
 =LD_LIBRARY_PATH=$HOME/roBin/lpsolve:$LD_LIBRARY_PATH=.  If everything
 is set-up correctly,
-#+srcname: body
+#+name: body
 #+begin_src clojure :results verbatim :exports both
 (import 'lpsolve.LpSolve)
 #+end_src
 #+results: body
 - intelligible, immutable output
 To deal with these issues I'll create four functions for interfacing
 with =LpSolve=
-#+srcname: declares
+#+name: declares
 #+begin_src clojure :results silent
 (in-ns 'pokemon.lpsolve)
 ;; deal with automatic memory management for LpSolve instance.
 (declare linear-program)
 Every instance of =LpSolve= must be manually garbage collected via a
 call to =deleteLP=. I use a non-hygienic macro similar to =with-open=
 to ensure that =deleteLP= is always called.
-#+srcname: memory-management
+#+name: memory-management
 #+begin_src clojure :results silent
 (in-ns 'pokemon.lpsolve)
 (defmacro linear-program
 "solve a linear programming problem using LpSolve syntax.
 within the macro, the variable =lps= is bound to the LpSolve instance."
 *** Sensible Results
 The =linear-program= macro deletes the actual =lps= object once it is
 done working, so it's important to collect the important results and
 add return them in an immutable structure at the end.
-#+srcname: get-results
+#+name: get-results
 #+begin_src clojure :results silent
 (in-ns 'pokemon.lpsolve)
 (defrecord LpSolution
 [objective-value
 =model= function which returns the problem in a form that can be
 solved by other linear programming packages.
 *** Solution Status of an LpSolve Object
-#+srcname: solve
+#+name: solve
 #+begin_src clojure :results silent
 (in-ns 'pokemon.lpsolve)
 (defn static-integer?
 "does the field represent a static integer constant?"
 (integer? (.get field nil))))
 (defn integer-constants [class]
 (filter static-integer? (.getFields class)))
-(defn-memo constant-map
+(defn constant-map
 "Takes a class and creates a map of the static constant integer
 fields with their names.  This helps with C wrappers where they have
 just defined a bunch of integer constants instead of enums."
 [class]
 (let [integer-fields (integer-constants class)]
 (into (sorted-map)
 	     (zipmap (map #(.get % nil) integer-fields)
 		     (map #(.getName %) integer-fields)))))
+(alter-var-root #'constant-map memoize)
 (defn solve
 "Solve an instance of LpSolve and return a string representing the
 status of the computation. Will only solve a particular LpSolve
 instance once."
 Now we can implement a nicer version of the examples from the
 [[http://lpsolve.sourceforge.net/][=lp\_solve= website]]. The following is a more or less
 line-by-line translation of the Java code from that example.
-#+srcname: farmer-example
+#+name: farmer-example
 #+begin_src clojure :results silent
 (in-ns 'pokemon.lpsolve)
 (defn farmer-example []
 (linear-program
 (results
 the particular instance of =lp_solve=.  Why not make a version of
 =linear-program= that takes care of initialization?
-#+srcname: lp-solve
+#+name: lp-solve
 #+begin_src clojure :results silent
 (in-ns 'pokemon.lpsolve)
 (defn initialize-lpsolve-row-oriented
 "fill in an lpsolve instance using a constraint matrix =A=, the
 objective function =c=, and the right-hand-side =b="
 #+end_src
 Now, we can use a much more functional approach to solving the
 farmer's problem:
-#+srcname: better-farmer
+#+name: better-farmer
 #+begin_src clojure :results silent
 (in-ns 'pokemon.lpsolve)
 (defn better-farmer-example []
 (lp-solve  [[120 210]
 	      [110 30]
 susceptance of each type, then finding an immortal type corresponds to
 setting each constraint (the $b$ vector) to -1 (since log_2(1/2) = -1)
 and setting the constraint vector $c$ to all ones, which means that we
 want to find the immortal type which uses the least amount of types.
-#+srcname: pokemon-lp
+#+name: pokemon-lp
 #+begin_src clojure :results silent
 (in-ns 'pokemon.lpsolve)
 (defn log-clamp-matrix [matrix]
 ;; we have to clamp the Infinities to a more reasonable negative
 (defn set-variable-names
 "sets the variable names of the problem given a vector of names"
 [#^LpSolve lps names]
 (dorun
-(map (fn [[index name]]
+(keep-indexed
-	  (.setColName lps  (inc index) (str name)))
+(fn [index name]
-	;; ONE based indexing!!!
+(.setColName lps  (inc index) (str name)))
-	(indexed names))))
+;; ONE based indexing!!!
+names)))
 (defn poke-solve
 ([poke-matrix target objective-function constraint min-num-types]
 ;; must have at least one type
 (let [poke-matrix
 #+end_src
 With this, we are finally able to get some results.
 ** Results
-#+srcname: results
+#+name: results
 #+begin_src clojure :results silent
 (in-ns 'pokemon.lpsolve)
 (defn best-defense-type
 "finds a type combination which is resistant to all attacks."
 Unfortunately, all of the tools that we've written so far are focused
 on defense type combinations.  However, it is possible to make every
 tool attack-oriented via a simple macro.
-#+srcname: attack-oriented
+#+name: attack-oriented
 #+begin_src clojure :results silent
 (in-ns 'pokemon.lpsolve)
 (defmacro attack-mode [& forms]
 `(let [attack-strengths# pokemon.types/attack-strengths

Mercurial > pokemon-types

comparison org/lpsolve.org @ 16:7698e9bdff2b