[ NOTE! This file, if in current directory, is used for on-line help. Therefore, it must not be altered in any way ] * ÜÜÜÜÜÜÜÜÜÜ ÛÝ Û ÛÝ Û ÞÛ ÞÛ ÛÝßßßßßßßß ÞÛ ÞÛ ÛÝÞßßßÞßßß ÞÛ ÞÛÞßßßÞßßß ÛÝÞßß Þßß ÜÜÞÛ Û ÞÛÞßß Þßß ÛÝÞÜÜÜÞÜÜÜ ÞÛÜÛÛÜÛÛÞÜÜÜÞÜÜÜ (Ver. 2.6) Copyright (c) Pablo A. Goloboff 1993-1997 G E N E R A L Pee-Wee is a program for parsimony analysis under implied weights, using a concave function of the homoplasy. It searches for trees which maximize äFi across characters, where Fi=K/(K+ESi). K is a constant of concavity, that can be changed by the user (with the command conc see below); ESi is the number of extra steps for character i. Theoretical justification can be found in Goloboff (1993. Cladistics 9:83-91); suffice here to say that the trees which maximize that function resolve character conflict in favor of the characters which have less homoplasy on the trees and imply that the average weight for the characters is as high as possible. Pee-Wee also provides facilities for diagnosing and comparing trees and calculating consensus. The default interface and some commands in Pee-Wee are as in Hennig86; if you do not have experience with Hennig86, the documentation of that program may help you deal with Pee-Wee. Commands can be entered in upper or lower case, and truncated, one or several at a time. In general, there is no need to leave blanks between alphabetical characters and digits; for example, hold 100 keep 1 jump 5 is equivalent to hold100keep1jump5 or simply h100k1j5 (this does not hold for data matrices: there must be a blank between taxon names and the first character!). Commmands that may take arguments are executed only after all possible arguments have been parsed, or a semicolon or another command is entered. Commands (with their arguments) can be passed as arguments to the program when invoking it (i.e. from the DOS command line), just like as from within the program. For those commands that take scopes, they work as in Hennig86, taking any of four forms (X and Y represent numbers): 'X.Y' all values between X and Y (it does not matter whether X or Y is the larger); '.X' all values between minimum and X, inclusive; 'X.' all values between X and the maximum, inclusive; '.' all values between minimum and maximum, inclusive. It is also possible to have a menu interface, which starts entering 'menu' at the command prompt (or using it as argument when calling the program). Data set size: there is no fixed limit for numbers of taxa or characters; the only limit is given by the amount of memory (and time) available. More than 500 taxa would cause problems to the aesthetics of tree diagrams if using the (default) naked- option to draw trees (the node numbers are suppossed to occupy 3 spaces, not 4!). On computers with only 640K available, 200-300 characters x 150-200 taxa is about the maximum that can be read, but if you have fewer characters you can have more taxa, and viceversa. Pee-Wee has (like Clados) a file for trees and one tree is current. The current tree is used to establish a reference tree, change branches, define constraints; the commands whennig and ranswap create or modify the current tree. Most of the commands that deal with trees (tree diagrams, tree saving, diagnosis, fit statistics) can be performed on current tree (if no argument, or a semicolon, follows the corresponding command) or on each memory tree (if the command is followed by '*'). A word on polytomies: the trees are treated internally by Pee-Wee as fully dichotomous. By default, the trees are displayed and compared taking into account character support, in which case (by default, see below under ambiguous) branches that are not supported under any possible optimization are shown as collapsed (this is a stricter interpretation than Hennig86's or PAUP's, which keep a branch if it is supported under some optimizations). The command poly sets whether trees are shown/saved/compared as polytomous or not (see below). Some of the collapsed trees may be longer than their resolutions if adjacent nodes are collapsed (i.e., collapsing the nodes separately does not add steps, but collapsing them together does). This is one of the reasons to internally store the trees as dichotomous: the information of which of the possible resolutions are parsimonious would be lost if the trees were actually collapsed. The trees are then compared to check whether they would be different IF unsupported branches were collapsed (but, I repeat, the branches ARE NOT collapsed). If the trees read with tread are not fully dichotomous, the unresolved clades are resolved arbitrarily. If the trees are saved in parenthetical notation with unsupported branches collapsed, subsequent reading of the files (be this with Pee-Wee, Hennig86, or Clados) may produce longer, or less fit, trees (then, the default sv saves the trees as dichotomous; to save them as collapsed, use k as prefix, i.e., ksv). The trees are displayed as polytomous, but optimizations correspond to the dichotomous resolution of the polytomy actually stored in memory (other resolutions or the polytomy itself may imply different change, so this is in some way similar to the problem of ambiguous optimizations). Pee-Wee does not optimize polytomies. In my opinion, one should ideally use max under poly- to find all the possible dichotomus resolutions of the polytomies due to lack of support, and consider as synapomorphies of the clades those changes that are common to all the resolutions (using '/', '-' or '[' as arguments for apo). If optimizing a polytomy as polytomy is required, Hennig86 or Clados have to be used. The branch-swapping algorithms need a tree to be inputted, but some of the commands (empezar, search, mult, and bound; see below) automatically create a wagner tree as starting tree and invoke the swappers. Pee-Wee swapps branches using either "subtree pruning- regrafting" or "tree bisection-reconnection." Subtree pruning-regrafting is the default swapper; if '*' is passed as first argument to the corresponding tree-searching commands, the "tree bisection-reconnection" swapper is used instead (since this swapper has to examine more trees, it naturally takes longer, but is more likely to find better trees). Using the different swappers and options for tree-searching, Pee-Wee allows to do searches within a wide range of detail, from very cursory (just using whennig) to very exhaustive (using numerous different random addition sequences, keeping trees suboptimal by a large fit difference, or clipping trees in several parts). A word on islands of fittest trees: the problem of islands is quite acute for concave functions of the homoplasy. Obviously, this is in part because the resolution of one clade depends on the resolution of other parts of the cladogram more than in pre-weighted approaches. In using Pee-Wee and Nona (which use exactly the same type of algorithms and shortcuts) I found that the problem of islands is apparently of a different nature for shortest and fittest trees. For minimum length trees there are often several islands of minimum length, few islands of suboptimal length, and the problem is moving between one optimal island and another. For fittest trees, in contrast, there seem to be one to very few islands of optimal trees, and many (non-connected) islands of suboptimal trees; the difficulty is then, not finding a greater number of fittest trees, but instead finding one of the fittest trees. Therefore, in Pee-Wee the command jump often allows to jump to a fitter island, while in Nona it often allows to find more trees of equal length. Similarly, intuition suggests that the use of a narrow clipping neighborhood in conjunction with the mswap command should limit much more the succes of the search in Pee-Wee than in Nona. What constitutes an 'island' for Pee-Wee/Nona is hard to predict, as it depends on many factors besides type of rearrangement I use the term 'island' rather loosely, as short for 'a case in which the program fails to find more trees of better or equal fit.' As the program allows to do multiple swappings, in theory one should always be able to overcome the problem by simply clipping more clades at the same time (practice falls VERY far from this, as this could take an extremely long time). I F P R O G R A M D O E S N ' T R U N ! If 386 versions of the program don't run when called from the DOS prompt, and report an error message saying something like: FATAL ERROR Previously installed software is neither VCPI nor DPMI compatible the most likely cause of the error is a memory manager (usually MicroSoft's emm386). Add the string 'REM' in front of the corresponding line of the config.sys file, reboot, and call the program again. A N O T E O N C O M P A T I B I L I T Y W I T H O T H E R P R O G R A M S Other Ms-Dos programs use rather similar formats, sharing some commands, but not all, with Pee-Wee/NONA. Execution of the same command, however, may differ slightly by some programs. To help create files which can be read by any program with no modifications, the program recognizes (only from within files) the names of other programs, as well as its own: nona dada piwe phast hennig86 spa clados all Its own name followed by '-' will make the program ignore everything in the file, until its name followed by '/,' '+' or '=' is found. Other program's name followed by '=' will cause the program to ignore everything in the file, untill the name of that program followed by '/' or '-,' or the own name of the program followed by '+,' is found. The string 'all' activates all programs, if they had been deactivated (by either its own name followed by '-' or other programs' name followed by '='). Examples: piwe= ccode =.; nona+ tplot; piwe/; max; of all the programs, only Pee-Wee will execute 'ccode,' Pee-Wee and NONA will execute 'tplot,' and all programs will execute 'max.' Using instead piwe= ccode =.; nona= tplot; piwe/; max; only Pee-Wee will execute 'ccode,' only NONA will execute 'tplot,' and all programs will execute 'max.' Note that in both cases programs other than NONA will ignore the 'nona+' or 'nona=' commands (since they are within a 'piwe=' and 'piwe/'); what will make those programs to start parsing commands again is the string 'piwe/.' An easier way to accomplish the same thing: piwe= ccode =.; nona= tplot; all max; T R E E S E A R C H I N G C O M M A N D S WHENNIG N creates a wagner tree (like the hennig command of Hennig86, maximizing fit in Pee-Wee, minimizing steps in Nona). It is fast but not very effective. If a number N is passed as argument to whennig, the order of addition for the taxa is randomized (according to current random seed, see below under rseed), N times, keeping only the best tree(s). If no number is passed as argument, the addition sequence is as in the matrix. The resulting tree(s) are added to the tree buffer. MAX do branch-swapping on initial trees, searching for trees with highest fit. The trees used as starting point are the trees that are topologically different and of highest fit in the memory trees and the current tree. If '/' is used as argument, searches for the fittest trees in which the groups specified in the list of constraints (with force) are monophyletic; if none of the available trees fulfills the requirements for monophyly, the search is aborted. If several groups are constrained for monophyly, fewer trees are examined, and searches may take shorter; constraining well supported groups may save time when exploring your data. If '*' is used as first argument (NOTE: can't be used in conjunction with '/'), the trees are swapped more exhaustively (using tree bissection-reconnection). If the trees are being treated as polytomous the swapping takes, per tree, a slightly longer time than simply comparing whether the trees have different unsupported dichotomous resolutions, but when branches are collapsed fewer trees may have to be swapped if the data produce unresolved clades (obviously, this is also true also for other commands that invoke the swapper). If '-' is used as argument, followed by a number N, the swapping starts on tree number N (obviously, max-0; is equivalent to max;); if no number follows the '-' and the current set of trees in memory corresponds to an aborted max search, swapping is resumed where it had been abandoned. EMPEZAR create a weighted wagner tree (i.e., as the command whennig), and then rearrange it (using subtree pruning-regrafting). If '=' is used as argument, the order of the taxa is randomized (for both the addition sequence and swapping sequence). SEARCH as empezar, but it also searches for additional trees (saving as many trees as storage space is left), using tree bisection-reconnection. If '=' is used as argument the order of taxa is randomized. MULT N it randomizes the order of the taxa, creates a weighted wagner tree, and submitts it to branch-swapping (if '*' is used as argument, using tree-bissection reconnection), storing in memory as many trees as it had been set before with hold/ (default number of trees to be kept during this initial stage of search is 20); repeat the process N times, 'seeding' the random number generator each time (see below, under rseed). By default, the program abandons a replication if a tree of better fit than trees previously found in that replication is the same as a tree already held in memory (can be reset with duplicate*). Another more exhaustive, but slower option (set with duplicate-), is to swap the first fittest tree in each replication, checking only additional trees. Under either duplicate- or duplicate* the program keeps, for each replication, all the trees it finds (so that subsequent replications can be compared to those trees, without swapping on the same tree many times). Note that if the number of trees found in a replication is less than the number of starting trees (i.e., determined with hold/N) it will be unnecesary to do additional swapping (using max) of those trees. Under duplicate=, the trees in each replication are not compared with previous trees (i.e., they are swapped even if they would collapse to produce the same tree), and only one tree per replication is retained. As mult under dupli= retains only one tree per replication, mult under dupli= should probably be used with low numbers of starting trees; normally, additional swapping should lead to find more trees. It is possible for mult to retain suboptimal trees, by a difference in steps independent of the value of suboptimal. This allows to do each replication saving only optimal trees (which increases the likelihood of finding optimal trees), but at the same time retain the trees resulting from all replications (instead of discarding those replications which ended up in longer trees). This could help in procedures like parsimony jacknifing, which tries to estimate well supported groups by examining what is common to many independent searches, regardless of whether the search actually found optimal trees. To set this, use 'mult/N' --where N is the maximum fit or step difference (use 'mult//' to retain all trees). Note that 'mult/' does NOT run mult, only changes the setting. BOUND N1 N2 same as mult, but instead of swapping on all the trees it can find, it swapps untill it finds a tree of fit N2 (the "bound"), in which case it starts the new replication with a new random order. The first replication swapps exhaustively (but keeping no more trees than the maximum number of initial trees, specified with hold/), in an attempt to improve the bound. If no number is provided as bound, it uses the best available or the one resulting from first replication. If there are trees in memory before issuing this command and the bound provided by the user is inferior to those trees, the best bound is used. If the bound is improved in one of the replications, a new bound is used for subsequent replications. For messy data sets, this may execute faster than mult, but if provided with a suboptimal initial bound it is quite likely to produce suboptimal trees. JUMP N do branch-swapping, on all the trees it can find with a difference of fit up to N/10. This allows to 'jump' between islands separated by differences in fit up to N/10. If another tree of better or equal fit is found while swapping a suboptimal tree, all the suboptimal trees are discarded and additional trees are sought (retaining now only those of equal or better fit). If that tree is found while swapping one of the initial trees, it is ignored, since that tree belongs --by necessity-- to the same island, and this command attempts to find trees in DIFFERENT islands (a warning message letting you know that the initial trees did not form a complete island is displayed). If the number of initial plus suboptimal trees equals max. trees, and one of the initial (optimal) trees was being swapped, the program starts swapping on the first suboptimal tree. So, this command jumps only ONE island at a time, and it is not effective to find more trees in an incomplete island (if the set of trees submitted to jump or jump* was obtained by max or max* without overflowing memory, or by a successful jump without overflowing memory, the set of trees will form a complete island). Obviously, more trees may have to be swapped; obviously again, values of N too high will just fill your memory with trash unless you are making memory space to store enormous numbers of trees (a tree which is much worse than the best is unlikely to lead, in a few swappings, to a tree as good as the best). Since after finding a tree as good or better than the original trees it discards the suboptimal trees, it does not insure that the final set of trees for jumps that succeeded in finding more trees will not lead, by swapping again on suboptimal trees, to more trees, not discoverable by swapping on the final trees (but note that if the jump failed to find more trees and you did not overflow the tree buffer you can be certain that, if there are more trees as good/better, they are separated through trees inferior by more than the jump value). Therefore, several executions of this command may produce different results (i.e., each time it jumps to a new island). Only those trees of highest fit are retained as final. Jump 0 is equivalent to max. Arguments '*', and '/' are the same as for max. MSWAP N Multiple swapper: cuts the tree at N points and swapps the N+1 resulting parts. If no argument follows mswap, subtree pruning- regrafting is used; if '*' is used as first argument, tree bisection- reconnection. Pressing '.' during the search, aborts it; pressing 'r' (note: lower case!) produces a report (of the fit, which tree is being swapped, how many trees are stored in the buffer, and the approximate proportion of the necessary swappings already done on the tree being swapped); pressing 'x' interrupts the swapping of the current tree, and starts swapping on the next. If the report option is in effect, the report is produced automatically. Note that calling 'mswap1' produces the same type of swapping than 'max' and calling 'mswap*1' the same as 'max*'. Although they try similar rearrangements, 'max' uses shortcuts specific for a single cut of the tree (shortcuts which are unnecesary for multiple cuts), and then using 'mswap1' (with or without '*' as argument) takes longer than 'max,' If '@' and a number J follow the number N, the search starts clipping at node J. If '=' immediately precedes the number N, the number of clippings to swap is counted, and the total swapping time (for a single tree) is estimated. The time estimate is VERY rough. If '-' and a number L follow number N, mswap completes the swapping of (at most) L trees and stops (something like 'mswap*2-5 max*;' may be useful to simply find trees in different islands, but then complete each island with a simpler swapping algorithm, without the need of one having to interrupt the mswap search 'manually'). This can be much more exhaustive than the simple max, but --obviously-- takes longer. The more parts the tree is cut, the more exhaustive the search is. For 40 or more taxa, however, it seems unlikely that a search cutting at more than 2 points can be finished in a reasonable time. In part for that reason, the maximum number of points at which the tree can be cut is currently set to 15. For TBR-2, the number of rearrangements/second the program can evaluate can be 20-30 times that for TBR-1. The number of rearrangements to try, however, is much more than 20-30 times that for TBR-1, being about the square of the number for TBR-1 (for TBR-3, it would be the cube of the number for TBR-1). Therefore, for 40 taxa, TBR-2 requires about 20,000 times more rearrangements than TBR-1: about 40 to 50 million rearrangements must be tried for 40 taxa; swapping with TBR-2 each tree of 40 taxa then takes about 500 times longer than with TBR-1 (in a 486, 66 MHz machine, a complete round of TBR-2 for a 40-taxon tree takes about 500 seconds). The mswap command can be used to produce exact solutions for up to 18 taxa: for t taxa, cutting the tree at t-3 points produces an exact solution (the qcollapse= or + options might lead to discard some trees actually different; so, if in effect, qcollapse= or + are temporarily deactivated when an exact search is called). Note that, even if the solution produced is exact, this is still organized as a 'swapper' more than as a 'branch and bound' routine; there is some redundancy and unnecessary work being done, so that it is not all the efficient that an exact solution could be. Because it is organized as a swapper, it needs trees as starting point; it does not create them 'de novo.' For less than 15 taxa, on fast machines, it can be used in reasonable times. If you don't want to calculate the value for t-3, use '+' as argument for mswap, which directly sets the number of clippings to produce exact solutions. Note: see under 'excomp' for a way to save some time for searches that can produce large numbers of trees under poly-. The number of rearrangements to try can be limited defining a "neighborhood" (see below); if the neighborhood is properly defined, a lot of time can be saved, probably without sacrificing much accuracy. The only approximation possible is in trying to eliminate duplicate swappings (i.e., swappings that produce the same tree) for the '*' options of multiple swappers. Normally, many swappings that will probably end up producing the same tree are not done (this reduces the number of actually distinct swappings in 5 % to 5 %.). Entering 'mswap];' the checking for duplicate swapping is more rigorous, and all actually distinct swappings are done. Entering 'mswap[;' goes back to the less strict checking. Entering mswap without arguments reports the setting; note that using '[' or ']' as arguments all that is done is changing the setting. SSWAP as mswap, but always clips 2 sister nodes together. It is faster, and although less effective than mswap, it often finds better trees than the single-cut swappers. Using '*', '-', or '@N' as argument is the same as for mswap. When '[' or ']' are used as argument for mswap the setting for swapping sequences of this command is also changed. TSWAP as mswap, but always clips 3 nodes together: the two descendants and the sister of each internal node. It is rather more exhaustive than sswap. Using '*', '-', or '@N' as argument is the same as for mswap. When '[' or ']' are used as argument for mswap the setting for swapping sequences of this command is also changed. ALTSWAP as mswap, but always clips 2 nodes: for each internal node, it does 5 clippings: both descendants, left descendant and right-left grandchild, left descendant and right-right grandchild, right descendant and left- right grandchild, and right descendant and left-left grandchild. If an immediate descendant is a terminal, swapping of grandchildren for that node is obviously ommited. Example: ÀÄ45ÂÄ23 BARYCHELID ÀÄ44ÂÄ42ÂÄ2 PARATROPID ³ ÀÄ37 Glabropelm ÀÄ43ÂÄ3 Ischnocolu ÀÄ22 THERAPHOSI If swapping starts on 42, the sequence would be: Node 42: 2+37; go to next; Node 43: 3+22; go to next; Node 44: 42+43; 2+43; 37+43; 3+42; 22+42; go to next; Node 45: 23+44; 23+42; 23+43; go to next; Obviously, each clipping combination done by sswap is also done by altswap. Therefore, sswap examines a subset of the trees examined by altswap (just like, other things being equal, subtree pruning regrafting examines a subset of the trees examined by tree bisection reconnection). Using '*', '-', or '@N' as argument is the same as for mswap. When '[' or ']' are used as argument for mswap the setting for swapping sequences of this command is also changed. OPTIONS for searches: see amb, break, discard, hold, nighbor, poly, qcollapse, report NOTE: Searches can be done more or less exhaustively, according to settings. Obviously, the more exhaustive, the longer it takes. The commands mult and bound provide starting points for subsequent branch- swapping (with max or max*). Obviously again, the larger the number of replications and the larger the number of initial trees to retain (i.e., hold/), the more effective. The '*' searching option should almost always be more effective than the default. For jump, the larger the jump, the more certain you can be that there are no better trees. If the trees are treated as polytomous, the island problem is least dramatic (as long as the tree buffer is not overflowed because of the many arbitrary resolutions), and if nodes supportable by ambiguous optimizations are retained the island problem is less important than when only unambiguously supported nodes are retained. The qcollapse option may preclude finding some trees when there is much ambiguity in optimizations (but note that using mult overcomes, at least partially, this problem). The settings established as defaults for the program are those which I consider as the best trade-off between speed and effectiveness. The order of precedence for the several swappers in the program is: MAX* ( MSWAP*1, Hennig86's 'BB,' PAUP's 'TBR')  SSWAP*  ALTSWAP* --> MSWAP*2   TSWAP* ---> MSWAP*3 --> MSWAP*4 --> MSWAP*N All of the multiple swappers accept '/' as first argument, and in that case initiate the search and stop when the first better tree is found, or when an additional tree is found. This allows switching from (say) 'mswap*2' and 'max*' with no need for 'mswap*2' to swap on all the trees. C O M M A N D S S H A R E D W I T H H E N N I G 8 6 PROCEDURE XXX, DO XXX parse file xxx for commands; with procedure, non-Pee-Wee's commands are ignored (i.e., any Hennig86 file can be parsed with procedure); with do they cause an error message (i.e., it may provide better error detection). Commands (and their arguments) are taken from the file just as from the screen. Arguments '-', '*' and '/' as in Hennig86: procedure- or do- temporarily deactivate the file, procedure* or do* reactivate it (input is taken from it beginning at the first character not yet read), and procedure/ or do/ close it. CCODE sets weights, additivities, activities and internal steps for each character. Characters may be given weights between 0 and 10 (not 100, as in Hennig86 or Nona). By default all characters have a weight of 1 and are active and additive (but note that polymorhic characters are considered as nonadditive). These settings may be changed by the ccode command. The command uses 7 control characters as specifiers: [ make following characters active ] make following characters inactive - make following characters nonadditive + make following characters additive /N set weight to number N, then apply to following characters =N set internal steps to number N, then apply to following characters * discard all previous specifiers Scopes can be used for the ccode; minimum and maximum values are respectively 0 and the number of characters minus 1. Examples: ccode/[+.; reestablishes defaults ccode]3 4 5 6 7 [/3 9 10 11 12 13 14; deactivate 3 4 5 6 7, apply (prior) weight 3 to 9 10 11 12 13 14 ccode]3.7*/3 9.14; ditto Unlike Hennig86's ccode, different 'ccodes' cannot be held in memory by Pee-Wee, but if no arguments follow ccode, the current settings are displayed in a form readable by Pee-Wee. Therefore, entering output xxx ccode; output/ would save the current settings for the characters to a file 'xxx.' If a character is variable within some terminals, those steps (which would imply homoplasy on any possible tree) can be added to the steps actually occurying on the tree. The default number of steps within terminals is 0 for each character; the specifier is '=', so that cc=0.; will set all internal steps to 0, cc=1 10.15; will set to 1 the internal steps for chars. 10-15; and so on. If no number immediately follows '=' the internal steps for the corresponding character are calculated according to the steps implied by the polymorphic terminals (i.e., to the minimim possible steps occurying in the terminals, according to current additivity settings). Also, it is possible to refer to characters by names in the ccode (optionally preceded by '$') as a blank-terminated string; (underscores represent blanks; semicolons separate state names!); all the characters that match the string will be set according to the preceding specifiers (see ncode for non-truncable names). By using suitable names, the settings for groups of characters can be easily changed. The symbol '?' can be used as wildcard for a letter. The string provided cannot be more than 24 characters long. Note that unlike Hennig86, each ccode statement MUST end with a semicolon, as the program attemps to match any non-number with a character name. If prior weights are assigned to the characters, the fit for the character is multiplied by the prior weight. This can be used to represent N different characters with identical distribution by just one variable of weight N. Also, by giving all the characters a weight of 10, the precision of the fit is increased (in one digit); this is probably necessary for large data sets (where some characters can have many extra steps: otherwise a character with, say, 50 extra steps could be taken to have the same fit as one with 51). TPLOT show trees (with '*' as argument, for every tree in memory; with no argument, for current tree). TREAD followed by a tree in parenthetical notation, reads the tree. Only '(' and ')' can be used to delimit groups (can't use \, /, [, ], {, or } as in Hennig86). Parentheses should ideally be balanced (as in the trees produced by the sv or ksv commands), but trees with unbalanced parentheses (with the trailing parentheses discarded) usually are properly read. Those taxa not included in the tread statement are included further down the tree; if taxon 0 is not the sister to anybody else, the tree is automatically rerooted such that it is (note then that groups which were monophyletic on the original may become paraphyletic if the tree is rerooted; this is avoided if taxon 0 is explicitly included in the tread statement). Can use taxon numbers or names (by default, not truncated). If using taxon names, can specify truncation by using '..' (as for nread). Examples: tread ( 0 ( M.. V..; would place all terminals for which the name starts with either 'M' or 'V' in a monophyletic group; tread ( 0 ( (M..) (V..; would place all terminals for which the name starts with either 'M' in a monophyletic group, all terminals for which it starts with 'V' in another, and those two groups as sister to each other; Note that the the (M..) works properly only if more than one taxon starts with 'M'; else, it is equivalent to enclosing in parentheses a single taxon: it causes an error. An asterisk (*) separates trees. If several trees are read with a tread command, they are added to the memory file (i.e., previous trees are NOT lost when issuing a tread command) and the last one is made current. TXASCII the program normally utilizes extended Ascii characters to draw trees. As one may experience difficulty printing them, it is possible to draw trees using "printable" characters, entering txascii-. Entering txascii; goes back to the default. Note that the trees are always shown on screen using extended Ascii characters (the only difference is in the output files). XREAD reads (or saves) data. Xread should be followed by: 1) an optional title, enclosed in single quotes; 2) the number of characters; 3) the number of terminal taxa; 4) for each terminal taxon: a. its name, b. its state(s) for each character. An unobserved entry in the matrix can be represented by - or ?. If a second data file is to be read, all results and character settings for the previous data file are discarded. The program asks confirmation before resetting the data file; if you want to skip the confirmation, you can discard the current data file issuing a 'data-' command (which cannot be truncated). Changes to the matrix can be done from within the program (with '=' as argument for xread or nread, see below). A terminal in the matrix can be considered as having several states; all the states that occur in a polymorhic terminal should be enclosed in (square) brackets ([013]). Polymorphic terminals are treated as if they were internal nodes leading to terminals having the states assigned to the terminal and forced to remain monophyletic during searches. By default, all characters with polymorphism are considered as nonadditive. If a character is made additive, those taxa polymorphic for the character which have non- adjacent states will be converted as having the complete range of states. For example, a taxon having [0128] will be converted as having states 0 through 8. Note that connecting this terminal to a node with states 3-7 would produce no steps, even though states 3-7 have not been 'observed' in the terminal (this would be the case also if the polymorphic taxon was a clade leading to two terminals having states 0 and 8: if connecting that clade to a node with states 3-7 no steps would be added). Note also that the information of which states (i.e., 3-7) were not present in the original, nonadditive coding, is lost, so that making a character additive and subsequently nonadditive may change the matrix for the polymorphic taxa. So, be advised not to mess with the ccode more than necessary! If you do, using '=' as argument for xread allows changing the matrix cell by cell: entering a character number, a taxon number, and the states to be assigned to the cell. This also allows to make small changes to the matrix without having to exit the program. If you want to save changes (to the screen or to the output file), use '*' as argument for xread. If you want to save changes excluding inactive characters, use '-' as argument (beware that numbers for characters change, so that previous ccode or cname statements may no longer be valid). Two other commands to read data are dread and nread. O T H E R C O M M A N D S ( A L P H A B E T I C A L ) AMBIGUOUS to collapse trees, a looser interpretation than the default can be followed. With ambiguous= those branches for which some states occurying in the set of possible states for the descendant node are absent in its ancestor (or viceversa) are considered as supported. This is not exactly the way that Hennig86 collapses the tree (it is still stricter), but is closer than amb-. If using the ambiguous= option, collapsed trees are always as short as the original resolution. Enter ambiguous- to collapse branches under the strictest interpretation: if any possible states are shared between ancestor and descendant node, the branch is considered unsupported. APO list synapomorphies of clades (with '*' as argument, for every tree in memory; with no argument, for current tree). Followed by a number N it reports the synapomorphies for clade N only (this can be done only for current tree), else it reports synapomorphies for each clade. If '=' is used as argument, it reports the synapomorphies for corresponding clades in current tree and each of the trees in memory (if no number follows '=' this is done for each of the nodes in current tree, else only synapomorphies of specified clade are reported). If '/' is used as argument, it reports the synapomorphies for each clade in current tree that occur in each and some of the trees in memory (if no number follows '=' this is done for each of the nodes in current tree, else only synapomorphies of specified clade are reported). If '-' is used as argument, it is equivalent to using '/' with the difference that only those nodes that would occur in the consensus tree are reported (but if a number follows '-' the synapomorphies are reported even if the component wouldn't occur in the consensus). Apo/ and apo- may be time consuming, since those commands require a complete optimization for each node of each tree (i.e., for 10 trees of 10 terminals, 10x18=180 complete optimizations would be required). If breaks are enabled (see break) apo/, and apo- can be interrupted by pressing '.'. If 't' and a number N follow '/' or '-' a 'table' format with columns N characters wide is used (if no number follows 't', default column width is 20; if 't' is followed by 0, tabs are used as separators --this makes it easier to print tables with proportional fonts). Note that apo/ and apo- consider that a given character may provide a synapomorphy in all trees even if the change is not the same; for taxa A-L, if A-F have state 0 and G-L have state 1 for a given character, for the two trees: ((D,E,F)(J(K(L(A(B(C(F,G,H)))))))) and ((J,K,L)(D(E(F(G(H(I(A,B,C)))))))) The character provides an unambiguous synapomorphy of (A,B,C,F,G,H) in both trees; in the first tree, it is a change 1-->0, in the second, a change 0-->1. The program would then report that the character provides an unambiguous synapomorphy in both trees, with a change from either 0 or 1 to either 0 or 1. If '+' is used as argument for apo, the (numbers of the) characters supporting each branch of current tree are shown on the tree diagram. If '[' is used, the same kind of diagram shows the character support common to all trees in memory (i.e., the same information as apo- or apo/ but in a different format; this is less time consumming than apo- or apo/; because it does not have to report character changes occurying in only some of the trees; as in apo- or apo/ calculation can be interrupted, if breaks are enabled, by pressing '.'). If '[' is followed by a number N, only clade N is shown. In the lists of synapomorphies, by default, only those changes that occur under any possible optimization are reported. The number of unambiguous synapomorphies may be LESS than the total number of steps of a tree if some characters have ambiguous optimizations. If using ambiguous= it reports all the branches for which the possible states of ancestor and descendant node are different (this is equivalent to change, listed on a node basis instead of a character basis). BEST keep the trees that are topologicaly different and of highest fit. If '/' is used as argument, keeps only the trees of highest fit in which all the groups defined in list of constraints are monophyletic. If '-' is used as argument, followed by a change type [as for change/: a character number or name, possibly truncated, slash, from state(s), to state(s)], the trees which minimize the number of specified changes are retained, discarding the rest. A related command, which does not discard unfit trees, is unique. BREAK with '=' as argument, enables breaks during tree searches (pressing '.'); if breaks are enabled, pressing 'r' during searches produces a report of the status of the search. If a long loop was being executed when a key is pressed, it may take a moment until the search is actually abandoned or a report is produced. If a breakable search is being performed, one cannot start typing more commands untill the search is completed. With '-' as argument, searches cannot be aborted (there is almost no difference in execution time if searches cannot be aborted, since the checking for a pressed key is done in the outer part of the loops; only real advantage of unbreakable searches is that one can type commands before the search ends). Default is break=. BSUPPORT Calculate bremer supports. This is done using available trees; if a number N is passed as argument to the command, the program automatically does TBR swaping on preexisting trees, saving trees up to N/10 less fit than the best found. The trees may also have been found by a previous search keeping suboptimal trees. Note that using trees suboptimal by a small difference many clades will still not be collapsed in the consensus; this is indicated as support "greater than" (>). Note that using trees found by heuristic methods the actual bremer supports may be overestimated; the support may actually be the one indicated, or less. To find the trees in a previous search, the 'find' command is useful --it searches trees according to current settings of 'suboptimal', but when memory is full, it stops (it may be much faster than max). NOTE! My implementing of the bremer supports in the program does not mean unconditional endorsement of the method. In particular, I think that the absolute magnitude of the fit difference is not enough; a difference of absolute fit of 1.00 is very significant if the fit is decreased in 1.00 for a character, and increased for none, but very in-significant if due to decreasing 1.00 for 101 characters and increasing it 1.00 for 100. Yet, compared to other current options for evaluating support for clades (bootstrapping, T-PTP), bremer supports are a much better way to evaluate support for clades. CHANGE by default, list nodes where there is change for each character (with '*' as argument, for every tree in memory; with no argument, for current tree). Followed by a number N, list only change for character N. If the characters have been named, the name can be used (optionally preceded by $, in the same format as for the ccode). If the report option is set (see below), it also reports the number of steps and extra steps for each character for which it lists the change. The number of branches along which there is a change in the possible states assignable to the node may be GREATER than the number of steps if there are ambiguous optimizations. Using '[' as argument, it shows the tree with state assignments for each node (if no number follows '[', for each character, else, only for number specified). With ']' instead of '[', only those nodes where changes are indicated on the tree (if the character states had been named, using the names; names don't fit in the '[' option). If one is interested in only a specific type of change, use '/', followed by a character number or name (if no name or number is specified, all characters are done), and a slash followed by ancestor and descendant state(s). This reports branches where ancestor and descendant nodes have the specified state(s) (by default, for current tree, if the first slash is preceded by '*', for all memory trees). Can use names for states, but then only those characters for which the names match are reported (i.e., change//abs pres; will report the branches where there is change in any character for which there are states called 'abs' and 'pres', from 'abs' to 'pres'). If a set of states is to be used, enclose them in square brackets ([ ... ]). By default, those branches are reported for which ancestor and descendant nodes have state sets identical to those specified and are different between them (i.e., change//abs abs; reports nothing!). If a state (or set of states) is preceded by a '+', those nodes are considered in which among the states are those specified (regardless of additional states); if a state (or set of states) is preceded by a '-', those nodes are considered in which the specified states are not present. If '=' instead of the first slash is used, it only counts the changes, without reporting branches where changes in state sets occur. CONC N fit is calculated as k/(k+ES). Conc N sets k to N. Higher values of k weight less strongly against characters with homoplasy. Default concavity is 3. CMP compare tree to a reference tree, reporting step and fit difference for each character fitting both trees differently. A tree is made the reference by making it current and entering ref. The reference tree is lost only if the additivity for some characters is changed (i.e., the tree has to be defined as reference again), or, obviously, redefined. Using '*' as argument, compares every tree in memory; with no argument, the current tree. CNAMES name character/states. The format is roughly as for Clados or Dada: for each character to name, use {N name_for_char name_for_state_0 name_for_state_1 name_for_2 etc.; Blanks or carriage returns do not count; a semicolon must finish the string of names for a single character. If a '+' instead of a number is used, it names the next character (if no character had been named before, it starts from 0). If '=' immediately followed by the name of an already named character is provided instead of a number or '+', the character is renamed. For a single character, the sum of the character plus the state names cannot exceed (roughly) 160 characters (i.e., two lines). If you want to have blanks for a name, use the underscore. Pee-Wee does not have (like Clados/Dada) 'default' names for characters, nor does it read scopes for character numbers. So, using cn {0.20 " absent present would give the name '.20' to character 0, give the name ' " ' to state 0, 'absent' to state 1, and 'present' to state 2. Obviously, not what you wanted. If you do not have enough memory space to store the names for all the characters, issue a hold command before reading the matrix, to make memory space for fewer trees. If '$' followed by a string is used as argument, it reports the characters for which the name matches the string provided (using cname$; will give the complete list of all the names, since any name can be truncated completely!). In providing a string for cname remember that the underscore should be used to mean blanks; a semicolon can be used to separate character/state names. The first blank indicates finalization of the string. The symbol '?' can be used as wildcard for any letter. The additivity, activity and weight settings for each character can be displayed, if using report (see below). If a number N follows cname, the character/states names for character N are displayed. If '*' is used as argument for cname, it saves the names (to the current output file). DEL N delete tree N from memory. For any i>N, tree i becomes tree i-1. DISCARD by default (or using '-' as argument for discard), previous trees are not discarded when commands mult, bound, search or empezar are issued. For mult and bound, the pooled set of the new plus the old trees is checked after the search, retaining only the trees of best fit. For search and empezar, the new trees found are added to the internal tree file. This allows to make new runs keeping previous results without saving the trees to a file. Using '=' as argument preexisting trees are automatically discarded before starting the search. DREAD Short for 'dna-read.' Use this command to read the most dreadful kind of data. The string dread should be followed by the string gap (with either a question mark (?) if gaps are to be read as missing entries - as some propose- or a semicolon (;) if gaps are to be read as a fifth state), the string match followed by the character which indicates matching with the first taxon (taxon 0), an optional title (enclosed in single quotes), number of characters, number of taxa, and data. Use A, G, C, T or U (read as T) for single-state entries; - is the only symbol for gaps, ? the only symbol for missing entries. To indicate polymorphisms use: R=AG; Y=CT; M=AC; K=GT; S=CG; W=AT; H=ACT; B=CGT; V=ACG; D=AGT; N=ACGT. If the data have been read as dna-data, the character-states will also be reported as ACGT, and they can be referred to as ACGT with change/. DUPLICATE Sets whether the trees, in each replication of mult and bound, are compared to previously found trees. With duplicate= they are not compared, so that effort can be actually duplicated by swapping twice or more on (trees that collapse to produce) the same tree; with duplicate- additional trees are compared during each replication, and only new trees are swapped; with duplicate* the trees are compared, even when a tree of better fit is found by swapping. Default is duplicate*. EXCOMP For exact searches (using mswap+) under poly-, a good deal of time may be spent comparing whether the trees found are identical to those previously in memory. Since the rearrangements are produced in an orderly manner, no dichotomous tree is actually found twice. If the trees previously found are discarded, all the trees found by mswap+ under poly- will be different. With excomp- previously found trees are discarded and there is no need to compare new trees; when there are many equally parsimonious trees, searches proceed faster. Note that this may lead to loosing some or all of the preexisting trees if searches are aborted. With excomp= trees are not discarded, and although searches proceed more slowly, previous results are never lost. The default is excomp=. FARRIS You will feel much better if you regularly execute this command before zzz FIND Use branch-swapping (default: subtree pruning regrafting; '*': tree bisection reconnection) to find suboptimal trees; when the tree buffer is full, stop without swapping remaining trees. FIT calculate total fit (with '*' as argument, for every tree in memory; with no argument, for current tree), and report the rescaled fit (varies between 0 --min. fit-- and 1 --perfect fit. The formula used is analogous to that for the retention index, 1 - (max.fit - fit)/(max.fit - min.fit), expressed as percentage. The best and worst total fits are calculated for the data only (i.e., the best/worst fits taking into account the steps within characters, so that a rescaled fit of 100 is possible even when some characters have internal steps). FORCE +N1 N2 N3; store clades N1 N2 N3 of current tree in list of constraints. Scopes can be used, as for the ccode (the scope limits are the internal nodes, i.e., from T to 2T-3 for T taxa). If '-' is used after '+' and some numbers, turns subsequently specified nodes off; a series of '+' and '-' can be used in any order, except that the first character that follows force has to be '+' (all groups are taken as non-constrained when starting to parse the force statement). Example: force+.-50.30+47; constrains all the groups in the tree except 30 to 46 and 48 to 50. This can be used to check for monophyly of groups among several trees and for constrained searches (implemented only for the subtree-pruning regrafting swapper). Constraining all the nodes except the nodes involved in an unsupported polytomy N, issuing a max/; command, and entering apo/N; (see above) will produce a list of the character change that would unambiguously support the clade N under any of its parsimonious resolutions. Force followed by a tree in parenthetical notation stores the tree in the list of constraints; use only trees produced by the program itself, or problems can occur. Force with no argument produces a list of the constraints defined, in a form readable by the program (i.e., it can be used to save lists of constraints to files), and with '=' it saves the tree after the force statement. Therefore, entering out=const.1 force= out/; will store both the constraints and a tree that fulfills them in a file 'const.1.' GET N make tree N in memory current. Previous current tree is lost. HELP With no argument, displays list of commands (in capitals, the minimum recognizable truncation of the command, with possible arguments). If a command (not truncated) is provided as argument for help (and the file 'piwe.doc' is in current directory) the documentation for the command is shown, one screen at a time (pressing 'x' goes back to the command prompt). Using '*' as argument, the generalities are shown; using'=' the list of the commands, by topic; using '/' a summary of all the commands with all their options. NOTE! Because 'help' directly parses the file 'piwe.doc', do not edit, change, rename, or alter in any way the file 'piwe.doc', as doing so may preclude it from being correctly parsed for help. HOLD N keep in memory up to N trees. The default maximum number of trees to keep in memory allowed by the program is 1000; if not enough memory is available to Pee-Wee, fewer trees can be stored; once a data set has been read, the number of max. trees is set by default to 50 (but can be changed). If '+N' is used as argument, makes space for N additional trees (useful for 'jumps'). If '/N' is used as argument, it determines the maximum number of initial trees, i.e., the maximum number of trees to keep in each replication of mult or bound. ICC report fit for each character (with '*' as argument, for every tree in memory; with no argument, for current tree). INTERS save to 'tsave' file strict consensus tree (calculated as for nelsen, see below). KEEP N keep only the first N trees in memory, discard the rest KSV see under sv. LENGTH calculate tree length (with '*' as argument, for every tree in memory; with no argument, for current tree). MINIMUM report minimum and maximum possible steps for each character MENU enter the menu interfase (from where pressing o,n exits). MESSAGE copy from input to output until a semicolon is found (i.e., like the quote command of Hennig86). MONO report whether each of the groups in the list of constraints is or is not monophyletic (with '*' as argument, for every tree in memory; with no argument, for current tree). MV go to branch-moving node. Some commands can be executed without exiting branch-moving mode. Some commands (length, fit, cmp), if executed on one tree, are repeated automatically for each new tree, unless one exits and reenters branch-moving mode. Note that the precedence of some commands may be different under branch-moving mode (e.g., under branch-moving mode cmp precedes change). NAKED with '=' as argument, does not specifiy node numbers when printing the tree diagram (so that the tree is actually narrower). With '-' the node numbers are specified. Default is naked-. NCODE It's like ccode (see above) but when using character names these can't be truncated (ncode is meant to be used for the nread command). If no argument follows ncode, current settings are saved to output file (by default, screen), using character names. NELSEN calculate and display strict consensus tree of current and every memory tree. Note that, unlike Hennig86, the consensus is displayed automatically when entering nelsen, and the current tree is not lost. Therefore, entering nelsen;tplot; would first display the consensus and subsequently display only the current tree. The consensus is calculated anew only when necessary; the consensus that had been calculated will no longer be valid if any of the following commands is executed: max, jump, get, whennig, empezar, search, ranswap, mv, or tread (those commands either change current tree, or add or eliminate trees from memory). Also, if the trees are being treated as polytomous, deactivating a character or changing its additivity makes a previously calculated consensus no longer valid. If '-' followed by taxon or node number(s) is used as argument, the taxa specified are not included in the consensus. After using '-', if using '+' it reincludes taxa excluded. If a number refers to an internal node, all the terminals belonging to that clade are excluded/included. Scopes can be used; if a non-digit follows the '.' the upper limit for the scope is taken as the largest terminal (taking it to be the largest node would always exclude/include all taxa, since the root is the largest node and all terminals belong to it). Examples: nelsen-.+20.35-27 28; consensus for taxa 20-26 and 29-35. nelsen-1 2 3; consensus excluding 1-3. nelsen-.+1.3; consensus including only 1-3. The consensus with some taxa excluded is always calculated anew. It is also possible to calculate which resolutions of a given polytomy in the consensus correspond (in the trees stored in memory and the current tree) to distinct relationships of the clades involved in the polytomy. For this, the consensus must have been calculated. Using '*' as argument, followed by a number N, the distinct resolutions of node N are shown. Note that N must be an internal node and must occur in the consensus. Using '=' as argument, the program shows each resolution for each polytomy in the consensus. In both cases a list of the trees having each resolution is produced, only if the 'report' option is in effect (as this list may be long and therefore, annoying, it may be turned off with report-). See also under 'vnelsen.' NIGHBOR Define a "neighborhood" for the multiple swapper, mswap. This limits the number of permissible swappings and clipping combinations. If a number N follows the command, for subsequent executions of the mswap command only those swappings moving one clade to those locations N or less nodes away are allowed (note that sister taxa are considered as being 1 node away). For tree bisection-reconnection, only those rerootings of a clipped clade which do not root more than N nodes aways are allowed. If the argument '*' precedes the number N, a "clipping neighborhood" of N is defined: only clades placed no more than N nodes away can be clipped together. This should be used with caution in Pee-Wee, but less so in Nona: changes in the tree which are many nodes away are unlikely to affect greatly another part of the tree for analyses under prior weights. Note that the "clipping neighborhood" has no effect over TBR-1 or SPR-1. NODE N display only node N of current tree (using *N, the equivalent node for each memory tree, if clade N is monophyletic). If a non-number follows the command, the whole tree is displayed. NREAD Reads a character-state matrix, but using the names for the characters/states instead of 0-9. It has the advantage that matrices for different sets of taxa where the shared characters have the same names can be merged almost automatically. It can also make working with the data considerably easier. The format is as follows: 1) nread 2) an optional title, enclosed in single quotes 3) the number of characters 4) the number of taxa 5) the names for the characters/states, in the same format as for cname (but not preceded by the string 'cname'). All the character names have to be different. ALL characters must be named. The length of a single name cannot exceed 50 characters; the sum of lengths of characters plus all state names plus the number of named states for a single character cannot exceed 160. 6) a semicolon; 7) the names for all the taxa. All the taxon names have to be different, and different from all character names. 8) optionally, one (or more) semicolons; 9) the data. Names for taxa/characters/states cannot, by default, be truncated, and have to be separated by one or more spaces. Missing entries can be explicitly specified with '---' or '----'. If multiple states for a character are to be assigned, should be enclosed in square brackets. Comments can be included within the data; a comment opens with '/*' and closes with '*/' (this is useful to include additional information on the data, like sources, or specimens examined, or what have you); only restriction is that you cannot place two comments separated only by blanks (i.e. /* this */ /* comment */ should be changed to /* this comment */). For the data two formats can be used: a) the default: The first name has to be a taxon name; subsequent character states are assigned to that taxon, until a new taxon name is read. Taxon names can be in any order, and some character states can be assigned at different parts. The string alltax can be used in place of a taxon name, and untill a new taxon name is read it assigns subsequent characters/states to all taxa. Separating several taxon names by a '+' sign all subsequent characters (untill a new taxon name is read) are assigned to all those taxa. If the string provided ends with a double period, all the taxa for which the name matches the string before the double period are set for subsequently specified characters (e.g., 'Ca..' is equivalent to 'Canis_lupus+Canis_familiaris' --as long as no other taxon names start with 'ca', in which case they would also be set); if the string does not match any taxon name, the characters with names matching string are set to subsequently specified state(s). If a taxon name (or group of taxon names separated by '+') is followed by the string match and another taxon name, the states for all characters for that taxon (or group of taxa) are set equal to to the second taxon (cannot match one taxon with itself). Make sure, before matching a taxon, that all the states for the taxon to be matched have been defined as you want them (if not yet defined explicitly, they'll be missing entries; see below). The name for the character for which a state is to be assigned has to precede the state. The characters within a given taxon can be assigned in any order; characters not specified are left as missing (but, remember, you can use '---'); if the states for a character are specified more than once, the character for the coresponding taxon is set to the last value specified; once a character has been specified, it must be followed by a state name (i.e., it can't be followed by a taxon or character name). b) the 'table' format (by passing 't' as argument for nread): the first name has to be a character name, followed by the states for the first to the last taxon (in the same order in which they were specified at point 7 above). Then, write the name for another character, followed by all the states. Obviously, for N taxa, the name for each character has to be followed by N names of states. The characters can be specified in any order. The data end with a semicolon. Example: xread 'Conventional form' 6 5 PROTOZOA 00-000 FISH 110000 TOAD 111100 BIRD 112111 MAMMAL 111111 ; cnames {0 vertebrae absent present; {1 paired_limbs absent present; {2 limbs fins legs wings; {3 lungs absent present; {4 warm-blooded no yes; {5 amniotic_eggs no yes; proc/; Is entirely equivalent to: nread 'Matrix with character names' 6 5 {+ vertebrae absent present; {+ paired_limbs absent present; {+ limbs fins legs wings; {+ lungs absent present; {+ warm-blooded no yes; {+ amniotic_eggs no yes; ; PROTOZOA FISH TOAD BIRD MAMMAL ; PROTOZOA vertebrae absent paired_limbs absent lungs absent warm-blooded no amniotic_eggs no FISH vertebrae present paired_limbs present limbs fins lungs absent warm-blooded no amniotic_eggs no TOAD vertebrae present paired_limbs present limbs legs lungs present warm-blooded no amniotic_eggs no BIRD vertebrae present paired_limbs present limbs wings lungs present warm-blooded yes amniotic_eggs yes MAMMAL vertebrae present paired_limbs present limbs legs lungs present warm-blooded yes /* NOTE: for this character, some exceptions in the human race */ amniotic_eggs yes ; proc/; Note that there is no entry for character "limbs" for protozoa, since it is a missing entry; the same effect would be achieved with "PROTOZOA limbs ---" placed anyhwere in the description. Also note that, in the second format, if changing the order of some character(s) is desired for any reason, it can be achieved by simply moving the corresponding character name definition to the desired place. That would hardly be necessary, however, since the characters can be referred to by name, not number, so that their 'placement' in the matrix (stored by the program) is of no actual concern for the user. Another possible description of the same data could be achieved as follows: nread 'Example of use of alltax, match and +' 6 5 {+ vertebrae absent present; {+ paired_limbs absent present; {+ limbs fins legs wings; {+ lungs absent present; {+ warm-blooded no yes; {+ amniotic_eggs no yes; ; PROTOZOA FISH TOAD BIRD MAMMAL ; ALLTAX vertebrae present paired_limbs present amniotic_eggs no warm-blooded no limbs legs lungs present PROTOZOA vertebrae absent paired_limbs absent MAMMAL warm-blooded yes amniotic_eggs yes BIRD match MAMMAL limbs wings /* only difference ! */ FISH + PROTOZOA lungs absent FISH limbs fins PROTOZA limbs ---- ; proc/; Which is somehwat more 'compact' (although it detracts from the explicitness of the previous example). Note that there is no explicit entry for taxon TOAD; all of the states for that taxon are defined with ALLTAX. Using the keywords alltax, match, the '..' to indicate truncation, and the '+' symbol to refer to groups of taxa, a set of data can be described in many different ways. Note that, when truncating, the program always attempts to match any string first to a taxon name; if unsuccessful, tries the characters. So, if some characters are male characters, and they are named starting with 'male_...,' and the male for a species XXX is unkown, you can set all male states for that species entering nread=XXX ma.. ---; as long as there are no taxon names which start with 'ma,' since in that case 'ma..' would be taken to match those taxa; in that case, you will have to type a little more and enter nread=XXX male.. --; The 'table' format may be preferrable in some cases, as it is both compact and explicit. Those data are described as: nread t ' Example of table format' 6 5 {+ vertebrae absent present; {+ paired_limbs absent present; {+ limbs fins legs wings; {+ lungs absent present; {+ warm-blooded no yes; {+ amniotic_eggs no yes; ; PROTOZOA FISH TOAD BIRD MAMMAL ; vertebrae absent present present present present paired_limbs absent present present present present limbs --- fins legs wings legs lungs absent absent present present present warm-blooded no no no yes yes amniotic_eggs no no no yes yes ; proc/; Once the data have been entered with the nread command, they are treated just like data read with the xread and cname commands. They can be modified (using xread= or nread=) or saved in the form of a conventional character-state matrix using xread* (using xread*cnames*; saves both matrix and names). Using '*' as argument for nread or nread t, the matrix is saved in a form readable by the nread command (like xread, if using '-' instead of '*' only active characters are saved); if '**' is used as argument (or '-*', to exclude inactive characters), the matrix is saved with the corresponding ncode statement. This can be used to convert conventional matrices to the nread format. Using '=' as argument for nread, any number of entries in the matrix can be changed, using the default format. Note that using this, one does not need to store all the data in one file. Changes to a data set can be made, if desired, in a separate file (containing only the changes), to be parsed after the main file. Using '+' as argument for nread, the current matrix is written to output file as an nread= statement. OUTPUT XXX send output of commands fit, icc, cmp, swap, opt, and some more, to file XXX. It is like the log command of Hennig86; out- sends again output to screen (after which entering only out; will redirect output to the file that had been defined; do not enter 'out*'). Using '+' as argument (preceding the file name), the file is opened in 'append' mode (i.e., new output is added to the file, preserving previous contents). Note that when saving text with some word-processors a character indicating EOF is placed at the end of the file, a character which will not be overwritten by Pee-Wee/Nona, so that text added will not be accessible to the word processor (an exception to this is DOS's editor, Edit). If using '=' as argument, the file is oppened in overwrite mode, without asking questions (even if file existed). If an output file is open but temporarily deactivated (with out-), the output for commands preceded by a comma (,) is sent to the output file (i.e., ,tplot; apo; ,change10; sends output of commands tplot and change to the file, but not the output for command apo). Out/ closes the ouptut file. PACK It 'packs' the matrix, merging characters with identical distribution in one character of higher weight. For most morphological data, which include few uninformative characters, this is seldom necessary, but for molecular characters (where as little as a fourth of the sites may be informative) the packed matrices may run much faster. Additionally, if the data are saved (e.g., using out=packed.dat xr* cc; out/ will save the packed data to a file called 'packed.dat') they will require less memory space for storage, so that you will be able to save more trees. Note that the order of the characters in the matrix is changed (the program changes the ccode settings accordingly); changing the weights or additivities of the characters after packing the matrix may lead to unwanted results. Similarly, if the characters had been named before packing, the names are discarded, since the program does not keep track of which final characters corrrespond to each original character. The process is irreversible; the only way to go back to the original matrix is exitting the program and reading the data again. PAUSE With no argument, pauses the program, untill a key is pressed. Using '=' as argument, it enables (for those commands that report results or display tree diagrams for all trees in memory) a pause between trees; pressing 'x' suspends further excution of the corresponding command, any other key continues with following tree. With '-' as argument, it does not pause between trees. With '*' as argument, if taking commands from a file, it pauses after taking each command; pressing '.' temporarily suspends parsing of file (i.e., is like proc-, so that entering proc* at screen will go back to file); pressing 'x' turns pause off (all the rest of the file is parsed without pauses); pressing any other key continues parsing file. Note that, if taking input from screen, subsequent commands in the input buffer will be ignored after a key is pressed. Default is pause-. POLY with '=' as argument, treat trees as polytomous; with '-' as argument, treat trees as dichotomous. With no argument, simply reports how the trees are being treated by the program. Default is poly=. PUT store current tree in memory QCOLLAPSE or 'quick collapse'. When doing searches of trees different as polytomous, some shortcuts can be used to quickly find whether the rearranged tree would collapse to the same polytomy as the tree being swapped. For the (default) ambiguous-two degrees of approximation can be used for this (for searches under ambiguous= the '=' and '+' options of qcollapse are identical). Qcollapse+ is faster but more prone to error (if there are lots of ambiguous optimizations, the program might discard some trees that actually collapse to different polytomies). Qcollapse= can be a little slower. Default is qcollapse=. To turn the shortcut completely off, use qcollapse- (if there are lots of unsupported branches, it will be much slower!). QUIT quits; to avoid exiting each time you parse a Hennig86 file with a 'quote' command truncated to 'qu' or 'q', quit cannot be truncated. An alternative command to quit (which can be truncated) is zzz. RANSWAP N perform N (up to 30,000, in the 286 version) random swappings on current tree. This can be used to have different starting points for max. If the trees from previous searches are still being held in memory, issuing a max command right after ranswap N would use as starting point the trees from the previous search (which will be of better fit), so that a keep 0 command has to be issued to eliminate those trees from memory before starting the search. If the command and the number are separated by an '=' sign, the program creates, de novo, N random trees (it adds 3 taxa, and then adds subsequent taxa with equal probability at each preexisting branch, N times), and adds them to memory. NOTE: this command always uses as seed for the random number generator the time, so it produces a different result each time it is invoked. REF define current tree as 'reference tree,' storing in memory the steps for each character on the tree. Subsequent executions of the command cmp will compare the number of steps for each character on the (then) current tree to those for the tree defined as reference. REPORT report status of ongoing searches or potentially time-consuming operations. If '-' is used as argument, it does not report status. The reporting can slow down the program (it may be preferable to use breakable searches and, when you're running out of patience, simply press 'r'). Default is report-. This command also sets whether additional information is shown when displaying the character names (using cname) and changes (using change). RESAMPLE n Eliminates (at random) n percent of the active characters. Useful for jackknifing. RSEED N set the number to be used as seed for the random number generator. For the commands mult and bound the seed in each replication is calculated with a random number (and then returned to its original defined value, so that each time mult or bound are called, under the same initial random seed, they produce the same result). If the seed is set to 0, the time is used as seed for each replication (and so each replication is different and unrepeatable). If '+' is used as argument, it increases present seed by one. Default value is one. SORT Order memory trees from fittest to least fit. SWAP N report the difference in fit for every possible placement of clade N in the tree. Can use '/' as argument, as for max. SUBOPTIMAL N When doing searches, keep trees up to N/10 less fit longer than the best. The command 'best' also keeps trees up to N/10 less fit than the best trees held in memory. Note that this is NOT equivalent to the command 'jump' (which jumps islands, one at a time). The main purpose of this command is to allow estimation of bremer supports (=decay indices), in conjunction with the 'bsupport' command. When it is swapping on suboptimal trees, and it finds a tree shorter than the best, it discards all the trees it had, even if some of them were less than N steps longer than the newly found tree. Then, the results produced by swapping using only the shortest trees as starting point, and using suboptimal trees as starting point, will be the same. Keeping those trees that would be less than N steps longer than shorter trees found during searches would make searches for suboptimal trees more exhaustive, but also much slower. As implemented here, more exhaustive searches for a given degree of suboptimality can be done increasing the margin of extra length acceptable. SV save trees (uncollapsed) to a file, in parenthetical notation (with '*' as argument, saves every tree in memory; with no argument, saves current tree). Trees are added to the file, until it is deliberately closed with sv/. If no file had been opened, the first time a sv command is issued, Pee-Wee requests a filename (it can be given as argument). Arguments: 'w' saves the tree followed by the weights the tree implies (in a ccode statement); '/' closes the file. To open files only, '+' or '=' can be used as first argument (to append or overwrite, respectively). Note that if '=' or '+' are used to open a sv file, no trees are actually saved when the file is opened (i.e., the file is just opened; to open and save trees you have to enter s+outfile s*s/, which opens 'outfile' in append mode, saves all memory trees, and closes the file). If 'k' is used as prefix (i.e., ksv), saves the trees as collapsed (to repeat once more, collapsed trees may be longer than the resolution, so that re-reading the tree may produce a less fit tree than the one saved). If '[' or ']' are used as argument, it sets whether trees are saved using taxon names or numbers, respectively (note that sv[; or sv]; do not save any tree; they only change the setting). STEPS report number of steps and extra steps for each character (with '*' as argument, for every tree in memory; with no argument, for current tree). UCONST Turns union construct shortcut of Goloboff (Cladistics 12:212-213) on or off. The default ('uconst+') is using it for TBR; 'ucons-' turns the shortcut off, and 'ucons*' uses it for both SPR and TBR ('ucons*' is not available in NONA, where it seems not to save time). The '+' or '*' options save more time for larger, more congruent data sets; for very bad data, it may even make the program slower. Note that the rearrangements tried cannot be counted using this shortcut; only under 'uconst-' are the number of rearrangs. reported. UNIQUE keep only those trees which are topologically different (collapsed or not, according to settings). If '/' is used as argument, only those that are different and fulfill constraints. VIEW XXX view file 'xxx.' VPLOT View trees. Use arrow keys to move tree, to exit viewer ( and move tree 15 characters right or left). The viewer displays first the memory trees (if any) and then current tree; and move from one tree to another. Vplot takes no arguments. Vplot always shows trees on screen, even if an output file is open; to write tree diagrams to a file, tplot must be used. VNELSEN View consensus (as in vplot). Can exclude taxa as in the nelsen command; '*' and '=' options not implemented. WATCH time execution of commands. Watch- deactivates the watch. Default is watch-. Entering watch= reports ellapsed time, since the program was called or since a watch* command (which sets the timer to zero) had been issued (this is useful for timing total duration of batch runs). ZZZ this is the last command you will issue in Pee-Wee; it sends him to sleep. N O N A M E - Version 1.50 Copyright (c) Pablo A. Goloboff 1993, 1994, 1996 Noname is a tree-searching program. It searches for trees which minimize steps according to prior weights set by the user. All the commands are as in Pee-Wee (ver. 2.50), except that all those commands that refer to 'fit' in Pee-Wee refer to 'steps' or 'length' here. For most commands, the user is referred to the documentation for Pee-Wee. The only commands that work differently in the two programs are: ICC - does not exist in Nona. FIT - in Nona, it reports the number of steps in informative (and polymorphic) characters, the consistency index, the consistency index for informative characters only, and the retention index. CCODE - the maximum permissible weight is 100. No internal steps (=) can be set. And the only command in Nona that does not exist in Pee-Wee is: ESTIMATE it estimates the number of swappings necessary for a complete round of branch-swapping in current tree (if using '*' as argument, for tree-bisection reconnection, with no argument, for subtree-pruning regrafting). If '=' is used as argument, it makes a rough estimate of the time needed to swap a tree. The estimate is very rough, but better than nothing. A Q U I C K G U I D E T O P E E - W E E A N D N O N A = C O M M A N D S, B Y T O P I C Getting help: help Reading and listing data, trees, or character names: cnames - dread - nread - tread - xread Controlling input-output, sending messages, viewing files: do - message - output - procedure - sv - view Exitting: quit - zzz Tree-finding commands: altswap - bound - empezar - max - find - jump - mswap - mult - mv - ranswap - search - sswap - tswap - whennig Best searching bet for most data sets: 'hold 100; hold/20; mult*15;' followed (if recommended after 'mult') by 'max*'. Increase those numbers for greater exhaustiveness (which will naturally take longer). Exact solutions can be obtained with 'mswap+;' (only for 18 taxa or less; it needs a tree as starting point, the better the tree, the shorter the search; very time consuming for 15 taxa or more) Handling, drawing, comparing and saving trees: best - cmp - del - get - hold - inters - keep - ksv - mv - naked - nelsen - node - put - sv - swap - tplot - txascii - unique Diagnosing and evaluating trees or characters: apo - best - bsupport - change - cmp - fit - icc - length - mono - ref - resample - steps - swap - unique Settings-Options: ambiguous - break - ccode - cnames - conc - discard - duplicate - excomp - force - hold - minimum - naked - ncode - nighbor - pause - poly - qcollapse - report - rseed - suboptimal - uconst - txascii - watch Consensus trees: inters - nelsen Constraints: best - force - mono - unique Timings: estimate - mswap - watch - / C O M M A N D S, A L P H A B E T I C A L (minimum truncation in capitals) ALtswap : do double-branch swapping, alternately clipping descendants and grandchildren of each internal node. ; using subtree pruning-regrafting *; using tree bisection-reconection -J; complete swapping on J trees, then stop (default J=1) @N; start clipping descendants/grandchildren of node N Apo : diagnose clades (according to present ccode and setting of ambiguous). ; list synapomorphies for current tree N same, for clade N only * list synapomorphies for each tree in memory =; for each clade of current tree, for each tree in memory =N same, for clade N only /; synapomorphies of each clade common to current and memory trees /N same, for clade N only -; same as /; but only lists nodes appearing in strict consensus /tN same as /; but in table form (N=column width; default=20; 0=tabs) -tN same as /N; but only nodes in consensus +; show tree diagram with characters supporting clades [N; show consensus and characters supporting clades in all memory trees, for node N (default N = root) AMbiguous : determine how strictly trees are collapsed. Default: -. = collapse only if ancestor and descendant have identical state sets - collapse whenever ancestor and descendant share states ; report present setting Best : clean internal (memory) tree file. ; retain trees distinct under present settings and of best fit / same, discarding trees which do not respect constraints (if defined) - followed by a type of character change (with the same format as in change/) retains only those trees which minimize the number of specified change. BReak : control breaks during searches. Default: =. = enable breaks ('.': interrupt; 'r': report) - disable ; report present setting BOund N F : do N tree searches with different addition sequences for starting tree, stopping each if a tree of fit F is found (if no F is provided, the best available is used). * use tree bisection-reconection (default is subtree pruning regrafting) CCode : change character settings. Characters entered as numbers (which have precedence) or names (optionally preceded by '$'). If using names, all characters whose name matches string are set to preceding specifiers. Obviously, scopes are allowed only for numbers. Defaults: all characters active, prior weight=1, no internal steps, and additive (except polymorphic characters, by default nonadditive). + make following characters additive - make them nonadditive [ make them active ] make them inactive /N give them prior weight N (if no N follows /, weight=1) =N add N steps (if no N follows =, steps are set according to polymorphisms in specified character) * discard all previous specifiers Change : report character change. ; list change for all characters, for current tree N only for character N (can use name, optionally preceded by '$') * list change for all characters, for each memory tree *N only for character N (can use name, optionally preceded by '$') / report changes for specific transformations. Use: change / character (default=all)/ state1 state2. Can enclose several states for either ancestor or descendant node in square brackets; preceding either of those by '+' it reports change where ancestor or descendant node has those states or more; by '-', where node has any state except the specified states (missing is specified only as '?'). */ same, for each memory tree = instead of '/' simply counts the changes instead of reporting them. For example, c*=//-[AT]-[GC] (for dna data) would count the number of transversions (from nodes with either G or C to nodes with either A or T) in all the memory trees. [N; show tree diagram with most parsimonious state assignments of character N (can use name instead of number). [; same, for all characters. ]; as [, but indicating only nodes where changes occur CNames : list and define character/state names. {N define names for character N; use: {N charname state0 state1 state2; '+' instead of N: name next character; =xxx intead of N: rename character previously named 'xxx' N list names for character N (can use name, optionally preceded by '$') * save current names to output file - same, but eliminating inactive characters CMp : do character-based tree comparisons (must define reference with ref). ; compare reference tree to current tree * compare reference tree to each memory tree COnc (Pee-Wee only) : change constant of concavity, k, in fit formula k/(k+extra steps). Higher values of k weight less strongly against homoplastic characters. Default: k=3. N set k to N (1<=N<=6) ; report present setting DAta- : discard current matrix without queries DEl N : delete tree N from memory. For any y>N, tree y becomes y-1. DIscard : change whether previous trees are discarded before commands search, empezar, mult or bound are executed. Default: -. - don't discard trees = discard them Do : control input. Parsing files with do unrecognized commands cause error messages (may provide better error detection than procedure). Do xxx parses file 'xxx' for commands. - temporarily deactivate file * reactivate deactivated file / close input file DRead : short for 'DNA-read.' Dread should be followed by the string 'gap' followed by '?' if one wants to treat gaps as missing, by a ';' if not (they are treated as a fifth character); then the string 'match' followed by the symbol which will represent the state as in the first taxon. Then, an optional title enclosed in single quotes, and the data. Valid characters are: AGCTU, self-explanatory; - is always read as gap; ? is used as missing; R=AG; Y=CT; M=AC; K=GT; S=CG; W=AT; H=ACT; B=CGT; V=ACG; D=AGT; N=ACGT. * save current data in dread format - same, excluding inactive characters DUplicate : change whether trees found by commands mult or bound are compared to preexisting trees. The best trade-off speed/effectiveness is *. Default is *. - do not check new trees = retain and swap more trees of equal fit only if different * if a replication finds a tree of better fit than previous trees in that replication and that tree had been found before, replication is abandoned. Empezar : search for one tree, creating a wagner tree and subsequently swapping it (with subtree pruning-regrafting, without saving additional trees). ; create wagner tree with addition sequence as in matrix = randomize addition sequence EStimate (Nona only) : ; estimate number of rearrangements need for complete round of subtree pruning-regrafting for current tree * same, for tree bisection-reconnection = estimate the time needed for swaping one tree EXcomp : set whether trees found by exact solutions under poly- are compared to preexisting trees. - trees are not compared. Searches may be faster, results from previous runs may be lost if search is aborted. = trees are compared. Searches are slower, previous results never lost. Fit : calculate total fit (for Pee-Wee, sums of fits for each informative character; for Nona, length of informative characters) ; for current tree * for memory tree FINd : search for trees using branch-swapping, but when memory is full, stop. *; using tree bisection reconnection (default: subtree pruning regrafting) FOrce : define and list constraints. Node numbers refer to nodes in current tree. Force followed by a tree in parenthetical notation stores the tree as constraint list (try to use trees produced by the program, as unbalanced parentheses can cause problems). +N force N to remain monophyletic (scopes allowed). -N if N had been included in constraint list, exclude it. ; output list of present constraints in parenthetical notation. This can be used to easily save lists of constraints to files. =; same, but adding a tread statement (so that the tree is also read as tree and added to file). Get N : make tree N in memory current. HElp : on-line help. ; list of all commands (with possible arguments and truncations). xxx documentation for command xxx * general documentation = list of commands, by topic / summary of commands and options /xxx summary and options for command 'xxx' Hold : change maximum numbers of trees to be stored in memory. N retain up to N trees in memory (only mult or bound can exceed those limits) * retain all the trees for which space had been allocated (or, before reading the data, try to allocate space for maximum number of trees: 100,000 in 32 bit versions, and 30,000 in 16 bit versions). +N set max. trees to the number of trees in memory plus N. /N retain, during replications of mult/bound, up to N trees. Icc (Pee-Wee only) : report fit for each character. ; for current tree * for each memory tree INters : save consensus of current and all memory trees in parenthetical notation (to 'tsave' file). ; including all taxa -N excluding N (can use scopes) +N including N (can use scopes) Jump N : do branch-swapping, retaining during swapping trees up to N/10 units fit less fit than the best (in Pee-Wee) or N steps longer (in Nona). Suboptimal trees are discarded after execution. * use tree bisection-reconection (default: subtree pruning- regrafting) / search for trees which respect constraints, if defined (can't use in conjunction with '*') Keep N : if more than N memory trees exist, keep the first N trees, discard the rest. ; reports number of memory trees KSave : saves trees to 'tsave' file, as collapsed. See sv for arguments. Length : calculate length (weighted number of steps) ; for current tree * for each memory tree LOop : do a loop. Syntax is: 'loop X+i Y string.' X: starting point. Y: ending condition. +i: increment/decrement (if ommited, unity). In the string, '#' is replaced by the corresponding value of iteration. MAx : do branch-swapping (retains only optimal trees). * use tree bisection-reconection (default: subtree pruning- regrafting) -N start swapping on tree N -; if a max search had been aborted (and resulting trees were not modified), resumes search where it had been interrupted. / search for trees which respect constraints, if defined (can't use in conjunction with '*'). MENU : enter menu interface. MEssage : copies from input to output until a semicolon is found. MInimum : reports minimum/maximum number of steps for each character. MOno : checks whether each of the groups in constraint list is monophyletic. ; for current tree * for each memory tree MSwap : do branch-swapping clipping tree at multiple points. /... stop if better or equal tree found N; using subtree pruning-regrafting (SPR-N; cut at N points). *N; using tree bisection-reconnection (TBR-N; cut at N points). =N count number of clippings to do and estimate time N@J start swapping on tree 0, clipping node J N-J complete swapping on J trees and stop (default J=1) ]; use exact swapping sequence for multiple swappers (mswap, sswap, tswap, and altswap). [; use approximate sequence to minimize redundant swappings +; clip tree of T taxa at T-3 points (produces exact solution; only for 18 taxa or less). MUlt N : do N tree searches with different addition sequences for starting tree. * tree bisection-reconection (default: subtree pruning-regrafting) Mv : go to branch-moving mode. S D move node number S to node number D ; exit branch-moving mode NAked : controls display of node numbers in tree diagrams = number nodes - don't NCode : same as ccode, but names of characters cannot be truncated and present settings displayed using character names. NElsen : calculate and display strict consensus of current and all memory trees. ; including all taxa -N excluding taxon/node N +N including taxon/node N *N show distinct resolutions of node N of consensus = show distinct resolutions of each polytomy NIghbor : sets neighborhood. N define swapping neighborhood *N define clipping neighborhood - no neighborhood in effect Node N : display node N of current tree. N; for current tree *N; for each memory tree (if group N is monophyletic) NRead : read data using character/state names. Use: nread 'optional title' nchar ntax character/state name definitions (semicolon) taxon name definitions (semicolon) data (semicolon). Default format is: taxon name, character names each followed by state name; another taxon name, etc. Can include comments, starting with '/*' and ending with '*/.' ' Strings alltax and match reserved, to assign subsequent characters/states to all taxa or to match a taxon to another. Several taxon names separated by '+' assigns subsequent characters/states to that group of taxa. A double period at the end of a string assigns all taxa matching string. t use table format, under which: enter character name, plus as many state names as taxa; another character name, etc. Alltax, match, and '+' not recognized as in default. * save current data in default nread format (with '**', including current character settings). t*N same, using table format, with columns N characters wide. Default width is 11 (** saves current settings). - same as *, but doesn't save inactive characters. = change entries in matrix, using default format. + save current data in nread= format (i.e., as changes only). Output : control output files. By default, output is sent to screen. Output for tree drawing, diagnosing and comparing can be sent to files. xxx open file xxx (query before overwritting) =xxx if file xxx exists, overwrite without queries. +xxx append new output at end of file xxx - temporarily deactivate output file (reactivated with output;) ; reactivate input file (if previously deactivated with out-) ,xxx if an output file is open but deactivated, execute command xxx sending output to file and automatically deactivate file after execution of the corresponding command / close output file PACk : eliminate inactive-uninformative characters, and merge characters with identical distribution. Data may run faster. PAuse : control pauses ; pause until a key is pressed = each time a command that deals with each memory tree is issued, pause before executing for next tree. * if parsing a file, pause after execution of each command; pressing '.' temporarily takes input from screen (i.e., as proc-); pressing 'x' turns pauses off (i.e., the rest of file is parsed w/out pauses); any other key goes to next command in file. - don't pause POly : treat trees as collapsed or dichotomous. = collapsed - dichotomous Procedure : same as do, ignoring unrecognized commands. PUt : store current tree in memory QCollapse : controls a shortcut for fast collapsing of trees during branch-swapping. Default is +. - shortcut off = shortcut on + fastest shortcut on (with ambiguous= equivalent to qcollapse=) QUIT : exit, go to DOS RAnswap N : do N random swappings on current tree REF : define current tree as reference (for cmp). Report : status of ongoing searches and time-consuming operations. Also: cname, reports settings; change, steps and extra steps, for each character; nelsen* and nelsen=, trees having each resolution. Default: -. ; report status - don't RESample N : eliminate (at random) N percent of active characters. RSeed N : set seed used for the pseudo-random number generator, used to randomize addition sequences, to N. If set to 0, the time is used as seed for first replication. + increase current seed by one SEarch : create wagner tree and do tree bisection-reconection branch- swapping. ; create wagner tree with addition sequence as in matrix = randomize addition sequence SSwap : do double-branch swapping, but clipping only sister nodes. ; using subtree pruning-regrafting *; using tree bisection-reconection -J; complete swapping on J trees, then stop (default J=1) @N; start clipping descendants of node N STeps : report steps and extra steps for each character ; for current tree * for each memory tree Sv : open 'tsave' file, save trees (NOTE: as dichotomous) to file. File can be opened with sv or ksv, and trees can be saved with sv or ksv. =xxx open file xxx. If xxx exists, overwrite without queries +xxx open file xxx, appending new trees at the end ; save current tree * save each memory tree / close 'tsave' file [ for subsequent executions of the sv command, use taxon names ] use taxon numbers SWap N : compare total fit of possible placements of clade N / same, respecting constraints (if defined) Tplot : write tree diagrams to output file ; for current tree output file * for each memory tree TRead : read trees in parenthetical notation TSwap : do triple-branch swapping, but clipping only descendants and sisters of each internal node. ; using subtree pruning-regrafting *; using tree bisection-reconection -J; complete swapping on J trees, then stop (default J=1) @N; start clipping descendants and sister of node N TXascii : how trees are drawn in files. Default: txasci; ; use extended Ascii characters - don't Unique : keep in memory only the trees distinct under current settings / same, but discards trees not respecting constraints (if defined) UConst : turn union-construct shortcut on/off - don't use + use for TBR only (Pee-Wee and NONA) * use for SPR and TBR (only Pee-Wee). VIew xxx : view file xxx. VNelsen : view consensus (use keys as in vplot). ; including all taxa -N excluding taxon/node N +N including taxon/node N Vplot : view trees. Arrow keys move tree (up,down,left,right,end,home,pgup,pgdn) F1,F2 move tree 15 characters to left, right. exit viewer next memory tree (if no more memory trees, current) previous tree (if viewing tree 0, current) WAtch : timing ; activate stopwatch - deactivate it. * set timer to zero = reports time since program was called or watch* was issued. Whennig : wagner trees. ; create a wagner tree N; create N wagner trees, with N randomized addition sequences, keeping only those of best fit N* same, but abandoning a replication if inferior to previous ones XRead : reads matrix. Use: xread 'optional title' nchar ntax matrix; = change a single cell in matrix * write matrix to output file - same, without saving inactive characters ** save with ccode -* same, without inactive characters Zzz : exit, go to DOS. A brief note of changes: ---------------------------------------------------------------------------- Pee-Wee NONA New Features ---------------------------------------------------------------------------- 2.6.1 1.6.1 cured two Pee-Wee bugs having to do with additive characters (one, introduced in the 'uconst' swappers, could cause crashes during swapping; the other, an old but undiscovered one, could overestimate the fit for some rearrangements with the multiple swappers --this could happen even when the multiple swappers were used for single-cut swapping, as in 'mswap*1'. These bugs showed up very rarely. The one in uconst, could not cause error in results, just crashes; the one in the multiple swapper could cause errors, but these were easily detected by re-optimizing the trees). Changed some problems with reporting results of runs (only aesthetical). ---------------------------------------------------------------------------- 2.6 2.6 menus (documentation in menu.doc); issuing 'hold' commands after reading the data now changes the actual memory space allocated (if there's no enough memory space for other stuff, reducing max.trees may solve it now); pause= makes tree diagrams to pause on screen; union construct shortcut ('uconst'); suboptimal trees and branch supports in NONA. NOTE: versions of Pee-Wee/NONA available from the Willi Hennig Society Web Site between early june, 1997 to mid july, 1997, had a bug that affected some calculations when suboptimal trees were retained. The 'resample' command was added to speed up jackknifing (the file 'jak.run' provided with the program uses this, and therefore cannot be used with earlier versions of the programs). ---------------------------------------------------------------------------- 2.5.2 1.5.2 cured some bugs in programming options; added 'find' command; changed the order in which locations for taxa or clipped nodes are tried in Wagner trees or cursory swapping (command 'empezar'). ---------------------------------------------------------------------------- 2.5.1 1.5.1 added programming options (IF,IFNOT,LOOP, and related commands; see file programs.doc). Added option to read new data sets. ---------------------------------------------------------------------------- 2.50 1.50 Implemented a new, exact shortcut to estimate ancestral states when clipping tree for branch-swapping; it makes the program 25-100% faster than previous ('qsearch') shortcut. Commands related to previous shortcut ('qsearch,' 'slftest,' and 'xcheck') eliminated. ---------------------------------------------------------------------------- 2.25 1.25 Cured a bug in 'tswap' for Pee-Wee (could fail to find shorter trees, but found equally short trees okey). Cured a bug in the tree collapser for multiple swappers (including exact searches) in Pee-Wee and NONA; if there were many polymorphisms, the trees were sometimes wrongly collapsed. Added suboptimal trees and bremer support to Pee-Wee (commands 'suboptimal' and 'bsupport'). The (default) 'qcollapse' option is now temporarily turned-off when doing an exact search under poly=. For most data sets, the exact solution is now faster (prior versions used addition sequence as in the matrix, while they now try to find the best sequence before running). ---------------------------------------------------------------------------- 2.20 1.20 'vplot' and 'vnelsen' commands added ---------------------------------------------------------------------------- 2.16 1.16 a bug in multiple swappers (if number of cuts was greater than number of characters, program crashed; especially a problem for exact solutions with more taxa than characters) cured. Some bug fixing in other commands; apo[ speeded up. Excomp- option added for exact searches under poly-. ---------------------------------------------------------------------------- 2.15 1.15 maximum number of cuts for mswap changed such that it allows exact solutions; nelsen* and nelsen=; node*N; apo[. ---------------------------------------------------------------------------- 2.10 1.10 multiple swappers (altswap, tswap, sswap, mswap); on-line help; change[; apo+; ---------------------------------------------------------------------------- 2.00 1.00 some bug fixing from previous versions addition of 'nread' and character names ---------------------------------------------------------------------------- 1.96 0.96 implemented main commands ----------------------------------------------------------------------------