/***
StyleSheet for use when a translation requires any css style changes.
This StyleSheet can be used directly by languages such as Chinese, Japanese and Korean which need larger font sizes.
***/
/*{{{*/
body {font-size:0.8em;}
#sidebarOptions {font-size:1.05em;}
#sidebarOptions a {font-style:normal;}
#sidebarOptions .sliderPanel {font-size:0.95em;}
.subtitle {font-size:0.8em;}
.viewer table.listView {font-size:0.95em;}
/*}}}*/

To get started with this blank TiddlyWiki, you'll need to modify the following tiddlers:
* SiteTitle & SiteSubtitle: The title and subtitle of the site, as shown above (after saving, they will also appear in the browser title bar)
* MainMenu: The menu (usually on the left)
* DefaultTiddlers: Contains the names of the tiddlers that you want to appear when the TiddlyWiki is opened
You'll also need to enter your username for signing your edits: <<option txtUserName>>

!
^^(from http://en.wikipedia.org/wiki/Bioinformatics)^^
''Bioinformatics'' is the application of information technology to the field of molecular biology. The term bioinformatics was coined by Paulien Hogeweg in 1978 for the study of informatic processes in biotic systems. Bioinformatics nowadays entails the creation and advancement of databases, algorithms, computational and statistical techniques, and theory to solve formal and practical problems arising from the management and analysis of biological data. Over the past few decades rapid developments in genomic and other molecular research technologies and developments in information technologies have combined to produce a tremendous amount of information related to molecular biology. It is the name given to these mathematical and computing approaches used to glean understanding of biological processes. Common activities in bioinformatics include mapping and analyzing DNA and protein sequences, aligning different DNA and protein sequences to compare them and creating and viewing 3-D models of protein structures. Bioinformatics is the branch of life science that deals with the study of application of information technology to the field of molecular biology.

[[BACK to Resources|Resource Index]]
!!!
!Bioinformatics Core at DBI:
''Biowolf'' is the 286-core parallel computing cluster maintained at the Delaware Biotechnology Institute. Class accounts will be assigned to any participants interested in learning how to utilize this resource.
When you are ready to start using the SUN GRID ENGINE to submit jobs to run on Biowolf, here's a detailed overview of the system provided by Doug O'Neal:
''A Hitchhiker's Guide to Biowolf:'' http://bioit.dbi.udel.edu/howto/sge
!!!Getting STARTED with your new accout:
# Your "username" and password were emailed to you. They are the first two entries in the text line.
** Your username is "class" followed by two digits, like "class05"
** Your password is the random 6 character string of letters and numbers
# Make an __[[SSH]]__ connection in a command window
** @@{{{ ssh username@biowolf.dbi.udel.edu }}}@@
** You will be prompted for your initial password
# Change your password:
** The command prompt will look like: @@{{{classXX@biowolf ~$ }}}@@
** Type the command ''passwd'', hit <enter>, follow the queries.
Now add some default folders to your home directory as follows:
{{{
prompt> mkdir 01-DATA
prompt> mkdir 02-SCRIPTS
prompt> mkdir 03-SANDBOX
}}}
* ''01-DATA''
** You will use this folder to store data files
* ''02-SCRIPTS''
** You will use this folder to store scripts
* ''03-SANDBOX''
** You will use this folder as your working folder for editing and running scripts
** When you are done with an analysis, you will copy the current version of your script back into "02-SCRIPTS" and move any of the data output generated into an appropriate folder in "01-DATA". Then you will delete whatever is left in "03-SANDBOX" to leave it clean for your next code session.
!!!FILE Transfer
It is important that in addition to the command window you have established above, you are also able to use SSH to move files between your Biowolf account and your own computer.
| TASK 1: Copy all the scripts you have in this class to your "02-SCRIPTS" folder. |
This is accomplished with different interface programs for each OS platform. But basically you want a GUI interface showing you a current folder on your computer and a current folder on Biowolf so you can easily navigate between folders and copy files with a simple drag-drop mouse action.
* On PCs the GUI you want to run is "SSH-client" (I think), which you can get from UD Network: [[SSH]].
* On Macs, you want the MacFuse plugin for SSH: see [[SSH]].
* On Unix/Linux, I use KDE's Knoqueror that allows for {{{fish://user@biowolf.dbi.udel.edu}}} connections.
!!!Basic UNIX commands
Work through this simple @@[[UNIX TUTORIAL|http://www.ee.surrey.ac.uk/Teaching/Unix/unix1.html]]@@ to get an introduction to command window controls.
These are the basic commands you will need to use:
{{{
commands:
ls = list files aka "dir"
rm = remove file aka "delete"
cd .. = change directory up one level
cd foldername = change directory down one level to foldername
mkdir foldername = make directory foldername
}}}
!!!

/***
|Name|CheckboxPlugin|
|Source|http://www.TiddlyTools.com/#CheckboxPlugin|
|Version|2.2.4|
|Author|Eric Shulman - ELS Design Studios|
|License|http://www.TiddlyTools.com/#LegalStatements <<br>>and [[Creative Commons Attribution-ShareAlike 2.5 License|http://creativecommons.org/licenses/by-sa/2.5/]]|
|~CoreVersion|2.1|
|Type|plugin|
|Requires||
|Overrides||
|Description|Add checkboxes to your tiddler content|
This plugin extends the TiddlyWiki syntax to allow definition of checkboxes that can be embedded directly in tiddler content. Checkbox states are preserved by either:
* automatically modifying the tiddler content (deprecated)
* or, by setting/removing tags on specified tiddlers,
* or, by setting custom field values on specified tiddlers,
* or, by saving to a locally-stored cookie ID.
When an ID is assigned to the checkbox, it enables direct programmatic access to the checkbox DOM element, as well as creating an entry in TiddlyWiki's config.options[ID] internal data. In addition to tracking the checkbox state, you can also specify custom javascript for programmatic initialization and onClick event handling for any checkbox, so you can provide specialized side-effects in response to state changes.
!!!!! Inline wiki-syntax usage
<<<
//{{{
[ ]or[_] and [x]or[X]
//}}}
Simple checkboxes using 'Inline X' storage. The current unchecked/checked state is indicated by the character between the {{{[}}} and {{{]}}} brackets ("_" means unchecked, "X" means checked). When you click on a checkbox, the current state is retained by directly modifying the tiddler content to place the corresponding "_" or "X" character in between the brackets.
>//''NOTE: 'Inline X' syntax has been deprecated...'' This storage format only works properly for checkboxes that are directly embedded and accessed from content in a single tiddler. However, if that tiddler is 'transcluded' into another (by using the {{{<<tiddler TiddlerName>>}}} macro), the 'Inline X' will be ''erroneously stored in the containing tiddler's source content, resulting in corrupted content in that tiddler.'' For anything but the most simple of "to do list" uses, you should select from the various alternative storage methods described below...//
//{{{
[x=id]
//}}}
Assign an optional ID to the checkbox so you can use {{{document.getElementByID("id")}}} to manipulate the checkbox DOM element, as well as tracking the current checkbox state in {{{config.options["id"]}}}. If the ID starts with "chk" the checkbox state will also be saved in a cookie, so it can be automatically restored whenever the checkbox is re-rendered (overrides any default {{{[x]}}} or {{{[_]}}} value). If a cookie value is kept, the "_" or "X" character in the tiddler content remains unchanged, and is only applied as the default when a cookie-based value is not currently defined.
//{{{
[x(title|tag)] or [x(title:tag)]
//}}}
Initializes and tracks the current checkbox state by setting or removing a particular tag value from a specified tiddler. If you omit the tiddler title (and the | or : separator), the specified tag is assigned to the current tiddler. If you omit the tag value, as in {{{(title|)}}}, the default tag, {{{checked}}}, is assumed. Omitting both the title and tag, {{{()}}}, tracks the checkbox state by setting the "checked" tag on the current tiddler. When tag tracking is used, the "_" or "X" character in the tiddler content remains unchanged, and is not used to set or track the checkbox state. If a tiddler title named in the tag does not exist, the checkbox state defaults to the "inline X" value. If this value is //checked//, or is subsequently changed to //checked//, it will automatically create the missing tiddler and then add the tag to it. //''NOTE: beginning with version 2.1.2 of this plugin, the "|" separator is the preferred separator between the title and tag name, as it avoids syntactic ambiguity when ":" is used within tiddler titles or tag names.''//
//{{{
[x(field@tiddler)]
//}}}
Initializes and tracks the current checkbox state by setting a particular custom field value from a specified tiddler. If you omit the tiddler title (but not the "@" separator), the specified field on the current tiddler is used. If you omit the field name, as in {{{(@tiddler)}}}, a default fieldname of {{{checked}}} is assumed. Omitting both the field and the tiddler title, {{{(@)}}}, defaults to setting the "checked" field on the current tiddler. When field tracking is used, the "_" or "X" character in the tiddler content remains unchanged, and is not used to set or track the checkbox state. If the tiddler title named in the parameter does not exist, the checkbox state defaults to the "inline X" value. If this value is //checked// or is subsequently changed to //checked//, it will automatically create the missing tiddler and then add the field to it.
//{{{
[x{javascript}{javascript}]
//}}}
You can define optional javascript code segments to add custom initialization and/or 'onClick' handling to a checkbox. The current checkbox state (and it's other DOM attributes) can be set or read from within these code segments by reference to the default context-object, 'this'.
The first code segment will be executed when the checkbox is initially displayed, so that you can programmatically determine it's starting checked/unchecked state. The second code segment (if present) is executed whenever the checkbox is clicked, so that you can perform programmed responses or intercept and override the checkbox state based on complex logic using the TW core API or custom functions defined in plugins (e.g. testing a particular tiddler title to see if certain tags are set or setting some tags when the checkbox is clicked).
Note: if you want to use the default checkbox initialization processing with a custom onclick function, use this syntax: {{{ [x=id{}{javascript}] }}}
<<<
!!!!! Macro usage
<<<
In addition to embedded checkboxes using the wiki syntax described above, a ''macro-based syntax'' is also provided, for use in templates where wiki syntax cannot be directly used. This macro syntax can also be used in tiddler content, as an alternative to the wiki syntax. When embedded in [[PageTemplate]], [[ViewTemplate]], or [[EditTemplate]] (or custom alternative templates), use the following macro syntax:
//{{{
<span macro="checkbox target checked id onInit onClick"></span>
//}}}
or, when embedded in tiddler content, use the following macro syntax:
//{{{
<<checkbox target checked id onInit onClick>>
//}}}
where:
''target''
>is either a tag reference (e.g., ''tagname|tiddlername'') or a field reference (e.g. ''fieldname@tiddlername''), as described above.
''checked'' (optional)
>is a keyword that sets the initial state of the checkbox to "checked". When omitted, the default checkbox state is "unchecked".
''id'' (optional)
>specifies an internal config.options.* ID, as described above. If the ID begins with "chk", a cookie-based persistent value will be created to track the checkbox state in between sessions.
''onInit'' (optional)
>contains a javascript event handler to be performed when the checkbox is initially rendered (see details above).
''onClick'' (optional)
>contains a javascript event handler to be performed each time the checkbox is clicked (see details above).
>//note: to use the default onInit handler with a custom onClick handler, use "" (empty quotes) as a placeholder for the onInit parameter//
<<<
!!!!!Examples
<<<
''checked and unchecked static default ("inline X") values:''
//{{{
[X] label
[_] label
//}}}
>[X] label
>[_] label
''document-based value (id='demo', no cookie):''
//{{{
[_=demo] label
//}}}
>[_=demo] label
''cookie-based value (id='chkDemo'):''
//{{{
[_=chkDemo] label
//}}}
>[_=chkDemo] label
''tag-based value (TogglyTagging):''
//{{{
[_(CheckboxPlugin|demotag)]
[_(CheckboxPlugin|demotag){this.refresh.tagged=this.refresh.container=false}]
//}}}
>[_(CheckboxPlugin|demotag)] toggle 'demotag' (and refresh tiddler display)
>[_(CheckboxPlugin|demotag){this.refresh.tagged=this.refresh.container=false}] toggle 'demotag' (no refresh)
''field-based values:''
//{{{
[_(demofield@CheckboxPlugin)] demofield@CheckboxPlugin
[_(demofield@)] demofield@ (equivalent to demonfield@ current tiddler)
[_(checked@CheckboxPlugin)] checked@CheckboxPlugin
[_(@CheckboxPlugin)] @CheckboxPlugin
[_(@)] @ (equivalent to checked@ current tiddler)
//}}}
>[_(demofield@CheckboxPlugin)] demofield@CheckboxPlugin
>[_(demofield@)] demofield@ (current tiddler)
>[_(checked@CheckboxPlugin)] checked@CheckboxPlugin
>[_(@CheckboxPlugin)] @CheckboxPlugin
>[_(@)] toggle field: @ (defaults to "checked@here")
>click to view current: <<toolbar fields>>
''custom init and onClick functions:''
//{{{
[X{this.checked=true}{alert(this.checked?"on":"off")}] message box with checkbox state
//}}}
>[X{this.checked=true}{alert(this.checked?"on":"off")}] message box with checkbox state
''retrieving option values:''
>config.options['demo']=<script>return config.options['demo']?"true":"false";</script>
>config.options['chkDemo']=<script>return config.options['chkDemo']?"true":"false";</script>
<<<
!!!!!Configuration
<<<
Normally, when a checkbox state is changed, the affected tiddlers are automatically re-rendered, so that any checkbox-dependent dynamic content can be updated. There are three possible tiddlers to be re-rendered, depending upon where the checkbox is placed, and what kind of storage method it is using.
*''container'': the tiddler in which the checkbox is displayed. (e.g., this tiddler)
*''tagged'': the tiddler that is being tagged (e.g., "~MyTask" when tagging "~MyTask:done")
*''tagging'': the "tag tiddler" (e.g., "~done" when tagging "~MyTask:done")
You can set the default refresh handling for all checkboxes in your document by using the following javascript syntax either in a systemConfig plugin, or as an inline script. (Substitute true/false values as desired):
{{{config.checkbox.refresh = { tagged:true, tagging:true, container:true };}}}
You can also override these defaults for any given checkbox by using an initialization function to set one or more of the refresh options. For example:
{{{[_{this.refresh.container=false}]}}}
<<<
!!!!!Installation
<<<
import (or copy/paste) the following tiddlers into your document:
''CheckboxPlugin'' (tagged with <<tag systemConfig>>)
<<<
!!!!!Revision History
<<<
2007.08.06 - 2.2.5 supress automatic refresh of any tiddler that is currently being edited. Ensures that current tiddler edit sessions are not prematurely discarded (losing any changes). However, if checkbox changes a tag on a tiddler being edited, update the "tags" input field (if any) so that saving the edited tiddler correctly reflects any changes due to checkbox activity... see refreshEditorTagField().
2007.07.13 - 2.2.4 in handler(), fix srctid reference (was "w.tiddler", should have been "w.tiddler.title"). This fixes broken 'inline X' plus fatal macro error when using PartTiddlerPlugin. Thanks to cmari for reporting the problem and UdoBorkowski for finding the code error.
2007.06.21 - 2.2.3 suppress automatic refresh of tiddler when using macro-syntax to prevent premature end of tiddler editing session.
2007.06.20 - 2.2.2 fixed handling for 'inline X' when checkboxes are contained in a 'trancluded' tiddler. Now, regardless of where an inline X checkbox appears, the X will be placed in the originating source tiddler, rather than the tiddler in which the checkbox appears.
2007.06.17 - 2.2.1 Refactored code to add checkbox //macro// syntax for use in templates (e.g., {{{macro="checkbox ..."}}}. Also, code cleanup of existing tag handling.
2007.06.16 - 2.2.0 added support for tracking checkbox states using tiddler fields via "(fieldname@tiddlername)" syntax.
2006.05.04 - 2.1.3 fix use of findContainingTiddler() to check for a non-null return value, so that checkboxes won't crash when used outside of tiddler display context (such as in header, sidebar or mainmenu)
2006.03.11 - 2.1.2 added "|" as delimiter to tag-based storage syntax (e.g. "tiddler|tag") to avoid parsing ambiguity when tiddler titles or tag names contain ":". Using ":" as a delimiter is still supported but is deprecated in favor of the new "|" usage. Based on a problem reported by JeffMason.
2006.02.25 - 2.1.0 added configuration options to enable/disable forced refresh of tiddlers when toggling tags
2006.02.23 - 2.0.4 when toggling tags, force refresh of the tiddler containing the checkbox.
2006.02.23 - 2.0.3 when toggling tags, force refresh of the 'tagged tiddler' so that tag-related tiddler content (such as "to-do" lists) can be re-rendered.
2006.02.23 - 2.0.2 when using tag-based storage, allow use [[ and ]] to quote tiddler or tag names that contain spaces:
{{{[x([[Tiddler with spaces]]:[[tag with spaces]])]}}}
2006.01.10 - 2.0.1 when toggling tags, force refresh of the 'tagging tiddler'. For example, if you toggle the "systemConfig" tag on a plugin, the corresponding "systemConfig" TIDDLER will be automatically refreshed (if currently displayed), so that the 'tagged' list in that tiddler will remain up-to-date.
2006.01.04 - 2.0.0 update for ~TW2.0
2005.12.27 - 1.1.2 Fix lookAhead regExp handling for {{{[x=id]}}}, which had been including the "]" in the extracted ID.
Added check for "chk" prefix on ID before calling saveOptionCookie()
2005.12.26 - 1.1.2 Corrected use of toUpperCase() in tiddler re-write code when comparing {{{[X]}}} in tiddler content with checkbox state. Fixes a problem where simple checkboxes could be set, but never cleared.
2005.12.26 - 1.1.0 Revise syntax so all optional parameters are included INSIDE the [ and ] brackets. Backward compatibility with older syntax is supported, so content changes are not required when upgrading to the current version of this plugin. Based on a suggestion by GeoffSlocock
2005.12.25 - 1.0.0 added support for tracking checkbox state using tags ("TogglyTagging")
Revised version number for official post-beta release.
2005.12.08 - 0.9.3 support separate 'init' and 'onclick' function definitions.
2005.12.08 - 0.9.2 clean up lookahead pattern
2005.12.07 - 0.9.1 only update tiddler source content if checkbox state is actually different. Eliminates unnecessary tiddler changes (and 'unsaved changes' warnings)
2005.12.07 - 0.9.0 initial BETA release
<<<
!!!!!Credits
<<<
This feature was created by EricShulman from [[ELS Design Studios|http:/www.elsdesign.com]]
<<<
!!!!!Code
***/
//{{{
version.extensions.CheckboxPlugin = {major: 2, minor: 2, revision:5 , date: new Date(2007,8,6)};
//}}}
//{{{
config.checkbox = { refresh: { tagged:true, tagging:true, container:true } };
config.formatters.push( {
name: "checkbox",
match: "\\[[xX_ ][\\]\\=\\(\\{]",
lookahead: "\\[([xX_ ])(=[^\\s\\(\\]{]+)?(\\([^\\)]*\\))?({[^}]*})?({[^}]*})?\\]",
handler: function(w) {
var lookaheadRegExp = new RegExp(this.lookahead,"mg");
lookaheadRegExp.lastIndex = w.matchStart;
var lookaheadMatch = lookaheadRegExp.exec(w.source)
if(lookaheadMatch && lookaheadMatch.index == w.matchStart) {
// get params
var checked=(lookaheadMatch[1].toUpperCase()=="X");
var id=lookaheadMatch[2];
var target=lookaheadMatch[3];
if (target) target=target.substr(1,target.length-2).trim(); // trim off parentheses
var fn_init=lookaheadMatch[4];
var fn_click=lookaheadMatch[5];
var tid=story.findContainingTiddler(w.output); if (tid) tid=tid.getAttribute("tiddler");
var srctid=w.tiddler?w.tiddler.title:null;
config.macros.checkbox.create(w.output,tid,srctid,w.matchStart+1,checked,id,target,config.checkbox.refresh,fn_init,fn_click);
w.nextMatch = lookaheadMatch.index + lookaheadMatch[0].length;
}
}
} );
config.macros.checkbox = {
handler: function(place,macroName,params,wikifier,paramString,tiddler) {
if(!(tiddler instanceof Tiddler)) { // if no tiddler passed in try to find one
var here=story.findContainingTiddler(place);
if (here) tiddler=store.getTiddler(here.getAttribute("tiddler"))
}
var srcpos=0; // "inline X" not applicable to macro syntax
var target=params.shift(); if (!target) target="";
var defaultState=params[0]=="checked"; if (defaultState) params.shift();
var id=params.shift(); if (id && !id.length) id=null;
var fn_init=params.shift(); if (fn_init && !fn_init.length) fn_init=null;
var fn_click=params.shift(); if (fn_click && !fn_click.length) fn_click=null;
var refresh={ tagged:true, tagging:true, container:false };
this.create(place,tiddler.title,tiddler.title,0,defaultState,id,target,refresh,fn_init,fn_click);
},
create: function(place,tid,srctid,srcpos,defaultState,id,target,refresh,fn_init,fn_click) {
// create checkbox element
var c = document.createElement("input");
c.setAttribute("type","checkbox");
c.onclick=this.onClickCheckbox;
c.srctid=srctid; // remember source tiddler
c.srcpos=srcpos; // remember location of "X"
c.container=tid; // containing tiddler (may be null if not in a tiddler)
c.tiddler=tid; // default target tiddler
c.refresh = {};
c.refresh.container = refresh.container;
c.refresh.tagged = refresh.tagged;
c.refresh.tagging = refresh.tagging;
place.appendChild(c);
// set default state
c.checked=defaultState;
// track state in config.options.ID
if (id) {
c.id=id.substr(1); // trim off leading "="
if (config.options[c.id]!=undefined)
c.checked=config.options[c.id];
else
config.options[c.id]=c.checked;
}
// track state in (tiddlername|tagname) or (fieldname@tiddlername)
if (target) {
var pos=target.indexOf("@");
if (pos!=-1) {
c.field=pos?target.substr(0,pos):"checked"; // get fieldname (or use default "checked")
c.tiddler=target.substr(pos+1); // get specified tiddler name (if any)
if (!c.tiddler || !c.tiddler.length) c.tiddler=tid; // if tiddler not specified, default == container
if (store.getValue(c.tiddler,c.field)!=undefined)
c.checked=(store.getValue(c.tiddler,c.field)=="true"); // set checkbox from saved state
} else {
var pos=target.indexOf("|"); if (pos==-1) var pos=target.indexOf(":");
c.tag=target;
if (pos==0) c.tag=target.substr(1); // trim leading "|" or ":"
if (pos>0) { c.tiddler=target.substr(0,pos); c.tag=target.substr(pos+1); }
if (!c.tag.length) c.tag="checked";
var t=store.getTiddler(c.tiddler);
if (t && t.tags)
c.checked=t.isTagged(c.tag); // set checkbox from saved state
}
}
if (fn_init) c.fn_init=fn_init.trim().substr(1,fn_init.length-2); // trim off surrounding { and } delimiters
if (fn_click) c.fn_click=fn_click.trim().substr(1,fn_click.length-2);
c.init=true; c.onclick(); c.init=false; // compute initial state and save in tiddler/config/cookie
},
onClickCheckbox: function(event) {
if (this.fn_init)
// custom function hook to set initial state (run only once)
{ try { eval(this.fn_init); this.fn_init=null; } catch(e) { displayMessage("Checkbox init error: "+e.toString()); } }
else if (this.fn_click)
// custom function hook to override or react to changes in checkbox state
{ try { eval(this.fn_click) } catch(e) { displayMessage("Checkbox click error: "+e.toString()); } }
if (this.id)
// save state in config AND cookie (only when ID starts with 'chk')
{ config.options[this.id]=this.checked; if (this.id.substr(0,3)=="chk") saveOptionCookie(this.id); }
if (this.srctid && this.srcpos>0 && (!this.id || this.id.substr(0,3)!="chk") && !this.tag && !this.field) {
// save state in tiddler content only if not using cookie, tag or field tracking
var t=store.getTiddler(this.srctid); // put X in original source tiddler (if any)
if (t && this.checked!=(t.text.substr(this.srcpos,1).toUpperCase()=="X")) { // if changed
t.set(null,t.text.substr(0,this.srcpos)+(this.checked?"X":"_")+t.text.substr(this.srcpos+1),null,null,t.tags);
if (!story.isDirty(t.title)) story.refreshTiddler(t.title,null,true);
store.setDirty(true);
}
}
if (this.field) {
if (this.checked && !store.tiddlerExists(this.tiddler))
store.saveTiddler(this.tiddler,this.tiddler,"",config.options.txtUserName,new Date());
// set the field value in the target tiddler
store.setValue(this.tiddler,this.field,this.checked?"true":"false");
// DEBUG: displayMessage(this.field+"@"+this.tiddler+" is "+this.checked);
}
if (this.tag) {
if (this.checked && !store.tiddlerExists(this.tiddler))
store.saveTiddler(this.tiddler,this.tiddler,"",config.options.txtUserName,new Date());
var t=store.getTiddler(this.tiddler);
if (t) {
var tagged=(t.tags && t.tags.find(this.tag)!=null);
if (this.checked && !tagged) { t.tags.push(this.tag); store.setDirty(true); }
if (!this.checked && tagged) { t.tags.splice(t.tags.find(this.tag),1); store.setDirty(true); }
}
// if tag state has been changed, update display of corresponding tiddlers (unless they are in edit mode...)
if (this.checked!=tagged) {
if (this.refresh.tagged) {
if (!story.isDirty(this.tiddler)) story.refreshTiddler(this.tiddler,null,true); // the TAGGED tiddler in view mode
else config.macros.checkbox.refreshEditorTagField(this.tiddler,this.tag,this.checked); // the TAGGED tiddler in edit mode (with tags field)
}
if (this.refresh.tagging)
if (!story.isDirty(this.tag)) story.refreshTiddler(this.tag,null,true); // the TAGGING tiddler
}
}
// refresh containing tiddler (but not during initial rendering, or we get an infinite loop!) (and not when editing container)
if (!this.init && this.refresh.container && this.container!=this.tiddler)
if (!story.isDirty(this.container)) story.refreshTiddler(this.container,null,true); // the tiddler CONTAINING the checkbox
return true;
},
refreshEditorTagField: function(title,tag,set) {
var tagfield=story.getTiddlerField(title,"tags");
if (!tagfield||tagfield.getAttribute("edit")!="tags") return; // if no tags field in editor (i.e., custom template)
var tags=tagfield.value.readBracketedList();
if (tags.contains(tag)==set) return; // if no change needed
if (set) tags.push(tag); // add tag
else tags.splice(tags.indexOf(tag),1); // remove tag
for (var t=0;t<tags.length;t++) tags[t]=String.encodeTiddlyLink(tags[t]);
tagfield.value=tags.join(" "); // reassemble tag string (with brackets as needed)
return;
}
}
//}}}

!Directed Evolution Script:
The script and the tool class files can be downloaded below. They are presented in [[Lecture 02|L02.05]].
//(These are version #02 files compatible with rpy2)//
[[DirectedEvo.py|02/DirectedEvo02.py]]
[[DirectedEvoTools.py|02/DirectedEvoTools02.py]]
These files generate frequency distribution plots for the number of generations required to "evolve" a specific string target AND a summary plot of the average generation times across all Nmer sequence lengths tested.
<html><table><tr>
<td><img src="02/00-DataPlot-ALL-GATC.png" style="height:200px"></td>
<td><img src="02/00-DistributionPlot-002500-GATC.png" style="height:200px"></td>
</tr></table></html>
!

!Basic Genetic Algorithm Script:
The script and the tool class files can be downloaded below. They are presented in [[Lecture 03|L03]].
//(These version files do not require rpy2)//
[[DirectedGA01.py|03/DirectedGA01.py]]
[[DirectedGATools01.py|03/DirectedGATools1.py]]
These files solve a simple algebraic problem: given a fixed number of factors and a target amount, find the combination of factors whose product is equal to the target. The progress of the script while running is an xy plot of the current functional score of the i^^th^^ generation factors plotted against generation number.
<html>
<img src="03/ScorePlotExample.png" style="height:300px">
</html>
!

[[BACK to Resources|Resource Index]]
!!!
!~Mark-Up Script Editors:
!!!1. Java Edit
''jEdit'' is a feature-rich programmer's text editor built on Java that will run on all computers with JRE (java runtime environment). To download, install, and set up jEdit as quickly and painlessly as possible, go to the [[Quick Start page | http://www.jedit.org/index.php?page=quickstart]].
<html><img src="00/jedit.png" style="height:300px"></html>
!!!2. Crimson Editor
''CE'' is a syntax mark-up editor for MS Windows. Folder navigation is pretty easy using this tool. It can be setup as a pass-through interface to the command terminal so running and editing scripts can all be done in one GUI. To download and install got to [[Crimson Editor | http://www.crimsoneditor.com/]].
<html><img src="00/crimsonedit.png" style="height:300px"></html>
!!!3. Komodo
''KOMODO EDIT'' is a feature code editor from Active State. They sell a high-octane version of the editor Komodo-IDE which is geared to professional coders. The freeware version Komodo-Editor still has more features than you will ever probably require. To download and install got to [[Komodo | http://www.activestate.com/Products/]], and select ''Komodo-Edit'', not ''Komodo-IDE''.
<html><img src="00/komodo.png" style="height:300px"></html>
!!!4. Vim
Vim is a highly configurable text editor built to enable efficient text editing. It is an improved version of the vi editor distributed with most UNIX systems. Vim is often called a "programmer's editor," and so useful for programming that many consider it an entire IDE. It's not just for programmers, though. Vim is perfect for all kinds of text editing, from composing email to editing configuration files. Vim can be configured to work in a very simple (Notepad-like) way, called evim or Easy Vim.
[[VIM download|http://www.vim.org/index.php]]
!

[[BACK to Lecture 1|L01.06]]
!!!
!Entropy
''ENTROPY'' is a concept to describe the information content of a system given different states of organization. It is borrowed by molecular biologists to describe the "organization" of sequence information. The idea of information entropy was first developed for telecommunications by: Shannon and Weaver, 1949, "The mathematical theory of communication," University of Illinois Press, Chicago.
The idea is that the more information you have about a system, the more certain you are about the current state of that system. The Shannon-Weaver entropy statistics works by a fairly simple summation of the probability states of any system to establish a metric that represents how much you DON'T know about that system. Yes, it is an inverse measure in that the greater the system entropy value, the more complex a system is, and consequently there's more that you don't know about it.
Example 1: From Dweyer's __Genomic PERL__, let's say there is a 90% chance of rain today, a 9% chance of overcast clouds but no rain, and a 1% chance of partly cloudy, sunny skies, with no rain. This weather "system" has the following potential probabilities:
''WEATHER~~system1~~ = [//p//(Rain), //p//(Clouds), //p//(Sun)] = [0.90, 0.09, 0.01]''
If you heard this information on the radio when you woke up, you would likely make an immediate mental note to bring an umbrella or wear a rain jacket when you left home. If however the forecast was for 33% chance of rain and a 34% chance of overcast skies with no rain and a 33% chance of partly cloudy, sunny skies, with no rain, then you would not be so quick to conclude that you needed an umbrella today.
''WEATHER~~system2~~ = [//p//(Rain), //p//(Clouds), //p//(Sun)] = [0.33, 0.34, 0.33]''
To make a correct decision about whether or not to bring an umbrella you would need to access more weather data (doppler radar, etc.) to better ascertain.
So these two weather states have very different levels of predictability or complexity or entropy. We generally calculate an entropy statistic as the summation of the probability of each possible state (//p//~~i~~) multiplied by the natural log of that probability:
''H'' = -1 * Ln( (//p//~~i~~ ^^//p//~~i~~^^)! ) //#(remember ! = factorial)//
| ''H'' = -1 * sum (//p//~~i~~ * Ln(//p//~~i~~) |
''H''-WEATHER~~system1~~ = -1 * ( (0.90 * -0.11) + (0.09 * -2.41) + (0.01 * -4.61) ) = __0.157__
''H''-WEATHER~~system2~~ = -1 * ( (0.33 * -1.11) + (0.34 * -1.08) + (0.33 * -1.11) ) = __1.099__
So if we compare the entropy numbers, the larger value for WEATHER~~system2~~ is interpreted to mean that there is more uncertainty about whether or not it will rain or shine on this day. The high number value means that it is more complex of a decision to ascertain the true state of the weather for day 2.
| In Bioinformatics you will often be faced with problems of trying to predict something about a DNA sequence base solely on the probabilities that nucloetide bases will be present at different frequencies. |
!

<html><div style="color: rgb(100, 100, 150); font-family: Monaco;"><big><big><big><b><center>
Environmental/Functional Bioinformatics Research Development
<br>
</b></big>
<br>
MAST 867-010 Spring 2009
<br>
<br>
Dr. Adam G. Marsh<br></big>
<i>College of Marine & Earth Studies</i><br>
<small>email: amarsh-at-udel-dot-edu; office: 645-4367
<br>
</html>
!!!
''COURSE DESCRIPTION:'' MAST867 will focus on developing and implementing an informatics research project for each participant using the data/subject of their choice. Prof. Marsh teaches two introductory courses (one in programming and one in informatics; see links below) and MAST867 is designed to culminate the programming and informatic skills of these students by focusing on a directed bioinformatics research project that is ''hypothesis'' driven. The two courses below are not prerequisites, but it is necessary for students to have some knowledge of programming and some knowledge of using UNIX (linux, os x) systems for MAST867. The format of the course will be class lectures for the first 4 weeks, and then for the remainder of the semester students will consult with Prof. Marsh individually once a week on their research projects. These consultations sessions will involve collaborative editing, writing and debugging code to develop a specific tool/pipeline that each student will need in their research. At the end of the course students should be capable of some degree of independent work with PERL, PYTHON, or R. Students will also be required to write up a small bioinformatics research paper, which ideally could be incorporated as a chapter/appendix in their dissertation.
[[MAST667 S08|http://icewater.cms.udel.edu/EnvBioInfo/]] 1 CR Environmental Bioinformatics
[[MAST667 F08|http://icewater.cms.udel.edu/IntroPerl/]] 2 CR PERL Beginning Bioinformatics
!!!

!Directed model probabilities
Using the MonkeysTyping script:
# Add an iterative loop so that one target string is repeatedly matched 100 times and an average generation count is calculated.
# Add another iterative loop so that 5 different strings varying in length by more than 10 characters is iteratively processed.
# PLOT y-axis = average generation time vs x-axis = number of characters to match
# Add regression line to plot
|@@SEND YOUR DATA PLOT TO ME BY THURSDAY 5:00 PM@@|
!!!
!!!23FEB: Hint 1
Set up the strings you will test as a PERL array:
{{{
my @quotes = qw |
We have nothing to fear but fear itself,
Ask not what your country can do for you but what you can do for your country,
Four score and seven years ago our forefathers setforth to build a new nation dedicated to the proposition that all men are created equal,
|
}}}
Remember that entries in a "quoted word" list (that's what the qw stands for) are separated by a comma, so there can be no commas in the text you enter. Now the outside iteration loop would look like this:
{{{
foreach my $line (@quotes)
{ foreach my $i (0..99)
{
#Monkey Typing Goes Here....
}
# Calculate MEAN number of bananas here . . .
}
}}}
!

!Basic instructions
#Download the file to your hard drive by [[right-clicking and saving the link / target as...|webviewtw.html]] to the filename and location of your choice. Close this page and open your new file.
#Replace the title in the upper left by editing MainMenu.
#Add topics to MainMenu. Click on those topics to create the tiddlers for those topics. To your uninitiated web viewers they will appear to be separate webpages, but you and I know better!
#Edit DefaultTiddlers to include the names of the tiddlers that you want to appear when the ~TiddlyWiki is opened.
#If you want different colorpalettes than the ones provided, check [[here|http://www.giffmex.org/webviewtwexample.html#MoreColorPalettes!]] for more. Just import them from that file to this file.
#If you want to temporarily suspend the single-page-only feature, I recommend the toggle singlepage mode bookmarklet from ~TiddlyTools [[(link here)|http://www.tiddlytools.com/#InstantBookmarklets.]]
#Upload to your site using the UploadPlugin. [[Instructions here|http://www.giffmex.org/twfortherestofus.html#%5B%5BSimple%20instructions%20for%20BidiX's%20UploadPlugin%5D%5D]]

<[[BACK|Lecture Index]]|[[NEXT|L01.01]]>
!!!
!Combinometric Diversity
Reading Assignment: [[Library of Babel]]
''Borges:'' keen interests in theology and geometry
//Library of Babel// essay written in 1941 describing the combinometrics of 22 letters and three punctuation characters (space, comma, period). 25 orthographic symbols in the total set of characters.
!!!
Each book is:
{{engindent{410 pages
40 lines per page
80 characters per line}}}
Total characters in a book: 410 x 40 x 80 = 1,312,000 total characters
!!!
How many different books are there?
{{engindent{25^^1,312,000^^}}}
OR
{{engindent{10^^1,834,097^^}}}
(//note: this number is a digit 1 followed by 1,834,097 "0" digits, which is a number too large to even represent within a book of 410 pages x 40 lines per page x 80 characters per line//).
!!!

<[[BACK|L01]]|[[MAIN|L01]]|[[NEXT|L01.02]]>
!!!
!Unimaginable Mathematics
William Goldbloom Bloch, "The Unimaginable Mathematics of Borges' Library of Babel".
<html><img src="01/bookcover.jpg" style="height:300px"></html>
Bloch provides some interesting mathematical insights into the "structure" of Library of Babel.
''How big would it be?''
1. Assume that you could fit 1000 (10^^3^^) books into one cubic meter. This is an admittedly large over-estimate.
2. Our known universe is ~1.5 x 10^^26^^ meters across. Round up to again be generous and call it 10^^27^^ meters.
3. Make a generous estimate of the size of the universe by assuming it is a cube, 10^^27^^ meters on a side, giving a total volume of 10^^81^^ m^^3^^
SO . . . . given a universe of 10^^81^^ m^^3^^ and 10^^3^^ books per m^^3^^, our universe could physically contain 10^^84^^ such books.
Far short of the 10^^1,834,097^^ total books in the library.
In fact, it would take 10^^1,834,013^^ parallel universes to ours in order to fit all these combinatorial books.
!!!

<[[BACK|L01.01]]|[[MAIN|L01]]|[[NEXT|L01.03]]>
!!!
!Babel Library of Genomes?
Given that there are only 4 DNA nucleotides, would a recombinatorial library of genomes be more manageable?
Imagine such a "GenBank" where every genome that has existed, or now exists, or would exist in the future, would be accessible . . . . if you could find them.
Take an average bacterial genome of 3 MB.
How many possible genomes would there be?
{{engindent{4^^3,000,000^^}}}
OR
{{engindent{10^^1,806,180^^}}}
How different does this number look to you from: 10^^1,834,097^^
OK, but bacteria are much smaller than books. Assume the average size of a bacterium to be ~ 5 cubic microns or 5 x10^^-18^^ m^^3^^. Then you could fit ~ 2 x 10^^17^^ bacteria in one m^^3^^.
In a universe of 10^^81^^ m^^3^^, then you could fit a total of 10^^98^^ bacteria.
(//for scale, remember that the age of our solar system is only 10^^18^^ seconds//)
!!!

<[[BACK|L01.02]]|[[MAIN|L01]]|[[NEXT|L01.04]]>
!!!
!Computational Challenge
As biologists, you are faced with the daunting task of trying to decipher biological patterns in sequence data but with only being able to see a infinitesmally small limited myopic unfocused biased fraction of sequence data.
''BioInformatics:'' discerning patterns of system organization against a background of disorganization.
//We are all "babel librarians" wandering the stacks, flipping through pages in books looking for signs or hints of sense.//
!!!

<[[BACK|L01.03]]|[[MAIN|L01]]|[[NEXT|L01.05]]>
!!!
!Computational Advantage
Biological systems are NOT random recombinatorial systems.
Consider the calculation that there are 10^^1,806,180^^ possible bacterial genomes of 3 MB in size.
What fraction of that total genome "space" would be occupied by "viable" genomes of bacteria that have existed, or currently exist, or could possibly exist in the future?
Well, if you can only fit 10^^90^^ in the universe, then that would be:
{{engindent{10^^90^^/10^^1,806,180^^ = 10^^-1,806,090^^}}}
Yes, that is a very small fraction, regardless of how rough the estimates above may be.
So biological system organization bypasses all the potential phenotype space. Evolution proceeds down a narrow path . . . . canalization.
The importance of this simple realization is that we know a GREAT deal about what biological systems are NOT like. We call these random or null models or distributions and our computational goals are basically to statistically test if observed features in a biological system are best described by a null or random process (we attempt to affirm a null hypothesis).
!!!

<[[BACK|L01.04]]|[[MAIN|L01]]|[[NEXT|L01.06]]>
!!!
!Recombinatorial Proofreading
In Bloch's book __The Unimaginable Mathematics of Borges' Library of Babel__, he ends his presentation with a metaphor of the librarian as a Turing machine. A simple, linear processor running through the text of each book programmed only to look for "words."
So consider a simple system in which a computer program was tasked to parse through the library, looking for books in which all the orthographic entries were "words" determined by matching against a language dictionary (rule 1)?
And if the processing rule was optimized so that when the first non-word was encountered, the rest of the book was skipped (rule 2).
Obviously the task of the Librarian would be greatly accelerated.
If a third rule was imposed to select only those books in which there were no grammatical errors, the search for books with meaning would be even more tightly focused and efficient.
So for biological systems, Natural Selection is like a great Turing machine to efficiently retain only those units that "qualify" as making sense as defined by these 3 simple rules.

<[[BACK|L01.05]]|[[MAIN|L01]]|[[NEXT|L01.07]]>
!!!
!Emergence
Complex systems can evolve from simple rule sets (solar systems, mammalian circulatory systems, a squid eye . . . . )
This is possible only when there is an "unimaginable" amount of recombinatorial space (//phenotypes//) that could potentially exist. Then a series of simple rules for parsing or selecting a path through that space has a high probability of "reaching" the end of that path.
In considering how systems are organized, we often use "entropy" as a measure of organization or more succinctly, predictability.
[[WHAT IS ENTROPY?|Entropy01]]
DNA Sequence Entropy: http://icewater.cms.udel.edu/IntroPerl/#L07
!!!

<[[BACK|L01.06]]|[[MAIN|L01]]|[[NEXT|L01.08]]>
!!!
!BioInformatics is more than just counting
The idea of a Babel Genome Library is intriguing because of the wealth of information it would contain about past life, present life and future life.
''Home Work Assignment #1: [[HW01]]''
|@@How big a hard drive would you need to store a Babel Library of 3 MB bacterial genomes?@@|
To make this a more manageable task, what if we devised a filtering algorithm as the genomes were being generated to only allow those that made "sense" into the library?
What would be the rule set?
What would be gained?
What would be lost?
What would be the size of the final library?
Could you search through it within your life time?
Do you need to search through the whole library?
!

<[[BACK|L01.08]]|[[MAIN|L01]]|[[NEXT|L01.10]]>
!!!
!Babel Gallery
As a more tangible model of generating a directed library via recombinatorial diversity, consider a babel gallery of images each 80 x 60 pixels in size.
Each pixel is reproduced as a color tile so the image size is larger.
Each pixel has three integers that determine color: R, G, B channels
Each channel can hold an integer from 0 to 255.
Inside this gallery, would be a representation of every 2D artwork that has ever been produced and that will ever be produced. All paintings, prints, lithographs, photographs . . . . European, Eastern, Inuit, Roman, Norse, . . . .
| @@How many images would be contained in this babel gallery?@@|
!!Randomized Color Map:
<html><img src="01/Babel-090220.png" style="height:400px"></html>
//Is this ART?//
!

<[[BACK|L01.09]]|[[MAIN|L01]]|[[NEXT|L01.11]]>
!!!
!Genetic Algorithms
Class of models for solving computational problems "de novo"
Example: de novo bicycle design http://www.wreck.devisland.net/ga/
<html><img src="01/bicycle-ga.png" style="height:200px"></html>
!!!Simple Logic:
# Create ANCESTOR object
# Ancestor object replicates to form DESCENDANT object
# DESCENDANT object mutates during the replication process
# DESCENDANT object is functionally evaluated
# If DESCENDANT is better than ANCESTOR, then the DESCENDANT becomes the new ANCESTOR of the next generation
# If DESCENDANT is not better than ANCESTOR, it is discarded and the existing ANCESTOR is replicated for the next generation
Run through a million generations, and a very complex, functionally intricate DESCENDANT can evolve from a simple ANCESTOR.
|@@Although the recombinatorial space may be unimaginable in total, the descendants will trace a single path through the expanse of possibilities@@|
!

<[[BACK|L01.10]]|[[MAIN|L01]]|[[NEXT|L01.12]]>
!!!
!Babel Model
{{{
while(lineage < 40000):
# Generate new descendant from ancestor image
descendant = copy.deepcopy(ancestor)
descendant.mutate()
descendant.evaluate()
if (descendant.cvscore > ancestor.cvscore):
descendant.save_current_image_data(namestr)
del(ancestor)
ancestor = copy.deepcopy(descendant)
lineage = lineage + 1
del(descendant)
}}}
The only tricky part of this model is the "evaluation" function. How do you evaluate an image to decide if it is a better image or not?
Could use Entropy . . . .
Could use color pallete . . . .
Could use . . . . .
In this implementation, I have just chosen to use a simple metric that scores each pixel for how different the R, G and B values are from the pixels that surround it. The idea is to select for some degree of localized color uniformity.
<html><table><tr>
<td><img src="01/Alpha-090115-start.png" style="height:250px"></td>
<td><img src="01/Alpha-090115-end.png" style="height:250px"></td>
</tr></table></html>
//Final image is generation #940,891//
''Plot of functional scores for each descendant in a lineage''
<html><img src="01/PlotData-MuteScores.png" style="height:300px"></html>
''Image Evolution Examples:''
http://icewater.cms.udel.edu/babel/
!

<[[BACK|L01.11]]|[[MAIN|L01]]>
!!!
!Shakespeare's Monkeys
A different class of models are described as directed selection in which the end-goal is already established and the model is essentially studying the process or mechanics by which that end-goal is achieved.
Simple PERL script to look at how long it would take to randomly fit a given text pattern following the rule that once a character in the evolving string was matched to the target string, it is fixed and stops changing. Code: MonkeysTyping
{{{
----------------------------------------------------------
Would it really take a thousand years for a thousand monkeys
typing on a thousand typewriters to compose Hamlet's soliloquy?
----------------------------------------------------------
}}}
Enter a starting target string that the monkeys have to type.
{{{
Here's what you entered:
F o u r s c o r e a n d s e v e n y e a r s
a g o o u r f o r e f a t h e r s c r e a t e d a
n e w n a t i o n
}}}
Final count for how many generations it took to match the initial input string:
{{{
It took 256 bananas to find 67 correct letters.
}}}
!
Home Work Assignment #2: HW02
|@@Plot the average number of generations it takes to reproduce a target string AGAINST the starting length of the target string@@|
!

<[[MAIN|L02]]>
!!!
!HW01 Babel Genome Library
''From Brian:''
A Babel Library of bacterial genomes would be just under 10^^1806180^^ bytes large or 10^^1806168^^ PB. However, since there are only four letters, letter could be encoded by 2 bits instead of the 7 required for ASCII, which would bring the file size down 64 fold, to around 10^^1806178.2^^ bytes.
Ever wonder how genomes have evolved with just 4 nucleotides?
4^^3,000,000^^ is a big enough number to cover the necessary sequence diversity.
!

<[[MAIN|L02]]|[[NEXT|L02.02]]>
!!!
!Monkeys Typing: History
The INFINITE MONKEY THEOREM:
[img[02/250px-Monkey-typing.jpg]]
^^http://en.wikipedia.org/wiki/Infinite_monkey_theorem^^
!!Émile Borel's 1913, French Physicist
In his article "Mécanique Statistique et Irréversibilité" (Statistical mechanics and irreversibility), and in his book "Le Hasard" (1914), he uses "monkeys" as a metaphor for a process by which large, random sequence of letters could be generated. Borel used the metaphor as a rhetorical device, saying that if a million monkeys typed ten hours a day, it was extremely unlikely that their output would exactly equal all the books of the richest libraries of the world; and yet, in comparison, it was even more unlikely that the laws of statistical mechanics would ever be violated, even briefly.
!!Sir Arthur Eddington in 1927
In a 1927 lecture, Eddington stated: "If I let my fingers wander idly over the keys of a typewriter it might happen that my screed made an intelligible sentence. If an army of monkeys were strumming on typewriters they might write all the books in the British Museum. The chance of their doing so is decidedly more favourable than the chance of the molecules returning to one half of the vessel."
^^(Arthur S. Eddington. The Nature of the Physical World: The Gifford Lectures, 1927. N.Y., Macmillan, 1929)^^
!!Sir James Hopwood Jeans 1930
"It was, I think, Huxley who said that six monkeys, set to strum unintelligently on typewriters for millions of millions of years, would be bound in time to write all the books in the British Museum."
^^The Mysterious Universe, 1st
edition, The MacMillan Copany, New York and At the University
Press, Cambridge, England, 163 pp.^^
!!Jorge Luis Borge 1939/1941
By 1939, the idiom was "that a half-dozen monkeys provided with typewriters would, in a few eternities, produce all the books in the British Museum." In his 1939 essay "The Total Library", Borges adds: ''"Strictly speaking, one immortal monkey would suffice."'' In this work he traces the infinite recombinatorial diversity problem back to Aristotle.
!

<[[BACK|L02.01]]|[[MAIN|L02]]|[[NEXT|L02.03]]>
!!!
!The WEASEL Directed Evolution Script
<html><img src="02/dawkinsBWM.png" style="height:200px"></html>
Richard Dawkins (The Blind Watchmaker, 1986) employs the typing monkey concept to demonstrate the abilities of natural selection in producing biological complexity out of random mutations. //In a simulation experiment, Dawkins has his ''Weasel program'' produce the Hamlet phrase METHINKS IT IS LIKE A WEASEL by typing random phrases but fixing those characters that match the goal.//
^^(http://en.wikipedia.org/wiki/Weasel_program)^^
!!!The Weasel Applet:
The weasel program is a computer software simulation written by ethologist Richard Dawkins in order to demonstrate the relative power of cumulative selection in an artificial evolutionary system.
LINK: http://home.pacbell.net/s-max/scott/weasel.html
!

<[[BACK|L02.03]]|[[MAIN|L02]]|[[NEXT|L02.05]]>
!!!
!Monkey Typing: Statistical Mechanics
<html><img src="02/DEquarter.jpg" style="height:100px"><img src="02/US_quarter_back.png" style="height:100px"><img src="02/DEquarter.jpg" style="height:100px"><img src="02/DEquarter.jpg" style="height:100px"><img src="02/US_quarter_back.png" style="height:100px"><img src="02/DEquarter.jpg" style="height:100px"><img src="02/US_quarter_back.png" style="height:100px">
</html>
# Given a fair coin, what is the probable outcome of an air toss for Heads or Tails?
## P(H) = 0.50; P(T) = 0.5
## What is the difference between a probability and a frequency?
# How many times do you have to flip the coin to be 95% sure that it will land heads-up at least once?
# Given two fair coins, how many times do you have to flip both to be 95% sure that both will land heads-up at least once?
## Is this a different number than the certainty associated with flipping just one coin?
# What if ten people were each flipping one coin . . . . how many times do they have to flip them to be 95% sure that all coins will land heads-up at least once?
|{{blue{The P of ten heads in a row is 0.5^^10^^. But the probability that each coin would be a head on the first toss is still 0.5.}}} |
The crux of the monkey typing idiom is recognizing that although it is highly unlikely that an immortal monkey could ever type out 130,000+ characters in a row representing Shakespeare's //Hamlet// in total, every character position still maintains the same probability of selection. And if a mechanism is in place to fix those characters that are "functional" independently, ''then the process of evolution does not defy the statistical mechanics molecular organization.''
|@@NATURAL SELECTION establishes a strong filter for function against an otherwise infinite expanse of possibilities@@|
!

<[[BACK|L02.04]]|[[MAIN|L02]]|[[NEXT|L02.06]]>
!!!
!Monkey Typing: Python
So why are the results for the [[Monkey Typing PERL scripts|MonkeysTyping]] so variable?
<html>
<img src="02/hw/Assing1-Jixian.jpg" style="height:100px">
<img src="02/hw/Data-plot_Monkey_script_SGK.jpg" style="height:100px">
<img src="02/hw/HW2-Huang.png" style="height:100px">
<img src="02/hw/Eddie-HW2.jpg" style="height:100px">
<img src="02/hw/Guidaplot.png" style="height:100px">
</html>
Let's simplify the objective of the script. Instead of trying to randomly match alphabet letters to a target sentence, we are instead interested in taking two random strings of characters from a defined set, and then seeing how many turns (cycles or generations or loops) it takes for one of those strings to mutate into the other. The only selection rule is when a character in the mutating string is identical to the character in the same sequential position in the target string, it no longer mutates.
Because we ant a more quantitative look at the selection process, we'll utilize a python script that will call upon functions from [[R|r]], [[NumPy|Npy]], and [[PyLab|MatPlotLib]] (see [[Resources|Resource Index]]).
The MAIN working part of this directed evolution script (DirectedEvoPy) is very easy to grasp in terms of the program logic:
{{{
# 1. MODEL DATA COLLECTION . . . . . . . .
for i in range(NumberLengths):
# A. Initialize a target sequence . . . .
LENGTH = InitialSeqLen + (i*IncrementLength)
Target = TOOLS.sequence_mosaic(CHARset,LENGTH,BOOT,outdir)
# B. Iterate directed evolution . . . . . .
for j in range(BOOT):
Target.fisheryates_randomize()
Target.evolution(j)
# C. Evaluate iterations . . . . . . . . . .
Target.evaluate(i,LENGTH,Scores,CHARset,PlotScale)
print "> Seq Length = ", LENGTH
# 2. MODEL DATA ANALYSIS . . . . . . . . . . . . .
flag = 0 # flag: 0=all, 1=mean, 2=var, 3=max
Informatics = TOOLS.evolution_analysis(Scores, InitialSeqLen, outdir)
Informatics.regression(flag)
Informatics.plot(flag,CHARset)
print "\n\n* * * * D O N E * * * *\n\n"
}}}
The beauty of Python is that much of the programming nuts-n-bolts can be separated away from the main logic pathway.
!

<[[BACK|L02.09]]|[[MAIN|L02]]|[[NEXT|L02.11]]>
!!!
!Alphabet Soup
Using a 52 letter character set (upper and lower case), with 100 bootstrap iterations at each length, there is a significant positive correlation between the number of characters in the sequence and the Min, Mean and Max generation cycles or turns that were required for one random string to converge on another.
!!!
<html><img src="02/00-DataPlot-ALL-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.png" style="height:400px"></html>
!!!
To achieve this result in one script, ''R'' functions were called to compute the correlation and regression statistics, ~NumPy arrays were used for string handling (mutation, randomization), and ~PyLab was used to produce the XY plot (snippets):
{{{
# R calls:
ls_fit = r.lsfit(self.Nchar,self.DATA[:,i])
result = r.cor_test(x=self.Nchar,y=self.DATA[:,i],method='pearson')
# NumPy arrays:
self.seq = np.zeros((length),dtype='S1')
newseq = np.random.random_integers(0,self.N-1,L)
# PyLab plots:
Yheight, Xbins, patches = p.hist(self.allcounts, bars, normed=1)
p.plot(self.Nchar, self.DATA[:,i],'o',markerfacecolor=color[i-1])
}}}
|@@NOTE: The count of 700 maximum turns for a 250 char sequence to match another is far less than 52^^250^^ permutations that would be required to find the match via combinometrics.@@|
{{blue{But WHY the positive slope? If all character positions have the same probability of reaching fixation independently, why does sequence length matter?}}}
!

<[[BACK|L02.10]]|[[MAIN|L02]]|[[NEXT|L02.12]]>
!!!
!Coin Toss Model
To better understand the "statistical mechanics" behind probabilities, frequencies and selection fixation, let's use a simple system and model a fair coin toss.
Now, by being good programmers and thinking broadly when we write scripts, we can often tackle several tasks from one basic code block. Here, the Directed Evolution script was initially written around an alphabet of 52 characters, but by just changing one line in the input section, it now becomes a coin toss model evaluating two possibilities: H = heads, T = tails:
{{{
#------------------------------------
# U S E R V A R I A B L E S
#------------------------------------
CHARset = "HT"
. . . . .
}}}
!!!Mutation Cycles:
<html><img src="02/00-DataPlot-ALL-HT.png" style="height:400px"></html>
!!!What is happening among the iterations at each individual seq length?
<html><table><tr>
<td><img src="02/00-DistributionPlot-000005-HT.png" style="height:250px"></td>
<td><img src="02/00-DistributionPlot-000250-HT.png" style="height:250px"></td>
</tr></table></html>
Distributions appear skewed at both short and long ends of the spectrum.
!

<[[BACK|L02.12]]|[[MAIN|L02]]>
!!!
!Integrating Software Tools
# Many tools available, all have their unique strengths and weaknesses.
# Working in a Python environment allows you to pick the strengths of each.
# Having a question and developing a broad tool to tackle it will often open up numerous new avenues of inquiry or application.
# Treat every script you write as if it were a new hammer and bash it around looking for nails.
!

!!!
<[[BACK|L03.01]]|[[MAIN|L03]]|[[NEXT|L03.03]]>
!!!
!Models and Mirrors
Which of the following statements do you believe to be TRUE:
{{engindent{
''A.'' models are quantitative methods for describing system structures.
''B.'' models are experimental tools to answer questions about how systems works.
''C.'' models are experimental tools to ask better questions about how systems works.
}}}
!!!Models and You
# Actually, models are all about you.
# They don't test systems.
# Instead, they test your conception of a system.
# The use of models should be explicitly focused on not answering questions, but instead on bettering your understanding of the questions that should be asked.
# They are an experimental tool, but what they really test is your mind and not the system being studied.
!

!!!
<[[BACK|L03.06]]|[[MAIN|L03]]|[[NEXT|L03.08]]>
!!!
!Bootstrap Model
Uses iterative power of a program/script to generate a "population" of results to usually ascertain the contribution of random effects on a model result.
# What is the probability that your "understanding" of a system (model) does not differ from a random or neutral or null system?
# Does your understanding provide you with more information than you would have if you just believed it was a random or neutral or null system?
''Linear Discriminate Analysis of bacterial genomes: free-living vs. pathogens''
<html>
<img src="03/Fig03-LDA.png" style="height:300px"><br>
<br>
<b>Build a response distribution by randomizing the input data over and over and over . . . . <br>
<img src="03/LDAdistribution.png" style="height:300px">
</html>
!

!!!
<[[BACK|L04.01]]|[[MAIN|L04]]|[[NEXT|L04.08]]>
!!!
!matplotlib documentation
http://matplotlib.sourceforge.net/contents.html
<html><img src="04/mpl/mpldoc.png" style="height:450px"></html>
!!What is pylab?
This is a subgroup of plotting functions within the larger matplotlib module. When these functions are loaded with:
{{engindent{@@{{{import pylab}}}@@}}}
''pylab'' is a reference handle for: ''matplotlib.pyplot''.
Most of the plotting you will want to do will be accessed through pyplot functions.
!

!!!
<[[BACK|L04.08]]|[[MAIN|L04]]|[[NEXT|L04.03]]>
!!!
!matplotlib: editing graphic objects
The ''matplotlibrc'' file contains many useful parameters for editing graphic object attributes. Using the ''pylab'' //rcParams// dictionary or ''rc()'' and ''rcdefaults()'' functions lets you make and revert changes on the fly. You can review a list of current graphic settings and variables in the ''rc'' parameters module:
{{{
import pylab as p
print p.rcParams
}}}
!!Editing matplotlibrc defaults
The ''matplotlibrc'' file contains most of the graphic settings for plots generated by pylab functions. You can make //hard-coded// changes to these default graphics settings by editing this file. The file is likely located in a system folder like:
@@{{{/usr/lib/python2.5/site-packages/matplotlib/mpl-data/matplotlibrc}}}@@
If you want to customize the defaults, {{red{FIRST}}} copy this system-level file and make a user-local copy by putting it in your home folder in @@{{{~/.matplotlib/matplotlibrc}}}@@. Editing this local file will make changes that are in effect every time you use matplotlib.
!!Setting runtime parameters
To access graphic objects while a script is running, use the ''pylab.rc'' function or set values in the ''rcParams'' dictionary (which is like a PERL hash).
For example, if you want to make a series of plots for a manuscript but the default font size is a too small when the figure size will be reduced at publication, you can set label size options so that the font size for every plot generated by your script will be the same. Look at your ''rc'' options: @@{{{ print p.rcParams }}}@@. Among a large number of options, you will see some that control the font size of different labels:
{{{
...
'axes.labelsize': 12.0,
...
'xtick.labelsize': 12.0,
...
'ytick.labelsize': 12,0,
...
}}}
There are two ways to change settings. It’s personal preference which one you use. Either way, you only have to do this once. From then on, all plots will use these new parameters.
First, note that the parameters are setup as a python dictionary where '''key' = value''. Using this ''rcParams'' dictionary, you set __//keys//__ to different __//values//__ with a simple list assignment statement:
{{{
p.rcParams['axes.labelsize'] = 16.0
p.rcParams['xtick.labelsize'] = 16.0
p.rcParams['ytick.labelsize'] = 16.0
}}}
The second alternative: you could use the ''rc'' function, which allows you set to set multiple parameters to the same value in one statement:
{{{
p.rc(('xtick','ytick','axes'), labelsize=16.0)
}}}
All other figure you make will this script is running will have the same text size.
To reset, plot variables back to their default settings:
{{{
p.rcdefaults()
}}}
!!Another example:
If you wanted to increase the separation between tick-labels and the tick marks on the axes:
{{{
p.rc(('xtick.major','xtick.minor','ytick.major','ytick.minor'), pad=10)
}}}
If you only want to change one of the tick labels, say, the x major ticks, use:
{{{
p.rc((’xtick.major), pad=10)
}}}
!
!

!Recombinatorial Diversity
Borges was a writer and philosopher with a large interest in classical theology and mathematics. But his day job was as a librarian and in this 1941 essay one can see a very well developed day-dream of his as he roamed the book stacks of the Argentine National Library in Buenos Ares.
[[Borges' essay: Library of Babel|01/Borges-LibraryBabel.pdf]]
!!!Borge
http://en.wikipedia.org/wiki/Jorge_Luis_Borges
''Jorge Francisco Isidoro Luis Borges'' (24 August 1899 – 14 June 1986) was an Argentine writer born on 24 August 1899 in Buenos Aires, Argentina. He was brought up bilingual in Spanish and English. In 1914 his family moved to Switzerland where he attended school, then traveled around Spain. On return to Argentina in 1921, Borges began his career as a writer with the publication of poems and essays in Surrealism literary journals. He worked as a librarian, suffering political persecution at the hands of the Peron administration. He then became a public lecturer.
Due to a hereditary condition, Borges became blind in his late fifties. In 1955 he was appointed director of the National Public Library (Biblioteca Nacional) and professor of Literature at the University of Buenos Aires. In 1961 he came to international attention when he received the first International Publishers' Prize Prix Formentor. His work was translated and published widely in the United States and in Europe. He died in Geneva, Switzerland, in 1986.
!!!Theology and Geometry
http://en.wikipedia.org/wiki/Combinatorics
''Combinatorics'' is a branch of pure mathematics concerning the study of discrete (and usually finite) objects. It is related to many other areas of mathematics, such as algebra, probability theory, ergodic theory and geometry, as well as to applied subjects in computer science and statistical physics. Aspects of combinatorics include "counting" the objects satisfying certain criteria (enumerative combinatorics), deciding when the criteria can be met, and constructing and analyzing objects meeting the criteria (as in combinatorial designs and matroid theory), finding "largest", "smallest", or "optimal" objects (extremal combinatorics and combinatorial optimization), and finding algebraic structures these objects may have (algebraic combinatorics).
Combinatorics is as much about problem solving as theory building, though it has developed powerful theoretical methods, especially since the later twentieth century. One of the oldest and most accessible parts of combinatorics is graph theory, which also has numerous natural connections to other areas. Combinatorics is used frequently in computer science to obtain estimates on the number of elements of certain sets.
!!!

[[BACK to Ressources|Resource Index]]
!!!
!What is PERL:
In computer programming, Perl is a high-level, general-purpose, interpreted, dynamic programming language. Perl was originally developed by Larry Wall, a linguist working as a systems administrator for NASA, in 1987, as a general purpose Unix scripting language to make @@ report processing easier.@@ The language provides powerful text processing facilities without the arbitrary data length limits of many contemporary Unix tools, making it the ideal language for manipulating text files. (from http://en.wikipedia.org/wiki/PERL)
Does your computer have PERL installed? All unix-type operating systems (Linux and OS X) have a PERL version installed by default. In contrast, MS Windows verisons (2000, XP, Vista) do not. You can check by opening a terminal window and at the command prompt (here just designated "prompt>") enter "perl -v" and hit <enter>:
{{{
prompt> perl -v
}}}
If PERL is installed, then you will get a brief summary of the current version index that is on your machine. If you need to install PERL, two common sources are listed below:
''PERL Sources:''
1. PERL Org - http://www.perl.org
<html><img src="00/perlorg.png" style="height:150px"></html>
2. For Windows (2000, XP, Vista): Active State - http://www.activestate.com/Products/activeperl/
<html><img src="00/activeperl.png" style="height:150px"></html>
''You will need the Windows x86 MSI file. Here is a local link to the current version available from Active state: [[EASY DOWNLOAD|00/ActivePerl-5.10.0.1003-MSWin32-x86-285500.msi]]
Full instructions for the install are described here:
| [[Windows PERL Install]] |
!

[[BACK to Ressources|Resource Index]]
!!!
!PERL on a MS Windows operating system
Active PERL ([[Active State|http://www.activestate.com/Products/activeperl/]]) is provided in an Microsoft Installer Package that will handle most of the details of the install. The default install location is "C:\Perl". It doesn't matter where PERL is installed, what matters is that you know where it is. Also, the installer should add the perl path statement (which with a default install is "C:\Perl\bin") to the PATH environmental variable. Instructions for checking this can be found [[HERE| http://www.computerhope.com/issues/ch000549.htm]]. You can check if PERL is installed by opening a terminal window and at the command prompt (here just designated "prompt>") enter "perl -v" and hit <enter>:
{{{
prompt> perl -v
}}}
If PERL is installed, then you will get a brief summary of the current version index that is on your machine. If you need to install PERL, two common sources are listed below:
!PERL test script
Here's the archetypical "hello world" program to test your perl skills at this point.
''1.'' Copy the lines below and paste them into a new text file via your favorite flavor of text editor.
{{{
#!PATH-2-PERL
# - - - - - M A I N - - - - - - - - -
print "\n\n\nLeft a good job in the city,\n";
print "workin for the man every night and day\n\n\n";
# - - - - - EOF - - - - - - - - - - -
}}}
''2.'' EDIT the "PATH-2-PERL" string by putting the exact path to where the perl.exe program resides on your machine. On a windows PC with a default Active Perl install, this should be "C:\Perl\bin". On unix-flavor machines, you can find where perl is installed by entering the following into a command window:
{{{
prompt> which perl
}}}
''3.'' SAVE the file as "00-TestPerl.pl"
''4.'' Open a command terminal window and navigate to the folder where you just saved "00-TestPerl.pl". This is usually accomplished using these two commands (where folder = the name of a folder within the current folder where the prompt is located):
{{{
prompt> cd folder # go down one level to folder
propmt> cd .. # go up one level in tree
}}}
For those of you with Windows PCs, more information about navigating in command mode can be found [[HERE| http://ourworld.compuserve.com/homepages/jsuebersax/dos.htm#paths]]
''5.'' Once you are in the folder where "00-TestPerl.pl" is located, you can run the script as follows:
@@FOR WINDOWS PCs@@
Enter the full filename at the command prompt:
{{{
prompt> 00-TestPerl.pl
}}}
@@FOR UNIX-FLAVORS@@
Before the script can be run, it has to be "given" permission to run as an executable file. This is accomplished with the //chmod// command:
{{{
prompt> chmod 755 00-TestPerl.pl
prompt> 00-TestPerl.pl
}}}
''6.'' The print statement should execute sending this message to the screen (or whatever message you put into the script):
{{{
Left a good job in the city,
workin for the man every night and day
}}}
[[BACK|Resource Index]]
!

[[BACK to Resources|Resource Index]]
!!!
!SSH
@@. ''SSH is an encrypted file transfer protocol that replaces telnet or ftp'' .@@
!!1. For Windows OS:
SSH and SSHclient are available from the UD Network software pages at http://www.udel.edu/network:
[img[00/udnetwork01.png]]
[img[00/udnetwork02.png]]
!!2. For Mac OS X:
It's already installed and running, but you in order to mount a remote system as a system drive, you need the macfuse update at (at least for Tiger): http://code.google.com/p/macfuse/
<html><img src="00/macfuse.png" style="height:400px"></html>
!!3. For linux/unix flavors:
It is already installed, running and can readily be mounted as a system drive. I like the KDE desktop file manager because it automatically mounts ssh connections as "drives".
!!!

[[BACK to Resources|Resource Index]]
!!!
!SSH setup for automatic login to Biowolf:
SSH has a system for allowing computers to recognize each other and bypass the exchange of a password when connecting them. The way it works is that your local computer (A) generates an encrypted KEY that is then put in a file in your home directory on Biowolf. Login authorization is then determined by the computers 'recognizing' each other using this key.
First, start an SSH-client (command) terminal window on local computer (here named 'LOCAL'). Then generate the ssh key by following these commands, but do not enter a 'passphrase' when prompted. Just hit return twice.
{{{
LOCAL> ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/user/.ssh/id_rsa):
Created directory '/home/user/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/user/.ssh/id_rsa.
Your public key has been saved in /home/user/.ssh/id_rsa.pub.
The key fingerprint is:
3e:4f:05:79:3a:9f:96:7c:3b:ad:e9:58:37:bc:37:e4 user@LOCAL
}}}
Now use ssh to create a directory ~/.ssh Biowolf. (The directory may already exist, which is fine). Use your classXX username. You will be prompted for your password:
{{{
LOCAL> ssh classXX@biowolf.dbi.udel.edu mkdir -p .ssh
}}}
Now we just add/append the public key from LOCAL to your Biowolf account in a file named "authorized_keys". Again use your classXX username and you will be prompted for your password:
{{{
LOCAL> cat .ssh/id_rsa.pub | ssh classXX@biowolf.dbi.udel.edu 'cat >> .ssh/authorized_keys'
}}}
From now on you can log into Biowolf from your LOCAL computer without entering a password.
You can streamline the login process even more by establishing an 'alias' command in your shell profile. This is easy to do, but depends upon what shell you are running on your LOCAL computer. For a C shell (csh) add a line like this to the ''.cshrc'' file in your home directory on LOCAL (//note that this is a hidden file//):
{{{
alias biowolf ssh -l classXX biowolf.dbi.udel.edu
}}}
For a bash shell add a line like this to the ''.bash_profile'' file in your home directory on LOCAL (//note that this is a hidden file//):
{{{
alias biowolf='ssh -l classXX biowolf.dbi.udel.edu'
}}}
From a terminal window you need to restart the shell with either:
** prompt> source .cshrc
** prompt> source .bashrc
And then you can log into your Biowolf account with just the command:
{{{
LOCAL> biowolf
}}}

Subtopic menus are menus at the top of the topic tiddlers, like the one above, which has three subtopics: "Welcome", "Instructions", and "Subtopic menu instructions". You can have a separate subtopic menu for as many topics as you add to your mainmenu. There are three steps to creating a new subtopic menu. You may do these steps in any order you wish:
#''Create tiddlers for each of the subtopics within a topic.'' Tag them all with one appropriate tag pertaining to the topic. This will link them all so that they appear in the subtopic menu.
#''Create a subtopic menu tiddler.'' This will be the tiddler where the menu that appears above the other tiddlers is stored. In the Sidebar, click on 'new subtopic menu'. Replace 'tagname' in the title with the name of the tag you added to the tiddlers above. Then add the title of your subtopic tiddlers in the table provided, within the double brackets {{{[[ ]]}}}. Three table cells have been provided. Delete or add table cells as needed.
#''Create a custom ~ViewTemplate for your topic.'' This will tell ~TiddlyWiki to show your subtopic menu at the top of all the tiddlers that you have tagged with that topic's tag. In the Sidebar, click on 'new viewtemplate'. Replace 'tagname' with the tag you added to the tiddlers above. Do this for the title of the tiddler, as well as in the two instances of 'tagname' in the viewtemplate's code (it will look like the line shown below before you change it).
<!--{{{-->
<div class='tagnameMacro='tiddler tagnameSubtopicmenu'></div>
<!--}}}-->
That's it. A menu of links to the tiddlers you have tagged and added to your subtopic menu tiddler should appear above the tiddler title of each of those tiddlers.

!Computational Requirements:
* You will need a user account on [[Biowolf]]
* Biowolf will provide you access to these following programs (see [[Resources|Resource Index]]):
** [[Perl|PERL]], [[Python|python]], [[R Statistics Package|r]], [[Rpy|Rpy]], [[NumPy|Npy]], [[PyLab|MatPlotLib]]
* It is @@HIGHLY@@ recommended that you have these programs also installed and configured on your own computer:
** A laptop so that when we meet in class you can work on code
** AND it would also be a good idea to find an old PC desktop that wasn't being used and installed a linux distro on it ([[Ubuntu|http://www.ubuntu.com]]), and then put these python modules on it and used the linux box as your programming/working machine.
!Course Summary:
For the first 4 lectures, we will meet jointly with Prof. Miller's course in Multivariate Statistics. On March 20th, students will present their research proposal ideas for class feedback. The remainder of the semester will involve an individual project discussion with me each week to be scheduled at a time of mutual convenience. Presentations of the research projects will be on 15MAY, with final reports due during Finals week.
|! DATE |! Statistics |! Informatics |
|FEB 20 | Multivariate Data | [[Recombinatorial Diversity|L01]] |
|FEB 27 | Principal Component Analysis | Programming Tools |
|MAR 06 | Multidimensional Scaling | Modeling & Bootstrapping |
|MAR 13 | Correspondence Analysis | Graphics Tools |
|MAR 20 | | Project Proposals |
|MAR 27 | | Project Discussions |
|APR 03 |>|bgcolor(yellow): SPRING BREAK |
|APR 10 | | Project Discussions |
|APR 17 | | Project Discussions |
|APR 24 | | Project Discussions |
|MAY 01 | | Project Discussions |
|MAY 08 | | Project Discussions |
|MAY 15 |>|bgcolor(lightgreen): Project Presentations |
|MAY 22 |>|bgcolor(lightgreen): Project Reports |

This is just a modest adaptation of ~TiddlyWiki for use as a webpage. I created it for my own use, but thought others might like an empty template of it. To see a working example of the Webview ~TiddlyWiki, [[see here|http://www.giffmex.org/webviewtwexample.html]]. ''Features of WebviewTW:''
*I have reduced as much clutter as possible, so as not to confuse first time visitors to your site: the header is gone, the sidebar hidden, and Tiddler elements such as author, date created, tagged and tagging have been removed. The mainmenu has a toolbox, which itself can be gutted if desired, when you are ready to upload.
*Only one tiddler opens at a time.
*There is a way to create a series of tiddlers linked in a colorful subtopic menu above the tiddler titles (the three squares above are an example of a subtopic menu and include the instructions necessary to create one). These are good just as subtopic menus, but are also meant for slideshows and linear tutorials and lessons. The idea is similar to the [[PresentationPlugin|http://lewcid.googlepages.com/presentation_empty_full.html#Documentation]], but this setup operates in a different way.
*Saving options have been set to ~SaveBackup:unchecked, and Animations:disabled, and the sidebar is hidden by default. (See [[z_configOptions]] to change these)
*In edit mode there are a number of easyEdit menus. See [[Formatting cheatsheet]] for details. There are also several color palettes to choose from (found in the Sidebar).
*The UploadPlugin and SplashScreenPlugin are installed. For directions for the UploadPlugin, see [[this external link|http://www.giffmex.org/twfortherestofus.html#%5B%5BSimple%20instructions%20for%20BidiX's%20UploadPlugin%5D%5D]]. My apologies to Alan Hecht, the creator of the ~WebViewPlugin - there is no relation between this adaptation and that plugin, which is not used here.

''* * * * Active PERL for Windows PCs * * * *''
If you are reading this page, you are likely having significant problems getting PERL running on your PC. So . . . . . . .
@@1.@@ Let's Start Over. Even if you already have a C:\Perl directory, let's pretend you don't.
@@2.@@ Here is a local link to the current Windows-x86-MSI version available from Active state: [[EASY DOWNLOAD|00/ActivePerl-5.10.0.1003-MSWin32-x86-285500.msi]]. After clicking on this link, if you are requested to do anything, select save and put it on your desktop. The file will be named: "ActivePerl-5.10.0.1003-MSWin32-x86-285500.msi"
@@3.@@ The "msi" extension on the file stands for "MicroSoft Installer". Double-click the file and it will start running an automatic installation routine. Just accept the default location ("C:\Perl") and on the options screen leave the boxes checked for: "Add Perl to PATH environmental variable" and "Create Perl file extension associations."
@@4.@@ Once the installer finishes, click START, click RUN, enter the command "cmd" (without quotations) and press RETURN to open a terminal window.
@@5.@@ At the command prompt, enter "perl -v" (w/o quotes), hit RETURN and the current version number of the perl install should be displayed in the terminal window. You are now ready to run perl scripts.
''If this worked, then you are ready to go to the test script here:'' [[Running PERL]]
//If the "perl -v" command doesn't work, then we will have to contact Active State and try to troubleshoot what's wrong with your computer.//
[[BACK|Resource Index]]
!

[[BACK to Resources|Resource Index]]
!!!
!Getting ~MatLab
Unfortunately, the University of Delaware no longer supports free licenses for students, only faculty. Student versions are available for purchase at a large discount, but you should ask your advisor to send this email to Anita Schwartz (anita@udel.edu):
{{{
Dear Ms. Schwartz,
I need to install MatLab on a research computer in my lab for the
(choose one: Windows, OS X, or Linux) operating system.
Could you please send me the install diskettes or the download instructions?
Thank you.
Sincerely, .......
}}}
''MatLab Tutorial: Lots of online resources available. Best HELP index of any program I have ever used.''
[[MATLAB HOME|http://www.mathworks.com/]]
<html><img src="00/matlab.png" style="height:300px"></html>
!!!