[Avida-cvs] [avida-svn] r926 - development/documentation
brysonda at myxo.css.msu.edu
brysonda at myxo.css.msu.edu
Tue Sep 5 06:51:40 PDT 2006
Author: brysonda
Date: 2006-09-05 09:51:40 -0400 (Tue, 05 Sep 2006)
New Revision: 926
Modified:
development/documentation/code_genome.html
development/documentation/code_instruction.html
development/documentation/code_life_cycle.html
development/documentation/code_standards.html
development/documentation/code_task.html
development/documentation/config.html
development/documentation/cpu_tour.html
development/documentation/environment.html
development/documentation/events.html
development/documentation/inst_set.html
development/documentation/main.css
development/documentation/print_data.html
development/documentation/structure.html
development/documentation/svn.html
Log:
Finish basic documentation semantic styling.
Modified: development/documentation/code_genome.html
===================================================================
--- development/documentation/code_genome.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/code_genome.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-30 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p><a href="index.html">Return to the Index</a></p>
@@ -32,35 +32,35 @@
</p>
<pre>
-class <span style="color: #880000">cInstruction</span> {
+class <span class="class">cInstruction</span> {
private:
- unsigned char <span style="color: #000088">m_operand</span>;
+ unsigned char <span class="object">m_operand</span>;
public:
- <span style="color: #886600">// Constructors and Destructor...</span>
- <span style="color: #008800">cInstruction()</span> : <span style="color: #000088">m_operand</span>(0) { ; }
- <span style="color: #008800">cInstruction</span>(const <span style="color: #880000">cInstruction</span>& <span style="color: #000088">inst</span>) { *<span style="color: #000088">this</span> = <span style="color: #000088">inst</span>; }
- explicit <span style="color: #008800">cInstruction</span>(<span style="color: #880000">int</span> <span style="color: #000088">in_op</span>) { <span style="color: #008800">SetOp</span>(<span style="color: #000088">in_op</span>); }
- <span style="color: #008800">~cInstruction</span>() { ; }
+ <span class="comment">// Constructors and Destructor...</span>
+ <span class="method">cInstruction</span>() : <span class="object">m_operand</span>(0) { ; }
+ <span class="method">cInstruction</span>(const <span class="class">cInstruction</span>& <span class="object">inst</span>) { *<span class="object">this</span> = <span class="object">inst</span>; }
+ explicit <span class="method">cInstruction</span>(<span class="class">int</span> <span class="object">in_op</span>) { <span class="method">SetOp</span>(<span class="object">in_op</span>); }
+ <span class="method">~cInstruction</span>() { ; }
- <span style="color: #886600">// Accessors...</span>
- <span style="color: #880000">int</span> <span style="color: #008800">GetOp()</span> const { return static_cast<int>(<span style="color: #000088">m_operand</span>); }
- void <span style="color: #008800">SetOp</span>(<span style="color: #880000">int</span> <span style="color: #000088">in_op</span>) { <span style="color: #008800">assert</span>(<span style="color: #000088">in_op</span> < 256); <span style="color: #000088">m_operand</span> = <span style="color: #000088">in_op</span>; }
+ <span class="comment">// Accessors...</span>
+ <span class="class">int</span> <span class="method">GetOp()</span> const { return static_cast<int>(<span class="object">m_operand</span>); }
+ void <span class="method">SetOp</span>(<span class="class">int</span> <span class="object">in_op</span>) { <span class="method">assert</span>(<span class="object">in_op</span> < 256); <span class="object">m_operand</span> = <span class="object">in_op</span>; }
- <span style="color: #886600">// Operators...</span>
- void <span style="color: #008800">operator=</span>(const <span style="color: #880000">cInstruction</span>& <span style="color: #000088">inst</span>) { <span style="color: #000088">m_operand</span> = <span style="color: #000088">inst</span>.<span style="color: #000088">m_operand</span>; }
- <span style="color: #880000">bool</span> <span style="color: #008800">operator==</span>(const <span style="color: #880000">cInstruction</span>& <span style="color: #000088">inst</span>) const { return (<span style="color: #000088">m_operand</span> == <span style="color: #000088">inst</span>.<span style="color: #000088">m_operand</span>); }
- <span style="color: #880000">bool</span> <span style="color: #008800">operator!=</span>(const <span style="color: #880000">cInstruction</span>& <span style="color: #000088">inst</span>) const { return !(<span style="color: #008800">operator==</span>(<span style="color: #000088">inst</span>)); }
+ <span class="comment">// Operators...</span>
+ void <span class="method">operator=</span>(const <span class="class">cInstruction</span>& <span class="object">inst</span>) { <span class="object">m_operand</span> = <span class="object">inst</span>.<span class="object">m_operand</span>; }
+ <span class="class">bool</span> <span class="method">operator==</span>(const <span class="class">cInstruction</span>& <span class="object">inst</span>) const { return (<span class="object">m_operand</span> == <span class="object">inst</span>.<span class="object">m_operand</span>); }
+ <span class="class">bool</span> <span class="method">operator!=</span>(const <span class="class">cInstruction</span>& <span class="object">inst</span>) const { return !(<span class="method">operator==</span>(<span class="object">inst</span>)); }
- <span style="color: #886600">// Some extra methods to convert too and from alpha-numeric symbols...</span>
- <span style="color: #880000">char</span> <span style="color: #008800">GetSymbol</span>() const;
- void <span style="color: #008800">SetSymbol</span>(<span style="color: #880000">char</span> <span style="color: #000088">symbol</span>);
+ <span class="comment">// Some extra methods to convert too and from alpha-numeric symbols...</span>
+ <span class="class">char</span> <span class="method">GetSymbol</span>() const;
+ void <span class="method">SetSymbol</span>(<span class="class">char</span> <span class="object">symbol</span>);
};
</pre>
<p>
As stated above, the only private datum is a numerical value that identifies
-this instruction. The name <span style="color: #000088">m_operand</span> is the term
+this instruction. The name <span class="object">m_operand</span> is the term
that is used for a command name in an assembly language. Most normal assembly
languages have both an operand and arguments associated with each full command.
In Avida, the commands have no arguments, and hence they just consist of a
@@ -75,12 +75,12 @@
make up over half of all the memory resources used by Avida.
</p>
<p>
-The public methods begin with the <span style="color: #008800">GetOp</span>() and
-<span style="color: #008800">SetOp</span>() methods, which are standard accessors.
+The public methods begin with the <span class="method">GetOp</span>() and
+<span class="method">SetOp</span>() methods, which are standard accessors.
Next, we have a collection of methods that begin with the word 'operator'.
These are used to define how the corresponding symbols should be treated
when applied to objects of this class. For example, the method
-<span style="color: #008800">operator==</span>() is called when we try to compare
+<span class="method">operator==</span>() is called when we try to compare
an object of type cInstruction to another. We have full control over the
definition of this method, just like any other.
</p>
@@ -105,43 +105,43 @@
</p>
<pre>
-class <span style="color: #880000">cGenome</span>
+class <span class="class">cGenome</span>
{
protected:
- <span style="color: #880000">tArray</span><<span style="color: #880000">cInstruction</span>> <span style="color: #000088">genome</span>;
- int <span style="color: #000088">active_size</span>;
+ <span class="class">tArray</span><<span class="class">cInstruction</span>> <span class="object">genome</span>;
+ int <span class="object">active_size</span>;
public:
- <span style="color: #008800">cGenome</span>() { ; }
- explicit <span style="color: #008800">cGenome</span>(int <span style="color: #000088">_size</span>);
- <span style="color: #008800">cGenome</span>(const <span style="color: #880000">cGenome</span>& <span style="color: #000088">in_genome</span>);
- <span style="color: #008800">cGenome</span>(const <span style="color: #880000">cString</span>& <span style="color: #000088">in_string</span>);
- virtual <span style="color: #008800">~cGenome</span>();
+ <span class="method">cGenome</span>() { ; }
+ explicit <span class="method">cGenome</span>(int <span class="object">_size</span>);
+ <span class="method">cGenome</span>(const <span class="class">cGenome</span>& <span class="object">in_genome</span>);
+ <span class="method">cGenome</span>(const <span class="class">cString</span>& <span class="object">in_string</span>);
+ virtual <span class="method">~cGenome</span>();
- virtual void <span style="color: #008800">operator=</span>(const <span style="color: #880000">cGenome</span>& <span style="color: #000088">other_genome</span>);
- virtual bool <span style="color: #008800">operator==</span>(const <span style="color: #880000">cGenome</span>& <span style="color: #000088">other_genome</span>) const;
- virtual bool <span style="color: #008800">operator!=</span>(const <span style="color: #880000">cGenome</span>& <span style="color: #000088">other_genome</span>) const { return !(<span style="color: #000088">this</span>-><span style="color: #008800">operator==</span>(<span style="color: #000088">other_genome</span>)); }
- virtual bool <span style="color: #008800">operator<</span>(const <span style="color: #880000">cGenome</span>& <span style="color: #000088">other_genome</span>) const { return <span style="color: #008800">AsString</span>() < <span style="color: #000088">other_genome</span>.<span style="color: #008800">AsString</span>(); }
+ virtual void <span class="method">operator=</span>(const <span class="class">cGenome</span>& <span class="object">other_genome</span>);
+ virtual bool <span class="method">operator==</span>(const <span class="class">cGenome</span>& <span class="object">other_genome</span>) const;
+ virtual bool <span class="method">operator!=</span>(const <span class="class">cGenome</span>& <span class="object">other_genome</span>) const { return !(<span class="object">this</span>-><span class="method">operator==</span>(<span class="object">other_genome</span>)); }
+ virtual bool <span class="method">operator<</span>(const <span class="class">cGenome</span>& <span class="object">other_genome</span>) const { return <span class="method">AsString</span>() < <span class="object">other_genome</span>.<span class="method">AsString</span>(); }
- <span style="color: #880000">cInstruction</span>& <span style="color: #008800">operator[]</span>(int <span style="color: #000088">index</span>) { <span style="color: #008800">assert</span>(<span style="color: #000088">index</span> >= 0 && <span style="color: #000088">index</span> < <span style="color: #000088">active_size</span>); return <span style="color: #000088">genome</span>[<span style="color: #000088">index</span>]; }
- const <span style="color: #880000">cInstruction</span>& <span style="color: #008800">operator[]</span>(<span style="color: #880000">int</span> <span style="color: #000088">index</span>) const { <span style="color: #008800">assert</span>(<span style="color: #000088">index</span> >= 0 && <span style="color: #000088">index</span> < <span style="color: #000088">active_size</span>); return <span style="color: #000088">genome</span>[<span style="color: #000088">index</span>]; }
+ <span class="class">cInstruction</span>& <span class="method">operator[]</span>(int <span class="object">index</span>) { <span class="method">assert</span>(<span class="object">index</span> >= 0 && <span class="object">index</span> < <span class="object">active_size</span>); return <span class="object">genome</span>[<span class="object">index</span>]; }
+ const <span class="class">cInstruction</span>& <span class="method">operator[]</span>(<span class="class">int</span> <span class="object">index</span>) const { <span class="method">assert</span>(<span class="object">index</span> >= 0 && <span class="object">index</span> < <span class="object">active_size</span>); return <span class="object">genome</span>[<span class="object">index</span>]; }
- virtual void <span style="color: #008800">Copy</span>(int <span style="color: #000088">to</span>, int <span style="color: #000088">from</span>);
+ virtual void <span class="method">Copy</span>(int <span class="object">to</span>, int <span class="object">from</span>);
- int <span style="color: #008800">GetSize</span>() const { return <span style="color: #000088">active_size</span>; }
- <span style="color: #880000">cString</span> <span style="color: #008800">AsString</span>() const;
+ int <span class="method">GetSize</span>() const { return <span class="object">active_size</span>; }
+ <span class="class">cString</span> <span class="method">AsString</span>() const;
};
</pre>
<p>
-The protected variable <span style="color: #000088">genome</span> is an array
+The protected variable <span class="object">genome</span> is an array
containing an object of type cInstruction at each position. The second
-variable <span style="color: #000088">active_size</span> denotes the number of
+variable <span class="object">active_size</span> denotes the number of
instructions in this array that are currently being used. The fact that
these variables are "protected" instead of "private" means that any
-class derived from <span style="color: #880000">cGenome</span> will also have direct
+class derived from <span class="class">cGenome</span> will also have direct
access to the variables. In particular, the class
-<span style="color: #880000">cCPUMemory</span> extends cGenome, adding methods to
+<span class="class">cCPUMemory</span> extends cGenome, adding methods to
alter the array length and new variables to keep track of information about
each instruction.
</p>
@@ -154,7 +154,7 @@
The operators created for manipulating genomes include both assignment
(setting one genome equal to another) and comparison (testing to see if
two genomes are identical.) Additionally, there are two
-<span style="color: #008800">operator[]</span> methods. This means that if you
+<span class="method">operator[]</span> methods. This means that if you
have an object of type cGenome, you can index into it to retrieve a single
instruction. Thus, if the object was called <code>initial_genome</code>, the
statement <code>initial_genome[15]</code> would return the instruction at
@@ -167,13 +167,13 @@
returned.
</p>
<p>
-The <span style="color: #008800">Copy(</span>) method is a shortcut to copy memory
+The <span class="method">Copy(</span>) method is a shortcut to copy memory
from one position in the genome to another. This method will later be
<strong>overloaded</strong> (that is, replaced with a newer version) by
cCPUMemory such that the proper flags will be copied, with the instruction
and others will be set to indicate the copied instruction for future tests.
-<span style="color: #008800">GetSize</span>() returns the length of the genome, and
-<span style="color: #008800">AsString</span>() returns a string who has symbols in
+<span class="method">GetSize</span>() returns the length of the genome, and
+<span class="method">AsString</span>() returns a string who has symbols in
each position that correspond to the the instruction in the same position in
the genome.
</p>
Modified: development/documentation/code_instruction.html
===================================================================
--- development/documentation/code_instruction.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/code_instruction.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-31 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p><a href="index.html">Return to the Index</a></p>
@@ -35,7 +35,7 @@
of subtracting 17 from the ?BX? register), you would add the line:
</p>
<pre>
-bool <span style="color: #008800">Inst_Minus17</span>(<span style="color: #880000">cAvidaContext</span>& <span style="color: #000088">ctx</span>);
+bool <span class="method">Inst_Minus17</span>(<span class="class">cAvidaContext</span>& <span class="object">ctx</span>);
</pre>
<p>
@@ -47,7 +47,7 @@
</p>
<p>
All methods associated with instructions return a
-<span style="color: #880000">bool</span> value that determines if it was
+<span class="class">bool</span> value that determines if it was
successfully executed. Most instructions will always return true since they
have now way to fail. The convention that we use to designate a method
explicitly associated with an instruction is placing a prefix of
@@ -61,17 +61,17 @@
</p>
<pre>
-void <span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">Inst_Minus17</span>(<span style="color: #880000">cAvidaContext</span>& <span style="color: #000088">ctx</span>)
+void <span class="class">cHardwareCPU</span>::<span class="method">Inst_Minus17</span>(<span class="class">cAvidaContext</span>& <span class="object">ctx</span>)
{
- const <span style="color: #880000">int</span> <span style="color: #000088">reg_used</span> = <span style="color: #008800">FindModifiedRegister</span>(nHardwareCPU::REG_BX);
- <span style="color: #008800">GetRegister</span>(<span style="color: #000088">reg_used</span>) -= 17;
+ const <span class="class">int</span> <span class="object">reg_used</span> = <span class="method">FindModifiedRegister</span>(nHardwareCPU::REG_BX);
+ <span class="method">GetRegister</span>(<span class="object">reg_used</span>) -= 17;
return true;
}
</pre>
<p>
The first line of this method uses a helper function called
-<span style="color: #008800">FindModifiedRegister</span>() to identify the register
+<span class="method">FindModifiedRegister</span>() to identify the register
that should be affected (it scans the next instruction to test if it is a
<code>nop</code>), with a default value of <code>REG_BX</code> passed in.
The second line then subtracts 17 from the value in that register. The
@@ -89,11 +89,11 @@
<h2>2. Link the instruction name to its method</h2>
For this step, you will need to edit the code file. You would go into the method
-<span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">initInstLib</span>()
+<span class="class">cHardwareCPU</span>::<span class="method">initInstLib</span>()
and add in the line
<pre>
-<span style="color: #880000">cInstEntryCPU</span>("minus-17", &<span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">Inst_Minus17</span>);
+<span class="class">cInstEntryCPU</span>("minus-17", &<span class="class">cHardwareCPU</span>::<span class="method">Inst_Minus17</span>);
</pre>
<p>
@@ -102,9 +102,9 @@
<p>
Since we want to use a pointer to the appropriate method, that is what we
must pass into the dictionary. To obtain said pointer, we must list the class
-the function is part of (<span style="color: #880000">cHardwareCPU</span>) follow it
+the function is part of (<span class="class">cHardwareCPU</span>) follow it
by a double colon (::) and then give the method name
-(<span style="color: #008800">Inst_Minus17</span>) <em>without</em> the normal
+(<span class="method">Inst_Minus17</span>) <em>without</em> the normal
parentheses following it. The parentheses indicate that we should execute
the method. Without them, it is just the data that represents the method,
and by preceding this whole mess with an ampersand ('&') we get the pointer
@@ -171,9 +171,9 @@
<dl>
<dt>
<pre>
-void <span style="color: #008800">StackPush</span>(<span style="color: #880000">int</span> <span style="color: #000088">value</span>);
-<span style="color: #880000">int</span> <span style="color: #008800">StackPop</span>();
-void <span style="color: #008800">SwitchStack</span>();
+void <span class="method">StackPush</span>(<span class="class">int</span> <span class="object">value</span>);
+<span class="class">int</span> <span class="method">StackPop</span>();
+void <span class="method">SwitchStack</span>();
</pre>
</dt>
<dd>
@@ -184,8 +184,8 @@
</dd>
<dt>
<pre>
-<span style="color: #880000">cCPUHead</span>& <span style="color: #008800">GetHead</span>(int <span style="color: #000088">head_id</span>);
-<span style="color: #880000">cCPUHead</span>& <span style="color: #008800">IP</span>();</pre>
+<span class="class">cCPUHead</span>& <span class="method">GetHead</span>(int <span class="object">head_id</span>);
+<span class="class">cCPUHead</span>& <span class="method">IP</span>();</pre>
</dt>
<dd>
Each thread in a CPU has four heads associated with it, designated by the
@@ -201,7 +201,7 @@
</dd>
<dt>
<pre>
-int& <span style="color: #008800">Register</span>(int <span style="color: #000088">reg_id</span>);
+int& <span class="method">Register</span>(int <span class="object">reg_id</span>);
</pre>
</dt>
<dd>
@@ -213,7 +213,7 @@
</dd>
<dt>
<pre>
-<span style="color: #880000">cCPUMemory</span>& <span style="color: #008800">GetMemory</span>();
+<span class="class">cCPUMemory</span>& <span class="method">GetMemory</span>();
</pre>
</dt>
<dd>
@@ -243,9 +243,9 @@
<dl>
<dt>
<pre>
-void <span style="color: #008800">ReadLabel</span>();
-<span style="color: #880000">cCodeLabel</span>& <span style="color: #008800">GetLabel</span>();
-<span style="color: #880000">cCPUHead</span> <span style="color: #008800">FindLabel</span>(int <span style="color: #000088">direction</span>);
+void <span class="method">ReadLabel</span>();
+<span class="class">cCodeLabel</span>& <span class="method">GetLabel</span>();
+<span class="class">cCPUHead</span> <span class="method">FindLabel</span>(int <span class="object">direction</span>);
</pre>
</dt>
<dd>
@@ -264,8 +264,8 @@
</dd>
<dt>
<pre>
-int <span style="color: #008800">FindModifiedRegister</span>(int <span style="color: #000088">default_register</span>);
-int <span style="color: #008800">FindModifiedHead</span>(int <span style="color: #000088">default_head</span>);
+int <span class="method">FindModifiedRegister</span>(int <span class="object">default_register</span>);
+int <span class="method">FindModifiedHead</span>(int <span class="object">default_head</span>);
</pre>
</dt>
<dd>
@@ -278,7 +278,7 @@
</dd>
<dt>
<pre>
-int <span style="color: #008800">FindComplementRegister</span>(int <span style="color: #000088">base_reg</span>);
+int <span class="method">FindComplementRegister</span>(int <span class="object">base_reg</span>);
</pre>
</dt>
<dd>
Modified: development/documentation/code_life_cycle.html
===================================================================
--- development/documentation/code_life_cycle.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/code_life_cycle.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-31 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p><a href="index.html">Return to the Index</a></p>
@@ -30,7 +30,7 @@
which will allocate space for an offspring to be placed into. If you look at
the file <kbd>source/cpu/cHardwareCPU.cc</kbd>, you will see that this
instruction is associated with the method
-<span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">Inst_MaxAlloc</span>().
+<span class="class">cHardwareCPU</span>::<span class="method">Inst_MaxAlloc</span>().
What this means is that the organism will automatically allocate as much
space as it possibly can, without having to first calculate its needs. When
the organism is finished copying itself and divides off its child, any excess
@@ -54,7 +54,7 @@
Most of the initial self-analysis done on Avida organisms is with the
<code>search</code> instruction or one of its variants. In the heads based
instruction set, we call this <code>h-search</code> and associate it with the
-method <span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">Inst_HeadSearch</span>().
+method <span class="class">cHardwareCPU</span>::<span class="method">Inst_HeadSearch</span>().
</p>
<p>
The search type instructions read in the template (series of nops) that
@@ -99,13 +99,13 @@
that will read in an instruction from the location of the read-head, and write
it out to the location of the write-head. It will then advance both heads to
the next positions in the genomes. Take a look at the source code for the
-method <span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">Inst_HeadCopy</span>().
+method <span class="class">cHardwareCPU</span>::<span class="method">Inst_HeadCopy</span>().
</p>
<p>
The first thing that happens in this method is the variables
-<span style="color: #000088">read_head</span>,
-<span style="color: #000088">write_head</span>, and
-<span style="color: #000088">cpu_stats</span> are setup as references to the
+<span class="object">read_head</span>,
+<span class="object">write_head</span>, and
+<span class="object">cpu_stats</span> are setup as references to the
appropriate objects in the hardware and organism (that is, any modifications
to these references change the actual objects, not just a local copy of them).
This is so that we have easy to use variables locally for those objects that
@@ -116,12 +116,12 @@
</p>
<p>
Next, the instruction at the read head is recorded in the variable
-<span style="color: #000088">read_inst</span>, and we test to see if this should
+<span class="object">read_inst</span>, and we test to see if this should
be mutated to some other value. If a mutation does occur, we change the
read_inst variable to a random value, increment the mutation count, and mark
flags at the instruction position of the write head to denote the mutation.
After we determine what instruction was read (be it a correct reading or not),
-we call the <span style="color: #008800">ReadInst</span>() method, which is simply
+we call the <span class="method">ReadInst</span>() method, which is simply
used to keep track of the most recent template copied. This template is used
to help detect the end of the organism, which we shall discuss in a moment.
</p>
@@ -166,7 +166,7 @@
When an organism finishes copying itself, it needs to divide off its
child using a divide command. In the heads based instruction set, this is
the <code>h-divide</code> command which calls the
-<span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">Inst_HeadDivide</span>()
+<span class="class">cHardwareCPU</span>::<span class="method">Inst_HeadDivide</span>()
method.
</p>
<p>
@@ -179,11 +179,11 @@
divide instructions in all of the sets).
</p>
<p>
-The <span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">Divide_Main</span>()
+The <span class="class">cHardwareCPU</span>::<span class="method">Divide_Main</span>()
method is therefore what we are most interested in. It begins by calculating
the size of that child that would result from the divide point and the
extra_line count that were passed into it, and runs
-<span style="color: #008800">Divide_CheckViable</span>() to make sure that all of
+<span class="method">Divide_CheckViable</span>() to make sure that all of
these values are legal (that is that both parent and child are reasonable
sizes for organisms, and reasonable sizes in relationship to each other -- for
definitions of reasonable as found in the configuration file). If any of
@@ -191,21 +191,21 @@
</p>
<p>
From this point on, we know the divide is legal, so we just need to process
-it. We create a variable called <span style="color: #000088">child_genome</span>,
+it. We create a variable called <span class="object">child_genome</span>,
which we use to construct the child genome. We use a reference to a cGenome
object inside of the organism so that this child genome is attached to its
parent organism and will be easily accessible from other places where it will
be needed later. We're not going to be doing all of the work on it right in
this method. We initialize the child genome to the section of the parents
genome that was created for it. We then run
-<span style="color: #008800">Resize</span>() on the parent genome to get
+<span class="method">Resize</span>() on the parent genome to get
rid of all of this extra space (both child and extra lines).
</p>
<p>
-The <span style="color: #008800">Divide_DoMutations</span>() method will test and
+The <span class="method">Divide_DoMutations</span>() method will test and
(if needed) process any divide mutations that may occur. There are many of
them, so this method is quite long. It is followed by
-<span style="color: #008800">Divide_TestFitnessMeasures</span>(), which will run the
+<span class="method">Divide_TestFitnessMeasures</span>(), which will run the
offspring through a test CPU for special options that may be set in the
genesis file (such as mutation reversions). Obviously this is very processor
intensive since it would occur with every birth, so tests are only performed
Modified: development/documentation/code_standards.html
===================================================================
--- development/documentation/code_standards.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/code_standards.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-31 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p><a href="index.html">Return to the Index</a></p>
@@ -50,7 +50,7 @@
exception to this rule is single line class methods, in which both braces
are allowed to be on the same line as the code (but only in pairs). Examples:
</p>
- <h5 style="color: #008800">Right:</h5>
+ <h5 class="method">Right:</h5>
<pre>
void cFoo::Method()
{
@@ -63,7 +63,7 @@
inline void Method()
{ // longer code in here }
</pre>
- <h5 style="color: #880000">Wrong:</h5>
+ <h5 class="class">Wrong:</h5>
<pre>
void cFoo::Method() {
// code goes here
@@ -82,13 +82,13 @@
The open brace should go on the same line as the control structure,
the close brace on its own line. Examples:
</p>
- <h5 style="color: #008800">Right:</h5>
+ <h5 class="method">Right:</h5>
<pre>
while (foo) {
// code goes here
}
</pre>
- <h5 style="color: #880000">Wrong:</h5>
+ <h5 class="class">Wrong:</h5>
<pre>
while (foo)
{
@@ -105,7 +105,7 @@
line if else statements should not get braces, unless they accompany a
multi-line statement. Examples:
</p>
- <h5 style="color: #008800">Right:</h5>
+ <h5 class="method">Right:</h5>
<pre>
if (foo) {
DoSomething();
@@ -117,7 +117,7 @@
if (!foo) CallAFunction();
else CallBFunction();
</pre>
- <h5 style="color: #880000">Wrong:</h5>
+ <h5 class="class">Wrong:</h5>
<pre>
if (foo)
{
@@ -145,12 +145,12 @@
parentheses, or before commas that separate arguments. A single space
should follow commas that separate arguments. Examples:
</p>
- <h5 style="color: #008800">Right:</h5>
+ <h5 class="method">Right:</h5>
<pre>
void cFoo::Method(int arg1, double arg2);
int aFunction();
</pre>
- <h5 style="color: #880000">Wrong:</h5>
+ <h5 class="class">Wrong:</h5>
<pre>
void cFoo::Method( int arg1 , double arg2 );
void cFoo::Method (int arg1, double arg2);
Modified: development/documentation/code_task.html
===================================================================
--- development/documentation/code_task.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/code_task.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-30 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p><a href="index.html">Return to the Index</a></p>
@@ -42,7 +42,7 @@
then add the line to this file:
</p>
<pre>
-double <span style="color: #008800">Task_Times2</span>(<span style="color: #880000">cTaskContext</span>* <span style="color: #000088">ctx</span>) const;
+double <span class="method">Task_Times2</span>(<span class="class">cTaskContext</span>* <span class="object">ctx</span>) const;
</pre>
<p>
@@ -63,11 +63,11 @@
</p>
<pre>
-double <span style="color: #880000">cTaskLib</span>::<span style="color: #008800">Task_Times2</span>(<span style="color: #880000">cTaskContext</span>* <span style="color: #000088">ctx</span>) const
+double <span class="class">cTaskLib</span>::<span class="method">Task_Times2</span>(<span class="class">cTaskContext</span>* <span class="object">ctx</span>) const
{
- const <span style="color: #880000">int</span> <span style="color: #000088">test_output</span> = <span style="color: #000088">ctx</span>-><span style="color: #000088">output_buffer</span>[0];
- for (<span style="color: #880000">int</span> <span style="color: #000088">i</span> = 0; <span style="color: #000088">i</span> < <span style="color: #000088">ctx</span>-><span style="color: #000088">input_buffer</span>.<span style="color: #008800">GetNumStored</span>(); <span style="color: #000088">i</span>++) {
- if (2 * <span style="color: #000088">ctx</span>-><span style="color: #000088">input_buffer</span>[i] == <span style="color: #000088">test_output</span>) {
+ const <span class="class">int</span> <span class="object">test_output</span> = <span class="object">ctx</span>-><span class="object">output_buffer</span>[0];
+ for (<span class="class">int</span> <span class="object">i</span> = 0; <span class="object">i</span> < <span class="object">ctx</span>-><span class="object">input_buffer</span>.<span class="method">GetNumStored</span>(); <span class="object">i</span>++) {
+ if (2 * <span class="object">ctx</span>-><span class="object">input_buffer</span>[i] == <span class="object">test_output</span>) {
return 1.0;
}
}
@@ -78,7 +78,7 @@
<p>
The most recent output is always placed at the beginning of the output
buffer, so we store it in the variable
-<span style="color: #000088">test_output</span> to compare it against all of the
+<span class="object">test_output</span> to compare it against all of the
different inputs. We then have a for-loop that goes from 0 to the number
of inputs stored in the input buffer. Inside the body of the loop, we
test for each input if twice that input is equal to the output. If so,
@@ -101,14 +101,14 @@
<p>
This next step is also done in the code file, inside the
-<span style="color: #880000">cTaskLib</span>::<span style="color: #008800">AddTask</span>()
+<span class="class">cTaskLib</span>::<span class="method">AddTask</span>()
method. Again, we want this to be in the same place, so we locate the
task 'echo' that its supposed to follow, and add in the new line.
</p>
<pre>
-else if (<span style="color: #000088">name</span> == "times2")
- <span style="color: #008800">NewTask</span>(<span style="color: #000088">name</span>, "Times2", &<span style="color: #880000">cTaskLib</span>::<span style="color: #008800">Task_Times2</span>);
+else if (<span class="object">name</span> == "times2")
+ <span class="method">NewTask</span>(<span class="object">name</span>, "Times2", &<span class="class">cTaskLib</span>::<span class="method">Task_Times2</span>);
</pre>
<p>
Modified: development/documentation/config.html
===================================================================
--- development/documentation/config.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/config.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-28 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p><a href="index.html">Return to the Index</a></p>
@@ -17,7 +17,7 @@
</div>
<p>
-The Avida configuration file (<kbd style="color: #000088">avida.cfg</kbd>)
+The Avida configuration file (<kbd>avida.cfg</kbd>)
is the main configuration file for Avida. With this file, the user can
setup all of the basic conditions for a run. Below are detailed descriptions
for some of the settings in the configuration file, with particularly important
@@ -50,7 +50,7 @@
default, so you typically won't need to worry about this.
</td>
</tr>
-<tr style="background-color: #AAFFAA">
+<tr class="important">
<td valign="top"><strong><code>
WORLD_X
<br />WORLD_Y
@@ -61,7 +61,7 @@
organisms that are in it.
</td>
</tr>
-<tr style="background-color: #AAFFAA">
+<tr class="important">
<td valign="top"><strong><code>
RANDOM_SEED
</code></strong></td>
@@ -85,14 +85,14 @@
This section relates Avida to other files that it requires.
</p>
<table border="1">
-<tr style="background-color: #AAFFAA">
+<tr class="important">
<td valign="top"><strong><code>DATA_DIR</code></strong></td>
<td>
The name (or path) of the directory where output files generated by
Avida should be placed.
</td>
</tr>
-<tr style="background-color: #AAFFAA">
+<tr class="important">
<td valign="top"><strong><code>
INST_SET
<br />EVENT_FILE
@@ -116,7 +116,7 @@
These settings control how creatures are born and die in Avida.
</p>
<table border="1">
-<tr style="background-color: #AAFFAA">
+<tr class="important">
<td valign="top"><strong><code>BIRTH_METHOD</code></strong></td>
<td>
The birth method sets how the placement of a child organism is
@@ -186,7 +186,7 @@
command to produce an offspring.
</p>
<table border="1">
-<tr style="background-color: #AAFFAA">
+<tr class="important">
<td valign="top"><strong><code>CHILD_SIZE_RANGE</code></strong></td>
<td>
This is the maximal difference in genome size between a parent and
@@ -279,7 +279,7 @@
random numbers to be tested every update.
</td>
</tr>
-<tr style="background-color: #AAFFAA">
+<tr class="important">
<td valign="top"><strong><code>COPY_MUT_PROB</code></strong></td>
<td>
The copy mutation probability is tested each time an organism copies
@@ -288,7 +288,7 @@
of mutations that we use in most of our experiments.
</td>
</tr>
-<tr style="background-color: #AAFFAA">
+<tr class="important">
<td valign="top"><strong><code>
INS_MUT_PROB
<br />DEL_MUT_PROB
@@ -302,7 +302,7 @@
Multiple insertions and deletions are possible each generation.
</td>
</tr>
-<tr style="background-color: #AAFFAA">
+<tr class="important">
<td valign="top"><strong><code>
DIVIDE_MUT_PROB
<br />DIVIDE_INS_PROB
@@ -534,7 +534,7 @@
required to raise this number.
</td>
</tr>
-<tr style="background-color: #AAFFAA">
+<tr class="important">
<td valign="top"><strong><code>TRACK_MAIN_LINEAGE</code></strong></td>
<td>
In a normal Avida run, the genebank keeps track of all existing
@@ -562,7 +562,7 @@
<tr>
<td valign="top"><strong><code>LOG_CREATURES</code></strong></td>
<td>
- If toggle is set, print an entry to <kbd style="#000088">creature.log</kbd>
+ If toggle is set, print an entry to <kbd>creature.log</kbd>
whenever a new organism is born. Include position information, parent
organism, and a link to it genotype so the run can be reconstructed.
This gets <em>very</em> large.
@@ -571,7 +571,7 @@
<tr>
<td valign="top"><strong><code>LOG_GENOTYPES</code></strong></td>
<td>
- If toggle is set, print an entry to <kbd style="#000088">genotype.log</kbd>
+ If toggle is set, print an entry to <kbd>genotype.log</kbd>
whenever a new genotype is created. Includes information on its parent
genotype.
</td>
@@ -579,7 +579,7 @@
<tr>
<td valign="top"><strong><code>LOG_THRESHOLD</code></strong></td>
<td>
- If toggle is set, print an entry to <kbd style="#000088">threshold.log</kbd>
+ If toggle is set, print an entry to <kbd>threshold.log</kbd>
whenever a genotype reaches threshold. Includes information on what
species it is.
</td>
@@ -587,7 +587,7 @@
<tr>
<td valign="top"><strong><code>LOG_SPECIES</code></strong></td>
<td>
- If toggle is set, print an entry to <kbd style="#000088">species.log</kbd>
+ If toggle is set, print an entry to <kbd>species.log</kbd>
whenever a new species is created. Includes information on the
genotype the triggered the creation.
</td>
@@ -596,7 +596,7 @@
<td valign="top"><strong><code>LOG_LINEAGES</code></strong></td>
<td>
Lineages can be given unique identifies and printed (into the file
- <kbd style="#000088">lineage.log</kbd>) whenever they are created.
+ <kbd>lineage.log</kbd>) whenever they are created.
Includes details about the event that created the lineage.
</td>
</tr>
Modified: development/documentation/cpu_tour.html
===================================================================
--- development/documentation/cpu_tour.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/cpu_tour.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-28 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p><a href="index.html">Return to the Index</a></p>
Modified: development/documentation/environment.html
===================================================================
--- development/documentation/environment.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/environment.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-28 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p><a href="index.html">Return to the Index</a></p>
@@ -44,10 +44,10 @@
<div align="center">
<p> </p>
-<h3>Table 1: <span style="color: #004400">Resource Specifications</span></h3>
+<h3>Table 1: <span>Resource Specifications</span></h3>
<p>
-(<span style="color: #0000AA">blue</span> variables used for all resources
-while <span style="color: #AA0000">red</span> variables are only used for
+(<span class="resall">blue</span> variables used for all resources
+while <span class="resspatial">red</span> variables are only used for
spatial resources)
</p>
<table border="1" cellpadding="2">
@@ -57,7 +57,7 @@
<th>Default</th>
</tr>
<tr>
- <td style="color: #0000AA">inflow</td>
+ <td class="resall">inflow</td>
<td>
The number of units of the resource that enter the population over
the course of an update. For a global resource this inflow
@@ -69,7 +69,7 @@
<td>0</td>
</tr>
<tr>
- <td style="color: #0000AA">outflow</td>
+ <td class="resall">outflow</td>
<td>
The fraction of the resource that will flow out of the population
each update. As with inflow, this happens continuously over the
@@ -81,7 +81,7 @@
<td>0.0</td>
</tr>
<tr>
- <td style="color: #0000AA">initial</td>
+ <td class="resall">initial</td>
<td>
The initial abundance of the resource in the population at the
start of an experiment. For a spatial resource the initial
@@ -90,7 +90,7 @@
<td>0</td>
</tr>
<tr>
- <td style="color: #0000AA">geometry</td>
+ <td class="resall">geometry</td>
<td>
The layout of the resource in space.<br>
<em>global</em> -- the entire pool of a resource is
@@ -105,7 +105,7 @@
<td>global</td>
</tr>
<tr>
- <td style="color: #AA0000">inflowx1</td>
+ <td class="resspatial">inflowx1</td>
<td>
Leftmost coordinate of the rectange where resource will flow
into world grid.
@@ -113,7 +113,7 @@
<td>0</td>
</tr>
<tr>
- <td style="color: #AA0000">inflowx2</td>
+ <td class="resspatial">inflowx2</td>
<td>
Rightmost coordinate of the rectange where resource will flow
into world grid.
@@ -121,7 +121,7 @@
<td>0</td>
</tr>
<tr>
- <td style="color: #AA0000">inflowy1</td>
+ <td class="resspatial">inflowy1</td>
<td>
Topmost coordinate of the rectange where resource will flow
into world grid.
@@ -129,7 +129,7 @@
<td>0</td>
</tr>
<tr>
- <td style="color: #AA0000">inflowy2</td>
+ <td class="resspatial">inflowy2</td>
<td>
Bottommost coordinate of the rectange where resource will flow
into world grid.
@@ -137,7 +137,7 @@
<td>0</td>
</tr>
<tr>
- <td style="color: #AA0000">outflowx1</td>
+ <td class="resspatial">outflowx1</td>
<td>
Leftmost coordinate of the rectange where resource will flow
out of world grid.
@@ -145,7 +145,7 @@
<td>0</td>
</tr>
<tr>
- <td style="color: #AA0000">outflowx2</td>
+ <td class="resspatial">outflowx2</td>
<td>
Rightmost coordinate of the rectange where resource will flow
out of world grid.
@@ -153,7 +153,7 @@
<td>0</td>
</tr>
<tr>
- <td style="color: #AA0000">outflowy1</td>
+ <td class="resspatial">outflowy1</td>
<td>
Topmost coordinate of the rectange where resource will flow
out of world grid.
@@ -161,7 +161,7 @@
<td>0</td>
</tr>
<tr>
- <td style="color: #AA0000">outflowy2</td>
+ <td class="resspatial">outflowy2</td>
<td>
Bottommost coordinate of the rectange where resource will flow
out of world grid.
@@ -169,7 +169,7 @@
<td>0</td>
</tr>
<tr>
- <td style="color: #AA0000">xdiffuse</td>
+ <td class="resspatial">xdiffuse</td>
<td>
How fast material will diffuse right <em>and</em> left. This flow
depends on the amount of resources in a given cell and amount in
@@ -178,7 +178,7 @@
<td>1.0</td>
</tr>
<tr>
- <td style="color: #AA0000">xgravity</td>
+ <td class="resspatial">xgravity</td>
<td>
How fast material will move to the right <em>or</em> left. This
movement depends only on the amount of resource in a given cell.
@@ -187,7 +187,7 @@
<td>0</td>
</tr>
<tr>
- <td style="color: #AA0000">ydiffuse</td>
+ <td class="resspatial">ydiffuse</td>
<td>
How fast material will diffuse up <em>and</em> down. This flow
depends on the amount of resources in a given cell and amount in
@@ -196,7 +196,7 @@
<td>1.0</td>
</tr>
<tr>
- <td style="color: #AA0000">ygravity</td>
+ <td class="resspatial">ygravity</td>
<td>
How fast material will move to the up <em>or</em> down. This
movement depends only on the amount of resource in a given cell.
@@ -247,35 +247,35 @@
<div align="center">
<p> </p>
-<h3>Table 2: <span style="color: #004400">Available Tasks</span></h3>
+<h3>Table 2: <span>Available Tasks</span></h3>
<table border="1" cellpadding="2">
<tr>
<th>Task</th>
<th>Description</th>
</tr>
<tr>
- <td style="color: #0000AA">echo</td>
+ <td class="resall">echo</td>
<td>
This task is triggered when an organism inputs a single number and
outputs it without modification.
</td>
</tr>
<tr>
- <td style="color: #0000AA">add</td>
+ <td class="resall">add</td>
<td>
This task is triggered when an organism inputs two numbers, sums them
together, and outputs the result.
</td>
</tr>
<tr>
- <td style="color: #0000AA">sub</td>
+ <td class="resall">sub</td>
<td>
This task is triggered when an organism inputs two numbers, subtracts
one from the other, and outputs the result.
</td>
</tr>
<tr>
- <td style="color: #0000AA">not</td>
+ <td class="resall">not</td>
<td>
This task is triggered when an organism inputs a 32 bit number,
toggles all of the bits, and outputs the result. This is typically
@@ -286,7 +286,7 @@
</td>
</tr>
<tr>
- <td style="color: #0000AA">nand</td>
+ <td class="resall">nand</td>
<td>
This task is triggered when two 32 bit numbers are input, the values
are 'nanded' together in a bitwise fashion, and the result is output.
@@ -296,7 +296,7 @@
</td>
</tr>
<tr>
- <td style="color: #0000AA">and</td>
+ <td class="resall">and</td>
<td>
This task is triggered when two 32 bit numbers are input, the values
are 'anded' together in a bitwise fashion, and the result is output.
@@ -305,7 +305,7 @@
</td>
</tr>
<tr>
- <td style="color: #0000AA">orn</td>
+ <td class="resall">orn</td>
<td>
This task is triggered when two 32 bit numbers are input, the values
are 'orn' together in a bitwise fashion, and the result is output.
@@ -314,7 +314,7 @@
</td>
</tr>
<tr>
- <td style="color: #0000AA">or</td>
+ <td class="resall">or</td>
<td>
This task is triggered when two 32 bit numbers are input, the values
are 'ored' together in a bitwise fashion, and the result is output.
@@ -323,7 +323,7 @@
</td>
</tr>
<tr>
- <td style="color: #0000AA">andn</td>
+ <td class="resall">andn</td>
<td>
This task is triggered when two 32 bit numbers are input, the values
are 'andn-ed' together in a bitwise fashion, and the result is output.
@@ -333,7 +333,7 @@
</td>
</tr>
<tr>
- <td style="color: #0000AA">nor</td>
+ <td class="resall">nor</td>
<td>
This task is triggered when two 32 bit numbers are input, the values
are 'nored' together in a bitwise fashion, and the result is output.
@@ -342,7 +342,7 @@
</td>
</tr>
<tr>
- <td style="color: #0000AA">xor</td>
+ <td class="resall">xor</td>
<td>
This task is triggered when two 32 bit numbers are input, the values
are 'xored' together in a bitwise fashion, and the result is output.
@@ -352,7 +352,7 @@
</td>
</tr>
<tr>
- <td style="color: #0000AA">equ</td>
+ <td class="resall">equ</td>
<td>
This task is triggered when two 32 bit numbers are input, the values
are equated together in a bitwise fashion, and the result is output.
@@ -361,7 +361,7 @@
</td>
</tr>
<tr>
- <td style="color: #0000AA">logic_3AA-<br />logic_3CP</td>
+ <td class="resall">logic_3AA-<br />logic_3CP</td>
<td>
These tasks include all 68 possible unique 3-input logic operations,
many of which don't have easy-to-understand human readable names.
@@ -381,7 +381,7 @@
<div align="center">
<p> </p>
-<h3>Table 3: <span style="color: #004400">Reaction Process Specifications</span></h3>
+<h3>Table 3: <span>Reaction Process Specifications</span></h3>
<table border="1" cellpadding="2">
<tr>
<th>Argument</th>
@@ -389,7 +389,7 @@
<th>Default</th>
</tr>
<tr>
- <td style="color: #0000AA">resource</td>
+ <td class="resall">resource</td>
<td>
The name of the resource consumed. By default, no resource is being
consumed, and the 'max' limit is the amount absorbed.
@@ -397,7 +397,7 @@
<td>infinite</td>
</tr>
<tr>
- <td style="color: #0000AA">value</td>
+ <td class="resall">value</td>
<td>
Multiply the value set here by the amount of the resource consumed
to obtain the bonus. (0.5 may be inefficient, while 5.0 is very
@@ -407,7 +407,7 @@
<td>1.0</td>
</tr>
<tr>
- <td style="color: #0000AA">type</td>
+ <td class="resall">type</td>
<td>
Determines how to apply the bonus (i.e. the amount of the resource
absorbed times the value of this process) to change the merit of the
@@ -422,12 +422,12 @@
<td>add</td>
</tr>
<tr>
- <td style="color: #0000AA">max</td>
+ <td class="resall">max</td>
<td>The maximum amount of the resource consumed per occurrence.</td>
<td>1.0</td>
</tr>
<tr>
- <td style="color: #0000AA">min</td>
+ <td class="resall">min</td>
<td>
The minimum amount of resource required. If less than this quantity
is available, the reaction ceases to proceed.
@@ -435,12 +435,12 @@
<td>0.0</td>
</tr>
<tr>
- <td style="color: #0000AA">frac</td>
+ <td class="resall">frac</td>
<td>The maximum fraction of the available resource that can be consumed.</td>
<td>1.0</td>
</tr>
<tr>
- <td style="color: #0000AA">product</td>
+ <td class="resall">product</td>
<td>
The name of the by-product resource. At the moment, only a single
by-product can be produced at a time.
@@ -448,12 +448,12 @@
<td>none</td>
</tr>
<tr>
- <td style="color: #0000AA">conversion</td>
+ <td class="resall">conversion</td>
<td>The conversion rate to by-product resource</td>
<td>1.0</td>
</tr>
<tr>
- <td style="color: #0000AA">inst</td>
+ <td class="resall">inst</td>
<td>
The instruction that gets executed when this reaction gets preformed. If
you do not want an organism to be able to have the instruction in their
@@ -463,7 +463,7 @@
<td>none</td>
</tr>
<tr>
- <td style="color: #0000AA">lethal</td>
+ <td class="resall">lethal</td>
<td>Whether the cell dies after performing the process</td>
<td>0</td>
</tr>
@@ -496,7 +496,7 @@
<div align="center">
<p> </p>
-<h3>Table 4: <span style="color: #004400">Reaction Requisite Specifications</span></h3>
+<h3>Table 4: <span>Reaction Requisite Specifications</span></h3>
<table border="1" cellpadding="2">
<tr>
<th>Argument</th>
@@ -504,7 +504,7 @@
<th>Default</th>
</tr>
<tr>
- <td style="color: #0000AA">reaction</td>
+ <td class="resall">reaction</td>
<td>
This limits this reaction from being triggered until the other
reaction specified here has been triggered first. With this, the
@@ -513,7 +513,7 @@
<td>none</td>
</tr>
<tr>
- <td style="color: #0000AA">noreaction</td>
+ <td class="resall">noreaction</td>
<td>
This limits this reaction from being triggered if the reaction
specified here has already been triggered. This allows the user to
@@ -523,7 +523,7 @@
<td>none</td>
</tr>
<tr>
- <td style="color: #0000AA">min_count</td>
+ <td class="resall">min_count</td>
<td>
This restriction requires that the task used to trigger this reaction
must be performed a certain number of times before the trigger will
@@ -534,7 +534,7 @@
<td>0</td>
</tr>
<tr>
- <td style="color: #0000AA">max_count</font>
+ <td class="resall">max_count</font>
<td>
This restriction places a cap on the number of times a task can
be done and still trigger this reaction. It allows the user to
Modified: development/documentation/events.html
===================================================================
--- development/documentation/events.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/events.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-28 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p><a href="index.html">Return to the Index</a></p>
@@ -62,23 +62,23 @@
<p>
Some examples:
</p>
-<div style="margin-left: 10px">
+<div class="sub">
<p>
- <code style="color: #0000AA">i Inject</code>
+ <code>i Inject</code>
<br />
Inject an additional start creature immediately.
</p>
<p>
- <code style="color: #0000AA">u 100:100 PrintAverageData</code>
+ <code>u 100:100 PrintAverageData</code>
<br />Print out all average measurements collected every one hundred updates,
starting at update 100.
</p>
<p>
- <code style="color: #0000AA">g 10000:10:20000 PrintData dom_info.dat update,dom_fitness,dom_depth,dom_sequence</code>
+ <code>g 10000:10:20000 PrintData dom_info.dat update,dom_fitness,dom_depth,dom_sequence</code>
<br />Between generations 10,000 and 20,000, append the specified information to
- the file <kbd style="color: #000088">dom_info.dat</kbd> every ten generations. Specifically, the first
+ the file <kbd>dom_info.dat</kbd> every ten generations. Specifically, the first
column in the file would be update number, second is the fitness of
the dominant genotype, followed by the depth in the phylogentic
tree of the dominant genotype, and finally its genome sequence.
Modified: development/documentation/inst_set.html
===================================================================
--- development/documentation/inst_set.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/inst_set.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-28 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p><a href="index.html">Return to the Index</a></p>
Modified: development/documentation/main.css
===================================================================
--- development/documentation/main.css 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/main.css 2006-09-05 13:51:40 UTC (rev 926)
@@ -1,11 +1,27 @@
-pre {
+pre, .sub {
margin-left: 10px;
}
+
div.revision {
float: right;
}
+tr.important {
+ background-color: #AAFFAA;
+}
+
+h3 span {
+ color: #004400;
+}
+
+.resall {
+ color: #0000AA;
+}
+.resspatial {
+ color: #AA0000;
+}
+
.cmdarg {
color: #0000AA;
}
Modified: development/documentation/print_data.html
===================================================================
--- development/documentation/print_data.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/print_data.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-29 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p>
Modified: development/documentation/structure.html
===================================================================
--- development/documentation/structure.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/structure.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-28 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p><a href="index.html">Return to the Index</a></p>
@@ -28,13 +28,13 @@
Source code files in Avida follow a standard naming convention. The C++ core,
in general, maintains one class per header/source file pair. The file name
should exactly match the class that it defines. All header files use
-<code style="color: #000088">.h</code> and all source files use
-<code style="color: #000088">.cc</code> as their respective file extensions.
+<code>.h</code> and all source files use
+<code>.cc</code> as their respective file extensions.
</p>
<p>
When you compile a program in C++, it goes through a <em>compilation</em> phase
-and then a <em>link</em> phase. The compilation phase takes each source (<code style="color: #000088">.cc</code>)
-file and compiles it independently into an object (<code style="color: #000088">.o</code>) file. In the
+and then a <em>link</em> phase. The compilation phase takes each source (<code>.cc</code>)
+file and compiles it independently into an object (<code>.o</code>) file. In the
link phase, all of these compiled object files are linked together into a
single executable (such as <kbd>avida</kbd>).
</p>
@@ -49,14 +49,14 @@
<p>
For example: The cOrganism object is declared in the file
-<code style="color: #000088">cOrganism.h</code> and fully
-defined in <code style="color: #000088">cOrganism.cc</code>. When
+<code>cOrganism.h</code> and fully
+defined in <code>cOrganism.cc</code>. When
this file is compiled, it creates the object file
-<code style="color: #000088">cOrganism.o</code>. Both the cPopulation
-class (<code style="color: #000088">cPopulation.cc</code>) and the
-cTestCPU class (<code style="color: #000088">cTestCPU.cc</code>) use
+<code>cOrganism.o</code>. Both the cPopulation
+class (<code>cPopulation.cc</code>) and the
+cTestCPU class (<code>cTestCPU.cc</code>) use
the cOrganism object. Since the majority of its methods are defined in
-<code style="color: #000088">cOrganism.cc</code>, the compiler only
+<code>cOrganism.cc</code>, the compiler only
needs to be compile these methods once. During the link phase
the linker connects the references together.
</p>
@@ -364,12 +364,12 @@
<h3>Directory: <kbd style="color: #008844">source/analyze/</kbd></h3>
<p>
-The primary class in this directory is <code style="color: #000088">cAnalyze</code>.
+The primary class in this directory is <code>cAnalyze</code>.
This class processes <kbd style="color: #000088">analyze.cfg</kbd> files to perform
data analysis on run data. The additional classes in this directory support various
types of analyses, along with provide the foundation for multithreaded execution.
-The <code style="color: #000088">cAnalyzeJobQueue</code> object, instatiated by
-<code style="color: #000088">cAnalyze</code>, orchestrates queuing and executing
+The <code>cAnalyzeJobQueue</code> object, instatiated by
+<code>cAnalyze</code>, orchestrates queuing and executing
jobs on parallel worker objects.
</p>
Modified: development/documentation/svn.html
===================================================================
--- development/documentation/svn.html 2006-09-04 01:25:47 UTC (rev 925)
+++ development/documentation/svn.html 2006-09-05 13:51:40 UTC (rev 926)
@@ -5,8 +5,8 @@
</head>
<body>
-<div style="float: right">
-Revised 2006-08-28 DMB
+<div class="revision">
+Revised 2006-09-05 DMB
</div>
<p><a href="index.html">Return to the Index</a></p>
More information about the Avida-cvs
mailing list