4 files changed, 65 insertions, 4 deletions

diff --git a/src/engine/machina/Evolver.hpp b/src/engine/machina/Evolver.hpp
index 051513b..6025210 100644
--- a/src/engine/machina/Evolver.hpp
+++ b/src/engine/machina/Evolver.hpp
@@ -47,7 +47,7 @@ private:
 
 	SharedPtr<MachinaGA> _ga;
 	SharedPtr<Problem>   _problem;
-	float                _active_fitness;
+	float                _seed_fitness;
 	Schrodinbit          _improvement;
 };
 
diff --git a/src/engine/machina/Mutation.hpp b/src/engine/machina/Mutation.hpp
index 52c02bc..18bc621 100644
--- a/src/engine/machina/Mutation.hpp
+++ b/src/engine/machina/Mutation.hpp
@@ -39,6 +39,7 @@ struct Compress   SUPER { void mutate(Machine& machine); };
 struct AddNode    SUPER { void mutate(Machine& machine); };
 struct RemoveNode SUPER { void mutate(Machine& machine); };
 struct AdjustNode SUPER { void mutate(Machine& machine); };
+struct SwapNodes  SUPER { void mutate(Machine& machine); };
 struct AddEdge    SUPER { void mutate(Machine& machine); };
 struct RemoveEdge SUPER { void mutate(Machine& machine); };
 struct AdjustEdge SUPER { void mutate(Machine& machine); };
diff --git a/src/engine/machina/Node.hpp b/src/engine/machina/Node.hpp
index 1f0face..87e14af 100644
--- a/src/engine/machina/Node.hpp
+++ b/src/engine/machina/Node.hpp
@@ -44,7 +44,7 @@ class Node : public Raul::Stateful {
 public:
 	typedef std::string ID;
 
-	Node(BeatCount duration=0, bool initial=false);
+	Node(BeatCount duration=1.0, bool initial=false);
 	Node(const Node& copy);
 
 	void set_enter_action(SharedPtr<Action> action);
@@ -56,6 +56,8 @@ public:
 	void enter(SharedPtr<Raul::MIDISink> driver, BeatTime time);
 	void exit(SharedPtr<Raul::MIDISink> driver, BeatTime time);
 
+	void edges_changed();
+
 	void add_edge(SharedPtr<Edge> edge);
 	void remove_edge(SharedPtr<Edge> edge);
 	void remove_edges_to(SharedPtr<Node> node);
@@ -82,6 +84,8 @@ public:
 	SharedPtr<Edge> random_edge();
 	
 private:
+	Node& operator=(const Node& other); // undefined
+
 	Schrodinbit       _changed;
 	bool              _is_initial;
 	bool              _is_selector;
diff --git a/src/engine/machina/Problem.hpp b/src/engine/machina/Problem.hpp
index 96ecb39..7605e88 100644
--- a/src/engine/machina/Problem.hpp
+++ b/src/engine/machina/Problem.hpp
@@ -18,6 +18,7 @@
 #ifndef MACHINA_PROBLEM_HPP
 #define MACHINA_PROBLEM_HPP
 
+#include <map>
 #include <raul/MIDISink.hpp>
 #include <eugene/core/Problem.hpp>
 #include <machina/Machine.hpp>
@@ -34,13 +35,20 @@ public:
 	float fitness(const Machine& machine) const;
 	
 	bool fitness_less_than(float a, float b) const { return a < b; }
+
+	void clear_fitness_cache() { _fitness.clear(); }
 	
 	boost::shared_ptr<Population>
 	initial_population(size_t gene_size, size_t pop_size) const;
 
 private:
-	struct Evaluator : public Raul::MIDISink {
-		Evaluator(const Problem& problem) : _problem(problem), _n_notes(0), _length(0) {
+	size_t distance(const std::vector<uint8_t>& source,
+	                const std::vector<uint8_t>& target) const;
+
+	// count
+	/*struct FreqEvaluator : public Raul::MIDISink {
+		Evaluator(const Problem& problem)
+		: _problem(problem), _n_notes(0), _length(0) {
 			for (uint8_t i=0; i < 128; ++i)
 				_note_frequency[i] = 0;
 		}
@@ -49,14 +57,62 @@ private:
 		                 const uint8_t* ev) throw (std::logic_error);
 		void compute();
 		const Problem& _problem;
+		
+		size_t n_notes() const { return _n_notes; }
 	
 		float  _note_frequency[128];
 		size_t _n_notes;
 		double _length;
+	};*/
+
+	// distance
+	/*struct Evaluator : public Raul::MIDISink {
+		Evaluator(const Problem& problem) : _problem(problem) {}
+		void write_event(Raul::BeatTime time,
+		                 size_t         ev_size,
+		                 const uint8_t* ev) throw (std::logic_error);
+		void compute();
+		const Problem& _problem;
+
+		size_t n_notes() const { return _notes.size(); }
+	
+		std::vector<uint8_t> _notes;
+		float                _counts[128];
+	};*/
+	
+	struct Evaluator : public Raul::MIDISink {
+		Evaluator(const Problem& problem) : _problem(problem), _order(8), _n_notes(0), _first_note(0) {
+			for (uint8_t i=0; i < 128; ++i)
+				_counts[i] = 0;
+		}
+		void write_event(Raul::BeatTime time,
+		                 size_t         ev_size,
+		                 const uint8_t* ev) throw (std::logic_error);
+		void compute();
+		const Problem& _problem;
+
+		size_t n_notes() const { return _n_notes; }
+		uint8_t first_note() const { return _first_note; }
+	
+		const uint32_t _order;
+
+		std::string _read;
+
+		typedef std::map<std::string, uint32_t> Patterns;
+		Patterns _patterns;
+		uint32_t _counts[128];
+		size_t   _n_notes;
+		uint8_t  _first_note;
 	};
 
 	Evaluator          _target;
 	SharedPtr<Machine> _seed;
+	
+	/// for levenshtein distance
+	mutable std::vector< std::vector<uint16_t> > _matrix;
+
+	/// memoization
+	mutable std::map<Machine*, float> _fitness;
 };