Emergent Changelog

What's new in Emergent 8.5.0 Build 11320

Jan 8, 2018

Major Changes:
State Separation -- The computational State (and functions to operate on it) are now fully separated from the Main gui / type-access enabled objects -- this enables GPU to run on the same code base, and also resulted in significant speedups for threaded CPU performance as well. IMPORTANT user-visible effects of this change:
cannot change which spec a given object is using after the network has been built -- instead use ParamSets and update parameters of existing specs -- see stroop.proj in CCN Text for an example of this.
Unit access routines have changed.
Lesion -- support for lesioning of different levels of the network has been improved significantly -- there were likely bugs in previous versions.
Minor Changes:
Net State Display -- The current value of variables such as epoch, trial, sse, trial_name, etc are now displayed above the network view rather than an in the network view itself. The "Net Text" checkbox in the Net View control (middle panel) still controls whether the values are displayed. And now you can easily choose the variables you want displayed -- use the "Net State Values" tab in the Net View control panel to choose the variables you want displayed and to set the width of the field.
Network Monitor -- The Network now has a dedicated Monitor object. Any built-in or computed variables added to this monitor are displayable above the Net View display along with the standard network variables.
The Constraint Satisfaction (Cs) and Self Organizing (So) specific algorithms have not yet been ported over to the new State Separation framework, and are thus not currently available. Use the 7.1 LTS support for running these projects in the meantime.
Mac updated to use HomeBrew for installing most dependencies, and using latest Qt LTS version (5.9.3), but with WebKit from https://github.com/annulen/webkit instead of the default WebEngine due to a bug on crashing with the latter. This means you need to use webkit arg to configure script when building -- see Build Mac.
Leabra changes:
A new form of adaptation has been introduced, replacing the previous version from AdEx -- this new version is based on sodium-activated potassium (K_Na) channels that have multiple time constants and are argued to be the main form of adaptation present in cortex.
The rate-code equivalent of spiking activation (act_eq) is now computed by averaging spiking intervals, producing a much more accurate online measure.
wt_bal weight balance dynamics have been updated with a new parameter that excludes the lowest weights -- works better.
Noisy XX1 rate-code activation function now uses a computed function instead of a lookup table -- and new vm_act_thr param removes small oscillations when activation goes back down after unit has been active.
Various tau time constants tested and comments updated with cases when they can be lengthened to deal with oscillations -- in particular LeabraLayerSpec inhib.fb_tau can be lengthened to 3.0 instead of 1.4 if there are oscillations with stronger inhibition cases.
Misc gui changes:
Edit Dialogs use smaller fixed-width fields for entering float and int numbers -- default width configurable in expert Preferences.
Duplicating multiple items now keeps them in order
Navigator selection no longer tracks Editor tab updates.
Significant Bug Fixes:
Major speedup in gui while Programs are running: a Qt timer call was eating huge amounts of time -- switched to much faster timer call.
Keyboard shortcuts changed by the user were not getting saved across sessions, now fixed.

New in Emergent 8.2.0 Build 11076 (Jan 8, 2018)

Major Changes:
Completion is now available everywhere! Any place that had a lookup gui, you'll see completion options when you start typing, and also Ctrl+L lookup in the field will pull up a chooser.
Not-a-number (NaN or nan) is now fully supported to code for missing data values in the standard statistics / aggregation routines in taMath vec_* functions, and in the NetMonitor -- e.g., if you are doing an aggregation of data from another table, and filtering that table (or it is otherwise empty), the result will be nan values that will then be ignored if you compute something like the MEAN, etc.
Minor Changes:
Browser (Navigator) -- double-click is always expand / collapse item for containers (that have sub-items), and will engage editing for other non-containers -- editing is always engaged for single-clicking into an already-selected item, which may look like double-clicking, but the two clicks must be spaced a bit further apart.
expanding an item will always work, and will then expand to default settings below that.
Major cleanup and simplification of the default expand code -- removed default settings in favor of generic defaults that achieve same as previous defaults
GraphTableView :
new option to display BY_GROUP colors using the existing y-axis colors, in order -- Gp/Ys button right below the color setting at bottom of control panel.
new string_spacing parameter to space out string values
8 new colors defined -- do View / Graph View Default Styles to get the new colors, in case you're plotting many things (see e.g., above option!)
fields for each axis so you can arbitrarily label rather than depend on column name - if you don't enter a label the column name will be used
unlimited number of y axis fields (used to be limited to 64)
ParamSet saved values now show the standard gui editor for non-atomic types (e.g., layer geometry, spec pointers, etc).
Coin3d Quarter library now included in emergent source, builds within standard CMake process -- this eliminates a non-maintained and very outdated build process that was always a bit of a nightmare, and a source of crashing from quarter builds that were out-of-sync with the Qt version used for emergent. Now any version of Qt can be used and emergent will adapt automatically.
LeabraConSpec momentum field added to replace dyn_lr -- dwt_zone etc replaced with std momentum and normalization -- works best for most cases and is marked as a default -- existing projects load with it off however -- strongly suggest giving it a try!
Projection has a notes field, and Network has methods to create list of all projections to a DataTable or to a list formatted in various markup languages (taMarkUp -- can be used in scripts to generate various types of formatted text too) -- very handy for keeping track of and reviewing / auditing large complex projects.
Any DataTable can also be saved to any taMarkUp format as a table -- Data/Export Data Text menu
Window size saving is more robust when dealing with multiple monitors, etc -- only saves size/position when project is saved, instead of everytime it changes -- allows for transient changes to be ignored.
also added a View / Restore Window Geom option to restore to saved window geometry info, in case your windows have been resized mysteriously (a regular problem on mac with a second monitor)
Program improvements:
Variables for objs objects now go into a separate objs_vars list -- these are automatically managed and thus only serve to clutter up the vars list.
Duplicate variable names across args, vars, and objs_vars are now detected
Matrix objects returned as temporary variables from DataTable GetValAsMatrix and related routines now check that the matrix variable is in the proper loop scope -- fixes memory leaks, and eliminates previous overly-broad warning.
Notable Bugs Fixed:
StdEverything wizard creates a working project
all known crash-on exit bugs fixed
significant speedups for operations involving DataTables with large numbers of columns
undoing a delete of an object that has a 3D view now works -- previously would lead to crashing

New in Emergent 8.0.0 (Nov 1, 2016)

Major Changes:
Major changes to Network and associated objects To optimize multithreading performance (see Thread Optimization for details), memory is now allocated separately for each thread (CPU core), which required a complete rewrite of the way that all of the network algorithms are implemented. Here are a few highlights:
All the compute-relevant variables from Unit have been moved to a separate UnitVars data structure, which is what is allocated in thread-specific chunks, maintained by the Network object. To access e.g., the activation of the unit, you can call the act() method on the unit (which goes through the associated UnitVars), or you can call GetUnitVars() on the Unit and access the act member from there. The NetView and NetMonitor will automatically find these variables as before.
The connection groups (.recv and .send) have been removed from Unit and are also allocated separately as ConGroup structures (managed by the Network) -- the optimized algorithm computations now loop directly over these ConGroup objects, instead of going through the Unit level first. To access the connections from the Unit, you need to use the relevant methods on Unit, e.g., NRecvConGps() tells you how many receiving connection groups there are (was .recv.size before), and RecvConGroup(rgp_idx) returns a particular connection group indexed from 0..NRecvConGps().
bias connections have been eliminated as a separate Connection object, and replaced with individual bias_* members directly on the unit vars, e.g., the bias weight is now bias_wt in UnitVars.
Overall, you should think of the Layer and Unit objects as providing the structure template or "skeleton" of the network, and contain all the more static, gui-level information, whereas UnitVars contain the dynamic state variables that are updated through processing.
It is no longer possible to save or load the entire network at the Unit and connection level to a file -- you can only save the Layer-level structure of the network, which is then built dynamically when a Project is loaded. It is now possible to specify a weights file that is loaded automatically when the project or network is loaded -- this achieves most of the functionality of saving the network.
The USE_SSE8 compile option and configure script option have been removed -- vectorizing is now auto-detected based on processor type at compile time. See compile_info under Preferences, Expert items for full information on the compile of the executable, including the vectorization instruction set available (7 = AVX, 8 = AVX2 / haswell)
Network Building and weight initialization are optimized, with speed improvements of a factor of 10 or more! This is especially true for networks with symmetric weights (ConSpec wt_limits.sym).
Vectorizing has been improved, by ensuring that connections are chunked to allow vectorized access to the unit variables associated with the connections, and connections are allocated in one huge memory chunk, with proper alignment for vectorization. For Leabra, which uses sender-based connections, this means that the receiving units receiving those sending activations are aligned. The chunk size used for vectorization depends on the processor, and can be 4 or 8 (you can click on a SendCons inside the unit.send and see vec_chunked_size for how many connections were chunked, and under hidden items, vec_chunk_targ which is the target chunk size, now set to 8 (for compatibility across all platforms, where 8 is the maximum vector chunk size).
To keep up with the new vectorizing changes, the Mersenne Twister pseudo-random number generator (PRNG) (see MTRnd) has been updated with a version that is fully thread safe, with 100 different parameterizations of the PRNG that can be used by up to 100 different threads to generate distinct sequences of random numbers, which nevertheless are all cued off of the same initial seed, for full reproducibility. Also, this seed is just a single int, instead of the internal state of the PRNG. As a result, the system will automatically generate new random seeds in any of your RndSeed_List objects -- these are typically found in Train programs, and in the BatchRndSeed program in LeabraFlex programs. These changes mean that specific random sequences will not be preserved from pre-8.0 projects. But after this point, barring further changes, sequences should be consistent, even when using multiple threads.
GPU support, specifically NVIDIA's CUDA toolkit, has been implemented for Backpropagation, with 21x speedup relative to a single CPU (see GPU for details) -- the new Thread Optimization memory allocation enables most host-side memory structures to be transparently shared with the GPU device (with n_threads = 1 to keep the memory blocks coherent -- could extend to n_threads = number of GPU's). Very general framework now in place so much easier to support other algorithms -- Leabra is next (an earlier implementation exists but has not yet been updated to the new framework).
Major changes for the Leabra algorithm, described in Leabra_8.0_Update with instructions for how to update existing projects. The entire implementation was re-examined with the objective of removing rarely-used and legacy options, to make the edit dialogs and parameters dramatically simpler -- only the current, best-performing, most biologically-supported versions of algorithms are now supported.
Major changes to the Backpropagation implementation -- see Backprop_8.0_Update for instructions to update existing projects. All of the supported options are now available in the basic BpUnitSpec and BpConSpec, with enumerated options for things like activation functions etc. This is necessary for supporting the GPU implementation which does not support C++-style class hierarchies very well, and is also much easier for exploring different options without having to create different spec types.
Significant changes for keyboard shortcuts:
The meta key is no longer equivalent to the control key (on mac this means the command key is no longer equivalent to the control key). This opens the door to additional keyboard shortcuts/commands.
Key bindings can be set by the user. See the menu item "Tools->Choose Key Bindings"
To use the custom key bindings go to preferences and set "current key bindings" to "Key Bindings Custom"
The backspace and delete keys no longer delete objects (too easy to do accidentally). Use Control-D or the Delete menu item (or choose your own key combination!). To move an object use Cut followed by Paste
The preference "emacs_mode" is gone because you can choose your own keyboard shortcuts
DataTable LoadData, LoadAnyData now have reset_first=true default arg, instead of false -- this means that the default is to overwrite any existing contents, instead of appending, which used to be the default -- loading over seems to be the more typical assumption, and forgetting to specify reset_first=true often results in repetitive unintended appending of data to a table, causing an effective memory leak. Any Program code that relied on the prior append default will need to be fixed to specify reset_true=false!!
Source code reorganized, breaking up the single src/temt/ta directory into separate directories, to make it easier to find things: ta_core, ta_math, ta_program (all the Program code), ta_data (all the DataTable related code), ta_proj (taProject and associated objects), ta_gui, ta_3d (3d gui elements)). Also, all the virtual environment and sensory processing stuff has been moved to src/emergent/virt_env
Minor Changes:
ClusterRun improvements:
search algorithms improved and simplified -- new syntax for specifying ranges of values, and simplified interface for writing search algorithms -- existing basic ones fully tested -- can be toggled on and off.
can now specify a given project name to use for the svn repository (in the Properties tab), instead of using the actual project name -- this allows multiple different project files to share a common svn repository, which is useful for trying out different architectural variants in different projects.
support for multiple users, and Update is MUCH faster when doing so
simplified flag for recording parameters vs. searching params
jobs_deleted table now accumulates all deleted jobs, including the svn number in last_svn needed to recover the job from svn -- the UnDelete function can now recover selected jobs -- facilitates keeping the jobs_done list, and the active svn list of files, smaller, while never losing anything really..
SaveState menu action triggers save of weights at any point, and system auto-saves weights 5 minutes prior to designated job end time.
Stampede super computer is available to emergent users to run large-scale models -- a great resource!
GridView fixes: Better performance with large data tables, set the paging size (i.e. set the number of rows/cols you jump when clicking >)
A number of GraphView improvements:
hide/show labels on axes
new color mode "Color by Group" provides color coding and legend when comparing variables across groups, for example data from models run with different parameters.
each Y variable now has an edit button for setting line color, style, etc.
Program improvements and fixes:
stop_step_cond condition expression for when they should obey the step (and stop) buttons. This allows more powerful stepping behavior, e.g., as implemented in the LeabraFlex programs MasterRun program, which can now step at the epoch level (and whenever there is an error, or a correct trial).
Can now directly call functions in other Programs -- functions must not take any args -- works just like calling another program (including setting the overall global args of the Program), except that it then just calls the named function. This allows Programs to function much like C++ classes, where the functions in the Program are now like methods on a class and can be called directly -- makes it easier to have one centralized Program that handles various aspects of a given functionality (e.g., everything to do with generating and updating a dynamic environment).
RunFunction button allows you to run program functions (that take no args) directly through the gui.
Conditional printing replaced with simpler mechanism that uses two booleans, one on the print statement and one on the program group. If the "debug" boolean on the print statement is false (default) then the print statement will execute but if true it will only print if the program group "debug_mode" boolean is also true. By toggling the program group debug_mode (at any level) you can turn printing on or off for all of the print statements that have debug set to true
Enhanced "lookup" - lookup now works for many cases not previously handled - use control key + l (that's a lowercase 'L')
Many fixes to parsing of typed ProgCode
support for Matrix access (i.e., a matrix on the left-hand-side of an = assignment) with a special ProgEl -- don't need to make these into css expressions anymore.
The menus/buttons "New From Program Lib" and "Load From Program Lib" are now "Add From Program Lib" and "Update From Program Lib" - hope that makes more sense
Console commands you type are now saved and reloaded when you relaunch emergent. Control+p or up-arrow to scroll back through commands.
Programming toolbar now has "new" objects you can drag into the navigator. For example, drag in a new data table, program, function, layer, etc
DataTable improvements:
ReadOnly data table columns have a light grey shading to distinguish them and doubling clicking a readonly cell displays the cell content in a new window for easy viewing
Boolean-valued data table columns -- have a convenient check box toggle in the gui.
You can now add a Data Table cell to a control panel. Select a single cell and choose the context menu item "Add to Control Panel"
Browser improvements:
Two versions of searching the Navigator tree selectable by a pop up menu below the tree
"Find" which only looks at the visible text in the tree
"Deep Find" which looks at object members, descriptions, etc
Incremental search and replace - In addition to Find and Deep Find there is Replace which allows you to advance through the found items and replace or skip
Search widget added below data tables for searching scalar and matrix columns. Default is a "contains" string search with option for "exact match".
Better control of tree expansion state
Preferences for default expansion of top level groups (docs, ctrl_panels, data, programs, etc)
Preferences for default expansion of program subgroups (objs, args, types, vars, etc).
Separate defaults for programs in Navigator tree (left panel) and Program Editor (middle panel)
Also you can control whether "Call Arguments" are shown when you expand - default is don't show
Navigator tree state now saved with project. The tree will automatically expand to the saved state when the project is reopened
Menu item and shortcuts for expand collapse
Double-clicking a collapsed tree node will expand the node to its default; Double-clicking an expanded node will collapse it
Double-clicking while pressing the control key (command key on Mac) will expand the node fully
Network improvements:
Layers now have both absolute and relative positions, and Network has an ABS_POS flag for selecting which one you want to be editable. Also, there is a new PositionLayersFromTable program in the Program Library that can grab layer positions and set them from values stored in a DataTable -- very handy for large, complex networks. Lastly, the MANUAL_POS flag on Network is now set on by default -- prevents automatic moving of layers when they overlap.
Unused specs are now shown with a grey background to indicate they are not used
The "Where Used" menu/button command on specs now lists child specs in use as well as the specific spec that was the target of the query.
New "Compare with Children" feature creates a data table showing overridden spec values. The table will be created in the group "spec_tables" under "networks". Makes it very easy to compare parent and child specs.
You can compare peer "specs" by choosing 2 or more and selecting the context menu item "Compare Peers". The table will be created in the group "spec_tables".
NetMonitor items can specify layers.varname to specifically target a variable on a layer, for all layers in the network -- this is the preferred way to do so, as it avoids confusion with network level objects having the same name. Also the Leabra standard monitors have been updated with many more useful items, and updated with new variable names -- recommended to update your monitors to match those in the LeabraEpochMonitor and LeabraTrialMonitor standard Program Library programs.
added new ParamSeq parameter sequencing capability, triggered off of the network epoch parameter, and using the same parameter access technology as the ParamSet -- can use this to define any kind of trajectory of any kind of parameter across training. MUST add call to network.Init_Epoch() method in appropriate place in the code (e.g., LeabraEpoch program or EpochStart in LeabraFlex programs -- standard program library has been updated with this call).
NetView allows you to select (in view control panel, check boxes) which variables appear in the "hot" list within the 3D network view panel (persists) -- different models have different relevant vars. Many fewer now appear there by default.
Other improvements:
Changes to color scale values are remembered so turning off auto_scale restores the last values.
New preference allows you to turn off Project level event logging (no .plog file will be created) -- this is only really needed for debugging. a general log is however always recorded in the user "library" emergent directory (e.g., ~/Library/Emergent/log on mac, ~/lib/Emergent/log on Unix)
New method SetMember() allows you to set a member value for multiple objects simultaneously. Very useful for setting a value on multiple "specs". To use select one or more items from the navigation tree. Children are automatically updated.
Font size preferences for specific parts of the GUI - labels, console, navigator and editor
If you are doing a demo try "View/Incr Font Size" to dynamically enlarge all fonts so your audience can read the text
Notable Bug Fixes:
MANY Major periodic crashing bugs in the gui fixed, by preventing re-entry into the GUI event loop from delayed processing waitproc code -- things were disappearing in the middle of some of these operations.. software should be MUCH more stable now!
1290 - some locale settings caused emergent to crash on windows and linux when opening a project -- no longer need to manually change your locale -- the program automatically uses the C locale which is compatible with the CSS programming language and expressions used throughout.
A bug in "Find" and "Deep Find" that was causing some items to be counted multiple times has been fixed

New in Emergent 7.0.1 (Nov 1, 2016)

New in Emergent 7.0.0 (7374) (Jul 9, 2014)

Major Changes:
Major optimization efforts, resulting in up to about 75% speedup in some models! Technical docs in Vectorizing
Connection is no longer used for memory allocation in BaseCons (i.e., RecvCons and SendCons) -- instead, each connection variable, all of which must be a float type, is allocated in its own separate vector. This speeds up access. Also, the unit on the other side of the connection is no longer specified by a pointer -- instead an index into the full flat list of units is used -- this same index can be used to directly access other data including the temporary net input array. Any Program access of weights will need to be updated -- see Unit for details.
Use of SSE or SIMD (single instruction multiple data) vectorizing instructions built into all x86 chips -- leverages Agner Fog's vectorclass.h http://www.agner.org/optimize -- used for netin and some basic weight change operations in Leabra.
core vector math routines in taMath_float / taMath_double optimized by adding faster branch when no ElView is in place, and some SSE on very core vec_ routines.
optimized Matrix indexing routines -- you now need to specify FastElxd where x = dimensionality (1..6 or so) -- much faster for 2d, 3d etc than the generic routine.
optimized wraparound logic in taImageProc routines
Handy new StartupWizard in the startup root window -- presents most common actions of making a new project, loading a recent one, or loading an arbitrary project.
SVG (scalable vector graphics) output of NetView, GraphView, and GridView displays -- custom-written rendering function produces much better looking output than previous postscript rendering (which worked off of the very low-level scene graph data), with appropriate grouping to make subsequent editing etc very straightforward. This represents a dramatic improvement for producing publication-quality figures. Just select the SVG format from the Snapshot tool in the 3D Viewer.
New annotation graphics available for all 3D view displays T3Annotation -- there is a + menu on the right side of the 3D viewers, where you can manually add lines (w/ arrows), rectangles, text, or 3D objects, optionally positioning using the native units of the underlying display (e.g., the graphed data values in the GraphView, columns and rows in the GridView, or coordinates of units in the NetView). These are saved with the view. They can be positioned with the usual draggers, and operated upon en masse by choosing "edit all", then selecting and choosing operations from the context menu (translation, scaling, setting properties, etc). They replace the NetViewObjs which were specific to the network view and much more limited.
DistMatrixTable in taDataAnal uses the new annotations to make a nicely labeled graphical distance matrix, optionally with grouping of repeated labels -- a major improvement in usability of this important form of analysis.
The GraphView has a better way of dealing with matrix columns in a DataTable -- you now can pick a cell from the matrix to use, or enter a -1 to see all the cells (color coded according to the current color scale). This allows e.g., 3d matrix data to be plotted as a 3d plot, by selecting cell 0 for the x axis, cell 1 for the y axis, and cell 2 for the z axis. The old matrix grid plot can be selected by setting the graph type to MATRIX.
Bar graphs now use a solid 3d bar -- much better visually
Can now select arbitrary number of things to plot -- set NPlots value to change number avail -- increased to 16 by default.
Various font size and other spacing and layout parameters are now avail in the control panels for GraphView and GridView. For the 3d view tabs, you can select the "1st View Properties.." item from the context menu to get the full set of parameters for a view in a usual edit dialog format (a few are still hidden because there isn't room). You can access all other views from the new EditView button in the Panel Properties dialog. Also GridView click values now toggles between values.
Major improvements to Programs:
Program breakpoints now have a gui (the break_points list right under main .programs line in Project) that allows easy management for enabling and disabling breakpoints across all the programs, and there is a context menu option for global enable and disable across groups of programs. Also, breakpoints should set and clear with 100% reliability now -- several issues fixed.
The Program Editor panel is much improved for those used to a standard text-editor environment: you can just type directly into the editor (hit Ctrl+a (goto start), Ctrl+e (goto end), Ctrl+k (kill existing), F2, or, if the line is blank, just start typing to engage editing) and add to or modify the program completely textually -- everything will automatically be converted into the appropriate ProgEl program elements. This builds upon the previous ProgCode system -- new code is entered into a ProgCode, which then parses and converts it into the appropriate program element. There is an expert Preferences setting that allows you to hide the mini-program edit dialog at top of editor area by default, if you prefer to only operate in editor mode.
Loops and other container elements have been streamlined by hiding their explicit "code" list from the view.
The combined If-Else has been replaced with separate If, Else, and ElseIf elements -- if you want to add an else case to an if, you now have to do that as a separate step -- the advantage is that the display is cleaner without the true_code and false_code lists.
Any object with a name in any tree browser can be edited inline as well -- makes it easy to name new objects created by hitting Enter/Return in the browser.
New Program Examples project under Demos which contains a comprehensive set of code examples that you can run and copy/paste/modify in your own projects -- great way to learn the programming system. Also the AX Tutorial was completely updated and is (once again) a great way to learn about how to use many of the major features of the software.
No more ordering constraints on functions in a program -- any can call any other, regardless of order in list
the css Console window now has a lock / unlock toggle to dynamically switch between using it to monitor for error messages (where it is locked below the project window) vs. using it for larger viewing / interacting cases (any attempt to manually position or resize automatically goes into unlock mode, and it will remember the size when you toggle back and forth).
paths to objects that show up in the css Console are now clickable to take you right to the object in question -- makes it easier to go back and find what caused an error.
New program run status displayed in main application toolbar at top of window -- if a program is running or has stopped, it will show you where and why -- click for a full backtrace (GlobalTrace)
Lots of fixes to ClusterRun: can now specify CRR: in a path to point to the cluster run results (CRR) directory, where e.g., weights files are saved -- when the project is running on the local workstation, this is mapped to the local svn cluster run repository -- when it is running on the cluster, it is the results directory where the the model is running -- allows one specification for where to find these files to work in either place. Also available: CRM: for models subdirectory (where the project is stored) and CR: for the parent cluster run directory for both results and models. ClusterRun path is also now automatically included in the file chooser dialog list of path shortcuts on left hand side.
now auto-updates after executing an action (Run, Kill, GetData, etc) -- you don't have to sit there and hit the Update button all the time! Also, the current svn revision is always shown in the button area at the bottom of the edit panel, so you don't need to keep looking at the css console for that information.
can select SET instead of SRCH for parameters -- simpler for manual parameter searching.
can copy files from other users or other project names -- easier for collaboration or trying out different variants w/ diff project names.
ClusterRun and ControlPanel (previously called SelectEdit) now use a "normal" edit panel with all the gui controls, as compared with the clunkier display that rendered mostly text and then the edit controls only for the currently-selected row. Also prevented excessive updating of the panel -- doesn't update while a program is running (except for variables and methods on programs) -- there is a running_updt flag to override this.
New SubversionBrowser, available from the Tools menu (for svn repositories defined in Preferences, and for emergent repository itself), and in the toolbar -- one click to checkin changes to the current project, or to open the browser in the current directory. Browser has all the basic functionality you'd expect, in a nice 3-pane structure with revision history, repository listing, and working directory listing.
Mac and Windows versions updated to Qt 5.2 -- provides better support for Mac Retina displays and fixes the keyboard focus bug on Mac.
New TA_BASEFUNS macros for the C++ classes, which greatly reduce the build dependencies, and the compile time. Important for any existing plugins: (see Plugins v7.0) -- you must add: TA_BASEFUNS_CTORS_DEFN(MyTypeName); to your .cpp files for any types in the .h files that have TA_BASEFUNS* in them, along with several other changes detailed in Plugins v7.0.
DataTable import/export
New - Import and export using JSON
Import of files using csv or whitespace now ignore extra spaces
Emergent Server_Protocol
The client now accepts commands in JSON format and the results are returned in JSON format
The implementation is column oriented (the native api is row oriented) so you can add/create new columns with this API
New Data menu - The data processing and analysis functionality previously hidden in the project tree has been moved to the application menubar. You will see a new menu labeled "Data" with 4 submenus. These processes allow you to modify and analyze data in data tables, create new tables based on data in existing tables, etc. All of these operations can also be done with program code.
the Find: tool at the bottom of every browser is now much faster and more robust -- also parses multi-word searches like google -- only finds items that fit the conjunction of all the terms. This can now be easily used for full browser searches, and complements the dialog-based find mechanism. Also, type in UpperCase letters and your search will automatically be case sensitive -- all lowercase is case insensitive.
Minor Changes:
String now has a split function that returns a String_Array, which can be iterated over using foreach -- also foreach will now iterate directly over chars in a string.
Array objects can now be converted into corresponding Matrix objects automatically, by using a cast operator: e.g., str_mat = String_Matrix("abc".split());
Can select the type of a new variable (and choose local/global) when prompted for it while programming in the Program Editor.
Object chooser dialog now allows you to create new items, if one you want is not avail (e.g., new specs, data tables, networks, etc)
Can now just press enter for e.g., LocalVars in a project, and it will add the first variable -- this is true for all such objects that have a "default child" list where sub-items automatically appear -- previously it was necessary to click a button to make the first item (after which point the Enter or Ctrl+I or Ctrl+O shortcuts would then work once you could put the cursor in the list of sub-items).
DataVarProg -- can now map between an enum and a Matrix data column -- uses a "localist" code of writing a 1 in the cell corresponding to the enum value.
In Network -- LayerPos_GridLayout_2d and 3d functions -- automatically arranges layers in an orderly grid, for both 2d and 3d views. Very handy for large models.
specs now have a SetParam function that can be used to set a given parameter for all specs in a group, including children.
VEBody and associated virtual environment code now has much better support for bodies defined relative to other bodies -- much better for constructing complex objects with multiple parts -- they all can be moved, rotated, etc just by moving the main "anchor" body.
Also fixed weird lighting discrepancies for VECamera -- cameras now see exactly what you see in view for lighting -- will require some fixes to existing projects that had things setup backward to accommodate previous bug.
Added support for shadows in virtual environment rendering -- see new params on VEWorld object.
LeabraLayerSpec has important new FF_FB inhibition type -- directly computes approximate feedforward and feedback inhibition based on average netin and average activity in layer or unit_group, respectively. Should be much closer to inhibitory interneuron inhibition, and gives much more natural "more is more" activation dynamics, where greater net input to the layer results in greater activation in general. Also eliminates pesky tie breaking issues. Extensive tests show that it performs as well or better than existing KWTA_AVG_INHIB on many challenging problems. Also this computed inhibition can now be combined with connection-spec based inhibition.
For Leabra programs, added LeabraNetwork::Compute_PhaseStats() function to be used instead of the Compute_TrialStats() function (along with the _Test version of that function) -- calls Compute_MinusStats() in the minus phase and Compute_PlusStats() in the plus phase, which allows for example the target values for SSE and other errors to be provided only in the plus phase -- previously these had to be present in the minus phase to count correctly.
New Keyboard shortcuts:
To control frames of the project window. With a single key combination you can have any combination of the browser (left pane), panels (center pane) and graphics (right pane). On Macintosh command-1 gives the browser the full window, command-2 panels get the full window, command-3 browser and panels share, command-4 graphics gets the entire window, command-5 browser and graphics, command-6 panels and graphics, command-7 all 3 frames. Works on all platforms with key equivalent to Macintosh command key.
To control 3D View. The arrow keys control rotation and while holding the shift key the arrow keys control rotation of the view. Zoom-In with the '+' key and Zoom-Out with the '-' key.
New class DynEnumTableCol generates enums corresponding to the values in a DataTable column. Any changes to the column (sorting, deleting, etc) causes regeneration of the enums. If you were previously using DynEnumType in conjunction with a DataTable column you probably want to update to this new type.
Functions in DynEnumType to convert enums to numbers in Matrix or Array objects -- handy for converting entire DataTables en-masse.
New color (taColor) attribute added to projections, available from projection edit panel.
DataVarProg now has an option to get or set all variables (boolean all_matches) that match the names of data table columns. This means you don't need to specify each variable you want to get or set.
DataVarRead and DataVarWrite are new programming elements that read or write one variable only at a time but don't require that the column name and variable name match.
The SelectEdit object has been renamed to ControlPanel to better reflect its purpose and the menu items are now of the form Add...ToControlPanel.
Option in Preferences to turn off the pager in the css console.
Tree browsers are now "spring loaded", hovering over an item during drag-n-drop will expand the item and moving off will collapse the item. This option and the spring delay time are settable in preferences.
Bug Fixes:
ClusterRun no longer so touchy and crash-prone when all params not yet set
ProgCode in Programs no longer causes sporadic crashes when it converts into specific ProgEl
When changing the value of a Spec in a ControlPanel or in a Program, sometimes the change would not propagate to all the child specs of that spec -- this is now fixed once and for all by propagating the UpdateAfterEdit call all the way up to the largest containing object of where a change occurred.
fixed crashes in taCanvas
fixed crashes in taImageProc region spec filtering code on Windows platform (affected the v1rf and objrec projects from the CCN textbook)
fixed important bug in css that was losing track of which program was running, which affected error reporting -- should now have much more reliable reporting of which program and where an error occurred in.
Ctrl-M was only duplicating the first of multiple items selected in the browser.
Some windows, e.g. Find, could only be closed by clicking the close box. Now they can be closed with the 'Close Window' menu or the keyboard shortcut.
On a mac, the laptop trackpad under Qt5 was hypersensitive -- now fixed -- turns out it was getting touch events -- turned those off.
Extended selection using cursor keys was missing the last item selected
Undo was not working for "Edit Dialogs" (e.g. a data table opened into its own window)
Around 200 bug tickets were addressed for this release -- too many issues to document them all here!

New in Emergent 6.3.2 (Jul 9, 2014)

Major Changes:
ACT-R is much more fully-functional -- still has a few more things to be done, but it now supports the visual and motor modules, and more of its overall behavior has been tested and validated against the actr6 lisp implementation.
DataTables now have (hidden) list of row numbers that are used in all access to the data, which enables much more efficient filtering, sorting, etc -- only this row number list needs to be sorted, for example, not all the raw data itself. All access of the data at all levels (even down to the low-level Matrix data that is used for storing each column worth of data) uses these row numbers to access the data, so you cannot tell that they are there, and all existing code works exactly the same as it did before (only faster!). There are however some important new functions that this now supports:
Deleting (including Filtering) rows from a table only deletes from the row list, effectively hiding the rows rather than immediately deleting them.
You can therefore restore the rows (or undo any other row-level operation, including Sorting) with the menu item "DataProc/Show All Rows". This function resets the row list to match the original raw data.
To permanently remove any hidden raw data, select "Flatten" -- this also reorganizes the raw data to match the current row list order, making the raw data and the row list isomorphic.
You can keep the original table by making a copy first (or calling FlattenTo to flatten to a different table).
Saving a project does not flatten the table -- the full raw data is saved along with the row list, so it is just as you left it. If you have a large table that has been significantly filtered, or a lot of adding and deleting has taken place, it can be more efficient to Flatten that table before saving.
When a Data Table is the source of input to a network, the view you see is the view the network sees. If you have hidden rows they will not be input to the network. Likewise all calculations operate only on the visible rows of a table. Again, the presence of this hidden row list is invisible, and everything works as before, except for the ShowAllRows and Flatten functions.
You can drag-and-drop the columns and rows of a DataTable to reorder them.
There are many new options on the DataTable context menus and the Column-level menus for commonly-used functions.
Data Table filtering
Two dialogs has been added to make filtering more user friendly.
Filter based on values of a single column by selecting the "Filter" menu item from the columns context menu.
Filter Dialog (Single Column).png
Filter based on multiple columns by selecting the "Filter" menu item from the "DataProc" menu.
Filter Dialog (multiple columns).png
You can write your own expression to filter rows by selecting the "Filter Custom" menu item and entering an expression.
The DataTable method Filter has been renamed to FilterByScript
High Dimensional Analysis GUI
Dialogs have been added to make high dimensional analysis (e.g. Cluster Analysis and Principal Component Analysis) more accessible
Select a data table matrix column and select an analysis from the context menu
Minor Changes:
View settings (e.g. panel and window size, data table column widths) are now saved by default. This is a project level setting and a checkbox has been added to the project properties panel to enable/disable this behavior.
A "Save As Only" property has been added to projects (good for demos and tutorials). If you set this property to true (checkbox on the project property panel) "Save" is disabled but "Save As" remains enabled. This property defaults to false.
Sort Ascending and Sort Descending added to column context menu. For multiple column sorting use DataProc/Sort that allows specifying up to 6 columns of sort hierarchy
Go directly from a line of code in the left browser to editing in the center panel from context menu item "Edit Program El"
Keyboard navigation of the lookup dialogs has been optimized -- saves a few keystrokes.
Bug Fixes:
The color scale chooser works again.(1583)
Find command was crashing during "member" searches.(1559)
Various other bug fixes and a few memory leaks patched -- improved overall stability.

New in Emergent 6.2.0 (May 24, 2013)

Major Changes:
Complete overhaul of the entire codebase, and the maketa system for getting type information, breaking each of our previously-massive files into separate files for each class object. Also a massive renaming, especially of the gui classes, so that name follows function much more closely -- see Gui Overview. This makes project files saved in 6.2 not fully readable in prior versions -- the files will load, but some gui view information will not be loaded. The net result for the developer is that the typical recompile times will be relatively short, even though the full recompile time is actually quite a bit longer. And it is now deterministic to find where code is, and what it depends upon -- should make it much easier for people to access and understand the code. Also, the maketa parser was upgraded significantly to deal with a much broader swath of C++ code, including sub-classes within a class, and many more features of templates.
Any existing Plugins will need to be updated for this version -- see Plugins_v6.2 for all the details on what you need to do.
ClusterRun -- automatic cluster or other compute server job submission and management -- manage everything from within the emergent system using a convenient gui.
TwoD NetView mode -- lays out everything in one big flat panel -- can be easier to see everything at once in a big complicated network.
Minor Changes:
Matrix now supports copying based on the slicing and other ways of specifying a subset of matrix elements -- this is incredibly powerful for composing larger patterns out of smaller matrix pattern pieces, and for replicating patterns in various ways. See docs under Matrix for full details.
Renamed all the ta_geometry classes to more standard names like taVector3f, taVector2i etc instead of things like FloatTDCoord and TwoDGeom -- these old names are still avail for backward compatibility, but please use the new names going forward. Also added a taQuaternion for more powerful rotation calculations.
VEBody and VEStatic can now be positioned, etc relative to other bodies -- often much easier than absolute coordinates.
Bug Fixes:
Lots of fixes to Virtual Environment system: Much clearer naming of methods, e.g., Init instead of "SetValsToODE", better sync'ing with ODE and a CurToODE method for explicitly updating ODE from changes to current values. Support for Euler angles to specify rotation, and use of a taQuaternion class that provides direct access to all manner of handy 3D rotation functionality -- VEBody objs have an init_quat and a cur_quat that has this quaternion reflecting current state. Also handling of the long_axis of capsules and cylinders is now vastly improved -- dragging works as expected, updates are immediately reflected, and internally these are always in the ODE-consistent LONG_Z state.
LeabraLayerSpec unit-group shared inhibition flag gp_i (and associated gp_g) settings were not being properly migrated to the new unit_gp_inhib (same with layer_gp_inhib, which is even more rarely used) -- wasn't setting the spec unique flag so changes were being lost -- now fixed. Double-check any projects that might have used this (probably this would have been found already) to make sure this param was not lost.

New in Emergent 6.1.0 (May 24, 2013)

New in Emergent 6.0.0 (May 24, 2013)

Major New Features:
Added in 5.3.3: powerful css list comprehension functionality, including significant Matrix css functionality for manipulating Matrix objects in css, using Slicing and other syntax as used in MATLAB and Python, including the convenient foreach loop. The semantics and syntax are quite similar to those of Python overall. See the previous links for more details.
Fully functional BrainView display which projects layer variables into an anatomical "glass brain" viewer, by assigning layers to associated brain areas. Currently only supports the human brain with a couple of reasonable brain atlases of brain areas. Provides an important visualization tool for mapping model data onto fMRI or other anatomically-based data. Plus it looks extremely cool.
can now specify an arbitrary suffix to a build (e.g., in configure script or args to CMake), and it will carry that through for the install, so you can have multiple different versions of emergent installed -- each different suffix now has separate preferences and plugins, so it is now possible to really keep things separate.
plugins now detect when they are out of date and prompt for remaking at startup if so.
Windows platform now can use the gui css console -- go to Options and select Gui type -- much better than the prior console (which remains for error messages from other components of emergent that can't write directly to the console). Required massive replacement of stream-based output with String-based, which is much more flexible and general-purpose.
Much improved Diff Compare dialog -- shows entire diff with all the context (and less clutter), so you can better tell where the diffs are, and the dialog is now non-blocking so you can also use the normal gui to investigate differences, etc (View button will take you directly to any given item in the diff list).
Significantly improved version (version 3) of the Leabra PBWM algorithm for simulating Prefrontal Cortex and Basal Ganglia Working Memory -- much more robust and powerful learning.
Minor New Features:
Programs:
Added Global Trace and Local Trace buttons to Programs (see Program Debugging) -- provides a back trace of the flow of programs up to the point where they were last stopped (by user Stop or an Error or Step). Helpful for debugging.
debug_level and my_mask variable pointers on PrintExpr and PrintVar Program elements, allowing for more finely-tuned control over what is printed when.
end any expression with a semicolon (;) in the ProgCode entry for programming in Programs, and it will convert that into a free-form CssExpr that allows any kind of valid css expression -- this is useful for things like declaring temporary variables outside the scope of program control, and certain Matrix css expressions that are otherwise not handled by other kinds of Program Elements.
Revert To Code button on Program Elements -- where possible, return a program element back into the ProgCode that originally created it -- allows you to easily fix bad conversions.
improved mouse-over in css Script panel for viewing curent state of variables -- now shows full state of object (e.g., matrix contents etc).
can drag and drop an object onto a Program and it will prompt to add a variable to that object to either args or vars -- often easier than doing the same thing within a program.
LeabraFlexProgs -- new cur_config enum chooser using function that can generate DynEnum dynamic enumerated values from a column in a DataTable.
The LeabraEpoch standard program now has a step_on_err flag which, when set, causes the Step: Epoch button to stop after any trials where there was an error -- very handy for sorting through trials to find the ones where it is failing. You can then use the NetView history browsing function to replay the last trial (cycle by cycle if you have that update set) and see what went wrong.
Other:
NETIN_PER_PRJN flag in Network -- can compute net input on a per-projection basis, which is important for various specialized cases. Inhibitory vs. excitatory input is now computed using this mechanism.
New gelin activation function in Leabra -- has better temporal integration dynamics and improves learning generally.
learn flag on LeabraConSpec -- can toggle learning on and off.
error dialog "cancel for next minute" function now improved to use interval between errors and time in the waitproc instead of the minute timeout -- works well at detecting beaks between errors.
blue select color now always in effect even if not in focus -- helps to see what is selected everywhere, esp useful during Find ops..
Find has match case option
There is now a "find" box at the bottom of every browser for quick find behavior without the Find dialog -- each kind has various tradeoffs so you can choose your favorite.
Projects now have an auto_name flag, set on by default, which updates the name based on what is called when saved -- useful for choosing items when multiple projects are active (often they have the same name if derived from a similar history)
moving of network layers and groups can now be undone -- handy because sometimes it doesn't turn out well and you need to try again..
can drag-n-drop to move tabs in the right 3D view
Buttons for adding "netmax" and "netrel" monitors for Leabra networks -- very handy for tuning the Leabra Netin Scaling parameters.
Bugs Fixed:
Program buttons were not getting updated if you switched away from them and then back.
fixed potential crashing in Undo system, and fixed some long latency issues in Undo -- also added a preferences undo_debug flag that can be turned on to debug any undo-related issues (sends messages to console and project log file)
fixed some css-related crashes.
eliminated duplicate paste on middle-mouse-button paste on linux
numerous other small bug fixes

New in Emergent 5.3.10 Beta (Jul 30, 2012)

Major New Features:
Added in 5.3.3: powerful css list comprehension functionality, including significant Matrix css functionality for manipulating Matrix objects in css, using Slicing and other syntax as used in MATLAB and Python, including the convenient foreach loop. The semantics and syntax are quite similar to those of Python overall. See the previous links for more details.
can now specify an arbitrary suffix to a build (e.g., in configure script or args to CMake), and it will carry that through for the install, so you can have multiple different versions of emergent installed -- each different suffix now has separate preferences and plugins, so it is now possible to really keep things separate.
plugins now detect when they are out of date and prompt for remaking at startup if so.
Windows platform now can use the gui css console -- go to Options and select Gui type -- much better than the prior console (which remains for error messages from other components of emergent that can't write directly to the console). Required massive replacement of stream-based output with String-based, which is much more flexible and general-purpose.
Much improved Diff Compare dialog -- shows entire diff with all the context (and less clutter), so you can better tell where the diffs are, and the dialog is now non-blocking so you can also use the normal gui to investigate differences, etc (View button will take you directly to any given item in the diff list).
Minor New Features:
Programs:
Added Global Trace and Local Trace buttons to Programs (see Program Debugging) -- provides a back trace of the flow of programs up to the point where they were last stopped (by user Stop or an Error or Step). Helpful for debugging.
debug_level and my_mask variable pointers on PrintExpr and PrintVar Program elements, allowing for more finely-tuned control over what is printed when.
end any expression with a semicolon (;) in the ProgCode entry for programming in Programs, and it will convert that into a free-form CssExpr that allows any kind of valid css expression -- this is useful for things like declaring temporary variables outside the scope of program control, and certain Matrix css expressions that are otherwise not handled by other kinds of Program Elements.
improved mouse-over in css Script panel for viewing curent state of variables -- now shows full state of object (e.g., matrix contents etc).
LeabraFlexProgs -- new cur_config enum chooser using function that can generate DynEnum dynamic enumerated values from a column in a DataTable.
can drag and drop an object onto a Program and it will prompt to add a variable to that object to either args or vars -- often easier than doing the same thing within a program.
Other:
NETIN_PER_PRJN flag in Network -- can compute net input on a per-projection basis, which is important for various specialized cases. Inhibitory vs. excitatory input is now computed using this mechanism.
New gelin activation function in Leabra -- has better temporal integration dynamics and improves learning generally.
learn flag on LeabraConSpec -- can toggle learning on and off.
error dialog "cancel for next minute" function now improved to use interval between errors and time in the waitproc instead of the minute timeout -- works well at detecting beaks between errors.
blue select color now always in effect even if not in focus -- helps to see what is selected everywhere, esp useful during Find ops..
Find has match case option
There is now a "find" box at the bottom of every browser for quick find behavior without the Find dialog -- each kind has various tradeoffs so you can choose your favorite.
Projects now have an auto_name flag, set on by default, which updates the name based on what is called when saved -- useful for choosing items when multiple projects are active (often they have the same name if derived from a similar history)
moving of network layers and groups can now be undone -- handy because sometimes it doesn't turn out well and you need to try again..
can drag-n-drop to move tabs in the right 3D view
Bugs Fixed:
Program buttons were not getting updated if you switched away from them and then back.
fixed potential crashing in Undo system
fixed some css-related crashes.
eliminated duplicate paste on middle-mouse-button paste on linux

New in Emergent 5.3.0 (Jul 30, 2012)

Major New Features:
Wizard interface improved significantly -- all the wizard options are presented with links in a textual document with useful usage information, and the network wizard was completely rewritten using new taGui system for easily creating new gui dialogs. Should be a lot easier to use.
new Project dialog is now a choice of a template for the new project -- includes projects configured in standard ways -- also very easy for users to add their own templates for useful starting configurations.
Project log of all informative messages and gui user actions now automatically created -- saved in new file with extension .plog -- can view in project edit panel -- should be useful for debugging problems.
can now search and replace in selected items -- does a text-based replace of values -- use context menu to access -- very handy.
Brain View projection of network onto "glass brain" 3D transparent brain rendering -- very cool! Beta implementation at this point.
Program Improvements:
Major improvements in programming efficiency: press Return/Enter key to add a new line of code, and type in a C++ expression and it is automatically converted into corresponding Program element, which can then be edited further etc. Use Ctrl+L lookup to find variables, members, etc while typing expressions. See Program documentation for details.
You can enter new variable names in expressions and it will then prompt you to create these variables (or go back and fix the expr) -- more efficient way of creating new variables. Also variable chooser dialogs have "New" options for making new variables.
many improvements in Program Debugging tools (see link for full docs)
css View tab in Program middle panel -- view and interact with css script generated from program -- great for watching new Step Css button for single stepping through the css code as it runs. mouse over variables to get current values. Context menu on line number to set a breakpoint or view corresponding program source. View Css button on a program element will highlight corresponding script code. color coding is consistent between two views as well.
Runtime and syntax errors in css are now linked back to the corresponding line in the program editor, greatly simplifying the process of fixing bugs. Line is highlighted in red as well.
Context menu options on the program element for toggling a breakpoint -- will stop execution of the program just before running that line of code, so that variables etc can be examined (in the css View or the css console, using standard css print commands, etc).
VERBOSE flag on program elements now reports much more useful information
bits flag now supported for DynEnumType dynamic enum types - allows mix-n-match multiple options selected
IMPORTANT: DynEnum enum value was stored as an index previously, but now it is the value directly -- projects with sequentially numbered enums (which is the default) should be unaffected, but if this was not the case, the enum vals loaded from the project may not be correct.
new QUIET flag on program elements to suppress warnings that are not relevant.
new NEW_OBJ flag for local variables -- auto-create a new object of given type for a local variable
renamed ProgVars to LocalVars -- these are only used for local variables so that makes a lot more sense.
much improved lookup (Ctrl+L) chooser -- segregates expert items from preferred normal items so that lists are much less cluttered and it is easier to see what the right options are -- to access the expert items, use the list view chooser on the right side of dialog. Help browser also segregates items in the same way, so that regular items are all at the top
Minor new features:
Added Show Icon check box on NetView control panel to determine whether iconified layers are actually rendered or not. New default is to not to render.
Can use arrow keys in NetView to move around the selected unit for viewing weight values. Also clicking to select unit is much more reliable now -- much more likely to always hit a unit now.
Tooltips (mouseover) on 3d view tabs provide full tab name (useful with many tabs where some are elided)
Drag-and-drop a layer on the projections group of another layer and you get a ConnectFrom option -- easy way to connect up layers using just the left browser on the layers. Also works for existing prjns to change who they connect to.
Network NetStruTo/FmTable and NetPrjnsToTable and Layer PrjnsToTable -- write and read network structure to/from a data table -- very handy for seeing in a glance the whole connectivity and specs.
Layer layer_type now drives background color hints: green = input, red = output/target
Projection name now updates appropriately as layers change names
enable_all_plugins and --list_plugins Command line switches for Plugin management on mpi or other batch executable platforms where you don't have easy gui access.
warnings for saving project file without write permission.
wizard in Leabra to create a hippocampus
Grid Layout option for 3D views -- can arrange multiple items (e.g, multiple graph or grid views) in a given view tab into a grid -- access from frame properties menu in 3D tab.
Bug fixes:
All panels with scrollbars should now save and restore scroll position over updates -- no more jumping around all over the place. DataTable will only scroll to bottom for AddNewBlankRow ("tail mode") -- not for other external changes.
LesionUnits in Network and related objects now works again -- it uses a LESIONED flag (set with Lesion and UnLesion functions on Unit), just like on layers, instead of actually removing the unit -- necessary for optimized unit access routines
NetView auto scaling now actually works!
Dreaded NULL network dialog bug fixed!

New in Emergent 5.2.0 (Jul 30, 2012)

New Features:
LIBLINEAR plugin now available -- allows access to various classification algorithms such as SVM's within emergent!
Projects now have a license field associated with them, where you can select from among a set of standard licenses governing the distribution and use of your project by others, or enter a custom license. There are new license_def, license_owner and license_org fields in the preferences to specify defaults for these when you make a new project.
Networks can now compute precision and recall statistics -- enabled by turning on compute_prerr flag on the network -- results go into prerr and epc_prerr fields on network (and prerr on layers). See http://en.wikipedia.org/wiki/Precision_and_recall for more details.
Movie button on the NetView history toolbar in the network viewer -- can create a movie directly from the stored history information -- renders individual frames to files and then you can call an mjpegutils command to concatenate into an MPEG movie, which can then be transcoded into other more general formats (e.g., using VLC to convert to MP4 works well).
verbose_load Options setting now has a VERSION_SKEW level that provides the ubiquitous version skew warnings -- otherwise these are now suppressed with the default QUIET option.
attachwait startup flag -- very useful for doing gdb attach on jobs that were submitted via a job scheduler on another node in a cluster, and especially for dmem (MPI) debugging -- just waits in an attach code thing, where you set the local i variable to a value other than 0, and the program will continue (see comments in code in ta_project.cpp where it should be when you attach -- set var i = 1 will enable it to continue)
Project::SelectT3TabNo/Name -- can select tabs by number or name from the project object, in program code
When your project is 'dirty', or, in other words, has unsaved changes, there will now be an asterisk (*) in the title of the window. When you press Ctrl-s or go to File > Save to save the project, the asterisk will go away, indicating the project is now 'clean' and no changes need to be saved. This gives you nice visual feedback that can boost your confidence that there aren't any unsaved changes right now.
Variables now have a SAVE_VAR flag which will determine whether or not the value of that variable will be saved in the project file. If not, it will be re-initialized whenever the project is loaded. Having this off can cause fewer conflicts with using diff or svn diff to merge projects.
Programs now have a LOCKED flag which indicates that the program should only be edited by expert users. Right now it doesnt actually prevent you from editing and so is just a visual clue.
If and IfElse now merged into single IfElse that can (optionally) not show the false condition if it is empty.
There are now VCR buttons associated with the control panels for GridViews that allow you to move just one row up/down or to the end/beginning.
taDataAnal::ReceiverOperatingCharacteristic. See here for documentation: Receiver Operating Characteristic
Minor new features:
RandomPrjnSpec - randomly connects sender to receiver with probability p_con.
GpMapDivergePrjnSpec and GpMapConvergePrjnSpec -- yummy!
TiledGpMapConvergePrjnSpec -- impressively complicated new prjn type -- see docs for details
taMisc has new file management functions: MakeDir, Rename etc.
Bugs Fixed:
fixes to 3D virtual environment when running in -nowin mode (i.e., batch mode) -- interaction is off by default.
no longer saving all units on recover files -- really not necessary and painful for large networks.
3d view thumbwheels now wraparound continuously so you can keep on going as you keep rotating -- no jumping backwards
Server Protocol GetTable Program.Table syntax fixed
Calling Print in a tight loop no longer causes locking of the css console. Missing taMisc::FlushConsole() was added.
Double-clicking the right or left horizontal sliders closes the slider without affecting the position of the other one.
Opening multiple projects with the same project root name no longer causes a crash. (regression).
URLs in the Find dialog now work correctly. (regression)
nan and inf numeric values are more reliably handled across platforms.
Windows installer has nice emergent icons and properly creates a desktop shortcut,
Fixes to MultiLayerNet wizard naming
GridView control panel shows the row you are on
BiasSpecs now show up in the spec explorer.
bug 1300: Fixed problems with line endings when saving weights files.
Various updates for motion filtering in image processing code.
r4798: Important fix for MultBias in matrix -- gp_sz = nunits / 2 -- biasing not right from virtual_groups onward as result of this.
r4801: Updated AX Tutorial project file for 5.1.x series. Also moved its documentation to wiki and updated.
bug 1311: Check for out-of-memory condition & try to recover; this is only a partial fix as there are other places OOM could occur. This is mostly a problem on 32-bit platforms where emergent is limited to using 2GB memory. There is now a 64-bit version for Windows that should obviate the need for a more thorough fix.
r4804: Unit::GetLayerAbsPos replaced with LayerLogPos and LayerDispPos based on corresponding functions at the layer level, which are unambiguous.
r4805, r4806: Changed snrthal act, act_eq to always equal act_m2 after a gating event has taken place -- makes it easier to see what is going on, and should help generativity model. Added flag snrthal.act_is_gate to control act = act_m2 behavior in snrthal.
r4807: Do not build or connect lesioned layers. Fix for no bias in GradRF projection.
r4812: Enclose ProgramCallVar in { } so that multiple can co-exist in same program.
r4814: Weight specs in projection specs are now conditionally editable based on init_wts. TiledGpRFOneToOne has gauss_sig weights -- needed to better replicate imgproc code. Added Init_Weights button to network.
massive speedup in deleting LeabraUnits (e.g., closing a project with a large network)

New in Emergent 5.1.0 (Jul 30, 2012)

New in Emergent 5.0.2 (Jul 30, 2012)

New Features:
Diff Compare -- very useful new feature for showing the differences between two objects (including their sub-objects), and allowing you to merge changes in either or both object, using a graphical dialog. This is essential for merging updates to programs, specs, etc from other sources (e.g., the new standard program library, or other forks of a given project, etc)
Param Search -- for single variables added to the SelectEdit editor, new parameter searching options are now available directly in the gui -- just click the search flag on, and you can set min/max and increment values to control parameter searching. See link for info about a demo project doing simple Grid search. Many more sophisticated search features are now being built upon this infrastructure.
Program Step -- special new interface for single-stepping programs -- shows list of eligible programs to be stepped (using new short_nm) and also selector for how many times to step per click -- makes it very quick and efficient to step at multiple levels.
NetView History -- the network viewer NetView now records all the network variables during a display update, so you can rewind and view previous network states (including variables you weren't originally looking at) -- very useful for debugging and understanding what the network is doing, etc.
Plugins -- several major improvements, including ability to compile directly within emergent, and pull up a built-in editor to edit the source code -- can do full plugin development all within emergent. Also useful command-line interface to re-make all plugins, e.g., after source update to main code.
Minor Features:
Projects are now automatically saved every 2 minutes by default if there are changes. If your project is my.proj, the autosave file will be my_autosave.proj. This is useful in cases where the software crashes and isn't able to dump a my_recover.proj file. If the software is able to dump a recover file after crashing the recover file will have more recent information than the autosave. Autosave will also save you if your computer gets turned off. Once you save the project, the _autosave file is removed, so if it exists, then it is more recent than your last save. Save interval is settable in Options
running in the gui is now generally as fast as -nogui -- was slow due to slow gui event processing routine, which is now called much less frequently
See Keyboard shortcuts for a number of new shortcuts -- emacs style editing is now fully supported everywhere.
Ctrl+i on var, args, funs and programs (or any case where there is only one option) no longer brings up a chooser -- it just directly inserts the object for you.
Ctrl+left and Ctrl+right now navigate forward and backwards in program code selection history.
When importing data into a datatable (such as csv or tsv) the header is automatically computed and the type of data is now inferred based on the first row.
Datatable buttons now show up on graph/grid view ctrl panels -- handy for just loading data and graphing it.
There is now a preference for disabling the application toolbar and the tools bar.
Choosers now allow you to interact with them more quickly. If you know the exact string that will cause the element you want to be selected, you can type it and press enter without waiting for the gui to catch up with you.
Methods that require a type (such as NewColMatrix) now automatically have taBase::VT_ filled in. Just put your cursor at the end and push Ctrl+l to see a list of type completions.
GpRndTesselPrjnSpec and PolarRndPrjnSpec are now fixed.
DataTables now support automatically scrolling to the bottom as more rows are added - auto tail mode.
Can drag a Program variable onto an argument to a MethodCall or a ProgramCall -- easy way to pass variables.
Programs now have an OBJS_UPDT_GUI flag. If it's unchecked (default) objs in that program will not have their gui representations updated automatically as changes occur -- only at the end when the program finishes. (for example, GraphView/GridView for tables)
DataTable columns with matrix cells can now have custom-named dimensions that show up in editor window
new utility functions:
taDataGen::GenSortedPermutations. generate a sorted list of all possible n! permutations
taMath::vec_jitter_gauss. jitter elements of a vector with a gaussian
taMath::fact. compute factorial of n
taMath::vec_kwta -- compute kwta on a vector
DataTable MatrixColToScalars and MatrixColFmScalars -- copy matrix data to sequence of corresponding scalar columns, or vice-versa -- useful e.g., for graphing matrix data as individual lines instead of the matrix graph view.
taDataProc::AllDataToOne2DCell -- collapse all data into one 2d matrix cell -- useful for analyses etc.
taDataProc::Slice2D - take a 1 or 2d slice out of the first 2 dimensions of a matrix.
taMath_float/double::mat_transpose - transpose a matrix
Bugs fixed:
Eliminated final several bugs with edit dialogs..
Tree update code is no longer N^2. You can, for example, now safely do .data.SetSize(1000), or create very large projects with many objects, without triggering exponentially expensive tree updates.
Fixed gui event loop calling within css, resulting in more than 2x speedup when running in gui mode.
Fixed several redundant gui update chains that were causing many excessive gui updates.
emergent --help or emergent my.proj --help now shows generic startup arguments. It does not show you the startup arguments defined in a particular program's LeabraStartup.
Dragging an object onto itself and choosing Set Object doesn't cause a crash
Tabbing on program element control panels no longer stops on help and edit buttons, instead skipping directly through the chooser buttons.
NetView -- seek (flashlight) button now working again
plugin fixes -- working again (and more)
parallel threading fixes -- could hang in some rare cases previously
Methods that require a type (such as New) no longer require you to use TA_TypeName. You can just enter TypeName.
Using Ctrl+i to insert a ForLoop now inserts the loop variable.
The Find chooser now shows you the full path to the object rather than the nesting level.
There are now StructUpdate blocks placed around gui operations where you have highlighted multiple elements and delete them all at once, speeding this up greatly.
Simply opening and closing a project will no longer result in a prompt asking you if you want to save the project.
Learn rule drop down on network is now wider
Some crash on close bugs fixed.
Target links for ProgramCall in program library code now set correctly (by name, not just path).
opening programs with startup programs and auto-building networks now all works properly -- Startup Program only runs if the -ni command line argument is passed (non-interactive)

New in Emergent 5.0.1 (Jul 30, 2012)

New in Emergent 5.0.0 (Jul 30, 2012)

Major Features:
Undo and Redo in the GUI! works pretty much just like you'd expect from other software, including a new parameter for undo_depth (100 is default -- uses diff's so memory usage is minimal).
Parallel Threading support -- uses multiple processors in parallel to compute faster (in principle): see Thread Params for more information -- unless you happen to have the new Nehalem i7 chips, earlier generations of processors are not likely to result in much speedup -- about 15-20%. However, with the dedicated memory managers in the i7's, you can get ~2x for 2 cores, ~3x for 4 cores, and not too much above that (3.5 or so for 6 cores).
Leabra code completely rewritten to be fully sender-based, which results in a 30-70% performance boost, and is essential for the above-noted threading speedups on the i7 processors. Backprop is naturally receiver-based and already gets the above speedups on i7's.
css optimized in several ways, resulting in a 2x speedup.
Doc objects now have Qt WebKit web browser functionality, with optimizations to support shared wiki-based docs within projects, making it easier to share a common set of documents across a set of related projects, and for collaborative projects more generally. You can also read the news or check email or facebook entirely within emergent, if that turns you on. Important: there is a known bug in the Qt WebKit cookies that causes problems for editing wiki pages: if your "Save page" or "Show preview" seems to hang, just hit the X to stop it, and then click the button a second time. It should then go through (may need to do a Go click to get it to actually show up).
New Help Browser for help information, which provides an integrated interface to both wiki and auto-generated help information from the source code. The wiki information is rendered in the native web browser. Help buttons are now avail on every edit dialog, in the context menu for every member of an object, and for token pointers ('?' button) -- please get in the habit of using this and also editing the help text while there to improve things for everyone! The auto-generated "reference information" from the source code is now much more comprehensive and easier to use -- based on the doxygen format that is widely used (e.g., Qt, Coin). The help browser can also show you the source code for all functions available to you in the software.
added gui and other support for Layer_Groups -- these are very useful for managing networks with multiple functional subregions, e.g., large-scale brain models with multiple brain areas represented.
The 3D View now can save 6 different views (buttons on bottom) -- very convenient for large networks or views with multiple elements. Use context menu or hold down button to save or name the view -- click otherwise takes you to the view. The most frequently used network variables are also now selectable for viewing in the upper left of the display, and it also automatically selects "interact" mode when you select a connection-level item that requires selecting a unit.
Can click to view or set values in the Grid View -- useful for drawing new training patterns. In the grid view control panel, the Click Vals button determines if clicking will set values, and the values that will be set depend on the button used, and can be set here too.
Minor Features:
Multi-selected objects now have many more useful context menu options, e.g., set multiple selected layers to use the same layer or unit spec, or set multiple selected program variables to all be in the control panel or not, etc.. Selecting multiple items and then clicking delete now deletes all of them.
taMisc::FullArgStringToFile -- saves startup args to a file -- now included in standard LeabraStartup script -- very handy for going back and finding out what args were passed to a given simulation run.
Network Monitors can now monitor values in UserData by using "user_data." (for simple values) or "user_data.key.xxx" (for complex subobjects) -- note that the specified UserData must already exist when you initialize the Monitor, otherwise an error occurs
nowin startup argument causes GUI to be initialized but no windows open (as in --nogui) -- allows for offscreen rendering in the virtual environment when running background batch jobs.
DataTables now have a more powerful and bug-free data import/export menu, including support for importing fixed width text using the FixedWidthSpec object.
Program elements have VERBOSE flag which prints out useful info when that program element runs -- very helpful for debugging.
Virtual Environment now has built-in support for simple servo motor control on joints, and also some sophisticated virtual muscles based on detailed physiological models (within the general equilibrium point control framework).
The web browser can now play flash movies. This is designed for screencasts that demonstrate how to use emergent which can be played from within emergent itself using the browser that you see in the root view when you open it. A few of these screencasts have already been created. See Tutorials.
Splitters on all windows can be double-clicked to toggle collapse/expand of corresponding panel -- very convenient for quickly focusing in on a given task (e.g., programming when you don't need 3d viewer)
Major Bug Fixes:
the Virtual Environment (ODE) system was not properly using the long_axis parameter for cylinders and capsules -- even though they looked right in the graphical display, the underlying physics was wrong (they were always oriented along the Z axis), which explains a lot of weird collision behavior.. also, it was not properly updating various shape parameters when you changed them, even after Init (SetValsToODE). Now it is a bit more dynamic, with the gui updating immediately and the Init button setting everything, and it also includes a Reset button for a *full* guaranteed reset, which is useful after numerical errors crop up, etc. Various other minor bugs fixed.
Regression Bug Fixes:
in Windows, the ScalarValueLayer had stopped working -- this has been fixed
Fixed linking against Termcap on Fedora by applying Florian Lengyel's patch. (autotools -> cmake regression)

New in Emergent 4.0.19 (Jul 30, 2012)

New Features:
PluginWizard for creating plugins -- this replaces the HelloWorld example, and provides a quick and easy way to get started making a new plugin. It is located in the root (startup) window, under wizards tab.
The Network view text display under the network is now movable to any location or orientation (using dragger box -- only visible when lay_mv box is on and red arrow selected), and can be turned off completely. See the PlaceNetText function under NetView menu on network for std options of where to put it.
You can also filter what information gets shown in the network text display, in the User Data editor on the Network object -- it comes pre-populated with check boxes for each viewable item -- uncheck to turn off.
The SelectEdit ("control panel") is now rendered with a much faster display technology that only shows the edit controls for the currently-selected item -- this means that it is now possible to use this instead of the network text display to monitor basic counters and stats. A convenient NetControlPanel function is now avail in the network SelectEdit menu for setting up such a thing.
Important note: to get the select edit to update as the network is trained, you need to turn on the update_after flag in the NetCounterInit and NetCounterIncr program elements in the Trial program (typically -- if you really want to see updates at the cycle level, which will be much slower, you can turn that on in the Settle program). These will be set for any new programs you create from the standard prog lib versions, but not for existing projects.
The Graph View can now plot up to 8 variables instead of 5.
A Copy From button is now available on all view control panels, to copy view settings from another view -- very useful if you've made a nice graph of a particular type of data, and then you want to graph a new data table with the same format, in the same way..
DataVarProg now supports getting/setting a full Matrix cell to/from a taMatrix object variable
UserData editor, shows up when there are 1 or more user-visible UserData items for an obj
Windows version now has full support for: 64 bits; end-user compiling; plugins (at last!)
Variant now supports TypeItem pointers (TypeDef, MemberDef, etc.)
CSS support for the enhanced Variant
Plugins can now easily express user options and retain plugin state (see the plugins/template plugin for details)
added na_by_range to LayerWriter = n/a values in InputData when the value is outside of the act_range on the unit spec.
added taDataAnal::Matrix3DGraph -- make a datatable display an X,Z graph (generates a matrix-like grid by duplicating the points and sorting the other way)
added taDataAnal::RegressLinear -- linear regression (and associated taMath functions too)
Major Changes:
CMake system is now used for building the application and plugins
The default emergent user folder has been changed. In addition, preferences are now stored in a prefs subfolder of the user app folder (instead of in a hidden folder on your system). The folders are:
Windows: [user]\Emergent (USERPROFILE env variable for user folder)
Mac: ~/Library/Emergent
Unix: ~/lib/Emergent
Existing installs will automatically be migrated to the new locations upon first launching the application.
the location of System plugins has changed on Unix and Mac as follows:
[install prefix]/lib/Emergent/plugins
All plugins need to be recompiled for new installs, and will automatically get installed to this location.
Minor Changes:
geom for mat cells now displays lowest dim on left, ex: ...:d3:d2:d; PAT_4D format has group on left, unit on right, ex G0:Y1
New and NewGroup now let you optionally supply the name
plugins are now installed to a different location, see [[1]]
Major Bug Fixes:
Server interface now returns word 'lines=' instead of 'line=' per documentation
fixed major ref-counting bug issues in CSS for taBase objects
added a GSL error handler so that GSL errors get reported in emergent, rather than crashing emergent
retinal image processing routines greatly improved, and new option to WRAP around on input, plus border stuff is now on the RetinaSpec object and not an arg.
Minor Bug Fixes:
fixed misc keyboard navigation issues: Ctrl+Enter and Esc work for view control panels, and they also take you back to the main browser from a reg edit dialog, as they do for the program editor.
saving to PNG format now automatically uses maximum deflate compression
switching to/from PAT_4D mat cells in table editor was erratic, fixed
can now remove a DocLink for an object
Group sorts now update the tree views properly (was not supported before)

New in Emergent 4.0.17 (Jul 30, 2012)

New Features:
Keyboard shortcuts massively improved -- it is now possible to fully operate the software without taking your hands off the "home" position on the keyboard -- should be a big help for programming.
Back and forward arrows for browsers work like same buttons on web browsers for tracing through history of selected items.
New button (and related operations) are now avail in the middle edit panel for any List or Group containers.
Improved several things with Programing, including adding UpdateAllArgs buttons to programs and functions, and a bug from prior version where the parent name of the progvar item in a lookup dialog was missing.
Added DataProc Tutorial -- extensive tutorial on use of DataTables for all manner of functions -- highly recommended for all users -- also covers a fair amount of programming stuff too.
Simple Unit Names - You can now set persistent Unit names (for display purposes) in the unit_names field on a Layer -- the simplest way to do this is first select Actions/GetUnitNames menu item on the layer(s) with names (or on the Network for all layers), and leave the force_use_unit_names flag checked ON -- this will initialize the unit_names matrix to the size of the layer (it will then remain in sync for subsequent changes every time you do a Build). Then just edit the unit_names field to enter names -- they will be saved and applied to the network when it is built after reloading a project. The InitNamedUnits program element now interfaces with this, and important note for existing projects that use InitNamedUnits: it no longer automatically runs LabelNetwork during the Init of your program, so you need to manually do that (click on the LabelNetwork button) and then save your project -- this will then save the unit_names values for all the layers, obviating the need to redo it during Init.. You won't see your names until you do this.. NOTE: Do not use < or > as part of your unit name, as these are used for the tags in the weight file, and using these will confuse emergent when it tries to read in weight files.
Parents instead of Owner - The token chooser dialog now lists the "Parent" of the tokens, not the "Owner" -- the "Parent" is basically defined as the first non-list owner in the owner chain, and is usually much more descriptive. So, for example, the parent of a data column is the table; the parent of a layer is the network, etc.
Save Layer Units - You can now save the units on a single layer basis, by setting the SAVE_UNITS flag on the Layer. This can be useful if you just want to simply label your units in a single layer or two, but don't want to bloat the proj file with units from all your hidden layers.
Save Except - You can set the network to save units, and then exempt single layers using the NO_SAVE_UNITS flag on the layer.
As now documented in Monitor Data, you can now monitor subsets of units within a layer, using a special syntax.
Major Bug Fixes;
Fixed crash on exit (caused by not explicitly cleaning up css space prior to exit and deleting other objects to which they refer)
Fixed crash from "New from Prog Lib"
Fixed various other memory management issues that could lead to crashing.