The changes to the non-beta versions are detailed below. If you have encountered any of those problems before, they should be fixed now. If you find further bugs, a report (with complete instructions to reproduce the bug, and preferably a data set) is appreciated. Thanks to all the people who found and reported bugs (indicated in square brackets) .

Fixes/changes to version of February 2004 (March 2004):

•       Added possibility to read files with blanks in the names (e.g. "My Documents" directory). This was fixed with a workaround in the string parser, a workaround which uses internally the '^' symbol (ASCII 94) as a substitute for the blanks. This means that file names which actually have the symbol '^' cannot be read (the symbol is highly unusual in file names, anyway).

•       Fixed storing of names of tree files in the "Previous files" section of the File menu; these were stored before without complete path specification, and then running TNT in a different directory created problems to re-read the files.

•       There was a bug in the monophyly checking commands (command "mono", invoked from Trees/Monophyly). When there were more than 16 positive group constraints defined and polytomies in the tree to be tested, the test was incorrect for some groups (possibly producing apparent non-monophyly for monophyletic groups among the first 16, and apparent monophyly for non-monophyletic groups beyond the first 16). [ Peter Hovenkamp ]

•       There was a bug in searches under group constraints (for both mono and non-monophyly); when more than 16 constraints were defined, constraints internally numbered as 15, 31, 47 (i.e. every 16, starting from 15) were not checked.

•       The "mono-" option (which reports trees violating constraints, instead of trees fulfilling them) did not work. It's fixed now.

•       Exact searches for continuous characters could sometimes miss optimal trees, in hardly predictable ways (which could depend on the taxon ordering in the matrix). When adding a taxon to a left branch in a growing network improved the bound, the bound was not updated properly, so that subsequent locations of that same taxon which improved even further the (actual) bound, were considered as inferior. Bounds were properly updated for the right branch.

•       Added possibility to randomize taxon insertion sequence in Wagner trees (rseed[;). Relevant only for highly unstructured data. With random insertion sequence, uninformative data with tree collapsing turned off produce (roughly) random trees as result of a Wagner tree. With the (default), up-down insertion sequence (or in PAUP*) uninformative data with tree collapsing turned off produce strongly pectinate wagner trees.

•       User-fuses (i.e. the '/ ' option of the tfuse command) produced trees that, even if identical, could be considered as distinct (unless subsequently collapsed).

•       On-line instructions for help were missing one carriage return (the first two lines ran one over the other). Added now.

•       Fixed occasional crashes when reading scopes where character names had been defined for some characters and not for others.

•       Fixed problems when using new tech searches as part of resampling; if using sectorial searches under resampling make sure you have plenty of slack (50% or so).

•       Added opendlg and getfname commands for macros (Windows only, see online help). The file "" (contained in the self-extracting file zipdruns.exe) is an example.

•       When running macros, if the end of file was found when expecting an end or else matching an if, the program freezed; an error message is now delivered. Finding end of file when expecting a stop matching loop, sprit ot tbrit caused an error, but the error message was about a RAM problem; the errror message now reports the end of file condition.

•       There were occassional length miscalculations during TBR (and possibly SPR) when there were asymmetric Sankoff character declared as "ancestral." This was easily detected because (after the search concluded) there was a message saying "oops?" (this is an internal checking for consistency, still in place). The problems were for rearrangements resulting from moving (rerooting) everything but the outgroup (which could underestimate length), and also when the outgroup had more than a single state (or a missing entry) and the root had as optimal some of the states in the outgroup (which could overestimate length). This is fixed now.

•       Added the option to request confirmation to stop searches or time consuming calculations (break/). Useful when you share office or computers with people who must click at every button they see?

•       There were problems saving files (in Windows version, with Data/SaveData) when there were complex character settings (like some states defined as ancestral) and trees/treegroups were being saved. Fixed now.

•       Added freqlist, freqdlist, and bremlist options to the scripting language. These store values of support in arrays, to facilitate comparison. Fixed potential problems with randomlist and other listing options. Added windows and linux keywords expressions to the scripting language (to identify running version).

•       For sectorial searches under sankoff parsimony, it was possible (although uncommon) for some actually informative characters to be considered uninformative during data reduction. This sometimes caused bogus lengths (the reduced analysis found a tree supossedly better, buth then replacing the small tree into the big tree increased length instead of decreasing it). This bug was introduced in the february 2004 version, which started using a better way to asess informativeness for the reduced sankoff characters (thus producing somewhat faster reduced analyses). The problem is fixed.

•       New Tech Searches (autoconstrained, or using tree-fusing) froze when some taxa were inactive. This was because of a bug in the module that creates the consensus of the two trees to use as either constraint or as guide for fusing, which consensed without knowing that the number of active taxa was less than the total number of taxa. [ Peter Hovenkamp ]

•       If some taxa were inactive and the memory was set for searches (the latter can be checked with the mxram command, which reports memory usage), then saving/showing transformation costs used the maximum number of states observed in the reduced set of terminals (not the entire set). Likewise when saving the data in Nexus format. This could cause the data to be unreadable by PAUP*, or to produce different results if re-read with TNT.

•       Fixed potential problems with changes to matrix after editing data (the changed characters were sometimes not re-checked before optimization, so that informativeness, or minimum/maximum number of states, could be wrong; the characters were rechecked before searches, so that the problem surfaced only if optimizations were done right after editing).

•       Added possibility to edit continuous characters from the menus, with Data/Edit/TaxonEdit (Windows only; character mode version could already edit them with xread=).

•       Added possibility to create data sets de novo (so you don't have to go through the text editor to get started), with File/New.

•       Mapping characters sometimes crashed the program. Fixed now.

•       There were problems reading interleaved data with some continuous characters, where some taxa were not defined for the block of continuous characters. Fixed now.

•       In at least some contexts, reading scopes of taxa/characters with a period in the name, produced errors. Names with periods can now be recognized in scopes.

Fixes/changes to version of March, 2004 (early April 2004):

•       In certain contexts, the '-' sign in negative numbers in macro scripts was not properly handled (such that instead of being read as a negative number, this produced a parsing error).

•       Trying to go beyond the last taxon in Data/Edit/TaxonNames (in the spin control) crashed the program.

•       There was no need to dichotomize non-binary trees before resampling; if using as reference a consensus tree, some unwanted groups were created when the reference tree was dichotomized. This is changed now, and pre-existing trees are unmodified before resampling.

•       The MRP sometimes created a matrix with continuous characters, as well as other problems with character names. That's fixed now.

•       Doing multiple random addition sequences followed by TBR saving a single tree per replication sometimes found duplicate trees (only for small, easy data sest; finding the same tree twice is very unlikely for larger and more complex data sets). This happened when the initial stage of the search (using SPR) found a tree not found before, but the subsequent TBR improved the tree and converged to a tree that had been found before; in that case, the tree resulting from TBR was saved even if duplicate. If the tree found by SPR was a duplicate, it was discarded. Note this happened only when saving a single tree per replication.

•       The export command refused to save trees only (the export- option) when data sets had more than 10 states.

•       In Windows versions, checking the "collapse trees after search" option sometimes did not properly set the auto collapsing on or off.

•       In Windows versions, when editing data with Data/Edit/CharacterEdit, there were problems when adding to a character a state larger than any of the preexisting states. Fixed now.

•       The tequal command (summoned with Trees/Buffer/CompareTrees) produced improper output when optional table format was on.

•       After changing the concavity constant for implied weights, without turning implied weights on, calculations of absolute bremer supports used floating point instead of integers. Fixed.

•       Frequency slope calculations were wrong when none of the replications displayed the group (the slope was reported as a negative number, intead of the actual 0 with frequency 0).

•       Stabilizing consensus more than once during driven new tech searches (xmult command, or Analyze/NewTechSearch) when some taxa were excluded produced the wrong results (many more taxa than requested were excluded after the first stabilization).

•       Tree-fusing when there were nonadditive characters of more than 16 states often produced wrong length evaluations, accepting fusings that worsened the trees instead of improving them.

•       Two problems that were not properly bugs: two portions of code intended to flag some bugs had not been removed after solving the bug they flagged. First, when the TBR swapper completed 4,000 million clippings, the search was interrupted and the tree being swapped was saved to the text buffer/output file in parenthetical notation. Second, when doing sectorial searches, if the reduced data set had a specific best length (4918, I believe it was), the search was interrupted. This code has been removed now.

•       Added the "repeat" option to the tfuse command.

•       Constraint based sectorial searches (CSS) with asymmetric sankoff characters sometimes miscalculated length for the reduced data sets.

•       Interrupting the search during constraint based sectorial searches (CSS) took a long while to actually interrupt anything. This works faster now.

Fixes/changes to version of early April, 2004 (May 2004):

•       If the data were packed for searches, re-setting the outgroup could cause a subsequent search to use the former outgroup. Now, changing the outgroup unpacks the data.

•       When the data were read as proteins, amino-acids were states 10-30; they are now states 0-20. For the most part, this is irrelevant for the user. Because of the internal treatment of the data, if you want to run step-matrices for protein data, though, having the amino-acids as 0-20 insrtead of 0-30 should run considerably faster.

•       When data are read as mixed types, all the characters were reset as alpha-numeric. Now, each type preserves its identity. Since this creates ambiguities when you want to subsequently read (say) transformation costs for sankoff characters (is an A an adenine in DNA, or state number 10 in an alphanumeric character?), you can now define how you want the states to be read in subsequent commands, with the nstates/type (where type is num, dna, or prot).

•       When reading taxon names with some symbols, a warning was issued telling the user that the symbol would be changed to an underscore, but the name was not actually changed. This created problems at the time of saving trees in parenthetical notation using taxon names. This is fixed.

•       Error messages were not sometimes properly displayed, especially when macros were enabled. There may still be exceptions, but display was improved.

•       Added the fuse option to the drift and ratchet commands. This fuses the trees found in a specified number of iterations, which sometimes produces a better tree.

•       Continuous characters cannot be mapped in color, but if Color Mapping was on, they were mapped anyway, as all gray (=ambiguous). They are mapped using numbers now, regardless of setting for Color Mapping.

•       For continuous characters, if the ranges were given so that the first number was smaller than the second, all length calculations were wrong (the "minimum" was then larger than the "maximum"). The program now stores the min/max numbers in the right order.

•       In scripts or macros, comparisons (i.e. >, >=, ==, <, <=) between floating point numbers were sometimes not properly done. The numbers were converted into integers for the comparison. This is fixed now.

•       For continuous characters, ranges in lists of common synapomorphies, or in lists and tree-maps of common optimizations, had errors. Fixed now.

•       After a mult search, with continuous characters and implied weighting turned off, some (or all) of the best trees found were not saved (this sometimes produced searches where no trees were found). This was because of rounding errors in score calculations (continuous characters, not having been planned from the beginning, are a hybrid between integer and floating point calculation).

•       The states for protein data sets were sometimes not properly displayed.

•       The number of rearrangements to accept during the perturbation phase of tree-drifting for large sectors (in sectorial searches) was the same as the number set for drifting the complete tree. This was ok if the perturbation was set to be abandoned when some percentage of the swapping was completed (the default), but otherwise, the perturbation phase for sectors could have gone on for longer than necessary. Now, the number of rearrangements to accept is set (during sectorial searches) to be no more than the number of taxa divided by 2 (or 30, if sector has less than 60 taxa). Note that some searches done with the old implementation could conceivably produce now different results.

•       The minimum/maximum numbers of characters (and thus informativeness) of characters was sometimes not changed after editing data (under Windows, or using the xread= option). Fixed now.

•       When reading interleaved matrices, the progress bar sometimes had problems (even going totally out of scale and never finishing).

•       When there were continuous characters, and some characters were deactivated, there were problems with the minmax command (displaying minimum/maximum numbers of steps usually crashed the program). Fixed now.

Fixes/changes to version of May 2004 (June 2004):

•       Saving the trees to RAM when finding out which nodes to cut to improve the consensus (Trees/Comparisons/PrunedTrees, or pruntree command) saved the trees in a format that was difficult to interpret. The trees are now saved with all the taxa, and placing the pruned taxa at the base of the tree (if all the trees are rooted at the same taxon, the pruned taxa will be outside the root taxon). This adds one extra node to the tree, so that the number of nodes gained is actually the number of nodes in saved tree minus the number of nodes in the complete consensus, minus 1.

•       With some groups constraints defined (from windows dialog, positive constraints with floating taxa), constrained searches under implied weights sometimes crashed the program (there was no problem under prior weights). Fixed now.

•       Added the possibility to read continuous characters as mean followed by standard deviation (assigns from mean minus SD, to mean plus SD). Instead of separating the two values with -, use the minus/plus symbol (ASCII 241).

•       When deactivating some blocks of characters, the outgroup was always set as the first active taxon, even if the current outgroup remained active. The outgroup is now changed only if the current outgroup becomes inactive.

•       Reading data as interleaved, the error message when there too many or too few characters for a taxon in a given block was always that there were "too many" characters for the taxon (except for the very first block, where the message was ok). Error message corrected now.

•       The maximum state for continuous characters is now 65.000 instead of 50.000.

•       Added the nozerowt option to the resample command (valid only for sym resampling). Instead of deleting characters with the same probability as upweighting them, this divides the weight by 2. The difference is that this identifies conflict only. Groups supported by some characters and contradicted by none appear with the maximum support (regardless of the number of characters supporting the group).

•       A rather harmless bug that looked deadly: when all the characters had the same weight, but different from unity, and implied weights was turned off, the lengths reported during a search corresponded to unitary weights for the informative characters (plus the weighted steps for the uninformative ones). Thus, optimizing the trees produced by a search resulted in huge discrepancies. Note that in most cases this could not have produced any problems, since the best trees continue being the same ones (the only difference could have been when a value of suboptimal was set, because then , for uniform weights of N, the effective value of suboptimal during searches would have been actually 1/N). This is fixed now.

•       There were problems displaying the names for continuous characters (for which the states cannot be named).

•       Deactivating data blocks with only continuous characters kept taxa with only missing entries as active. Fixed now.

•       Added the "!" option to the pruntax command (it prunes all the taxa that are not active).

•       Saving trees in compact form when some taxa were missing from the trees freezed the program (or could create other anomalies). This was because the missing taxa were supossed to be added to the tree, but the addition had some problems. Fixed now.

•       Determining active blocks with scopes didn't work (i.e. blocks had to be specified one by one). Fixed.

•       Sometimes the if-else did not behave as expected (problems were created sometimes when loops were included within the else part). Fixed now.

•       There were problems with the mxproc command (specially when used from within files), that caused crashes or unexpected behaviour. Fixed now.

•       In some versions, saving the matrix counted the number of taxa as the number of active taxa, even when all the taxa were being saved. This created matrices that could not be read without edition.

•       When resampling, if trees were to be collapsed with less than SPR or TBR (which is the recommended collapsing for real cases), sometimes groups with no real character support were retained in a replicate, thus distorting group frequencies. The effect could be quite drammatic when there were few supported groups. This is fixed now.

•       Added an option that facilitates reading trees or defining constraints: taxon names can be specified as multiple taxa, using three periods (?) at the end of the name, in which case all the taxa matching the name are considered (in the case of trees, all the taxa that match the name and had not been yet placed in the tree). This is in effect only when reading trees in parenthetical notation, and when defining constraints.

•       Groups of trees, taxa or characters were lost when the number of trees was changed. They are kept now.

•       Added something that could be useful only in very specific circumstances: the option to increase the random seed, in multiple randomizations, by a fixed amount for each replication (with the rseed:N option), instead of generating a new random seed and making sure it's different from all the previous ones. This is something that could be useful only in very specific circumstances, e.g. when a very large number of randomizations is to be done, but each of which takes very little time of analysis. In those cases, checking that each new seed is different may take some extra time.

•       Fixed potentially dangerous code in calculation of consensus other than strict (combinable components, majority, or frequency differences). This might under some circumstances have affected the results (hard to detect) or caused crashes.

•       Added the option to find which taxa to prune to improve combinable component consensus (pruncom command). Changed the name of the command to improve strict consensus (formerly called pruntree) to prunnnelsen. Note that for large numbers of taxa the command for combinable components may be significantly slower than the one for strict consensus.

•       Added the macro expression flipd. This calculates the flip distance between a matrix and a tree (see Eulenstein et al., 2004. Performance of flip supertree construction with a heuristic algorithm. Syst. Biol. 53:299-308). The matrix (which will normally be created with the mrp command) must have only binary, non sankoff, discrete characters. Two macros, (which calls the routine) and were added to zipdruns.exe (feel free to modify them to suite your needs). These macros calculate supertrees, either by branch-and-bound or heuristics, as described in Eulenstein et al.

•       The setloop command created problems when within a sprit or tbrit command. Fixed.

•       When positive groups constraints were read (or positive constraints with floating taxa were defined from the menus), there were problems when the number of groups was not an exact multiple of 16. There were also problems when some of the groups defined were not informative (i.e. could never be non-monophyletic).

•       Drawing the trees in parenthetical notation (tplot* option) created problems (crashes) when the trees were not binary. Fixed.

•       Definitions of tree groups were not changed when randomizing the tree order (rand/ command). This is fixed now. Note that randomizing tree order, defining tree groups, and then changing the number of maxtrees (hold command) de-randomizes the tree sequence, and changes the definitions of tree groups accordingly.

•       Added the option to save or draw the last tree in memory using commands (tplot/ or tsave/ options). You could do this before by turning macros on, setting a variable to the number of the last tree, and then saving the tree 'variable'. The tplot/ or tsave/ options are simpler.

•       Added possibility to calculate agreement subtrees (i.e. find out which taxa have to be pruned from the input trees to make them identical). This is implemented with the prunnelsen command, with the + and ! options (see help for prunnelsen). The algorithms are either exact (+), which can be very time consuming for cases where the trees are not very similar (i.e. they have a poorly resolved consensus), or approximmate (!), which are pretty fast but can be used only for binary input trees. The approximmate algorithms find sets of taxa for which the input trees are identical, but the sets of taxa may not be the largest ones. The approximmate algorithms are faster than those in PAUP* (agree command; note that the equivalent in PAUP* requires that the trees be rooted, since calculating unrooted agreement subtrees, which TNT doesn't do, is much more costly), but often find subtrees which are not maximal (usually within 10% of the actual maximum). Note that the agreement subtree maximizes the number of shared terminal taxa, not the number of shared groups (the two are the same when input trees are binary, but may be different when input trees have polytomies).

•       RNA data (with U instead of T) can now be read. Note the U is read (and mapped, etc.) as if it was a T.

Fixes/changes to version of June, 2004 (July 2004):

•       Added possibility to read comments in Nexus files.

•       In Nexus files, taxon names that are too long now produce a warning instead of an error. The "endblock" command was not recognized before (only "end"). Truncations of "endblock" are now recognized.

•       Added the hold+ and hold- options (see help hold).

•       TBR or SPR searches under implied weights miscalculated scores when there were several characters with more than 4 states and less than 9. The score was recalculated exactly after the search, so that everything seemed ok, but this could cause the program to miss some better trees during the search, without the user becoming aware.

•       The flipd expression returned the number of flips without counting the terminals. Eulenstein et al. (see above) do not specify that terminals are to be included in the matrix representation of the tree to be evaluated, but that is the only way to reproduce the numbers of flips reported by their program, Rainbow.

•       Saving trees in compact form when some taxa were inactive created difficulties for subsequent comparisons of trees (node numbers were not properly reassigned after inserting the missing taxa at the base opf the tree). Trees that were identical could be evaluated as different. Fixed now.

•       Added isdup to the list of macro expressions.

•       Calculating differences of frequencies for the groups of a reference tree caused crashes when the tree itself was not included in the set of trees. Fixed.

•       There were problems reporting synapomorphies as lists (cases where state sets were identical were reported as synapomorphies), and when some characters were inactive (inactive characters could be reported as synapomorphies, or active characters could be mist). This bug had probably been introduced when adding continuous characters. Fixed now. [Julian Faivovich]

•       Running ratchet searches with autoconstraints sometimes crashed the program. Fixed now. [ Jarno Tuimala]

•       The tcomp command (comparison of trees) did not check whether the numbers of the trees to compare corresponded to trees in memory (for example, you could compare trees 5 and 6 when having only 2 trees in memory). The results were meaningless (and possibly could have caused crashes). The program now checks to make sure the tree numbers requested do exist.

•       It is possible now to open a metafile so that subsequent tree-drawing commands save their tree(s) to that metafile (Windows only). Before, it was necessary for the user to be present, and when the tree pre-viewing window opened, to press M. Now, a metafile can be opened with File/OutputFile/OpenMetafile; this can be saved to batch menu instructions. To play it safe, it is better not to save many trees to one metafile (the file may become rather large); I advice to close the metafile, and open a new one for each tree, if you intend to save many trees. You can use this option, for example, to have tree-resampling calculations output their tree right to the file. [Rudolf Meier]

•       Trees in Nexus format were always saved using taxon numbers, even if "use taxon names" was on. Fixed. [Rudolf Meier]

•       Added option to undefine tree, taxon, or character groups (with - followed by the number or name of group(s) to undefine).

•       Added option to save tree-tags in a readable form (ttag/ option).

•       Sometimes there were problems when a tree was optimized, then some (but not all) continuous characters were deactivated, and the tree were optimized again. In such a case, the length could include the steps calculated before deactivation of the deactivated continuous characters.

•       Linux versions include now the possibility to buffer previous commands, so that they can be recalled using the arrow keys. This is optional, and is turned on with lintrees* (once connected, it cannot be turned off).

Fixes/Changes to version of July, 2004 (August 2004):

•       Attempting to export data or trees without providing a file name (which you were not supossed to do, anyway), crashed the program or caused unexpected behaviour. [Serita Von Groningen]

•       Creating a new data set and editing it (under Windows versions) caused crashes. This bug had probably been added in May, 2004 (when added option to preserve the identity of the type of characters in the matrix). Fixed.

•       Labels on tree-branches (ttag command) were not properly saved. They are now.

•       The Windows version updated its icons/menus too often, even when nothing had been done. This was annoying sometimes.

•       In the Windows version, it is now possible for the user to set the colors for the tree branches (useful for preparing presentation of results). For this, the tree must be "unlocked," the "pre-view trees" option must be on, and the "map characters in color" option must be on. When you map a character, double clicking the right button on a node, sets all the descendants of the node to the color of the specified state (0-9).

•       Added the riddup command (get rid/reinsert duplicate taxa). Duplicate taxa cannot change the tree length, so deactivating, searching, and reinserting, produces identical results when there are numerous duplicates.

Fixes/changes to version of August, 2004 (September 2004):

•       Mac OS X versions: fixed problems with saving/reading trees in compact notation (it is now possible to exchange trees with the Linux/Windows versions); fixed problems with text-viewer; fixed problems with reporting RAM usage (bogus amounts of RAM were reported). Added possibility to read file names with spaces (as in the windows versions, see above, this is done by typing "^" instead of the space).

•       Added possibility to read files in other directories, to both Mac OS X and Linux versions.

•       Nothing significant done to the Windows versions.

Fixes/changes to version of September, 2004 (November 2004):

•       Added the possibility to have any number of tree-groups. This was added so that the (Linux) parallel version of TNT can deal more easily with its tasks; for compatibility, it was added also to the other versions. The maximum number of groups to store is set with tgroup+N; this must be done before reading the data set (it cannot be changed after reading the data set). Any number of groups can be stored (but keep in mind that this uses memory; if you're not planning to actually use them for anything, just stick to the default 32 groups).

•       Added the possibility to auto-save the results every a specified time interval. This is the "!" option of the tsave command (see online help for tsave).

•       A bad bug in the macro language… The checking of the dimensions for multi-dimensional arrays had a bug, such that subscripting a multi-dimensional array with a value from a multi-dimensional array could cause problems. Example: ray1 and ray2, both of dimensions 10x10, with value ray[9 9] = 0; then: set ray1 [ 0 'ray2[9 9]' ] 0.5555 ; should have been interpreted as setting ray1[ 0 0 ] to 0.5555, but instead this was interpreted as setting ray1[ 9 0 ] to 0.5555 (the first dimension of the array inside the brackets was taken as the first dimension of ray1).This is fixed now.

•       Displaying the weighting function (if implied weights was on when the data were read) if the buffers were prepared for optimization (or searches) caused problems if it was followed immediately by an optimization (or search).Fixed.

•       In the macro expressions ismono and comnod, it is now possible to read the set of nodes as a scope (referring to taxon groups, or to tree nodes).

•       Windows versions only: a problem that was added to some recent versions (and therefore did not exist in earlier versions), was that sometimes (e.g. when doing repeated searches in scripts) the status window was erased and did not show up again. This is hopefully fixed now (different versions of Windows may still have some problems with this?).

•       Windows versions only: under tree-view mode, if the command line was open, pressing <enter> or <tab> switched focus to the (non-visible) command line.Fixed.

•       Reporting the number of replications for mult (either with the mult:; option or with Analyze/ShowParameters/RandomAdditionSeqs) actually displayed the number of trees to hold per replication, not the number of replications.Fixed now. [Martin Ramirez]

•       The program did not issue an error message if some continuous characters were preceded by some discrete ones, which was incorrect input format.This caused errors in length calculations and in optimizations.An error message is now issued. [Diego Pol, Dan Janies]

•       Matrices with large numbers (>10,000) of continuous characters sometimes caused an error message to be displayed, reporting an internal error in TBR calculations.This was because the length calculations during searches sometimes differed from the true length (calculated with a complete optimization) in more than the error margin (set to 10xe-11), due to rounding errors.This should not have caused any other problem than alarm in the user. The error margin has now been set to 10xe-8, so this is prevented.

•       Linux versions: added possibility to run in parallel, using the PVM system. PVM can be downloaded from A single command, ptnt, has been added for handling the parallel jobs. See the online help for the options on using the ptnt command. This is a new and complex option, and so it may still be somewhat unstable or cause crashes/errors.

Fixes/changes to version of November, 2004 (December 2004):

•       When reading tree files, if the file contains more trees than maxtrees, maxtrees is now automatically reset (as long as enough free RAM is available) instead of causing an error message. Likewise for calculating a consensus to be stored in memory.

•       The amount of RAM for macros, and the number of loops/user variables, can now be set with (simple) expressions (i.e. operations within parentheses). This makes it possible for a macro routine to adjust these parameters automatically for different numbers of taxa/characters/trees.

•       As long as enough RAM is available, the constraint definitions now do not have to be reset after changing maxtrees. This sounds very simple, but TNT is very parsimonious with its memory usage, and thus this is not so simple as it sounds. It did take me a while to find the strength and stamina to implement it. It's done now.

•       A bug introduced in the version of november, 2004: the timeout for searches could not be set, either from the menus or with commands. This is fixed now.

•       Resetting maxtrees, or randomizing tree order, when low amounts of free RAM were available, could cause crashes. Fixed now.

•       The parallel routines of TNT (Linux versions only) were made more stable and less prone to crashes/deadlocks; several options were added to the ptnt command (again, goto, skipto, hgroup); added a bunch of macro expressions to the parallel versions.

•       For large data sets, the TBR branch swapper was speeded up (TBR is now from 10% to 30% faster, sometimes more, depending on the data sets; the cleaner and larger the data set, the bigger the gain). Gains are less significant for characters with 16-32 states, and for Sankoff/continuous characters.

•       Added the * option to the copytree command (see online help).

•       DNA data sets with gaps could not be saved in Nexus format (the program complained that more than 4 states were present, even if the fifth state was a "legal" DNA state). Fixed now.

•       Running a constraint-based sectorial search without having turned the constraints on (which was not supossed to be done!) sometimes caused the program to crash. An error message is now issued.

•       Fixed a problem with the macro expressions isinagroup, isintgroup, and isinxgroup, that had arisen when introducing urestricted numbers of tree groups.

Fixes/changes to version of December, 2004 (January 2005):

•       Fixed problems closing metafiles to automatically save tree diagrams.

•       Fixed some glitches with macros (i.e. problems reading variables as strings in macros; user progress report flashing).

•       Windows versions only: re-setting parameters for macros (with Settings/Memory) caused an error if macros were on (this bug was added to the december 2004 version, when changing the way in which macro parameters are read). Fixed now.

•       The number of max. trees was reset only if max. trees was reached while reading the trees, but not if memory was already full when starting to parse the tree file. A foolish distraction on my part!! Fixed now.

•       In Linux versions, running searches under implied weights sometimes crashed the program. This was an error apparently due to some problem in how gcc 2.96 treats doubles and floating point numbers; some compilations were ok, others weren't. The version posted up in the web in december did have the problem. The problem is hopefully fixed for good (i.e. a workaround to make sure the compiler doesn't screw things up is now used in Linux versions).

•       When a block of continuous characters that did not include all taxa was followed by a block of data in dna format (i.e. indicated with the &[dna] ), the taxa not defined in the continuous block were considered as having state 65.535, instead of the range 0 - 65.535 (i.e. all possible values). This did not happen when the taxa were explicitly defined as missing for all the characters in the continuous block. Fixed now.

•       Added a progress bar to the riddup command.

•       Printing tables in default format (e.g. minimum/maximum number of steps) with floating point numbers (e.g. with continuous characters) for large numbers of values (e.g. many characters) crashed the program. Fixed now.

•       Added the sibyl option to the resample command. This is intended as a test of stability, achieved by comparing the results that would have been obtained if analyzing a data set with fewer characters with the results obtained for the complete data set. This checks whether a group supported for the reduced data set is supported/compatible with the results for the complete data set; the group may well be absent from all the trees for the complete data set; this does not measure support for groups.

•       Added the lastsibyl and lastsupp expressions to the scripting language.

•       Analyzing resampled data sets using the ratchet caused the original weights to be improperly buffered, thus the results were wrong. Fixed now.

•       Added the = option to the tcomp command (it calculates retention indices, which are similar to distortion coefficients, for mapping of some trees onto others). Also added the discoeff expression to the scripting language.

•       Certain combinations of number of replications, with certain numbers of ratchet iterations, of the mult command, caused a "heap deallocation" error message. This is fixed now.

•       Some problems with merging DNA data sets were fixed. Some may remain; dmerge is a tricky command. [Kurt Picket]

•       Macros were not allowed as part of the instructions for resample or qnelsen; they are now.

•       Added the possibility to convert user variables to series of values. If array is defined as an array, then 'array[x-y]' is expanded to the series of values x through y in the array (separated by a blank space). If y is followed by "&N" then ASCII character number N is used as separator; otherwise a blank (ASCII 32) is used for all values.

•       Added the impwtlist expression to the scripting language. This sets an array to the implied weights (writing to global variable listsize the number of values written in the array, which must be large enough to hold the values). This can be used to easily modify existing weighting functions.

•       Condensing trees when filtering (best or unique commands, option Trees/TreeBuffer/Filter) when collapsing rule was SPR or TBR caused the wrong trees to be retained (sometimes, no trees at all!). This is fixed.

Fixes/changes to version of January, 2005 (February 2005):

•       the resample sibyl option could sometimes crash the program. The problem was in some memory allocations when calculating the RI's (specially if the trees were well resolved). Also, added a reciprocal RI calculation to the sibyl option (the first value is the best value of the dummies if the consensus of the reduced data set, mapped onto the original tree(s); the second value is best value of the dummies for each of the original trees, mapped onto the consensus of the reduced data set). The reciprocal calculation was added because the fact that trees for the reduced data set are typically less resolved, this artificially inflates the RI when there is very little resolution in the reduced data sets.

•       Added the flat, rflat, and flatnumsubs options to the drift command. These define a different (probably lower, and possibly 0) value of relative fit difference (rflat) for the first N iterations of drifting (flat N), which will use a different number of substitutions in the tree (flatnumsubs). This is intended to be useful at a stage where by swapping equally (or almost equally) parsimonious trees we would still find better trees; only when the swapping gets stuck, it becomes more important to accept suboptimal trees.

•       The discoeff macro expression sometimes had problems when taxa were excluded from the trees (particularly, taxon 0).

•       Parallel versions only: There were problems with percdone (and possibly other macro expressions pertaining to values in slaves) when several parallel jobs were running at the same time.

•       Parallel versions only: When large tree sectors were spawned in parallel from a group of trees (instead of all sectors being taken from a single tree), the sector N option of the ptnt command could freeze sometimes (sector *N required input from a single tree, thus it didn't have this problem).

•       Parallel versions only: The slaveget option worked ok when the variable to get from the slaves was the last variable defined and no values had been read/set for other arrays; if other variables were defined subsequently, and/or read/set subsequently, slaveget could easily get into trouble (e.g. causing unjustified warnings, or getting improper values). This is fixed now.

•       Parallel versions only: The help command did not include help for ptnt hgroup. It's there now.

•       Mac versions: a serious bug in the january 2005 version (due both to changes in compilers and to the addition of the command recalling system): displaying large trees to the console caused some of the subsequent output to be screwed up, specially for reading commands. This problem did not surface if you were working with silent=con and then using view; to view the results, only if you had the (default) silent – con. This is fixed now.

•       Windows menu versions only: Saving data sets with additional numbers of taxa and characters (Data/SaveData) produced files that were not readable (i.e. only the additional characters were saved for the additional taxa, so that the new taxa had fewer characters than the others).

Fixes/changes to the version of February, 2005 (March 2005):

•       In protein data, the dash (-) was read as missing, not as gap (i.e. state 21), which is probably the usual treatment for the symbol. [Usman Roshan]

•       The smatrix command could read only step-matrices for up to 10 states. This has been changed now, and up to 32 states can be read. [Usman Roshan]

•       Added the + option to the var macro command. This produces a very simple graph of one or two user variables.

•       Parallel versions only: added the tasksatsch and schalg macro expressions (see online help).

•       Parallel versions only: running a loop within a slave job that was being called from within a loop caused problems. The #N symbol was replaced when parsing the instructions for the slave, so that, within the slave, it always referred to the value in the loop of level N outside the slave. Now, the #N symbols refers to the loop of level N within the slave; if you want to access the value of loop of level N outside the slave (i.e. in the parent), then set a user variable before giving the instructions to the slave.

•       Parallel versions only: "spying" trees from slaves (ptnt spy option) when a slave was doing a sectorial search caused the wrong trees to be transferred to the master (handling the trees received caused crashed, freezes). Fixed now.

•       Parallel versions only: the macro expression numhosts used the number of hosts in the last ptnt call; now, it uses the current state of the virtual machine.

•       Parallel versions only: when added the possibility to create groups of hosts, the string myself, parent, and master were no longer recognized as names of hosts. They are recognizable again. [Diego Pol]

•       Parallel versions only: added the mnemonic option to the ptnt command (see online help). [Diego Pol]

•       Parallel versions only: added macro expression numerrors (number of tasks in a job that have errors or are dead).

•       Parallel versions only: improved way in which interruptions are handled by slaves when values/variables from secondary slaves are being read.

•       A bug introduced in the september, 2004 version: increasing max. trees, when character names had been defined (and, possibly, constraints had been defined) and the maximum number of tree groups was more than 32, caused memory error messages (there were no problems if the maximum number of tree groups was set to 32 or less). This is fixed now.

•       Using the macro expressions distnode, ismono, comnod, altered memory so that most tree tree-search commands caused an error message.

•       There were problems with files in DNA or protein formats, either when the state for the first taxon in a given character was a gap (-), or when all taxa had a gap for the character. Saving the data (and possibly mapping the characters onto trees as well) caused the program to crash. [Diego Pol]

•       Added a new search routine, piρon fijo. This is not yet included in the menus; the command to invoke the piρon fijo is pfijo. It is a sort of ratchet, where the perturbation is not given by reweighting characters, but given by creating reduced data sets from sectors of the tree. Instead of replacing the HTU's by their own down-pass states (as in sectsch, which produces exact score evaluations), this may use in some cases (randomly determined, with a probability constant) the states of one of the descendants (terminal or not) of the HTU. After searching for the "perturbated" reduced data set, then full TBR and tree-drifting is performed. The process is repeated a certain number of times (optionally, the resulting trees can be fused every certain numbers of cycles). This is inspired in Usman Roshan's REC-I-DCM3 algorithm (with the difference that he used only terminals, not HTU's, and that he conceived the search for the reduced data sets as a "search" phase, not a a "perturbation" phase, which led to unnecessary effort in the reduced data sets –trees shorter for the reduced data sets were usually not shorter for the entire data set). The advantage over other search algorithms seems to be that it can move to trees which are rather different from the starting one, yet quasi-optimal, in relatively little time (although this does not easily find minimum scores by itself, it is helpful in combination with other search routines).

Fixes/changes to the version of March, 2005 (May 2005):

•       When defining groups of trees (or taxa, or characters, or hosts, in the case of parallel versions), references to existing groups were done only within square brackets, so that [ one two three ] added (or removed) to the group all the trees that were within groups one AND two AND three. Since in some cases it may be desirable to be able to add the trees that are in groups one OR two OR three, the option to refer to groups using braces ({ and }) was added. Thus,

tgroup =0 (groupname) { group_one group_two group_three } ;

or, if groups one, two and three are the only ones which starts with "group_":

tgroup =0 (groupname) { group_ } ;

•       Parallel versions only: for large data sets, if a slave did not receive data and settings from parent within one minute, the slave exitted. It was intended to simply check whether parent was alive, but a bug made it exit. Now, slaves only exit if parent process is dead.

•       Parallel versions only: added the tasktoh macro expression (returns number of host in which a task is running), added the possibility to pause/resume only some tasks of a job (the '=' option of ptnt pause and ptnt resume), and added the possibility to pause/resume all the tasks in a given host (ptnt hpause and ptnt hresume).

•       Parallel versions only: there were problems when a slave task tried to spawn other slave tasks repeating its instructions (i.e. using "..." as instructions).

•       When reading compact tree files which contained more trees than could be fit into memory (so that tree-buffer size had to be increased while reading the file), some of the trees read were read improperly. This could cause subsequent crashes or freezes, when attempting to operate on the trees read. This was not a problem if the trees were being read in parenthetical notation; only compact notation caused a problem.

•       Attempting to save the data, if some character(s) had been renamed and multiple data blocks had also been named caused the program to crash. Fixed now. [Camilo Mattoni]

•       For data sets with more than 8,000 taxa, saving the trees in compact notation produced the wrong output, so that saved trees were read back into the program as different from the saved trees. This did not affect any data set with 8,000 or less taxa.

•       The pfijo command crashed on data sets with more than 8,000 taxa (for reasons entirely different from the previous one; that both caused problems beyond 8,000 is just coincidence!). This was because pfijo attempted to divide the tree in more chunks than expected. It could also crash (if more rarely) on small data sets, because it sometimes attempted to create uninformative reduced data sets. These two bugs are fixed now.

•       The chunksize option was added to the pfijo command. The tree can be divided in up to 32 chunks; if the size given leads to dividing the tree in more than 32 chunks (or less than 2), the sizes corresponding to 32 chunks (or 2) are used.

•       The sector option of the ptnt begin command formerly allowed division of the tree in up to 16 chunks; the limit is now raised to 32.

•       Running the xmult command (or Analyze/NewTechSearch), with autoconstraints turned on for xmult and turned on for drifting, caused crashes or freezes. Note the autoconstraints for drift have no effect on the drift analysis of tree-sectors.

•       Saving data (Data/SaveData) with some taxa/characters deactivated and some taxon/character groups defined created problems (the inactive taxa/characters were saved in the group definitions, but the taxa/characters were not actually present in the saved matrix). Fixed now. [Martνn Ramνrez]

•       For very large data sets, some randomizations took too long (for example, xperm, a command that should take a very short time). This was because the randomizations were done very carefully, to insure random sequences. If the careful process takes too long, now it is possible to use approximmate randomizations, which should be reasonably random for most purposes. This is turned on with rseed !; (the default, careful and slower randomizations, is set with rseed-;). This only affects data sets with over 2,000 taxa.

•       For very large numbers of taxa (above 5,000), the program could easily run out of memory during searches which involved strict consensus calculation at some point (autoconstrained drifting or ratcheting, tree-fusing). This was because consensus calculation was made with routines that use large amounts of memory for large numbers of taxa. Now, if necessary, the program uses an alternative (less memory-consuming) routine.

•       When doing resampling, the cutoff value for GC summarizing of results (cut option) was properly set only if the resampling method was set to symmetrical (sym), not if resampling was set to jacknifing (jak) or bootstrapping (boot, poisson). Now, the cut is read as cutoff for GC whenever summarizing is set to GC, regardless of resampling type. [Andreas Wahlberg]

•       There were problems when several character (or host, in parallel versions) groups were created using a single xgroup (or ptnt hgroup) command, AND some group which was not the last one was defined using the "=" option (instead of ">" or "<"), AND the number of characters was less than the number of taxa. This could cause crashes (immediate or not), or unexpected behaviour. This is fixed now.

•       Parallel versions only: there were problems propagating host group definitions to slaves. Host group propagation is now correct.

•       Parallel versions only: added the possibility to specify a list of tasks, for the ptnt spy command. When a single job is to be spied, a list of the tasks to spy can be given after the job name/number, separated by a slash (/).

•       Parallel versions only: if a slave had launched other slaves, using only some sectors of a tree (i.e. with the sector option), no in-situ search had been made after launching those slaves, and the master attempted to spy the trees in the slave, errors occurred (freezes, deadlocks, crashed). Fixed now.

•       Parallel versions only: added the option to spawn only some sectors, when using the sector* option of the ptnt begin command. This can be used to sequentially resolve different sections of a tree, in single machines (where simultaneously spawning all sectors, for large data sets, required very large amounts of memory). The syntax of the sector* option remains the same, except that if a list of sectors (within square brackets) follows the number of sectors in which tree is to be partitiones, then only the sectors specified are launched. When a slave task returns trees (with ptnt get or ptnt spy), one of the best trees in the slave task is returned with the rest of the sectors polytomized (two copies, placed in a group called TreeSector_i_jobname, where I is the task number, and jobname is the name of the job). With this, it is easy to combine the sector with the rest of the trees, or with the other sectors.

•       Added the possibility to estimate the number of SPR moves between two trees (sprdiff command). Added macro expressions to access these values (sprdiff and sprsim). The method used will be published soon; it is a heuristic, and it depends on the current random seed (rseed command), so that repeating several estimations gives an idea of the error in the estimation.

•       It was possible for the SPR and TBR swappers to miss some moves when doing searches under tree-constraints (i.e. depending on tree topologies, some moves that should have been accepted were sometimes rejected). This was most likely unnoticed by the user (it was discovered when testing the sprdiff command), and very unlikely to cause any harm. Anyway, it doesn't happen anymore.

•       Attempting to prune (with the pruntax command) some taxa that were already absent from a tree caused the tree to be polytomized, instead of pruned.

•       An important change: the TBR algorithms used to be slowed down a lot when a better tree was found (lots of buffers had to be re-calculated). I had been thinking about this for a while, and finally decided to seat down and improve it. The transition from one tree to the next tree is now much faster, and buffers are modified based on the changes done to the tree; since this is not well tested yet, it might conceivably have some errors and then it is set as optional. The new way of switching between trees is deactivated, with bbreak:safe (the setting subsequently applies to all instances of TBR; if you have asymmetric sankoff characters, the safe applies always). For large data sets (500 taxa or more), this makes a significant difference in the time needed to complete a random addition sequence, and it allows to do much faster drifting or ratcheting (specially with high numbers of replacements in the perturbation phase, which used to consume a lot of the search time). Note that with the former method, each replication of mult or xmult started with a round of SPR before switching to TBR. Since with bb: nosafe TBR is now much faster in the initial stages of swapping, then doing Wagner+TBR now takes considerably shorter than Wagner+SPR+TBR (as long as you're not saving multiple trees, in which case starting with SPR under nomulpars still makes sense). If you want the SPR phase to not be skipped from mult (when a single tree per replication is being saved) and from xmult, then use bb: noskipspr.

Fixes/changes to the version of May, 2005 (July 2005):

•       The goto- option (i.e. to undefine a target file for goto) caused an error.

•       Added the possibility to insert contents from files (file contents are copied, not interpreted). The syntax is similar to that for goto, except that literal replacement is indicated with a double @ (not used for anything else in TNT syntax). This is useful specially to send instructions to slave tasks, without having to copy the file with instructions to all the slave machines:

             ptnt begin jobname = @@filename labelname ; return ;

       if a "target" file had been defined (with goto=), then the filename can be skipped:

              goto= filename; ptnt begin jobname = @@ labelname ; return ;

       The end of the text to copy must be indicated with a double @. Aside for instructions to slave task(s), this can simplify the syntax for loops, etc.

•       Made it possible for sectorial searches to use a separate matrix-buffer (xbuf option of the sectsch command). In the case of very large data sets (i.e. 2000 or more taxa) and relatively small sectors (i.e. below 300), the conversion to reduced data sets is significantly faster.

•       Made it possible for sectorial searches to fuse the results of multiple starting points for "small" sectors (i.e. sectors below drifting size). This is the fuse option of the sectsch command.

•       Added a new type of sectorial search, the "exclusive sectorial search," as an option to the sectsch and xmult commands This had been implemented before, in the parallel versions (Linux/Mac OS X), but it has now been added as a serial command. Using xss N-M+R-S divides tree with T taxa, starting with sectors of size approximmately T/N and ending in size T/M, analyzing each, and repeats the selections R times, and doing a round of global TBR every S rounds; the sectors are not exactly even, admitting small differences, determined with the random seed (with the xeven option, the size can be made as even as possible; default is noxeven). In the case of the xmult command, specifying xss does first css (if specified), then rss (if specified), and then xss. The parameters for xss under xmult (chunks, cycles, even sizes) are set with the sectsch command.

•       Calculating relative bremer supports, considering only trees within absolute supports, produced serious overestimations of the actual supports. This is fixed now.

•       Interrupting the pfijo command caused subsequent crashes. Fixed.

•       Defining a value of suboptimal/relative suboptimal, when the trees were being collapsed with SPR or TBR, was intended to influence tree collapsing when doing resampling, but it didn't. Now it does: the trees are further collapsed.

•       Parallel versions only: an important addition: it is now possible to swap (using TBR) on a tree in parallel. This is the swap option of the ptnt begin or ptnt again commands. Swapping in parallel only saves time for very large data sets (otherwise, swapping on a tree takes so short that the communication time takes longer than the swapping itself). When several trees are to be swapped in parallel (and given that transferring data to a job that has been initiated takes a significant amount of time), it is best to have some jobs (inactive) ready for swapping, and re-start them with again.

•       Parallel versions only: for very large data sets, considerable time is spent (when initiating jobs with begin) in transferring the data to all the slaves. It is now possible to create a copy of the data (in binary format) in the disk in each slave (with ptnt setdata), and then have the slaves read the data from disk instead of getting it through PVM (with the /dskdata option of ptnt begin). See online help of the ptnt command for details.

•       Parallel versions only: in very large data sets, initiating jobs sometimes crashed the slaves. This was because of a misscommunication problem with the master, at the time when the slave was checking min-max steps for the data received (since the time to check min-max steps for smaller data sets is non-significant, then it was very unlikely that the problem arose in smaller data sets). This is fixed now, and jobs for large data sets can be initiated more reliably now.

•       In very big data sets, the time used to set up the tree-constraints, in constrained searches, was too much. Since this is, in principle, not a very costly job, I had used a lousy algorithm to do it. However, on very large data sets, when better trees were being found frequently, the tree-constraints made the search slower, instead of faster. This is fixed now, and a much faster algorithm is used to set up the constraints. Since the default for xmult is using autoconstrained searches (level 1: consensus of previous and wagner), this will make xmult searches significantly faster, for data sets above 2500 taxa or so.

•       Again, in very big (and messy) data sets (2500 taxa or more), it is now possible to try to select first the most promising rearrangements when doing TBR on strongly suboptimal trees. This makes the initial stages of the swapping to lower the score a little more rapidly (subsequent stages of the search catch up, or almost, so that the net gain is only a little). This is set with the preproc option of the bbreak command (and it applies only to mult saving a single tree per replication and skipspr, and bbreak with nomulpars).

•       The expressions $taxon N, $character N, or $state N S, are now read as the name of taxon N, character N, or state S of character N. Note that this works only if the macros are on and no user variable has been named "taxon", "character", or "state." The name of the file with the data set, is referred to as $datafile. In parallel versions, $host N is read as the name of host N. This can be used to produce more verbose reports in scripts.

Fixes/changes to the version of July, 2005 (September 2005):

•       The prunnelsen! option sometimes caused crashes or freezes; fixed now.

•       The macro expressions states, contmins, and contmaxs, caused all other characters to be deactivated. Fixed.

•       If tree-tags have been written, then the expression $ttag N is equivalent to typing the label for node N of tag-tree.

•       To prevent problems in the macro language, now it is not possible to name a user-variable as one of the built-in expressions [Andrιs Varσn]

•       Parallel versions only: when executing TBR in parallel (the swap option of the ptnt begin or ptnt again commands) it is now possible to have one of the slaves work exclusively controlling the others. In some cases (i.e. data sets where swapping proceeds slowly because of many characters or slow optimizations, numerous slave jobs) this works somewhat faster than the earlier implementation (in which one of the slaves was a controller and it also did swapings itself; often, the other slaves had to wait for the controller to finish its own swappings before proceeding with further swappings). The option to have one slave acting exclusively as controller is set with swap+N (where N is the tree to swap); the default (controller also does some swapping of its own) is swap N.

•       Parallel versions only: spying onto a job where the resampling command was being executed caused errors (returning no trees at all, or crashing the slaves).

•       Parallel versions only: the behavior of slaveget, when values from some slaves could not be retrieved, was somewhat erratic (including –1 values written onto the wrong cells, and some non-retrieved cells written as 0 instead of –1). Fixed now.

•       The xss option of sectorial searches had problems under implied weights. Fixed now.

•       Saving step-matrices (defined with smatrix) produced output that was not readable by TNT, as well as saving character costs in Nexus file when the data were of type DNA. Fixed now.

•       Calculation of minimum possible branch lengths (blength command) under sankoff characters was wrong (with larger errors in the more basal nodes of trees). This is fixed now. Note however that the calculation of branch lengths in the case of sankoff characters is based on final costs, not on reconstructions; for each character, all combinations of states x in ancestor and y in descendant are tried, and the minimum of cost[x][n]+cost[y][ancestor[n]]+trans[y][x] (where cost[x][n] is the cost beyond the minimum possible of assigning state x to node n, and trans[y][x] is the cost of transforming from state y to state x). This can overestimate the length of a branch, and possibly underestimate it as well (see Goloboff, 1997, for discussion of a similar problem in a different –but related- situation).

•       Windows versions only: defining constraints (with Data/DefineConstraints) could cause problems. If you attempted to define negative constraints, then switched negative constraints off, then tried to define them again (without leaving the constraint dialog), the field for the tree number (that is, the reference number for the negative constraints) was not reactivated.

•       When the transformation costs for a sankoff character are equivalent to those of a Fitch character, then the character is optimized (during searches) using Fitch's algorithms (which is much faster). The rule used is as follows: when the cost of transformation between states present is all the same (P), and the cost to/from any absent state from/to any present state (A) multiplied by the number of states present (N) is less than or equal the cost of transformation between states present (P) multiplied by the number of states present minus one (that is, when Px(N-1) ≤ AxN), then consider the sankoff character as a Fitch equivalent.

•       Mac versions only: storing a string in a user variable produced a reversed string (because of the big/little endian difference). This is fixed now. [Diego Pol]

Fixes/changes to the version of September 2005 (November 2005):

•       Resetting the RAM for macros in Linux/Mac OSX versions, after having turned macros on and then off, caused crashes. [Andrιs Varσn]

•       Sectorial searches under xbuf (=default) when there were nonadditive characters with 2-8 states AND nonadditive characters with 16-32 AND continuous characters caused miscalculations. Fixed now. [Hiri Julcr]

•       There is now an alternative (easier) form of declaration of variables. Using the ":" option, it is now possible to simply declare the names of the variables (and their dimensions), omitting the number of variable to which the name is to be assigned, or the plus (+) symbol. This works as if the declarations always used the plus; note that naming starts always from the lowest available variable.

•       The set command could set one-dimensional arrays (for example, with the downlist or deslist expressions) only if they had been defined as such; it is now possible to use any valid array (for example, matrix[2] is now valid as a one-dimensional array with 10 cells, if matrix had been defined as matrix[3 10]).

•       It is now possible to assign state sets (with the macro expression states) corresponding to all characters, all taxa, or both, to one-dimensional or two-dimensional arrays.

•       Added expression statediff to the macro language (see command-line help for syntax).

Fixes changes to the version of November 2005 (December 2005):

•       The contmins and contmaxs expressions produced an error message if a tree-number (which is unneeded, but optional) was specified [Farhat Habib]

•       For sectorial searches, it is now possible to specify exactly the number of selections for each size, using the "selfactor = N1 N2 N3" option.

•       Parallel versions only: If a job was reset with ptnt again, and the slaves had been used before to swap a tree in parallel, then the job was not reset (receiving the new set of instructions), but instead swapped again on the tree received (as if it had been asked to swap in parallel). This is fixed now.

•       Parallel versions only: when recovering results (with ptnt get) from running exclusive sectors (/sector *N or /sector-N options) the polytomized tree was sent back only if the initial score had been bettered or matched, and the master had no control over this. When spying results (with ptnt spy) the polytomized tree was sent always. Now, with a special return command, it is possible to control whether ptnt get returns a polytomized tree always (with return polytree) or never (with return nopolytree).

•       The xmult command (invoked by most of the New Tech Search options) had problems when doing autoconstrained searches under previously defined constraints.

•       Added calculation of "wrong groups" and "mist groups" to the sibyl option of the resample command (optionally, with the errcount option). "Error rates" are the number of groups in the reduced data set that are not found in the complete data set, divided by the total number of groups supported by the reduced data set. "Mist groups" are the number of groups in the complete data set that are not found in the reduced data set, divided by the total number of groups supported by the complete data set.

•       Linux/Mac versions only: when program is running in the background, it is now possible to stop it by creating a file called stop_tnt_ID (where ID is the process ID; TNT automatically deletes this file when exitting), and pause it by creating a file pause_tnt_ID. Before, TNT could be stopped (not paused), but without specification of a process ID (so that all TNT instances were stopped).

•       Added a new (experimental) command, hybrid. This allows exchanging a group between two trees, even when the group does not have identical composition in both trees. The program makes an effort to identify the most evenly sized partition for which the group has the most similar composition. The taxa present in group of donor tree but not present in the most similar group of the recipient tree are pruned off before moving group from donor to recipient (they are already placed somewhere else in the recipient tree); the taxa present in group of recipient tree but not in group of donor tree are pruned off, and then they are absent from the resulting tree. The missing taxa (if any) are then sequentially added at the best available position (as in a wagner tree, only that the starting point is an almost complete tree), and then the entire tree is swapped. Recipient and donor tree are exchanged, and process repeated. This command can also be used to complete (as described) trees which are missing some taxa (see online-help for details). It is intended for use (in scripts) in cases where tree-fusing fails to produce better trees by virtue of the source trees being too different (e.g. in the case of very poorly structured data sets) and there being no (or few) equivalent groups to exchange. It may, on rare occassions, produce better results than the tfuse command.

Fixes/Changes to the version of December 2005 (February 2006)

•       using large numbers of initial replications for new tech searches often crashed the program. Fixed now [Tobias Malm]

•       In exceptionaly rare cases (and only for data sets with 100 to 200 taxa), the TBR swapper triggered an interal error message regarding clusters. The TBR swapper now has a wider margin of tolerance, so that this error isn't triggered anymore. [Rafael Miranda]

•       A small change that may make the life of some people easier: when doing random adition sequences plus TBR (Analyze/TraditionalSearch, or mult command) the program issues a warning (instead of an error message) if the number of replications times the number of trees to save per replication exceeds available treespace. The search proceeds, stopping when (and if) the buffer is actually filled.

•       The macro expressions length and fit no longer re-pack data if this isn't needed: if the tree to optimize is binary and complete, and the data are already packed for searches, then the optimizer for searches is used now. This may save a little time in some macro routines.

•       The lists of taxa included/excluded from trees (incltax, Trees/Describe), in optional table formats, did not use taxon names even if requested to do so. Now they do.

Fixes/Changes to the version of February 2006 (March 2006):

•       both the SPR and the TBR swapper running under tree-constraints (i.e. constraints for monophyly) could (rarely, depending on the constraint topologies) miss some rearrangements. This is fixed now.

•       As a consequence of the previous bug, the calculation of SPR-distances between trees sometimes could report that the trees differed in fewer rearrangements than they actually did.

•       Setting gaps to be read as missing (nstates nogaps;), although it produced the proper setting, produced an error message.

•       There was a bug in the analysis of sectorial searches with randomly chosen sectors and combined strategies (beyond the gocomb value), that produced improper randomizations of the sectors to chose for analysis. Therefore, the results of using combined strategies were sometimes very poor. This is fixed now.

Fixes/changes to the version of March, 2006 (April 2006):

•       A bug introduced in the version of Sept. 2005, when adding the automatic treatment of Fitch-like Sankoff characters as additive during searches: a Sankoff character which was equivalent to a Fitch one, but had been set as additive, could cause crashes during packing of the data for searches (and perhaps incorrect calculations).

•       Selecting only some trees for calculation of a supertree may have caused the wrong selection to be used, in the Linux or Mac versions. This is fixed now.

•       An addition useful for very big and difficult data sets, which required a good deal of programming, and I had been expecting to do it for a long time: recursive sectorial searches. This lets you define any search routine you want for the analysis of sectors in a search with sectsch. The search routine is specified within square brackets, as an option of sectsch. The search routine may include macro instructions, and instructions to use sectsch (possibly also with user-specified routines; if you want these to be identical to the previous level of recursion, use "…" as instructions; this will obviously require some means for deciding when to stop recursing, such as the number of taxa for the current sector, or the desired maximum level of recursion). Two macro expressions were added, for facilitating recursive sectorial searches: seclevel (the level of recursion of the current subproblem; 0 if called from outside sectsch) and grandscore (best score for complete tree, of the current execution). This option may still be somewhat unstable or cause problems, because it is a complex option.

Fixes/changes to the version of April, 2006 (May 2006):

•       Added the possibility to optimize polytomies as "soft" (Maddison, 1989). This is the "!" option of commands length, fit, score, and cscore. Sankoff characters cannot be optimized on soft polytomies. It is possible to access character fits through macro expressions, simply adding the prefix "soft" to the expressions score, homo, fit, and length (please spare me any jokes about the unfortunate combination of "softhomo").

•       Previous update (March, 2006) had an addition not included in the present list, which contained a minor bug. For continuous characters, it is now possible to plot on the tree branches the maximum increases and decreases among different possible reconstructions (when all reconstructions imply an increase along a branch, the "maximum decrease" is reported as the minimum increase –a positive number). A bug caused some increases to be improperly calculated. This is the > and < options of the blength command.

•       A bug fix not reported in earlier versions: matrices with continuous characters mixed with alpha-numeric caused the "-" symbol in the alphanumeric matrix to be read as a gap instead of a missing entry. The "-" is now properly read as missing.

•       RAS+TBR (nomulpars) for large matrices with 16-32 states is now much faster (10 to 1).

•       Calculations of minimum steps for nonadditive characters faster for most data sets, and eliminates possible errors when there are many polymorphisms. Added xmin/noxmin option to the nstates command.

•       Fixed some problems when mapping unnamed characters with characters names ON.

•       Fixed some problems with randomizations using approximmate random sequences (rseed !).

•       Changing the type of randomization (rseed ! or - ) after permuting data, and before de-permuting, caused data to be wrongly de-permuted. Now, the data are automatically de-permuted if type of randomization changed.

Fixes changes to the version of May, 2006 (June 2006):

•       The value of informativeness (isinfo expression) returned to macros could be wrong. This bug was introduced only in the last update, and it probably didn't affect things other than scripts making use of the isinfo expression.

•       Now it's possible to run (almost) all commands from within resample or qnelsen, with the allow option. For example, you can further modify the character weights set by resample (keep in mind that resample "deactivates" characters by giving them zero-weight, which users aren't allowed to). Forbidden things continue being (1) resetting maxtrees (explicitly or implicitly, say, by reading tree files with many trees), and (2) turning macros on-off. This is intended for use in very specific scripts.

•       Running CSS with user-defined search routines (added after March, 2006) often caused freezes (or possibly crashes). Hopefully fixed for good.

•       In parallel versions, taxon and character group definitions were not transferred to slave tasks (tree group definitions are not supossed to be transferred).

•       Added @T N and +T N to the tread command (see help tread;).

•       The – option of minmax reported minima/maxima for all taxa, not just active ones.

•       Added option to parse arguments as ('0') (where 0 is a user variable). This allows more flexibility in parsing arguments (an example is now included in file, included with the example scripts). In connection with this, it is now possible to pass up to 32 arguments when running a script (as opossed to the previous 10).

•       Added iterrecs command (and the recsteps expression; see help iterrecs and help+recsteps).

•       Three cosmetic changes: the blength command now doesn't add a new line if the tree is not being drawn (because of multiple tags), the macfloat command reports the number of digits only if report is on, and writing tags to a tree is reported only if report is on.

•       Loops can now be named, with loop = loopname (see help loop for details).

•       Undefining tree groups (with tgroup–) eliminated the trees from the group, but retained the group name. This is no longer so. Also, it is now possible to use a scope to specify a range of groups (although not the complete specification with – and +).

•       Undefining groups of taxa, characters, or hosts (with hgroup–, agroup–, or chargroup–) crashed the program. This bug was introduced in november 2004 (when making it possible to have unlimited numbers of tree groups), but hadn't been noticed so far.

•       Reading a tree (in parenthetical notation) without title caused crashes when automatic placement in groups of trees read was set off.

•       Interrupting quick-consensus estimations, or resampling (qnelsen, resample) sometimes caused input to be improperly parsed when the commands to run had been read from a file (the input file continued being parsed, despite the interruption).

•       Sectorial searches under implied weights, with the (default) xbuf option on, sometimes produced crashes or erroneous tree evaluations when the sector selected comprised only uninformative characters. This bug had been introduced in may 2005, when introducing the xbuf option to the sectsch command.

•       Added the option to locally format user-variables when outputting them. This can be done only for named variables. Using '/' right after the opening single quotes, it is possible to specify format, as in the C function, printf: + determines a signed output, a number determines field width (if negative, flush it left), and a dot (.) followed by a number is the number of significant digits. If several specifiers are used at the same time, the first one must be the +, then the field width, then the number of significant digits.

•       Command-driven versions only: when literal quotes and ASCII character conversion are ON, ASCII 0 (i.e. &0 within quote) is now interpreted as "erase and go to the beggning of the line", and ASCII 1 (i.e. &1) is interpreted as "backspace". These work on stderr only.

•       The discoeff expression, when comparing multiple trees, reported only comparisons between the first tree of the first set specified, and all the trees in the second set. The trees other than the first one in the first set were never compared. When comparisons were specified only between two trees, they were ok.

Fixes/changes to the version of June, 2006 (August 2006):

•       Tree-tags were saved (with the save * option) only for internal nodes, and reading tree-tags in parenthetical notation was possible only for internal nodes. Terminals now can be done, both in and out.

•       A bug introduced in the version of May, 2006: TBR swapping for data sets with continuous and sankoff characters stopped when there were still rearrangements that produced better trees. That is, successively repeating swapping often produced better trees every time. This did not occur under the safe option of bbreak, only under the (default) nosafe. This bug was NOT there in versions before May, 2006. Sorry 'bout that!!! This is solved now.

•       Added a new command, travtree, useful for macros. This command allows to traverse trees in specific ways. See online help for details.

•       The silent mode for tree-editing (the ] option of edit) often produced freezes or crashes, if the tree to be edited had not been just plotted. Fixed.

•       If the first argument to a macro command was a number given in the form #loopname, this was not recognized and caused an error message (the expression #1 was properly recognized; only loop names didn't work). Fixed now.

•       When sankoff characters had (due to internal recoding, because of equivalence with a Fitch character; added July 2005) differential weights, sectorial searches often produces length miscalculations. It is conceivable that other cases of differential weights also produced errors. This is fixed now.

•       The comparison of groups absent in one tree but present in another (tcomp command, or Trees/Comparisons/CompareGroups), under temporary collapsing, mistakenly reported as "present in one but not the other" those groups which were present and unsupported in both trees. Fixed now.

Fixes/changes to the version of July, 2006:

•       Changing format of data to DNA while reading matrices caused problems with missing entries if the initial format had been defined as either 16 or 32 states. [Martνn Ramνrez]

•       In Nexus format, the gap symbol was always read as a new state, even when nogaps had been set.

•       The nogaps option applied only to DNA data, not to proteins. Now it applies to both.

•       The way in which user variables (with quotes), references to loop values (with #), and arguments (with %), are parsed has been changed, leading to a cleaner interpretation. For example, '0''1' did not concatenate the values for both variables 0 and 1, and #1%1 did not concatenate the value of the loop with the first argument. Concatenation is now produced properly. Note that this might conceivably produce problems in some scripts which worked ok for the old parsing style; I'd appreciate reports on errors produced by this change. [Martνn Ramνrez]

•       Fixed some errors occuring when converting a tree-tag (with $ttag) for a node for which a tag had not been defined.

•       Added expression numbits to the macros.

•       When doing searches, the time used for packing data is now not counted (the times reported correspond to the actual search times, and do not vary depending on whether the data had been previously packed or not).

Fixes/changes to the version of August, 2006 (October 2006; this is now version 1.1):

•       Not truly a bug, but perhaps unexpected: counting numbers of transformations between states (change or Optimize/CountSpecificChanges) included the steps in non-active characters. The steps in non-active characters are now never counted.

•       Added the possibility to do the auto-weighted optimization method of Goloboff (1997. Cladistics 13:225-245), previously implemented only in the program SL. This weights character-state transformations according to their homoplasy on the trees; it is computationally very complex (between 10,000 and 100,000 times slower than analyses of nonadditive characters under equal weights), and can be used only for relatively small data sets (i.e. no more than 100-150 taxa) and with not many states per character (i.e. characters with more than 4 or 5 states may be very time consuming). This is turned ON with piwe+ (or from the menus). The options are set with the (new) command slfwt (or from menus). This required some months of programming, and is the reason for switching from version 1.0 to version 1.1. Also added a new option to the ratchet command, the tradrat option (the "traditional ratchet", where the perturbation phase simply swaps to completion, not saving equally optimal trees; under auto-weighted optimization, which produces very few trees, the modified ratchet implemented so far in TNT seems to produce inferior results; to run the tradrat option you should probably increase upfactor and downfactor). Given that this is so computationally demanding, it is possible to restrict the TBR rearrangements (with slfwt maxtbr, which restricts the possible rerootings of the clipped clade); note that there is no point in restricting possible re-insertion points of the clipped clade, since this can be evaluated efficiently; the problem with rerooting is that (implied) asymmetries in transformation costs require that most characters be re-optimized every time the tree is rerooted (as noted in Goloboff, 1997). Because of this, under auto-weighted optimization SPR is more efficient (i.e. it looks at more rearrangements per unit time) than TBR (therefore, turning off the skipspr option of the bbreak command --with bbreak : noskipspr;-- will usually produce better searches). When using this option, keep in mind that, since this is a recent addition, it may still produce crashes or freezes; be cautious and save results frequently. Note that even the optimization of a single tree can be costly, and it uses heuristic shortcuts; thus, the score reported after a search is completed may be slightly different from the score obtained by reoptimizing the trees found in a search, which doesn't indicate a bug but simply the heuristic nature of the optimization process (the likelihood of this actually happenning decreases when increasing exops, maxdist, setlim from the slfwt command).

•       Windows only: when some tree-tags had been written to a target tree, and a tree-save file was open in compact mode (append or not), the program attempted to save the tree-tags to the compact tree-file (which is not a legal action). Now, tree-tags are saved only if the tree-file is open in parenthetical mode.

•       Under the (default) skipspr mode of swapping, when requesting mult replications under SPR holding a single tree per replication, no actual rearrangements were done (i.e. the SPR phase was skipped, and followed by nothing!). This works as expected now.

•       performing tree-fusing when more than 65535 trees were in memory crashed the program [ Henrik Nilsson ]. While it is still not possible to run more than 65535 trees, the program now issues an error message and continues execution. The same is true for other randomizations involving more than 65535 things.

•       Parallel versions only: there were problems when transferring values of user variables from slaves, if either the source or destination variable was dimension-less (i.e. not an array). Arrays worked ok. This is fixed now.

Fixes/changes to the version of October, 2006 (December 2006):

•       During searches under auto-weighted optimization tree-scores were occassionally grossly miscalculated, producing either that (a) some better trees were mist, or (b) many bad trees seemed to be within the error margin and then the score had to be checked exactly for too many trees (slowing down program). [ Marcos Mirande ]

•       Added an option for showing location of pruned taxa on reduced consensus (either from the consensus dialog, in Windows version, or as an option of the nelsen command). This can be useful to summarize information for conflicting trees. I should have thought of this before. Sorry I didn't. Now it's there. As any new option, it may still have problems; double-check results and keep in mind it might freeze or crash the program.

•       Windows version only: added the possibility to turn pre-viewing of trees on and off with a command (tplot[, and tplot], respectively).

•       Windows versions only: improved the way in which the opendlg command defines subordination for controls.

•       Added a new macro expression, numhits, which returns the number of hits to the best score that were done in the last execution of a mult or xmult command.

•       Fixed some potential problems with outgroup identification when deactivating some specific blocks (blocks command).

•       The hybrid command did not properly parse the '-' option (to mix without completing and swapping). Fixed now.

•       Reading large matrices in blocks of data could create problems for the reporting of progress. Fixed now.

Fixes/changes to the version of December, 2006 (January 2007):

•       Parallel versions only: the slaves could not run recursive sectorial searches (the maximum level of recursion was determined at startup as always 0). The maximum level of recursion on slaves is now set as identical to that of the master. In addition, several potential problems with interrupting/spying recursive sectorial searches from slaves were fixed.

•       Added a new command, chkmoves (see online help). This can be useful to quickly identify taxa that deresolve the strict consensus (or decrease group supports).

•       Tree collapsing under either SPR or TBR, when using auto-weighted optiimization as optimality criterion, produced serious errors (either crashing or freezing program, or producing wrong collapsings). Fixed now.

•       The just added option to show location of pruned taxa on the consensus produced errors when the list of taxa to exclude used some taxon groups (possibly excluding many more taxa than it had been actually requested). Fixed now.

Fixes/changes to the version of January, 2007 (March 2007):

•       Added a new command, prunmajor, which helps identifying taxa to prune to improve group frequencies (or frequency differences), used to calculate group supports. This command is likely to change soon, with addition of more options.

•       A bug in the sprdiff command sometimes led to improper calculations when not using stratified calculations; this became obvious when displaying tree-diagrams of the moves, and the number of moves needed to resolve some node of the consensus was reported as a lower number than the actual number of individual moves reported. Fixed now.

•       Added the '[' option to the sprdiff command. This tries to find the minimum SPR distance between two trees, but weighting moves. Longer moves are more costly. The weight of an individual move to N nodes away, is calculated as FxN/(N+K), where K is a constant of "strength" (as in implied weighting, with smaller values of K determining that all moves have a more similar cost, and K=0 that every move costs the same, regardless of distance), and F is a "normalizing factor", so that the largest possible move (T-3, where T=taxa) costs 1 (i.e., F=(T-3+K)/(T-3)). The distance N is calculated as the degree of the polytomy created by consensing the trees before and after the move, minus 2. The weighted SPR distance is probably a more accurate measure of tree similarity than the unweighted SPR distance.

•       Added the "noviol(ations)" and "poly" options to the sprdiff command (see online help). The first determines that (single) moves placing a node as sister to its ancestor are not accepted (although combinations of moves may still violate time constraints: moving first to the sister of the ancestor, and then to the ancestor istelf, is allowed). The second counts the number of moves necessary to resolve/collapse when source and/or target trees have polytomies (with a heuristic which is dependent on the ordering of the trees; if using this option for trees i, j, it is advisable to calculate both sprdiff i j and sprdiff j i, and use the smallest value).

•       Performing tree-searches after calculating SPR-distances led to crashes or error messages [Leandro Jones]. This is fixed now.

•       Linux/MacOSX versions only: it is now possible to record to file each of the commands given to the program, when inputting commands from the console. For this, set echo to "[" (use "]" to turn it off). Note that this doesn't echo commands from input files.

•       Calculating distortion coefficients when trees had different sets of taxa sometimes produced impossible values. This is fixed now.

•       The program uses now a buffering system for output that causes long output to be written out much faster. This was an issue only in the case of saving large data sets, or drawing tree-diagrams for very large trees.

•       Mac OS X versions only: the most recent versions had changed the way in which the backspace key behaves. The behaviour of the backspace key is now, again, what Mac users expect of backspace keys.

Fixes/changes to the version of March, 2007 (April 2007):

•       there were problems when applying the chkmoves command with some taxa deactivated (either the node numbers were obviously screwed up, or –if creating taxon groups- there were freezes).

•       There were problems merging data files (the dmerge command got screwed up when adding the "!" option to the xread command, a few months ago). Also, when some character contained only missing entries, there were problems saving the data (the all-missing character was placed at the beginning of a block, with unspecified format). [Kurt Pickett]

•       Under auto-weighted optimization, polytomies cannot be optimized (as "soft" or otherwise), but the program calculated SOME value (I don't even know what it was). Now, a check was added to make sure that if auto-weighted optimization is ON, the program refuses to soft-optimize polytomies. Also, in the Windows version, the option to optimize as "soft" was removed from the corresponding dialog.

•       Windows versions only: there were problems with the behaviour of the dialog for weighting (Settings/ImpliedWeighting). It works ok now.

•       Added the "noglobal" option to the sectsch command. With this, global TBR is never performed (not even at the end of the procedure). Note that, under xss, global must be set to 1 or more for the global TBR to take effect (after the specified number of cycles).

•       Windows version only: resampling and analyzing with New Tech (from the menus), produced problems (crashes, bogus error messages). This is fixed. [Andres Parada]

•       The iterrecs command sometimes had problems (e.g. crashes) when there were nested iterrecs commands for non-continuous characters. Hopefully fixed. [Santiago Catalano]

Fixes/changes to the version of April, 2007 (May 2007):

•       Issuing a condense command without having read data or trees crashed the program [Matt Yoder]

•       Added the rfreqs command (see help rfreqs). This is intended as an experimental exploratory tool. It calculates a score (0–100) for the occurrence of groups from a "reference" tree among a set of "input" trees. If the group occurs identically (i.e. as monophyletic) in one of the trees, it is counted as 1; if the most similar group is non-monophyletic by virtue of excluding/including one (or very few taxa), it counts almost as one; if the most similar group differs in including/excluding many taxa, it counts almost as zero. Thus, a group which is often non-monophyletic in the input trees but only because of a single floating taxon, will get a score close to 100. The formula to measure the "similarity" S between two groups is S = B/(B+(AxWa)+(RxWr)), where B=number of taxa in both groups or in neither (whichever is smallest), A=number of taxa added to group, R=number of taxa removed from group (Wa and Wr are weight factors to make removal/addition more costly, set with the prunmaj command. If group adds/removes more than a certain proportion of taxa (default is 0.333) then S=0.

•       Added the simgroup expresion for scripts (see help + simgroup), which uses the same measure of "group similarity" as the rfreqs command.

Fixes/changes to the version of May, 2007 (June 2007):

•       Program initialization can now be done similarly in the Mac/Linux/Windows version, with a unique password system.

•       The commands that show reduced trees (resols, prunnelsen) did not use the tree-shrinking definitions. Now they do.

•       Under exclusive sectorial searches, with sectors analyzed with a combined strategy (gocomb option), if the number of starts (combstarts) was greater than twice the number of starts defined for smaller sectors (starts), the program crashed. Fixed now.

•       Sectorial searches under auto-weighted optimization, when recording to text-buffer search status every few seconds, often displayed/saved the wrong scores (this was because the score was displayed/saved for trees during intermediate stages of the search). This is fixed now.

•       Running under implied weighting using internal steps could create problems under two situations: (1) if some additive character with uninformative state(s) was assigned internal steps, the scores reported for a search (any search) did not agree with those for a subsequent optimization (this was due to a constant difference, so it did not affect results, but it was annoying); and (2) if some continuous character had been assigned internal steps, tree scores under sectorial searches could be wrong (usually considered lower than they truly were). These two are fixed now. [Claudia Szumik]

•       Linux/Mac versions only: when running in the background, some commands to clear the screen were not ignored, which was annoying. All of them are ignored now.

Fixes/changes to the version of June, 2007 (July 2007):

•       if the transformation cost between two states in a step-matrix character equalled 0, and implied weighting was ON, the program could not calculate tree-scores during searches. This was because of the formula used to calculate to calculate fits for sankoff characters, which uses the minimum possible cost. The "minimum possible" for characters where some transformations cost 0 (which continue being unexpected and may produce problems in other fronts!) is now considered as unity, so that the score calculations under implied weighting are "correct". [ Santiago Catalano ]

•       Added the hifile command for scripting, which allows handling input files. See "help hifile;" for details, and associated expressions hifchar, hifstring, hifeof, hifline, hifnumber, hifspy.

•       If the tree order had been just randomized (command "randtrees/;"), some search command sometimes failed to find all equally parsimonious trees. This was because of a bug which made TNT think that additional most parsimonious trees were duplicates of preexisting trees, when they were in fact different. Exact searches did not place their trees in a tree-group; now they do, in a group called "exact_search".

Fixes/changes to the version of July, 2007 (December 2007):

•       The program now is free. The password system is changed, and (in Windows version) it is now possible to run the program even if you have no administrator rights.

•       Some potentially unsafe memory reallocations were changed.

•       Fixed problems with indicating location of pruned taxa on the consensus when input trees had different taxon sets.

•       Added 64-bit Linux versions, and the possibility of running any number of taxa (before, no more than 16383 could be analyzed). The version that can run more than 16383 taxa uses more memory to store the trees (as 32-bit ints, instead of 16-bit ints). In 64-bit machines, this shouldn't be a problem.

•       The option of the xread command that generates data under a simple JC model now can take two decimals for the probability of stasis. Before, the highest possible probability of stasis was 99; now, it's 99.99.

•       Parallel versions only: it is now possible to specify the number of jobs to spawn on each slave (to be used when some machines are faster, or have more than a single processor). See online help for the ptnt command.

•       Fixed some potential problems when reading groups of taxa or characters (or hosts, in parallel versions): groups beyond 31 could be accepted in some contexts, even of those groups could not be defined).

•       Added possibility to use branch-lengths defined by the user to the option for generating data (see online help for xread).

•       Converting a string used to add a white space right after the string. This was annoying under many circumstances [Diego Pol]. No white space is added now.

•       Comments embedded within instructions for iterrecs and travtree are now not counted (maximum is now 4128 bytes of actual commands).

•       Added the wcluster option, which makes wagner trees for very large data sets up to 3 times faster (see on-line help for mult). This is of no use for data sets below 1000 taxa.

•       Plotting synapomorphies common to several trees, while correct in itself, sometimes caused subsequent tree-mappings to be incorrect.

•       Added the option to not use memory for identifying nodes to shrink (which, in large data sets, can be a significant amount of memory). This is set with tshrink! (i.e. exclamation mark) before reading the data set.

•       Added option to calculate strict consensus trees, and to compare trees (tcomp command) using algorithms which consume very little memory (and which, in the case of the strict consensus, are sometimes faster than the previous one). When free memory is low, these algorithms are used automatically; their use can be forced with nelsen< (the default is using low mem algorithms only if memory is low, set with nelsen>).

Fixes/changes to the version of December, 2007 (February 2008):

•       Saving pruned trees (prunnelsen command, or Trees/Comparisons/PrunedTrees) sometimes caused freezes (and, conceivably, crashes). This seemed more likely when some taxa were excluded a priori, but it may have happened as well under other circumstances. Hopefully fixed.

•       Resampling under TBR-collapsing, when the outgroup was not the first taxon in the matrix, corrupted the results. Fixed now.

•       There were problems when the autosave option was used during sectorial searches (the trees saved to file were corrupted). Fixed now. [ David Maddison]

•       The handling of multiple tree-tags (which used to often cause problems) is now cleaner.

•       Running searches (or sometimes, even optimization of a given tree) under auto-weighted optimization with some sankoff characters caused problems. Fixed now.

•       Trees were sometimes not properly put into tree-groups after the user had re-defined (manually) some tree groups. Fixed.

•       Windows only: Excluding taxa from the strict consensus and showing their location on the tree, using the menus, did not group taxa which belong to a single node in the consensus (as done if using commands). They are grouped now.

Fixes/changes to the version of February, 2008 (April 2008):

•       NEW! It is now possible to read and save FASTA files. Reading: "proc & file". If file starts with =N, then it fills with gaps (the same effect is achieved with =N after the &). Saving: export ! filename (use !! to skip gaps).

•       Maximum length of taxon names now can be changed, with "taxname +N". This has to be done before reading the data set. In the case of Linux/Mac, this change makes the new binaries incapable of communicating with old binaries when running in parallel: make sure you update slaves!!

•       It is now possible to plot polytomous trees more symmetrically than before. See help for tplot.

•       For data in multiple blocks (xread format only), it is now possible to have a loose checking for name matches (with [match S], where S=similarity), using a Needleman-Wunsch algorithm to calculate distances (similarity is obtained dividing edit cost by length of shortest sequence and subtracting the result from 1).

•       Now string conversions (including $taxon, $character, etc.) can use the part of the string that comes after (>) or before (<) a given symbol x. To do this for taxon N: $taxon <x N. They can also use the first C characters in the string: $taxon:C N (if C is negative, then it uses only the last C characters; if C preceded by a + sign, then it uses the characters beyond C). If C is greater than the length of the string, then it adds blanks (after –in the case of a negative C, before- the string itself).

•       Fixed some potential problems with the mxproc command (commands following it sometimes were not properly parsed), and with displaying of error messages from within loops (which sometimes caused crashes).

•       Scopes of essentially any kind, can now also select things for which the string provided appears somewhere. For this, precede the string with a colon. E.g. if a taxon is called Xus_yus, then "taxcode - :yus;" will deactivate that taxon. This can be used when the names contain some taxonomy. Suposse taxon names are:






you can then create a taxon group with either of these two groups by typing:

agroup =0 (Vertebrates) :_Vertebrata_ ;

agroup =1 (Arthropods) :_Arthropoda_ ;

You can apply the same logic to taxon names when reading trees in parenthetical notation. Thus,

tread ( ( :_Vertebrata_ ) ( :_Arthropoda ) ) ;

will create a tree in which vertebrates and arthropods are monophyletic groups.

•       The tread command now can read taxon groups.

•       For very large data sets (i.e. over 10,000 taxa), speed was vastly improved in many operations which require tree-sorting.

•       Searches could in some rare cases be terminated with a message of an internal error in memory allocation. This is less likely now.

•       Windows only: under auto-weighted optimization, attempting to switch to tree-viewing mode when a tree was polytomous caused the program to exit. Fixed now.

•       Now it is possible to condense trees (condense command) excluding some taxa.

•       Low memory algorithms are now also available for majority rule consensus (majority command); in addition to consuming less memory, the new algorithms sometimes are (for large data sets) faster than the previous (default) ones. This is set with nelsen <;. One limitation of these algorithms is that taxa cannot be ignored during consensus calculation, and trees cannot be collapsed temporarily (thus the addition of the previous option to the condense command, to physically collapse trees and exclude taxa).

•       It is now possible to truncate long taxon names on output to N letters, with the taxname [ N option (use taxname ] to output complete name).

Fixes/changes to the version of April, 2008 (August 2008):

•       The parsing of long matrices with multiple data blocks was very slow (due to the addition, in the previous version, of the match option, which allows for application of the Needleman-Wunsch algorithm to taxon names; note that now all letters after a cuadruple underscore are ignored). The parsing is now as fast as it was before.

•       The verbose option as specification for a block (within square brackets) was added.

•       Very long group names (i.e. within the length specified with taxname+, but over the previous limit of 32 characters) could cause errors (or possibly crashes).

•       Added the int option to the bbreak command. This option uses a special kind of sorting for the characters to be optimized during swapping; option 1 considers only the most relevant characters, option 2 re-orders them, so that the most relevant are checked first (often requiring examination of fewer characters). These two options are useful only for very large data sets (>10,000 taxa) with many characters.

•       Windows only: attempting to swtich to tree-viewing mode without enough memory available to optimize a tree crashed the program. The program now attempts to recover more gracefully from that [Santiago Catalano].

•       Parallel versions only: improved memory management and speed for recovering trees (with either spy or get) from sectorial searches in parallel. Also improved memory management in a couple other places.

•       Added the option to never make space for assigning costs to sankoff characters. When characters are read as 32-states this can save a small but yet significant amount of memory (see help costs).

•       Fixed potential crashes (or erroneous calculations) with TBR under sectorial searches (specially likely to cause problems with recursive sectorial searches).

•       In 64-bit versions with no taxon limit, trying to open a file for saving trees for more than 16,383 taxa in compact format and append mode caused an improper error message to be displayed. Fixed.

•       A bug introduced in the April, 2008 version: the prunnelsen command (Trees/Comparisons/PrunedTrees) crashed (or produced bogus results) when input trees had polytomies (and perhaps under other circumstances). This was because of the faster tree-sorting, which had a problem for sorting reduced trees.

•       Added possibility to not prepare memory space for sankoff costs when reading the data. For data sets with many characters and many states, this can save a small (but significant) amont of memory, if you do not plan to use step-matrix characters.

•       Improved memory usage of recursive sectorial searches in master process (which formerly allocated some amount of unnecessary memory).

•       Fixed some glitches with prediction of number of clusters for reduced data sets during sectorial searches.

•       A bug which could have caused errors in either sectorial searches, or any search in which some taxa had been deactivated (either causing TNT to crahs, or to miss some TBR rearrangements), was fixed.

•       Compact tree files for more than 16383 taxa in append mode could not be opened. They can now.

•       Testing of monophyly (hard constraints) for searches in very large data sets is now much faster.

•       Sectorial searches for cases where no character had less than 9 states, but sector ended up having some characters with 8 states or less, often asked for inordinate amounts of slack, too large to satisfy. Fixed.

•       Report of "more slack required" informed of the increase over current setting; it should have said:

"... increase slack in X and try again..."

but it confusingly said:

"... increase slack to X and try again..."

The value reported is now the value to which the slack should be set.

•       Sectorial searches for cases with lots of characters with different prior weights, and with some 9-32 state chars which became 8-state or less for the sector, produced problems (messages of internal errors or undetected erroneous length calculations). Fixed. [Mark Siddall]

•       Sectorial searches for cases where matrix had some 32-state characters and no 16-state, but sector ended up having some 16 states, caused crashes. Fixed.

Fixes/changes to the version of June, 2008 (August 2008):

•       Windows versions only: added option to contract the trees (in the pre-viewing screen) so that the entire tree fits the screen (this makes it possible to look at very large trees). To toggle this, press "f". Taxon names may overlap when doing that and it may be better to use color mappings to indicate groups; in this case, taxon names may be hidden by pressing "n" (also a toggle). If taxon names are hidden, a single left-click on a node toggles display of the name of that taxon (or its descendants). To move the tree by small steps, use "k" and "l".

•       Searches under tree-constraints could crash the program when (1) there were pre-existing trees in memory, and/or (2) no tree-searches had been done before.

Fixes/changes to the version of August, 2008 (November 2008):

•       Defining positive or negative constraints, and then changing the number of maximum trees, produced freezes or crashes (note that changing number of max. trees first and then defining the constraints should have produced no problems). This is fixed now. [Martνn Ramνrez]

•       Windows only: defining from the menus negative constraints, or positive constraints with some floating taxa, caused an internal error message. The constraints could thus be defined only by using commands. Fixed now. [ Juliαn Faivovich ].

•       Running multiple random addition sequences under implied weights, accepting suboptimal trees caused crashes (and, possibly, unexpected bahviour). Running multiple random addition sequences accepting suboptimal trees is generally undesirable (except under very specific circumstances, e.g. running few replications saving many trees each); however, one expects it to function. The problem was because the value of maximum score acceptable during a replication depended on the score of the best tree found so far (i.e. in previous replications) and the value of suboptimal. This meant that, sometimes, a tree which improved the score during a replication was nonetheless “unacceptable”, causing further problems. Now, the maximum acceptable score for multiple random addition sequences under implied weights is determined by the best tree in that replication alone (when not using implied weighting, it continues being, as before, the best tree so far). [ Martνn Ramνrez ]

•       Linux 64-bit versions only: re-setting maxtrees to a large number when character names had been defined either crashed the program or issued an error message stating that not enough RAM was available (when in fact it was). Fixed now.

•       Linux 64-bit versions only: several error or notification messages could have potentially produced bogus output –don’t know whether this actually happened to anyone. It’s safe now.

Fixes/changes to the version of November, 2008 (February 2009):

•       Reading trees with excess/unbalanced parentheses caused the program to abort reading trees; the program now tries to fix the trees.

•       This version includes some work in progress, on landmark data (unstable and unfinished; missing entries cannot yet be handled). This is mostly undocumented; future versions (and a paper) will document it properly.

•       Windows versions only: it should now be possible to double-click (or drag-and-drop) files saved in folders with spaces in the names!

•       Linux/Mac versions only: added the option to replace the instructions for TNT when it is running in the background. If the file tnt_execute_PID (where PID is process ID of the TNT instance to reset) exists in current directory, then when TNT runs out of instructions –or finds a quit command, or file stop_tnt_PID exists in current directory (see additions to version of November 2005)- then TNT begins taking input from file –renaming it as a new file, so that instructions can be replaced again. With this (pause_tnt, stop_tnt, and execute_tnt) the user can have complete control of a TNT process running in the background.

•       Running constrained sectorial searches (CSS) with user-defined tree constraints in which there was a (large) basal polytomy caused bogus results, crashes or freezes. This is fixed now.

•       Relative fit differences when TBR-collapsing during implied weighting may have been miscalculated (underestimated). This error is unlikely to have been noticed, except by someone who was paying very close attention to the results.

•       Added the option to calculate bremer supports by keeping track of the score differences during TBR swapping. This is the “!” option of the bsupport command. This is probably the best way to estimate bremer supports for very large data sets. To my knowledge, the only program which has implemented this method is POY (versions 3 and 4). The implementation in TNT differs from POY's in that TNT can swap several trees (keeping track of the score differences among the source trees themselves), it can ignore the positions of selected taxa, and it can calculate relative bremer supports in addition to absolute supports.

•       Added the track option to the sectsch command, as well as the macro expressions nodtosect, biginsect, bignotsect, and bigntax. These should allow calculating approximmate support values from analyses of sectors of the tree. NOTE: For running TNT in parallel, this addition means that the slaves must be updated, too, or they won't be able to receive the data from the master.

•       The riddup command (to eliminate or reinsert duplicate taxa) is now, for large data sets, orders of magnitude faster.

•       The reactivating/reinserting option of the riddup command (riddup - ) may have altered node numbers for the trees (so that node numbering did not follow the same standard as all other TNT command).

•       Added the “/ ” option to the riddup command, to reinsert duplicate inactive taxa into the tag-tree. This can be used to calculate supports with duplicates deactivated and store them in tags; subsequent re-insertion of the duplicates into the tree shuld not change the support values.

•       Added the chkroot option to the sectsch command; this affects only XSS searches, making sure that the tree base (often left out of selections) is selected. This is to be used if you really want to make sure you cover all the sectors of the tree (e.g. for estimating supports using analysis of sectors).

•       Linux/Mac versions only: Since the chkroot option affects the way in which exclusive sectors are selected (with ptnt /sector *N), a new expression, treeparts, was added. This lets you know how many tasks to spawn in a parallel job where sectors are to be analyzed under chkroot.

•       Unlikely to have affected anybody: writing tree-tags during a recursive sectorial search, and then plotting the tags after having exitted the sectorial search, corrupted the taxon names –so that any command which attempted to write taxon names caused crashes.

Fixes/changes to the version of February 2009 (March 2009):

•       Made the track option of sectsch more stable .

•       Parallel versions only: couldn't run sectors when some taxa were deactivated. It works ok now.

•       Fixed a few problems with the landmark stuff (but this continues being in pre-beta).

•       Slightly changed the way in which existing tree-tags are handled when doing recursive sectorial searches

•       Added the DSS option to the sectsch command, and (for parallel versions only) the "sector D" option to the ptnt command. This option provides an easy way to effect a sectorial search around a node specified by the user.

•       When renaming chars., a blank before the semicolon caused an additional state to be named " " (blank). Only real strings used now.

•       Added option to collapse user-specified nodes to the condense command.

•       Scripting: vastly improved speed for the expression eqgroup in large data sets.

•       Parallel versions only: the sprit and tbrit commands could not be run in slaves. They can now; now they silence the output automatically (as in travtree or recursive sectorial searches).

•       Parallel versions only: the treeparts expression may have miscalculated number of parts if no search had been done before.

•       Re-inserting duplicate taxa into tree(s) caused the program to crash. This was introduced in previous version, with the possibility of reinserting taxa into tree-tags (which worked ok; only actual trees caused problems).

•       Added “help topics” (i.e. help [ topic ] displays all commands for topic topic).

Fixes/changes to the version of March 2009 (April, 2009):

•       Running resampling with xmult and/or sectsch for small data sets (20 or fewer taxa) sometimes caused crashes. This is really not something people were expected to do (running such small data sets with those routines is an overkill), but it should have worked anyway. Fixed now.

•       On some rare ocassions, data sets with continuous characters may either have (a) interrupted searches and displayed an error message about an “internal error in TBR calculations”, or (b) never finished searching, although the search could be interrupted and had the appearance of working normally. This seems to have been more likely to occur under Windows, due to code changes made by the compiler to my code during optimization.

•       Added the maketables + option, to save in an array the values displayed in a table.

•       The parsing of definitions of positive and negative constraints sometimes didn't work properly (in either Windows or other versions).

•       Some options for analyzing landmark data are now ready for use. See help lmark. For the time being, landmark data can be mapped onto trees, but no tree searches are implemented in TNT. Searches can be implemented only in combination with the scripting language (see here for some scripts). Added several macro expressions (lmscore, lmwts, lmfactors, lmnchar, lmnpoints), useful to handle landmark data.

Fixes/changes to the version of May 2009 (June, 2009)

•       when a landmark comprised only identically positioned points, the (default) noinscale option produced correct results, but the inscale option produced erroneous cost calculations (even when the cost contribution for the landmark was 0). This is fixed now.

•       Landmarks with a missing entry in the outgroup caused all sorts of problems (miscalculations, etc.). Fixed now.

•       Added the options termpoints and options to the landmark command (see help command).

•       Windows versions only: when running landmarks, now it is possible to better place the tree on screen if the (default) auto-shift of wide screens (under Format/DisplayBuffer) is turned off.

•       Parallel versions only: running the ptnt command from within a tbrit or sprit loop caused (after changes to sprit and tbrit done in March, 2009) problems with the memory management for the macros. It can be run ok now.

•       Versions with no taxon limit (whether 64 or 32 bit): the option to map a character on several trees at a time (map [, or Optimize/Characters/ CommonMapping) produced erroneous output. Fixed now [ Martνn Ramνrez ]

•       The travtree command had problems on trees with many polytomies (versions with no taxon limit were more prone to the problem). Fixed now. [ Diego Pol ]

•       Windows only: added option to use state legends from a specified character when printing tree-tags in color (with the ttag : option). Before, ttag : always used the state names from the first character in the matrix, which was confusing [ Martνn Ramνrez ]

•       Linux/Mac only: there were problems when resetting instruction files from background (with execute_tnt_PID, see under help bground), specially when macros were connected, and when the stop_tnt_PID file was created right at the time when a ptnt wait loop was being executed (which interrupted the wait loop, but did not begin to parse the new set of instructions). :-(

•       The continue comand was not properly recognized from within tbrit or sprit loops (after changes introduced in March, 2009). As far as I know, they work ok now.

Fixes/changes to the version of June 2009 (July, 2009)

•       The rfreqs command did not properly handle elimination of some taxa. It does now.

•       Changed the way in which similar groups in trees are recognized (macro expression simgroup, and rfreqs command). The new way uses a lot less memory (previous algorithm needed roughly an extra 3T2/4 bytes for T taxa, while the new algorithm uses only 16T extra bytes in the case of versions with no limit in the number of taxa, 8T otherwise –for the 73,060-taxon data set of Goloboff et al. 2009, this is over 4 GB instead of only 1.2 MB), and is a lot faster (for 500 taxa, 20 to 1, for 2500, 80 to 1, for 13000, 300 to 1). This means that the scripts used by Goloboff et al. (2009) in their eukaryote paper, can now be used on a windows machine, allocating only 1.5 GB of memory.

•       Given the above, the view command was added to Windows versions, but only with the “search” option (i.e. view : xxx; positions the cursor at the next occurence of string “xxx”).

•       A strange bug occured in some unusual circumstances during searches, when the nuber of rearrangements examined had a certain number of digits. This was due to a bug in the function that writes the number of rearrangements examined, and only under 32-bit Linux were any effects detected. The bug caused unstable/erratic behavior during or after the search, and may have caused crashes as well. This is fixed now. [ Rafael Miranda ]

Fixes/changes to the version of July 2009 (September, 2009):

•       Calculation of branch lengths was totally screwed up when there were sankoff characters. They're ok now. [ Diego Pol ]

•       The sprit or tbrit commands could cause crashes or freezes (I believe, after changes introduced March, 2009).

•       It is now possible to re-align 2D landmark data using RFTRA. The code for this (not stable yet!) was written mostly by Santiago Catalano.

•       When naming loops, all letters were downcased, but when subsequently accessing loop values the name was not. This caused unexpected errors if you attempted to name a loop with upper-case letters –loop values could subsequently be accessed only using lower case. Loop name is now read in lower or upper case (and continues being accessed in the same way). [ Salvador Arias ]

Fixes/changes to the version of September 2009 (October, 2009)

•       The command chomo (character homoplasy) was supossed to take a list of trees as argument, but it didn't –it always did all trees. [ Salvador Arias ]

•       Windows only: saving data for “only active characters” (Data/saveData) saved block definitions for the original matrix (i.e. the matrix with all characters) with a blocks command at the end of the file. This block definition was incorrect, and unnecessary, since the data were saved in proper blocks (thus, reading the matrix naturally produced the right block definitions). The blocks command at the end of the file is now skipped when saving only active characters. [ Mark Siddall ]

•       Renaming characters but without naming the states created bogus names for states. States remain unnamed now.

•       Windows versions only: improved the aesthetics and cosmetics (if not the ethics) of the display for landmark mapping.

•       Improved and added new options for re-aligning landmark data; see help for the lmrealign command (also added menu options for realigning, under Data/Landmarks). The tree-guided algorithms provide the best fit for the tree used as guide, using a method by S. Catalano and P. Goloboff (in prep.). The code for alignment was written in collaboration with S. Catalano.

•       Windows versions only: added to the menus some options for landmark optimization, under Settings/LandmarkOptimization, and the possibility to call the mapper for landmarks from the menus (under Optimize/Characters/Landmarks).

Fixes/changes to the version of October 2009 (December 2009)

•       There was a bug, unlikely to be noticed by users, which made sectorial searches use “combined strategies” (as in gocomb) when no value for gocomb had been set by the user and the sector selected was large enough to be analyzed with tree-drifting. This did not affect searches that defined a sector size above which to use combined strategies, and it did not affect searches with user-defined algorithms for each sector.

•       Some specific combinations of sector sizes with exclusive sector selections may have caused memory problems which resulted (most likely) in crashes. This could happen only for relatively large sectors (almost half the taxa). This is fixed, and it is now possible to run exclusive sector selections dividing tree in 2 pieces (minimum used to be 3).

•       Added the option to reroot tag-tree, and to specify an internal node as rooting point (see online help for reroot).

•       Parallel versions only: an unlikely problem: when running some resampling in slaves, but not using any actual search routine to analyze each data set (yeah, right!), there were problems if the results were spied with ptnt spy (ptnt get worked ok). Spying should be ok now.

•       Problems could also have arisen after resampling using the low-memory consensus algorithms (probably needed for very large data sets), when some taxa had been deactivated. Fixed now.

•       For very large numbers of taxa, the speed of the low-memory majority rule consensus algorithms has been vastly improved.

•       Improved the way in which initialization of the program is carried out in Linux and Mac when it is run for the first time (people using Mac were specially adept at screwing up when installing).

Fixes/changes to the version of December 2009 (January 2010)

•       Added the grptogrp (=group-to-group) expression to the scripting language.

•       A few really minor/cosmetic changes.

Fixes/changes to the version of January 2010 (March, 2010)

•       Windows only: in the dialog for Optimize/CountSpecificChanges, selecting “all trees” after having selected some trees did not actually optimize all trees –it used the previous tree-selection again. Fixed.

•       The maximum length of taxon names is now also used for the maximum length of tree-tags (if larger than 128).

•       There was a memory leak when naming loops; if the loop was repeated a large enough number of times, then this may have caused out-of-memory problems that shouldn't have been there. Fixed now. [ Salvador Arias ]

Fixes/changes to the version of March, 2010 (June, 2010):

•       there were problems with character-state trees, both with tree-length calculations themselves (due to problems with internal binary recoding), and with the fit expression for individual characters (the expression calculated the fit for the character-state tree as a whole, instead of using the sum of fits for the binary variables representing the character, producing an inconsistency with values reported by searches or for the entire tree). [Martνn Ramνrez]

•       Added the option to calculate the fit for character-state trees as units, under implied weighting, instead of decomposing them in binary variables.

•       Added option to read group names in scripting expressions. Also added expressions $agroup, $tgroup, $xgroup, and $hgroup.

•       Typing the wrong [topic] for help could crash the program. Fixed. [Jan De Laet ]

•       Linux/Mac only: Improved the way in which the program accesses the home directory to read/store password (after accepting license terms) and command history. Before, the program did this by means of a temporary file created in current directory, which could create problems if the user was running TNT in a directory without write permissions. Jan De Laet provided me with more proper code (thanks!), so that keeping track of acceptance of license terms and command-history are now cleaner. [Jan De Laet]

•       A bug introduced in Feb. 2008 (with the faster tree-sorting operations) but discovered only recently: calculating pruned consensus (prunnelsen, or Trees/Comparisons/PrunedTrees) could produce bogus results or output. This happened only when displaying the results, not when simply saving pruned trees to memory. This was because some tree-simplifying operations done when pruning made the trees intractable by the new tree-sorting routines. Fixed.

•       Depending on the set of input trees, reduced the amount of memory needed to calculate SPR differences between large trees (sprdiff). In many cases, the algorithm is also about 30% faster.

•       Last minute fixes to the June version: some of the previous fixes created problems for many character-mapping options under implied weights. The version with this problem was up in the web for about 10 days. If you downloaded it before, and sometimes use implied weightng, make sure you get the replacement version. Also fixed a long standing (but previously undiscovered) bug in calculation of scores under implied weights, for step-matrix characters that were actually equivalent to Fitch characters with weight greater than unity –this led to miscalculations of tree-scores during searches.

•       Mac 64 bits only: fixed a long standing (but previously undiscovered) bug, when printing tables (and possibly other kinds of output) with numbers having decimals (e.g. implied weighting scores, length with continuous characters included).

Fixes/changes to the version of June-August, 2010 (October, 2010):

•       Parallel versions only: fixed problems deciding RAM in slaves in 32-bit versions; better estimation of amount of RAM needed in slave.

•       Parallel versions only: setting number of tree-groups to other than 32 crashed slaves. Fixed now.

•       The command hybrid often crashed the program; now the two trees can be given as a scope (or tree-group).

•       Parallel versions only: improved the behaviour of launching new jobs in clausters with slow communication. Before, launching a job with many tasks for a big data set could overload pvm daemons; the use of communication at that initial stage is now more parsimonious. Also, improved the speed with which slaves can communicate for many tasks.

•       Running under implied weighting some sankoff characters with more than 16 states, or sankoff characters with any number of states on versions with no limit on the number of taxa, produced internal errors (and a message warning about score miscalculation). Fixed now.

•       Large data sets required a lot of RAM to run under implied weighting, most of which was needed for buffering steps under tree-fusing. If the amount of RAM allocated is too low for tree-fusing under implied weighting, tree-fusing is simply disabled, but the rest of the searches can be carried out.

•       Added options for “extended implied weighting.” This allows defining sets of characters with constant weight, sets of characters to be reweighted according to group homoplasy (instead of individually), and different weighting strengths for different characters (including the possibility of taking missing entries into account, extrapolating from homoplasy in observed entries to missing entries). This is a complex option (it took a month of intense programming), so it may have some glitches here or there. See details with “help xpiwe;”.

•       Improved the behaviour of recursive sectorial searches on several fronts (now including, in parallel versions, the possibility of launching slave jobs from within the sectorial search).

•       Last minute fix to the update: SPR differences (after changes introduced june, 2010) typically produced meaningless values when moves needed to produce/resolve polytomies were counted. Fixed now. [ Brian Andres ]

Fixes/changes to the version of October, 2010 (April, 2011):

•       Now all versions (Windows included) write to log file (if open) the version number and date, as well as OS. [ David Maddison ]

•       Added the possibility to save HTU's together with the matrix (by specifying a tree to use for reconstructing the HTU's, see online help for xread).

•       Changed the behavior of the keepall option of the xmult command; now, when doing more than one hit to the best length, keepall retains the trees resulting from the fusing of the initial replications. Together with noupdate, this can be used to save the trees resulting from each set of replications (e.g. xmult = hit 5 noupdate keepall).

•       Now the color of tree-branches in “tree-tags” (ttag command) can be specified (on a branch-per-branch basis) as RGB color codes (in parentheses, separated by commas). You can also specify branch thickness (as a fourth number within the parentheses). This is used when saving tree-diagrams as SVG files in all versions, and in the windows versions (where the branch color/thickness can be changed, when the tree is unlocked, by double right-clicking on the node and entering the RGB color and thickness).

•       Linux/Mac versions: now it is possible to obtain help for each command by typing "command ?” (this used to be available only for Windows versions).

Fixes/changes to the version of April, 2011 (July, 2011):

•       The extrapolator (used for extended implied weighting under user-defined weighting functions, and for the intpol scripting expression) could sometimes freeze (or take a very long time to produce calculations).

•       Windows versions, running under VISTA: there were problems (which I hadn't seen myself, not having a machine with Vista) with reporting progress of searches and time-consuming operations. The program stopped responding, and searches could not be interrupted. This should work now. I have not so far been able to make the “pause” button work properly under Vista, reason for which I hve made it optional (to enable pausing, which works under XP, type “pause[;” at the command line).

•       Added the “!” option of the tcomp command, which calculates the PCR index (Pol & Escapa, 2009) for the specified taxa. This is intended to facilitate calculation of PCR (it is much faster than the original implementation using scripts, and can handle much larger cases). There is also work in progress, in the PCR command, but this is not yet documented.

•       A few cosmetic changes here or there.

Fixes/changes to the version of July, 2011 (August, 2011):

•       Windows only: fixed glitches with the behavior of the new report window, and with the focus after execution of some command (this had been changed with the last version, it now behaves more like before, automatically going back to command line without the need of using the mouse).

•       Added option to extrapolate user-defined weighting functions for weighting-sets (both with a unique concavity, or extrapolating to missing entries).

•       Fixed some minor problems here or there with the interpolator (it had some tendency to freeze or take too long, for some specific curve shapes).

•       There were problems calculating minimum possible numbers of steps for continuous characters with lots of polymorphisms [ Bruno de Medeiros ]

•       The commands for realigning landmark configurations are now more stable, and include the tree-based alignment algorithm by Catalano & Goloboff (in press, Syst. Biol.). Most of the code for aligning landmarks was written by S. Catalano.

Fixes/changes to the version of August, 2011 (September, 2011):

•       A remaining bug (which I had not discovered previously): when there are continuous characters but none is informative, length of uninformative continuous characters is not reported during searches. this affects nothing, really, but it may confuse users.

•       Saving DNA data used to indicate polymorphisms by enclosing the nucletides in square brackets; this made it harder to export data to other programs (such as RaxML). Now, saving DNA data uses the IUPAC codes for polymorphisms.

•       Scripting: the loop command automatically was set to decreasing or increasing, depending only on the initial and ending values. Now, this is done if the increase is not specified; explicitly specifying a negative increase, the loop is now always set as decreasing (and viceversa); thus, loops such as:

loop 0-1 10

loop 10+1 0

will never get executed, only:

loop 0+1 10

loop 10-1 0


•       Fixed occassional problems with running tree-searches with continuous characters (branch-swapping sometimes would never finish). This could be a problem for cases where many searches were done (such as resampling), thus increasing the chances that one of the starting points would lead to this deadlock situation. [ Juan Manuel Dνaz Gσmez ]

•       Windows versions only: After April 2011 (when I switched machine and the version of the Watcom compiler), it became impossible to deactivate taxa, either through menus or commands. Now it works again. [ Mario Cozzuol].

Fixes/changes to the version of September, 2011 (December, 2011):

•       Added the options to handle taxonomy (taxonomy command, Trees/Taxonomy). In addition to the documentation for taxonomy itself, there are related entries under copytree (how to make the tag-tree into a taxonomy), taxname (how to make taxonomic changes, transferring or synonymizing groups), and outgroup/reroot (how to make use of taxonomic information to define tree-rooting). In connection to the possibility of making tag-tree into a taxonomy, also added the option to edit tree-tags under Windows. Creating new categories with taxname is possible, but tricky. Here is how. Assume Barychelidae, Theraphosidae, and Paratropididae are families of Mygalomorphae, and you want to create a new category, Theraphosoidina, to which these three families belong. This needs two steps, one to make a new group Theraphosoidina (at the root of the taxonomy), the other to make that new new group part of Mygalomorphae:

taxname : :Barychelidae :Theraphosidae :Paratropididae =Theraphosoidina = Mygalomorphae ;

taxname : :Theraphosoidina =Mygalomorphae >Theraphosoidina ;

•       The xread[ option did not randomize character sequence (as it was supossed to). Now it does. [ Mark Siddall ]

•       Added the rcompl command (see help rcompl;).

•       Added the option to read taxon names (in multi-block matrices) with a triple-dot ending, which is interpreted as “set all previously defined taxa which this name matches”.

•       Greatly speeded up the writing of multiple tags for trees with many taxa (writing the first label was ok, but relocating the corresponding nodes for subsequent writes used lousy code; a much better code is used now).

Fixes/changes to the version of December, 2011 (February, 2012):

•       Added to the sort command the possibility of sorting trees by number of nodes, taxa, or number of constraint groups for monophyly requirements are violated.

•       Windows only: improved the way in which tree-width is handled when trees are plotted fitting the screen (with the “F” option in the tree pre-viewing screen).

•       Greatly improved the speed for sorting, when there are very large numbers of trees to be sorted and they have many different categories (e.g. in trees for large data sets under implied weighting).

•       Generating all trees (possible only for low numbers of taxa) when some taxa were deactivated created bogus trees; attempting to subsequently plot or optimize them, crashed the program.

Fixes/changes to the version of February, 2012 (March, 2012):

•       Improved bounding for Fitch/Farris characters (under prior weights) in exact solutions (ienum command). This makes execution significantly faster for larger data sets (i.e. 14 or more taxa) with good structure; it does not make much of a difference for smaller and noisy data sets. In case you want to compare, the previous implementation is retained as the "ienum-" option (available only via commands).

•       Documented the pcrprune command, which implements Pol and Escapa's (2009) iterative PCR nethod. Also, fixed some bugs in this command (which are unlikely to have affected anybody, since the command itself was undocumented. [ Diego Pol ]

•       Added the forfiles scripting command, and thus also the expressions curwd, curfile, and curisdir.

•       Added the bandb scritping command, and thus also the expressions bbtax and bbfull.

•       Windows only: made further improvements to tree displaying when fitting to screen.

•       Scripting: defining a default target for goto did not work when the error occured inside sprit, tbrit, combine, or iterrecs command. It should work always now.

•       The help for the expression distnode listed it as "distnod"; the correct name is used now. [ Martνn Ramνrez ]

Fixes/changes to the version of March, 2012 (May, 2012):

•       improved speed of pcrprune for many taxa; added [N] and >N options to pcrprune.

•       added untouchables to the commands prunnelsen and pruncom.

•       64-bit versions (Linux and Mac) had a problem with accessing arguments to scripts; this only surfaced with mxproc 25 or more, but it could well have caused problems in other cases as well.

Fixes/changes to the version of May, 2012 (Sept., 2012):

•       Windows only: the “var +” option (to plot variables in a graph) had problems saving graphs where the X and Y axes had very different maxima.

•       Fixed some problems with macro expressions minval, maxval, and meanval.

•       Runnig autoconstrained ratchet within an autoconstrained driven search, or running an autoconstrained drift within an autoconstrained driven search using ratchet (of any kind) produced either bogus results or crashed the program. Fixed now. [ Βngelo P. Pinto ]

•       Running autoconstrained ratchet or drifting from within a non-autoconstrained driven search crashed the program.

•       Random sectorial searches selecting sectors of size 3 (or probably less) was allowed, but produced bogus results. This sector size is, in any event, not very meaningful. The program now issues an error message if you attempt to set minimum sector size to less than 5. [ Βngelo P. Pinto ]

Fixes/changes to the version of Sept. 2012 (Nov. 2012)

•       The extended implied weighting (xpiwe option) had problems when different concavities were used for different characters, but some characters were left with no concavity specified. This was supossed to leave those unspecified characters with the default concavity, but it didn't, and thus searches and score calculations were bogus. [ James Carpenter ]

•       Saving the data and character settings for active characters only (either with “xread -*” or with Data/SaveData) produced an erroneous list of character names when some active characters had not been named (it was ok when all characters had names). Fixed.

•       Scripting: Fixed the expressions taxinblock and nummissing, so that now they properly take into account landmark characters (they didn't before).

Fixes/changes to the version of Nov. 2012 (Jan. 2013)

•       The interpolator used to calculate weights fro fractional numbers of steps (when a user weighting function was used under extended implied weights) had a problem. It made many more straight lines than it should have (there was an error checking whether a segment is curved; it always concluded “no”). This may have been a problem for analyses with xpiwe= under user-defined weighting functions.

•       When the outgroup had a missing entry for a landmark character, and the first subsequent tree split involved a terminal taxon also with a missing entry, the coordinates for the first two (most basal) tree nodes were bogus. Fixed.

•       There were some problems with impwtlist expression, sometimes causing crashes. Fixed.

Fixes/changes to the version of Jan. 2013 (May 2013):

•       The double-line option of tplot+ did not work when some shrinks were defined (with thsrink). Now it does.

•       The tshrink command could not properly read names of shrinks to activate/deactivate/undefine (the name of the group was expected to be a truncation of the name given in the list; it is now the other way around, as expected). Also, shrink number 0 could not be referred to by name; now it can.

•       When doing multiple RAS the program checked whether a tree existed in memory before, but without considering score –thus, under rule 1, two different binary trees with different score might collapse to the same one, and this wasn't considered during mult (only at the end). Then, if trees A and B collapse to the same tree, but A has worse score than B and A is found first, and B is the best tree of all replications, A would have been stored and B would not --thus, mult found "no trees", because B --the best tree-- was never stored, and A was dumped at the end because it wasn't of the best score. Uncommon, but possible. Fixed now.

•       Fixed bugs when using positive constraints with floating taxa. When the constraints could not be obeyed at the same, searches could have delivered trees not obeying constraints, instead of reporting an error.

•       There was a bug in calculations under self-weighted optimization. This surfaced only under 64-bit Linux versions, but it is conceivable that the bad code could have caused problems in other versions as well. In the example for 64-bit versions, the program crashed when attempting to calculate score, but in other cases it could well have produced erratic/unexpected results. Fixed now. [ Marcos Mirande ]

•       If tree tags exist, now they are also saved in Nexus format. Thus, for example, to save group supports as Nexus, you would have to type:

ttag=; resample; taxname=; export – nexusfile.tre ;

•       Added the “combined bremer supports” to the bsupport command (“&” option). This combines absolute and relative bremer supports, in such a way that the results of jackknifing are approximated, in the case of simple data sets. The combination is (Q.R)1/A , where Q = 1 – P(del), R = relative support, and A = absolute support.

•       Now it is possible to consider only trees within the absolute support, when calculating the relative bremer supports via TBR.

Fixes/changes to the version of May 2013 (Sept 2013):

•       A bug introduced in March 2012, with the new bounding for exact solutions: a driven New Tech search (xmult command) right after an exact solution with the new (=default) bounding method produced erroneous results. This could be avoided by using the older method for exact solutions (ienum–) or by issuing a length command before doing the New Tech Search. This only arose in the very unlikely scenario that you wanted to do both an exact and a New Tech search for a data set. Annoying, nonetheless. Fixed now. [ Douglas Ribeiro ]

•       The option to save colored trees as SVG files with user-defined (RGB) color codes for some branches did not work. Fixed now. [ Martνn Ramνrez ]

•       The heuristic aligner for landmark data produced an error when some taxa were missing from some block. Fixed.

•       Mapping landmark data had problems when the outgroup had a missing state.

•       The alignment on a tree could not handle configurations with missing entries, but instead of producing a warning and error message, it crashed the program. A warning is issued now.

•       A bug in all 32-bit versions (Windows, Mac, and Linux): bootstrapping data sets with more than 32,767 characters never selected any character beyond number 32,767. Thus, the resampled matrices had a non-random sample of characters for more than 32,767 original characters. This affected only the standard bootstrapping (not the Poisson). [ Mark Simmons ]

•       Before, the scripting expression getrandom returned a random number between 0 and 32,767, even if the upper limit of the interval was much larger. Now, it properly returns values up to much larger numbers.

Fixes/changes to the version of Sept. 2013 (Nov. 2013):

•       The pfijo command could crash when chunksize was too large and data set too small (which could occur often, since the default chunksize is 500). Fixed it.

•       The pfijo command reported the wrong score at the end of the search. The problem was only in report produced by command: it was always the score of the last tree, which is not necessarily the best tree overall.

•       Windows only: optimizing synapomorphies on branches (under tree-view mode) when extended implied weighting was ON crashed TNT. It works now. [ Marcos Mirande ]

•       Hybrid command: adding the missing taxa to an incomplete tree using a randomized insertion sequence (rseed[ option) crashed the program. It works now.

•       Agreement subtrees: there were problems saving to memory agreement subtrees for source trees that were pruned of some taxa. These could have caused crashes or errors. Also, the taxa missing from all the trees were placed at the base of the agreement subtrees, which (for scripts or things like that) required pruning them. The taxa missing from all trees are now handled more gracefully.

•       Parallel versions only: for landmark data, realigning configurations in the slaves caused crashes (it worked ok on the master, or when the data had been directly read by the slave instead of transferred to it from the master).

•       The scripting expressions length, score, fit, homo (and related ones), could miscalculate tree-scores if invoked right after a search had been done. Fixed.

•       Selecting random elements in agroup, tgroup, and xgroup commands (as well as the hgroup command, under Linux/Mac) did not work properly; the same was true of true of the GUI interface of those commands (under Windows). This works ok now.

•       A minor glitch: when a replication with multiple random addition sequences produced one of the preexisting tree with the Wagner tree (i.e. no need to swap the tree), the score and number of hits to minimum length reported were incorrect. They are correct now.

•       Added the ras (=default), mas, fas, ias, and sas options to the mult and xmult commands. This serves to determine fine details of the addition sequence for the Wagner trees. Also, it is now possible to randomize the outgroup in Wagner trees (before, outgroup was always the first taxon to add to the tree), with the rseed > option (rseed < sets it back to the default, with outgroup not randomized).

Fixes/changes to the version of Nov. 2013 (Feb. 2014):

•       The option to save tree-tags in Nexus format did not save labels for the terminals [ Thomas Halliday ]. Now it does, and it can also optionally save tags as branch-lengths (instead of labels).

•       Added the hybridize option to the tfuse command. This is useful for obtaining better trees from sets of trees, in the case of very poorly structured data sets (e.g. random data sets), in which standard tree-fusing fails to produce improvement because no groups can be exchanged (two independently found trees are unlikely to share any groups). It uses the same criterion for exchanging grups as in the hybrid command, but it repeats exchanges many times. See details with help tfuse. Keep in mind that more trees than used for fusing should be input to hybridization, and it also needs memory space to create many more trees –e.g. you should be careful to set hold to a lrge number before running this command.

•       Added a new command, rebuild. This is a perturbate-and-search-again algorithm, where the perturbation is given by pruning some taxa (terminals or not) from a tree, reinserting them back at the remaining subtree (as in a Wagner tree), and then doing TBR. Repeating this many times works very well for poorly structured data sets (e.g. random data sets), for which the other search routines don't always work well. See details with help rebuild.

•       Added the option to use rebuilding and hybridization in combination with the xmult command. The new xmult options are hybrid, rebuild, and picktype.

•       Documented the hold option of the xmult command. It's been there since 2004, but I had forgot to document it. Now it's documented! This makes a difference only when ratchet, drift, or (now) rebuild are used. Very rarely needed anyway.

•       Added the option to randomize the clipping sequence during branch-swapping. Before, TNT always cut the branches to swap in a fixed sequence. With the randclip option of the bbreak command, now the swapping sequence is randomized with a different sequence for each tree to be swapped. This produces much better results than the standard when saving suboptimal trees for data sets where there are multiple islands with few trees each, facilitating the jump from one island to the next with lower values of suboptimal.

•       A few really minor changes here or there.

Fixes/changes to the version of Feb. 2014 (April 21, 2014):

•       Only a minor change: a glitch when saving subptimal trees, and initially swapping from trees that led to better trees, may have produced freezes. This shouldn't happen now.

Fixes/changes to the version of April 2014 (May, 2014):

•       An important fix: a bug probably introduced with the Feb. 2014 version, sectorial searches using tree-drifting (usually done for larger tree sectors) reported bogus best scores, impossibly low (the problem apparently was only in the reporting, but it was very disconcerting nonetheless). Fixed, I think.

Fixes/changes to the version of May, 2014 (October, 2014):

•       Counting specific character-state transformations (with the command change, or Optimize/CountSpecificChanges) produced the wrong results for characters with 32 states (2 to 31 were okay).  Fixed now.  [ Daniel Janies ]

•       Improved the way in which untouchables are handled in the commands pcrprune, prunnelsen, and pruncom.

•       Fixed some glitches with the pcrprune command, and added the !! option to the tcomp command, to calculate the Leaf Stability Index of Thorley and Wilkinson (1999).

•       The command iterrecs had problems with continuous characters with ranges in some terminals (which are indeed expected to occur).  Fixed now.

•       A few really minor cosmetic changes here or there.

Fixes/changes to the version of October, 2014 (December, 2014):

•       Added the “&” option to the tcomp! and pcrprune commands.

•       Changed the option to calculate Robinson-Foulds distances (in the tcomp command) to < instead of [ (the [ symbol was already used for displaying compatible groups only).

Fixes/changes to the version of December, 2014 (February, 2015):

•       The command pruncom (Trees/Comparisons/PrunedTrees, selecting combinable components) had problems in some cases (miscalculations or crashes).  Fixed.

•       Symmetric step-matrix characters that could be converted into Fitch characters for optimization (to save time during tree searches) could be treated inconsistently under standard implied weights. Consider the case of costs between A-T defined as 2 and a tree where the character can be optimized to imply 4 steps.  Recoding the character as Fitch (with only states AT) produces only 2 steps and the same fit [ k / ( 2+k ) ] as the Sankoff character [fit calculated as k / ( (4/2) + k ) ].  However, if the cost between AG and GT is defined as 1 and G is not present in the matrix, the steps under equal weights as Fitch or Sankoff are the same, but under the default treatment for Sankoff characters, the minimum transformation cost for that character is 1, so that the fit under implied weights is k/(4+k) instead of k/((4/2)+k). Thus, to have Sankoff characters handled always in the same way, the program was changed to not recode any Sankoff characters as Fitch when running under implied weights.

•       There was a problem eliminating some uninformative Sankoff characters under implied weights, which could produce internal errors during SPR or TBR. Fixed.  [ Mark Wilkinson ]

•       Added the possibility to save to taxon groups the taxa pruned with the commands prunnelsen and pruncom.

•       Added the “= =” option to the tcomp command.  This calculates a symmetric measure of tree difference, based on the distortion coefficient of Farris (1972). Define Gi and Mi as the maximum and minimum possible number of steps for the MRP matrix representing tree i, and Sij as the number of steps of the MRP matrix representing tree i when mapped onto tree j. Then, a measure of tree difference analogous to the distortion coefficient, but symmetric, is obtained with ( Gi + Gj – Si – Sj ) /  ( Gi + Gj – Mi – Mj ).  Also added, correspondingly, the symcoeff expression to the scripting language.

•       Added the “:” option to the tcomp command.  This uses the measure of group similarity (implemented in the commands prunmajor and rfreqs) to calculate tree similarity.  This works analogously to the Robinson-Foulds distance, but measuring group presence/absence by degrees.  Note that the parameters to measure group recovery (e.g. maximum percentage of taxa that can be excluded from a group) are set with the prunmajor command, and by setting this to extreme values (e.g. maximum percentage of taxa that can be excluded from a group set to 0) the measure approximmates the behaviour of the Robinson-Foulds distance.  With the default parameters, the measure of tree similarity is not affected as strongly as the Robinson-Foulds distance by a few floating taxa moving on an otherwise similar tree skeleton.  Also added, correspondingly, the grpdist expression to the scripting language.

•       Added the “*” option to the alltrees command.  This generates all possible rooted tree shapes (or as many shapes as can be held in the tree buffer). 

Fixes/changes to the version of February, 2015 (March, 2015):

•       Windows only: in dialogs to select (taxa, characters, trees), it is now possible to specify several numbers, or a range (two numbers separated by a dash).

•       The option to use string matching for command options could crash the program if set before reading data.  Fixed.

•       For comparability with PAUP*, added the option to do TBR but only moving (or rerooting) the clipped clade no more than N nodes away from the original, with the limit N option of the bbreak command.  With this (and for a fixed N), the number of rearrangements increases about lineally with number of taxa –i.e. this examines only a tiny subset of all possible TBR rearrangements (which increase with T3). For large data sets, it is thus a lot faster than the default (nolimit), but also produces results of much lower quality and therefore should be used very sparingly and only under exceptional circumstances.  In addition, the efficiency with which rearrangements can be examined decreases as the neighborhood is decreased (cf. Goloboff, 2015, Cladistics 31, p. 214, who shows that this behaviour occurs in both TNT and PAUP*), further advising against using limited neighborhoods.  The main reason to include this option is to allow comparisons with the “reconlimit” option of PAUP*.

•       Added the option to collapse branches in the tag tree based on whether (numerical) label is smaller or larger than a certain specified value, with the condense command.

•       Added the len, homo, score, min, and max, to the command xgroup, so that you can define groups of characters based on their fit to trees. See help xgroup.

Fixes/changes to the version of March, 2015 (June, 2015):

•       The command iterrecs with the option of saving to arrays only increments had problems. Fixed. [ Jorge Flores ]

•       Added the “!” and “!!” options to the taxonomy command (and to the Windows dialogs).  This produces a verbose description of the differences between the reference taxonomy and a given tree.  For the time being, it is somewhat experimental; use with caution and re-confirm results and descriptions by looking at the actual trees!

•       Windows only: added IterPCR as an option to the dialogs (under Trees/Comparisons).

Fixes/changes to the version of June, 2015 (November, 2015) – This is a beta for version 1.5.  For this version, Santiago Catalano provided code for calculation of four–point Steiner trees (about 5% of the new code incorporated into the program, used for the initial evaluation of rearrangements during branch swapping); all the rest, as usual, by Yours Truly.

•       The main change is the incorporation of landmark data to all the commands, including commands for searches (except exact searches or the pfijo command), score calculation, tree diagnosis, etc.  Landmark data used to require (since early 2009) the use of special scripts; landmark and one-dimensional characters had to be handled separately, and most commands included neither an evaluation of landmark data nor error messages to warn the user that not all data were being considered; landmark data now require no special precautions on the part of the user –all commands transparently incorporate them, or issue an error message.  In general, for data sets of T taxa comprising only landmarks, searches are now between 2T and 3T times faster than they were when using scripts, in practice making it possible to analyze landmark data for up to a few hundred taxa on personal computers.  For searches mixing landmark and discrete characters, the speed difference may be even more drammatic.

•       As a result of the previous, changes were introduced in a number of commands: mult, xmult , bbreak, tfuse, hybrid, drift, ratchet, sectsch, score, cscore, chomo, minmax, lmark, blength, apo, xread, chkmoves, bsupport, resample, xpiwe, all the commands that find unsupported branches, and several macro expressions. All the menu options that invoke those commands were also modified. 

•       Added the command lmbox, to save diagrams of reconstructed landmark configurations as SVG files (easily viewed with any web browser, and easily exported into jpg or tiff format).

•       Fixed a number of existing bugs, specially in landmark data.  The most serious ones were miscalculations of the minimum for implied weights (we have now also added the possibility of evaluating the minimum more accurately than with the Steiner for the largest triplet of taxa), potential floating point errors in iterative improvement of point positions, and crashes or miscalculations during realignment with several of the methods available in TNT.

•       TNT now reads data sets with continuous characters in any scale –if some value(s) exceed the maximum of 65.000, the character is automatically rescaled to 0 – 65.  TNT can now also automatically standardize continuous characters, with the stand option of the nstates command (see help nstates).

•       Windows only: added dialog for extended implied weighting (under Settings/ImpliedWeighing).  Note that this becomes available only if implied weights was ON at the moment of reading the data set.  Added a dialog for the chkmoves command (under Trees/SwapAndReportMoves), which helps identifying unstable taxa.  Modified the dialogs for landmark data (and added a dialog which controls options for branch swapping with landmarks).

Fixes/changes to the version of Nov. 2015 (Feb. 2016):

•        Fixed several issues with the recently added options for landmarks; improved handling of error margins during searches. 

Fixes/changes to the version of Feb. 2016 (August 2016). 

•       This is no longer a beta for version 1.5.  It's been tested in the last months and seems stable; no big changes anticipated for a while (unless serious bugs surface unexpectedly).

•       If using this version, you should cite the paper in Cladistics (Goloboff & Catalano 2016 DOI 10.1111/cla.12160).

•       Fixed a small bug with rescaling continuous characters (problems arose when the minimum for some character was greater than zero). 

•       Added the matchtax command, for finding equivalent taxa in two trees.  This implements methods described in a ms. in preparation (by Goloboff, Arias, and Szumik).  See help matchtax for brief discussion.

•       Changed the way in which the error margin for landmark searches is handled, allowing a more precise tuning.

•       The option to save landmark coords as a TPS file (export | option)  did not work; it does now.

•       Saving of branch lengths and legends for Nexus improved.   It worked only under some circumstances.  It should be general now.

•       Branch lengths for landmark data did not take into account the weights for individual landmarks or configurations (only the weights defined with ccode took effect).

•       The plus/minus symbol was represented with ASCII 241.  In newer versions of Windows, ASCII 177 is displayed in the same way.  Thus, TNT now recognizes both 241 and 177 as the plus/minus symbol.

Fixes/changes to the version of August 2016 (November 2016):

•       Fixed some glitches with the recently added command matchtax.

Fixes/changes to the version of November 2016 (March 2017):

•       Using commands, taxonomic groups could be colored only for specified groups; there was no easy way to color all groups.  Now, if no group is specified, all groups are colored (before, this would have displayed a tree with no colors).

•       The option to verbosely describe taxonomy (taxonomy !) could have freezes.  Fixed.

Fixes/changes to the version of March 2017 (April 2017, Hong Kong version):

•       Windows version: added the option to save tree-tags as SVG from the menus (Trees/MultipleTags/ExportTagsAsSVG), either in black-and-white or color.  Of course, this requires that tree-tags have been stored already.

•       Changed the way in which branches are colored (either under Windows, or metafiles, or saving trees in color as SVG files).  Before, the vertical line leading to a split of two descendants was colored as the ancestor; now, the upper branch is colored as the first descendant, the lower branch as the second.  Color diagrams look better this way.  Branchings of 3 or more descendants are colored as before.

•       Added the "italics" and ""bitalics" option for saving tagged trees (ttag & option).   See help ttag for details.

•       Fixed some potential crashes with mapping synapomorphies common to several trees when extended implied weighting was in effect.

•       When importing TPS files (with the dmerge command, or the File/MergeImportData/TPSFiles), the number "9999" is now read as a missing entry (this caused improper translations before).

•       Added the double "*" option to the taxonomy command (to label tree-branches, but without using statistics).

•       The piwe scripting expression (which had just a 0/1 value) now returns values that indicate the type of weighting in effect (0 no weight; 1 standard implied weighting; 2 auto-weighted optimization; 3 extended implied weightins with no weighting-sets; 4 same, with weighting sets).

•       Added the prupdn command.  This enumerates combinations of possible prunings (from a taxon-group), and uses an optimality criterion to select the best, itertiavely.  The best sets are written to an output taxon group.  See help prupdn for details.

•       The resols command crashed when using only a subset of the trees in RAM.

•       Added the option to save trees with different resolutions to taxon-groups, for the resols command (valid only when resolutions for a single node requested).  This is useful for subsequent manipulation of the trees displaying each of the resolutions.

•       Automatic rescaling of continuous characters to fit the 0-65 range did not work when the first taxon (or taxa) in the matrix had missing entries.  Fixed.

•       Command xcomp: now it is possible to save to character-groups the characters with better/worse fit, for subsequent manipulation with scripts.

•       The rooting using a taxonomic outgroup may have caused problems in some cases; this uses safer code now.

•       The untouchable taxa for the prunnelsen command were sometimes improperly handled.  They are OK now.

•       The commands that draw reduced trees (e.g. prunnelsen, resols) caused problems when tree-tags were ON, because tags can be written only to trees with identical taxon sets (which the reduced trees don't have!).  For those commands, tag-storing is now temporarily deactivated when draing the reduced tree, so that the command can be run also when storing tree-tags.

•       Added the kleex command, which calculates maximal cliques, with a fast implementation of the Bron-Kerbosch's algorithm, written by J.S.Farris.  This serves to compare results, e.g. with TNT's search algorithms for a user-defined weighting function with cost 0 for all numbers of transformations but the first.

•       Added the option to store downpass (instead of uppass) states with the macro expression states.  For this, precede the number of node with a colon (:).

Fixes/changes to the version of April 2017, Hong Kong version (June 2017):

•       Added the possibility to display synapomorphies with character names on tree branches (putting every synapomorphy in a new line), for the synapomorphies in common to a set of trees.  These are the apo ] (to list  character names only) and apo >  options (to also add state information).  In Windows versions, this is  done with Optimize/Synapomorphies/TextListsOnConsensus.

•       It is now possible to print multiline labels in grahic trees (SVG, EMF) so that the tags are either centered/above/below branches.  It is also possible to truncate width of messages in multiline tags, with ttag[N.

•       Added the ttag ! option, to erase blank-lines in multilag messages (these can be created by commands that produce output for some branches but not for others).

•       Reading long tree tags (specifically, tags over 42 characters) from parenthetical trees caused problems. [ found and fixed by Santi Catalano ].

•       Displaying strict consensus trees placing floater taxa could cause problems when the location for some taxa eliminated from the consensus was not being indicated on the tree.

•       Windows only: The branch lengths for long legends are now calculated more accurately (specially for non-proportional fonts). 

•       Added a cutoff option to the prupdn command (the "&" option); cut=100 improves strict-consensus (and it may be faster than for lower cutoffs, because then it can make aditional assumptions).

•       There was a bug in the prupdn command, so that in down mode with separators, it could miss some improvements.  Fixed now.

•       Added the possibility to use separators for the "up" mode of the prupdn command (these were formerly available only for the "down" mode).  See help prupdn for usage.

•       Added the sort option (i.e. set !) to the set command.  I thought it was already there.

•       The scripting option set * (to operate on whole arrays) worked ok in simple cases (e.g. two one-dimensional arrays), but had problems when the two arrays had different dimensions.  Hopefully fixed now.

Fixes/changes to the version of June 2017 (July 4, 2017,  Independence Day version):

•       Added the possibility to display values of continuous characters in the original scale, with the nstates[ option (see help nstates).  This only affects the commands apo, map, and xread (saving data).  It does not affect the iterrecs command (it returns always the scale stored internally, which must be rescaled to the original by the user, with the contscale expression).

•       Added scripting expressions contscale, contmin, and contmax.  See help+.

•       Fixed problems with the contmins and contmaxs expressions (they both returned maximum).

•       Added the logten scripting expression (for log base 10).

Fixes/changes to the version of July, 2017 (October 2017)

•       Interrupting resampling before any trees had been calculated would crash the program.  This is handled more gracefully now.

•       There were problems with datasets mixing landmarks and one-dimensional characters, when some landmark characters were deactivated (e.g. under resampling with the confsample option).  Working ok now. [ Andrew Jones]

•       Pruning taxa from the tag tree (pruntax * option) had problems when pruning more than a few taxa.  Fixed now.

•       Branch-swapping searches for matrices containing continuous characters had problems when saving a single tree (i.e. some better trees may have been missed).

•       Three-dimensional landmarks with missing entry in both the outgroup taxon, and the next sister group as a terminal taxon, caused wrong score calculations.

•       Windows only: displaying the text buffer when the text was too wide caused problems (printing nothing to screen for those lines).  Lines are now truncated on display.

•       Windows only: the dialog box for New Tech Searches always attemped to set parameters for sectorial searches (even if sectorial searches were not to be done).  This could cause problems in small datasets (e.g. 10 or fewer taxa) where sectorial searches are not applicable.

•       Windows only: added a dialog for the prupdn and prunmajor commands (in Trees/Comparisons/OptimizePrunsets and Trees/Comparisons/QuickHeuristic).

•       Now, it is possible to display continuous characters in the original scale even after standardizing.

•       Incomplete trees caused problems with pcrprune command (i.e. Trees/Comparisons/IterPCR).

•       The resols command (Trees/Comparisons/ShowResolutions) would choke on trees producing a consensus with a basal polytomy (an unexpected situation anyway).  In that case, an error message is displayed now (instead of a crash or freeze).

•       The rebuild command (default options) had problems when setting the number of trees to about the same as the "sample" size.  It should be ok now (displaying an appropriate error message if max. trees is set too low).

•       Landmarks with only missing entries would crash the program.  They're just ignored now. [ Santi Catalano ]

•       Setting the number of characters too low when reading landmark data using pipes ("|") to separate characters could crash the program.  Fixed now. [Santi Catalano ]

•       The ancestral states (lmark show option) for landmarks with only missing entries were not displayed improperly or not at all. [ Sati Catalano ]

•       The absincl command stopped being recognized in previous versions (probably it was inadvertently eliminated in some earlier update).  In place again.

Fixes/changes to the version of October 2017 (November, 2017)

•       Added the "&" option to the xread command (to easily generate data with the exponential "model" of Goloboff et al., 2017).

•       Fixed some problems with calculations of combined Bremer supports.

•       Windows only: Added a few options for finding wildcard taxa to the GUI.  These call the commands pcrprune (via Trees/Comparisons/PrunedTrees), prunmaj (via  Trees/Comparisons/QuickPruningHeuristic), and the recently added prupdn (via Trees/Comparisons/OptimizePrunsets).  See documentation of the respective commands for details of how each operates.

Fixes/changes to the version of Nov. 2017 (December 2017):

•                   It is now possible to read Nexus files even when macros are ON. 

•       Improved the reading of branch lengths from Nexus tree files.

•       The report for scales and weights in landmark data had problems when the matrix also contained one-dimensional characters.

•       The sort command worked ok when sorting all trees in memory, but had unpredictable results (including crashes) when sorting only a list of trees.  Now, the command always sort all trees in memory (no longer admitting a list of trees to sort). [ Ana Andruchow ]

•       Linux/Mac versions only: in slaves, it is now possible to use the goto command to go to specific labeled points in the set of instructions received from master.  The file name for goto should be substituted with "myself".  The labels should be placed after a proc/; command.  This allows writing more structured instructions for the slaves.

Fixes/changes to the version of Dec. 2017 (May 2018):

•       Running asymmetric sankoff characters with ancestral states caused crashes when using more than 16 states or in the no-taxon-limit versions.

•       Now it is possible to save plots of user variables (var+ option) to SVG files.  See help for var command.

•       The placement of trees in automatic tree groups now restarts again from 0 if reading a new dataset.

•       The xcomp= option produced crashes under extended implied weighting with multiple concavities.

•       Added the varsize expression to the scripting language.

•       The setarray command did not work properly if setting only part of a multi-dimensional array.

•       Added the possiblity to parse parentheses in Nexus files, in addition to braces.

•       The pairlin option of the lmreal command had problems when aligning multiple landmark configurations. [ Fixed --this is code by S. Catalano ]

•       Windows only: Other minor fixes for displaying landmark configurations on screen.

•       The lmark swap command had problems when landmark configurations had some missing entries.

•       Added the = option to the return command for scripts.  This retains in memory variables declared in the returning script.  If they need to be subsequently freed, they must be freed from one of the scripts calling the one that exits without freeing memory.

Fixes/changes to the version of May 2018 (Sept. 2018):

•       Landmark data in 2D and 3D had to be read in in different blocks, but redefining blocks such that 2D and 3D landmarks were in the same block, and saving data (e.g. with xread*) placed the 2D and 3D landmark in the same block (with a header indicating the dimensions of the first landmark in the block), separated by the pipe symbol, and thus made these data unreadable.

•       There were potential problems using searched user defined minima for landmarks.

•       With the xread- option, inactive landmark configurations were saved anyway (instead of being skipped).

•       Attempting to run the kleex command with continuous/landmark data crashed the program (it was supossed to invoke an error message).

Fixes changes to the version of Sept. 2018 (November 2018):

•       Merging TPS datasets could have problems with end of files. Fixed.

•       Added the scripting expressions mplik, smplik, implik, simplik, and mklik. These calculate likelihood scores, using different approximations to equal weights or implied weights parsimony (Goloboff and Arias, in prep.).

Fixes/changes to the version of Nov. 2018 (February 2019):

•       Added a command for comparing (and merging) two datasets, the dcomp command.  In the Windows version, this is available under File/MergeImport/PairwiseComparison.  This command represents the work of several months.  See help dcomp for details.  As a result, also added the scripting expression dcomp (for which, see help + dcomp).

•       Fixed potential problems with Bremer support calculation by means of TBR-swapping when some taxa had been deactivated.

•       Improved the positioning of multiline labels in graphic trees (EMF or SVG).

•       Making some characters as character state trees, and then back into non-sankoff (additive or nonadditive) caused problems with subsequent searches.

Fixes/changes to the version of Feb. 2019 (March 2019):

•       Minor fixes and improvements of the dcomp command.

Fixes/changes to the version of March 2019 (May 2019):

•       Added the option to normalize Robinson-Foulds distances between trees with number of groups in trees being compared, instead of 2T – 3 (for unrooted comparison) or 2T – 2 (for rooted).  As proposed by Smith (2019,, this produces a distance of 1 to a complete bush (instead of 0.5); partial polytomies are preferred to incorrect resolution.  This is now available as an option of the tcomp command, and with the rfdistp or rrfdistp scripting expressions.

•       Added the option to calculate automatically the value of suboptimal needed to collapse all groups with TBR collapsing (needed, e.g., for calculating bremer supports via TBR), with subopt:T or bsupport:T.

•       Improved the interpolator (intpol scripting expression).

•       Added the xread < option, to generate datasets with all branch lengths equal (and differing among characters, with a uniform distribution of branch lengths, taken from the interval provided by the user). See help xread.

•       Improved the reporting of matrix differences in the dcomp command.

•       Almost trivial: running the bandb command without having read a dataset crashed the program.  The command requires (duhh!!) that a dataset has been read, but no checking was done before.  Now, running bandb without a dataset in memory triggers an error message, not a crash.

•       Under some circumstances, the bsupport command could display values (or legends) in the terminal branches. Fixed.

•       Added a “tree-vault” option, to protect trees from subsequent tree-searching commands.  In this way, trees can be saved to the internal vault, then retrieved into the normal tree buffer.  Both the tree and their group membership (if any) are saved to / retrieved from the vault.  This could formerly be done only by saving trees to disk. The vault is set with hold M / V (which sets memory space to M trees, and a vault to contain up to V trees).  The trees are placed in (retrieved from) the vault with tvault. Also added the vtrees scripting expression. 

•       Parallel versions: there were problems defining groups of slaves (ptnt hgroup option). Fixed.

Fixes/Changes to the version of May 2019 (July 2019):

•       A major addition: in all the command-driven versions, it is now possible to interpret C-style scripts, allowing calls to TNT and access to TNT internal variables. This uses the C-interpreter from "PicoC":

      © 2009–2011 Zik Saleeba,

      © 2015 Joseph Poirier,

A lot of added functionality concerns specifics of phylogeny and connection with TNT.  With this, people used to writing C code can make use of TNT, without the need to learning the details and syntax structure of TNT’s scripting language (some basic knowledge of TNT standard commands is required, however). The work for this was done in collaboration with Martin E. Morales.  The interpreter has most of C’s functionality (with a few exceptions: no pointers to functions can be defined, there is no way to define variadic functions, and the only way to have your code in multiple source files is with #include directives). This is implemented in the runc command (see help+runc for usage options).  The command runc takes a filename as first argument, and any subsequent arguments (until a semicolon is found) are passed to the script (via the standard argc and argv).  Fragments of C-code can also be embedded within TNT-style scripts. All the main libraries (stdlib, stdio, math, ctype, string, time, and unistd) are included automatically when running the C script, so all those library functions are available without the need to #include them. Other preprocessor directives (e.g. #include, #define, #ifdef) work normally.  Note that the return value from main() cannot be accessed by TNT upon return from the C-script; using instead exit() (from any point in the script) sets the value of exstatus (the TNT scripting expression).  Interaction between C and TNT’s scripting language is possible, for example, having a TNT script invoking execution of a C-script with the runc command, e.g.:


            loop 1 100 runc C-script.c #1; stop


or vice-versa, having a C-script invoking execution of a TNT script with the run command, via the tnt() function (which passes a string of commands to TNT), e.g.:


       for ( i = 1 ; i <= 100 ; ++ i )

           tnt ( “run %i” , i ) ;


Any memory dynamically allocated during execution of the C-script with malloc() (or modified with calloc(), realloc(), or free()) is internally handled by their namesakes (from stdlib).  By default, TNT keeps tracks of all the memory allocated dynamically by the script, and automatically frees it after the C script or block finishes (up to 5,000 simultaneous memory allocations can be handled by default; this number can be changed with the runc command). This makes it unnecessary to explicitly free() the memory at the end of the C-script or block.  Although this does not prevent memory fragmentation (e.g. resulting from repeated calls to malloc() and free()), it minimizes the risk of memory leaks in C-scripts executed repeatedly.

We have been developing this for 2 full months, and have tested as much as we could all the new options.  As with any new, complex code, there may be bugs or unexpected problems; please report them to me.  The file, distributed with the TNT package for all versions, contains an example of mixed code, TNT and C, in the file “” (to run as a TNT script). 


•       Added the stddev scripting expression (to easily calculate standard deviation for a number of values).

•       Added the + – (plus/minus) option to the var command (see help var).  This only prints lines and exits; it can be used to make nicer SVG plots.

•       There was the potential for leaks in the memory for TNT scripts, if they were called repetitively.  Fixed now.

Fixes/Changes to the version of July 2019 (September 2019):

•       Command-line versions: added the xval function to the C interpreter, for better connection with TNT scripting.

•       Command dcomp (in Windows, File/MergeImportData/PairiwiseComparison), fixed some glitches: could have crashes when datasets included no trees, some datasets could require a long time to identify cells critical to differences in synapomorphies (for very large numbers of combinations to try, a restriction was placed before only on cells critical to differences in length; now the restriction applies to cells critical for differences in synapomorphies as well).

•       The option tree of the command lmreal (Data/EditaData/LandmarkAlignment) could not properly handle datasets where some (or all) of the landmarks for a configuration where missing in one or more taxa.

•       Saving tree diagrams as SVG files with user-set branch lengths when there were also text messages did not work properly. Fixed.

•       Parallel versions only: setting the number of tasks per host when creating a parallel job (with ptnt begin) and referring to groups of hosts only worked when the hosts were referred to by number, not name.  Now it works for names as well.

Fixes/Changes to the version of September 2019 (October 2019):

•       Combined bremer supports estimated using TBR branch swapping did not work –because of a silly problem with parsing options, they produced relative bremer supports instead.

•       Fixed a few commands that worked under 32-bit but not 64-bit versions (string-matching in command identification; reporting of costs read in cstree command or other Sankoff-related stuff).

•       The counting of lines read in a file opened with hifile was not updated if the new line character delimited a string read with $hifstring. Fixed now.

Fixes/changes to the version of October 2019 (February 2020)

•       A few really minor fixes.

Fixes changes to the version of Feb. 2020 (April 2020)

•       Setting weights for individual landmarks in datasets where landmarks were mixed with discrete/continuous characters created problems (most often, invalid error messages). Fixed.

•       The scripting expression isinfo did not work properly for invariant characters.

•       Added the option to read Newick tree files (e.g. RAxML files), with the proc [ option.

•       Parsing Nexus tree files with single character taxon names caused problems. Fixed now.

•       Improved the handling of tree-group names when reading trees from files (it used to copy the title, if present within quotes, to the group name; now, file name is always used, with the path skipped).

•       Added barplot to the scripting commands. This allows creating barplot graphs, or heatmaps, in SVG. See help barplot for details.

•       Added option to make line scatterplots (instead of dot scatterplots), with the var + option (only on SVG files). For this, make sure the arrays are ordered (lines connect first dot with second, second with third, and so on), and enclose RGB color code for line in slashes instead of parentheses (i.e. “/ R G B /”).

•       A bug unlikely to have affected anyone: The alltrees option generated all trees, but did not properly renumber nodes, so that subsequent comparisons of those trees with others (e.g. read from a tree file, generated randomly or with search commands), may have incorrectly identified equality, unless the trees generated by alltrees were saved onto a tree file and then read back into the program (which would have properly renumbered tree nodes).

Fixes changes to the version of April 2020 (May 2020):

•       Previously, only branch lengths could be read from Nexus files, not node labels. Both are properly parsed now (and stored as tree-tags).

•       There may have been problems with the scripting expression meanval. Fixed now.

•       The hifile seeks option may have had problems (e.g. failing to find a string actually present in the file, depending on the flanking regions). It is now possible to seek for strings containing spaces –string termination is now indicated only with a semicolon, not with a space.

•       Due to an oversight, the default search commands used for resampling from the menus (mult5= hold 5 keep tbr, which keeps the best trees from each of the 5 initial points) were different from the default search commands used for resampling with commands (mult5= hold 5 nokeep tbr, which keeps the trees only from the best replication(s)). The default setting from menus was more conservative (particularly with datasets or settings where optimal tree is hard to find), and (if using the defaults) this may have caused some differences in results from menus or commands. The menus use now by default mult5= hold 5 nokeep tbr, just like the resampling command. [ Diego Pol ]

•       The iterrecs option did not work properly for Sankoff characters when they were also ancestral (with ancstates). Fixed now.

•       The functions in the TNT library that call user-defined functions (combine, iterrecs, swaptree, and travtree) previously required that the function called returned an int. Now, the function called can be a void, case in which it is assumed to always return 1.

•       Added the Nnodes() function to the TNT library.

Fixes changes to the version of May 2020 (June 2020):

•       The dcomp (or File/MergeImportData/PairwiseComparisonCombination, in Windows) command caused crashes when there names defined for states not present in the matrix, or for a character with only missing entries and some state names defined. [ Diego Pol ]

•       Made it possible to set user-defined maximum number of states for Sankoff on a character-by-character basis (with the usminmax command). Before, maximum was set collectively. 

•       There were problems with the change command for Sankoff characters, either if a user-defined maximum was in effect, or some state(s) smaller than the maximum observed one were not present in any of the taxa.

•       Added compromise treatment for inapplicables, converting them into step-matrix characters, with the smatrix & option. In Windows versions, this is also accessible from the menus (Data/InapplicablesAsSankoff). See help smatrix for a general description (a forthcoming paper by Goloboff et al.will describe additional details). This can handle simple cases (where combination results in no more than 32 states).

•       Added option to make cost from/to unobserved states in step-matrices very expensive (effectively banning them from consideration at ancestral nodes), with the smatrix < option. This change is reversible only by re-defining new costs.

•       Running searches for complex step-matrix costs (particularly with many states) under auto-weighted optimization (piwe+ option), or even under piwe=, may have caused errors or crashes. Hopefully fixed.

•       Previous problems resulted from erroneous calculation of minimum possible numbers of steps. To remedy this, now it is also possible to have TNT calculate the minimum by effecting a tree-search. This is the usmin ! option (it is done automatically when issuing a smatrix& command). This could be done manually before, but using the usmin ! is easier (and it creates reduced trees, where only one terminal taxon per state or state-combination is present, thus saving time in the search). 

•       When saving tree diagrams in color as SVG files, branches with white color are now drawn as an outline. Also, added the possibility to draw a branch as a dashed line, by preceding the first color in the RGB code with a dash: (-0,0,0,6) is a dashed black line 6 pixels wide.

•       The warning message when parentheses in trees read from files were unbalanced used to say that “excess parentheses they will be ignored”. Now it says (in proper English): “excess parentheses will be ignored”. Grammar is important.

•       In rare circumstances, with complicated schemes of Sankoff costs, exact searches could save suboptimal trees (and miss some optimal ones). Exact searches for Sankoff characters are rarely used, so this hadn’t had much testing. I think this problem is fixed now.

•       Parallel version only: There was potentially dangerous code in swapping a tree with a control process. Never saw it cause problems, but it might have done so. Fixed now. [ Martνn Morales ]

•       Redefining some character names with cnames + , using longer names than before, and then changing the number of max trees (with hold), may have screwed up some character/state names. Fixed.

Fixes changes to the version of June 2020 (Sept. 2020):

•       The minimum possible number of steps for character-state trees was calculated as 1 less than the actual number (a silly oversight). This is unlikely to have had any effect on results, unless you were using both implied weighting and character-state trees (case in which characters with a character-state tree would have been given a somewhat lower weight than they should).

•       Changed the behavior of the smatrix& option (added in the last update), so that it produces results more similar to those of anagallis, both for single- and multi-level dependences. 

•       Added the <N option to the cstree command (to reset larger costs to N). This uses smaller differences in costs between states more distant in the given character-state tree, thus being intermediate between nonadditive and additive schemes. It may provide a better treatment of additive characters in the case of characters with inapplicables. 

Fixes changes to the version of Sept. 2020 (Oct. 2020)

•       The behavior of smatrix& is now more stable, producing the same results as anagallis also in the presence of additive characters. Made calculation of minimum steps for the recoded character equal to the sum of minima for the individual characters the default, as this aligns evaluations of homoplasy in the recoded and original characters. The use of minimum achievable lengths (i.e. with TBR) is now produced with smatrix&+.

•       An important change: relative fit differences for asymmetric step-matrix during TBR, between original and rearranged tree, were calculated only approximately (the program issued a warning about this in at least some contexts). There was some internal error checking for impossible values, and this could trigger error messages. Now, the values are corrected (to “zero relative support”) when estimated as impossible values by those approximate means, and it is also possible to (optionally) calculate relative fit differences exactly during TBR swapping. Exact calculation can use more memory and time, that’s why it is retained as optional. Exact calculation is connected on and off with cost& and cost |, respectively.

•       Another important change: performing tree searches under implied weights with a taxon limit with some sankoff characters with fewer than 16 states, and some sankoff characters with more than 16, could trigger errors in Windows or Linux versions (all Mac versions should have been ok). Fixed now.

•       Attempting to undefine groups (of taxa, trees, or characters) without having read a dataset into memory caused crashes. It causes an error message now. [Santiago Catalano]

Fixes/changes to the version of Oct. 2020 (Jan. 2021)

•       The ratchet had problems with the alternation between cycles (equal weights, upweighting, and downweighting). This has been fixed, and the ratchet may work better than before in some cases.

•       The reporting of the memory used (under watch=; watch[;) is now done in MB instead of just bytes (which was hard to read).

•       Changed the code for identifying duplicate taxa (riddup command). For very large numbers of taxa (>20,000), and perhaps for fewer taxa and many characters, the new code can be 4X to 5X faster than the code before.

Fixes/changes to the version of Jan. 2021 (Feb. 2021) 

•       Changed the mode for gap-reading in DNA/aminoacid dataset to be missing by default (the default used to be a fifth state, and had to be explicitly set as missing). This can be set to a fifth state with nstates gaps. [ Mark Simmons ] 

•       Fixed a small problem with un-defining tree-group (tgroup –). It did undefine the group, but did not properly empty it, so that adding taxa to the group (instead of starting from scratch), started from the group before un-definition.

•       Improved the report for the majority option of the pcrprune command. Now, if report is ON, a list of taxa pruned is also reported.

•       Added the option, in the chkmoves command, to display N taxa with the longest (or most) moves, with the \N option. This allows isolating the single worst (or the N worst) rogues in your dataset. Before, you needed to give a specific value of moves/distance (with /N instead of \N).

•       Landmarks: during searches, TNT can now use multithreading. The multithreading is used only for the Sankoff stage of score calculations, but that is a significant portion of the search time. Thus, landmark searches can now be significantly faster. The number of threads to use is changed with lmark threads (obviously, setting it to more than the number of processors decreases performance). The default is determined from the number of processors in your machine.

Fixes/changes to the version of Feb. 2021 (March 2021)

•       Command dcomp: added the > option to output character-distances between unmatched taxa. This facilitates deciding whether unmatched taxa can be synonyms.

•       The command dcomp could cause occasional crashes. Fixed.

•       Newick trees could be read only if using taxon names (using numbers crashed the program). Fixed. [S. Catalano]

•       There were problems with the mkmap command, when mapping several characters in a single execution of the command (first character mapped was always ok). The lset nogstate option didn’t affect output of mkmap (as would be expected); now it does.

•       Added the “\” option to the mkmap command.

•       The hybrid+ and hybrid* options crashed when some taxa were inactivated. Fixed.

Fixes/changes to the version of March 2021 (June 2021)

•       The sibyl option of the resample command could cause crashes with very poorly resolved trees. Fixed.

•       In datasets with continuous characters, when implied weights was off, and total tree length exceeded 2,147,483, branch-swapping algorithms produced messages of internal errors in calculations. Fixed. [ F. Prevosti ]

•       Added the piwe< and piwe | options. See help piwe.

•       Added the xpiwe(= option. This produces a better adjustment of k values for characters with missing entries.

•       Added the whomo scripting expression (see help + whomo).

•       The dcomp command produced crashes if the number of trees saved to the files to be compared exceeded 100.

•       The step differences reported by the dcomp command in text-output had problems, and differed from the character frames in file matrix_differences.svg. This is fixed now.

•       Added scripting expressions subopt and rsubopt.

•       Calculating combined bremer supports via TBR swapping (bsupport &!) under implied weights may have occasionally produced error messages of incorrect calculations. Fixed.

•       The poisson resample did not properly take into account prior character weights, if different from unity. Now it does.

•       Added the blength/ option (see help blength). Keep in mind that for landmark and Sankoff characters this is only approximate.

•       Added the whomo scripting expression (see help + whomo).

•       Occasionally, exact searches may have retained some suboptimal trees they should not have.

•       Bootstrapping when some characters were deactivated may have had problems (depending on which characters were inactive). Fixed.

•       Added the softboot option to the resample command. See help resample.

•       The ttag< command can now take a list of nodes for which the tag is to be erased (instead of a single one).

Fixes/changes to the version of June 2021 (November 2021)

•       For landmark characters, added the option to define connections (lmark connect) by just separating with dashes the series of numbers (pairs, as before, are allowed but not required).  

•       For aligning characters with lmrealign pairlin, it is now possible to avoid rotating the shapes (e.g. to preserve symmetry), if the pairlin keyword is preceded by “=”.

•       For 3-d landmarks, the lmrealign pairlin or tree options had problems with rotating configurations along the z-axis.

•       During a search under implied weights for landmarks where the minima have been defined by the user, finding a tree where a landmark had a score smaller than the minimum defined by the user triggered an error message, even when the difference between scores was within rounding errors. Now, the message is displayed only if the difference is within 0.01%, preventing superfluous warnings.

•       Due to a problem with internal memory management, repeated reading of fasta files may have on occasion caused error messages of “Heap deallocation error” [Santiago Castroviejo]

•       Added the option to leave threads (for multi-threaded optimization of landmark characters during searches) as suspended. Normally, the program begins new threads for every search (and exits them after finishing the search). If you repeat thousands of searches (e.g. in scripts), you may hit a system limit on the maximum number of threads (i.e. in Linux, 32,767) that a user can create. With lmark xthreads, you create the threads and leave them in a suspended state, using the same threads for all searches. This can incur in a small performance penalty if you are not doing searches (or reading and searching trees for new datasets without landmarks), and so it is not the default; it can be disconnected with lmark noxthreads.

•       Added the size, bigframe, bw, and color options to the lmbox command.

•       For the lmark usmin option, added the possibility of using the landmark scores from a specific tree T, with usmin =(T). See help lmark.

•       Windows versions only: heuristic alignment (minimizing linear differences by pairwise comparisons) from the menus (Data/EditData/LandmarkAlignment) was always done without resizing (even if the corresponding box was ticked). Fixed now.

•       Windows versions only: generating a new matrix (File/New) with some continuous characters did not automatically set the maximum number of states to the (required) 32. Thus, if you did not tick 32 states yourself, this created bogus matrices. Fixed. [ S. Catalano ]

•       For CygWin and Linux only: added MPI parallel versions. The interface is similar to that for PVM, connected with ptnt mpi (in Linux; this is the only option in CygWin, so it requires no specification). Check out the web site of TNT for instructions on how to install and run. This is a new development, involving over a year of work (in collaboration with M. Morales). Although we have done extensive testing, use this option with caution until it has withstood the test of time.

•       In parallel version, modified the way slavenum works (see help+slavenum).

•       Added the > option to the lquote command, useful to have runs in the background (e.g. slaves in a parallel run) write short messages to stderr.

Fixes/changes to the version of November 2021 (February 2022)

•       Windows versions only: when doing Bremer supports with TBR from the menus, taxon exclusion did not work properly.

•       When doing bremer supports with suboptimal trees (bsupport command), selecting some trees (instead of all) produced unpredictable values in the groups that were monophyletic in all the available trees (instead of the expected difference between best/worst trees in the set, followed by a question mark to indicate group is monophyletic in all the trees in the set).

•       Added the bsupport | option, for a closer correspondence with jackknife values in simple cases.

•       The apo> option did not work properly in 64 bit versions.

•       The command tcomp& (as well as the related expression, grptogrp) had problems when excluding some taxa.