Analytica Docs - User contributions [en]

What's new in Analytica 7.2?

2026-08-17T20:26:46Z

Lchrisman:

Analytica 7.2 is currently under development, and will be a future release of Analytica. The current official release is [[Analytica 7.1]]. This page is under construction, and will list enhancements that are new to Analytica or ADE 7.2.

What's new in Analytica 6.6?

2026-08-17T20:25:49Z

Lchrisman:

[[category:What's new pages]]
[[category:Analytica releases]]

This page lists new features in release 6.6 (not the current release) of Analytica (including [[ACP]] and [[ADE]]) since the previous [[Analytica 6.5]] release.

Analytica normally prompts you to download and install the new release the next time you run it.
If not, you can download it from [https://analytica.com/users/renew-upgrade/ Renew, upgrade or download].

== Highlights of 6.6 ==

* [[#Assista|Assista]], the Analytica AI Assistant, is faster and more reponsive.
* The [[#Keelin Metalog distribution 2.0|Keelin (or Metalog) distribution]] is now the preferred method to define any continuous distribution, because it now avoids the occasional infeasibility problem that previously bedeviled it.
* You can select [[#Diagrams and controls|All in Checkboxes]] for parametric analysis and in Multichoice.
* You can use [[Links_or_URL_in_model_attributes#Extended_HTML_markup| html to set text styles in text nodes]], including bold, italic, underline, bold, colors, bullets, and more in desktop Analytica. Even more html tags work in ACP.
* [[#Expression language|Sum(x, All) sums over All indexes of x]]. Similar for Min, Max, Product, and more.
* The new [[OAuth2Authorize]] function lets you access web services, such as Google docs, sheets, Salesforce, etc to read or write data.
* You can specify a [[#Graphing|Fill origin for graphs]] to let you show colored bands around the center line -- e.g. for probability bands over time.

== Assista ==
* The chat UI is faster. Responses start streaming sooner.
* You can use the Enter key (or Ctrl+Alt) to submit responses without having to click to submit button. The Return key adds a new line (the behavior elsewhere in Analytica). If you have the [[Preferences_dialog#Personal_Preferences|Use Return to enter data]] preference set, then the Return key will submit responses and the Enter key adds a new line.

== Keelin Metalog distribution 2.0 ==
Introducing the '''''always feasible''''', [[Keelin|infinitely flexible distribution]]!

The [[Keelin (MetaLog) distribution]] has become popular due to its ability to closely match the shapes of all the standard continuous distributions as well as offering enormous flexibility in matching amost any shape. But up until now it has been plagued by finding some parameter combinations ''infleasible'', so it would sometimes fail t to find a valid distribution to fit.

[[Analytica 6.6]] fixes this problem with the MetaLog 2.0 distribution. It includes many new results from
* Manel Baucells, Lonnie Chrisman, Thomas W. Keelin and Stephen Xu (2025), "[https://papers.ssrn.com/sol3/papers.cfm?abstract_id=5279416 On the properties of the Metalog distribution]" (preprint), forthcoming.

New features include:
* The resulting [[Keelin (MetaLog) distribution]]s are ''always'' feasible.
* There are closed-form analytic expressions for all central and standardized moments (see [[KeelinPropertyFromA#Basic_statistics_and_moments]]).
* There is a closed-form analytic expression for partial expectation (see [[KeelinPropertyFromA#Partial_expectation]]). This makes the Keelin distribution especially convenient for many problems that use piecewise-linear transformations of an uncertain quantity.
* It uses the superior basis order of the MetaLog 2.0.
* You can also specify the desired «mean», in addition to «values» (data points).
* New set of functions with names of the form <code><x>KeelinFromA(...)</code>use the «a» coefficient vector from [[KeelinCoefficients]]:
** <code>[[KeelinFromA]](...)</code> -- analog to <code>[[Keelin]](...)</code>
** <code>[[DensKeelinFromA]](...)</code> -- analog to <code>[[DensKeelin]](...)</code>
** <code>[[CumKeelinFromA]](...)</code> -- analog to <code>[[CumKeelin]](...)</code>
** <code>[[CumKeelinInvFromA]](...)</code> -- analog to <code>[[CumKeelinInv]](...)</code>
** <code>[[KeelinPropertyFromA]](...)</code> -- ''new to [[Analytica 6.6]]''
*:When using the Keelin distribution, you can either use a quantile parameterization or an «a»-vector parameterization. These new functions make it clearer that you are using the «a»-vector parameterization, instead of using the original (analogous) functions with a special flag.
* A new option uses a [https://docs.analytica.com/index.php?title=Keelin_(MetaLog)_distribution&anarelease=6.6#Using_direct_method_for_bounds direct method for bounded support] as an alternative to the previous [https://docs.analytica.com/index.php?title=Keelin_(MetaLog)_distribution&anarelease=6.6#Using_the_Transform_method_for_bounds transform-method for bounded support].

== Diagrams and controls ==
* [[Checkbox]] now has an "include ALL" option, enabling [[Parametric analysis]] even with a checkbox.
* [[Multichoice]] controls include a new option at the top to ''select '''all''''', ''select '''none''''' or ''select '''first''''', depending on the context. These are more obvious to the user than using the <code>Ctrl+A</code> key.
* A text node can display several [[Links_or_URL_in_model_attributes#Extended_HTML_markup|new html formatting options]], including changes to text color, bullets and numbered lists.
* A new [[ChangeNodeVisibility|node visibility option]] lets you hide a node while Analytica is computing.

== Expression language ==
* There is a new separate <code>Boolean</code> data type. To preserve backward compatibility, the values continue to display as 0 or 1, but the [[Number format dialog]] provides an option to display values with the boolean data type as True or False to distinguish them from 0 and 1.
* You can now find the maximum over all indexes of <code>X</code> using
*::<code>[[Max]](X, All)</code>
*:as a shortcut for
*::<code>[[Max]]( X, ...[[IndexesOf]](X) )</code>
*:which uses [[Repeated parameter forwarding]]. The <code>All</code> keyword works for these array-reducing functions, [[Sum]], [[Min]], [[BitAnd]], [[BitOr]] and [[BitXOr]].
* If you write your own function, and want it to accept the keyword <code>All</code> for a repeated index parameter, you can include a new <code>OrAll</code> [[Function parameter qualifiers|function parameter qualifier]].
* When passing a [[Local function]] (aka '''lambda function''') as a parameter to a function call, you no longer have to include a function name (which wasn't used anyway).
* You can use '.. operator ([[Repeated parameter forwarding]]) on literal lists to "splat" lists (or 1-D arrays) together into the list. Example:
*:<code>[[Local]] s1 := 'c'..'f', s2 := 'h'..'k' Do [ 'a', 'b', ...s1, 'g', ...s2, 'l' ]</code>
*::→ <code>['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l']</code>

== Built-in functions ==
* [[OAuth2Authorize]]: A new function to log into web services such as Google docs, sheets, Salesforce, etc., which makes it much easier for Analytica models to access (read from or write to) web applications that require authentication.
* <code>[[TypeOf]](x, shallow: True)</code> now returns <code>"Image"</code> when <code>x</code> is an image.
* When <code>x</code> is an image, <code>f"{x:H}"</code> returns the long hex string that appears in a [[Pict]] attribute in a model file (but without the parens around it that appear in the model file).
* [[ReadTextFile]] returns the file encoding as its fourth return value.
* [[RunConsoleProcess]] is able to launch several applications that it previous could not, including PowerShell.
* New syntactic extensions added to the [[Arrow_operator#x_.E2.86.92_.5Bi.5D|arrow operator]], namely <code>x→[n]</code> and <code>x→[m..n]</code> for [[Text values]] and [[In-memory binary data terms]].

== File saving and loading ==
* '''Add Library...''' defaults to ''Link to filed module or library'' for almost all the standard libraries, which is the preferred way to add libraries to your model. (Except it still defaults to ''Embed a copy'' for the [[ACP Style Library]] since that library acts more module-like and changes its internal state).
* You can now set the [[Att_Dirties]] attribute (to 0) for your own user Variables. When set to 0, a change to the Definition doesn't dirty the Library or module that contains the Variable.

== Example models and libraries ==
* A new example model included: <code>"Engineering / Generator availability.ana"</code>
* An able to handle file paths > 256 characters in most cases. Actually taking advantage of this requires you to have long paths enabled in Windows, e.g., by setting the registry setting
*::<code>HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem :: LongPathsEnabled = 1</code>
*:or by using the <code>\\unc\.... </code> syntax for file paths. However, long file paths are not supported by Microsoft One drive or by Microsoft office, including Excel, so you cannot use long paths for files within a One drive folder or when opening a spreadsheet file.
* Several of the diagram themes in the [[Themes Library]] were renamed.

== Graphing ==
* For Filled-area charts, in '''Graph set up''' you can now set the '''Fill type''' to "From origin"., and then select the '''Fill origin''' in the graph. A common use is in probability bands plot to select <code>.Probability=0.5</code> as the fill origin, to produce a plot like this:
*:::[[image:filled_bands_plot.png]]
*: You could previously do this by placing the [[Plot solid prob bands]] function in the [[OnGraphDraw]] attribute, but the new feature is much easier to configure, with just a few clicks in the [[Graph setup dialog]].
* '''Graph Setup / Text / Adapt displayed font sizes to graph height''' now uses the current height of the graph window you were viewing as the reference height, so that the font sizes you select in the graph setup dialog will be correct when the graph is at that height. Font sizes automatically adjust when you change the graph window size. Previously the reference height was fixed at the default result window height (a graph of 241 pixels tall), which tended to make the fonts way too large for normal window heights. We now recommend using this setting by default so that text on graphs is easily legible at various sizes.

== Other GUI ==
* There are a few new options on the '''Windows''' menu:
** Bring next window to front
** Bring previous window to front
** [[Typescript window|Typescript console]] to show the Typescript window. (Still also available with ctrl+'.)

== Licensing ==
* [[ParseJSON]] and [[MakeJSON]] no longer require {{Analytica Enterprise}}.

What's new in Analytica 7.1?

2026-08-17T20:25:19Z

Lchrisman: Live with 7.1 release.

Analytica release 7.1 is the current official release of Analytica. This page lists features that were added since the previous [[Analytica 7.0]] release.

== Highlights of Analytica 7.1 ==

'''[[#Assista|Assista]]:''' By far the most visible improvement is in [[#Assista|Assista]], Analytica's A.I. helper. When first released in Analytica 6.5, Assista was already quite useful for explaining Analytica features, describing and documenting models, and building models, but it was a bit unreliable in Analytica syntax and arranging influence diagrams. We think you will find that the latest version is so much smarter and more reliable, you may find chatting with Assista is the main way you interact with Analytica. Of course, the familiar influence diagram interface is still there when you need it. But now Assista is pretty good at drawing diagrams and writing Analytica expressions.

[[File:Assista What kinds of things can you do.png|alt=Assista dialog screen answering "What kinds of things can you do?"|thumb|600x600px]]
Other improvements include faster response time, better look and feel, a trace of its thinking, the ability to save and use conversations from previous sessions, ingesting files to provide information, including txt, pdf, csv, xlsx; understanding images and diagrams; a set of skills that you can extend and customize, and more.

'''[[#Engine|Performance]]:''' Large models start up much faster using multiple processes to parse the definitions. Arrays now use a ''tensor'' representation, similar to AI frameworks like PyTorch and TensorFlow, but with Index labels that support "Intelligent Arrays". This internal improvement isn't noticeable to users -- but enables major future performance improvements.

'''[[#Spreadsheets|CSV and spreadsheet files]] :''' You can now import [[#CSV files|CSV files]] simply by dragging them into an diagram or in a command line when you start Analytica. You can create a new [[#spreadsheets |spreadsheet]] with and add or remove sheets from it.

'''[[#Spanish|Espagnol]]:''' The user interface now supports Spanish -- with other languages in the future. Assista already supports most languages, and explains features (translating docs) in your language.

== Assista ==
[[Assista]] is an AI collaborator in Analytica, greatly improved in this release:
* The '''chat window''' is faster and more responsive, with a new look and feel, and clear formatting of responses. Leave it within the Analytica window, or move it anywhere on your screen(s) to make best user of screen space.
* You can '''highlight, drag, and copy any text''' to paste elsewhere.
* Click the microphone button to speak your request. Click it again when you're done.
* Selected objects in the Analytica window stay selected as you type into Assista, so you can refer to them as "this variable" and so on.
* It shows its "thinking" while processing your request giving you a peek into what it is doing.
* It '''saves dialogs''', keyed to your model. You can resume a previous session for that model from a dropdown in the UI (saved on your local computer, not on our server).

On the '''backend,''' Assista has:
* A new '''processing pipeline''' enabling faster response and also enabling it work longer on harder tasks.
* An extensible set of '''skills (competencies)''', including structuring decision models, drawing influence diagrams, designing user interfaces, Analytica syntax, and more.
* You can create and expose [[Assista_-_Analytica_AI_Assistant/Custom_user_skills_for_Assista|your own custom skills]] to expand its capabilities, or ask it to create new skills for you.

Assist can now:
* '''Ingest documents''' (<code>*.txt, *.pdf, *.md, *.docx, *.xlsx, *.xlsm</code>) or URLs into the chat using a menu in the Request box, or by dragging and dropping files into the window. Assista "ingests" the files and can extract data from a doc or image, adding tables to your model, translate a spreadsheet into Analytica, or even implement a model described in the article.
* ''' "See" images''' in your model -- pictures in nodes, images in table cells, and diagram or graph screenshots.
* '''Create images and node icons''' in your model.
* '''Read from URLs''' that you explicitly point it to (or drag into the chat)
* Converse in most common '''languages.''' In Spanish, it can provide UI instructions referring to the Spanish-language UI elements.
* '''Explain its reasoning''' in previous requests and expand on ideas .
* '''Personalize tone''', style, level of verbosity and provide custom instructions. Click the icon in the top-left corner of the Assista window and select Personization.
* '''Generate reports''' as a downloadable PDF or Word document, which can contain tables, graphs, and influence diagrams from your model and formatted equations.
* '''Take you through a tutorial''' of how to use Analytica for new users.

== More languages: Spanish UI ==

Analytica now comes with a Spanish-language UI, in which its menus, dialogs, error messages and built-in function descriptions are all in Spanish. The installer runs with a Spanish UI by default when you are in a Spanish-language region.

You can override the default language by launching Analytica as:
* <code>Analytica.exe /lang:es</code>
*: or
* <code>Analytica.exe /lang:en</code>

You can also set the <code>Language</code> registry setting in the <code>"HKCU/Software/Lumina Decision Systems/Analytica"</code> hive to REG_SZ <code>"en"</code> on <code>"es"</code> for your default if different from your windows region setting.

You may ask "what about my language?". Stay tuned (and let us know there is a demand for your language). Once our AI translation pipeline is solid, it shouldn't be too hard for us to add more.

== CSV files and Spreadsheets ==

Import data

* You can drag and drop a CSV file onto the diagram (it does the same as using <code>File / Import...</code> on the *.csv file).
* You can drag and drop a CSV file, spreadsheet, or even a PDF or Doc containing tables into the Assista Window. Assista can then extract the tables and add them as
* If you launch Analytica from command line, you can include a CSV file as a parameter: <code>Analytica.exe MyData.csv</code>

Expanded Spreadsheet functions:
* <code>[[SpreadsheetOpen]]("new")</code> now creates a blank spreadsheet in memory. Works with both the Excel and LibXl backends.
* Preface a sheet name with + in the call to [[SpreadsheetSetCell]] or [[SpreadsheetSetRange]] to add a new sheet by that name to the workbook (as it applies the specified change to that new worksheet). Also works with Excel and LibXl backends.
* You can also now remove a sheet from a workbook using: <code>[[SpreadsheetSetCell]](wb, "-OldSheet", col, row, Null)</code>. The «col» and «row» parameters are required but ignored in this case.

== User Interface ==

* The frames of Windows (the "chrome", aka the "non-client area") now use the Windows 11 stylse -- i.e., thin (1 pixel) borders, rounded corners at the top, white title bar, and plain (text-like) button images in the toolbar.
* The [[Outline window]] is now docked on the left of the Anallytica Window, and won't overlap other windows.
* The '''Node Icon editor''' (on the Diagram menu) is far more powerful. You can use it to edit arbitrary node images, with color and transparency.
* New keyboard shortcuts for '''Set Node Style...''' and '''Set Diagram Style...'''
* The new '''Use as default arrow style''' on the right-click menu for an influence diagram arrow lets you set model defaults arrows styles, such as thickness and color.
* When your model uses a [[Modules_and_Libraries#Filed_Module|filed module]] or [[Modules_and_Libraries#Filed_Module|filed library]], it auto-detects any changes to the source file, and informs you, letting you update to (reload) the new version.

== Built-in functions ==

* New options for [[GetProcessInfo]]: <code>"Number of monitors"</code>, <code>"Current monitor rect"</code>, <code>"Current monitor work rect"</code>, <code>"Monitor «N» Rect"</code>, and <code>"Monitor «N» work rect"</code>.
* Several new optional parameters to [[Evaluate]].
** «throwParsingErrors»: Flag to throw a parsing error instead of returning [[Null]] when the call to [[Evaluate]] is not inside a [[Try|Try...catch]].
** «maxSeconds»: Adds a timeout if the evaluation does not complete within the specified time duration.
** «ignoreAtFirstWarning: Flag used in conjunction with «reportOutput». When set, includes the first warning text in the output reported to the «reportOutput» function, and then ignores additional warnings during the duration of the Evaluate calls (this enables [[Assista]] to see the warnings).
** «reportOutput»: Accepts a function (usually a [[Local function]]). Calls it with output that was written to the typescript window during the evaluation, including stuff written by [[ConsolePrint]].
* New optional parameter, «throwParsingErrors», to [[Evaluate]].
* [[ReadFromURL]] is a bit smarter about returning binary content (like <code>*.zip</code> files) as a [[In-memory binary data terms|Binary Data Term]].
* [[MakeJSON]] will automatically encode an image in base64 JSON, and [[ParseJSON]] will automatically decode a base64 representation into an image. Also there is a new «maxCells» parameter that can be used to prevent giagantic arrays from being encoded (resulting in immensely long text).
* <code>[[GetProcessInfo]]("UI Language")</code> returns the UI language, either <code>"en"</code> (for English) or <code>"es"</code> for Spanish.
* <code>[[QualifiedName]]( obj, nsContext )</code>: Returns the qualified identifier (as text) that uniquely identifies «obj» from the context of «nsContext».
* <code>[[Namespace]] of X</code>: A new virtual attribute that returns the namespace of «X».
* Added a syntax construct for [[Namespaces#Scoped_namespace_inclusion:_Using|Scoped namespace inclusion]] to bring a namespace into scope for only a localized expression or lexical block.
* File functions ([[ReadTextFile]], [[WriteTextFile]], [[ReadBinaryFile]], [[WriteBinaryFile]], [[ReadImageFile]] and [[WriteImageFile]]) have a new optional parameter, «extensionFilter», where you can specify which file extensions show up on a file selector dialog.

== Engine ==

* You can use a localized namespace import (for a single expression or single lexical block) with the syntax
*:<code>[[Using..Do|Using]] NS;</code>

When opening a model file, the "checking" stage (when attributes are parsed) parses different expressions on different threads, resulting in substantially faster model load times for very large models.

Note: In the event that this creates a problem with your specific model (maybe due to an as-yet-undiscovered multithreading bug), you can disable it for your model as follows:
# Temporarily turn off multithreading (Skip this step if you are able to load your model)
## New model
## Definition menu / System variables / Settings / Maximum evaluation threads
## Set to 1 (and remember the previous value)
# Open your model
# Definition menu / System variables / Settings / Disable Multithreaded Evaluations
# Press the <code>Edit Table</code> button.
# Check the checkbox for <code>Parsing</code>
# Save your model
# Definition menu / System variables / Settings / Maximum evaluation threads
#: Restore the original value from Step 1

== MCP server for LLMs ==
* You can install multiple ADE-based Mcp servers that run different ADE releases. For example, you could install two MCP servers into Claude Code to compare results for the same model across different releases:
* ade-server: Runs ADE 7.1
* ade-server-70: Runs ADE 7.0
The <code>«ADE install folder»\Examples\Mcp_server\README.txt</code> file explains how, with enough info for Claude code to configure this for you.

Side note: The Mcp server was added to ADE 7.0.

== Internals ==

There has been major internal restructuring and refactorization in this release. This shouldn't change functionality, but may improve speed and memory efficiency now, and more in future releases.

* Internal data structures use for multi-dimensional arrays has been changed. Possible impacts:
** Reduced sensitivity to the "canonical order" of indexes on evaluation speed.
** Evaluation speeds of various functions and operations.
* When loading a large model, it parses expressions in parallel, using multiple threads/cores. On some computers on some models, this dramatically speed sup model load time.
* Added system modules/namespaces: <code>SysLib_Internal</code> and <code>SysLib_Experimental</code>. Intended for Analytica-internal use.
* [[:Category:Cell format functions|Cell formatting functions]] (like [[CellSpan]], [[CellFill]], etc.) are now [[Struct]]s rather than functions. Does not impact usage, other that making it easier for code to traverse resulting data structures.
* Color attributes use color integers for consistently (rather than the legacy number triples for R,G,B).
* SysVar [[Graph_ColorSequence]] replaces [[Graph_ColorSeq]] which is now deprecated. It contains a list of color integers with one integer (of the form <code>0x00rrggbb</code>) per color (the old version used a triple of numbers per color).

== Discontinued... ==

* Plug-in functions. (An old hook that allows you to extend Analytica with compiled functions and UI elements written it C++. We are almost certain no one is using these hooks any more.)
* The sysvar [[Graph_ColorSeq]] is now deprecated (but works for both reading and setting to preserve backward compatibility). It has been replaced by the system variable [[Graph_ColorSequence]].
* The built-in (but undocumented, unsupported) <code>ifpos</code> and <code>if0</code> functions were removed.
* The legacy (deprecated) syntax <code>Using temp:=... Do</code> for declaring locals is no longer supported. Legacy models will have such definitions automatically rewritten to use [[Local..Do]] when you load them. [[Using..Do]] now has a different meaning, which is to provide a temporary namespace import.

What's new in Analytica 7.0?

2026-08-17T20:23:54Z

Lchrisman:

[[category:What's new pages]]
[[category:Analytica releases]]

This page lists new features in [[Analytica 7.0]] since the previous [[Analytica 6.6]]. Its successor, [[Analytica 7.1]] has been released, making this a past (non-current) release.

==Highlights of Analytica 7.0==

* '''[[#Python integration|Python integration]]:''' The major enhancement is integration with Python and hence the entire Python ecosystem of libraries. You can easily call functions from Python libraries, access Python variables, and even write Python code right inside Analytica variables and functions. So now you can mix and match Analytica and Python according to which language you think best for your modeling or coding needs.
* '''[[#Index label auto updates|Index label auto updates]]:''' A common source of errors has been when you change a text label in an Index without remembering to change expressions that refer to that same text label. Changes to labels now update automatically in expressions in most cases.
* The '''Analytica Enterprise'''' edition has been renamed the [[#Developer Edition (formerly known as Enterprise) |Developer edition]], which better reflects what it is.
* It introduces two new object Classes:
** [[Struct]] lets you bundle disparate values, like text, numbeers, atoms and arrays, together in one object that does not array abstract -- similar to Records and Classes in other languages).
** [[Callable]] is like a user-defined Function but it's Definition can be a [[handle]] to a Python class or a Python function.
* [[ParseJSON]] and [[MakeJSON]] now use Structs, which are much more convenient for representing the hierarchical structure of JSON.
* [[#SpreadsheetOpen|Read and write spreadsheets without Excel]]: This is faster and more robust, and you don't need Excel installed.

== [[Using Python from Analytica|Python integration]] ==

You can now write Python code inside Analytica definitions! It's easy to call Python functions, with Analytica-style Intelligent Arrays!. So you can access the vast ecosystem of Python libraries (''modules'' in Python lingo). Among the gazillion possibilities are specialized libraries for data visualization, statistics, machine learning, and much more.
It means that you can mix and match Analytica and Python -- write Analytica code for what's easiest in Analytica and Python code for what's easiest in Python.

See: [[Using Python from Analytica]]
(In [[Analytica Developer]] edition or better).

For the Analytica modeler, this puts a ton of resources at your fingertips.

It's also pretty cool for the Python developer. Analytica is like a new interactive development environment with a lot of unique advantages, especially during interactive code development:
* Analytica's dependency maintenance can be really convenient during interactive development, creating automatic dependency maintenance between your Python functions, classes and variables that don't exist in Python.
* The visual influence diagram layout can be a super useful to way organize and visualize your code.
* It naturally encourages declarative code practices, which leads to better and more maintainable coding style.
* You get the benefits of Analytica's edit tables, plus for results, Analytica's multi-D result tables and one-click, no-code, graphing.
* It is easy to wrap existing Python models to get Monte Carlo, parametric analysis and sensitivity analysis with Analytica ease.
* Sometimes one or the other language is more convenient for a particular task. You can freely switch between whichever language feels better suited to the immediate task, and intermix languages easily.

== Developer Edition (formerly known as Enterprise) ==

Analytica's middle-tier edition formerly known as the ''Enterprise Edition'', it is now called the [[Analytica Developer|Analytica Developer edition]]. That name better reflects what it is--software for developers of decision applications. If you're now a user of Analytica Enterprise you don't have to update your license or do anything special. The name will just change when you install Analytica 7.0. In Analytica docs, when you select "7.0" on the release bar (at the top of pages that have release-contingent content), all the docs automatically use the new Analytica Developer edition name.

== Analytica language extensions ==

=== Index label auto updates ===

When you change the identifier of a variable, Analytica automatically updates all Definitions to use the new name. But, when you change a text label in an Index, it previously caused an error in any Definition using that label. For example, if you have
<code>
Index Animal := ['Cat', 'Dog']
Variable Sound := IF Animal = 'Cat' THEN 'Miaow' ELSE 'Woof'
</code>
If you change <code> 'Cat'</code> to <code>'Feline' </code> in Index <code>Animal</code>, the Definition of <code>Sound</code> will now automatically update to
<code>
IF Animal = 'Feline' THEN 'Miaow' ELSE 'Woof'
</code>

It does this wherever it sees <code>Animal= 'Cat'<label></code>. If you use an index label in a context where the index doesn't normally appear, you should use the new [[Index-label dot syntax]] (<code>Animal . 'Cat'</code>). By associating the label with its index it will automatically update when needed. These [[Keeping text literals consistent with index labels| features]] help you avoiding a common error when updating text labels in Indexes.

=== Callable ===

The new object [[Class]] [[Callable]] is a variable-like object, meaning it has a [[Definition]] and a computed value, but can be used for convenience and documentation when the computed value itself is something that can be called, such as a [[Local function]] (aka ''lambda function''), a [[handle]] to an global function, a Python class or a Python function.

If you "compute" the identity of a callable data item inside a normal [[Variable]] instance, <code>X</code>, you could call it using the syntax <code>X->(a,b,c)</code>. On your influence diagram the object would have a rounded rectangle and thus would not communicate that the result is something that can be called. When you change its class to be a [[Callable]], you can then invoke the call using the syntax <code>X(a,b,c)</code> and the shape of the node changes to something that resembles a function shape, thus communicating that this holds something that is callable.

To create a callable, first create a [[Variable]] node, then use the [[Class]] dropdown from the [[Object window]] or [[Attribute pane]] to change the class to ''Callable''.

=== Struct ===
A [[Struct]] defines a new atomic, immutable data type. For use when you need to bundle multiple heterogeneous items and don't want their dimensionalities to interact. Array abstract treats an instance of a Struct as a single cell (an atom).

=== Expression and Lazy qualifiers ===
An expression passed to a function parameter declared with the qualifier as <code>[[Function_parameter_qualifiers#Expression|Expression]]</code> can now include local variable identifiers. The local variables are captured (similar to how they would be captured by a [[Local function]]).

A new function parameter qualifier, [[Function_parameter_qualifiers#Lazy]], has been added, which does lazy evaluation of the expression passed to it. In the function Definition, you can use it as if it were a normal value parameter, but evaluation occurs when the value is used rather than when the function is called, and in the evaluation context (which includes the [[Evaluation modes|evaluation mode]]) where the value is used instead as in the context of the call.

=== Excess parameter qualifier ===
A new function declaration allows a function to tolerate or capture excess named parameters in the call that are not declared as parameter names in the function's Parameters declaration. It can also be used in a [[Struct]] declaration.

== Functions ==
=== ParseJSON ===
Changed to parse to [[Struct]]s, thus greatly simplifying and improving the convenience of using JSON in Analytica expressions.

For parsing with a schema, a Struct's declaration serves as the schema, which is far easier and more familiar for an Analytica user than the former scheme for specifying a schema.

[[MakeJSON]] is able to generate JSON from a Struct (or nested structs) as well, which is the most convenient representation for JSON representations.

=== SpreadsheetOpen ===
Added a new «backend» parameter to [[SpreadsheetOpen]] with a new option of <code>'LibXl'</code>, allowing you to read and manipulate a spreadsheet without having Excel installed. But unlike the Excel backend, the LibXl option does not have a calculation engine (so can't recompute cell formulas after you change cells). This option is be better when you simply want to read (or write) data in a *.xlsx file format.

== Example models and libraries ==

* There is a new "Auto insurance claim risk analysis.ana" in the Example Models / Risk Analysis folder.
* The [[Mutables library]] has been updated. It provides a new [[Mutable]] [[Struct]] which is superior to the older representation, which displays the actual value in result table cells and is atomic. The legacy functions ([[MutableNew]], [[MutableSet]] and [[MutableGet]]) are still there for backward compatibility, but have been changed to just wrap the new Mutable.

== Result tables and graphs ==
* A blank (none) entry was added to the [[XY_comparison#Use_comparison_index|comparison index pulldown]]. Use this to quickly unset the comparison index without having to re-enter the [[XY_comparison]] dialog. Also, the pulldown is now visible and enabled in browse mode.
* Comparison variables are no longer summed over slicer indexes that are set to '''Totals''' when the value for that variable does not include the slicer index. Note that this results in some changes to what is displayed in table body cells and in axis scaling on graphs.

== Assista ==

You can now copy-paste from Expression blocks in Assista's response using the little copy icon in the top-right corner of the expression block.

== Experimental ==
* A way for an Analytica model running in desktop Analytica to [[MCP server in Analytica|act as a Model Context Protocol (MCP) server]] for use by Large Language Models (LLMs).

== ADE ==
* Added a new example: <code>Mcp_server</code>. This is an MCP server that wraps ADE. Among other things, it can give AI agents like Claude Code the ability to build, explore and use Analytica models.

Analytica Docs

2026-08-17T20:21:43Z

Lchrisman: /* What's new in Analytica 7.1? */

[[Category: Analytica Docs]]
{| class="wikitable" style="width: 90%"
|style="width: 100%;border: 1px solid #ffffff;background-color:#ffffff; text-align:center;" |
[[File:Splashero.png|center|500px]]

|}

{| class="wikitable" style="width: 100%; border: 1px solid #ffffff"
|style="width: 33%;border: 1px solid #ffffff;padding: 10px; background-color:#ffffff;vertical-align:top;"|
<big>'''About'''</big> 
These '''Analytica docs''' include a rich variety of [[Tutorial|tutorials]], [[User Guide|user guides]], example models, and reference materials. You can explore what's available in the '''Docs contents''' -- the expandable outline on the left of this and every page.

[[What are these Analytica docs?]] 

|style="width: 33%;border: 1px solid #ffffff;padding: 10px; background-color:#ffffff;vertical-align:top;"|
<big>'''Analytica'''</big> 
[[Open these docs from Analytica]] 
[[Edit and improve these docs]] 
[[What's new|What's new in the latest release?]] 
[[What's new in ACP?]] 
[[Editions of Analytica|Compare editions]] 
[https://analytica.com/products/free/ Download Analytica Free Edition] 
[https://analytica.com/analytica-downloads/ Download Analytica and ADE] 
|style="width: 33%;border: 1px solid #ffffff;padding: 10px; background-color:#ffffff;vertical-align:top;"|
<big>'''Getting Started'''</big> 
[[Analytica Tutorial|Tutorial]] 
[[Building Effective Models]] 
[[Creating Lucid Influence Diagrams]] 
[[Indexes and arrays: An introduction|Intro to Indexes and Arrays]] 
[[Example Models and Libraries]] 
|}

==[[What's new in Analytica 7.1?|What's new in the latest release of Analytica?]]==

=What if you don't read docs or tutorials?=

If you want to use Analytica but don't want to spend time reading these docs, you're in luck!
Start up Analytica and open Assista -- the AI collaborator. You can ask it anything about Analytica. Or you can just ask it to help you build your model. And you can learn Analytica in the process.

==Recent additions==
{| class="wikitable" style="width: 100%;vertical-align:top;"
|-
|rowspan="2" style="width: 50%;vertical-align:top;"| <big>[[Assista]]</big> 
Analytica's new AI assistant has a conversational interface to answer questions about Analytica and your model. It can even help you build your model and write Analytica expressions. It makes modeling much faster and more convenient. Learn more at [[Assista]].

|[[Database library]]: A library of functions to make it easy to create, read, update, examine and delete database tables, without having to write SQL.
|-
|[[Themes Library]]: Use the Themes Library to quickly update your diagram and graph styles with some new and updated preset themes!
|-
|[[Weibull estimation library]]: Functions to generate and estimate Weibull distributions for lifespan or time to failure from data.
|[[Why Analytica doesn't need Map and Reduce functions]] Analytica's Intelligent Arrays mean that you can operate on arrays directly, without needing to use these functions, or even know what they are.
|}

Template:ReleaseBar

2026-08-17T15:54:41Z

Lchrisman: Change default to 7.1 for the 7.1 release.

{{#svarset:anarelease|{{#urlget:anarelease|{{#svarget:anarelease|7.1}}}}}}{{#svarset:show_full|
{{#ifexpr: {{#isReleaseBetween:1.0|{{#svarget:anarelease}}|5.9}} |1|}}
}}{{#switch:{{#svarget:anarelease}}
| 4.6 =
| 5.0 =
| 5.1 =
| 5.2 =
| 5.3 =
| 5.4 =
| 6.0 =
| 6.1 =
| 6.2 =
| 6.3 =
| 6.4 =
| 6.5 =
| 6.6 =
| 7.0 =
| 7.1 =
| 7.2 =
| #default = {{#svarset:anarelease|7.1}}
}}{|class="release-table"
|-
! Release:
|
{{#if: {{#svarget:show_full}}
| 
{{ReleaseBarItem|4.6|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.0|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.1|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.2|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.3|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.4|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.0|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.1|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.2|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.3|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.4|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.5|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.6|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|7.0|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|7.1|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|7.2|{{#svarget:anarelease}}}}
| 
…

 • {{ReleaseBarItem|4.6|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.0|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.1|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.2|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.3|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.4|{{#svarget:anarelease}}}} • 
 • 
{{ReleaseBarItem|6.0|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.1|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.2|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.3|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.4|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.5|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.6|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|7.0|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|7.1|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|7.2|{{#svarget:anarelease}}}}
}}
|}{{#svarset:anamajor|{{#expr:floor{{#svarget:anarelease|7.1}}}}}}<noinclude>

To display a release bar at the top of a page, insert the following at the top:

<nowiki>{{ReleaseBar}}</nowiki>

You must have a Release Bar visible for a <nowiki>{{Release|startVer|endVer|content}}</nowiki> macro to work properly within the page.
</noinclude>

Additional libraries

2026-08-14T17:58:09Z

Lchrisman: Add the Salesforce REST library to the data-source libraries

[[Category:Function libraries]]
{{ReleaseBar}}
__TOC__

This page describes a set of useful Analytica function libraries. These are ''additional'' to the [[Standard libraries]] that are automatically installed when you install Analytica. If you want to use any of these additional libraries, click on its link and it will download onto your computer. Depending on your download settings, it may automatically open it in Analytica. Either way, you should save it into a directory so that you can add it into your models. It's usually most convenient to save it with your [[Standard libraries]] in directory
:<code>"C: \Program Files\Lumina\Analytica {{#svarget:anarelease|6.5}}\Libraries"</code>

You can then easily add it into your models using the standard menu option '''Add Library...''' from the [[File menu]].

See [[User-defined Functions and Libraries]] to build your own functions and libraries.

__TOC__

== Misc. libraries ==
=== Large Sample Library ===
'''Download:''' [[media:Large_Sample_Library_v10.ana]]

:[[image:Large sample library.png]]

The [[Large Sample Library: User Guide|Large Sample Library]] is an Analytica library that lets you run a Monte Carlo simulation for large models or a large sample size that might otherwise exhaust computer memory, including virtual memory. It breaks up a large sample into a series of batch samples, each small enough to run in memory. For selected variables, known as the Large Sample Variables or LSVs, it accumulates the batches into a large sample. You can then view the probability distributions for each LSV using the standard methods — confidence bands, [[PDF]], [[CDF]], etc. — with the full precision of the large sample.

See [[Large Sample Library: User Guide]].

===The Sensitivity Analysis Library===
[[The Sensitivity Analysis Library]] provides functions for analyzing the sensitivity of an output to each cell of each array-valued chance input, and locating those individual scalar inputs that have the greatest impact on the result. See [[The Sensitivity Analysis Library]] for documentation on using this library.

The library itself can be downloaded from [[media:Sensitivity Analysis Library.ana|Sensitivity Analysis Library.ana]], and an example model to demonstrate its usage is at [[media:Sensitivity Functions Examples.ana|Sensitivity Functions Examples.ana]].

=== Model Documentation Library ===
'''Download: ''' [[media:Model Documentation Library.ana|Model Documentation Library.ana]]

'''Prerequisites:''' [[Analytica 5.0]] or later. The [[Preferences_dialog|Domain acts as self index]] legacy preference must be OFF. You must be using [[Diagram_Style_dialog|ClearType text]] (not the very old non-clearType legacy setting).

Some people like to create a concise report on paper that contains all objects in their model along with descriptions or other selected attributes. The "Print Report" feature in Analytica can be used for this purpose, but is not at all concise and ends up placing each object window on a separate page. The ''Model Documentation Library'' allows you to select a module from your model and produce a result table containing every object within that module with its selected attributes such as title, description, units, definition, or user-defined attributes. This table can then be exported to Excel where you can format it nicely and print it. Thus, you can end up with a very concise report on paper.

To use this library, load your model and then select '''File → Add Module...'''. Add the [[media:Model Documentation Library.ana|Model Documentation Library.ana]] module file using Embed. In that module, using the pulldown, select the top-level module for the report. Follow the instructions shown on the diagram. If you make changes to your model later, press the ''Update Model Documentation'' button to adjust the pulldown content.

=== [[Units Conversion Library]] ===
'''Download: ''' [[media:Units conversion library.ANA|Units conversion library.ana]]

These functions convert between different units -- for example, from feet to kilometers, or from Btu (British thermal units) to gigajoules of energy. They relieve you from having to look up conversion factors. They also make your model more transparent by making it clear where you are converting from one units to another -- instead of just embedding conversion constants in the formulas.

[[File:Units conversion library.png|600px]]

You can use the '''Conversion example''' section to enter a quantity, select its type (dimensions) and units, and convert it to another unit of that type.

====Library functions====

'''Units_factor'''(oldUnits, newUnits) to give a conversion factor between two units.
If you omit newUnits, it will assume the standard units for that type (dimensions).
The units parameters text values must match an abbreviation, synonym, or full name (case insensitive) in the Units data table.
If the units are of different dimensions, e.g. energy and power, or if it doesn't recognize the units, it will give an error.

'''Units_conversion'''(x, oldUnits, newUnits) returns the value of quantity x converted from oldUnits to newUnits. This works for units like temperature, where simple factors don't work.

'''Units_real_dollars'''(yr, baseYr) returns a multiplication factor used to convert nominal dollars in year yr to real (also known as constant) dollars using baseYr as the base year. If you omit baseYr, it uses the "Standard base year for inflation" which you can set in the Units Conversion Library user interface. It uses consumer price index data provided by the US Energy Information Administration from 1949 to 2017 with projections up to 2040. It gives an error if yr or baseYr are outside that range.

The '''Units_table''' contains the list of units, with abbreviation, full-name, and synonyms, type (dimensions) and conversion factors to the base unit for each type. For example, the base unit for 'Energy' is Joule. The conversion factor for gigajoule (GJ) is 10^9. You can add your own units. Be careful to select the correct type (dimensions).

=== Greatest Common Divisor functions ===
'''Download: ''' [[media:GCD function library.ana|GCD function library.ana]]

This library contains two [[User-Defined Functions]] for computing the greatest common divisor.

=== [[Database library]] ===
'''Download: ''' [[Media:Database library.ana|Database library.ana]]

A library of functions to make it easy to create, read, update, examine and delete database tables, without having to write SQL. It works with Microsoft Access, Microsoft SQL Server, MariaDB, and PostgreSQL, and can be expanded to support other database platforms.

=== [[Salesforce REST library]] ===

Reads Salesforce records and metadata into your model through the Salesforce REST API. It provides OAuth 2.0 client-credentials authentication, SOQL queries with automatic pagination, record retrieval, SOSL search, and Salesforce object and field metadata. It reads from Salesforce -- it has no functions to create, update, or delete records.

Requires [[Analytica 7.1]] {{Analytica Developer}} edition or better. See [[Salesforce REST library]] for the download and the function reference.

=== DB Conversion Library ===
'''Download: ''' [[media:Db conversion lib.ana|DB conversion lib.ana]]

Lets you embed data obtained from a database into the Analytica model. This breaks the need to use it with an external database, so -- for example -- you can send to someone (e.g. Lumina tech support) who does not have access to the database or has an edition of Analytica (e.g. Professional) that doesn't support database access.

Press a button in this library to transform all the variables defined using [[DbQuery]], [[DbLabels]] and [[DbTable]] to literal data. Variables and indexes defined using [[DbQuery]] or [[DbLabels]] are transformed to list definitions, and those defined using [[DbTable]] are transformed into edit tables. This breaks the connection to the external database. So, of course, the model will no longer be able to get new or extended data from the database.

The library is limited in its scope. It only works when all calls to [[DbQuery]], [[DbLabels]] and [[DbTable]] occur at the top level of variable definitions. Do not try to use it if the calls to these functions are embedded within larger expressions or in [[User-Defined Functions]].

'''''Use with extreme caution!!''''': Make a copy of your original model ''before'' adding and executing this module. After running the transformation, be sure to use '''File → Save As...''' to save the transformed model under a different filename, so you don't clobber your original model.

=== Spreadsheet Helper Library ===
'''Download: ''' [[media:Spreadsheet Helper lib.ana|Spreadsheet Helper lib.ana]]

Includes functions that return the list of worksheet names and the Excel filename of the workbook. It also contains a SpreadsheetOpenEx function that can be used in place of [[SpreadsheetOpen]], but which remembers the filename selected by the user so the next time they don't have to select the file again.

=== Data Standardization Library ===
'''Download: ''' [[media:Data Standardization Library.ana|Data Standardization Library.ana]]

Imported data is often inconsistent. This library allows you to choose what the "standard" values should be in a column of data. You can then map any non-standard value to one of the standard values. The result is a column of consistent data.

== Additional probability distributions ==

=== Laplacian distribution ===

'''Download: ''' [[media:Laplacian distribution library.ana|Laplacian distribution library.ana]]

'''Description: ''' The Laplacian distribution (or [https://en.wikipedia.org/wiki/Laplace_distribution Laplace distribution]) is a continuous, unbounded distribution that is essentially a double-sided [[Exponential distribution]] with a «mean» parameter. The library contains the distribution function, and the analytica functions for density, cumulative density and inverse cumulative density (the quantile function).

== The HDR pseudo-random number generator ==

'''Download:''' [[media:Hubbard HDR Library.ana|Hubbard HDR Library.ana]]

'''Authors:''' [https://en.wikipedia.org/wiki/Douglas_W._Hubbard Doug Hubbard], [https://hubbardresearch.com/ Hubbard Decision Research], and Lonnie Chrisman, [https://lumina.com Lumina Decision Systems]

'''Description:''' [https://www.researchgate.net/publication/338824184_A_Multi-Dimensional_Counter-Based_Pseudo_Random_Number_Generator_as_a_Standard_for_Monte_Carlo_Simulations The HDR] is a simple, open-source pseudo-random number generation algorithm. It has been embraced by organizations such as [https://ProbabilityManagement.org ProbabilityManagement.org] as a standard for efficiently exchanging exact Monte Carlo samples. Given 4 integer seed values, the sequence is deterministic, so two parties with these same 4 values can reproduce precisely the same sequence up to a length of 100M samples, even from Excel. Select a different combination of seeds to prevent any two independent simulations from inadvertently using the same random number stream. This ensures that independent simulation results can be combined without unintended correlations. Or use the same combination of seeds to intentionally produce identical simulations of the same stream. This allows entire Monte Carlo simulation samples to be communicated in just a few numbers.

This library provides the functions for using HDR in an Analytica model. The <code>Hubbard_HDR(...)</code> function enables you to obtain the nth random number in a sequence, while the <code>HDR_U(...)</code> function acts as a <code>[[Uniform|Uniform(0,1)]]</code> distribution as is convenient to use in any Inverse Cumulative Probability Function (e.g., [[CumKeelinInv]], [[CumNormalInv]], [[CumBetaInv]], etc) to encode a specific distribution inside a model.

* Douglas Hubbard (Aug 2019), "[https://www.researchgate.net/publication/338824184_A_Multi-Dimensional_Counter-Based_Pseudo_Random_Number_Generator_as_a_Standard_for_Monte_Carlo_Simulations A Multi-Dimensional, Counter-Based Pseudo Random Number Generator as a Standard for Monte Carlo Simulations]", Winter Simulation Conference, Washington DC, DOI: 10.1109/WSC40007.2019.9004773.

== Individual functions with examples ==

'''Download: ''' [[media:Recumulate example.ana|Recumulate example.ana]] : Like [[Cumulate]], but resets to zero at selected points.

'''Download:''' [[media:Apportion.ana|Apportion.ana]]: Aggregates or disaggregates an array of values from one index to another index, where the second index may be larger or smaller. Does not require the indexes to be index multiples of each other. For example, if you map from a 47-element index to a 13-element index, each 3.62 elements of the original map to an element in the destination, so for example, the first 3 items map to the first item, then the fourth item is shared, with 0.62 apportioned to the first element and 0.38 apportioned to the second element. Supports aggregation types <code>'SUM'</code>, <code>'AVERAGE'</code>, <code>'MIN'</code> and <code>'MAX'</code>. Contributed by Paul Sanford of EPRI.

<div name="SequentialDispatch">
'''Download: ''' [[media:Sequential dispatch library.ana|Sequential dispatch library.ana]] : The function '''SequentialDispatch''' generalizes the [[Dispatch]] function by adding a time-like index to carry over unsatisfied demand or unallocated capacity. [[media:Sequential dispatch test.ana|Sequential dispatch test.ana]] is an example of its use.
</div>

== The [[Legendre Library]] ==
The [[Legendre Library]] includes functions for:

* Gauss-Legendre Quadrature
* Numerically stable, accurate and efficient calculation of an order n Legendre Polynomial at values -1<=x<=1
* Numerically stable calculation of the derivative of an order n Legendre Polynomial at x.
* Calculation of the zeros of Legendre polynomials.
* Calculation of the Legendre polynomial coefficients.

'''Author:''' Lonnie Chrisman, Lumina Decision Systems

'''Download:''' [[media:Legendre library.ana|Legendre library.ana]]

The library has [[Legendre Library|its own reference page]] on this wiki.

== Cell Icon Set Library ==
:[[image:CellIconSetExample1.png|600px]]

Provides pre-curated icon sets for use as [[CellIcon|cell icons in tables]]. The functions automatically select which icon in a set to use to depict the value that you want the icon to depict. Each icon set uses a consistent color scheme and consistent icon shapes having a consistent theme. Icon sets include shape collections, directional indicators, indicator styles and rating styles.

Without this library, you can use cell icons in table cells by using the [[CellIcon]] function in a [[Computed cell format attribute]]. But this requires you to find suitable icon images and write logic to map from your values to these images. This library takes care of these pain points for you.

'''Documentation:''' [[Cell Icon Set Library]]

'''Download:''' [[media:Cell_Icon_Set_Library.ana|Cell_Icon_Set_Library.ana]]

'''Author:''' Lonnie Chrisman, Lumina Decision Systems

==See Also==
* [[Standard libraries]]: Installed with Analytica
* [[User Libraries]]: How to create your own Libraries
* [[Example Models]]
* [[Large Sample Library: User Guide]]
* [[Modules and Libraries]]
* [[Filed modules and libraries]]
* [[User-defined Functions and Libraries]]
* [[Example Models and Libraries]]
* [[Financial library functions]]
* [[The Sensitivity Analysis Library]]
* [[Distribution Densities Library]]
* [[Linked list library]]
* [[Base Conversion Function Library]]
* [[Performance Profiler library]]
* [[List of libraries]]

Salesforce REST library

2026-08-14T17:49:34Z

Lchrisman: Pin the Libraries folder path to release 7.1, the minimum this library requires

[[Category:Function libraries]]
[[Category:Integration Functions]]

{{ReleaseBar}}

''Requires [[Analytica 7.1]] {{Analytica Developer}} edition or better.''

The '''Salesforce REST library''' lets your model authenticate with [https://www.salesforce.com/ Salesforce] and read Salesforce records and metadata through the Salesforce REST API, version 67.0. Use it to pull live data -- accounts, contacts, opportunities, or your own custom objects -- straight into an Analytica model, so that your analysis works from current CRM data instead of an exported snapshot.

It provides:
* OAuth 2.0 client-credentials authentication for unattended, server-to-server use
* A legacy SOAP-login option as a temporary migration bridge
* SOQL query execution, including automatic pagination
* Record-selection and record-retrieval helpers
* Salesforce object and field metadata
* SOSL search

This library reads from Salesforce. It has no functions to create, update, or delete Salesforce records.

'''Download:''' [[media:Salesforce REST library.ana|Salesforce REST library.ana]] (v. 1.01)

== Requirements ==

To use this library, you need:
* [[Analytica 7.1]] or later, {{Analytica Developer}} edition or better. The library is built on [[ReadFromUrl]](), which is not available in the Professional or Player editions.
* A Salesforce account, and an OAuth client configured in Salesforce (see [[#Setting up Salesforce for client-credentials authentication|Setting up Salesforce]] below).
* Internet access allowing Analytica to reach your Salesforce login and instance domains over HTTPS. If you have a strong firewall, you may need to add a rule to allow this.

== Getting started ==

# [[media:Salesforce REST library.ana|Download the library]] and save it into your <code>"C:\Program Files\Lumina\Analytica 7.1\Libraries"</code> folder.
# Launch Analytica and open your model, or start a new one.
# Select '''Add Library...''' from the '''File''' menu, select <code>Salesforce REST library.ana</code>, click '''OK''', select '''Link''', then click '''OK'''.

A typical model then uses three Variables -- an authentication Struct, a connection Struct, and one or more query results:

<pre style="background:white; border:white; margin-left: 1em;">
Variable Sf_auth ::= ClientCredentialsAuth(
"https://login.salesforce.com",
Sf_client_id,
Sf_client_secret )

Variable Sf ::= Salesforce( Sf_auth )

Variable Active_accounts ::= SalesforceSelect( Sf, "Account", "Id, Name, Industry",
where: "IsDeleted = false",
order_by: "Name",
row_limit: 100 )
</pre>

<code>Active_accounts</code> is a query-result [[Struct]]. Its list of records is:
:<code>Active_accounts -> records</code>

To read a field from the first record:
:<code>SalesforceField( Active_accounts -> records[@=1], "Name" )</code>

When you authenticate to a sandbox, use <code>"https://test.salesforce.com"</code> in place of <code>"https://login.salesforce.com"</code>.

== A brief introduction to SOQL ==

Salesforce Object Query Language (SOQL) resembles SQL, but it queries Salesforce objects and fields by their '''API names''' rather than by table and column names. A basic query looks like this:

<pre style="background:white; border:white; margin-left: 1em;">
SELECT Id, Name, Industry
FROM Account
WHERE Industry = 'Technology'
ORDER BY Name
LIMIT 100
</pre>

Standard object names include <code>Account</code>, <code>Contact</code>, and <code>Opportunity</code>. API names of custom objects and custom fields usually end in <code>__c</code> -- for example <code>License__c</code> or <code>Expiration_Date__c</code>. An object's API name is often not the same as the label you see in the Salesforce user interface, so use [[#SalesforceObjects|SalesforceObjects]]() and [[#SalesforceFields|SalesforceFields]]() to discover the names you need.

Whenever you insert a text value into a SOQL expression, quote it with [[#SalesforceSoqlQuote|SalesforceSoqlQuote]](). Don't use that function for object or field API names.

For the full language, see the Salesforce [https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/ SOQL and SOSL Reference].

== Setting up Salesforce for client-credentials authentication ==

[[#ClientCredentialsAuth|ClientCredentialsAuth]]() is meant for unattended, server-to-server access. It needs an OAuth client configured in Salesforce, plus a dedicated Salesforce user whose permissions the integration runs under.

Salesforce terminology and Setup screens vary by edition and release. In current releases the OAuth client is normally an '''External Client App'''; some organizations still use a '''Connected App'''.

A Salesforce administrator generally needs to:
# Create an '''External Client App''' in Salesforce Setup.
# Enable '''OAuth settings''' and the '''OAuth 2.0 Client Credentials Flow'''.
# Grant the OAuth scope needed for REST access, normally '''Manage user data via APIs''' (<code>api</code>). Avoid broader scopes unless you need them.
# Save the app, then copy its '''Consumer Key''' and '''Consumer Secret'''. These become the «client_id» and «client_secret» parameters in Analytica.
# In the app's OAuth policies, select a dedicated '''Run As''' integration user for the client-credentials flow. Depending on the app type, Salesforce may also require '''Admin approved users are pre-authorized'''.
# Give the integration user the permissions your model needs -- API access, plus read access to the required objects and fields. Prefer permission sets and least privilege.
# If the app uses pre-authorization, assign the app's permission set or profile authorization to the integration user.

The library sends the token request to:
:<code>https://login.salesforce.com/services/oauth2/token</code>
or, for a sandbox:
:<code>https://test.salesforce.com/services/oauth2/token</code>

Salesforce returns an access token and the instance URL that the library uses for all later requests.

For current Salesforce-side details, see the Salesforce [https://developer.salesforce.com/docs/platform/mobile-sdk/guide/oauth-client-credentials-flow.html OAuth 2.0 Client Credentials Flow] documentation.

=== Protect the client secret ===

The consumer secret grants access as the configured integration user. Don't save it in a model that you distribute to people who shouldn't have the credential, and don't commit it to source control. Where you can, obtain it at deployment time from your organization's approved secret-management mechanism.

== Authentication and connection ==

=== ClientCredentialsAuth(login_url, client_id, client_secret) ===

Authenticates using the OAuth 2.0 client-credentials flow and returns a [[Struct]] holding the access token.

:{| class=wikitable
! Parameter
! Meaning
|-
| «login_url»
| <code>"https://login.salesforce.com"</code> for production, or <code>"https://test.salesforce.com"</code> for a sandbox
|-
| «client_id»
| Consumer key from the Salesforce External Client App or Connected App
|-
| «client_secret»
| Consumer secret from the same app
|}

The Struct it returns contains these members:
* <code>access_token</code>
* <code>instance_url</code>
* <code>status_code</code>
* <code>status_text</code>
* <code>raw_response</code>

Example:
:<code>ClientCredentialsAuth( "https://login.salesforce.com", Sf_client_id, Sf_client_secret )</code>

When authentication fails, it reports an Analytica error that includes the HTTP status and the Salesforce response.

[[Parameter types]]: <code>ClientCredentialsAuth(login_url: Text; client_id: Text; client_secret: Text)</code>

=== Salesforce(auth) ===

Creates the connection Struct that you pass to every query, record, search, and metadata function. «auth» is the Struct returned by [[#ClientCredentialsAuth|ClientCredentialsAuth]]() or [[#SoapLoginAuth|SoapLoginAuth]]().

The Struct it returns contains these members:
* <code>api_version</code> -- <code>"67.0"</code>
* <code>instance_url</code>
* <code>access_token</code>
* <code>rest_base_url</code>

Example:
:<code>Salesforce( Sf_auth )</code>

It's usually clearer to define the authentication and the connection as separate Variables, as shown in [[#Getting started|Getting started]], so that you can inspect an authentication failure on its own. You can also nest the calls:

<pre style="background:white; border:white; margin-left: 1em;">
Salesforce(
ClientCredentialsAuth(
"https://login.salesforce.com",
Sf_client_id,
Sf_client_secret ) )
</pre>

All REST calls use API version 67.0, including calls authenticated through [[#SoapLoginAuth|SoapLoginAuth]]().

[[Parameter types]]: <code>Salesforce(auth)</code>

=== SoapLoginAuth(login_url, username, password, security_token) ===

Logs in with the legacy Salesforce SOAP Partner API <code>login()</code> call and returns a Struct whose session ID the REST functions use as a bearer token.

«security_token» is the Salesforce security token for that user account. The function concatenates it onto the password, as SOAP login requires.

'''This authentication method is a migration bridge only.''' Salesforce retires the SOAP <code>login()</code> mechanism on '''1-Jun-2027''', after which this function stops working. Write new models against [[#ClientCredentialsAuth|ClientCredentialsAuth]](), and migrate existing ones before that date.

[[Parameter types]]: <code>SoapLoginAuth(login_url: Text; username: Text; password: Text; security_token: Text)</code>

== Query functions ==

=== SalesforceSelect(sf, sobject, fields, ''where, order_by, row_limit'') ===

Builds and runs a common SOQL <code>SELECT</code>. This is the easiest entry point when your query has a straightforward <code>WHERE</code>, <code>ORDER BY</code>, and <code>LIMIT</code> structure. It returns the same query-result Struct as [[#SalesforceQuery|SalesforceQuery]]().

:{| class=wikitable
! Parameter
! Meaning
|-
| «sf»
| The connection returned by [[#Salesforce|Salesforce]]()
|-
| «sobject»
| Salesforce object API name, such as <code>"Account"</code>
|-
| «fields»
| Comma-separated field API names
|-
| «where»
| Optional SOQL condition, without the <code>WHERE</code> keyword
|-
| «order_by»
| Optional ordering expression, without the <code>ORDER BY</code> keywords
|-
| «row_limit»
| Optional maximum number of records. <code>0</code>, the default, applies no explicit limit
|}

The three optional parameters are declared <code>Named</code>, so pass them by name:

<pre style="background:white; border:white; margin-left: 1em;">
SalesforceSelect( Sf, "Contact", "Id, Name, Email, Account.Name",
where: "Email = " & SalesforceSoqlQuote( Target_email ),
order_by: "Name",
row_limit: 20 )
</pre>

It validates the object and field API names, but «where» and «order_by» are SOQL fragments that you supply. Quote any text value you interpolate into them with [[#SalesforceSoqlQuote|SalesforceSoqlQuote]](), as in the example above.

[[Parameter types]]: <code>SalesforceSelect(sf; sobject: Text; fields: Text; where: Named Text := ""; order_by: Named Text := ""; row_limit: Named Number := 0)</code>

=== SalesforceQuery(sf, soql, ''include_deleted, max_pages'') ===

Runs a complete SOQL expression and follows Salesforce pagination until it has retrieved every page.

It returns a query-result Struct with these members:

:{| class=wikitable
! Member
! Meaning
|-
| <code>records</code>
| List of parsed Salesforce record Structs
|-
| <code>total_size</code>
| Total matching records, as reported by Salesforce
|-
| <code>pages</code>
| Number of pages retrieved
|-
| <code>done</code>
| Whether Salesforce reported the query complete
|-
| <code>next_records_url</code>
| URL of a subsequent page. Normally <code>Null</code> once the query is complete
|-
| <code>raw_response</code>
| Raw response for the final page
|}

Set «include_deleted» to <code>True</code> to use Salesforce's query-all behavior, which can include deleted and archived records where Salesforce supports it.

«max_pages», 100 by default, protects your model from an unexpectedly large or insufficiently bounded query. If the result needs more pages than this, it raises an error rather than quietly returning an incomplete result.

Example:
<pre style="background:white; border:white; margin-left: 1em;">
Local soql := "SELECT Id, Name, Amount, CloseDate " &
"FROM Opportunity " &
"WHERE IsClosed = false " &
"ORDER BY CloseDate";
SalesforceQuery( Sf, soql )
</pre>

[[Parameter types]]: <code>SalesforceQuery(sf; soql: Text; include_deleted := False; max_pages: Number := 100)</code>

=== SalesforceQueryFirst(sf, soql) ===

Runs a SOQL expression and returns the first matching record Struct, or <code>Null</code> when nothing matches. Include an <code>ORDER BY</code> clause whenever more than one record could match, so that you get a predictable result.

Example:
<pre style="background:white; border:white; margin-left: 1em;">
SalesforceQueryFirst( Sf,
"SELECT Id, Name FROM Account WHERE Name = " &
SalesforceSoqlQuote( Account_name ) &
" ORDER BY LastModifiedDate DESC LIMIT 1" )
</pre>

[[Parameter types]]: <code>SalesforceQueryFirst(sf; soql: Text)</code>

=== SalesforceCount(sf, soql, ''include_deleted'') ===

Returns the query's <code>totalSize</code> as a number, so you don't have to retrieve and inspect the record list to count matches.

Example:
:<code>SalesforceCount( Sf, "SELECT Id FROM Opportunity WHERE IsClosed = false" )</code> → <code>42</code>

[[Parameter types]]: <code>SalesforceCount(sf; soql: Text; include_deleted := False)</code>

=== SalesforceQueryPage(sf, soql_or_next_url, ''include_deleted'') ===

Retrieves exactly one query page. Pass a SOQL expression to get the first page, or the <code>next_records_url</code> from a previous result to get the page after it.

Most models should use [[#SalesforceQuery|SalesforceQuery]](), which handles pagination for you. Use this function when your model deliberately needs page-by-page control.

[[Parameter types]]: <code>SalesforceQueryPage(sf; soql_or_next_url: Text; include_deleted := False)</code>

== Record functions ==

=== SalesforceGetRecord(sf, sobject, record_id, fields) ===

Retrieves one record, given its Salesforce object API name and record ID. It returns the record Struct itself, not a query-result wrapper.

* «record_id» must be a 15- or 18-character Salesforce ID.
* «fields» is a comma-separated list of field API names.

Example:
:<code>SalesforceGetRecord( Sf, "Account", Account_id, "Id, Name, Industry, BillingCountry" )</code>

[[Parameter types]]: <code>SalesforceGetRecord(sf; sobject: Text; record_id: Text; fields: Text)</code>

=== SalesforceGetRecords(sf, sobject, record_ids, fields) ===

Retrieves several records from a list of Salesforce record IDs, and returns a list of record Structs. Internally it builds a SOQL <code>IN (...)</code> condition from the IDs.

Example:
:<code>SalesforceGetRecords( Sf, "Contact", Contact_ids, "Id, Name, Email" )</code>

[[Parameter types]]: <code>SalesforceGetRecords(sf; sobject: Text; record_ids: List; fields: Text)</code>

=== SalesforceField(record, field_path, ''default_value'') ===

Reads a field from a Salesforce record Struct when the field name is a text value. A dotted «field_path» traverses relationship Structs.

Examples:
:<code>SalesforceField( Contact_record, "Email" )</code>
:<code>SalesforceField( Contact_record, "Account.Name", "No account" )</code>

It returns «default_value», <code>Null</code> by default, when the member is absent or it can't traverse the path.

When you already know the field name as you write the Definition, direct Struct access is simpler:
:<code>Contact_record -> Email</code>

Use <code>SalesforceField</code> for dynamic field names, dotted paths, or when you want a controlled default.

[[Parameter types]]: <code>SalesforceField(record; field_path: Text; default_value := Null)</code>

== Quoting text values ==

=== SalesforceSoqlQuote(value) ===

Escapes a text value as a SOQL string literal and surrounds it with single quotes, handling quotes, backslashes, and control characters.

Example:
:<code>"Name = " & SalesforceSoqlQuote( Customer_name )</code>

If <code>Customer_name</code> is <code>O'Reilly</code>, this produces a valid quoted SOQL literal instead of letting the apostrophe terminate the value early.

Use this function for '''values only'''. You can't safely turn Salesforce object or field API names into identifiers by quoting them -- the library validates those names instead.

[[Intelligent Arrays|Array abstraction]] applies, so it also quotes a list of values. [[#SalesforceGetRecords|SalesforceGetRecords]]() relies on this when it builds its <code>IN (...)</code> condition.

[[Parameter types]]: <code>SalesforceSoqlQuote(value: Text)</code>

== Metadata functions ==

These functions help you discover the API names and properties available to the authenticated integration user.

=== SalesforceObjects(sf) ===

Returns a list of summary Structs for the Salesforce objects that the authenticated user can see.

Example:
:<code>SalesforceObjects( Sf )</code>

Useful members usually include the object's API <code>name</code>, its display <code>label</code>, and capability flags. Salesforce supplies the exact members, which vary by API release and object type.

[[Parameter types]]: <code>SalesforceObjects(sf)</code>

=== SalesforceDescribe(sf, sobject) ===

Returns Salesforce's full metadata description for an object, including its fields, relationships, picklist entries, and access capabilities.

Example:
:<code>SalesforceDescribe( Sf, "Opportunity" )</code>

[[Parameter types]]: <code>SalesforceDescribe(sf; sobject: Text)</code>

=== SalesforceFields(sf, sobject) ===

Returns just the list of field metadata Structs from [[#SalesforceDescribe|SalesforceDescribe]](). Use it to find field API names, types, labels, whether a field can be filtered, and its allowed picklist values.

Example:
:<code>SalesforceFields( Sf, "Account" )</code>

[[Parameter types]]: <code>SalesforceFields(sf; sobject: Text)</code>

== Search ==

=== SalesforceSearch(sf, sosl) ===

Runs a Salesforce Object Search Language (SOSL) expression and returns its <code>searchRecords</code> list.

SOQL queries known objects and fields; SOSL searches text across one or more objects. Use <code>SalesforceSearch</code> when your search spans object types, or when it resembles a text search more than a structured query.

Example:
<pre style="background:white; border:white; margin-left: 1em;">
SalesforceSearch( Sf,
"FIND {Acme} IN NAME FIELDS " &
"RETURNING Account(Id, Name), Contact(Id, Name, Email)" )
</pre>

For the full SOSL syntax, see the Salesforce [https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/ SOQL and SOSL Reference].

[[Parameter types]]: <code>SalesforceSearch(sf; sosl: Text)</code>

== Working with returned records ==

The library represents Salesforce JSON objects as Analytica [[Struct]]s, and collections as lists. Given:

<pre style="background:white; border:white; margin-left: 1em;">
Variable Result ::= SalesforceSelect( Sf, "Account", "Id, Name, Owner.Name",
where: "BillingCountry = " & SalesforceSoqlQuote( Country ),
order_by: "Name",
row_limit: 100 )
</pre>

the records are:
:<code>Result -> records</code>

the first record is:
:<code>Result -> records[@=1]</code>

and you can read a field directly:
:<code>Result -> records[@=1] -> Name</code>

or through the helper, which also handles the dotted relationship path:
:<code>SalesforceField( Result -> records[@=1], "Owner.Name" )</code>

To build an array from the record list, introduce an [[Index]] for the record position and extract the members you want over that Index.

== Error handling and troubleshooting ==

The library raises an Analytica error when authentication fails, when Salesforce returns an unsuccessful HTTP status, when a record ID is malformed, when an object or field API name is invalid, or when a query exceeds «max_pages».

Common causes:
; Authentication fails
: Check the login URL, the consumer key and secret, the client-credentials setting, the '''Run As''' user, and the app authorization.
; <code>INVALID_FIELD</code>, or an unknown field
: Use [[#SalesforceFields|SalesforceFields]]() to check the field's API name. The display label is often not the API name.
; Insufficient access
: Check the integration user's API permission, object permissions, field-level security, sharing access, and permission-set assignments.
; No records returned
: Try a simpler query, confirm the integration user can see the records, and inspect <code>total_size</code> in the query-result Struct.
; Query exceeds «max_pages»
: Add a selective <code>WHERE</code> clause or a <code>LIMIT</code>. Raise «max_pages» only when you intend the larger transfer.
; Sandbox authentication fails
: Use <code>"https://test.salesforce.com"</code>, unless your organization requires a specific My Domain login URL.
; The network request fails
: Confirm that the computer running Analytica reaches the Salesforce login and instance domains over HTTPS, and that any proxy or firewall permits the requests.

An HTTP 401 gets its own message asking you to recalculate the authentication and the connection, then retry -- the access token has expired or been revoked.

== Function summary ==

:{| class=wikitable
! Function
! Purpose
|-
| [[#ClientCredentialsAuth|ClientCredentialsAuth]]()
| Authenticate with the OAuth 2.0 client-credentials flow
|-
| [[#Salesforce|Salesforce]]()
| Create the REST connection Struct
|-
| [[#SoapLoginAuth|SoapLoginAuth]]()
| Legacy SOAP authentication. Migrate before 1-Jun-2027
|-
| [[#SalesforceSelect|SalesforceSelect]]()
| Build and run a common SOQL <code>SELECT</code>
|-
| [[#SalesforceQuery|SalesforceQuery]]()
| Run complete SOQL and retrieve all pages
|-
| [[#SalesforceQueryFirst|SalesforceQueryFirst]]()
| Return the first matching record, or <code>Null</code>
|-
| [[#SalesforceCount|SalesforceCount]]()
| Return the total matching-record count
|-
| [[#SalesforceQueryPage|SalesforceQueryPage]]()
| Retrieve one query page manually
|-
| [[#SalesforceGetRecord|SalesforceGetRecord]]()
| Retrieve one record by ID
|-
| [[#SalesforceGetRecords|SalesforceGetRecords]]()
| Retrieve several records from a list of IDs
|-
| [[#SalesforceField|SalesforceField]]()
| Read a dynamic or dotted field path from a record
|-
| [[#SalesforceSoqlQuote|SalesforceSoqlQuote]]()
| Quote a text value safely for SOQL
|-
| [[#SalesforceObjects|SalesforceObjects]]()
| List the objects visible to the authenticated user
|-
| [[#SalesforceDescribe|SalesforceDescribe]]()
| Retrieve full metadata for an object
|-
| [[#SalesforceFields|SalesforceFields]]()
| List the field metadata for an object
|-
| [[#SalesforceSearch|SalesforceSearch]]()
| Run SOSL and return the search records
|}

== History ==

The Salesforce REST library was introduced in August 2026, and requires [[Analytica 7.1]] or later. The Constant <code>Salesforce_library_version</code> in the library holds its version number, currently <code>1.01</code>.

== See also ==

* [[ReadFromUrl]]() -- the function this library is built on
* [[ParseJSON]]() -- parses the JSON that Salesforce returns
* [[Struct]] -- the data structure used for connections, records, and query results
* [[Additional libraries]]
* [[OpenAI API library]]
* [[Database library]]
* Salesforce [https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/ SOQL and SOSL Reference]
* Salesforce [https://developer.salesforce.com/docs/platform/mobile-sdk/guide/oauth-client-credentials-flow.html OAuth 2.0 Client Credentials Flow]

Salesforce REST library

2026-08-14T17:48:31Z

Lchrisman: Full documentation for the Salesforce REST library v1.01: overview, setup, function reference, troubleshooting, and download link

[[Category:Function libraries]]
[[Category:Integration Functions]]

{{ReleaseBar}}

''Requires [[Analytica 7.1]] {{Analytica Developer}} edition or better.''

The '''Salesforce REST library''' lets your model authenticate with [https://www.salesforce.com/ Salesforce] and read Salesforce records and metadata through the Salesforce REST API, version 67.0. Use it to pull live data -- accounts, contacts, opportunities, or your own custom objects -- straight into an Analytica model, so that your analysis works from current CRM data instead of an exported snapshot.

It provides:
* OAuth 2.0 client-credentials authentication for unattended, server-to-server use
* A legacy SOAP-login option as a temporary migration bridge
* SOQL query execution, including automatic pagination
* Record-selection and record-retrieval helpers
* Salesforce object and field metadata
* SOSL search

This library reads from Salesforce. It has no functions to create, update, or delete Salesforce records.

'''Download:''' [[media:Salesforce REST library.ana|Salesforce REST library.ana]] (v. 1.01)

== Requirements ==

To use this library, you need:
* [[Analytica 7.1]] or later, {{Analytica Developer}} edition or better. The library is built on [[ReadFromUrl]](), which is not available in the Professional or Player editions.
* A Salesforce account, and an OAuth client configured in Salesforce (see [[#Setting up Salesforce for client-credentials authentication|Setting up Salesforce]] below).
* Internet access allowing Analytica to reach your Salesforce login and instance domains over HTTPS. If you have a strong firewall, you may need to add a rule to allow this.

== Getting started ==

# [[media:Salesforce REST library.ana|Download the library]] and save it into your <code>"C:\Program Files\Lumina\Analytica {{#svarget:anarelease|7.1}}\Libraries"</code> folder.
# Launch Analytica and open your model, or start a new one.
# Select '''Add Library...''' from the '''File''' menu, select <code>Salesforce REST library.ana</code>, click '''OK''', select '''Link''', then click '''OK'''.

A typical model then uses three Variables -- an authentication Struct, a connection Struct, and one or more query results:

<pre style="background:white; border:white; margin-left: 1em;">
Variable Sf_auth ::= ClientCredentialsAuth(
"https://login.salesforce.com",
Sf_client_id,
Sf_client_secret )

Variable Sf ::= Salesforce( Sf_auth )

Variable Active_accounts ::= SalesforceSelect( Sf, "Account", "Id, Name, Industry",
where: "IsDeleted = false",
order_by: "Name",
row_limit: 100 )
</pre>

<code>Active_accounts</code> is a query-result [[Struct]]. Its list of records is:
:<code>Active_accounts -> records</code>

To read a field from the first record:
:<code>SalesforceField( Active_accounts -> records[@=1], "Name" )</code>

When you authenticate to a sandbox, use <code>"https://test.salesforce.com"</code> in place of <code>"https://login.salesforce.com"</code>.

== A brief introduction to SOQL ==

Salesforce Object Query Language (SOQL) resembles SQL, but it queries Salesforce objects and fields by their '''API names''' rather than by table and column names. A basic query looks like this:

<pre style="background:white; border:white; margin-left: 1em;">
SELECT Id, Name, Industry
FROM Account
WHERE Industry = 'Technology'
ORDER BY Name
LIMIT 100
</pre>

Standard object names include <code>Account</code>, <code>Contact</code>, and <code>Opportunity</code>. API names of custom objects and custom fields usually end in <code>__c</code> -- for example <code>License__c</code> or <code>Expiration_Date__c</code>. An object's API name is often not the same as the label you see in the Salesforce user interface, so use [[#SalesforceObjects|SalesforceObjects]]() and [[#SalesforceFields|SalesforceFields]]() to discover the names you need.

Whenever you insert a text value into a SOQL expression, quote it with [[#SalesforceSoqlQuote|SalesforceSoqlQuote]](). Don't use that function for object or field API names.

For the full language, see the Salesforce [https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/ SOQL and SOSL Reference].

== Setting up Salesforce for client-credentials authentication ==

[[#ClientCredentialsAuth|ClientCredentialsAuth]]() is meant for unattended, server-to-server access. It needs an OAuth client configured in Salesforce, plus a dedicated Salesforce user whose permissions the integration runs under.

Salesforce terminology and Setup screens vary by edition and release. In current releases the OAuth client is normally an '''External Client App'''; some organizations still use a '''Connected App'''.

A Salesforce administrator generally needs to:
# Create an '''External Client App''' in Salesforce Setup.
# Enable '''OAuth settings''' and the '''OAuth 2.0 Client Credentials Flow'''.
# Grant the OAuth scope needed for REST access, normally '''Manage user data via APIs''' (<code>api</code>). Avoid broader scopes unless you need them.
# Save the app, then copy its '''Consumer Key''' and '''Consumer Secret'''. These become the «client_id» and «client_secret» parameters in Analytica.
# In the app's OAuth policies, select a dedicated '''Run As''' integration user for the client-credentials flow. Depending on the app type, Salesforce may also require '''Admin approved users are pre-authorized'''.
# Give the integration user the permissions your model needs -- API access, plus read access to the required objects and fields. Prefer permission sets and least privilege.
# If the app uses pre-authorization, assign the app's permission set or profile authorization to the integration user.

The library sends the token request to:
:<code>https://login.salesforce.com/services/oauth2/token</code>
or, for a sandbox:
:<code>https://test.salesforce.com/services/oauth2/token</code>

Salesforce returns an access token and the instance URL that the library uses for all later requests.

For current Salesforce-side details, see the Salesforce [https://developer.salesforce.com/docs/platform/mobile-sdk/guide/oauth-client-credentials-flow.html OAuth 2.0 Client Credentials Flow] documentation.

=== Protect the client secret ===

The consumer secret grants access as the configured integration user. Don't save it in a model that you distribute to people who shouldn't have the credential, and don't commit it to source control. Where you can, obtain it at deployment time from your organization's approved secret-management mechanism.

== Authentication and connection ==

=== ClientCredentialsAuth(login_url, client_id, client_secret) ===

Authenticates using the OAuth 2.0 client-credentials flow and returns a [[Struct]] holding the access token.

:{| class=wikitable
! Parameter
! Meaning
|-
| «login_url»
| <code>"https://login.salesforce.com"</code> for production, or <code>"https://test.salesforce.com"</code> for a sandbox
|-
| «client_id»
| Consumer key from the Salesforce External Client App or Connected App
|-
| «client_secret»
| Consumer secret from the same app
|}

The Struct it returns contains these members:
* <code>access_token</code>
* <code>instance_url</code>
* <code>status_code</code>
* <code>status_text</code>
* <code>raw_response</code>

Example:
:<code>ClientCredentialsAuth( "https://login.salesforce.com", Sf_client_id, Sf_client_secret )</code>

When authentication fails, it reports an Analytica error that includes the HTTP status and the Salesforce response.

[[Parameter types]]: <code>ClientCredentialsAuth(login_url: Text; client_id: Text; client_secret: Text)</code>

=== Salesforce(auth) ===

Creates the connection Struct that you pass to every query, record, search, and metadata function. «auth» is the Struct returned by [[#ClientCredentialsAuth|ClientCredentialsAuth]]() or [[#SoapLoginAuth|SoapLoginAuth]]().

The Struct it returns contains these members:
* <code>api_version</code> -- <code>"67.0"</code>
* <code>instance_url</code>
* <code>access_token</code>
* <code>rest_base_url</code>

Example:
:<code>Salesforce( Sf_auth )</code>

It's usually clearer to define the authentication and the connection as separate Variables, as shown in [[#Getting started|Getting started]], so that you can inspect an authentication failure on its own. You can also nest the calls:

<pre style="background:white; border:white; margin-left: 1em;">
Salesforce(
ClientCredentialsAuth(
"https://login.salesforce.com",
Sf_client_id,
Sf_client_secret ) )
</pre>

All REST calls use API version 67.0, including calls authenticated through [[#SoapLoginAuth|SoapLoginAuth]]().

[[Parameter types]]: <code>Salesforce(auth)</code>

=== SoapLoginAuth(login_url, username, password, security_token) ===

Logs in with the legacy Salesforce SOAP Partner API <code>login()</code> call and returns a Struct whose session ID the REST functions use as a bearer token.

«security_token» is the Salesforce security token for that user account. The function concatenates it onto the password, as SOAP login requires.

'''This authentication method is a migration bridge only.''' Salesforce retires the SOAP <code>login()</code> mechanism on '''1-Jun-2027''', after which this function stops working. Write new models against [[#ClientCredentialsAuth|ClientCredentialsAuth]](), and migrate existing ones before that date.

[[Parameter types]]: <code>SoapLoginAuth(login_url: Text; username: Text; password: Text; security_token: Text)</code>

== Query functions ==

=== SalesforceSelect(sf, sobject, fields, ''where, order_by, row_limit'') ===

Builds and runs a common SOQL <code>SELECT</code>. This is the easiest entry point when your query has a straightforward <code>WHERE</code>, <code>ORDER BY</code>, and <code>LIMIT</code> structure. It returns the same query-result Struct as [[#SalesforceQuery|SalesforceQuery]]().

:{| class=wikitable
! Parameter
! Meaning
|-
| «sf»
| The connection returned by [[#Salesforce|Salesforce]]()
|-
| «sobject»
| Salesforce object API name, such as <code>"Account"</code>
|-
| «fields»
| Comma-separated field API names
|-
| «where»
| Optional SOQL condition, without the <code>WHERE</code> keyword
|-
| «order_by»
| Optional ordering expression, without the <code>ORDER BY</code> keywords
|-
| «row_limit»
| Optional maximum number of records. <code>0</code>, the default, applies no explicit limit
|}

The three optional parameters are declared <code>Named</code>, so pass them by name:

<pre style="background:white; border:white; margin-left: 1em;">
SalesforceSelect( Sf, "Contact", "Id, Name, Email, Account.Name",
where: "Email = " & SalesforceSoqlQuote( Target_email ),
order_by: "Name",
row_limit: 20 )
</pre>

It validates the object and field API names, but «where» and «order_by» are SOQL fragments that you supply. Quote any text value you interpolate into them with [[#SalesforceSoqlQuote|SalesforceSoqlQuote]](), as in the example above.

[[Parameter types]]: <code>SalesforceSelect(sf; sobject: Text; fields: Text; where: Named Text := ""; order_by: Named Text := ""; row_limit: Named Number := 0)</code>

=== SalesforceQuery(sf, soql, ''include_deleted, max_pages'') ===

Runs a complete SOQL expression and follows Salesforce pagination until it has retrieved every page.

It returns a query-result Struct with these members:

:{| class=wikitable
! Member
! Meaning
|-
| <code>records</code>
| List of parsed Salesforce record Structs
|-
| <code>total_size</code>
| Total matching records, as reported by Salesforce
|-
| <code>pages</code>
| Number of pages retrieved
|-
| <code>done</code>
| Whether Salesforce reported the query complete
|-
| <code>next_records_url</code>
| URL of a subsequent page. Normally <code>Null</code> once the query is complete
|-
| <code>raw_response</code>
| Raw response for the final page
|}

Set «include_deleted» to <code>True</code> to use Salesforce's query-all behavior, which can include deleted and archived records where Salesforce supports it.

«max_pages», 100 by default, protects your model from an unexpectedly large or insufficiently bounded query. If the result needs more pages than this, it raises an error rather than quietly returning an incomplete result.

Example:
<pre style="background:white; border:white; margin-left: 1em;">
Local soql := "SELECT Id, Name, Amount, CloseDate " &
"FROM Opportunity " &
"WHERE IsClosed = false " &
"ORDER BY CloseDate";
SalesforceQuery( Sf, soql )
</pre>

[[Parameter types]]: <code>SalesforceQuery(sf; soql: Text; include_deleted := False; max_pages: Number := 100)</code>

=== SalesforceQueryFirst(sf, soql) ===

Runs a SOQL expression and returns the first matching record Struct, or <code>Null</code> when nothing matches. Include an <code>ORDER BY</code> clause whenever more than one record could match, so that you get a predictable result.

Example:
<pre style="background:white; border:white; margin-left: 1em;">
SalesforceQueryFirst( Sf,
"SELECT Id, Name FROM Account WHERE Name = " &
SalesforceSoqlQuote( Account_name ) &
" ORDER BY LastModifiedDate DESC LIMIT 1" )
</pre>

[[Parameter types]]: <code>SalesforceQueryFirst(sf; soql: Text)</code>

=== SalesforceCount(sf, soql, ''include_deleted'') ===

Returns the query's <code>totalSize</code> as a number, so you don't have to retrieve and inspect the record list to count matches.

Example:
:<code>SalesforceCount( Sf, "SELECT Id FROM Opportunity WHERE IsClosed = false" )</code> → <code>42</code>

[[Parameter types]]: <code>SalesforceCount(sf; soql: Text; include_deleted := False)</code>

=== SalesforceQueryPage(sf, soql_or_next_url, ''include_deleted'') ===

Retrieves exactly one query page. Pass a SOQL expression to get the first page, or the <code>next_records_url</code> from a previous result to get the page after it.

Most models should use [[#SalesforceQuery|SalesforceQuery]](), which handles pagination for you. Use this function when your model deliberately needs page-by-page control.

[[Parameter types]]: <code>SalesforceQueryPage(sf; soql_or_next_url: Text; include_deleted := False)</code>

== Record functions ==

=== SalesforceGetRecord(sf, sobject, record_id, fields) ===

Retrieves one record, given its Salesforce object API name and record ID. It returns the record Struct itself, not a query-result wrapper.

* «record_id» must be a 15- or 18-character Salesforce ID.
* «fields» is a comma-separated list of field API names.

Example:
:<code>SalesforceGetRecord( Sf, "Account", Account_id, "Id, Name, Industry, BillingCountry" )</code>

[[Parameter types]]: <code>SalesforceGetRecord(sf; sobject: Text; record_id: Text; fields: Text)</code>

=== SalesforceGetRecords(sf, sobject, record_ids, fields) ===

Retrieves several records from a list of Salesforce record IDs, and returns a list of record Structs. Internally it builds a SOQL <code>IN (...)</code> condition from the IDs.

Example:
:<code>SalesforceGetRecords( Sf, "Contact", Contact_ids, "Id, Name, Email" )</code>

[[Parameter types]]: <code>SalesforceGetRecords(sf; sobject: Text; record_ids: List; fields: Text)</code>

=== SalesforceField(record, field_path, ''default_value'') ===

Reads a field from a Salesforce record Struct when the field name is a text value. A dotted «field_path» traverses relationship Structs.

Examples:
:<code>SalesforceField( Contact_record, "Email" )</code>
:<code>SalesforceField( Contact_record, "Account.Name", "No account" )</code>

It returns «default_value», <code>Null</code> by default, when the member is absent or it can't traverse the path.

When you already know the field name as you write the Definition, direct Struct access is simpler:
:<code>Contact_record -> Email</code>

Use <code>SalesforceField</code> for dynamic field names, dotted paths, or when you want a controlled default.

[[Parameter types]]: <code>SalesforceField(record; field_path: Text; default_value := Null)</code>

== Quoting text values ==

=== SalesforceSoqlQuote(value) ===

Escapes a text value as a SOQL string literal and surrounds it with single quotes, handling quotes, backslashes, and control characters.

Example:
:<code>"Name = " & SalesforceSoqlQuote( Customer_name )</code>

If <code>Customer_name</code> is <code>O'Reilly</code>, this produces a valid quoted SOQL literal instead of letting the apostrophe terminate the value early.

Use this function for '''values only'''. You can't safely turn Salesforce object or field API names into identifiers by quoting them -- the library validates those names instead.

[[Intelligent Arrays|Array abstraction]] applies, so it also quotes a list of values. [[#SalesforceGetRecords|SalesforceGetRecords]]() relies on this when it builds its <code>IN (...)</code> condition.

[[Parameter types]]: <code>SalesforceSoqlQuote(value: Text)</code>

== Metadata functions ==

These functions help you discover the API names and properties available to the authenticated integration user.

=== SalesforceObjects(sf) ===

Returns a list of summary Structs for the Salesforce objects that the authenticated user can see.

Example:
:<code>SalesforceObjects( Sf )</code>

Useful members usually include the object's API <code>name</code>, its display <code>label</code>, and capability flags. Salesforce supplies the exact members, which vary by API release and object type.

[[Parameter types]]: <code>SalesforceObjects(sf)</code>

=== SalesforceDescribe(sf, sobject) ===

Returns Salesforce's full metadata description for an object, including its fields, relationships, picklist entries, and access capabilities.

Example:
:<code>SalesforceDescribe( Sf, "Opportunity" )</code>

[[Parameter types]]: <code>SalesforceDescribe(sf; sobject: Text)</code>

=== SalesforceFields(sf, sobject) ===

Returns just the list of field metadata Structs from [[#SalesforceDescribe|SalesforceDescribe]](). Use it to find field API names, types, labels, whether a field can be filtered, and its allowed picklist values.

Example:
:<code>SalesforceFields( Sf, "Account" )</code>

[[Parameter types]]: <code>SalesforceFields(sf; sobject: Text)</code>

== Search ==

=== SalesforceSearch(sf, sosl) ===

Runs a Salesforce Object Search Language (SOSL) expression and returns its <code>searchRecords</code> list.

SOQL queries known objects and fields; SOSL searches text across one or more objects. Use <code>SalesforceSearch</code> when your search spans object types, or when it resembles a text search more than a structured query.

Example:
<pre style="background:white; border:white; margin-left: 1em;">
SalesforceSearch( Sf,
"FIND {Acme} IN NAME FIELDS " &
"RETURNING Account(Id, Name), Contact(Id, Name, Email)" )
</pre>

For the full SOSL syntax, see the Salesforce [https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/ SOQL and SOSL Reference].

[[Parameter types]]: <code>SalesforceSearch(sf; sosl: Text)</code>

== Working with returned records ==

The library represents Salesforce JSON objects as Analytica [[Struct]]s, and collections as lists. Given:

<pre style="background:white; border:white; margin-left: 1em;">
Variable Result ::= SalesforceSelect( Sf, "Account", "Id, Name, Owner.Name",
where: "BillingCountry = " & SalesforceSoqlQuote( Country ),
order_by: "Name",
row_limit: 100 )
</pre>

the records are:
:<code>Result -> records</code>

the first record is:
:<code>Result -> records[@=1]</code>

and you can read a field directly:
:<code>Result -> records[@=1] -> Name</code>

or through the helper, which also handles the dotted relationship path:
:<code>SalesforceField( Result -> records[@=1], "Owner.Name" )</code>

To build an array from the record list, introduce an [[Index]] for the record position and extract the members you want over that Index.

== Error handling and troubleshooting ==

The library raises an Analytica error when authentication fails, when Salesforce returns an unsuccessful HTTP status, when a record ID is malformed, when an object or field API name is invalid, or when a query exceeds «max_pages».

Common causes:
; Authentication fails
: Check the login URL, the consumer key and secret, the client-credentials setting, the '''Run As''' user, and the app authorization.
; <code>INVALID_FIELD</code>, or an unknown field
: Use [[#SalesforceFields|SalesforceFields]]() to check the field's API name. The display label is often not the API name.
; Insufficient access
: Check the integration user's API permission, object permissions, field-level security, sharing access, and permission-set assignments.
; No records returned
: Try a simpler query, confirm the integration user can see the records, and inspect <code>total_size</code> in the query-result Struct.
; Query exceeds «max_pages»
: Add a selective <code>WHERE</code> clause or a <code>LIMIT</code>. Raise «max_pages» only when you intend the larger transfer.
; Sandbox authentication fails
: Use <code>"https://test.salesforce.com"</code>, unless your organization requires a specific My Domain login URL.
; The network request fails
: Confirm that the computer running Analytica reaches the Salesforce login and instance domains over HTTPS, and that any proxy or firewall permits the requests.

An HTTP 401 gets its own message asking you to recalculate the authentication and the connection, then retry -- the access token has expired or been revoked.

== Function summary ==

:{| class=wikitable
! Function
! Purpose
|-
| [[#ClientCredentialsAuth|ClientCredentialsAuth]]()
| Authenticate with the OAuth 2.0 client-credentials flow
|-
| [[#Salesforce|Salesforce]]()
| Create the REST connection Struct
|-
| [[#SoapLoginAuth|SoapLoginAuth]]()
| Legacy SOAP authentication. Migrate before 1-Jun-2027
|-
| [[#SalesforceSelect|SalesforceSelect]]()
| Build and run a common SOQL <code>SELECT</code>
|-
| [[#SalesforceQuery|SalesforceQuery]]()
| Run complete SOQL and retrieve all pages
|-
| [[#SalesforceQueryFirst|SalesforceQueryFirst]]()
| Return the first matching record, or <code>Null</code>
|-
| [[#SalesforceCount|SalesforceCount]]()
| Return the total matching-record count
|-
| [[#SalesforceQueryPage|SalesforceQueryPage]]()
| Retrieve one query page manually
|-
| [[#SalesforceGetRecord|SalesforceGetRecord]]()
| Retrieve one record by ID
|-
| [[#SalesforceGetRecords|SalesforceGetRecords]]()
| Retrieve several records from a list of IDs
|-
| [[#SalesforceField|SalesforceField]]()
| Read a dynamic or dotted field path from a record
|-
| [[#SalesforceSoqlQuote|SalesforceSoqlQuote]]()
| Quote a text value safely for SOQL
|-
| [[#SalesforceObjects|SalesforceObjects]]()
| List the objects visible to the authenticated user
|-
| [[#SalesforceDescribe|SalesforceDescribe]]()
| Retrieve full metadata for an object
|-
| [[#SalesforceFields|SalesforceFields]]()
| List the field metadata for an object
|-
| [[#SalesforceSearch|SalesforceSearch]]()
| Run SOSL and return the search records
|}

== History ==

The Salesforce REST library was introduced in August 2026, and requires [[Analytica 7.1]] or later. The Constant <code>Salesforce_library_version</code> in the library holds its version number, currently <code>1.01</code>.

== See also ==

* [[ReadFromUrl]]() -- the function this library is built on
* [[ParseJSON]]() -- parses the JSON that Salesforce returns
* [[Struct]] -- the data structure used for connections, records, and query results
* [[Additional libraries]]
* [[OpenAI API library]]
* [[Database library]]
* Salesforce [https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/ SOQL and SOSL Reference]
* Salesforce [https://developer.salesforce.com/docs/platform/mobile-sdk/guide/oauth-client-credentials-flow.html OAuth 2.0 Client Credentials Flow]

File:Salesforce REST library.ana

2026-08-14T17:43:13Z

Lchrisman: The Salesforce REST library for Analytica -- a REST + JSON client for the Salesforce API v67.0. Supports OAuth 2.0 client-credentials authentication (and legacy SOAP login), paginated SOQL queries, record retrieval, SOSL search, and sObject metadata. Library version 1.01. Requires Analytica 7.1 {{Analytica Developer}} edition or better.

== Summary ==
The [[Salesforce REST library]] for Analytica -- a REST + JSON client for the Salesforce API v67.0. Supports OAuth 2.0 client-credentials authentication (and legacy SOAP login), paginated SOQL queries, record retrieval, SOSL search, and sObject metadata. Library version 1.01. Requires [[Analytica 7.1]] {{Analytica Developer}} edition or better.

Salesforce REST library

2026-08-14T17:30:30Z

Lchrisman:

''Requires [[Analytica 7.1]] {{Developer}} edition or better

Salesforce REST library

2026-08-14T17:29:41Z

Lchrisman: Created page with "''Requires Analytica 7.1 {{Developer Edition}} or better"

''Requires [[Analytica 7.1]] {{Developer Edition}} or better

ReadFromUrl

2026-08-14T17:28:54Z

Lchrisman: /* See Also */

[[Category:Database Functions]]
[[Category:Image and canvas functions]]
[[Category:Integration Functions]]

{{ReleaseBar}}

Reads a page or text file from a URL and returns the result as a text value.

''Requires Analytica Enterprise''

== ReadFromUrl(url) ==

This function can read text data from an HTTP or HTTPs page (a standard or secure web page), from FTP, or from GOPHER. You can also submit data as would occur on a web page when a user submits an HTTP form. You can also use it to "call" a web service to obtain data. Its result is a text value. You can use functions like [[ParseCSV]]() to parse the text into data.

There are several optional parameters:
;«method»: The HTTP method, usually "GET" or "POST". More esoteric methods include "HEAD", "PUT", "DELETE", "OPTIONS". The verbs "CONNECT", "PATCH" and "TRACE" cannot be used.
;«formFields», «formValues», «formIndex»: Data for form field values to submit to a web page. Usually, you use «formValues» as an array indexed by «formFields», or if they both have a single common index. If «formValues» and «formFields» have multiple indexes in common, you should specify the common index as «formIndex».
;«httpHeaders»: Additional HTTP headers (separate with <code>Chr(13)</code>).
;«httpContent»: custom submitted HTTP content
;«fieldHeaders»: Used only when sending multi-part requests. In multipart messages, the parts and the content for each part are passed in the «formFields» and «formValues» parameters, and can be text, images or binary blobs. But in general you also can specify separate httpHeaders for each part, which are passed in this parameter. The «httpHeaders» is for the full message, whereas the headers here (each is multi-line text) are the headers for each part. «fieldHeaders» is indexed by «formIndex». By specifying this parameter, the message will be configured as multipart.
;«connectTimeoutMs», «sendTimeoutMs», «receiveTimeoutMs»: Timeouts for the key stages of connecting to the server, sending the request, and receiving the response, each expressed in milliseconds.{{Release|6.5||
;«connectionType»: One of <code>'asyncWait'</code> (default), <code>'synchronous'</code>, <code>'asynchronous'</code>, <code>'SSE'</code>, or <code>'websocket'</code>. When <code>'asynchronous'</code>, <code>'SSE'</code> or <code>'websocket'</code>, a «webConnection» object is returned instead of a response. }}

== Return values ==
[[ReadFromUrl]] has multiple return values:
# The response. Could be text, image, or [[In-memory binary data terms|binary]].
# HTTP status code. This is 200 when successful.
# HTTP status code textual description.
# The HTTP response headers
# The content-type (if specified)

For example, to capture the status code, use:
:<code>[[Local]] ( response, code ) {{eq}} [[ReadFromUrl]](....);</code>
or to avoid a warning and handle a code <code>200</code> yourself,
:<code>[[Local]] ( response, code, errMsg, headers, contentType ) {{eq}} [[IgnoreWarnings]]([[ReadFromUrl]](....));</code>

{{Release|6.5||
When «connectionType» is <code>'asynchronous'</code>, <code>'SSE'</code> or <code>'websocket'</code>, the return value is a «webConnection» object and there are no auxillary return values (they aren't available yet). In these cases, [[ReadFromUrl]] returns immediately without waiting for the response. You then use the methods [[_WebConnectionStatus]], [[_WebConnectionRead]], [[_WebConnectionSend]] (web sockets only), and [[_WebConnectionClose]] to receive the content.
}}

== Reading from a Web page ==
To read the contents of a web page,usually in HTML format, just supply the URL, e.g.:
:<code>ReadFromUrl("http://lumina.com")</code>

If you omit the "http://" part, it defaults to an http query, e.g.:
:<code>ReadFromUrl("lumina.com")</code>

== Obtaining an image from a web page ==
ReadFromUrl() can download images with standard formats (i.e., JPG, PNG, GIF, etc) from HTTP pages by supplying the URL, e.g.:
:<code>ReadFromUrl("analytica.com/wp-content/uploads/2023/07/analytica-img.png")</code>"

The result is a picture value object. You can assign the result to the [[Attributes#Node attributes|Pict]] attribute of an object on a diagram to view the image in the model (and to cause the image to be saved with the model file).

== Submitting Data to a Web Page ==

To simulate the submission of HTML form data when querying a web page, you can submit the information using either GET or POST methods. With a GET method, you normally see the parameters appear on the URL itself. With a POST method, you normally don't see the parameters -- they are passed in the body of the HTTP request.

To submit form data, you can set up an table of fields values indexed by field names, usally as an index as a list-of-labels.
The function call uses these parameters:
:[[ReadFromUrl]](url, method, formValues, formFields'', formIndex'')

You only need to specify the «formIndex» parameter if «formValues» and «formFields» are arrays that may have more than one index in common.

For example, the following queries Google for "Analytica":
:<code>INDEX fieldNames := ["hl", "q"];</code>
:<code>VARIABLE form := Array(fieldNames, ["en", "Analytica"]);</code>
:<code>ReadFromUrl("http://google.com/search", "GET", form, fieldNames)</code>

It returns the result in HTML format.

You don't have to worry about URL-encoding the field names or values. If they containnon-alpha numeric characters in either, it will encode them before they are submitted.

=== Submitting multi-part data ===
''Requires [[Analytica 6.4]]''

Data sent in an HTTP <code>method:post</code> can usually be formatted in two ways:
* <code>Content-Type:application/x-www-form-urlencoded</code>
* <code>Content-Type:multipart/form-data</code>

When a form value contains [[In-memory binary data terms|binary data]] or an image, you must use the multipart format. By default, it uses <code>Content-Type:application/x-www-form-urlencoded</code> when possible, but uses <code>Content-Type:multipart/form-data</code> when a form value requires a multipart format.

To force a multipart format when it is not required (e.g. if the web-service you requires a multipart format), include the header explicitly, e.g.:
:<code>[[ReadFromURL]]( url, method:'POST', formValues:vals, formIndex:I, httpHeaders: 'Content-Type:multipart/form-data' )</code>
Or you can specify the «fieldHeaders» parameter (even by passing it an empty string).
In either case, it generates a boundary string between parts. If you provide your own boundary, it will use it, but you need to be careful that this exact sequence of bytes does not appear in any of the content. For example
:<code>[[ReadFromURL]]( url, method:'POST', formValues:vals, formIndex:I, httpHeaders: 'Content-Type:multipart/form-data;boundary=MyBoundary' )</code>
would malfunction if one of your vals contains the byte sequence "MyBoundary".

When sending multi-part data, you may also want to add custom headers to individual items. You can do this using the «fieldHeaders» parameter, which also uses the «formIndex». One example is when you want a field to appear to be the contents of a file and you want to provide the file name.

:<code>[[LocalIndex]] Field := ['Date','Upload'];</code>
:<code>[[Local]] fileContents := [[ReadBinaryFile]]( filename, typeFlags: 7 {binary data blob} );</code>
:<code>[[Local]] values:= [[Array]]( Field, [ Today(), fileContents ] );</code>
:<code>[[Local]] specialHeader := f"Content-Disposition: form-data; name=""File""; filename=""{filename}""";</code>
:<code>[[Local]] fieldHeaders := [[Array]]( Field, [ "", specialHeader ] );</code>
:<code>[[ReadFromURL]]( url, 'Post', formValues: values, formIndex: Field, fieldHeaders: fieldHeaders )</code>

In this code, specialHeader creates a header field for the form item 'Upload' which includes the file name. The server who receives this will think you used an HTML file upload field to select a file named ''filename''. In addition, the server will see the field name as being <code>"File"</code> (from the specialHeader) overriding the name "Upload" in the «formIndex» parameter.

Note that if you are not adding a filename or altering the usual <code>Content-Disposition</code>, you don't have to specify it as a fieldHeader. If you don't specify it, the function automatically creates <code>Content-Disposition</code> for each part.

A second common case where you might need to customize the «fieldHeaders» is when you need to customize the <code>Content-Type</code>. For example, suppose you upload a video file, which you read into memory as a [[In-memory binary data terms|binary data term]]. If you don't specify the content-type, it will default to <code>Content-Type: application/octet-stream</code>. Thus, you might specify it for the field:
:<code>[[ReadFromURL]](url, "Post", vals, fields, I, fieldHeaders: If I="video clip" then "Content-Type: video/mp4" else "" )</code>

If you are sending only a single image or a single [[In-memory binary data terms|binary data term]], it is usually simpler to pass it as the «httpContent» rather than using form fields at all. In that case the message is a single part (not multipart) body, assuming you also control what the receiving side expects.

== Obtaining content from an FTP site ==
To obtain content from an FTP site, use:
:<code>ReadFromUrl("ftp://site.com/directory/file.txt")</code>

The content must be textual. Binary files will be corrupted as they are read into a text value (specifically, '\0' characters will be converted to spaces).

== Authentication ==
FTP sites usually require user and password authentication, as do web services and some web pages. You can embed the user name and password in the URL like this:
:<code>ReadFromUrl("http://user:password@www.site.com/dir/page.htm")</code>
:<code>ReadFromUrl("ftp://user:password@www.site.com/dir/page.htm")</code>

If the user or password contains any of the special characters <code>@ : / ? #</code>, these must be percent encoded. Thus an email user name, <code>john.doe@gmail.com</code>, would be
:<code>ReadFromURL("https://john.doe%40gmail.com@domain.com")</code>

Here are the % codes for the other special chars that might appear in a username or password:
:{| class="wikitable"
! Char !! Code
|-
! Space || %20
|-
! @ || %40
|-
! : || %3A
|-
! / || %2F
|-
! ? || %3F
|-
! # || %23
|}

== Sending data CGI scripts and proprietary web services ==

If you call a CGI service, the CGI program will accept input in its own format, which could be arbitrary. You can send this data as follows:
:<code>ReadFromUrl("http://server.com/cgi-bin/myProgram.cgi", httpContent: data)</code>

In this example, ''data'' contains the data that you are submitting to the CGI script. This data will form the body of the HTTP request. Content may only be used with HTTP requests, not with FTP or Gopher requests.

Various web services fall into this category as well, where data being submitted via HTTP may be in a proprietary format.

In some cases, you may also need to include additional HTTP headers in your request. You can insert these using the optional «httpHeaders» parameter. If you have more than one HTTP header, separate them using a CR character, [[Chr]](13). If you enter these into a definition (e.g., with quotes), you can just type a new line, or if you enter them into a single edit table cell, pressing ''ALT-ENTER'' to insert a CR (new-line) into the cell. Otherwise, you can use the & operator to concatenate each header line with [[Chr]](13).

:<code>ReadFromUrl("http://somehost.com", httpHeaders: "Accept:text/xml"&Chr(13)&"User-Agent:MyModel.ana")</code>

The content value is passed directly with no special encoding of characters.

== HTTP Status Codes ==
During an HTTP request, if the status code returned by the server is greater than or equal to 400, [[ReadFromUrl]] issues a warning displaying the status code and status text, unless the '''Show Result Warnings''' preference is turned off.

== Proxy Servers ==
[[ReadFromUrl]] uses information stored in the system registry to determine whether or a proxy server should be used to access the internet. The configuration can be set up using Internet Explorer or Chrome web browsers (but not through Firefox). The proxy configuration is stored in the system registry in the hive:

:<code>HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings</code>

in the registry values ''ProxyEnable'', ''ProxyServer'' and ''ProxyOverride''.

It should work with TIS, SOCKS and CERN style proxy servers as long as Internet Explorer is installed (SOCKS support requires IE).

{{Release|6.5||
== Connection types ==
In most situations, [[ReadFromUrl]] sends a request to a remote server then waits until it has received the response. It then returns the response. This is synchronous operation. This occurs when you omit the «connectionType» parameter, or when you specify it as <code>'asynchWait'</code> or <code>'synchronous'</code>.

The <code>'synchronous'</code> option is fully synchronous, turning control over to the operating system while it waits for a response. The downside of this is that no window events arrive to the Analytica process during this time, which means the screen cannot redraw and the application cannot respond to Ctrl+Break, etc. In [[Analytica 6.4]] and earlier, this is the mode that was used by [[ReadFromUrl]]. This fully synchronous connection type is the lowest in complexity, so it can serve as a fallback if you discover an unexpected problem in the default <code>'asynchWait'</code> method.

The <code>'asynchWait'</code> method is synchronous as far as your model and code is concerned, but it allows Windows events to arrive and be processed. It can be aborted by pressing Ctrl+Break or Stop calculation. And the screen can redraw while you are waiting. But as with fully synchronous operation, the function call does not return until the full response is received, and the response is then returned directly as the return value of [[ReadFromUrl]].

The remaining connection types are asynchronous. In these cases, [[ReadFromUrl]] returns immediately without waiting for the response from the server. These are each discussed in the next subsections.

=== Asynchronous connections ===
With an <code>'asynchronous'</code> «connectionType», [[ReadFromUrl]] returns immediately, allowing your code to work on something else while the server works on your request. This would be applicable to RESTful web services that take a long time to process AND where your code has something it can work on concurrently, or when you want to launch multiple concurrent web service calls so that they can process concurrently. If you aren't computing while waiting or launching multiple simultaneous calls, then you probably don't want to use an <code>'asynchronous'</code> connection type, simply because it is more complex for your own code.

When you specify <code>connectionType: 'asynchronous'</code>, [[ReadFromUrl]] returns a «webConnection» object immediately. You can then call
:<code>_WebConnectionStatus( wc )</code>
to test the status, which moves through the stages: <code>'Connecting'</code>, <code>'Waiting'</code>, <code>'ResponseReady'</code>, <code>'Done'</code> and <code>'Closed'</code>.

You can receive the message with
:<code>_WebConnectionRead(wc)</code>
which blocks until the message arrives. Or you can use
:<code>_WebConnectionRead(wc, block:false)</code>
which returns immediately. If so message is available (i.e., <code>_WebConnectionStatus(wc)</code> is something other than <code>'ResponseReady'</code>), it returns Null.

An asynchronous connections is one-directional, so [[_WebConnectionSend]] does nothing. Also, the entire message, when ready, is received in a single call to [[_WebConnectionRead]]. If you were to call it multiple times (in the <code>'Done'</code> or <code>'Closed'</code> states), it would simply return null.

When you are done, you can close the connection by releasing the «webConnection», or by calling <code>_WebConnectionClose(wc)</code>.

Once you have stored (cached) the «webConnection» object, so that it is not released, then stop-calculation events, such as when you press Ctrl+Break, do not cancel the communication. However, if you are only holding the «webConnection» in a local variable and the calculation aborts, then the «webConnection» will, in general, be released, thus closing the connection.

=== Streaming responses (SSE) ===

Server-Sent Events (SSE) is a standard used when the HTTP server streams the response rather than sending it all at once. The response is a sequence of messages (events), and you can process these message-by-message as they arrive by setting «connectionType» to <code>'sse'</code> (or to <code>'stream'</code>, which is a synonym). SSE is still a uni-directional communication channel, with the server sending the events only as a stream. After the initial request, the client cannot send additional data to the server.

Most people have used ChatGPT and thus seen an example of streaming SSE in action. In the case of ChatGPT, the server sends one token at a time to the UI, and you see the response appear token-by-token without having to wait for the entire response to appear.

To use SSE streaming, specify <code>connectionType: 'sse'</code> (or synonymously, <code>connectionType: 'stream'</code>). A «webConnection» is returned immediately. Use
:<code>_WebConnectionStatus(wc)</code>
to monitor the status of incoming messages. The status moves through the states: <code>'Connecting'</code>, <code>'Waiting'</code>, <code>'ResponseReady'</code>, <code>'Waiting'</code>, <code>'ResponseReady'</code>, <code>'Waiting'</code>, <code>'ResponseReady'</code>, <code>'Waiting'</code>, ...., and <code>'Closed'</code>. If a message arrives before you have read it, then it skips the <code>'Waiting'</code> state.

To read the next incoming message, use
:<code>_WebConnectionRead(wc)</code>
If the next message has not yet arrived, this waits (blocks) until it arrives. Or you can call
:<code>_WebConnectionRead(wc, block:false)</code>
which return Null if a full message has not yet been received.

You will read each event message successively by iterating over calls to [[_WebConnectionRead]]. The SSE standard does not have a standard for flagging the end of the stream, but many specific applications agree on a common convention. For example, the OpenAI API sends <code>"[DONE]"</code> as the last message. However, with or without a special closing message, either side might close the connection. Once closed, [[_WebConnectionRead]] will simple return Null, so to avoid an infinite loop you should also check that [[_WebConnectionStatus]] is not equal to <code>'Closed'</code>

Because SSE is not bi-directional, the [[_WebConnectionSend]] method does nothing with an 'SSE' connection.

=== Websocket connections ===
A Websocket is a bi-directional communication standard, which starts with an HTTP request. Your client model can send and receive messages with the server in any order, and the connection can remain open for an extended period of time.

Server URLs that expect a websocket connection usually start with a <code>ws://</code> or <code>wss://</code>, but this is only a convention and not required. The way to tell [[ReadFromUrl]] to open a websocket connection is to specify <code>connectiontype:'websocket'</code>, as in
:<code>[[ReadFromUrl]]( "ws://acme.org/interactive", connectionType: 'websocket' )</code>

The [[ReadFromUrl]] call returns after the header response has been received, and if the server has agreed to the websocket upgrade, it returns a «webConnection» object. If the server does not upgrade, then it returns the response in the same way an <code>'asynchWait'</code> call would (i.e., as text in most cases). There is a good chance that this response contains error message information from the server.

Use [[_WebConnectionStatus]] to examine the current status of the connection, which moves through the states <code>'Waiting'</code> and <code>'ResponseReady'</code> multiple times as messages are received and read. Eventually if either side closes the connection, the status becomes <code>'Closing'</code>.

To read the next incoming message, you might optionally check the [[_WebConnectionStatus]] to make sure it is <code>'ResponseReady'</code>, and then call
:<code>_WebConnectionRead(ws)</code>
to receive the message. To send a message, call
:<code>_WebConnectionSend(ws, "Hello out there")</code>
Messages are asynchronous is both direction, so the client and server don't need to alternate.

To close the connection, release the «webConnection» object, or call <code>_WebConnectionClose(ws)</code>.
}}
== Limitations ==

The function waits until the full request from the server has been received. It does not respond to ''Ctrl+Break''. Some requests (e.g. if there is a problem), may take a while to time out before you can return to using Analytica.

On computers that aren't always connected to the internet, or need to dial up a modem or other connection to obtain access, the function does nothing to attempt to establish a connection. It will simply fail with an error.

Several possible error conditions return a cryptic message with only an error code number.

If cannot download binary data. It can only obtain text or pictures from HTTP sources.

It cannot access file system files, e.g., you can't use a url starting with "file://...".

==History==
[[ReadFromUrl]] was introduced in [[Analytica 4.2]].

[[Analytica 6.4]] added support useful for some web service calls that includes
* the transfer of [[In-memory binary data terms|binary data]]
* multi-part message payloads in both directions
* Explicit control over timeouts
* Access to the HTTP status code and text, the HTTP response headers, and the content type (as aux return values).

[[Analytica 6.5]] added asynchronous connection types ([[WebConnections]]), and the <code>'asynchWait'</code> connection type that responds to Ctrl+Break and windows events (like redraw events) while waiting for a lengthy web service call.

== See Also ==
{{Release|6.5||
* [[WebConnections]]}}
{{Release|6.6||
* [[OAuth2Authorize]]}}
* [[OpenURL]]
* [[ReadTextFile]]
* [[RunConsoleProcess]]
* [[ReadImageFile]]
* [[TextCharacterEncode]]
* [[Retrieving Content From the Web]]
* [[Links or URL in model attributes]]
* Analytica example model: <code>"Function Examples/Map images from internet.ana"</code>
* [[Salesforce REST library]] -- An Analytica library for querying Salesforce from a model.

Tutorial: Arrays

2026-08-12T17:24:02Z

Lchrisman: Marked this version for translation

<translate>

[[Category:Analytica Tutorial]]
<breadcrumbs>Analytica Tutorial > {{PAGENAME}}</breadcrumbs>
{{ReleaseBar}}
This section (page) introduces you to [[Intelligent Arrays]], which is source of much of Analytica's power and flexibility. An array is a table of values, with one, two, or more dimensions. Even if you often skip tutorials, you may find it valuable to go through this section, because Analytica arrays have some unique aspects different from other modeling tools and computer languages. And it's essential to understand the basics of arrays before you can use Analytica effectively.


<div style="column-count:2;-moz-column-count:2;-webkit-column-count:2">
__TOC__
</div>


This chapter shows you how to:
* Create and define an Index
* Define an array variable as a Table
* Understand principles of array abstraction when combining arrays in an expression
* Use conditional expressions and logical values when defining an array
* Define variables using Expression syntax
* Use local values to simplify an expression
* Analyze a multi-dimensional result by pivoting indexes
* Reduce an array using subscripts
* Use array reducing functions such as [[Sum]]() and [[NPV]]()


In the previous chapter you defined a single variable, '''Miles per gallon''', as a list of values. This is an example of a simple one-dimensional array. When you defined '''Fuel cost''' using the '''Miles per gallon''' array variable as an input, it also became an array. This demonstrates the concept of [[Array Abstraction|array abstraction]]. Array variables can be used just like ordinary variables in expressions. Whenever you expand an index of the array to include more values, or even add an entirely new index along a new dimension, all dependent variables downstream will be extended automatically! [[Intelligent Arrays|Intelligent arrays]] allow you to scale your model without making any changes to the design.


This section covers lots of ground. The example model is simple, but demonstrates many important array concepts. The approach is streamlined so you can learn the key ideas with-out getting bogged down with procedural details. You should already be familiar with the basic mechanics of Analytica‘s user interface, and know how to:
* Create a new model; Open an existing model; Save; Save As... (See [[Tutorial: Open a model to browse]])
* Create and define new variables; Enter attributes in [[Attribute panel|Attribute]] or [[Object window]]s; Draw influence arrows between nodes. (See [[Tutorial: Create a model]])

==Summarize variables using Expression syntax== 


You will need to know how to enter definitions directly as [[Expression Syntax|Expressions]]. Every variable type and every functional expression can be represented this way. In addition to its usefulness in building models, expression syntax is a convenient and efficient way to summarize examples in the documentation. For example, this summarizes the '''Car cost '''model from the previous section:


:<code>Variable MPY := 12K</code>
:<code>Variable MPG := Sequence(20, 50, 5)</code>
:<code>Variable Fuel_price := 3</code>
:<code>Variable Fuel_cost := MPY*Fuel_price/MPG</code>


We summarize new variables in this form in this section. It is also widely used throughout the [[Analytica Docs|Docs]]:


* The first term indicates the [[Class]] of the object being defined. Classes include '''Decision, Variable, Chance, Objective, Module, Index, Constant ''' and '''Function'''.
* The second term is the [[Identifier]] for the object. (Identifiers may not contain spaces.)
* <code>:=</code> sometimes known as the [[Assignment Operator :=|assignment operator]].
* The definition is an expression, which could be a number, function call, probability distribution, table, or other expression. It may refer to other variables (the "Inputs" of this variable. You could even copy the expression directly into the Definition of a variable or function. The expressions are marked as <code><nowiki><code></nowiki></code>.

==Fast Tony’s Generic Wheels== 
In this chapter you extend the '''Car cost '''model to address an important decision scenario: the purchase of a new car. There are three cars to choose from: '''''Standard''''', '''''SUV '''''and '''''Hybrid'''''.


There are also three finance options: '''''Cash purchase''''', '''''Lease''''', or '''''Loan'''''. Fast Tony has presented you with an array of decision possibilities, a 3 x 3 array to be exact. Your objective is to determine the option with the lowest total cash outflow over a 24-month period, including fuel. (Maintenance costs are covered under warranty as long as Fast Tony’s cousin, Greasy Tony, is on his feet that day.) Ownership equity will be represented as a positive cash flow on the last period.

==Continue with model== 
In this chapter, you will continue with the model you developed in [[Tutorial: Create a model]]. The model from the end of [[Tutorial: Create a model]] can be found in the '''Tutorial Models''' directory. Select '''Open''' on the '''File''' menu.


{{CalloutAnnotationBlock|[[Image:Chapter_5.1-updated.png]]|
{{CalloutAnnotation|Press the ''Example Models'' button.''|n=1|pt=43,95|v=20}}
{{CalloutAnnotation|Enter the '''Tutorial Models''' folder.|n=+|v=120}}
{{CalloutAnnotation|Open model from [[Tutorial%3A_Create_a_model#Saving_your_model_2|end of Chapter 4]].|pt=117,79|path=R10|n=+|v=220}}
}}

==Create an index variable== 
Index variables define the categories along a dimension of an array. They are represented by index nodes (parallelogram shapes) in the [[influence diagram]]. In this example, your decision will be arrayed by '''Car type''' and '''Finance Option''' so you will need to define an index for each of these dimensions. Index variables are generally defined as a ''list of labels'' or a ''list of values'' representing categories in the array.


(For the finance options you will leave out "Loan" for now. It will be added later.)
:<code>Index Car_type := ['Standard', 'SUV', 'Hybrid']</code>
:<code>Index Finance_option := ['Purchase', 'Lease']</code>


{{Release||4.6|
:[[File:Chapter_5.2-updated.png]]
}}{{Release|5.0||
{{CalloutAnnotationBlock|[[Image:TutChap5CreateIndexes.png]]|{{
CalloutAnnotation|For each of the index nodes listed above, do the following:|v=0|style=border:none;}}{{
CalloutAnnotation|Choose the Edit tool|n=1|path=-|pt=249,27|v=70}}{{
CalloutAnnotation|Drag the Index icon down to the diagram|n=+|path=/|pt=503,27|v=120}}{{
CalloutAnnotation|Enter a title for the node|n=+|v=190}}{{
CalloutAnnotation|Open the definition field and select '''List of text''' from the expression popup menu|n=+|v=270|pt=324,525|path=/}}{{
CalloutAnnotation|Enter labels as shown|n=+|v=400|pt=12,509}} }}}}


{{#tag:tip|As an alternative to selecting '''''{{Release||4.6|List of Labels}}{{Release|5.0||List of Text}}''''' in [[the Expression popup menu]], you can select '''Expression''' and enter the definition directly using [[Expression Syntax|Expression syntax]]. Simply list the values separated by commas and encase them in square brackets <code>[ ]</code>. Note that all text values in Expression syntax must be enclosed in quotes (single or double).}}

==Defining a variable as a table== 
Each of the cars has a unique purchase price. You will define '''Car price''' as a '''''Table''''' indexed by '''Car type'''. In this context, a "table" does not necessarily have two dimensions. It can have one (as in this case), two, three or more.
:<code>Variable Car_price := Table(Car_type)(22K, 40K, 24K)</code>


{{CalloutAnnotationBlock|[[Image:Chapter_5.3-updated.png]]|{{
CalloutAnnotation|Create a new variable titled '''Car price'''.|n=1|v=20|pt=76,87}}{{
CalloutAnnotation|Open the Definition field, then open the Expression popup menu. Select '''''Table'''''.|n=+|v=100|pt=326,400|path=R70!}}{{
CalloutAnnotation|The [[Indexes dialog]] appears. Select the '''Car type''' index and click the transfer button to move it to the selected indexes list. Click '''OK'''.|n=+|v=220|pt=486,160}}
}}


After you close the [[Indexes dialog]] an [[Edit table]] will appear.


Enter the following values for ''Car price'':


:Standard: ''''22K''''
:SUV: '''''40K''''
:Hybrid: ''''24K''''


{{CalloutAnnotationBlock|[[File:Chapter_5.4-updated.png]]|{{
CalloutAnnotation|Click the index button if you want to go back to the [[Indexes dialog]].|v=0|pt=12,38}}{{
CalloutAnnotation|Index categories appear as table headings.|v=78|pt=10,134}}{{
CalloutAnnotation|Press '''Tab''' or '''Shift+Tab''' to move through the cells.|v=160|pt=122,161|path=-}}
}}


<tip>
You can draw influence arrows from index nodes to table variables to pre-populate the [[Indexes dialog]] with the chosen indexes. Influence arrows from index nodes are invisible by default but can be made visible by choosing the [[Diagram menu]] and selecting '''''Set diagram style'''''.
</tip>


Next you will create a variable for lease payments. Fast Tony lists the following monthly payments for the two-year lease option:
:Standard: ''''$400''''
:SUV: '''''$700''''
:Hybrid: ''''$500''''


'''Lease Payment''' is similar to the '''Car price''' variable. But this time you will enter the [[definition]] directly using [[Expression Syntax|expression syntax]] instead of using the [[edit table]].


:<code>Variable Lease_payment := [[Table]](Car_type)(400, 700, 500)</code>


{{CalloutAnnotationBlock|[[Image:Chapter_5.5-updated.png]]|{{
CalloutAnnotation|Create a new variable titled '''Lease payment'''|n=+|v=0|pt=335,73}}{{
CalloutAnnotation|Open the definition field and select [[image:exprExpression_menu_item.png]] from the Expression popup menu.
(This will not change the definition of an existing variable.)|n=+|v=75|pt=432,184|path=-}}{{
CalloutAnnotation|Enter the definition directly as shown|n=+|v=250|pt=123,224}}
}}


As you can see, [[Table]] definitions follow a specific syntax. The '''Table '''declaration is followed by two lists enclosed in parentheses. The first list contains the indexes by which the table will be arrayed. (In this simple example there is only one index but there can be many.) The second list contains the values.


'''It is important for the values to be in the same order as the index categories.''' Recall that the Car type index was defined as:


:<code>Index Car_type := ['Standard', 'SUV', 'Hybrid']</code>


which matches the respective order of values in the '''Lease payment '''variable. The same principle applies when there is more than one index. For example, a two dimensional array might look like:


:[[Table]] (Index_abc, Index_123)
::('a1', 'a2', 'a3', 'b1', 'b2', 'b3', 'c1', 'c2', 'c3')


It is generally easier to use an [[edit table]] when multiple dimensions are involved.


Finally, re-define the existing '''Miles per gallon '''variable as a table indexed by '''Car type'''. The MPG values for Standard, SUV and Hybrid are 28, 23, and 45 respectively.


:<code>Variable Mpg := Table(Car_type)(28, 23, 45)</code>


Select the '''Miles per gallon '''variable.


Open the Definition field and select [[File:Chapter_5.6-updated.png]] from [[the Expression popup menu]]. Enter the new [[definition]] as shown above.

==Combine arrays== 
Now that you have established purchase and lease payments, you can combine them in one variable. This time the index will be '''Finance Option'''.


:<code>Variable Payments := [[Table]] (Finance_option)(Car_price, Lease_payment)</code>


Create a new variable titled '''Payments'''.


Open the definition field and select '''''Table''''' from the [[Expression popup menu]].


The [[Indexes dialog]] appears. Select the Finance option index and transfer it to selected indexes list. Click '''OK'''. An edit table will appear.


{{CalloutAnnotationBlock|[[Image:Chapter_5.7-updated.png]]|{{
CalloutAnnotation|Enter '''''Car_price''''' next to '''Purchase'''|v=0|pt=138,116|n=1}}{{
CalloutAnnotation|Enter '''''Lease_payment''''' next to '''Lease'''|n=+|v=60|pt=97,134}}{{
CalloutAnnotation|Press [[image:GreenCheck.png]]|n=+|v=140|pt=15,87}}
}}


You may have noticed an important difference between this table and the previous tables. In the previous tables you entered number values into the table cells, but this time you are entering expressions! Expressions are valid entries for table cells. With very few exceptions they can be as complex as anything you might enter in a standard definition line, including formulas, logical expressions and conditional expressions. You will see more examples of this later in the chapter.


Now look at the result of this new variable.


Select the '''Payments''' variable and click the '''Results''' button ([[File:Chapter_4.54-updated.png]])


Something interesting has happened! Notice that the array contains two dimensions even though only one index is called out in the definition of the array:


:<code>Variable Payments := [[Table]] (Finance_option)(Car_price, Lease_payment)</code>


Why is '''Car type''' included in the result when '''Finance_option''' is the only index included in the definition of the table?


The '''Car type''' index is included because it is an index of the input variables '''Car price''' and '''Lease payment'''.


You have just encountered one of the most powerful features of Analytica’s array abstraction: The dimensions of arrayed input variables will automatically be incorporated into the resulting output of an expression. The general principle of array abstraction can be summarized as follows:


'''In Analytica, the result of an expression is arrayed by the ''union'' set of dimensions from all input variables, and the definition of the expression itself.'''

==Add a dimension to an array== 
So far, the Payments variable is not very useful for comparing the purchase and lease options. Lease payments are paid every month instead of just once, and there is still ownership equity to consider. In order to represent payments as a stream of cash flows over time, you will need to add a new dimension to the Payments array:


Create and define a new index titled Period. Define it as a sequence of months from 0 to 24.
:<code>Index Period := [[Sequence]](0, 24)</code>


<tip>
There is a special shortcut syntax for sequences that have a step value of one: Type the starting value, followed by two periods (..), followed by the final value. For example, the '''Period''' index can be defined as: <code>Index Period := 0..24</code>
</tip>


Next, you will edit the '''Payments''' definition to include the new index. Try using the edit table for this:


{{CalloutAnnotationBlock|[[Image:Chapter_5.8-updated.png]]|{{
CalloutAnnotation|Select the '''Payments''' variable and open the definition field.|n=1|v=50|pt=189,175|path=r(240,103)mbD20/}}{{
CalloutAnnotation|Click the '''''Edit Table''''' button.|n=+|v=180|pt=16,197}}
}}


There is a button in the top left corner of the edit table, labeled with a parallelogram. Click this button to open the Indexes window. Then add '''Period''' to the list of selected indexes.


{{CalloutAnnotationBlock|[[File:Chapter_5.9-updated.png]]|{{
CalloutAnnotation|Click the ''Index button'' in the top-left corner of the edit table.|n=+|v=30|pt=22,41}}{{
CalloutAnnotation|Select the '''Period''' index and add it to the Selected Indexes list.|n=+|v=130|pt=400,123|path=rR15(*,185)(400,185)(278,130)m(400,185)(488,114)m(400,185)}}{{
CalloutAnnotation|Note: By default, Analytica will copy current values to all new slices along the added index.|v=230|pt=216,265}}
}}


The edit table should now look like this:


{{CalloutAnnotationBlock|[[File:Chapter_5.10-updated.png]]|{{
CalloutAnnotation|The '''Period''' index has been added to the '''Payments''' array.|v=0}}{{
CalloutAnnotation|Change vertical and horizontal indexes if necessary to pivot the table as shown.|n=+|v=90|path=(45,89)(67,59)m(45,89)|pt=86,80}}
}}


The subset of an array corresponding to a singe index value is referred to as a [[slice]]. When you expanded the '''Payments''' array to include a new index, the original values (expressions in this case) were copied into all new slices along the '''Period''' index.


The '''Payments''' array is not yet accurate. Under the Purchase column you should have zero values for all periods except Period 0. Lease payments should be included in periods 1 through 24 but not Period 0. It would not take too much effort to edit all the cells to be the way you want them to be. The final definition of the array would look something like this:


:[[File:Chapter_5.11-updated.png]]


Although this would work, it would not be a very efficient approach. In general, whenever you find yourself editing tables in the same way you would edit a spreadsheet, you are not benefiting from the advantages of array abstraction.

==Use conditional expressions== 
Expressions can include conditional statements using If...then...else syntax. The condition can be based on a variable or an index value. This is a very useful way of defining array variables. For example, the cash flow for purchasers can be represented as:


:<code>[[If]] Period = 0 [[Then]] Car_price [[Else]] 0</code>


Likewise, the cash flow for lease holders can be represented as:


:<code>[[If]] Period = 0 [[Then]] 0 [[Else]] Lease_payment</code>


Specifying a condition based on '''Period''' will automatically add the '''Period''' index to the array. This would have been a better way to add a new dimension to the '''Payments''' variable, compared to the example above.


Let’s revert the Payments variable to the way it was before adding the Period index:


:<code>Variable Payments := [[Table]](Finance_option)(Car_price, Lease_payment)</code>


As you did in the section above, Select the '''Payments''' variable, open the edit table, and click the Index button in the top left corner.


Select the '''Period''' index in the Selected Indexes list and transfer it back to left hand box. Click '''OK'''. Answer '''Yes''' when the warning appears:


:[[File:Chapter_5.12-updated.png]]


{{CalloutAnnotationBlock|[[File:Chapter_5.7-updated.png]]|{{
CalloutAnnotation|The edit table should be back to its original one-dimensional form.|v=5}} }}


This time you will add the '''Period''' index by including it in a conditional expression. Edit the cells to include conditional expressions:


:<code>Variable Payments := [[Table]](Finance_option)</code>
:::<code>([[If]] Period = 0 [[Then]] Car_price [[Else]] 0,</code>
:::<code> [[If]] Period = 0 [[Then]] 0 [[Else]] Lease_payment)</code>


{{CalloutAnnotationBlock|[[File:Chapter_5.14-updated.png]]|{{
CalloutAnnotation|Enter conditional expressions in the edit table cells as shown.|v=5}} }}


Let’s take a step back to consider how many indexes are now included in the '''Payments '''array:


* '''Finance_option '''is called out specifically as a table index
* '''Period '''is the basis for a condition statement within an expression
* '''Car_type '''is an index of the '''Car price '''and '''Lease payment '''input variables. Therefore, you can expect that '''Payments '''will be a three-dimensional array.


Conditional expressions can have nested [[If-Then-Else]] statements. In fact, it would be possible to define the '''Payments '''array using only one conditional expression:


:<code>Variable Payments :=</code>
::<code>[[If]] Finance_Option = 'Purchase' [[Then]]</code>
::<code>    [[If]] Period = 0 [[Then]] Car_price [[Else]] 0</code>
::<code>[[Else]] [[If]] Period = 0 [[Then]] 0</code>
::<code>[[Else]] Lease_payment</code>


This would be equivalent to the table definition above.


Logical statements can also be used to specify a condition. They are enclosed in parentheses and include an equal sign. When used in a mathematical expression, a logical statement assumes a value of one if true, or zero if false. For example:


:<code>24*(2 + 2 = 4) → 24</code>
:<code>24*(2 + 2 = 5) → 0</code>


Hence another equivalent to the previous table definition is
:<code>[[If]] Finance_Option = 'Purchase' [[Then]] (Period=0) * Car_price</code>
:<code>[[Else]] (Period>0) * Lease_payment</code>

==View the results of a multi-dimensional array== 
Representing a multi-dimensional array on a two-dimensional screen presents a challenge. When viewing results in tabular form, Analytica will display only a two-dimensional slice of the data. You can change the orientation and selection of data by ''pivoting ''the table. To do this, select the desired row and column indexes from the row and column pop-up menus. Any leftover indexes become ''slicer indexes ''for which only slice of data (corresponding to a single index value) can be displayed at a time.


Select the Payments variable and click the Results button ([[File:Chapter_4.54-updated.png]]).


Select the table view button ([[File:Chapter_4.58-updated.png]]).


You can experiment by selecting different row and column indexes, and by changing the value of the slicer index.


{{CalloutAnnotationBlock|[[File:Chapter_5.15-updated.png]]{{
CalloutAnnotation|The slicer menu button displays a pop-up menu of all slicer index values.|v=5|style=left:385px;|pt=104,54|path=lmU15-}}{{
CalloutAnnotation|Slicer steppers change the value of the slicer index sequentially.|v=100|style=left:385px;|pt=231,58|path=l}}|{{
CalloutAnnotation|The row index pop-up menu selects the index of rows.|v=20|pt=47,79}}{{
CalloutAnnotation|The column index pop-up selects the index of columns.|v=100|pt=78,100}}
}}


Now click on the graph view button ([[File:Chapter_4.56-updated.png]])


The vertical axis of the graph represents data values. The graph indexes can be pivoted to select the desired horizontal axis, key, and slicer index. You can experiment with various graph configurations and slicer values.


{{CalloutAnnotationBlock|[[File:Chapter_5.16-updated.png]]|{{
CalloutAnnotation|The graph displays data for only one value of the slicer index.|v=20|pt=110,58}}{{
CalloutAnnotation|The Horizontal Axis pop-up menu selects the index for the horizontal axis.|v=140|pt=146,241|path=rmU20(195,80)mrmD20}} {{
CalloutAnnotation|Key index categories are divided by color.|v=275|pt=131,302}}
}}


<tip>
You can explore various chart types and options by selecting '''''Graph Setup'''''... from the [[Result menu]]. For more details about graphs reference [[Tutorial: Reviewing a model]].
</tip>

==Add a new value to an index== 
Fast Tony’s loan financing terms require 10% down and 2% of the purchase price per month for 60 months. His financing manager, Big Anthony, explains that at a 12% nominal interest rate (1% per month compounded monthly), the load will be paid off in 60 months. There are severe penal- ties for delinquency but none of them are expressed in dollar values.


One of the advantages of ''intelligent arrays ''is that they are easily expandable. So far, you have set up cash flows for purchasers and lease holders. Adding a third financing option is a simple matter of adding a new value to the '''Finance option '''index.


:<code>Index Finance_option := ['Purchase','Lease','Loan']</code>


Select the '''''Finance option '''''index and open the [[Definition]] field. Select '''''{{Release||4.6|List of Labels}}{{Release|5.0||List of Text}}'''''from the [[Expression popup menu]]. You will see a list of current values in the definition field. Select the bottom value ('''Lease''') and press the '''down-arrow '''key. A new box appears at the bottom of the list. By default the previous label is copied down. Change the new value to '''''Loan'''''.


{{CalloutAnnotationBlock| [[Image:Chapter_5.17-updated.png]]|{{
CalloutAnnotation|Select '''{{Release||4.6|List of Labels}}{{Release|5.0||List of Text}}''' from the Expression pop-up menu.|n=1|v=0|pt=336,80|path=/}}{{
CalloutAnnotation|Select the bottom category and press ''Enter''.|n=+|v=85|pt=15,71}}{{
CalloutAnnotation|Enter '''Loan''' as the new value.|n=+|v=170|pt=33,94|path=-}}
}}


Now select the Payments variable and click the Results button ([[File:Chapter_4.54-updated.png]]).


A new column appears with zero values by default.
{{CalloutAnnotationBlock|[[File:Chapter_5.18-updated.png]]{{
CalloutAnnotation|A new column appears for '''Loan'''.|v=30|style=left:400px;|pt=245,113|path=l-}}|{{
CalloutAnnotation|Click the table view button.|n=+|v=30|pt=11,56}}{{
CalloutAnnotation|Pivot the table as shown.|n=+|v=120}}
}}


Now you will need to add an expression for loan payments in the edit table:


:<code>Car_price*(If Period = 0 then 10% else 2%)</code>


Select the '''Payments''' variable. Open the Definition field, then click the '''''Edit table''''' button.


{{CalloutAnnotationBlock|[[File:Chapter 5.19-updated.png]]|{{
CalloutAnnotation|Enter the new expression for Loan payments as show.|n=+|pt=100,151}}
}}


Recall that the input variable '''Car price''' is indexed by '''Car type'''. Therefore, your new expression will be evaluated separately for the Standard car, the SUV and the Hybrid. The new expression also references the '''Period''' index, so it will be evaluated separately for each period as well.


{{CalloutAnnotationBlock|[[File:Chapter 5.20-updated.png]]|{{
CalloutAnnotation|Loan payments have been added for all values of '''Car type''' and '''Period'''.|v=50|pt=238,142}}
}}

==Using local values and indexes in an expression== 
Now that you have established all the cash outflows, you can start thinking about how much ownership equity you will have at the end of the 24-month period. Unavoidably you will need to calculate the remaining loan balance at that time. The financial dynamics of a typical loan include compound interest offset by fixed payment amounts. Although the formula for loan balances can be derived fairly easily, this section will focus on how to apply the formula rather than explaining the formula itself. Readers are invited to verify on their own if they wish:


Assuming that a constant amount is paid and nominal interest is compounded every month:


:<code>B0</code> = Starting balance of the loan
:<code>12%</code> = Nominal interest rate
:<code>60</code> = The total number of periods required to pay off the loan
:<code>Period</code> = A number from 0 to 24 representing the current period
:<code>B(Period)</code> = The remaining loan balance for the current period
:Let <code>A = (1 + 12% / 12)</code>
:<code>B(Period) = B0 * (A^60 - A^Period) / (A^60 - 1)</code>


It is easy to verify that <code>B(0) = B0</code> and <code>B(60)=0</code> as required.


The quantity <code>A</code> appears several times in this formula so it makes sense to define it as an intermediate variable. To do the same thing in Analytica, you could define a new variable called <code>A</code> and use it as an input to the loan balance variable. But this would clutter your diagram with an unnecessary node.


Analytica allows ''local'' values and indexes to be used temporarily within a definition. In this case you will define a local identifier.


Create a new variable titled '''Loan balance''' and enter the following definition:


:<code>Variable Loan_balance :=</code>
::<code>{{Local}} A := (1 + 12%/12);</code>
::<code>Car_price * (1 - 10%) * (A^60 - A^Period)/(A^60 - 1)</code>


Syntax rules for local objects are as follows:


* The instruction line starts with <code>{{Local}}</code> or <code>{{LocalIndex}}</code> to declare a local value or index.
* The declaration is followed by an identifier. This can be anything you choose but it must not be identical to any other input contained in the expression.
* The ''assignment operator'' <code>:=</code> comes next (colon followed by an equal sign), followed by an expression defining the object.
* A semicolon (<code>;</code>) is required to end the instruction line. You may choose to have a visual break (Enter key) after the semicolon for appearance purposes but this is optional. Analytica only looks at semicolons to mark line breaks in code. Each local identifier declaration must be on a separate code line.
* The final line of instruction contains the definition as usual. All declared local values and indexes will be available to use in expressions.


Local variables are used temporarily and then forgotten after the expression is evaluated. Therefore, the same local identifier (i.e. <code>A</code>) can be used in any number of nodes without conflict.


{{CalloutAnnotationBlock|[[File:Chapter_5.21-updated.png]]|{{
CalloutAnnotation|Create a new Variable titled '''Loan balance''' and enter definition as shown.|pt=50,156}}}}


A final note about the expression for '''Loan Balance''':


Although '''Period '''is an index, you have used it here as a variable in a mathematical expression. This is possible because '''Period '''is a list of numerical values. It would not have been possible to use '''Car type '''or '''Finance option '''in a mathematical formula since they are lists of labels (although they could be used in logical or conditional statements). In general, you can think of an index as a one-dimensional array that uses its own values as an index.


By the principles of array abstraction, you should expect '''Loan Balance '''to be a two-dimensional array indexed by '''Car type '''(an index of '''Car price''') and '''Period'''.


{{CalloutAnnotationBlock|[[File:Chapter_5.22-updated.png]]|{{
CalloutAnnotation|'''Load Balance''' is a two-dimensional array indexed by '''Car type''' and '''Period'''|pt=50,151}}}}


<tip>
The Future Value function [[Fv]] is a convenient way to calculate loan balances and annuity values without using formulas. Arguments in order are: Interest rate per period, Future period, Payments (negative for payouts), Initial value. For example, '''Loan Balance''' could be defined as: <code>[[Fv]](1%, Period, -Car_price*2%, Car_price*90%)</code>
See [[Financial functions]] in the [[Analytica User Guide]].
</tip>

==Reduce an array using subscripts== 
Sometimes you may want to reference part of an array variable without using all of its available indexes. [[Subscript]]s allow you to reference a [[slice]] of an array, effectively eliminating one or more dimensions. The [[subscript]] specifies indexes and their desired values for the slice. It is enclosed in square brackets placed immediately after the identifier for the array. For example:


The subscript has reduced a two-dimensional array to a one-dimensional array


:<code>Variable Final_period_balance := Loan_balance[Period = 24]</code>


This refers only to the '''Loan Balance '''values that correspond to Period 24. Recall that '''Loan Balance '''is a two-dimensional array indexed by '''Period '''and '''Car Type'''. The subscripted reference above will eliminate the '''Period '''dimension and return a one-dimensional array indexed only by '''Car_type'''.


{{CalloutAnnotationBlock|[[File:Chapter_5.23-updated.png]]|{{
CalloutAnnotation|The subscript has reduced a two-dimensional array to a one-dimensional array.|pt=100,151}}}}


It is possible to eliminate multiple dimensions by including multiple indexes in the [[subscript]], separated by commas. For example:


:<code>Variable Final_period_balance := Loan_balance[Period = 24, Car_type = 'SUV']</code>


The result of this expression will be a single value corresponding to the loan balance at Period 24 for the SUV: 24.11K


An Index value can also be selected according to its position in the index rather than the actual value. To make a positional reference, place the "at" symbol (cat) in front of the index identifier. For example, 'SUV' is second in the order of values for the '''Car type '''index.


The following [[subscript]] references are equivalent:
:<code>Loan_balance[Car_type = 'SUV']</code>
:<code>Loan_balance[@Car_type = 2]</code>


The verbal terminology for this reference would be: "'''Loan_balance '''[[slice]]d at position of '''Car_type '''equal to 2".

==Complete cash flows== 
Now you can add a variable to represent the amount of ownership equity you will have after 24 months. Of course this will depend on the finance option.


Assume that the value of every car depreciates by 35% over two years.


* Cash purchasers’ equity will be: '''Car_price (1 - 35%)'''
* Lease holders’ equity will be zero
* Loaners’ equity will be the difference between car value and the loan balance at Period 24: '''Car_price (1 - 35%) - Loan_balance<nowiki>[Period =</nowiki> 24]'''


The '''Equity '''variable has only two dimensions: '''Car type '''and '''Finance option'''.


It refers to a single slice of the '''Period '''index.


You can define the '''Equity '''variable as a table indexed by '''Finance option'''. Each of the expressions above can be entered into the appropriate cell in the edit table:


:<code>Variable Equity := Table(Finance_option)</code>
:<code>(Car_price*(1 - 35%), 0, (Car_price*(1 - 35%) - Loan_balance[Period = 24]))</code>


Alternatively, you can use [[If-Then-Else|conditional]] and [[Logical Operators|logical]] statements as follows:


:<code>Variable Equity := If Finance_option = 'Lease' then 0 else</code>
:<code>Car_price*(1 - 35%) - (Finance_option = 'Loan')*Loan_balance[Period = 24]</code>


Once again, consider how many dimensions your new variable will have. At first you might be tempted to list the indexes as follows:


:'''Finance option '''(Specified as a table index or used in a conditional expression)
:'''Car type '''(Index of the input variables '''Car price '''and '''Loan balance''')
:'''Period '''(Index of the input variable '''Loan balance''')


But '''Loan balance '''is not an input to this expression; only a [[slice]] of it is used. The slice is arrayed only by '''Car type'''. Therefore, the Equity variable will be indexed by '''Finance option '''and '''Car type '''but not by '''Period'''.


{{CalloutAnnotationBlock|[[File:Chapter_5.24-updated.png]]|{{
CalloutAnnotation|The '''Equity '''variable has only two dimensions: '''Car type '''and '''Finance option'''. 
It refers to a single slice of the '''Period '''index.|pt=50,151}}}}

==Combine dissimilar arrays== 


Now that you have established payments and ownership equity, you can combine them into a single cash flow variable. '''Payments '''will be represented as negative cash flows. '''Equity '''will be represented as a positive cash flow on the last period.


Create a new variable titled '''Cash flow '''and enter the following definition:


:<code>Variable Cash_flow := If Period = 24 then Equity - Payments else -Payments</code>


In this expression you have combined arrays with different numbers of dimensions:
:'''Payments '''is indexed by '''Car type''', '''Finance option '''and '''Period.
:Equity '''is indexed only by '''Car type '''and '''Finance option'''.


There is no ambiguity here since '''(Equity - Payments) '''applies to a [[slice]] along the '''Period''' index. The slice is called out in the conditional statement.


Notice that '''Equity '''and '''Payments[Period = 24] '''have the same dimensions.


There are other situations where you may want to use a scalar variable (not an array) as an input to an array. Similarly, you may want use an array as an input to another array that has more dimensions. In this situation Analytica will repeat the values of the smaller array for each [[slice]] along the new dimensions.


For example, suppose you want to incorporate monthly fuel cost into the '''Cash flow '''variable.


Here again you are combining two dissimilar arrays:


:'''Cash flow '''is indexed by '''Car type''', '''Finance option '''and '''Period'''
:'''Fuel cost '''is indexed only by '''Car type'''


Create a new variable titled '''Cash flow with fuel '''and define it as follows:


:<code>Variable Cash_flow_with_fuel :=</code>
:<code>If Period = 0 then Cash_flow else Cash_flow - Fuel_cost/12</code>


In this example, '''Fuel cost '''is applied to multiple slices along new dimensions:
* All '''Period '''values except Period 0
* All three '''Finance option '''categories.


Select '''Cash_flow_with_fuel '''and click the Results button ([[File:Chapter_4.54-updated.png]])


You will notice "Totals" check boxes next to the row and column index pop-up menus. Checking the box next to '''Period '''will allow you to see totals along that index.


{{CalloutAnnotationBlock|[[File:Chapter_5.25-updated.png]]|{{
CalloutAnnotation|
#Pivot the table as shown. 
#Check the "totals" box next to the row index menu '''Period''' index.|pt=220,101}}}}

==Array-Reducing Functions== 


A function that reduces one or more indexes of an array is referred to as an [[Array-reducing functions|array reducing function]]. The output of an array reducing function will have fewer dimensions than the input array. For example, the following expression will determine the sum of cash flows over all periods:


:<code>Variable Total_cash_flow := Sum(Cash_flow_with_fuel, Period)</code>


The input array is indexed by '''Car type''', '''Finance option '''and '''Period'''. The output will be a two- dimensional array indexed by '''Car type '''and '''Finance option'''. In this example the '''Period '''dimension has been reduced.


{{CalloutAnnotationBlock|[[File:Chapter_5.26-updated.png]]|{{
CalloutAnnotation|The '''Period''' index has ben reduced by the Sum() function.|pt=20,131}}}}


* The first argument of the [[Sum]]() function is the identifier of the variable to be operated on.
* This is followed by a list of indexes separated by commas. These are the indexes over which the function will operate.


In this example you have taken a sum over a single index.


Similar examples of [[array-reducing functions]] include [[Max]](), [[Min]](), [[Product]]() and [[Average]]().

==Net Present Value (NPV) analysis== 


If someone offered you a choice of receiving $100 today or receiving $100 two years from now, which would you choose? If you choose to receive it immediately, you can invest in a low risk bond with an annual return of, say, 6%. In two years the investment will be worth about $112. Clearly these two alternatives do not have equal value. Conversely, you would probably prefer to pay an obligation later rather than sooner.


''Net present value ''([[NPV]]) analysis is a way to compare various scenarios that involve inflows and outflows of money at different time periods. It converts a stream of cash flows to an equivalent scenario where all money is exchanged in a single transaction at the present time. The interest rate that can be achieved in a low risk investment is referred to as the ''discount rate''. For example, given a discount rate of 6%, the NPV of $112 paid two years in the future would be $100.


By taking a simple sum of cash flows as in the example above, you have ignored the time value of money. A Net Present Value analysis is more useful in this case. The [[NPV]]() function in Analytica makes this easy. It is another example of an array reducing function.


Assume the discount rate is 0.5% per month. Create an objective node titled '''Cash flow NPV'''.


(Objective nodes are represented by the hexagon shape on the node palette.)


Apply the following definition:


:<code>Objective Cash_flow_NPV := NPV(0.5%, Cash_flow_with_fuel, Period)</code>


* The first argument of the [[NPV]] function is the discount rate per period.
* The second argument is the identifier for the variable containing cash flows.
* The third argument is the index containing period values.


The analysis is complete!


:[[File:Chapter 5.27-updated.png]]

==Summary== 


In this chapter you have:
* Learned [[Expression Syntax|Expression syntax]]
* [[Creating an index|Created and defined index ]]variables
* Created array variables as tables dimensioned along established indexes
* Expanded arrays by adding new indexes
* Expanded indexes by adding new index values
* Created examples that demonstrate the basic principle of [[Array Abstraction|array abstraction]]: '''The result of an expression is arrayed by the ''union set ''of dimensions from all input variables, and the definition of the expression itself.'''
* Used conditional and logical statements within an expression
* Established local values in the definition field
* Analyzed a multi-dimensional result by pivoting indexes
* Reduced array variables using [[subscript]]s
* Applied [[array-reducing functions]] to arrays

==See Also== 
<div style="column-count:2;-moz-column-count:2;-webkit-column-count:2">
* [[Array]]
* [[Table]]
* [[Creating Arrays (Tables)]]
* [[Intelligent Arrays]]
* [[Arrays and Indexes]]
* [[Indexes and arrays: An introduction]]
* [[Creating an index]]
* [[Functions that create indexes]]
* [[Array-reducing functions]]
* [[Array functions]]
* [[Array Manipulation Examples and Challenge Problems]]
* [[Array Function Example Variables]]
* [[Multidimensional array]]s
* [[Expression Syntax]]
* [[Expressions]]
* [[The Expression popup menu]]
* [[Class]]
* [[Classes of variables and other objects]]
* [[Local Values]]
* [[Subscript]]
* [[Subscript and slice of a subarray]]
* [[Identifier]]
* [[Modeling Depreciation]]
* [[NPV]]
* [[Choice menus and Checkboxes in an edit table]]
* [[Dynamic Simulation]]
* [[Tutorial videos]]
* [https://www.youtube.com/watch?v=_8ZaXnEwhoE Intelligent Array Abstraction] (explanatory video on YouTube)
* [https://webinars.analytica.com/Docs/2008-01-11-Intro-to-arrays.mp4 Intro-to-arrays (Part 1).mp4] (an explanatory video about Analytica arrays and indexes (part 1); requires Windows Media player)
* [https://webinars.analytica.com/Docs/2008-01-17-Intro-to-arrays2.mp4 Intro-to-arrays (Part 2).mp4] (an explanatory video about Analytica arrays and indexes (part 2); requires Windows Media player)
</div>


<footer>Tutorial: Create a model/ {{PAGENAME}} / Tutorial: Uncertainty</footer>
</translate>

Analytica Command Line

2026-08-11T22:49:13Z

Lchrisman: ER 22418 -- document /WindowSize and /WindowXY, new in 7.2

[[category:File Commands]]
[[Category:Analytica User Guide]]

{{ReleaseBar}}

The desktop Analytica.exe process is launched with a command line having the format:

Analytica.exe [options] [filename]

The brackets mean that these are optional. When ''filename'' has one or more spaces, you need to put double quotes around the filename. Or, you can put double quotes around the ''filename'' even if it doesn't have spaces. The ''filename'' will usually have the extension *.ana. When no filename is specified, Analytica launches to the intro screen. When a filename is specified, it loads that model file.

== Options ==

Each option can be prefixed either with a forward slash, <code>/</code>, or with a minus, <code>-</code>. Option values appear after a colon. There can be no spaces within the option or its value. When an option value contains a space, the option value must be quoted using double quotes.

{{Release|1=7.2|2=|3=As of [[Analytica 7.2]], an option may also be prefixed with a double minus, <code>--</code>, and an option value may be introduced by an equal sign, <code>=</code>, in place of the colon. So <code>/nosplash</code>, <code>-nosplash</code> and <code>--nosplash</code> are all the same option, and <code>/mcp:8080</code> and <code>--mcp=8080</code> are the same option with the same value. This makes the spellings that are conventional for Chromium and for command lines on other operating systems work as expected.}}

* <code>/rlmDiag:''filename''</code>: Writes diagnostic information about licenses to ''filename''. This is very useful if you are encountering problems with a license that you believe has been activated, but is not working. After launching Analytica with this option, exit Analytica and either review the log file in a text editor, or email the diagnostic file to support@lumina.com for assistance. The diagnostic file logs the information about licenses that it finds on your computer, and hence is very useful for debugging license problems.
*: Example usage: <code>Analytica.exe /rlmDiag:"c:\Temp\rlmDiag.log"</code>

* <code>/roam:''days''</code>: Specifies the number of days to roam a floating license. Or, if ''days'' is -1, it releases a roamed license. See [[License Roaming]].
*: Example usage: <code>Analytica.exe /roam:7</code>

* <code>/lic:''licenseName''</code>: Uses the specified license name without changing which license is selected by default. The license must already be activated (i.e., the license must be in your <code>C:\ProgramData\Lumina\Licenses</code> folder).
*:Example: <code>Analytica.exe /lic:analytica_optimizer_761_2</code>

* <code>/rlm:''server''</code>: Specifies the server name (or port@serverName) that is running a Reprise License Manager with the desired centrally managed (e.g., floating) license.

* <code>/eval:''expression''</code>: (new to [[Analytica 6.0]]). Specifies an Analytica expression that is evaluated immediately after the model file that is specified on the command line finishes loading. The evaluating occurs after any proactively evaluated variables or buttons in the model. It does not dirty the model. The expression can include global variable assignments, and button identifiers. You will almost certainly want to include double quotes around the expression, and you need to escape any interior quotes by proceeding the quote with a backslash. The parameter is ignored if ''filename'' is not specified on the command line. See [[Running a model in a command line workflow]].

*: Example usage: <code>Analytica.exe /eval:"Claimant=\"JDoe\";Run_Batch;Exit" "Claim analysis.ana"</code>
*: In this example, <code>Claimant</code> is the identifier of an input variable in the model and <code>Run_batch</code> and <code>Exit</code> are names of a buttons in the model.

* <code>/comment:''text''</code>: (new to [[Analytica 6.0]]) The ''text'' is a comment that is ignored by Analytica. In one example usage, ACP3 adds a comment to each spawned processes to differentiate them in task manager.

* <code>/NoSplash</code>: (new to [[Analytica 6.0]]) Don't show the splash screen at startup (which normally displays for 3 seconds).

* <code>/mcp:«port»</code>: (new to [[Analytica 7.0]]) Enable Analytica as [[MCP server in Analytica|an MCP server]] (a protocol that allows A.I. language models to call functions in your model). [[UDF]]s that contain <code>@mcpTool</code> in their description are exposed as functions that the external A.I. client can call.

* <code>/lang:«code»</code> (new to [[Analytica 7.1]]) Specifies the User Interface language for Analytica (for menus, dialogs, error messages, built-in function descriptions, etc.). «code» is a language code such as <code>'en'</code> (for English), <code>'es'</code> (for Spanish), etc. The language is only used when the resource files exist for that language in
*:<code>«Analytica install folder»\Resources\«code»\</code>
*: The command line overrides the registry setting <code>Language</code> (if present) in the hive
*:<code>HKCU\Software\Lumina Decision Systems\Analytica</code>
*:As of [[Analytica 7.1]], non-English UI options is an experimental feature and not complete.

The remaining options exist for internal purposes and aren't generally used by end-users:
* <code>/embedding</code>: The Windows operating system uses this parameter when launching Analytica as a OLE-link server. Not used by end-users. Causes Analytica to launch quietly (without a GUI), load an indicated model, and exposes key OLE interfaces to Windows enabling an external application to complete the link to the model's data.

* <code>/solverDevLic</code>: This parameter is sometimes used by Analytica developers, but not generally by end-users. It indicates that the licenses from [https://solver.com Frontline Systems] found in the <code>Solver.lic</code> file are developer licenses rather than runtime licenses.

* <code>/forcerelease</code>: This parameter is used by Analytica quality assurance engineers during beta testing periods. It causes a beta release to behave like a final release build with regard to licensing.

*<code>/config:''filename''</code>: This is an option used by ACP3 (by Suan.exe) and not in Desktop Analytica. The specified config file contains settings that define the ACP3 server configuration.

{{Release|1=7.2|2=|3=
* <code>/remote-debugging-port:«port»</code>: (new to [[Analytica 7.2]]) Exposes the Chrome DevTools protocol (remote debugging) endpoint of Analytica's embedded Chromium (CEF) browser windows on <code>127.0.0.1:«port»</code>, so that an external tool — a benchmark driver, Claude Code, Puppeteer, or Chrome's <code>chrome://inspect</code> page — can inspect and drive HTML-based windows such as the Assista chat window, HTML dialogs, and windows created with the <code>CefWindow</code> function. The Chromium spelling <code>--remote-debugging-port=«port»</code> is also accepted. Use a «port» of 0 to have a free (ephemeral) port picked automatically. Valid values are 0 or 1024 through 65535. The endpoint listens only on 127.0.0.1, and enabling it is per-process (all CEF windows of the process share one endpoint, with one DevTools target per window).
*: After launch, the process reports the outcome in <code>%LOCALAPPDATA%\Lumina\Analytica\CEF\«pid»\RemoteDebug.json</code>, where «pid» is the process id of the launched Analytica.exe. On success this contains <code>"status":"listening"</code> and the actual port; when the requested port is already in use by another process, or CEF fails to initialize, it contains <code>"status":"failed"</code> with a reason, and a warning dialog is also shown. A tool that launches Analytica.exe with this option should read this file rather than connecting blindly, so that it cannot be fooled into talking to some other process that owns the port.
*: While remote debugging is enabled, each page in a CEF window exposes the JavaScript global <code>window.anaCefWindow</code> with fields <code>pid</code>, <code>handle</code>, <code>kind</code> and <code>title</code>, identifying which window a DevTools target belongs to. The <code>handle</code> matches the handle of the corresponding <code>CefWindow</code> object in the model.

* <code>/remote-allow-origins:«origins»</code>: (new to [[Analytica 7.2]]) A comma-separated list of origins (or <code>*</code>) allowed to connect to the remote-debugging endpoint from a web page. This is only needed when the DevTools client is itself a web page, which sends an HTTP Origin header that Chromium rejects by default. Ordinary clients (Python or Node scripts, Puppeteer, <code>chrome://inspect</code>) send no Origin header and connect without this option. The Chromium spelling <code>--remote-allow-origins=«origins»</code> is also accepted.
}}
{{Release|1=7.2|2=|3=
* <code>/lib:''filename''</code>: (new to [[Analytica 7.2]]) Loads the Analytica library in ''filename'' into the <code>SysLib_Customizations</code> system module, before the model named on the command line is opened. The library is then present no matter which model is loaded, and it stays loaded as models are closed and opened during the session. The option can be repeated to load several libraries. They load in the order given, all of them before the model.
*: Example usage: <code>Analytica.exe /lib:"W:\Analytica\Libraries\Multivariate Distributions.ana" MyModel.ana</code>
*: A relative ''filename'' is looked for first in the directory that the process was launched from, then in the directories on the <code>AddLibraryDir</code> library search path, then in the Analytica installation folder, and finally in the preferences folder. Path substitutions such as <code>%appdata%</code> and <code>%installdir%</code> are expanded.
*: Each library loaded this way is its own namespace. Since <code>SysLib_Customizations</code> is a private namespace, the library is not in namespace scope for the user's model. A model that wants to use one of these libraries must name it in its [[NamespaceImports]] attribute.
*: When the file is not found, or when it fails to load, a warning dialog names the file and Analytica continues to start up without it.
*: Uses for this include loading an [[MCP server in Analytica]] that works with whatever model is subsequently loaded, a benchmark driver, or a library that adds toolbar buttons or menu items.
}}

{{Release|1=7.2|2=|3=
* <code>/Automation</code>: (new to [[Analytica 7.2]]) Runs Analytica in ''automation mode'', in which every modal dialog that would otherwise block is answered automatically, so that an unattended run never stops waiting for a person. Each dialog is answered either by a built-in default, or by a handler function that the model or a library registers with [[RegisterAutomationModalHandler]]. This is intended for unattended and agent-driven runs, such as a benchmark driver, an automated QA run, or a session driven by an AI coding agent through the [[MCP server in Analytica]].
*: This is '''not''' a headless mode. The user interface, diagram windows, HTML dialogs, and Assista all remain fully alive and usable; only the blocking dialogs are answered for you. The splash screen is suppressed, as with <code>/nosplash</code>.
*: Some built-in defaults are deliberately conservative so that an unattended run cannot damage the model it is testing. In particular, "Save changes?" is answered '''No''', so the model file on disk is never written when the process exits. File open and save prompts fail rather than choosing a file, unless a registered handler supplies a path.
*: For the full list of defaults, how to write and register a handler, and worked examples of driving Analytica this way, see '''[[Analytica Command Line/Automation]]'''.
*: Example usage: <code>Analytica.exe /Automation /lib:BenchmarkDriver.ana MyModel.ana</code>

* <code>/AutomationTrace:''filename''</code>: (new to [[Analytica 7.2]]) Writes a log of every modal dialog to ''filename'', in JSON Lines format (one JSON object per line). Each dialog record names the kind of dialog, its caption and body text, the buttons it offered, the answer that was given, and where that answer came from. Records are appended, so a driver can pre-create the file and tail it while the run proceeds, and each record carries the process id so that concurrent runs remain distinguishable.
*: Used together with <code>/Automation</code>, this records what automation answered. Used '''without''' <code>/Automation</code>, it is an ''observe mode'': dialogs appear and behave completely normally, and the log records what the user actually chose. This is a convenient way to inventory which dialogs a scenario poses before you automate it.
*: A relative ''filename'' is resolved against the directory the process was launched from. If the file cannot be opened, Analytica starts normally and simply produces no log.
*: Example usage: <code>Analytica.exe /Automation /AutomationTrace:C:\Temp\run1.jsonl MyModel.ana</code>
}}

{{Release|1=7.2|2=|3=
These two options place the main Analytica application window explicitly, instead of using the size and position that Analytica saved when it last exited. They are intended for benchmark automation and automated QA, where the window needs to be the same from one run to the next, or needs to be somewhere predictable.

* <code>/WindowSize:«width»,«height»</code>: (new to [[Analytica 7.2]]) Sets the size of the main application window, in screen pixels.
*: Example usage: <code>Analytica.exe /WindowSize:1000,600</code>

* <code>/WindowXY:«x»,«y»</code>: (new to [[Analytica 7.2]]) Sets the position of the top left corner of the main application window, in screen coordinates. On a computer with more than one monitor, these coordinates can be negative, or larger than the size of the primary monitor, to place the window on another monitor.
*: Example usage: <code>Analytica.exe /WindowSize:1000,600 /WindowXY:-1000,100</code>

Either option can be used without the other. The one you leave out keeps the value that was saved when Analytica last exited.

The window is placed exactly where you ask for it. Unlike a position restored from a previous session, it is not nudged back onto a monitor, so a window that falls partly or entirely off screen stays where you put it. These options also take precedence over a maximized state saved from the previous session, and over the ''Run: Maximized'' setting of a Windows shortcut, so that the size you ask for is never ignored.

The geometry given on the command line is '''not''' saved back to the registry when Analytica exits. An automated run that uses these options therefore leaves the window size and position of your own interactive sessions undisturbed.

The size is that of the visible window frame. Windows surrounds that frame with an invisible drop shadow, so a script that measures the window using <code>GetWindowRect</code> sees a few extra pixels on each side, while <code>DwmGetWindowAttribute</code> with <code>DWMWA_EXTENDED_FRAME_BOUNDS</code> reports exactly the size that was requested.

A value that is not two whole numbers, or a width or height that is not positive, produces the ''Unrecognized command line parameter'' warning and that option is ignored.
}}

{{Release|1=7.2|2=|3=
== Command line options for libraries ==

''new in [[Analytica 7.2]]''

An option that begins with a double minus, <code>--</code>, and that is not one of the options listed above, does '''not''' produce the ''Unrecognized command line parameter'' warning. Analytica ignores it and passes it through, so that a library or a model can read it. This lets a library define command line options of its own without having to be built into Analytica. For example:

:<code>Analytica.exe --AssistaURL:<nowiki>"https://aaia.analytica.com/staging"</nowiki> --OpenAssista MyModel.ana</code>

A library reads them with [[GetProcessInfo]]:

:<code>GetProcessInfo("Command line:--AssistaURL") → 'https://aaia.analytica.com/staging'</code>
:<code>GetProcessInfo("Command line:--OpenAssista") → True</code>
:<code>GetProcessInfo("Command line:--NotGiven") → Null</code>
:<code>GetProcessInfo("Command line parameters") → ['--AssistaURL', '--OpenAssista']</code>

The value of such an option is the text that follows its colon or equal sign, and it must be quoted when it contains a space. An option that appears with no value reads as <code>True</code>, and an option that is not on the command line at all reads as <code>Null</code>, so a library can tell those two apart. A value always comes back as text, even when it looks like a number, so use [[ParseNumber]] when you want a number. When the same option appears more than once, the last occurrence is the one reported.

Because Analytica accepts any unrecognized <code>--</code> option silently, a misspelled one is simply ignored rather than reported. <code>GetProcessInfo("Command line parameters")</code> returns the list of <code>--</code> options that actually arrived, which is how a driver or library can check that it was passed what it expected.

The <code>--</code> options are not copied into the file names that Analytica opens, and they are not case-sensitive. When reading one, the leading dashes are optional, so <code>GetProcessInfo("Command line:AssistaURL")</code> finds it as well.

This mechanism is available in Analytica.exe, in ACP (Suan.exe) and in [[ADE]]. In ADE the command line is the one belonging to the host process that loaded ADE, which is the same command line that <code>GetProcessInfo("Command line")</code> reports.
}}

== Accessing the Command line from a model ==

The expression <code>[[GetProcessInfo]]('Command line')</code> returns the command line used to launch the process.

Timer

2026-08-11T15:06:54Z

Lchrisman:

''New to [[Analytica 7.2]]''

'''''Experimental''''' -- An experimental function is subject to change. To use, your model must import from the namespace <code>SysLib_Experimental</code>, or use a fully qualified name, <code>SysLib_Experimental::Timer</code>.

== Struct Timer( expr, secondsFromNow'', fireIfReleased'' ) ==

Schedules «expr» to be evaluated at an idle moment about «secondsFromNow» seconds from now -- never in the middle of a computation, a model load, or a modal dialog.

<code>Timer(expr, 0)</code> means "as soon as the current work finishes". Returns a timer instance.

Read <code>t->secondsFromNow</code> for the time remaining (Null once it has fired), assign to it to re-arm, and assign Null or a negative number to cancel.

Releasing the instance cancels the timer unless you pass <code>fireIfReleased:True</code>, which lets it fire once even when nothing holds onto it. Timers fire only in the Analytica desktop application.

== Experimental -- using Namespace import ==

To use an experimental function, your model should [[NamespaceImports|import from]] the <code>SysLib_Experimental</code> [[Namespace]]. If this is your only namespace import, you can set this from typescript using:
NamespaceImports MyModel: SysLib_Experimental

You can alternatively use a fully qualified name, <code>SysLib_Experimental::Timer(...)</code>. The downside of doing so is that if the function later becomes non-experimental, then it will be removed from that namespace.

== To fire at a specific time ==

[[Timer]]( DoIt(), 86400 * (t - [[Today]](true) ) )

Where 86400 is the number of seconds in a day.

Timer

2026-08-11T15:05:13Z

Lchrisman: Created page with "''New to Analytica 7.2'' '''''Experimental''''' -- To use, your model must import from the namespace <code>SysLib_Experimental</code>, or use a fully qualified name, <cod..."

''New to [[Analytica 7.2]]''

'''''Experimental''''' -- To use, your model must import from the namespace <code>SysLib_Experimental</code>, or use a fully qualified name, <code>SysLib_Experimental::Timer</code>.

== Struct Timer( expr, secondsFromNow'', fireIfReleased'' ) ==

Schedules «expr» to be evaluated at an idle moment about «secondsFromNow» seconds from now -- never in the middle of a computation, a model load, or a modal dialog.

<code>Timer(expr, 0)</code> means "as soon as the current work finishes". Returns a timer instance.

Read <code>t->secondsFromNow</code> for the time remaining (Null once it has fired), assign to it to re-arm, and assign Null or a negative number to cancel.

Releasing the instance cancels the timer unless you pass <code>fireIfReleased:True</code>, which lets it fire once even when nothing holds onto it. Timers fire only in the Analytica desktop application.

== Experimental -- using Namespace import ==

To use an experimental function, your model should [[NamespaceImports|import from]] the <code>SysLib_Experimental</code> [[Namespace]]. If this is your only namespace import, you can set this from typescript using:
NamespaceImports MyModel: SysLib_Experimental

== To fire at a specific time ==

[[Timer]]( DoIt(), 86400 * (t - [[Today]](true) ) )

Where 86400 is the number of seconds in a day.

GetProcessInfo

2026-08-10T20:22:26Z

Lchrisman: Remove a stray leading space introduced by the previous edit (action=raw round-trip)

[[Category:System Functions]]
[[Category: Memory management]]
{{ReleaseBar}}

[[GetProcessInfo]] can give you information about the current Analytica or [[ADE]] process, such as user name, computer, name, memory in use, number of processors available, number of objects in the model, and a whole lot more. from the Windows operating system,

== Types of information ==

[[GetProcessInfo]] returns information about the current Analytica or [[ADE]] process from the Windows operating system, according to which of these texts you pass as the «item» parameter:
:<code>"Process ID"</code> -- returns the Process ID, or Pid, for the current process.
:<code>"Thread ID"</code> -- returns the Id of the Analytica/ADE thread.
:<code>"Priority"</code> -- returns the priority of the Analytica/ADE thread. The following values are possible (defined by the Windows operating system):
::*<code>-15</code> : Idle only
::*<code>-2</code> : lowest priority
::*<code>-1</code> : below normal
::*<code>0</code> : normal priority
::*<code>1</code> : Above normal
::*<code>2</code> : Highest priority
::*<code>15</code>: Critical priority
::*<code>31</code>: Real-time priority
:<code>"Computer Name"</code>
:<code>"User Name"</code>: Windows login name
:<code>"User Identity"</code>: User name in ACP, or Windows login name in DTA.
:<code>"Windows Version"</code>
:<code>"Windows SP"</code>
:<code>"Windows Build"</code>
:<code>"Abort Event Object"</code> { ADE only }. Name of global Event object for ADE project that can be used to send ADE a break signal to abort the current computation.
: <code>"ENV:''«name»''"</code>: Retrieves the value for the environment variable «name»
: <code>"Environment Variables"</code>: List of all Environment variables
: <code>"Command Line"</code>
{{Release|1=7.2|2=|3=
: <code>"Command line:''«option»''"</code>: The value of a single option from the command line. See the example below.
: <code>"Command line parameters"</code>: A list of the <code>--</code> options that appeared on the command line.}}
: <code>"Analytica Path"</code>: Full file path to the ''Analytica.exe, Ade.exe'', or ''Ade.dll'' file being run.
: <code>"Working Set Size"</code>
: <code>"Working Set Max"</code>
: <code>"Working Set Min"</code>
: <code>"Working Set Flags"</code>
:<code> "Working Set Peak"</code>
: <code>"Private Bytes"</code>
: <code>"Total RAM"</code>
: <code>"Free RAM"</code>
: <code>"Total Virtual"</code>
: <code>"Max Address Space"</code>
: <code>"Memory Load"</code>
: <code>"Total Free Memory"</code>
: <code>"Page Fault Count"</code>
: <code>"Avail Virtual"</code>
: <code>"Processor #"</code>: On a multi-core computer, the processor currently running the current evaluation. This changes with time.
: <code>"Affinity Mask"</code>: A list of which processors the operating system will allow Analytica's evaluation to run on.
: <code>"Num Processors"</code>: The number of processors the Analytica process is allowed to run on.
: <code>"Num Sys Processors"</code>: The total number of processors on this computer in the current processor group. Always <=64.{{Release|6.0||
: <code>"Num cores"</code>: The total number of processors on this computer in all [https://docs.microsoft.com/en-us/windows/win32/procthread/processor-groups processor groups]. (Typically the same as <code>"Num Sys Processors"</code> on computers with 64 cores or less, but can be greater than 64 on very high-end servers).}}
: <code>"User Objects"</code>: Number of objects in use (variable nodes, local indexes, etc) by a model
: <code>"Total Objects"</code>: Number of objects in use including both user objects and built-in system objects.
: <code>"Free Objects"</code>: Number of free "slots" still available for additional objects.{{Release|1=7.1|2=|3=
: <code>'UI Language'</code>: Returns the language used for the Analytica user interface, "en"=English, "es"=Spanish, etc. }}{{Release|6.5||
:<code>"Application Rect"</code>: Returns width, height, top, left, as 4 return values, describing the screen coordinates of the desktop Analytica application window. Returns Null in ADE.
:<code>"Desk Rect"</code>: Returns width, height, x,y, as 4 return values, describing the rectangle within the desktop application where MDI windows can be. This rectangle starts below the toolbar, and does not include application boundaries.}}{{Release|1=7.0|2=|3=
:<code>"Python Environments"</code>: returns a list of all discovered Python/conda environment paths
:<code>"Python Installations"</code>: returns just the base Python installations
:<code>"Screenshot"</code>: Returns an image of the Analytica desktop application window (at the time the function call is evaluated).}}{{Release|1=7.1|2=|3=
:<code>"Current Monitor Rect"</code>: Returns width, height, x, y, as 4 return values, describing the screen coordinates of the monitor that the Analytica application window is currently on. Returns Null in ADE.
:<code>"Current Monitor Work Rect"</code>: Returns width, height, x, y, as 4 return values, describing the work area (excluding taskbar) of the monitor that the Analytica application window is currently on. Returns Null in ADE.
:<code>"Number of Monitors"</code>: The number of monitors connected to the system.
:<code>"Monitor ''N'' Rect"</code>: Returns width, height, x, y, as 4 return values, describing the screen coordinates of the ''N''th monitor (1-based). Replace ''N'' with any integer from 1 to the value of <code>"Number of Monitors"</code>. For example, <code>GetProcessInfo("Monitor 2 Rect")</code> returns the rectangle of the 2nd monitor.
:<code>"Monitor ''N'' Work Rect"</code>: Like <code>"Monitor ''N'' Rect"</code> but returns the work area (excluding taskbar) of the ''N''th monitor. For example, <code>GetProcessInfo("Monitor 1 Work Rect")</code>.}}

== Examples ==
=== Process ID ===
Knowing the Process ID makes it possible to differentiate between multiple instances of Analytica or [[ADE]] in the Windows Task Manager.
:<code>GetProcessInfo("Process ID") → 4117</code>

=== Reading the command line ===
:<code>GetProcessInfo("Command Line") → '"C:\Program Files\Lumina\Analytica.exe" "C:\My Models\Costs.ana"'</code>

See [[Analytica Command Line]] for a list of valid command line parameters recognized by Analytica.

{{Release|1=7.2|2=|3=
=== Reading a command line option ===
''new in [[Analytica 7.2]]''

<code>GetProcessInfo("Command line:''«option»''")</code> returns the value of one option from the command line, so that you do not have to parse the whole command line yourself. Any option that begins with a double minus, <code>--</code>, and that Analytica does not itself recognize, is accepted without an ''Unrecognized command line parameter'' warning, so that a library can define command line options of its own. After launching:

:<code>Analytica.exe --AssistaURL:<nowiki>"https://aaia.analytica.com/staging"</nowiki> --OpenAssista MyModel.ana</code>

these read as:

:<code>GetProcessInfo("Command line:--AssistaURL") → 'https://aaia.analytica.com/staging'</code>
:<code>GetProcessInfo("Command line:--OpenAssista") → True</code>
:<code>GetProcessInfo("Command line:--NotGiven") → Null</code>
:<code>GetProcessInfo("Command line parameters") → ['--AssistaURL', '--OpenAssista']</code>

The value is the text following the option's colon or equal sign. An option present with no value returns <code>True</code>, and an option that is not on the command line returns <code>Null</code>, so a library can distinguish ''not given'' from ''given with no value'' and from ''given an empty text''. A value is always returned as text, even when it looks like a number, so use [[ParseNumber]] when you want a number. When an option is repeated, the last occurrence is reported. The option name is not case-sensitive, and its leading <code>--</code> (or <code>-</code> or <code>/</code>) can be omitted when you read it.

<code>GetProcessInfo("Command line parameters")</code> returns the list of <code>--</code> options that were actually present. Since a misspelled <code>--</code> option is silently ignored rather than reported, this is the way for a launcher or library to confirm that it was passed what it expected.

See [[Analytica Command Line]] for the options that Analytica itself recognizes.
}}

=== Reading Environment Variables ===
Obtain a list of all environment variables:
:<code>Index EnvVarName := GetProcessInfo("Environment Variables");</code>
:<code>GetProcessInfo("Env:"&EnvVarName)</code>

=== Getting PID from ADE (C#) ===
:<code>CAEngine ade = new CAEngine();</code>
:<code>CAObject V = ade.CreateObject("V", "variable");</code>
:<code>V.SetAttribute("definition", "GetProcessInfo(\"Process ID\")");</code>
:<code>string pInfoResult = V.Result().ToString();</code>

=== Aborting an in-progress evaluation in ADE ===
To abort a computation in [[ADE]], your program must obtain a HANDLE to the ''abort event object''. In order to obtain this, you need to obtain the name of this object from ADE. You get this by calling <code>GetProcessInfo("Abort Event Object")</code>. You then use the Windows Platform SDK routine OpenEvent to get the handle to this object. When you want to abort an in-process computation, you set this event. Generally your application that uses ADE will need to be multi-threaded, so that one thread calls ADE, the other thread detects the signal to abort the computation (the signal might be a user pressing ''Ctrl+Break'', for example).

<pre style="background:white; border:white; margin-left: 1em;">
C++ example:

/* From first application thread, which uses ADE: */
#include <windows.h>
#import "ADE.exe"
using namespace ADE4;
...
GLOBAL HEVENT hAbort;
...
void main()
{
...
CAEngine* pAde = new CAEngine();
pAde->SendCommand("GetProcessInfo('Abort Event Object')");
_bstr_t abortObjName = pAde->get_OutputBuffer();
hAbort = OpenEvent(EVENT_MODIFY_STATE,/*bInherit*/FALSE,abortObjName);
...
CreateThread(..., MonitorForBreak,... );
CTable* pResult = pAde->Get("X")->ResultTable(); /* Initiate a very long computation */
if (pAde->get_ErrorCode() == 78) {
/* The computation was aborted before completion */
...
}
...
}

DWORD WINAPI MonitorForBreak( LPVOID )
{
/* This routine detects a signal to break the computation. Maybe it is a user-keypress,
* or other UI interaction. */
if (DetectUserWantsToAbort()) {
SetEvent(hAbort); /* Causes the abort */
}
}
</pre>

=== Memory Information ===
The Analytica process that evaluates your model may end up using a lot of memory. The operating system keeps some of that memory in RAM, and swaps some of it out to virtual memory. Accessing RAM is fast, while accessing virtual memory is much slower. Windows makes various tradeoffs with what other programs are running on your computer to decide how much of the Analytica process to keep in RAM. The amount of RAM to devote to Analytica is called its ''working set''. When the working set is much smaller that the available RAM, other applications on your computer will respond well (since they can use that RAM), but Analytica may run slowly. If the working set is close to the amount of available RAM, then Analytica gets to make more use of fast RAM, but other applications, and the Windows UI, may get very slow, since they will then need to switch in and out of memory.

<code>GetProcessInfo("Working Set Max")</code> and <code>GetProcessInfo("Working set Min")</code> return the minimum and maximum working set size, in bytes, currently imposed by Windows on the Analytica process. <code>GetProcessInfo("Working Set Flags")</code> returns an integer containing flags, indicating whether Windows is allowed to alter these limits as the process uses more or less memory. The flags are the following numbers added together:
* <code>1</code> = Analytica is guaranteed at least the minimum working set.
* <code>2</code> = Windows may reduce Analytica's working set below the minimum value when memory demands are high
* <code>4</code> = Windows will not allocate more than the indicated working set max.
* <code>8</code> = Windows may give Analytica more than the <code>Working Set Max</code> when memory demands from other applications is low.

The <code>"Avail Virtual"</code> option returns the number that Windows reports as the theoretical maximum amount of memory available to all processes running on the operating system, including both RAM and page file space. However, the number isn't very meaningful or reliable, as Windows often reports a number that far exceeds the amount of available hard disk space (for example, in Windows x64, a number of 8.8 TeraBytes is reported), and in 32-bit processes on Windows x64, the huge number seems to be wrap at 4GB, resulting in a nonesense (and often very small) number.

{{Release|1=6.5|2=|3=
== Application window coordinates ==
''new in [[Analytica 6.5]]''
:<code>[[Local]] (width, height, left, top) := [[GetProcessInfo]]( 'Application Rect');</code>

This gets the rectangle, in screen coordinates, of the desktop application. From ADE, or ACP when there is no dual desktop UI running, returns Null.

:<code>[[Local]](width, height) := [[GetProcessInfo]]('Desk Rect');</code>

This gets the size of the desk, the rectangle within the application where diagram windows, object window, result windows, the outliner, Assista window, etc. reside. This desk rectangle starts below the toolbar. You can also get the location:

:<code>[[Local]](width, height, x, y) := [[GetProcessInfo]]('Desk Rect');</code>

The x,y location coordinate is relative to the application window.
}}
==History==
This function was introduced in [[What's new in Analytica 4.0?|Analytica 4.0]].

==See Also==
* [[Working Set Size]]
* [[Memory usage and management]]

Analytica Command Line

2026-08-10T20:22:26Z

Lchrisman: Remove a stray leading space introduced by the previous edit (action=raw round-trip)

[[category:File Commands]]
[[Category:Analytica User Guide]]

{{ReleaseBar}}

The desktop Analytica.exe process is launched with a command line having the format:

Analytica.exe [options] [filename]

The brackets mean that these are optional. When ''filename'' has one or more spaces, you need to put double quotes around the filename. Or, you can put double quotes around the ''filename'' even if it doesn't have spaces. The ''filename'' will usually have the extension *.ana. When no filename is specified, Analytica launches to the intro screen. When a filename is specified, it loads that model file.

== Options ==

Each option can be prefixed either with a forward slash, <code>/</code>, or with a minus, <code>-</code>. Option values appear after a colon. There can be no spaces within the option or its value. When an option value contains a space, the option value must be quoted using double quotes.

{{Release|1=7.2|2=|3=As of [[Analytica 7.2]], an option may also be prefixed with a double minus, <code>--</code>, and an option value may be introduced by an equal sign, <code>=</code>, in place of the colon. So <code>/nosplash</code>, <code>-nosplash</code> and <code>--nosplash</code> are all the same option, and <code>/mcp:8080</code> and <code>--mcp=8080</code> are the same option with the same value. This makes the spellings that are conventional for Chromium and for command lines on other operating systems work as expected.}}

* <code>/rlmDiag:''filename''</code>: Writes diagnostic information about licenses to ''filename''. This is very useful if you are encountering problems with a license that you believe has been activated, but is not working. After launching Analytica with this option, exit Analytica and either review the log file in a text editor, or email the diagnostic file to support@lumina.com for assistance. The diagnostic file logs the information about licenses that it finds on your computer, and hence is very useful for debugging license problems.
*: Example usage: <code>Analytica.exe /rlmDiag:"c:\Temp\rlmDiag.log"</code>

* <code>/roam:''days''</code>: Specifies the number of days to roam a floating license. Or, if ''days'' is -1, it releases a roamed license. See [[License Roaming]].
*: Example usage: <code>Analytica.exe /roam:7</code>

* <code>/lic:''licenseName''</code>: Uses the specified license name without changing which license is selected by default. The license must already be activated (i.e., the license must be in your <code>C:\ProgramData\Lumina\Licenses</code> folder).
*:Example: <code>Analytica.exe /lic:analytica_optimizer_761_2</code>

* <code>/rlm:''server''</code>: Specifies the server name (or port@serverName) that is running a Reprise License Manager with the desired centrally managed (e.g., floating) license.

* <code>/eval:''expression''</code>: (new to [[Analytica 6.0]]). Specifies an Analytica expression that is evaluated immediately after the model file that is specified on the command line finishes loading. The evaluating occurs after any proactively evaluated variables or buttons in the model. It does not dirty the model. The expression can include global variable assignments, and button identifiers. You will almost certainly want to include double quotes around the expression, and you need to escape any interior quotes by proceeding the quote with a backslash. The parameter is ignored if ''filename'' is not specified on the command line. See [[Running a model in a command line workflow]].

*: Example usage: <code>Analytica.exe /eval:"Claimant=\"JDoe\";Run_Batch;Exit" "Claim analysis.ana"</code>
*: In this example, <code>Claimant</code> is the identifier of an input variable in the model and <code>Run_batch</code> and <code>Exit</code> are names of a buttons in the model.

* <code>/comment:''text''</code>: (new to [[Analytica 6.0]]) The ''text'' is a comment that is ignored by Analytica. In one example usage, ACP3 adds a comment to each spawned processes to differentiate them in task manager.

* <code>/NoSplash</code>: (new to [[Analytica 6.0]]) Don't show the splash screen at startup (which normally displays for 3 seconds).

* <code>/mcp:«port»</code>: (new to [[Analytica 7.0]]) Enable Analytica as [[MCP server in Analytica|an MCP server]] (a protocol that allows A.I. language models to call functions in your model). [[UDF]]s that contain <code>@mcpTool</code> in their description are exposed as functions that the external A.I. client can call.

* <code>/lang:«code»</code> (new to [[Analytica 7.1]]) Specifies the User Interface language for Analytica (for menus, dialogs, error messages, built-in function descriptions, etc.). «code» is a language code such as <code>'en'</code> (for English), <code>'es'</code> (for Spanish), etc. The language is only used when the resource files exist for that language in
*:<code>«Analytica install folder»\Resources\«code»\</code>
*: The command line overrides the registry setting <code>Language</code> (if present) in the hive
*:<code>HKCU\Software\Lumina Decision Systems\Analytica</code>
*:As of [[Analytica 7.1]], non-English UI options is an experimental feature and not complete.

The remaining options exist for internal purposes and aren't generally used by end-users:
* <code>/embedding</code>: The Windows operating system uses this parameter when launching Analytica as a OLE-link server. Not used by end-users. Causes Analytica to launch quietly (without a GUI), load an indicated model, and exposes key OLE interfaces to Windows enabling an external application to complete the link to the model's data.

* <code>/solverDevLic</code>: This parameter is sometimes used by Analytica developers, but not generally by end-users. It indicates that the licenses from [https://solver.com Frontline Systems] found in the <code>Solver.lic</code> file are developer licenses rather than runtime licenses.

* <code>/forcerelease</code>: This parameter is used by Analytica quality assurance engineers during beta testing periods. It causes a beta release to behave like a final release build with regard to licensing.

*<code>/config:''filename''</code>: This is an option used by ACP3 (by Suan.exe) and not in Desktop Analytica. The specified config file contains settings that define the ACP3 server configuration.

{{Release|1=7.2|2=|3=
* <code>/remote-debugging-port:«port»</code>: (new to [[Analytica 7.2]]) Exposes the Chrome DevTools protocol (remote debugging) endpoint of Analytica's embedded Chromium (CEF) browser windows on <code>127.0.0.1:«port»</code>, so that an external tool — a benchmark driver, Claude Code, Puppeteer, or Chrome's <code>chrome://inspect</code> page — can inspect and drive HTML-based windows such as the Assista chat window, HTML dialogs, and windows created with the <code>CefWindow</code> function. The Chromium spelling <code>--remote-debugging-port=«port»</code> is also accepted. Use a «port» of 0 to have a free (ephemeral) port picked automatically. Valid values are 0 or 1024 through 65535. The endpoint listens only on 127.0.0.1, and enabling it is per-process (all CEF windows of the process share one endpoint, with one DevTools target per window).
*: After launch, the process reports the outcome in <code>%LOCALAPPDATA%\Lumina\Analytica\CEF\«pid»\RemoteDebug.json</code>, where «pid» is the process id of the launched Analytica.exe. On success this contains <code>"status":"listening"</code> and the actual port; when the requested port is already in use by another process, or CEF fails to initialize, it contains <code>"status":"failed"</code> with a reason, and a warning dialog is also shown. A tool that launches Analytica.exe with this option should read this file rather than connecting blindly, so that it cannot be fooled into talking to some other process that owns the port.
*: While remote debugging is enabled, each page in a CEF window exposes the JavaScript global <code>window.anaCefWindow</code> with fields <code>pid</code>, <code>handle</code>, <code>kind</code> and <code>title</code>, identifying which window a DevTools target belongs to. The <code>handle</code> matches the handle of the corresponding <code>CefWindow</code> object in the model.

* <code>/remote-allow-origins:«origins»</code>: (new to [[Analytica 7.2]]) A comma-separated list of origins (or <code>*</code>) allowed to connect to the remote-debugging endpoint from a web page. This is only needed when the DevTools client is itself a web page, which sends an HTTP Origin header that Chromium rejects by default. Ordinary clients (Python or Node scripts, Puppeteer, <code>chrome://inspect</code>) send no Origin header and connect without this option. The Chromium spelling <code>--remote-allow-origins=«origins»</code> is also accepted.
}}
{{Release|1=7.2|2=|3=
* <code>/lib:''filename''</code>: (new to [[Analytica 7.2]]) Loads the Analytica library in ''filename'' into the <code>SysLib_Customizations</code> system module, before the model named on the command line is opened. The library is then present no matter which model is loaded, and it stays loaded as models are closed and opened during the session. The option can be repeated to load several libraries. They load in the order given, all of them before the model.
*: Example usage: <code>Analytica.exe /lib:"W:\Analytica\Libraries\Multivariate Distributions.ana" MyModel.ana</code>
*: A relative ''filename'' is looked for first in the directory that the process was launched from, then in the directories on the <code>AddLibraryDir</code> library search path, then in the Analytica installation folder, and finally in the preferences folder. Path substitutions such as <code>%appdata%</code> and <code>%installdir%</code> are expanded.
*: Each library loaded this way is its own namespace. Since <code>SysLib_Customizations</code> is a private namespace, the library is not in namespace scope for the user's model. A model that wants to use one of these libraries must name it in its [[NamespaceImports]] attribute.
*: When the file is not found, or when it fails to load, a warning dialog names the file and Analytica continues to start up without it.
*: Uses for this include loading an [[MCP server in Analytica]] that works with whatever model is subsequently loaded, a benchmark driver, or a library that adds toolbar buttons or menu items.
}}

{{Release|1=7.2|2=|3=
* <code>/Automation</code>: (new to [[Analytica 7.2]]) Runs Analytica in ''automation mode'', in which every modal dialog that would otherwise block is answered automatically, so that an unattended run never stops waiting for a person. Each dialog is answered either by a built-in default, or by a handler function that the model or a library registers with [[RegisterAutomationModalHandler]]. This is intended for unattended and agent-driven runs, such as a benchmark driver, an automated QA run, or a session driven by an AI coding agent through the [[MCP server in Analytica]].
*: This is '''not''' a headless mode. The user interface, diagram windows, HTML dialogs, and Assista all remain fully alive and usable; only the blocking dialogs are answered for you. The splash screen is suppressed, as with <code>/nosplash</code>.
*: Some built-in defaults are deliberately conservative so that an unattended run cannot damage the model it is testing. In particular, "Save changes?" is answered '''No''', so the model file on disk is never written when the process exits. File open and save prompts fail rather than choosing a file, unless a registered handler supplies a path.
*: For the full list of defaults, how to write and register a handler, and worked examples of driving Analytica this way, see '''[[Analytica Command Line/Automation]]'''.
*: Example usage: <code>Analytica.exe /Automation /lib:BenchmarkDriver.ana MyModel.ana</code>

* <code>/AutomationTrace:''filename''</code>: (new to [[Analytica 7.2]]) Writes a log of every modal dialog to ''filename'', in JSON Lines format (one JSON object per line). Each dialog record names the kind of dialog, its caption and body text, the buttons it offered, the answer that was given, and where that answer came from. Records are appended, so a driver can pre-create the file and tail it while the run proceeds, and each record carries the process id so that concurrent runs remain distinguishable.
*: Used together with <code>/Automation</code>, this records what automation answered. Used '''without''' <code>/Automation</code>, it is an ''observe mode'': dialogs appear and behave completely normally, and the log records what the user actually chose. This is a convenient way to inventory which dialogs a scenario poses before you automate it.
*: A relative ''filename'' is resolved against the directory the process was launched from. If the file cannot be opened, Analytica starts normally and simply produces no log.
*: Example usage: <code>Analytica.exe /Automation /AutomationTrace:C:\Temp\run1.jsonl MyModel.ana</code>
}}

{{Release|1=7.2|2=|3=
== Command line options for libraries ==

''new in [[Analytica 7.2]]''

An option that begins with a double minus, <code>--</code>, and that is not one of the options listed above, does '''not''' produce the ''Unrecognized command line parameter'' warning. Analytica ignores it and passes it through, so that a library or a model can read it. This lets a library define command line options of its own without having to be built into Analytica. For example:

:<code>Analytica.exe --AssistaURL:<nowiki>"https://aaia.analytica.com/staging"</nowiki> --OpenAssista MyModel.ana</code>

A library reads them with [[GetProcessInfo]]:

:<code>GetProcessInfo("Command line:--AssistaURL") → 'https://aaia.analytica.com/staging'</code>
:<code>GetProcessInfo("Command line:--OpenAssista") → True</code>
:<code>GetProcessInfo("Command line:--NotGiven") → Null</code>
:<code>GetProcessInfo("Command line parameters") → ['--AssistaURL', '--OpenAssista']</code>

The value of such an option is the text that follows its colon or equal sign, and it must be quoted when it contains a space. An option that appears with no value reads as <code>True</code>, and an option that is not on the command line at all reads as <code>Null</code>, so a library can tell those two apart. A value always comes back as text, even when it looks like a number, so use [[ParseNumber]] when you want a number. When the same option appears more than once, the last occurrence is the one reported.

Because Analytica accepts any unrecognized <code>--</code> option silently, a misspelled one is simply ignored rather than reported. <code>GetProcessInfo("Command line parameters")</code> returns the list of <code>--</code> options that actually arrived, which is how a driver or library can check that it was passed what it expected.

The <code>--</code> options are not copied into the file names that Analytica opens, and they are not case-sensitive. When reading one, the leading dashes are optional, so <code>GetProcessInfo("Command line:AssistaURL")</code> finds it as well.

This mechanism is available in Analytica.exe, in ACP (Suan.exe) and in [[ADE]]. In ADE the command line is the one belonging to the host process that loaded ADE, which is the same command line that <code>GetProcessInfo("Command line")</code> reports.
}}

== Accessing the Command line from a model ==

The expression <code>[[GetProcessInfo]]('Command line')</code> returns the command line used to launch the process.

GetProcessInfo

2026-08-10T20:19:00Z

Lchrisman: ER 22408: document Command line:--option and Command line parameters (7.2)

Analytica Command Line

2026-08-10T20:11:38Z

Lchrisman: ER 22408: document the -- prefix and library command line options (7.2)

[[category:File Commands]]
[[Category:Analytica User Guide]]

{{ReleaseBar}}

The desktop Analytica.exe process is launched with a command line having the format:

Analytica.exe [options] [filename]

The brackets mean that these are optional. When ''filename'' has one or more spaces, you need to put double quotes around the filename. Or, you can put double quotes around the ''filename'' even if it doesn't have spaces. The ''filename'' will usually have the extension *.ana. When no filename is specified, Analytica launches to the intro screen. When a filename is specified, it loads that model file.

== Options ==

Each option can be prefixed either with a forward slash, <code>/</code>, or with a minus, <code>-</code>. Option values appear after a colon. There can be no spaces within the option or its value. When an option value contains a space, the option value must be quoted using double quotes.

{{Release|1=7.2|2=|3=As of [[Analytica 7.2]], an option may also be prefixed with a double minus, <code>--</code>, and an option value may be introduced by an equal sign, <code>=</code>, in place of the colon. So <code>/nosplash</code>, <code>-nosplash</code> and <code>--nosplash</code> are all the same option, and <code>/mcp:8080</code> and <code>--mcp=8080</code> are the same option with the same value. This makes the spellings that are conventional for Chromium and for command lines on other operating systems work as expected.}}

* <code>/rlmDiag:''filename''</code>: Writes diagnostic information about licenses to ''filename''. This is very useful if you are encountering problems with a license that you believe has been activated, but is not working. After launching Analytica with this option, exit Analytica and either review the log file in a text editor, or email the diagnostic file to support@lumina.com for assistance. The diagnostic file logs the information about licenses that it finds on your computer, and hence is very useful for debugging license problems.
*: Example usage: <code>Analytica.exe /rlmDiag:"c:\Temp\rlmDiag.log"</code>

* <code>/roam:''days''</code>: Specifies the number of days to roam a floating license. Or, if ''days'' is -1, it releases a roamed license. See [[License Roaming]].
*: Example usage: <code>Analytica.exe /roam:7</code>

* <code>/lic:''licenseName''</code>: Uses the specified license name without changing which license is selected by default. The license must already be activated (i.e., the license must be in your <code>C:\ProgramData\Lumina\Licenses</code> folder).
*:Example: <code>Analytica.exe /lic:analytica_optimizer_761_2</code>

* <code>/rlm:''server''</code>: Specifies the server name (or port@serverName) that is running a Reprise License Manager with the desired centrally managed (e.g., floating) license.

* <code>/eval:''expression''</code>: (new to [[Analytica 6.0]]). Specifies an Analytica expression that is evaluated immediately after the model file that is specified on the command line finishes loading. The evaluating occurs after any proactively evaluated variables or buttons in the model. It does not dirty the model. The expression can include global variable assignments, and button identifiers. You will almost certainly want to include double quotes around the expression, and you need to escape any interior quotes by proceeding the quote with a backslash. The parameter is ignored if ''filename'' is not specified on the command line. See [[Running a model in a command line workflow]].

*: Example usage: <code>Analytica.exe /eval:"Claimant=\"JDoe\";Run_Batch;Exit" "Claim analysis.ana"</code>
*: In this example, <code>Claimant</code> is the identifier of an input variable in the model and <code>Run_batch</code> and <code>Exit</code> are names of a buttons in the model.

* <code>/comment:''text''</code>: (new to [[Analytica 6.0]]) The ''text'' is a comment that is ignored by Analytica. In one example usage, ACP3 adds a comment to each spawned processes to differentiate them in task manager.

* <code>/NoSplash</code>: (new to [[Analytica 6.0]]) Don't show the splash screen at startup (which normally displays for 3 seconds).

* <code>/mcp:«port»</code>: (new to [[Analytica 7.0]]) Enable Analytica as [[MCP server in Analytica|an MCP server]] (a protocol that allows A.I. language models to call functions in your model). [[UDF]]s that contain <code>@mcpTool</code> in their description are exposed as functions that the external A.I. client can call.

* <code>/lang:«code»</code> (new to [[Analytica 7.1]]) Specifies the User Interface language for Analytica (for menus, dialogs, error messages, built-in function descriptions, etc.). «code» is a language code such as <code>'en'</code> (for English), <code>'es'</code> (for Spanish), etc. The language is only used when the resource files exist for that language in
*:<code>«Analytica install folder»\Resources\«code»\</code>
*: The command line overrides the registry setting <code>Language</code> (if present) in the hive
*:<code>HKCU\Software\Lumina Decision Systems\Analytica</code>
*:As of [[Analytica 7.1]], non-English UI options is an experimental feature and not complete.

The remaining options exist for internal purposes and aren't generally used by end-users:
* <code>/embedding</code>: The Windows operating system uses this parameter when launching Analytica as a OLE-link server. Not used by end-users. Causes Analytica to launch quietly (without a GUI), load an indicated model, and exposes key OLE interfaces to Windows enabling an external application to complete the link to the model's data.

* <code>/solverDevLic</code>: This parameter is sometimes used by Analytica developers, but not generally by end-users. It indicates that the licenses from [https://solver.com Frontline Systems] found in the <code>Solver.lic</code> file are developer licenses rather than runtime licenses.

* <code>/forcerelease</code>: This parameter is used by Analytica quality assurance engineers during beta testing periods. It causes a beta release to behave like a final release build with regard to licensing.

*<code>/config:''filename''</code>: This is an option used by ACP3 (by Suan.exe) and not in Desktop Analytica. The specified config file contains settings that define the ACP3 server configuration.

{{Release|1=7.2|2=|3=
* <code>/remote-debugging-port:«port»</code>: (new to [[Analytica 7.2]]) Exposes the Chrome DevTools protocol (remote debugging) endpoint of Analytica's embedded Chromium (CEF) browser windows on <code>127.0.0.1:«port»</code>, so that an external tool — a benchmark driver, Claude Code, Puppeteer, or Chrome's <code>chrome://inspect</code> page — can inspect and drive HTML-based windows such as the Assista chat window, HTML dialogs, and windows created with the <code>CefWindow</code> function. The Chromium spelling <code>--remote-debugging-port=«port»</code> is also accepted. Use a «port» of 0 to have a free (ephemeral) port picked automatically. Valid values are 0 or 1024 through 65535. The endpoint listens only on 127.0.0.1, and enabling it is per-process (all CEF windows of the process share one endpoint, with one DevTools target per window).
*: After launch, the process reports the outcome in <code>%LOCALAPPDATA%\Lumina\Analytica\CEF\«pid»\RemoteDebug.json</code>, where «pid» is the process id of the launched Analytica.exe. On success this contains <code>"status":"listening"</code> and the actual port; when the requested port is already in use by another process, or CEF fails to initialize, it contains <code>"status":"failed"</code> with a reason, and a warning dialog is also shown. A tool that launches Analytica.exe with this option should read this file rather than connecting blindly, so that it cannot be fooled into talking to some other process that owns the port.
*: While remote debugging is enabled, each page in a CEF window exposes the JavaScript global <code>window.anaCefWindow</code> with fields <code>pid</code>, <code>handle</code>, <code>kind</code> and <code>title</code>, identifying which window a DevTools target belongs to. The <code>handle</code> matches the handle of the corresponding <code>CefWindow</code> object in the model.

* <code>/remote-allow-origins:«origins»</code>: (new to [[Analytica 7.2]]) A comma-separated list of origins (or <code>*</code>) allowed to connect to the remote-debugging endpoint from a web page. This is only needed when the DevTools client is itself a web page, which sends an HTTP Origin header that Chromium rejects by default. Ordinary clients (Python or Node scripts, Puppeteer, <code>chrome://inspect</code>) send no Origin header and connect without this option. The Chromium spelling <code>--remote-allow-origins=«origins»</code> is also accepted.
}}
{{Release|1=7.2|2=|3=
* <code>/lib:''filename''</code>: (new to [[Analytica 7.2]]) Loads the Analytica library in ''filename'' into the <code>SysLib_Customizations</code> system module, before the model named on the command line is opened. The library is then present no matter which model is loaded, and it stays loaded as models are closed and opened during the session. The option can be repeated to load several libraries. They load in the order given, all of them before the model.
*: Example usage: <code>Analytica.exe /lib:"W:\Analytica\Libraries\Multivariate Distributions.ana" MyModel.ana</code>
*: A relative ''filename'' is looked for first in the directory that the process was launched from, then in the directories on the <code>AddLibraryDir</code> library search path, then in the Analytica installation folder, and finally in the preferences folder. Path substitutions such as <code>%appdata%</code> and <code>%installdir%</code> are expanded.
*: Each library loaded this way is its own namespace. Since <code>SysLib_Customizations</code> is a private namespace, the library is not in namespace scope for the user's model. A model that wants to use one of these libraries must name it in its [[NamespaceImports]] attribute.
*: When the file is not found, or when it fails to load, a warning dialog names the file and Analytica continues to start up without it.
*: Uses for this include loading an [[MCP server in Analytica]] that works with whatever model is subsequently loaded, a benchmark driver, or a library that adds toolbar buttons or menu items.
}}

{{Release|1=7.2|2=|3=
* <code>/Automation</code>: (new to [[Analytica 7.2]]) Runs Analytica in ''automation mode'', in which every modal dialog that would otherwise block is answered automatically, so that an unattended run never stops waiting for a person. Each dialog is answered either by a built-in default, or by a handler function that the model or a library registers with [[RegisterAutomationModalHandler]]. This is intended for unattended and agent-driven runs, such as a benchmark driver, an automated QA run, or a session driven by an AI coding agent through the [[MCP server in Analytica]].
*: This is '''not''' a headless mode. The user interface, diagram windows, HTML dialogs, and Assista all remain fully alive and usable; only the blocking dialogs are answered for you. The splash screen is suppressed, as with <code>/nosplash</code>.
*: Some built-in defaults are deliberately conservative so that an unattended run cannot damage the model it is testing. In particular, "Save changes?" is answered '''No''', so the model file on disk is never written when the process exits. File open and save prompts fail rather than choosing a file, unless a registered handler supplies a path.
*: For the full list of defaults, how to write and register a handler, and worked examples of driving Analytica this way, see '''[[Analytica Command Line/Automation]]'''.
*: Example usage: <code>Analytica.exe /Automation /lib:BenchmarkDriver.ana MyModel.ana</code>

* <code>/AutomationTrace:''filename''</code>: (new to [[Analytica 7.2]]) Writes a log of every modal dialog to ''filename'', in JSON Lines format (one JSON object per line). Each dialog record names the kind of dialog, its caption and body text, the buttons it offered, the answer that was given, and where that answer came from. Records are appended, so a driver can pre-create the file and tail it while the run proceeds, and each record carries the process id so that concurrent runs remain distinguishable.
*: Used together with <code>/Automation</code>, this records what automation answered. Used '''without''' <code>/Automation</code>, it is an ''observe mode'': dialogs appear and behave completely normally, and the log records what the user actually chose. This is a convenient way to inventory which dialogs a scenario poses before you automate it.
*: A relative ''filename'' is resolved against the directory the process was launched from. If the file cannot be opened, Analytica starts normally and simply produces no log.
*: Example usage: <code>Analytica.exe /Automation /AutomationTrace:C:\Temp\run1.jsonl MyModel.ana</code>
}}

{{Release|1=7.2|2=|3=
== Command line options for libraries ==

''new in [[Analytica 7.2]]''

An option that begins with a double minus, <code>--</code>, and that is not one of the options listed above, does '''not''' produce the ''Unrecognized command line parameter'' warning. Analytica ignores it and passes it through, so that a library or a model can read it. This lets a library define command line options of its own without having to be built into Analytica. For example:

:<code>Analytica.exe --AssistaURL:<nowiki>"https://aaia.analytica.com/staging"</nowiki> --OpenAssista MyModel.ana</code>

A library reads them with [[GetProcessInfo]]:

:<code>GetProcessInfo("Command line:--AssistaURL") → 'https://aaia.analytica.com/staging'</code>
:<code>GetProcessInfo("Command line:--OpenAssista") → True</code>
:<code>GetProcessInfo("Command line:--NotGiven") → Null</code>
:<code>GetProcessInfo("Command line parameters") → ['--AssistaURL', '--OpenAssista']</code>

The value of such an option is the text that follows its colon or equal sign, and it must be quoted when it contains a space. An option that appears with no value reads as <code>True</code>, and an option that is not on the command line at all reads as <code>Null</code>, so a library can tell those two apart. A value always comes back as text, even when it looks like a number, so use [[ParseNumber]] when you want a number. When the same option appears more than once, the last occurrence is the one reported.

Because Analytica accepts any unrecognized <code>--</code> option silently, a misspelled one is simply ignored rather than reported. <code>GetProcessInfo("Command line parameters")</code> returns the list of <code>--</code> options that actually arrived, which is how a driver or library can check that it was passed what it expected.

The <code>--</code> options are not copied into the file names that Analytica opens, and they are not case-sensitive. When reading one, the leading dashes are optional, so <code>GetProcessInfo("Command line:AssistaURL")</code> finds it as well.

This mechanism is available in Analytica.exe, in ACP (Suan.exe) and in [[ADE]]. In ADE the command line is the one belonging to the host process that loaded ADE, which is the same command line that <code>GetProcessInfo("Command line")</code> reports.
}}

== Accessing the Command line from a model ==

The expression <code>[[GetProcessInfo]]('Command line')</code> returns the command line used to launch the process.

MCP server in Analytica

2026-08-07T19:02:31Z

Lchrisman: ER 22409: note that /Automation keeps modal dialogs from blocking an agent session; link to the Automation guide

''New in [[Analytica 7.0]]''

::''The feature described here is '''''experimental''''' and for the time being intended for Lumina-internal use. As an experimental feature, it is subject to change.''

== Implementing an MCP server ==
A [https://modelcontextprotocol.io/docs/getting-started/intro Model Context Protocol (MCP)] server exposes tools that can be used by an AI agent such as Claude Code and Gemini CLI. It is possible to implement an MCP server directly in an Analytica model using specially tagged [[UDF]]s to implement each tool. It is easy to do so, and can enable AI agents to use or control your Analytica model.

At present, this feature has been created and is being used (or use being explored) internally at Lumina in several ways, including:
* For automation of Quality Assurance testing.
* For end-to-end Assista evaluation (especially when Assista takes actions during its response).
* To enable AI coding tools to more actively control Analytica when developing code, debugging, reproducing UI bugs, etc.
* To interactively use desktop Analytica in coordination with Claude Code, especially on some cases where Claude has access to tools that Assista does not.

The current feature implementation has distinct limitations, and is likely to change as we gain more internal experience with coordinating AI agents and desktop Analytica.

== Creating an MCP server ==
To put desktop Analytica into an MCP-serving mode, you need to launch it with the command line parameter:
:<code>Analytica.exe /mcp:«port»</code>
such as
:<code>Analytica.exe /mcp:6541</code>

To implement a tool that an AI agent can use, create a [[User-Defined Function]] with a description that guides a language model as to when and how to use the tool, and then include the following text somewhere within the description: <code>{@mcpTool}</code>. We usually place this at the very beginning or very end of the description. This tag labels the UDF as an MCP tool.

When you declare parameters, you ''must'' declare the data type of each parameter as either <code>Number</code> or <code>Text</code>. The <code>atom</code> qualifier is also recommended but not required. Parameters can be optional and can include default values. At this time, no parameter can be declared as an array, index, object (or other non-evaluated eval mode), or repeated parameter. These may be relaxed later as the implementation becomes more complete.

If your UDF makes use of parameter qualifiers that are not yet supported, it will not be included in the tool/list result.

== Configuring the client ==
To configure the client to use your server, your Analytica process must already be running with your UDFs existing.

Configure the client using a Transport type of <code>"Streamable HTTP"</code> and a URL of <code>"http://localhost:6541/mcp"</code>, where the port number matches the port you used for the <code>/mcp:6541</code> parameter when you launched Analytica.exe.

A convenient testing client is the '''MCP Inspector''' which can be run in an installation-free mode. You do have to already have Node.js installed, and then from a command line just run:
:<code>npx @modelcontextprotocol/inspector</code>
The testing client UI opens in a browser. After you connect, you should see your exposed UDFs after pressing '''List tools'''.

== Keeping dialogs from blocking the agent ==
{{Release|1=7.2|2=|3=
A modal dialog is invisible to an AI agent: if Analytica poses one while serving a tool call, the call simply never returns and the agent cannot tell a blocked process from a slow one. Launch Analytica with the <code>/Automation</code> option alongside <code>/mcp:</code> so that every blocking dialog is answered automatically and the session keeps running:
:<code>Analytica.exe /Automation /mcp:6541 MyModel.ana</code>
A model or library can also register a handler with [[RegisterAutomationModalHandler]] to decide the answers itself, and to record each dialog so that an <code>{@mcpTool}</code> UDF can report back to the agent what Analytica asked while a tool call ran. See [[Analytica Command Line/Automation]].
}}

== Limitations ==
There are currently many limitations. These contribute to the experimental status of the feature. These may be progressively relaxed in the future.
* Not namespace aware - make sure your tools are in scope from the main model and names not ambiguous.
* Only a subset of [[Function Parameter Qualifiers]] currently supported:
** Only Number and Text parameters
** Array parameters, index parameters, and other evaluation models other than Context are not supported.
** Repeated parameters not supported.
* No array abstraction on calls.
* Can only be used by AI agents running on localhost.
* Does not proactively push notification to clients when changes to the <code>tools/list</code> occur. (But you can interactively debug and refine your tools, you clients just need to re-read the tool list. Claude Code needs to be restarted to have in reread).
* There is no authentication on the connection. Hence, once you have your server running, and process running on localhost could potentially connect and call your tools.
* If a UDF with the <code>{@mcpTool}</code> tag uses parameter qualifiers that aren't yet supported, it is quietly excluded from the tool list, but it does not report this to you, nor does it report what qualifier is not supported.

RegisterAutomationModalHandler

2026-08-07T19:02:14Z

Lchrisman: ER 22409: new function reference page for RegisterAutomationModalHandler (new to 7.2)

[[category:User-interface functions]]
[[Category:Doc Status D]] 
{{ReleaseBar}}

__TOC__

== RegisterAutomationModalHandler( handler ) ==

''New to [[Analytica 7.2]].''

Registers «handler» as the function that answers modal dialogs while Analytica is running in ''automation mode'' — that is, while the process was launched with the [[Analytica Command Line|command line]] option <code>/Automation</code>. Returns the previously registered handler, or [[Null]] if there was none.

In automation mode, every modal dialog that would otherwise block is answered automatically instead of being shown. When a handler is registered, it is called with a description of each dialog and its return value supplies the answer. When no handler is registered, or when the handler returns [[Null]], a built-in default answer is used.

The function may be called at any time, and the registration succeeds whether or not the process is in automation mode. The handler is only ''consulted'' in automation mode, so it is harmless to leave the call in a model that people also use interactively.

For a guide to using this — including the full table of built-in defaults, worked examples, and how to package a handler as a driver library for benchmarks or for an AI agent — see '''[[Analytica Command Line/Automation]]'''.

=== The «handler» parameter ===

«handler» is required, and must be a callable that accepts one parameter:
* a [[Handle]] to a [[User-Defined Function]],
* a local (lambda) function, or
* a Python callable.

:<code>[[RegisterAutomationModalHandler]]( [[Handle]](My_dialog_handler) )</code>
:<code>[[RegisterAutomationModalHandler]]( Function(s) ::= If s->kind = 'SaveChanges' Then 'No' Else [[Null]] )</code>

An error is reported if «handler» is not callable.

There is no separate "unregister" form. A handler that returns [[Null]] for every dialog behaves identically to having no handler at all — the built-in defaults apply — so registering such a handler stands the previous one down. Because the previous handler is returned, a library can also chain to it:

<code><pre>
Variable Prior_handler := RegisterAutomationModalHandler( Handle(My_handler) )
</pre></code>

=== The «s» parameter of the handler ===

The handler receives one <code>AutomationDialogStruct</code> value describing the dialog. Read its fields with the <code>-></code> operator, e.g. <code>s->kind</code>.

{| class="wikitable"
! Field !! Type !! Meaning
|-
| <code>kind</code> || Text || The dialog family. One of <code>'MsgBox'</code>, <code>'Ask'</code>, <code>'AskText'</code>, <code>'AskNumber'</code>, <code>'AskChoice'</code>, <code>'FileOpen'</code>, <code>'FileSave'</code>, <code>'Warning'</code>, <code>'Redefine'</code>, <code>'SaveChanges'</code>, <code>'Comment'</code>, <code>'LinkedModuleChanged'</code>, <code>'Win32Dialog'</code>, <code>'MacAppDialog'</code>, <code>'Alert'</code>, <code>'CmdLineWarning'</code>
|-
| <code>id</code> || Text or [[Null]] || A stable identity for the particular dialog when one is known, such as <code>'SaveQuitting'</code>, <code>'CheckFailure'</code> or <code>'ContinueReading'</code>, or the internal name of a template dialog
|-
| <code>caption</code> || Text or [[Null]] || The dialog's title bar text
|-
| <code>body</code> || Text or [[Null]] || The dialog's message text
|-
| <code>buttons</code> || List of Text, or [[Null]] || The button names offered, e.g. <code>['Yes','No','Cancel']</code>
|-
| <code>defaultAnswer</code> || Text || What the built-in default would answer if the handler returns [[Null]]
|-
| <code>obj</code> || [[Handle]] or [[Null]] || The object the dialog concerns, when there is one
|-
| <code>att</code> || Text or [[Null]] || The attribute concerned, when relevant
|-
| <code>seq</code> || Number || This dialog's sequence number, matching the <code>seq</code> field in the <code>/AutomationTrace:</code> log
|}

The field set is fixed for [[Analytica 7.2]] and will only grow by addition, so a handler that reads these fields will keep working.

=== The handler's return value ===

{| class="wikitable"
! Return value !! Effect
|-
| [[Null]] || Use the built-in default answer for this dialog
|-
| Text || For a button dialog: the name of the button to press — <code>'Yes'</code>, <code>'No'</code>, <code>'OK'</code>, <code>'Cancel'</code>, <code>'Ignore'</code>, <code>'Retry'</code>, <code>'Abort'</code>. For <code>'AskText'</code>: the text to enter. For <code>'FileOpen'</code> or <code>'FileSave'</code>: the full path of the file to use, which is treated exactly as if the user had selected it
|-
| Number || For <code>'AskNumber'</code>: the value entered. For <code>'AskChoice'</code>: the 1-based index of the option chosen
|}

Answering <code>'Cancel'</code> has exactly the same effect as a user pressing Cancel, including aborting the computation in progress where that is what Cancel normally does.

If the return value is not one of the above — a button name that the dialog does not offer, or the wrong data type for the dialog — the built-in default is used and the event is recorded in the trace log as <code>handler-error-fallback</code>.

=== Rules the handler runs under ===

* '''Main thread only.''' A dialog raised on a worker thread (during parallel evaluation, for example) is answered with the built-in default without calling the handler. Such events are recorded as <code>offthread-default</code>.
* '''Not re-entrant.''' A dialog raised ''while'' the handler is running takes the built-in default rather than calling the handler again, and is recorded as <code>reentrant-default</code>. Note that [[WriteTextFile]] can itself raise a dialog, so pass <code>warn: False</code> when logging from a handler.
* '''Errors are contained.''' If the handler raises an error, the built-in default is used, the event is recorded as <code>handler-error-fallback</code>, and evaluation continues. The handler is not called a second time and no dialog is shown about the failure.
* '''Cannot change the model.''' The handler runs with model dirtying and autosave suppressed, so observing a dialog cannot mark the model as changed. Do not use a handler to modify the model.
* '''Error state is preserved.''' Most dialogs occur while an error or warning is pending. That state is saved before the handler is called and restored afterwards.
* '''Timed.''' The handler's wall-clock time is recorded in the trace log as <code>handlerMs</code>.

== Examples ==

Answer one specific question and default everything else:

<code><pre>
Function Qa_handler( s : atom ) :=
If s->id = 'CheckFailure' Then 'No'
Else If s->kind = 'FileOpen' Then 'C:\Scenarios\input1.csv'
Else Null
</pre></code>
:<code>[[RegisterAutomationModalHandler]]( [[Handle]](Qa_handler) )</code>

Record every dialog without changing any answer:

<code><pre>
Function Watch_handler( s : atom ) :=
( WriteTextFile( 'dialogs.log',
s->seq & Chr(9) & s->kind & Chr(9) & s->defaultAnswer & Chr(13) & Chr(10),
append: True, warn: False );
Null )
</pre></code>

== Notes ==

* The handler is a property of the process, not of the model. It survives closing one model and opening another, which is what makes it useful in a library loaded with <code>/lib:</code>.
* If the [[UDF]] a registered handle refers to is deleted (for instance because its model was closed), the handler is treated as unregistered and the built-in defaults resume.
* This function is hidden from the function list (it has a low Intellisense level); type its name to use it.

== See Also ==
<div style="column-count:2;-moz-column-count:2;-webkit-column-count:2">
* '''[[Analytica Command Line/Automation]]'''
* [[Analytica Command Line]]
* [[MCP server in Analytica]]
* [[Running a model in a command line workflow]]
* [[MsgBox]]
* [[AskMsgText]]
* [[AskMsgNumber]]
* [[AskMsgChoice]]
* [[Handle]]
* [[User-Defined Function]]
* [[WriteTextFile]]
</div>

Analytica Command Line/Automation

2026-08-07T18:58:08Z

Lchrisman: ER 22409: new user guide for /Automation mode - defaults, writing a RegisterAutomationModalHandler handler, the trace log, and driver/agent/QA uses

[[category:File Commands]]
[[Category:Analytica User Guide]]
{{ReleaseBar}}

''New in [[Analytica 7.2]].'' See also the parent page, [[Analytica Command Line]].

__TOC__

== Why automation mode exists ==

A dialog box is fine when a person is sitting in front of Analytica. It is fatal when nobody is. A single unexpected "Save changes?" or "This variable failed its Check" dialog will stop an overnight benchmark, a QA sweep, or an AI agent's session dead, and you often will not find out until much later that nothing after that point ran.

Launching with <code>/Automation</code> answers those dialogs for you:

:<code>Analytica.exe /Automation MyModel.ana</code>

Every modal dialog that would block gets an answer — either a sensible built-in default, or an answer computed by a handler function you register with [[RegisterAutomationModalHandler]]. The run keeps going.

Three things are worth being clear about up front:

* '''It is not a headless mode.''' The main window, diagrams, result windows, HTML dialogs, and Assista all work exactly as usual. You can watch the run happen, and you can take over with the mouse at any point. If you want Analytica without a user interface, that is a different thing entirely.
* '''It changes nothing unless you ask for it.''' Without the flag, every dialog behaves exactly as it always has. Automation mode is a property of the process, set once from the command line.
* '''The defaults are chosen to protect the model under test,''' not to make progress at all costs. Where "keep going" and "do not touch anything" conflict, automation picks "do not touch anything" — see [[#What the built-in defaults do]].

== Getting started ==

=== Just run it ===

Start with no handler at all. The built-in defaults handle a surprising amount on their own:

:<code>Analytica.exe /Automation /eval:Run_batch "Claim analysis.ana"</code>

If your model already runs unattended except for the occasional dialog, this may be all you need.

=== See which dialogs your scenario actually poses ===

Before writing any handler, find out what you are dealing with. Add a trace file:

:<code>Analytica.exe /Automation /AutomationTrace:C:\Temp\run1.jsonl MyModel.ana</code>

Every dialog is appended to <code>run1.jsonl</code> as one JSON object per line, recording what it said and how it was answered. See [[#The trace log]].

You can also run the trace ''without'' <code>/Automation</code>:

:<code>Analytica.exe /AutomationTrace:C:\Temp\baseline.jsonl MyModel.ana</code>

This is '''observe mode'''. Dialogs appear and block normally, exactly as for any other user, and the log records what ''you'' chose. It is the easiest way to walk a scenario by hand once and get a complete inventory of its dialogs, along with the answers a human considered correct — which is a good starting specification for the handler you are about to write.

== What the built-in defaults do ==

With no handler registered, dialogs are answered as follows.

{| class="wikitable"
! Dialog !! Automatic answer !! Why
|-
| Message boxes ([[MsgBox]] and internal ones) || The default button — the one '''Enter''' would press || Matches what a user pressing through quickly would get
|-
| [[AskMsgText]] || The «default» text || The value the model already proposed
|-
| [[AskMsgNumber]] || The «default» number ||
|-
| [[AskMsgChoice]] || The «default» option ||
|-
| '''Save changes?''' on close or quit || '''No''' — discard || An unattended run must never overwrite the model it is testing
|-
| Evaluation warnings (Check failures, bad values) || Ignore ''this one'' || See the note below
|-
| "Stop evaluating and edit the definition?" || '''No''' || The error is already recorded; opening an editor mid-run helps nobody
|-
| File open / file save prompts || Fail, as if cancelled || Guessing a filename is worse than failing. A handler can supply a real path
|-
| Other template-based dialogs || Cancel, ''without running the dialog'' || Cancelling a dialog that never opened has no side effects
|-
| Externally-changed linked module || Later (keep what is in memory) ||
|-
| Legal agreement, license prompts || Accepted || So a fresh machine does not hang at startup
|-
| Unrecognized command-line option || Continue || Never <code>exit(-1)</code> in the middle of a batch
|}

Two of these deserve emphasis.

'''Save changes is answered No.''' This is deliberately the opposite of what Analytica's existing headless/server path does, which silently saves. A benchmark that mutates its fixture model between runs is not measuring what you think it is measuring, and a QA run that rewrites the model under test destroys the evidence. If your automation genuinely wants to save, make that explicit — have your handler answer <code>'Yes'</code> to the <code>'SaveChanges'</code> dialog, so the intent is visible in the trace.

'''Warnings are ignored once, not switched off.''' Pressing "Ignore Warnings" interactively silences warnings for the rest of the session. Automation deliberately does not do that: each warning is cleared individually, so the tenth warning is still reported to your handler and still written to the trace. You get a complete record instead of a log that goes quiet after the first problem.

Dialogs raised on a worker thread (during parallel evaluation, for instance) always take the built-in default and are recorded with <code>"source":"offthread-default"</code>. Your handler is only consulted on the main thread.

== Writing an automation handler ==

When the defaults are not enough — when the answer depends on ''which'' dialog it is, or when you want to record something, or ask a person or an orchestrator — register a handler:

:<code>[[RegisterAutomationModalHandler]]( ''handler'' )</code>

The handler is any callable: a handle to a [[UDF]], a local (lambda) function, or a Python callable. It takes one parameter, receives a struct describing the dialog, and returns the answer. It may be registered at any time, but it is only consulted when the process is running with <code>/Automation</code>, so it is harmless to leave the registration in a model that people also use interactively.

The simplest useful handler answers nothing and just watches:

<code><pre>
Function Log_dialogs( s : atom ) :=
( WriteTextFile( 'dialogs.log',
s->seq & ' ' & s->kind & ' ' & s->caption & Chr(13) & Chr(10),
append: True, warn: False );
Null ) { Null means: use the built-in default }
</pre></code>

:<code>[[RegisterAutomationModalHandler]]( [[Handle]](Log_dialogs) )</code>

=== What the handler receives ===

The parameter is an <code>AutomationDialogStruct</code> with these fields, read with the <code>-></code> operator:

{| class="wikitable"
! Field !! Meaning
|-
| <code>kind</code> || The family of dialog: <code>'MsgBox'</code>, <code>'Ask'</code>, <code>'AskText'</code>, <code>'AskNumber'</code>, <code>'AskChoice'</code>, <code>'FileOpen'</code>, <code>'FileSave'</code>, <code>'Warning'</code>, <code>'Redefine'</code>, <code>'SaveChanges'</code>, <code>'LinkedModuleChanged'</code>, <code>'Win32Dialog'</code>, <code>'MacAppDialog'</code>, <code>'Alert'</code>, <code>'Comment'</code>, <code>'CmdLineWarning'</code>
|-
| <code>id</code> || A stable identity for the specific dialog when one is known, such as <code>'SaveQuitting'</code> or <code>'CheckFailure'</code>, or the internal name of a template dialog. [[Null]] otherwise
|-
| <code>caption</code> || The title bar text
|-
| <code>body</code> || The message text
|-
| <code>buttons</code> || A list of the button names offered, such as <code>['Yes','No','Cancel']</code>. [[Null]] when the dialog is not a button dialog
|-
| <code>defaultAnswer</code> || What the built-in default would answer, as text. Useful for logging, and for "default unless I say otherwise" logic
|-
| <code>obj</code> || A [[Handle]] to the object the dialog is about, when there is one. [[Null]] otherwise
|-
| <code>att</code> || The attribute involved, as text, when relevant
|-
| <code>seq</code> || The sequence number of this dialog, matching the <code>seq</code> in the trace log
|}

=== What the handler returns ===

{| class="wikitable"
! Return !! Effect
|-
| [[Null]] || Use the built-in default. This is the right answer most of the time
|-
| Text || For a button dialog, the name of the button to press: <code>'Yes'</code>, <code>'No'</code>, <code>'OK'</code>, <code>'Cancel'</code>, <code>'Ignore'</code>, <code>'Retry'</code>, <code>'Abort'</code>. For <code>'AskText'</code>, the text to enter. For <code>'FileOpen'</code> or <code>'FileSave'</code>, the full path of the file to use
|-
| Number || For <code>'AskNumber'</code>, the value. For <code>'AskChoice'</code>, the 1-based index of the option to choose
|}

Answering a file dialog with a path is often the single highest-value thing a handler does: instead of the prompt failing, the run proceeds with exactly the file your driver wants, chosen at the moment it is asked for.

A handler that returns [[Null]] for everything behaves exactly like no handler at all, which is how you stand a handler down without unregistering it.

=== A worked example ===

<code><pre>
Function Bench_handler( s : atom ) :=
Var body := If IsNull(s->body) Then '' Else s->body;
( { 1. Record everything, whatever we decide below. }
WriteTextFile( 'bench-dialogs.log',
s->seq & Chr(9) & s->kind & Chr(9) & s->defaultAnswer & Chr(9) & body & Chr(13) & Chr(10),
append: True, warn: False );

{ 2. Feed the scenario the input file it is about to ask for. }
If s->kind = 'FileOpen' Then Bench_input_path

{ 3. This scenario is supposed to reach the end; a Check failure means it did not. }
Else If s->kind = 'Warning' Or s->id = 'CheckFailure' Then
( WriteTextFile( 'bench-failures.log', 'FAILED: ' & body & Chr(13) & Chr(10),
append: True, warn: False );
Null )

{ 4. Everything else: whatever the built-in default is. }
Else Null )
</pre></code>

=== Rules the handler runs under ===

* '''Main thread only.''' Dialogs raised on worker threads take the built-in default (traced as <code>offthread-default</code>).
* '''No re-entry.''' If your handler itself causes a dialog — and a [[WriteTextFile]] easily can — that inner dialog takes the built-in default rather than calling your handler again. It is recorded as <code>reentrant-default</code>, so you can see it happened.
* '''Errors are contained.''' If your handler raises an error, the built-in default is used, the trace records <code>handler-error-fallback</code>, and the run continues. A broken handler degrades to the defaults; it does not stop the run and never pops up a dialog of its own about the failure.
* '''It cannot dirty the model.''' The handler runs with model-dirtying and autosave suppressed, so merely observing a dialog cannot mark the model changed. Note this means a handler is not the place to modify the model.
* '''The error state is preserved.''' Most of these dialogs occur while an error or warning is pending. That state is saved before your handler runs and restored afterwards, so your handler sees a clean slate and does not disturb the error being reported.
* '''It is timed.''' The wall-clock time your handler takes is recorded in the trace as <code>handlerMs</code>, so you can see how much your instrumentation perturbs a benchmark.

== The trace log ==

<code>/AutomationTrace:''filename''</code> writes [https://jsonlines.org JSON Lines] — one self-contained JSON object per line, appended, each written in a single operation so that concurrent processes never interleave a record.

A run starts with:

<code><pre>
{"ev":"start","pid":66668,"exe":"...\\Analytica.exe","ver":"7.2.0.318","cmdLine":"...","automation":true,"t":"2026-08-07T11:29:47.694"}
</pre></code>

and then one record per dialog:

<code><pre>
{"ev":"dialog","seq":5,"t":"2026-08-07T11:29:48.108","thread":80872,"kind":"MsgBox",
"caption":"Overwrite?","body":"...","buttons":["Yes","No"],
"response":"No","source":"handler","handlerMs":0.939}
</pre></code>

The field to look at first is <code>source</code>, which says where the answer came from:

{| class="wikitable"
! <code>source</code> !! Meaning
|-
| <code>default</code> || The built-in default answered
|-
| <code>handler</code> || Your registered handler answered
|-
| <code>handler-error-fallback</code> || Your handler raised an error; the default was used and the run continued
|-
| <code>reentrant-default</code> || The dialog was raised while your handler was running, so the default was used
|-
| <code>offthread-default</code> || The dialog was raised off the main thread, so the handler was not consulted
|-
| <code>shown</code> || Observe mode: the dialog was actually displayed and this is what the user chose
|}

Registering a handler also writes a <code>{"ev":"handlerInstalled", ...}</code> record, so you can confirm from the log alone that your library really did get loaded and registered.

Body text is truncated at 4 KB, with <code>"bodyTruncated":true</code> added when that happens.

Because the file is appended rather than truncated, a driver can create it, start tailing it, and then launch Analytica — no polling for the file to appear, and no race at startup.

=== Reading the trace back in Analytica ===

The log is ordinary text, so a model can read its own trace:

:<code>Var lines := [[SplitText]]( [[ReadTextFile]]('run1.jsonl'), Chr(10) );</code>
:<code>[[ParseJSON]]( lines[@Line = 2] )</code>

This is handy for a QA model that runs scenarios and then asserts on which dialogs appeared.

== Putting it in a library ==

You will usually want the handler in a library rather than in the model under test, so that the model stays exactly as shipped and the automation is bolted on from outside. Load it with <code>/lib:</code>:

:<code>Analytica.exe /lib:BenchmarkDriver.ana /Automation /AutomationTrace:C:\Temp\run1.jsonl MyModel.ana</code>

Libraries named with <code>/lib:</code> load before the model, into <code>SysLib_Customizations</code>, and stay loaded as models are closed and opened. So a driver library can register its handler once at startup and keep answering dialogs across many models in one session. See the <code>/lib:</code> entry on [[Analytica Command Line]].

To have the library register itself as it loads, put the [[RegisterAutomationModalHandler]] call in a button in the library and mark that button to evaluate proactively, or call it from the driver's entry point before it opens the first model.

== Uses ==

=== A benchmark driver ===

Everything that makes benchmarks unreliable — a stray dialog stalling one run, a fixture model quietly rewritten between runs, a scenario that silently stops halfway — is what this mode is for.

* Launch each run with <code>/Automation</code> and a per-run <code>/AutomationTrace:</code> file.
* Let the built-in Save-changes default protect your fixture models. Verify it by checking that the <code>.ana</code> file's timestamp is unchanged after the run.
* Have the handler answer <code>FileOpen</code> with the scenario's input file, so the same model can be run against many datasets without editing it.
* Treat the trace as part of the result. A run whose trace contains a <code>Warning</code> or <code>CheckFailure</code> record did not really succeed, even if it finished.
* Watch <code>handlerMs</code> to confirm your instrumentation is not itself distorting the timings.

=== An AI agent, such as Claude Code ===

An agent driving Analytica has the same problem as a benchmark, only worse: it cannot see a modal dialog, and a blocked Analytica just looks like one that stopped responding.

Combine automation mode with the [[MCP server in Analytica]]:

:<code>Analytica.exe /Automation /mcp:6541 /AutomationTrace:C:\Temp\agent.jsonl MyModel.ana</code>

Now the agent's tool calls cannot deadlock behind a dialog. Some things worth doing in the handler in this setup:

* '''Make dialogs visible to the agent.''' Write each dialog to a file, or into a model variable, that you expose through an <code>{@mcpTool}</code> UDF. The agent can then ask "what did Analytica ask me while that ran?" and get a real answer instead of guessing why a call returned nothing.
* '''Answer according to what the agent is trying to do.''' A handler can read a model variable that the agent set through another tool, and use it to decide — for instance, permitting a save only while an "allow writes" flag is on.
* '''Ask the orchestrator.''' <code>[[RunConsoleProcess]]</code> with <code>block: True</code> lets the handler call out to a broker process and wait for its answer, so a genuinely ambiguous dialog can be escalated to the agent, or to a person, instead of being defaulted. Keep the timeout on the broker's side.
* '''Talk to a browser-based driver.''' If the agent is already attached through <code>/remote-debugging-port:</code>, the handler can call <code>ExecuteJavaScript</code> on a <code>CefWindow</code> object to signal what just happened. This is fire-and-forget and does not block the run.

=== Automated QA ===

* Drive a scenario with <code>/eval:</code> to press a button, and let automation answer whatever the button's script raises.
* Use observe mode first to capture what the dialogs ''should'' be, then assert against that inventory in later runs. A new record appearing in the trace, or an expected one disappearing, is exactly the kind of regression that is otherwise easy to miss.
* Have the handler answer the specific dialog the test is about with a specific button, and leave everything else on the defaults. That keeps each test's intent obvious.

== Limitations ==

* Not every dialog in Analytica is intercepted yet. A number of older dialogs, mostly in OLE linking and a few utility dialogs, are still shown and still block. If you hit one, the trace will show nothing at that point while the process sits there — comparing the trace against a run that finished is the quickest way to spot it. Please report any you find.
* The handler is only consulted on the main thread. Dialogs from worker threads take the defaults.
* A handler cannot modify the model; it runs with dirtying suppressed.
* Automation mode applies to desktop Analytica. The server (ACP) already answers dialogs through its own web mechanism, and ignores <code>/Automation</code>. The <code>/AutomationTrace:</code> log does work in either.

== See Also ==
<div style="column-count:2;-moz-column-count:2;-webkit-column-count:2">
* [[Analytica Command Line]]
* [[RegisterAutomationModalHandler]]
* [[MCP server in Analytica]]
* [[Running a model in a command line workflow]]
* [[MsgBox]]
* [[AskMsgText]]
* [[AskMsgNumber]]
* [[AskMsgChoice]]
* [[WriteTextFile]]
* [[RunConsoleProcess]]
* [[Libraries]]
</div>

Analytica Command Line

2026-08-07T18:46:50Z

Lchrisman: ER 22409: document /Automation and /AutomationTrace: (7.2), linking to the new Automation subpage

[[category:File Commands]]
[[Category:Analytica User Guide]]

{{ReleaseBar}}

The desktop Analytica.exe process is launched with a command line having the format:

Analytica.exe [options] [filename]

The brackets mean that these are optional. When ''filename'' has one or more spaces, you need to put double quotes around the filename. Or, you can put double quotes around the ''filename'' even if it doesn't have spaces. The ''filename'' will usually have the extension *.ana. When no filename is specified, Analytica launches to the intro screen. When a filename is specified, it loads that model file.

== Options ==

Each option can be prefixed either with a forward slash, <code>/</code>, or with a minus, <code>-</code>. Option values appear after a colon. There can be no spaces within the option or its value. When an option value contains a space, the option value must be quoted using double quotes.

* <code>/rlmDiag:''filename''</code>: Writes diagnostic information about licenses to ''filename''. This is very useful if you are encountering problems with a license that you believe has been activated, but is not working. After launching Analytica with this option, exit Analytica and either review the log file in a text editor, or email the diagnostic file to support@lumina.com for assistance. The diagnostic file logs the information about licenses that it finds on your computer, and hence is very useful for debugging license problems.
*: Example usage: <code>Analytica.exe /rlmDiag:"c:\Temp\rlmDiag.log"</code>

* <code>/roam:''days''</code>: Specifies the number of days to roam a floating license. Or, if ''days'' is -1, it releases a roamed license. See [[License Roaming]].
*: Example usage: <code>Analytica.exe /roam:7</code>

* <code>/lic:''licenseName''</code>: Uses the specified license name without changing which license is selected by default. The license must already be activated (i.e., the license must be in your <code>C:\ProgramData\Lumina\Licenses</code> folder).
*:Example: <code>Analytica.exe /lic:analytica_optimizer_761_2</code>

* <code>/rlm:''server''</code>: Specifies the server name (or port@serverName) that is running a Reprise License Manager with the desired centrally managed (e.g., floating) license.

* <code>/eval:''expression''</code>: (new to [[Analytica 6.0]]). Specifies an Analytica expression that is evaluated immediately after the model file that is specified on the command line finishes loading. The evaluating occurs after any proactively evaluated variables or buttons in the model. It does not dirty the model. The expression can include global variable assignments, and button identifiers. You will almost certainly want to include double quotes around the expression, and you need to escape any interior quotes by proceeding the quote with a backslash. The parameter is ignored if ''filename'' is not specified on the command line. See [[Running a model in a command line workflow]].

*: Example usage: <code>Analytica.exe /eval:"Claimant=\"JDoe\";Run_Batch;Exit" "Claim analysis.ana"</code>
*: In this example, <code>Claimant</code> is the identifier of an input variable in the model and <code>Run_batch</code> and <code>Exit</code> are names of a buttons in the model.

* <code>/comment:''text''</code>: (new to [[Analytica 6.0]]) The ''text'' is a comment that is ignored by Analytica. In one example usage, ACP3 adds a comment to each spawned processes to differentiate them in task manager.

* <code>/NoSplash</code>: (new to [[Analytica 6.0]]) Don't show the splash screen at startup (which normally displays for 3 seconds).

* <code>/mcp:«port»</code>: (new to [[Analytica 7.0]]) Enable Analytica as [[MCP server in Analytica|an MCP server]] (a protocol that allows A.I. language models to call functions in your model). [[UDF]]s that contain <code>@mcpTool</code> in their description are exposed as functions that the external A.I. client can call.

* <code>/lang:«code»</code> (new to [[Analytica 7.1]]) Specifies the User Interface language for Analytica (for menus, dialogs, error messages, built-in function descriptions, etc.). «code» is a language code such as <code>'en'</code> (for English), <code>'es'</code> (for Spanish), etc. The language is only used when the resource files exist for that language in
*:<code>«Analytica install folder»\Resources\«code»\</code>
*: The command line overrides the registry setting <code>Language</code> (if present) in the hive
*:<code>HKCU\Software\Lumina Decision Systems\Analytica</code>
*:As of [[Analytica 7.1]], non-English UI options is an experimental feature and not complete.

The remaining options exist for internal purposes and aren't generally used by end-users:
* <code>/embedding</code>: The Windows operating system uses this parameter when launching Analytica as a OLE-link server. Not used by end-users. Causes Analytica to launch quietly (without a GUI), load an indicated model, and exposes key OLE interfaces to Windows enabling an external application to complete the link to the model's data.

* <code>/solverDevLic</code>: This parameter is sometimes used by Analytica developers, but not generally by end-users. It indicates that the licenses from [https://solver.com Frontline Systems] found in the <code>Solver.lic</code> file are developer licenses rather than runtime licenses.

* <code>/forcerelease</code>: This parameter is used by Analytica quality assurance engineers during beta testing periods. It causes a beta release to behave like a final release build with regard to licensing.

*<code>/config:''filename''</code>: This is an option used by ACP3 (by Suan.exe) and not in Desktop Analytica. The specified config file contains settings that define the ACP3 server configuration.

{{Release|1=7.2|2=|3=
* <code>/remote-debugging-port:«port»</code>: (new to [[Analytica 7.2]]) Exposes the Chrome DevTools protocol (remote debugging) endpoint of Analytica's embedded Chromium (CEF) browser windows on <code>127.0.0.1:«port»</code>, so that an external tool — a benchmark driver, Claude Code, Puppeteer, or Chrome's <code>chrome://inspect</code> page — can inspect and drive HTML-based windows such as the Assista chat window, HTML dialogs, and windows created with the <code>CefWindow</code> function. The Chromium spelling <code>--remote-debugging-port=«port»</code> is also accepted. Use a «port» of 0 to have a free (ephemeral) port picked automatically. Valid values are 0 or 1024 through 65535. The endpoint listens only on 127.0.0.1, and enabling it is per-process (all CEF windows of the process share one endpoint, with one DevTools target per window).
*: After launch, the process reports the outcome in <code>%LOCALAPPDATA%\Lumina\Analytica\CEF\«pid»\RemoteDebug.json</code>, where «pid» is the process id of the launched Analytica.exe. On success this contains <code>"status":"listening"</code> and the actual port; when the requested port is already in use by another process, or CEF fails to initialize, it contains <code>"status":"failed"</code> with a reason, and a warning dialog is also shown. A tool that launches Analytica.exe with this option should read this file rather than connecting blindly, so that it cannot be fooled into talking to some other process that owns the port.
*: While remote debugging is enabled, each page in a CEF window exposes the JavaScript global <code>window.anaCefWindow</code> with fields <code>pid</code>, <code>handle</code>, <code>kind</code> and <code>title</code>, identifying which window a DevTools target belongs to. The <code>handle</code> matches the handle of the corresponding <code>CefWindow</code> object in the model.

* <code>/remote-allow-origins:«origins»</code>: (new to [[Analytica 7.2]]) A comma-separated list of origins (or <code>*</code>) allowed to connect to the remote-debugging endpoint from a web page. This is only needed when the DevTools client is itself a web page, which sends an HTTP Origin header that Chromium rejects by default. Ordinary clients (Python or Node scripts, Puppeteer, <code>chrome://inspect</code>) send no Origin header and connect without this option. The Chromium spelling <code>--remote-allow-origins=«origins»</code> is also accepted.
}}
{{Release|1=7.2|2=|3=
* <code>/lib:''filename''</code>: (new to [[Analytica 7.2]]) Loads the Analytica library in ''filename'' into the <code>SysLib_Customizations</code> system module, before the model named on the command line is opened. The library is then present no matter which model is loaded, and it stays loaded as models are closed and opened during the session. The option can be repeated to load several libraries. They load in the order given, all of them before the model.
*: Example usage: <code>Analytica.exe /lib:"W:\Analytica\Libraries\Multivariate Distributions.ana" MyModel.ana</code>
*: A relative ''filename'' is looked for first in the directory that the process was launched from, then in the directories on the <code>AddLibraryDir</code> library search path, then in the Analytica installation folder, and finally in the preferences folder. Path substitutions such as <code>%appdata%</code> and <code>%installdir%</code> are expanded.
*: Each library loaded this way is its own namespace. Since <code>SysLib_Customizations</code> is a private namespace, the library is not in namespace scope for the user's model. A model that wants to use one of these libraries must name it in its [[NamespaceImports]] attribute.
*: When the file is not found, or when it fails to load, a warning dialog names the file and Analytica continues to start up without it.
*: Uses for this include loading an [[MCP server in Analytica]] that works with whatever model is subsequently loaded, a benchmark driver, or a library that adds toolbar buttons or menu items.
}}

{{Release|1=7.2|2=|3=
* <code>/Automation</code>: (new to [[Analytica 7.2]]) Runs Analytica in ''automation mode'', in which every modal dialog that would otherwise block is answered automatically, so that an unattended run never stops waiting for a person. Each dialog is answered either by a built-in default, or by a handler function that the model or a library registers with [[RegisterAutomationModalHandler]]. This is intended for unattended and agent-driven runs, such as a benchmark driver, an automated QA run, or a session driven by an AI coding agent through the [[MCP server in Analytica]].
*: This is '''not''' a headless mode. The user interface, diagram windows, HTML dialogs, and Assista all remain fully alive and usable; only the blocking dialogs are answered for you. The splash screen is suppressed, as with <code>/nosplash</code>.
*: Some built-in defaults are deliberately conservative so that an unattended run cannot damage the model it is testing. In particular, "Save changes?" is answered '''No''', so the model file on disk is never written when the process exits. File open and save prompts fail rather than choosing a file, unless a registered handler supplies a path.
*: For the full list of defaults, how to write and register a handler, and worked examples of driving Analytica this way, see '''[[Analytica Command Line/Automation]]'''.
*: Example usage: <code>Analytica.exe /Automation /lib:BenchmarkDriver.ana MyModel.ana</code>

* <code>/AutomationTrace:''filename''</code>: (new to [[Analytica 7.2]]) Writes a log of every modal dialog to ''filename'', in JSON Lines format (one JSON object per line). Each dialog record names the kind of dialog, its caption and body text, the buttons it offered, the answer that was given, and where that answer came from. Records are appended, so a driver can pre-create the file and tail it while the run proceeds, and each record carries the process id so that concurrent runs remain distinguishable.
*: Used together with <code>/Automation</code>, this records what automation answered. Used '''without''' <code>/Automation</code>, it is an ''observe mode'': dialogs appear and behave completely normally, and the log records what the user actually chose. This is a convenient way to inventory which dialogs a scenario poses before you automate it.
*: A relative ''filename'' is resolved against the directory the process was launched from. If the file cannot be opened, Analytica starts normally and simply produces no log.
*: Example usage: <code>Analytica.exe /Automation /AutomationTrace:C:\Temp\run1.jsonl MyModel.ana</code>
}}

== Accessing the Command line from a model ==

The expression <code>[[GetProcessInfo]]('Command line')</code> returns the command line used to launch the process.

Beta Tester Page

2026-08-07T14:16:30Z

Lchrisman: /* How to start beta-testing */

[[Category: Beta testing]]
{{#svarset:betarelease|7.1}}
{{#svarset:prevrelease|7.0}}

We invite you to be a beta tester of [[Analytica {{#svarget:betarelease}}]] if you have Analytica {{#svarget:prevrelease}} installed on your computer with an active subscription. (Sorry, not [[Analytica Free Edition]] and not a legacy permanent license). A floating license subscription works.



== Why become a beta tester? ==
* Test drive the upcoming release {{#svarget:betarelease}} and start using its [[Analytica {{#svarget:betarelease}}|new features]] immediately.
* Participate in webinars on tips and guides on new features.
* Help improve the final release.
* Check that your models work in the new release. Find any issues while they can still be fixed, ensuring a seamless transition for you and your model users when this release becomes official.
== As a beta tester, we request that you ==
* Read [[What's new in Analytica {{#svarget:betarelease}}?]] for an overview of the new features.
* Sign up as a beta tester by filling in the form when you run the installer.
* Try out the new Analytica enhancements of interest to you.
* [[Beta_Tester_Page/Submitting_a_Bug_Report|Submit a bug report]] if you find an issue
* Keep up-to-date with the latest beta build. Analytica will show you an alert whenever there is a new build ready to install, about every 2 weeks. We may also send you email reminders. See [[Analytica {{#svarget:betarelease}} beta Release Notes| release notes]] for changes and bug fixes in each beta release.
* We encourage you to retain Analytica {{#svarget:prevrelease}} when you install Analytica {{#svarget:betarelease}} beta. That lets you compare their behavior if you suspect a new bug.

== How to start beta-testing ==
Download the installer for the latest beta build, release number 7.1.11.323, from:
* [https://downloads.analytica.com/ANA7.1/AnaSetup7_1_11_323.exe Analytica {{#svarget:betarelease}} installer]
* [https://downloads.analytica.com/ANA7.1/AnaSetup7_1_11_323.exe ADE {{#svarget:betarelease}} installer]
These beta builds use your existing {{#svarget:prevrelease}} subscription license that is already on your computer. A separate beta license is not required.

The installers for the current non-beta release can be downloaded directly from the [https://analytica.com/support-2/analytica-downloads/ Analytica Downloads] page.

== Improve Analytica docs ==

During the alpha and beta testing period, we are still updating these Analytica Docs to reflect new features. [[What's new in Analytica {{#svarget:betarelease}}?]] is the most complete listing of new features, and is also a work in progress. As we approach final release date, this information will be more complete.

As an Analytica user, you are invited to contribute to the docs! Since it's on a wiki (using Mediawiki software, just like Wikipedia), you can add or edit any content. If you find something unclear, incomplete, or just wrong, feel free to fix it yourself. Or add comments, asking someone else to. And you are welcome to add tips or interesting examples.

== Known issues ==

If you find an issue, please let us know about it at <code>support@lumina.com</code>. Please see [[/Submitting a Bug Report|Submitting a bug report]] for instructions on reporting bugs.

'''Note:''' We list only the most important issues here (ones that might impact your ability to use it, or which are likely to be found and reported multiple times). We maintain a comprehensive bug base in-house, which is not accessible outside of Lumina.

== FAQs: Frequently Asked Questions ==

See [[Analytica User FAQs]] for frequently asked questions not specific to {{#svarget:betarelease}} or to beta testing.

Analytica Command Line

2026-08-06T18:34:12Z

Lchrisman: ER 21888 - document the /lib: command-line option (7.2, internal options section)

What's new in Analytica 7.1?

2026-08-06T17:56:27Z

Lchrisman: /* Misc. User Interface */ -- Outline window

Analytica release 7.1 is currently in late-stage [[Beta Tester Page|Beta Testing]]. If have have a paid desktop Analytica subscription, we encourage you to try it out from the [[Beta Tester Page]].

== Highlights of Analytica 7.1 ==

'''[[#Assista|Assista]]:''' By far the most important visible improvement is in [[#Assista|Assista]], Analytica's A.I. assistant. When first released in Analytica 6.5, Assista was already quite useful for explaining Analytica features, describing and documenting models, and building models, but it was a bit unreliable in Analytica syntax and arranging influence diagrams. We think you will find that the latest Assista is so much improved, including writing Analytica Definitions and drawing influence diagrams. You may start to use chatting with Assista as the primary way you interact with Analytica.
[[File:Assista What kinds of things can you do.png|alt=Assista dialog screen answering "What kinds of things can you do?"|thumb|600x600px]]
Other improvements include faster response time, better look and feel, a trace of its thinking, the ability to save and use conversations from previous sessions, ingesting files to provide information, including txt, pdf, csv, xlsx; understanding images and diagrams; a set of skills that you can extend and customize, and more.

'''[[#Engine|Performance]]:''' Large models start up much faster using multiple processes to parse the definitions. Arrays now use a ''tensor'' representation, similar to AI frameworks like PyTorch and TensorFlow, but with Index labels that support "Intelligent Arrays". This internal improvement isn't noticeable to users -- but enables major future performance improvements.

'''[[#Spreadsheets|CSV and spreadsheet files]] :''' You can now import [[#CSV files|CSV files]] simply by dragging them into an diagram or in a command line when you start Analytica. You can create a new [[#spreadsheets |spreadsheet]] with and add or remove sheets from it.

'''[[#Spanish|Espagnol]]:''' The user interface now supports Spanish -- with other languages in the future. Assista already supports most languages, and explains features (translating docs) in your language.

== Assista ==
[[Assista]] is an AI collaborator in Analytica, greatly improved in this release:
* The '''chat window''' s now a top-level window at the same level as Analytica's main application window.
** Click the microphone button if you want to speak your request. Click it again when you're done.
** You can '''move the chat window''' to another location on the screen or even a different screen, to make best user of screen space.
** Selected objects remain visually selected in the main window as you type into Assista.
** The window is '''faster and more responsive''', with a new look and feel and clearer formatting of responses.
** You can '''highlight, drag, and copy any text''' to paste elsewhere.
** It displays a stream of "thoughts" while processing your request giving you a peek into what it is doing.
** It '''saves dialogs''', keyed to your model. You can resume a previous session for that model from a dropdown in the UI. (these are saved on your local computer, not on our server).
* On the '''backend,''' Assista has:
** A new '''processing pipeline''' enabling faster response and also enabling it work longer on harder tasks.
** An extensible set of '''competencies (skills)''', including structuring decision models, drawing influence diagrams, designing user interfaces, Analytica syntax, and more.
** You can create and expose [[Assista_-_Analytica_AI_Assistant/Custom_user_skills_for_Assista|your own custom skills]] to expand capabilities, or ask it to create new skills for you.
* Assist can now:
** '''Ingest documents''' (<code>*.txt, *.pdf, *.md, *.docx, *.xlsx, *.xlsm</code>) or URLs into the chat using a menu in the Request box, or by dragging and dropping files into the window. Assista "ingests" the files and can extract data from a doc or image, adding tables to your model, translate a spreadsheet into Analytica, or even implement a model described in the article.
** ''' "See" images''' in your model -- pictures in nodes, images in table cells, and diagram or graph screenshots.
** '''Create images and node icons''' in your model.
** '''Read from URLs''' that you explicitly point it to (or drag into the chat)
** Converse in most common '''languages.''' In Spanish, it can provide UI instructions referring to the Spanish-language UI elements.
** '''Explain its reasoning''' in previous requests and expand on ideas .
** '''Personalize tone''', style, level of verbosity and provide custom instructions. To do this, click on the icon in the top-left corner of the Assista window and select Personization.
** '''Generate reports''' as a downloadable PDF or Word document, which can contain tables, graphs or other images from your model and formatted equations.
** '''Take you through a tutorial''' of how to use Analytica.

== Multi-linguality: Spanish UI ==
Analytica now comes with a Spanish-language UI, in which its menus, dialogs, error messages and built-in function descriptions are all in Spanish. Also its installer runs with a Spanish-language UI when you are in a Spanish-language region. Spanish is the default when you are in a Spanish-language region.

You can override the default language by launching Analytica as:
* <code>Analytica.exe /lang:es</code>
*: or
* <code>Analytica.exe /lang:en</code>

You can also set the <code>Language</code> registry setting in the <code>"HKCU/Software/Lumina Decision Systems/Analytica"</code> hive to REG_SZ <code>"en"</code> on <code>"es"</code> for your default if different from your windows region setting.

Some of you may ask "what about my language?". Stay tuned (and let us know there is a demand for your language). Once our AI translation pipeline is solid, it shouldn't be too hard for us to add more.

== Window appearance ==
The appearance of the chrome around child MDI windows (aka the "non-client area") has been changed to more closely match the Windows 11 style of windows -- i.e., thin (1 pixel) borders, rounded corners at the top, white title bar, very plain (text-like) button images in the toolbar.

== CSV files ==
There are now a few additional ways to open CSV files in Analytica:
* On the command line: <code>Analytica.exe MyData.csv</code>
* Drag and drop a *.csv file onto the diagram (which behaves the same as using <code>File / Import...</code> on the *.csv file).

== Spreadsheets ==
* <code>[[SpreadsheetOpen]]("new")</code> now creates a blank spreadsheet in memory. Works with both the Excel and LibXl backends.
* Prefacing a sheet name with + in the call to [[SpreadsheetSetCell]] or [[SpreadsheetSetRange]] will add a new sheet by that name to the workbook (as it applies the specified change to that new worksheet). Works with either backend.
* You can also now remove a sheet from a workbook using: <code>[[SpreadsheetSetCell]](wb, "-OldSheet", col, row, Null)</code>. The «col» and «row» parameters are required but ignored in this case.

== Misc. User Interface ==
* The [[Outline window]] is now docked on the left.
* The Node Icon editor (on the Diagram menu) is far more flexible. You can use it to edit arbitrary node images, with support for color and transparency.
* Added keyboard shortcuts for '''Set Node Style...''' and '''Set Diagram Style...'''
* There is a new option, '''Use as default arrow style''', on the right-mouse context menu for an influence diagram arrow. This sets the global arrow style default to match the selected arrow.
* When your model uses a [[Modules_and_Libraries#Filed_Module|filed module]] or [[Modules_and_Libraries#Filed_Module|filed library]], and the source file changes, it auto-detects the change, informs you, and gives you an opportunity to update (reload) to the new version.

== Built-in functions ==
* New options for [[GetProcessInfo]]: <code>"Number of monitors"</code>, <code>"Current monitor rect"</code>, <code>"Current monitor work rect"</code>, <code>"Monitor «N» Rect"</code>, and <code>"Monitor «N» work rect"</code>.
* Several new optional parameters to [[Evaluate]].
** «throwParsingErrors»: Flag to throw a parsing error instead of returning [[Null]] when the call to [[Evaluate]] is not inside a [[Try|Try...catch]].
** «maxSeconds»: Adds a timeout if the evaluation does not complete within the specified time duration.
** «ignoreAtFirstWarning: Flag used in conjunction with «reportOutput». When set, includes the first warning text in the output reported to the «reportOutput» function, and then ignores additional warnings during the duration of the Evaluate calls (this enables [[Assista]] to see the warnings).
** «reportOutput»: Accepts a function (usually a [[Local function]]). Calls it with output that was written to the typescript window during the evaluation, including stuff written by [[ConsolePrint]].
* New optional parameter, «throwParsingErrors», to [[Evaluate]].
* [[ReadFromURL]] is a bit smarter about returning binary content (like <code>*.zip</code> files) as a [[In-memory binary data terms|Binary Data Term]].
* [[MakeJSON]] will automatically encode an image in base64 JSON, and [[ParseJSON]] will automatically decode a base64 representation into an image. Also there is a new «maxCells» parameter that can be used to prevent giagantic arrays from being encoded (resulting in immensely long text).
* <code>[[GetProcessInfo]]("UI Language")</code> returns the UI language, either <code>"en"</code> (for English) or <code>"es"</code> for Spanish.
* <code>[[QualifiedName]]( obj, nsContext )</code>: Returns the qualified identifier (as text) that uniquely identifies «obj» from the context of «nsContext».
* <code>[[Namespace]] of X</code>: A new virtual attribute that returns the namespace of «X».
* Added a syntax construct for [[Namespaces#Scoped_namespace_inclusion:_Using|Scoped namespace inclusion]] to bring a namespace into scope for only a localized expression or lexical block.
* File functions ([[ReadTextFile]], [[WriteTextFile]], [[ReadBinaryFile]], [[WriteBinaryFile]], [[ReadImageFile]] and [[WriteImageFile]]) have a new optional parameter, «extensionFilter», where you can specify which extension filters show up on a file selector dialog.

== System variables ==
* SysVar [[Graph_ColorSequence]]: Replaces [[Graph_ColorSeq]] which is now deprecated. The new sysvar contains a list of color interer with one integer (of the form <code>0x00rrggbb</code>) per color (the deprecated version used triples of numbers per color).

== Engine ==
* After loading a large model, it parses expressions in parallel, using multiple threads/cores to parse different variables. On some computers on some models, this can dramatically speed up model load time.
* Color attributes use color integers for consistently (rather than the legacy number triples for R,G,B).
* You can use a localized namespace import (for a single expression or single lexical block) with the syntax
*:<code>[[Using..Do|Using]] NS;</code>

== Model loading ==
When opening a model file, the "checking" stage (when attributes are parsed) parses different expressions on different threads, resulting in substantially faster model load times for very large models.

Note: In the event that this creates a problem with your specific model (maybe due to an as-yet-undiscovered multithreading bug), you can disable it for your model as follows:
# Temporarily turn off multithreading (Skip this step if you are able to load your model)
## New model
## Definition menu / System variables / Settings / Maximum evaluation threads
## Set to 1 (and remember the previous value)
# Open your model
# Definition menu / System variables / Settings / Disable Multithreaded Evaluations
# Press the <code>Edit Table</code> button.
# Check the checkbox for <code>Parsing</code>
# Save your model
# Definition menu / System variables / Settings / Maximum evaluation threads
#: Restore the original value from Step 1

== MCP server ==
* Added an ability to install multiple ADE-based Mcp servers that run different ADE releases. For example, you can install two MCP servers into Claude Code:
* ade-server: Runs ADE 7.1
* ade-server-70: Runs ADE 7.0
The information in the <code>«ADE install folder»\Examples\Mcp_server\README.txt</code> file explain how (with enough info for Claude code to configure this for you).

With both installed, Claude Code (or other MCP-enabled AI agents) can compare results for the same model across different releases, etc.

Side note: The Mcp server was added to ADE 7.0.

== Internals ==
This release has undergone massive internal restructuring and refactorization. Ideally (i.e., in the absence of bugs) these changes won't change functionality, but may alter some aspects of behavior, hopefully for the better.
* Internal data structures use for multi-dimensional arrays has been changed. Possible impacts:
** Likely to remove the sensitivity to the "canonical order" of indexes on evaluation speed.
** May change relative evaluation speeds of various functions and operations.
* Added system modules/namespaces: <code>SysLib_Internal</code> and <code>SysLib_Experimental</code>. Intended for Analytica-internal use.
*[[:Category:Cell format functions|Cell formatting functions]] (like [[CellSpan]], [[CellFill]], etc.) are now [[Struct]]s rather than functions. Does not impact usage, other that making it easier for code to traverse resulting data structures.

== Discontinued... ==
* Plug-in functions. (An old hook that allows you to extend Analytica with compiled functions and UI elements written it C++. We are almost certain no one is using these hooks any more.)
* The sysvar [[Graph_ColorSeq]] is now deprecated (but works for both reading and setting to preserve backward compatibility). It has been replaced by the system variable [[Graph_ColorSequence]].
* The built-in (but undocumented, unsupported) <code>ifpos</code> and <code>if0</code> functions were removed.
* The legacy (deprecated) syntax <code>Using temp:=... Do</code> for declaring locals is no longer supported. Legacy models will have such definitions automatically rewritten to use [[Local..Do]] when you load them. [[Using..Do]] now has a different meaning, which is to provide a temporary namespace import.

What's new in Analytica 7.1?

2026-08-06T17:54:02Z

Lchrisman: /* Misc. User Interface */

Analytica release 7.1 is currently in late-stage [[Beta Tester Page|Beta Testing]]. If have have a paid desktop Analytica subscription, we encourage you to try it out from the [[Beta Tester Page]].

== Highlights of Analytica 7.1 ==

'''[[#Assista|Assista]]:''' By far the most important visible improvement is in [[#Assista|Assista]], Analytica's A.I. assistant. When first released in Analytica 6.5, Assista was already quite useful for explaining Analytica features, describing and documenting models, and building models, but it was a bit unreliable in Analytica syntax and arranging influence diagrams. We think you will find that the latest Assista is so much improved, including writing Analytica Definitions and drawing influence diagrams. You may start to use chatting with Assista as the primary way you interact with Analytica.
[[File:Assista What kinds of things can you do.png|alt=Assista dialog screen answering "What kinds of things can you do?"|thumb|600x600px]]
Other improvements include faster response time, better look and feel, a trace of its thinking, the ability to save and use conversations from previous sessions, ingesting files to provide information, including txt, pdf, csv, xlsx; understanding images and diagrams; a set of skills that you can extend and customize, and more.

'''[[#Engine|Performance]]:''' Large models start up much faster using multiple processes to parse the definitions. Arrays now use a ''tensor'' representation, similar to AI frameworks like PyTorch and TensorFlow, but with Index labels that support "Intelligent Arrays". This internal improvement isn't noticeable to users -- but enables major future performance improvements.

'''[[#Spreadsheets|CSV and spreadsheet files]] :''' You can now import [[#CSV files|CSV files]] simply by dragging them into an diagram or in a command line when you start Analytica. You can create a new [[#spreadsheets |spreadsheet]] with and add or remove sheets from it.

'''[[#Spanish|Espagnol]]:''' The user interface now supports Spanish -- with other languages in the future. Assista already supports most languages, and explains features (translating docs) in your language.

== Assista ==
[[Assista]] is an AI collaborator in Analytica, greatly improved in this release:
* The '''chat window''' s now a top-level window at the same level as Analytica's main application window.
** Click the microphone button if you want to speak your request. Click it again when you're done.
** You can '''move the chat window''' to another location on the screen or even a different screen, to make best user of screen space.
** Selected objects remain visually selected in the main window as you type into Assista.
** The window is '''faster and more responsive''', with a new look and feel and clearer formatting of responses.
** You can '''highlight, drag, and copy any text''' to paste elsewhere.
** It displays a stream of "thoughts" while processing your request giving you a peek into what it is doing.
** It '''saves dialogs''', keyed to your model. You can resume a previous session for that model from a dropdown in the UI. (these are saved on your local computer, not on our server).
* On the '''backend,''' Assista has:
** A new '''processing pipeline''' enabling faster response and also enabling it work longer on harder tasks.
** An extensible set of '''competencies (skills)''', including structuring decision models, drawing influence diagrams, designing user interfaces, Analytica syntax, and more.
** You can create and expose [[Assista_-_Analytica_AI_Assistant/Custom_user_skills_for_Assista|your own custom skills]] to expand capabilities, or ask it to create new skills for you.
* Assist can now:
** '''Ingest documents''' (<code>*.txt, *.pdf, *.md, *.docx, *.xlsx, *.xlsm</code>) or URLs into the chat using a menu in the Request box, or by dragging and dropping files into the window. Assista "ingests" the files and can extract data from a doc or image, adding tables to your model, translate a spreadsheet into Analytica, or even implement a model described in the article.
** ''' "See" images''' in your model -- pictures in nodes, images in table cells, and diagram or graph screenshots.
** '''Create images and node icons''' in your model.
** '''Read from URLs''' that you explicitly point it to (or drag into the chat)
** Converse in most common '''languages.''' In Spanish, it can provide UI instructions referring to the Spanish-language UI elements.
** '''Explain its reasoning''' in previous requests and expand on ideas .
** '''Personalize tone''', style, level of verbosity and provide custom instructions. To do this, click on the icon in the top-left corner of the Assista window and select Personization.
** '''Generate reports''' as a downloadable PDF or Word document, which can contain tables, graphs or other images from your model and formatted equations.
** '''Take you through a tutorial''' of how to use Analytica.

== Multi-linguality: Spanish UI ==
Analytica now comes with a Spanish-language UI, in which its menus, dialogs, error messages and built-in function descriptions are all in Spanish. Also its installer runs with a Spanish-language UI when you are in a Spanish-language region. Spanish is the default when you are in a Spanish-language region.

You can override the default language by launching Analytica as:
* <code>Analytica.exe /lang:es</code>
*: or
* <code>Analytica.exe /lang:en</code>

You can also set the <code>Language</code> registry setting in the <code>"HKCU/Software/Lumina Decision Systems/Analytica"</code> hive to REG_SZ <code>"en"</code> on <code>"es"</code> for your default if different from your windows region setting.

Some of you may ask "what about my language?". Stay tuned (and let us know there is a demand for your language). Once our AI translation pipeline is solid, it shouldn't be too hard for us to add more.

== Window appearance ==
The appearance of the chrome around child MDI windows (aka the "non-client area") has been changed to more closely match the Windows 11 style of windows -- i.e., thin (1 pixel) borders, rounded corners at the top, white title bar, very plain (text-like) button images in the toolbar.

== CSV files ==
There are now a few additional ways to open CSV files in Analytica:
* On the command line: <code>Analytica.exe MyData.csv</code>
* Drag and drop a *.csv file onto the diagram (which behaves the same as using <code>File / Import...</code> on the *.csv file).

== Spreadsheets ==
* <code>[[SpreadsheetOpen]]("new")</code> now creates a blank spreadsheet in memory. Works with both the Excel and LibXl backends.
* Prefacing a sheet name with + in the call to [[SpreadsheetSetCell]] or [[SpreadsheetSetRange]] will add a new sheet by that name to the workbook (as it applies the specified change to that new worksheet). Works with either backend.
* You can also now remove a sheet from a workbook using: <code>[[SpreadsheetSetCell]](wb, "-OldSheet", col, row, Null)</code>. The «col» and «row» parameters are required but ignored in this case.

== Misc. User Interface ==
* The Node Icon editor (on the Diagram menu) is far more flexible. You can use it to edit arbitrary node images, with support for color and transparency.
* Added keyboard shortcuts for '''Set Node Style...''' and '''Set Diagram Style...'''
* There is a new option, '''Use as default arrow style''', on the right-mouse context menu for an influence diagram arrow. This sets the global arrow style default to match the selected arrow.
* When your model uses a [[Modules_and_Libraries#Filed_Module|filed module]] or [[Modules_and_Libraries#Filed_Module|filed library]], and the source file changes, it auto-detects the change, informs you, and gives you an opportunity to update (reload) to the new version.

== Built-in functions ==
* New options for [[GetProcessInfo]]: <code>"Number of monitors"</code>, <code>"Current monitor rect"</code>, <code>"Current monitor work rect"</code>, <code>"Monitor «N» Rect"</code>, and <code>"Monitor «N» work rect"</code>.
* Several new optional parameters to [[Evaluate]].
** «throwParsingErrors»: Flag to throw a parsing error instead of returning [[Null]] when the call to [[Evaluate]] is not inside a [[Try|Try...catch]].
** «maxSeconds»: Adds a timeout if the evaluation does not complete within the specified time duration.
** «ignoreAtFirstWarning: Flag used in conjunction with «reportOutput». When set, includes the first warning text in the output reported to the «reportOutput» function, and then ignores additional warnings during the duration of the Evaluate calls (this enables [[Assista]] to see the warnings).
** «reportOutput»: Accepts a function (usually a [[Local function]]). Calls it with output that was written to the typescript window during the evaluation, including stuff written by [[ConsolePrint]].
* New optional parameter, «throwParsingErrors», to [[Evaluate]].
* [[ReadFromURL]] is a bit smarter about returning binary content (like <code>*.zip</code> files) as a [[In-memory binary data terms|Binary Data Term]].
* [[MakeJSON]] will automatically encode an image in base64 JSON, and [[ParseJSON]] will automatically decode a base64 representation into an image. Also there is a new «maxCells» parameter that can be used to prevent giagantic arrays from being encoded (resulting in immensely long text).
* <code>[[GetProcessInfo]]("UI Language")</code> returns the UI language, either <code>"en"</code> (for English) or <code>"es"</code> for Spanish.
* <code>[[QualifiedName]]( obj, nsContext )</code>: Returns the qualified identifier (as text) that uniquely identifies «obj» from the context of «nsContext».
* <code>[[Namespace]] of X</code>: A new virtual attribute that returns the namespace of «X».
* Added a syntax construct for [[Namespaces#Scoped_namespace_inclusion:_Using|Scoped namespace inclusion]] to bring a namespace into scope for only a localized expression or lexical block.
* File functions ([[ReadTextFile]], [[WriteTextFile]], [[ReadBinaryFile]], [[WriteBinaryFile]], [[ReadImageFile]] and [[WriteImageFile]]) have a new optional parameter, «extensionFilter», where you can specify which extension filters show up on a file selector dialog.

== System variables ==
* SysVar [[Graph_ColorSequence]]: Replaces [[Graph_ColorSeq]] which is now deprecated. The new sysvar contains a list of color interer with one integer (of the form <code>0x00rrggbb</code>) per color (the deprecated version used triples of numbers per color).

== Engine ==
* After loading a large model, it parses expressions in parallel, using multiple threads/cores to parse different variables. On some computers on some models, this can dramatically speed up model load time.
* Color attributes use color integers for consistently (rather than the legacy number triples for R,G,B).
* You can use a localized namespace import (for a single expression or single lexical block) with the syntax
*:<code>[[Using..Do|Using]] NS;</code>

== Model loading ==
When opening a model file, the "checking" stage (when attributes are parsed) parses different expressions on different threads, resulting in substantially faster model load times for very large models.

Note: In the event that this creates a problem with your specific model (maybe due to an as-yet-undiscovered multithreading bug), you can disable it for your model as follows:
# Temporarily turn off multithreading (Skip this step if you are able to load your model)
## New model
## Definition menu / System variables / Settings / Maximum evaluation threads
## Set to 1 (and remember the previous value)
# Open your model
# Definition menu / System variables / Settings / Disable Multithreaded Evaluations
# Press the <code>Edit Table</code> button.
# Check the checkbox for <code>Parsing</code>
# Save your model
# Definition menu / System variables / Settings / Maximum evaluation threads
#: Restore the original value from Step 1

== MCP server ==
* Added an ability to install multiple ADE-based Mcp servers that run different ADE releases. For example, you can install two MCP servers into Claude Code:
* ade-server: Runs ADE 7.1
* ade-server-70: Runs ADE 7.0
The information in the <code>«ADE install folder»\Examples\Mcp_server\README.txt</code> file explain how (with enough info for Claude code to configure this for you).

With both installed, Claude Code (or other MCP-enabled AI agents) can compare results for the same model across different releases, etc.

Side note: The Mcp server was added to ADE 7.0.

== Internals ==
This release has undergone massive internal restructuring and refactorization. Ideally (i.e., in the absence of bugs) these changes won't change functionality, but may alter some aspects of behavior, hopefully for the better.
* Internal data structures use for multi-dimensional arrays has been changed. Possible impacts:
** Likely to remove the sensitivity to the "canonical order" of indexes on evaluation speed.
** May change relative evaluation speeds of various functions and operations.
* Added system modules/namespaces: <code>SysLib_Internal</code> and <code>SysLib_Experimental</code>. Intended for Analytica-internal use.
*[[:Category:Cell format functions|Cell formatting functions]] (like [[CellSpan]], [[CellFill]], etc.) are now [[Struct]]s rather than functions. Does not impact usage, other that making it easier for code to traverse resulting data structures.

== Discontinued... ==
* Plug-in functions. (An old hook that allows you to extend Analytica with compiled functions and UI elements written it C++. We are almost certain no one is using these hooks any more.)
* The sysvar [[Graph_ColorSeq]] is now deprecated (but works for both reading and setting to preserve backward compatibility). It has been replaced by the system variable [[Graph_ColorSequence]].
* The built-in (but undocumented, unsupported) <code>ifpos</code> and <code>if0</code> functions were removed.
* The legacy (deprecated) syntax <code>Using temp:=... Do</code> for declaring locals is no longer supported. Legacy models will have such definitions automatically rewritten to use [[Local..Do]] when you load them. [[Using..Do]] now has a different meaning, which is to provide a temporary namespace import.

What's new in Analytica 7.1?

2026-08-06T17:53:33Z

Lchrisman: /* Misc. User Interface */

Analytica release 7.1 is currently in late-stage [[Beta Tester Page|Beta Testing]]. If have have a paid desktop Analytica subscription, we encourage you to try it out from the [[Beta Tester Page]].

== Highlights of Analytica 7.1 ==

'''[[#Assista|Assista]]:''' By far the most important visible improvement is in [[#Assista|Assista]], Analytica's A.I. assistant. When first released in Analytica 6.5, Assista was already quite useful for explaining Analytica features, describing and documenting models, and building models, but it was a bit unreliable in Analytica syntax and arranging influence diagrams. We think you will find that the latest Assista is so much improved, including writing Analytica Definitions and drawing influence diagrams. You may start to use chatting with Assista as the primary way you interact with Analytica.
[[File:Assista What kinds of things can you do.png|alt=Assista dialog screen answering "What kinds of things can you do?"|thumb|600x600px]]
Other improvements include faster response time, better look and feel, a trace of its thinking, the ability to save and use conversations from previous sessions, ingesting files to provide information, including txt, pdf, csv, xlsx; understanding images and diagrams; a set of skills that you can extend and customize, and more.

'''[[#Engine|Performance]]:''' Large models start up much faster using multiple processes to parse the definitions. Arrays now use a ''tensor'' representation, similar to AI frameworks like PyTorch and TensorFlow, but with Index labels that support "Intelligent Arrays". This internal improvement isn't noticeable to users -- but enables major future performance improvements.

'''[[#Spreadsheets|CSV and spreadsheet files]] :''' You can now import [[#CSV files|CSV files]] simply by dragging them into an diagram or in a command line when you start Analytica. You can create a new [[#spreadsheets |spreadsheet]] with and add or remove sheets from it.

'''[[#Spanish|Espagnol]]:''' The user interface now supports Spanish -- with other languages in the future. Assista already supports most languages, and explains features (translating docs) in your language.

== Assista ==
[[Assista]] is an AI collaborator in Analytica, greatly improved in this release:
* The '''chat window''' s now a top-level window at the same level as Analytica's main application window.
** Click the microphone button if you want to speak your request. Click it again when you're done.
** You can '''move the chat window''' to another location on the screen or even a different screen, to make best user of screen space.
** Selected objects remain visually selected in the main window as you type into Assista.
** The window is '''faster and more responsive''', with a new look and feel and clearer formatting of responses.
** You can '''highlight, drag, and copy any text''' to paste elsewhere.
** It displays a stream of "thoughts" while processing your request giving you a peek into what it is doing.
** It '''saves dialogs''', keyed to your model. You can resume a previous session for that model from a dropdown in the UI. (these are saved on your local computer, not on our server).
* On the '''backend,''' Assista has:
** A new '''processing pipeline''' enabling faster response and also enabling it work longer on harder tasks.
** An extensible set of '''competencies (skills)''', including structuring decision models, drawing influence diagrams, designing user interfaces, Analytica syntax, and more.
** You can create and expose [[Assista_-_Analytica_AI_Assistant/Custom_user_skills_for_Assista|your own custom skills]] to expand capabilities, or ask it to create new skills for you.
* Assist can now:
** '''Ingest documents''' (<code>*.txt, *.pdf, *.md, *.docx, *.xlsx, *.xlsm</code>) or URLs into the chat using a menu in the Request box, or by dragging and dropping files into the window. Assista "ingests" the files and can extract data from a doc or image, adding tables to your model, translate a spreadsheet into Analytica, or even implement a model described in the article.
** ''' "See" images''' in your model -- pictures in nodes, images in table cells, and diagram or graph screenshots.
** '''Create images and node icons''' in your model.
** '''Read from URLs''' that you explicitly point it to (or drag into the chat)
** Converse in most common '''languages.''' In Spanish, it can provide UI instructions referring to the Spanish-language UI elements.
** '''Explain its reasoning''' in previous requests and expand on ideas .
** '''Personalize tone''', style, level of verbosity and provide custom instructions. To do this, click on the icon in the top-left corner of the Assista window and select Personization.
** '''Generate reports''' as a downloadable PDF or Word document, which can contain tables, graphs or other images from your model and formatted equations.
** '''Take you through a tutorial''' of how to use Analytica.

== Multi-linguality: Spanish UI ==
Analytica now comes with a Spanish-language UI, in which its menus, dialogs, error messages and built-in function descriptions are all in Spanish. Also its installer runs with a Spanish-language UI when you are in a Spanish-language region. Spanish is the default when you are in a Spanish-language region.

You can override the default language by launching Analytica as:
* <code>Analytica.exe /lang:es</code>
*: or
* <code>Analytica.exe /lang:en</code>

You can also set the <code>Language</code> registry setting in the <code>"HKCU/Software/Lumina Decision Systems/Analytica"</code> hive to REG_SZ <code>"en"</code> on <code>"es"</code> for your default if different from your windows region setting.

Some of you may ask "what about my language?". Stay tuned (and let us know there is a demand for your language). Once our AI translation pipeline is solid, it shouldn't be too hard for us to add more.

== Window appearance ==
The appearance of the chrome around child MDI windows (aka the "non-client area") has been changed to more closely match the Windows 11 style of windows -- i.e., thin (1 pixel) borders, rounded corners at the top, white title bar, very plain (text-like) button images in the toolbar.

== CSV files ==
There are now a few additional ways to open CSV files in Analytica:
* On the command line: <code>Analytica.exe MyData.csv</code>
* Drag and drop a *.csv file onto the diagram (which behaves the same as using <code>File / Import...</code> on the *.csv file).

== Spreadsheets ==
* <code>[[SpreadsheetOpen]]("new")</code> now creates a blank spreadsheet in memory. Works with both the Excel and LibXl backends.
* Prefacing a sheet name with + in the call to [[SpreadsheetSetCell]] or [[SpreadsheetSetRange]] will add a new sheet by that name to the workbook (as it applies the specified change to that new worksheet). Works with either backend.
* You can also now remove a sheet from a workbook using: <code>[[SpreadsheetSetCell]](wb, "-OldSheet", col, row, Null)</code>. The «col» and «row» parameters are required but ignored in this case.

== Misc. User Interface ==
* The Node Icon editor (on the Diagram menu) is far more flexible. You can use it to edit arbitrary node images, with support for color and transparency.
* Added keyboard shortcuts for '''Set Node Style...''' and '''Set Diagram Style...'''
* There is a new option, '''Use as default arrow style''', on the right-mouse context menu for an influence diagram arrow. This sets the global arrow style default to match the selected arrow.
* When your model uses a [[Modules_and_Libraries#Filed_Module|filed module]] or [[filed library|Modules_and_Libraries#Filed_Module]], and the source file changes, it auto-detects the change, informs you, and gives you an opportunity to update (reload) to the new version.

== Built-in functions ==
* New options for [[GetProcessInfo]]: <code>"Number of monitors"</code>, <code>"Current monitor rect"</code>, <code>"Current monitor work rect"</code>, <code>"Monitor «N» Rect"</code>, and <code>"Monitor «N» work rect"</code>.
* Several new optional parameters to [[Evaluate]].
** «throwParsingErrors»: Flag to throw a parsing error instead of returning [[Null]] when the call to [[Evaluate]] is not inside a [[Try|Try...catch]].
** «maxSeconds»: Adds a timeout if the evaluation does not complete within the specified time duration.
** «ignoreAtFirstWarning: Flag used in conjunction with «reportOutput». When set, includes the first warning text in the output reported to the «reportOutput» function, and then ignores additional warnings during the duration of the Evaluate calls (this enables [[Assista]] to see the warnings).
** «reportOutput»: Accepts a function (usually a [[Local function]]). Calls it with output that was written to the typescript window during the evaluation, including stuff written by [[ConsolePrint]].
* New optional parameter, «throwParsingErrors», to [[Evaluate]].
* [[ReadFromURL]] is a bit smarter about returning binary content (like <code>*.zip</code> files) as a [[In-memory binary data terms|Binary Data Term]].
* [[MakeJSON]] will automatically encode an image in base64 JSON, and [[ParseJSON]] will automatically decode a base64 representation into an image. Also there is a new «maxCells» parameter that can be used to prevent giagantic arrays from being encoded (resulting in immensely long text).
* <code>[[GetProcessInfo]]("UI Language")</code> returns the UI language, either <code>"en"</code> (for English) or <code>"es"</code> for Spanish.
* <code>[[QualifiedName]]( obj, nsContext )</code>: Returns the qualified identifier (as text) that uniquely identifies «obj» from the context of «nsContext».
* <code>[[Namespace]] of X</code>: A new virtual attribute that returns the namespace of «X».
* Added a syntax construct for [[Namespaces#Scoped_namespace_inclusion:_Using|Scoped namespace inclusion]] to bring a namespace into scope for only a localized expression or lexical block.
* File functions ([[ReadTextFile]], [[WriteTextFile]], [[ReadBinaryFile]], [[WriteBinaryFile]], [[ReadImageFile]] and [[WriteImageFile]]) have a new optional parameter, «extensionFilter», where you can specify which extension filters show up on a file selector dialog.

== System variables ==
* SysVar [[Graph_ColorSequence]]: Replaces [[Graph_ColorSeq]] which is now deprecated. The new sysvar contains a list of color interer with one integer (of the form <code>0x00rrggbb</code>) per color (the deprecated version used triples of numbers per color).

== Engine ==
* After loading a large model, it parses expressions in parallel, using multiple threads/cores to parse different variables. On some computers on some models, this can dramatically speed up model load time.
* Color attributes use color integers for consistently (rather than the legacy number triples for R,G,B).
* You can use a localized namespace import (for a single expression or single lexical block) with the syntax
*:<code>[[Using..Do|Using]] NS;</code>

== Model loading ==
When opening a model file, the "checking" stage (when attributes are parsed) parses different expressions on different threads, resulting in substantially faster model load times for very large models.

Note: In the event that this creates a problem with your specific model (maybe due to an as-yet-undiscovered multithreading bug), you can disable it for your model as follows:
# Temporarily turn off multithreading (Skip this step if you are able to load your model)
## New model
## Definition menu / System variables / Settings / Maximum evaluation threads
## Set to 1 (and remember the previous value)
# Open your model
# Definition menu / System variables / Settings / Disable Multithreaded Evaluations
# Press the <code>Edit Table</code> button.
# Check the checkbox for <code>Parsing</code>
# Save your model
# Definition menu / System variables / Settings / Maximum evaluation threads
#: Restore the original value from Step 1

== MCP server ==
* Added an ability to install multiple ADE-based Mcp servers that run different ADE releases. For example, you can install two MCP servers into Claude Code:
* ade-server: Runs ADE 7.1
* ade-server-70: Runs ADE 7.0
The information in the <code>«ADE install folder»\Examples\Mcp_server\README.txt</code> file explain how (with enough info for Claude code to configure this for you).

With both installed, Claude Code (or other MCP-enabled AI agents) can compare results for the same model across different releases, etc.

Side note: The Mcp server was added to ADE 7.0.

== Internals ==
This release has undergone massive internal restructuring and refactorization. Ideally (i.e., in the absence of bugs) these changes won't change functionality, but may alter some aspects of behavior, hopefully for the better.
* Internal data structures use for multi-dimensional arrays has been changed. Possible impacts:
** Likely to remove the sensitivity to the "canonical order" of indexes on evaluation speed.
** May change relative evaluation speeds of various functions and operations.
* Added system modules/namespaces: <code>SysLib_Internal</code> and <code>SysLib_Experimental</code>. Intended for Analytica-internal use.
*[[:Category:Cell format functions|Cell formatting functions]] (like [[CellSpan]], [[CellFill]], etc.) are now [[Struct]]s rather than functions. Does not impact usage, other that making it easier for code to traverse resulting data structures.

== Discontinued... ==
* Plug-in functions. (An old hook that allows you to extend Analytica with compiled functions and UI elements written it C++. We are almost certain no one is using these hooks any more.)
* The sysvar [[Graph_ColorSeq]] is now deprecated (but works for both reading and setting to preserve backward compatibility). It has been replaced by the system variable [[Graph_ColorSequence]].
* The built-in (but undocumented, unsupported) <code>ifpos</code> and <code>if0</code> functions were removed.
* The legacy (deprecated) syntax <code>Using temp:=... Do</code> for declaring locals is no longer supported. Legacy models will have such definitions automatically rewritten to use [[Local..Do]] when you load them. [[Using..Do]] now has a different meaning, which is to provide a temporary namespace import.

What's new in Analytica 7.1?

2026-08-06T17:52:44Z

Lchrisman: /* Misc. User Interface */

Analytica release 7.1 is currently in late-stage [[Beta Tester Page|Beta Testing]]. If have have a paid desktop Analytica subscription, we encourage you to try it out from the [[Beta Tester Page]].

== Highlights of Analytica 7.1 ==

'''[[#Assista|Assista]]:''' By far the most important visible improvement is in [[#Assista|Assista]], Analytica's A.I. assistant. When first released in Analytica 6.5, Assista was already quite useful for explaining Analytica features, describing and documenting models, and building models, but it was a bit unreliable in Analytica syntax and arranging influence diagrams. We think you will find that the latest Assista is so much improved, including writing Analytica Definitions and drawing influence diagrams. You may start to use chatting with Assista as the primary way you interact with Analytica.
[[File:Assista What kinds of things can you do.png|alt=Assista dialog screen answering "What kinds of things can you do?"|thumb|600x600px]]
Other improvements include faster response time, better look and feel, a trace of its thinking, the ability to save and use conversations from previous sessions, ingesting files to provide information, including txt, pdf, csv, xlsx; understanding images and diagrams; a set of skills that you can extend and customize, and more.

'''[[#Engine|Performance]]:''' Large models start up much faster using multiple processes to parse the definitions. Arrays now use a ''tensor'' representation, similar to AI frameworks like PyTorch and TensorFlow, but with Index labels that support "Intelligent Arrays". This internal improvement isn't noticeable to users -- but enables major future performance improvements.

'''[[#Spreadsheets|CSV and spreadsheet files]] :''' You can now import [[#CSV files|CSV files]] simply by dragging them into an diagram or in a command line when you start Analytica. You can create a new [[#spreadsheets |spreadsheet]] with and add or remove sheets from it.

'''[[#Spanish|Espagnol]]:''' The user interface now supports Spanish -- with other languages in the future. Assista already supports most languages, and explains features (translating docs) in your language.

== Assista ==
[[Assista]] is an AI collaborator in Analytica, greatly improved in this release:
* The '''chat window''' s now a top-level window at the same level as Analytica's main application window.
** Click the microphone button if you want to speak your request. Click it again when you're done.
** You can '''move the chat window''' to another location on the screen or even a different screen, to make best user of screen space.
** Selected objects remain visually selected in the main window as you type into Assista.
** The window is '''faster and more responsive''', with a new look and feel and clearer formatting of responses.
** You can '''highlight, drag, and copy any text''' to paste elsewhere.
** It displays a stream of "thoughts" while processing your request giving you a peek into what it is doing.
** It '''saves dialogs''', keyed to your model. You can resume a previous session for that model from a dropdown in the UI. (these are saved on your local computer, not on our server).
* On the '''backend,''' Assista has:
** A new '''processing pipeline''' enabling faster response and also enabling it work longer on harder tasks.
** An extensible set of '''competencies (skills)''', including structuring decision models, drawing influence diagrams, designing user interfaces, Analytica syntax, and more.
** You can create and expose [[Assista_-_Analytica_AI_Assistant/Custom_user_skills_for_Assista|your own custom skills]] to expand capabilities, or ask it to create new skills for you.
* Assist can now:
** '''Ingest documents''' (<code>*.txt, *.pdf, *.md, *.docx, *.xlsx, *.xlsm</code>) or URLs into the chat using a menu in the Request box, or by dragging and dropping files into the window. Assista "ingests" the files and can extract data from a doc or image, adding tables to your model, translate a spreadsheet into Analytica, or even implement a model described in the article.
** ''' "See" images''' in your model -- pictures in nodes, images in table cells, and diagram or graph screenshots.
** '''Create images and node icons''' in your model.
** '''Read from URLs''' that you explicitly point it to (or drag into the chat)
** Converse in most common '''languages.''' In Spanish, it can provide UI instructions referring to the Spanish-language UI elements.
** '''Explain its reasoning''' in previous requests and expand on ideas .
** '''Personalize tone''', style, level of verbosity and provide custom instructions. To do this, click on the icon in the top-left corner of the Assista window and select Personization.
** '''Generate reports''' as a downloadable PDF or Word document, which can contain tables, graphs or other images from your model and formatted equations.
** '''Take you through a tutorial''' of how to use Analytica.

== Multi-linguality: Spanish UI ==
Analytica now comes with a Spanish-language UI, in which its menus, dialogs, error messages and built-in function descriptions are all in Spanish. Also its installer runs with a Spanish-language UI when you are in a Spanish-language region. Spanish is the default when you are in a Spanish-language region.

You can override the default language by launching Analytica as:
* <code>Analytica.exe /lang:es</code>
*: or
* <code>Analytica.exe /lang:en</code>

You can also set the <code>Language</code> registry setting in the <code>"HKCU/Software/Lumina Decision Systems/Analytica"</code> hive to REG_SZ <code>"en"</code> on <code>"es"</code> for your default if different from your windows region setting.

Some of you may ask "what about my language?". Stay tuned (and let us know there is a demand for your language). Once our AI translation pipeline is solid, it shouldn't be too hard for us to add more.

== Window appearance ==
The appearance of the chrome around child MDI windows (aka the "non-client area") has been changed to more closely match the Windows 11 style of windows -- i.e., thin (1 pixel) borders, rounded corners at the top, white title bar, very plain (text-like) button images in the toolbar.

== CSV files ==
There are now a few additional ways to open CSV files in Analytica:
* On the command line: <code>Analytica.exe MyData.csv</code>
* Drag and drop a *.csv file onto the diagram (which behaves the same as using <code>File / Import...</code> on the *.csv file).

== Spreadsheets ==
* <code>[[SpreadsheetOpen]]("new")</code> now creates a blank spreadsheet in memory. Works with both the Excel and LibXl backends.
* Prefacing a sheet name with + in the call to [[SpreadsheetSetCell]] or [[SpreadsheetSetRange]] will add a new sheet by that name to the workbook (as it applies the specified change to that new worksheet). Works with either backend.
* You can also now remove a sheet from a workbook using: <code>[[SpreadsheetSetCell]](wb, "-OldSheet", col, row, Null)</code>. The «col» and «row» parameters are required but ignored in this case.

== Misc. User Interface ==
* The Node Icon editor (on the Diagram menu) is far more flexible. You can use it to edit arbitrary node images, with support for color and transparency.
* Added keyboard shortcuts for '''Set Node Style...''' and '''Set Diagram Style...'''
* There is a new option, '''Use as default arrow style''', on the right-mouse context menu for an influence diagram arrow. This sets the global arrow style default to match the selected arrow.
* When your model uses a filed module or filed library, and the source file changes, it auto-detects the change, informs you, and gives you an opportunity to update (reload) to the new version.

== Built-in functions ==
* New options for [[GetProcessInfo]]: <code>"Number of monitors"</code>, <code>"Current monitor rect"</code>, <code>"Current monitor work rect"</code>, <code>"Monitor «N» Rect"</code>, and <code>"Monitor «N» work rect"</code>.
* Several new optional parameters to [[Evaluate]].
** «throwParsingErrors»: Flag to throw a parsing error instead of returning [[Null]] when the call to [[Evaluate]] is not inside a [[Try|Try...catch]].
** «maxSeconds»: Adds a timeout if the evaluation does not complete within the specified time duration.
** «ignoreAtFirstWarning: Flag used in conjunction with «reportOutput». When set, includes the first warning text in the output reported to the «reportOutput» function, and then ignores additional warnings during the duration of the Evaluate calls (this enables [[Assista]] to see the warnings).
** «reportOutput»: Accepts a function (usually a [[Local function]]). Calls it with output that was written to the typescript window during the evaluation, including stuff written by [[ConsolePrint]].
* New optional parameter, «throwParsingErrors», to [[Evaluate]].
* [[ReadFromURL]] is a bit smarter about returning binary content (like <code>*.zip</code> files) as a [[In-memory binary data terms|Binary Data Term]].
* [[MakeJSON]] will automatically encode an image in base64 JSON, and [[ParseJSON]] will automatically decode a base64 representation into an image. Also there is a new «maxCells» parameter that can be used to prevent giagantic arrays from being encoded (resulting in immensely long text).
* <code>[[GetProcessInfo]]("UI Language")</code> returns the UI language, either <code>"en"</code> (for English) or <code>"es"</code> for Spanish.
* <code>[[QualifiedName]]( obj, nsContext )</code>: Returns the qualified identifier (as text) that uniquely identifies «obj» from the context of «nsContext».
* <code>[[Namespace]] of X</code>: A new virtual attribute that returns the namespace of «X».
* Added a syntax construct for [[Namespaces#Scoped_namespace_inclusion:_Using|Scoped namespace inclusion]] to bring a namespace into scope for only a localized expression or lexical block.
* File functions ([[ReadTextFile]], [[WriteTextFile]], [[ReadBinaryFile]], [[WriteBinaryFile]], [[ReadImageFile]] and [[WriteImageFile]]) have a new optional parameter, «extensionFilter», where you can specify which extension filters show up on a file selector dialog.

== System variables ==
* SysVar [[Graph_ColorSequence]]: Replaces [[Graph_ColorSeq]] which is now deprecated. The new sysvar contains a list of color interer with one integer (of the form <code>0x00rrggbb</code>) per color (the deprecated version used triples of numbers per color).

== Engine ==
* After loading a large model, it parses expressions in parallel, using multiple threads/cores to parse different variables. On some computers on some models, this can dramatically speed up model load time.
* Color attributes use color integers for consistently (rather than the legacy number triples for R,G,B).
* You can use a localized namespace import (for a single expression or single lexical block) with the syntax
*:<code>[[Using..Do|Using]] NS;</code>

== Model loading ==
When opening a model file, the "checking" stage (when attributes are parsed) parses different expressions on different threads, resulting in substantially faster model load times for very large models.

Note: In the event that this creates a problem with your specific model (maybe due to an as-yet-undiscovered multithreading bug), you can disable it for your model as follows:
# Temporarily turn off multithreading (Skip this step if you are able to load your model)
## New model
## Definition menu / System variables / Settings / Maximum evaluation threads
## Set to 1 (and remember the previous value)
# Open your model
# Definition menu / System variables / Settings / Disable Multithreaded Evaluations
# Press the <code>Edit Table</code> button.
# Check the checkbox for <code>Parsing</code>
# Save your model
# Definition menu / System variables / Settings / Maximum evaluation threads
#: Restore the original value from Step 1

== MCP server ==
* Added an ability to install multiple ADE-based Mcp servers that run different ADE releases. For example, you can install two MCP servers into Claude Code:
* ade-server: Runs ADE 7.1
* ade-server-70: Runs ADE 7.0
The information in the <code>«ADE install folder»\Examples\Mcp_server\README.txt</code> file explain how (with enough info for Claude code to configure this for you).

With both installed, Claude Code (or other MCP-enabled AI agents) can compare results for the same model across different releases, etc.

Side note: The Mcp server was added to ADE 7.0.

== Internals ==
This release has undergone massive internal restructuring and refactorization. Ideally (i.e., in the absence of bugs) these changes won't change functionality, but may alter some aspects of behavior, hopefully for the better.
* Internal data structures use for multi-dimensional arrays has been changed. Possible impacts:
** Likely to remove the sensitivity to the "canonical order" of indexes on evaluation speed.
** May change relative evaluation speeds of various functions and operations.
* Added system modules/namespaces: <code>SysLib_Internal</code> and <code>SysLib_Experimental</code>. Intended for Analytica-internal use.
*[[:Category:Cell format functions|Cell formatting functions]] (like [[CellSpan]], [[CellFill]], etc.) are now [[Struct]]s rather than functions. Does not impact usage, other that making it easier for code to traverse resulting data structures.

== Discontinued... ==
* Plug-in functions. (An old hook that allows you to extend Analytica with compiled functions and UI elements written it C++. We are almost certain no one is using these hooks any more.)
* The sysvar [[Graph_ColorSeq]] is now deprecated (but works for both reading and setting to preserve backward compatibility). It has been replaced by the system variable [[Graph_ColorSequence]].
* The built-in (but undocumented, unsupported) <code>ifpos</code> and <code>if0</code> functions were removed.
* The legacy (deprecated) syntax <code>Using temp:=... Do</code> for declaring locals is no longer supported. Legacy models will have such definitions automatically rewritten to use [[Local..Do]] when you load them. [[Using..Do]] now has a different meaning, which is to provide a temporary namespace import.

What's new in Analytica 7.1?

2026-08-06T17:48:38Z

Lchrisman: /* Assista */

Analytica release 7.1 is currently in late-stage [[Beta Tester Page|Beta Testing]]. If have have a paid desktop Analytica subscription, we encourage you to try it out from the [[Beta Tester Page]].

== Highlights of Analytica 7.1 ==

'''[[#Assista|Assista]]:''' By far the most important visible improvement is in [[#Assista|Assista]], Analytica's A.I. assistant. When first released in Analytica 6.5, Assista was already quite useful for explaining Analytica features, describing and documenting models, and building models, but it was a bit unreliable in Analytica syntax and arranging influence diagrams. We think you will find that the latest Assista is so much improved, including writing Analytica Definitions and drawing influence diagrams. You may start to use chatting with Assista as the primary way you interact with Analytica.
[[File:Assista What kinds of things can you do.png|alt=Assista dialog screen answering "What kinds of things can you do?"|thumb|600x600px]]
Other improvements include faster response time, better look and feel, a trace of its thinking, the ability to save and use conversations from previous sessions, ingesting files to provide information, including txt, pdf, csv, xlsx; understanding images and diagrams; a set of skills that you can extend and customize, and more.

'''[[#Engine|Performance]]:''' Large models start up much faster using multiple processes to parse the definitions. Arrays now use a ''tensor'' representation, similar to AI frameworks like PyTorch and TensorFlow, but with Index labels that support "Intelligent Arrays". This internal improvement isn't noticeable to users -- but enables major future performance improvements.

'''[[#Spreadsheets|CSV and spreadsheet files]] :''' You can now import [[#CSV files|CSV files]] simply by dragging them into an diagram or in a command line when you start Analytica. You can create a new [[#spreadsheets |spreadsheet]] with and add or remove sheets from it.

'''[[#Spanish|Espagnol]]:''' The user interface now supports Spanish -- with other languages in the future. Assista already supports most languages, and explains features (translating docs) in your language.

== Assista ==
[[Assista]] is an AI collaborator in Analytica, greatly improved in this release:
* The '''chat window''' s now a top-level window at the same level as Analytica's main application window.
** Click the microphone button if you want to speak your request. Click it again when you're done.
** You can '''move the chat window''' to another location on the screen or even a different screen, to make best user of screen space.
** Selected objects remain visually selected in the main window as you type into Assista.
** The window is '''faster and more responsive''', with a new look and feel and clearer formatting of responses.
** You can '''highlight, drag, and copy any text''' to paste elsewhere.
** It displays a stream of "thoughts" while processing your request giving you a peek into what it is doing.
** It '''saves dialogs''', keyed to your model. You can resume a previous session for that model from a dropdown in the UI. (these are saved on your local computer, not on our server).
* On the '''backend,''' Assista has:
** A new '''processing pipeline''' enabling faster response and also enabling it work longer on harder tasks.
** An extensible set of '''competencies (skills)''', including structuring decision models, drawing influence diagrams, designing user interfaces, Analytica syntax, and more.
** You can create and expose [[Assista_-_Analytica_AI_Assistant/Custom_user_skills_for_Assista|your own custom skills]] to expand capabilities, or ask it to create new skills for you.
* Assist can now:
** '''Ingest documents''' (<code>*.txt, *.pdf, *.md, *.docx, *.xlsx, *.xlsm</code>) or URLs into the chat using a menu in the Request box, or by dragging and dropping files into the window. Assista "ingests" the files and can extract data from a doc or image, adding tables to your model, translate a spreadsheet into Analytica, or even implement a model described in the article.
** ''' "See" images''' in your model -- pictures in nodes, images in table cells, and diagram or graph screenshots.
** '''Create images and node icons''' in your model.
** '''Read from URLs''' that you explicitly point it to (or drag into the chat)
** Converse in most common '''languages.''' In Spanish, it can provide UI instructions referring to the Spanish-language UI elements.
** '''Explain its reasoning''' in previous requests and expand on ideas .
** '''Personalize tone''', style, level of verbosity and provide custom instructions. To do this, click on the icon in the top-left corner of the Assista window and select Personization.
** '''Generate reports''' as a downloadable PDF or Word document, which can contain tables, graphs or other images from your model and formatted equations.
** '''Take you through a tutorial''' of how to use Analytica.

== Multi-linguality: Spanish UI ==
Analytica now comes with a Spanish-language UI, in which its menus, dialogs, error messages and built-in function descriptions are all in Spanish. Also its installer runs with a Spanish-language UI when you are in a Spanish-language region. Spanish is the default when you are in a Spanish-language region.

You can override the default language by launching Analytica as:
* <code>Analytica.exe /lang:es</code>
*: or
* <code>Analytica.exe /lang:en</code>

You can also set the <code>Language</code> registry setting in the <code>"HKCU/Software/Lumina Decision Systems/Analytica"</code> hive to REG_SZ <code>"en"</code> on <code>"es"</code> for your default if different from your windows region setting.

Some of you may ask "what about my language?". Stay tuned (and let us know there is a demand for your language). Once our AI translation pipeline is solid, it shouldn't be too hard for us to add more.

== Window appearance ==
The appearance of the chrome around child MDI windows (aka the "non-client area") has been changed to more closely match the Windows 11 style of windows -- i.e., thin (1 pixel) borders, rounded corners at the top, white title bar, very plain (text-like) button images in the toolbar.

== CSV files ==
There are now a few additional ways to open CSV files in Analytica:
* On the command line: <code>Analytica.exe MyData.csv</code>
* Drag and drop a *.csv file onto the diagram (which behaves the same as using <code>File / Import...</code> on the *.csv file).

== Spreadsheets ==
* <code>[[SpreadsheetOpen]]("new")</code> now creates a blank spreadsheet in memory. Works with both the Excel and LibXl backends.
* Prefacing a sheet name with + in the call to [[SpreadsheetSetCell]] or [[SpreadsheetSetRange]] will add a new sheet by that name to the workbook (as it applies the specified change to that new worksheet). Works with either backend.
* You can also now remove a sheet from a workbook using: <code>[[SpreadsheetSetCell]](wb, "-OldSheet", col, row, Null)</code>. The «col» and «row» parameters are required but ignored in this case.

== Misc. User Interface ==
* The Node Icon editor (on the Diagram menu) is far more flexible. You can use it to edit arbitrary node images, with support for color and transparency.
* Added keyboard shortcuts for '''Set Node Style...''' and '''Set Diagram Style...'''
* There is a new option, '''Use as default arrow style''', on the right-mouse context menu for an influence diagram arrow. This sets the global arrow style default to match the selected arrow.

== Built-in functions ==
* New options for [[GetProcessInfo]]: <code>"Number of monitors"</code>, <code>"Current monitor rect"</code>, <code>"Current monitor work rect"</code>, <code>"Monitor «N» Rect"</code>, and <code>"Monitor «N» work rect"</code>.
* Several new optional parameters to [[Evaluate]].
** «throwParsingErrors»: Flag to throw a parsing error instead of returning [[Null]] when the call to [[Evaluate]] is not inside a [[Try|Try...catch]].
** «maxSeconds»: Adds a timeout if the evaluation does not complete within the specified time duration.
** «ignoreAtFirstWarning: Flag used in conjunction with «reportOutput». When set, includes the first warning text in the output reported to the «reportOutput» function, and then ignores additional warnings during the duration of the Evaluate calls (this enables [[Assista]] to see the warnings).
** «reportOutput»: Accepts a function (usually a [[Local function]]). Calls it with output that was written to the typescript window during the evaluation, including stuff written by [[ConsolePrint]].
* New optional parameter, «throwParsingErrors», to [[Evaluate]].
* [[ReadFromURL]] is a bit smarter about returning binary content (like <code>*.zip</code> files) as a [[In-memory binary data terms|Binary Data Term]].
* [[MakeJSON]] will automatically encode an image in base64 JSON, and [[ParseJSON]] will automatically decode a base64 representation into an image. Also there is a new «maxCells» parameter that can be used to prevent giagantic arrays from being encoded (resulting in immensely long text).
* <code>[[GetProcessInfo]]("UI Language")</code> returns the UI language, either <code>"en"</code> (for English) or <code>"es"</code> for Spanish.
* <code>[[QualifiedName]]( obj, nsContext )</code>: Returns the qualified identifier (as text) that uniquely identifies «obj» from the context of «nsContext».
* <code>[[Namespace]] of X</code>: A new virtual attribute that returns the namespace of «X».
* Added a syntax construct for [[Namespaces#Scoped_namespace_inclusion:_Using|Scoped namespace inclusion]] to bring a namespace into scope for only a localized expression or lexical block.
* File functions ([[ReadTextFile]], [[WriteTextFile]], [[ReadBinaryFile]], [[WriteBinaryFile]], [[ReadImageFile]] and [[WriteImageFile]]) have a new optional parameter, «extensionFilter», where you can specify which extension filters show up on a file selector dialog.

== System variables ==
* SysVar [[Graph_ColorSequence]]: Replaces [[Graph_ColorSeq]] which is now deprecated. The new sysvar contains a list of color interer with one integer (of the form <code>0x00rrggbb</code>) per color (the deprecated version used triples of numbers per color).

== Engine ==
* After loading a large model, it parses expressions in parallel, using multiple threads/cores to parse different variables. On some computers on some models, this can dramatically speed up model load time.
* Color attributes use color integers for consistently (rather than the legacy number triples for R,G,B).
* You can use a localized namespace import (for a single expression or single lexical block) with the syntax
*:<code>[[Using..Do|Using]] NS;</code>

== Model loading ==
When opening a model file, the "checking" stage (when attributes are parsed) parses different expressions on different threads, resulting in substantially faster model load times for very large models.

Note: In the event that this creates a problem with your specific model (maybe due to an as-yet-undiscovered multithreading bug), you can disable it for your model as follows:
# Temporarily turn off multithreading (Skip this step if you are able to load your model)
## New model
## Definition menu / System variables / Settings / Maximum evaluation threads
## Set to 1 (and remember the previous value)
# Open your model
# Definition menu / System variables / Settings / Disable Multithreaded Evaluations
# Press the <code>Edit Table</code> button.
# Check the checkbox for <code>Parsing</code>
# Save your model
# Definition menu / System variables / Settings / Maximum evaluation threads
#: Restore the original value from Step 1

== MCP server ==
* Added an ability to install multiple ADE-based Mcp servers that run different ADE releases. For example, you can install two MCP servers into Claude Code:
* ade-server: Runs ADE 7.1
* ade-server-70: Runs ADE 7.0
The information in the <code>«ADE install folder»\Examples\Mcp_server\README.txt</code> file explain how (with enough info for Claude code to configure this for you).

With both installed, Claude Code (or other MCP-enabled AI agents) can compare results for the same model across different releases, etc.

Side note: The Mcp server was added to ADE 7.0.

== Internals ==
This release has undergone massive internal restructuring and refactorization. Ideally (i.e., in the absence of bugs) these changes won't change functionality, but may alter some aspects of behavior, hopefully for the better.
* Internal data structures use for multi-dimensional arrays has been changed. Possible impacts:
** Likely to remove the sensitivity to the "canonical order" of indexes on evaluation speed.
** May change relative evaluation speeds of various functions and operations.
* Added system modules/namespaces: <code>SysLib_Internal</code> and <code>SysLib_Experimental</code>. Intended for Analytica-internal use.
*[[:Category:Cell format functions|Cell formatting functions]] (like [[CellSpan]], [[CellFill]], etc.) are now [[Struct]]s rather than functions. Does not impact usage, other that making it easier for code to traverse resulting data structures.

== Discontinued... ==
* Plug-in functions. (An old hook that allows you to extend Analytica with compiled functions and UI elements written it C++. We are almost certain no one is using these hooks any more.)
* The sysvar [[Graph_ColorSeq]] is now deprecated (but works for both reading and setting to preserve backward compatibility). It has been replaced by the system variable [[Graph_ColorSequence]].
* The built-in (but undocumented, unsupported) <code>ifpos</code> and <code>if0</code> functions were removed.
* The legacy (deprecated) syntax <code>Using temp:=... Do</code> for declaring locals is no longer supported. Legacy models will have such definitions automatically rewritten to use [[Local..Do]] when you load them. [[Using..Do]] now has a different meaning, which is to provide a temporary namespace import.

What's new in Analytica 7.1?

2026-08-06T17:44:40Z

Lchrisman: /* Assista */

Analytica release 7.1 is currently in late-stage [[Beta Tester Page|Beta Testing]]. If have have a paid desktop Analytica subscription, we encourage you to try it out from the [[Beta Tester Page]].

== Highlights of Analytica 7.1 ==

'''[[#Assista|Assista]]:''' By far the most important visible improvement is in [[#Assista|Assista]], Analytica's A.I. assistant. When first released in Analytica 6.5, Assista was already quite useful for explaining Analytica features, describing and documenting models, and building models, but it was a bit unreliable in Analytica syntax and arranging influence diagrams. We think you will find that the latest Assista is so much improved, including writing Analytica Definitions and drawing influence diagrams. You may start to use chatting with Assista as the primary way you interact with Analytica.
[[File:Assista What kinds of things can you do.png|alt=Assista dialog screen answering "What kinds of things can you do?"|thumb|600x600px]]
Other improvements include faster response time, better look and feel, a trace of its thinking, the ability to save and use conversations from previous sessions, ingesting files to provide information, including txt, pdf, csv, xlsx; understanding images and diagrams; a set of skills that you can extend and customize, and more.

'''[[#Engine|Performance]]:''' Large models start up much faster using multiple processes to parse the definitions. Arrays now use a ''tensor'' representation, similar to AI frameworks like PyTorch and TensorFlow, but with Index labels that support "Intelligent Arrays". This internal improvement isn't noticeable to users -- but enables major future performance improvements.

'''[[#Spreadsheets|CSV and spreadsheet files]] :''' You can now import [[#CSV files|CSV files]] simply by dragging them into an diagram or in a command line when you start Analytica. You can create a new [[#spreadsheets |spreadsheet]] with and add or remove sheets from it.

'''[[#Spanish|Espagnol]]:''' The user interface now supports Spanish -- with other languages in the future. Assista already supports most languages, and explains features (translating docs) in your language.

== Assista ==
[[Assista]] is an AI collaborator in Analytica, greatly improved in this release:
* The '''chat window''' s now a top-level window at the same level as Analytica's main application window.
** Click the microphone button if you want to speak your request. Click it again when you're done.
** You can '''move the chat window''' to another location on the screen or even a different screen, to make best user of screen space.
** Selected objects remain visually selected in the main window as you type into Assista.
** The window is '''faster and more responsive''', with a new look and feel and clearer formatting of responses.
** You can '''highlight, drag, and copy any text''' to paste elsewhere.
** It displays a stream of "thoughts" while processing your request giving you a peek into what it is doing.
* On the '''backend,''' Assista has:
** A new '''processing pipeline''' enabling faster response and also enabling it work longer on harder tasks.
** An extensible set of '''competencies (skills)''', including structuring decision models, drawing influence diagrams, designing user interfaces, Analytica syntax, and more.
** You can create and expose [[Assista_-_Analytica_AI_Assistant/Custom_user_skills_for_Assista|your own custom skills]] to expand capabilities, or ask it to create new skills for you.
** It '''saves dialogs''', keyed to your model. You can resume a previous session for that model from a dropdown in the UI.
* Assist can now:
** '''Ingest documents''' (<code>*.txt, *.pdf, *.md, *.docx, *.xlsx, *.xlsm</code>) or URLs into the chat using a menu in the Request box, or by dragging and dropping files into the window. Assista "ingests" the files and can extract data from a doc or image, adding tables to your model, translate a spreadsheet into Analytica, or even implement a model described in the article.
** ''' "See" images''' in your model -- pictures in nodes, images in table cells, and diagram or graph screenshots.
** Converse in most common '''languages.''' In Spanish, it can provide UI instructions referring to the Spanish-language UI elements.
** '''Explain its reasoning''' in previous requests and expand on ideas .
** '''Personalize tone''', style, level of verbosity and provide custom instructions. To do this, click on the icon in the top-left corner of the Assista window and select Personization.
** '''Generate reports''' as a downloadable PDF or Word document, which can contain tables, graphs or other images from your model and formatted equations.
** '''Take you through a tutorial''' of how to use Analytica.

== Multi-linguality: Spanish UI ==
Analytica now comes with a Spanish-language UI, in which its menus, dialogs, error messages and built-in function descriptions are all in Spanish. Also its installer runs with a Spanish-language UI when you are in a Spanish-language region. Spanish is the default when you are in a Spanish-language region.

You can override the default language by launching Analytica as:
* <code>Analytica.exe /lang:es</code>
*: or
* <code>Analytica.exe /lang:en</code>

You can also set the <code>Language</code> registry setting in the <code>"HKCU/Software/Lumina Decision Systems/Analytica"</code> hive to REG_SZ <code>"en"</code> on <code>"es"</code> for your default if different from your windows region setting.

Some of you may ask "what about my language?". Stay tuned (and let us know there is a demand for your language). Once our AI translation pipeline is solid, it shouldn't be too hard for us to add more.

== Window appearance ==
The appearance of the chrome around child MDI windows (aka the "non-client area") has been changed to more closely match the Windows 11 style of windows -- i.e., thin (1 pixel) borders, rounded corners at the top, white title bar, very plain (text-like) button images in the toolbar.

== CSV files ==
There are now a few additional ways to open CSV files in Analytica:
* On the command line: <code>Analytica.exe MyData.csv</code>
* Drag and drop a *.csv file onto the diagram (which behaves the same as using <code>File / Import...</code> on the *.csv file).

== Spreadsheets ==
* <code>[[SpreadsheetOpen]]("new")</code> now creates a blank spreadsheet in memory. Works with both the Excel and LibXl backends.
* Prefacing a sheet name with + in the call to [[SpreadsheetSetCell]] or [[SpreadsheetSetRange]] will add a new sheet by that name to the workbook (as it applies the specified change to that new worksheet). Works with either backend.
* You can also now remove a sheet from a workbook using: <code>[[SpreadsheetSetCell]](wb, "-OldSheet", col, row, Null)</code>. The «col» and «row» parameters are required but ignored in this case.

== Misc. User Interface ==
* The Node Icon editor (on the Diagram menu) is far more flexible. You can use it to edit arbitrary node images, with support for color and transparency.
* Added keyboard shortcuts for '''Set Node Style...''' and '''Set Diagram Style...'''
* There is a new option, '''Use as default arrow style''', on the right-mouse context menu for an influence diagram arrow. This sets the global arrow style default to match the selected arrow.

== Built-in functions ==
* New options for [[GetProcessInfo]]: <code>"Number of monitors"</code>, <code>"Current monitor rect"</code>, <code>"Current monitor work rect"</code>, <code>"Monitor «N» Rect"</code>, and <code>"Monitor «N» work rect"</code>.
* Several new optional parameters to [[Evaluate]].
** «throwParsingErrors»: Flag to throw a parsing error instead of returning [[Null]] when the call to [[Evaluate]] is not inside a [[Try|Try...catch]].
** «maxSeconds»: Adds a timeout if the evaluation does not complete within the specified time duration.
** «ignoreAtFirstWarning: Flag used in conjunction with «reportOutput». When set, includes the first warning text in the output reported to the «reportOutput» function, and then ignores additional warnings during the duration of the Evaluate calls (this enables [[Assista]] to see the warnings).
** «reportOutput»: Accepts a function (usually a [[Local function]]). Calls it with output that was written to the typescript window during the evaluation, including stuff written by [[ConsolePrint]].
* New optional parameter, «throwParsingErrors», to [[Evaluate]].
* [[ReadFromURL]] is a bit smarter about returning binary content (like <code>*.zip</code> files) as a [[In-memory binary data terms|Binary Data Term]].
* [[MakeJSON]] will automatically encode an image in base64 JSON, and [[ParseJSON]] will automatically decode a base64 representation into an image. Also there is a new «maxCells» parameter that can be used to prevent giagantic arrays from being encoded (resulting in immensely long text).
* <code>[[GetProcessInfo]]("UI Language")</code> returns the UI language, either <code>"en"</code> (for English) or <code>"es"</code> for Spanish.
* <code>[[QualifiedName]]( obj, nsContext )</code>: Returns the qualified identifier (as text) that uniquely identifies «obj» from the context of «nsContext».
* <code>[[Namespace]] of X</code>: A new virtual attribute that returns the namespace of «X».
* Added a syntax construct for [[Namespaces#Scoped_namespace_inclusion:_Using|Scoped namespace inclusion]] to bring a namespace into scope for only a localized expression or lexical block.
* File functions ([[ReadTextFile]], [[WriteTextFile]], [[ReadBinaryFile]], [[WriteBinaryFile]], [[ReadImageFile]] and [[WriteImageFile]]) have a new optional parameter, «extensionFilter», where you can specify which extension filters show up on a file selector dialog.

== System variables ==
* SysVar [[Graph_ColorSequence]]: Replaces [[Graph_ColorSeq]] which is now deprecated. The new sysvar contains a list of color interer with one integer (of the form <code>0x00rrggbb</code>) per color (the deprecated version used triples of numbers per color).

== Engine ==
* After loading a large model, it parses expressions in parallel, using multiple threads/cores to parse different variables. On some computers on some models, this can dramatically speed up model load time.
* Color attributes use color integers for consistently (rather than the legacy number triples for R,G,B).
* You can use a localized namespace import (for a single expression or single lexical block) with the syntax
*:<code>[[Using..Do|Using]] NS;</code>

== Model loading ==
When opening a model file, the "checking" stage (when attributes are parsed) parses different expressions on different threads, resulting in substantially faster model load times for very large models.

Note: In the event that this creates a problem with your specific model (maybe due to an as-yet-undiscovered multithreading bug), you can disable it for your model as follows:
# Temporarily turn off multithreading (Skip this step if you are able to load your model)
## New model
## Definition menu / System variables / Settings / Maximum evaluation threads
## Set to 1 (and remember the previous value)
# Open your model
# Definition menu / System variables / Settings / Disable Multithreaded Evaluations
# Press the <code>Edit Table</code> button.
# Check the checkbox for <code>Parsing</code>
# Save your model
# Definition menu / System variables / Settings / Maximum evaluation threads
#: Restore the original value from Step 1

== MCP server ==
* Added an ability to install multiple ADE-based Mcp servers that run different ADE releases. For example, you can install two MCP servers into Claude Code:
* ade-server: Runs ADE 7.1
* ade-server-70: Runs ADE 7.0
The information in the <code>«ADE install folder»\Examples\Mcp_server\README.txt</code> file explain how (with enough info for Claude code to configure this for you).

With both installed, Claude Code (or other MCP-enabled AI agents) can compare results for the same model across different releases, etc.

Side note: The Mcp server was added to ADE 7.0.

== Internals ==
This release has undergone massive internal restructuring and refactorization. Ideally (i.e., in the absence of bugs) these changes won't change functionality, but may alter some aspects of behavior, hopefully for the better.
* Internal data structures use for multi-dimensional arrays has been changed. Possible impacts:
** Likely to remove the sensitivity to the "canonical order" of indexes on evaluation speed.
** May change relative evaluation speeds of various functions and operations.
* Added system modules/namespaces: <code>SysLib_Internal</code> and <code>SysLib_Experimental</code>. Intended for Analytica-internal use.
*[[:Category:Cell format functions|Cell formatting functions]] (like [[CellSpan]], [[CellFill]], etc.) are now [[Struct]]s rather than functions. Does not impact usage, other that making it easier for code to traverse resulting data structures.

== Discontinued... ==
* Plug-in functions. (An old hook that allows you to extend Analytica with compiled functions and UI elements written it C++. We are almost certain no one is using these hooks any more.)
* The sysvar [[Graph_ColorSeq]] is now deprecated (but works for both reading and setting to preserve backward compatibility). It has been replaced by the system variable [[Graph_ColorSequence]].
* The built-in (but undocumented, unsupported) <code>ifpos</code> and <code>if0</code> functions were removed.
* The legacy (deprecated) syntax <code>Using temp:=... Do</code> for declaring locals is no longer supported. Legacy models will have such definitions automatically rewritten to use [[Local..Do]] when you load them. [[Using..Do]] now has a different meaning, which is to provide a temporary namespace import.

What's new in Analytica 7.2?

2026-08-06T15:13:09Z

Lchrisman: Created page with "Analytica 7.2 is currently under development, and will be a future release of Analytica. The current official release is Analytica 7.0, which Analytica 7.1 currently i..."

Analytica 7.2 is currently under development, and will be a future release of Analytica. The current official release is [[Analytica 7.0]], which [[Analytica 7.1]] currently in late [[Beta Tester Page|beta testing]]. This page is under construction, and will list enhancements that are new to Analytica or ADE 7.2.

Analytica 7.2

2026-08-06T15:11:54Z

Lchrisman: Redirected page to What's new in Analytica 7.2?

#REDIRECT [[What's new in Analytica 7.2?]]

Analytica Command Line

2026-08-06T15:09:50Z

Lchrisman: ER 22407: document /remote-debugging-port and /remote-allow-origins (shown for 7.2+ only)

Analytica Command Line

2026-08-06T15:05:46Z

Lchrisman: Added the release bar

Template:ReleaseBar

2026-08-06T15:05:13Z

Lchrisman: Added 7.2

{{#svarset:anarelease|{{#urlget:anarelease|{{#svarget:anarelease|7.0}}}}}}{{#svarset:show_full|
{{#ifexpr: {{#isReleaseBetween:1.0|{{#svarget:anarelease}}|5.9}} |1|}}
}}{{#switch:{{#svarget:anarelease}}
| 4.6 =
| 5.0 =
| 5.1 =
| 5.2 =
| 5.3 =
| 5.4 =
| 6.0 =
| 6.1 =
| 6.2 =
| 6.3 =
| 6.4 =
| 6.5 =
| 6.6 =
| 7.0 =
| 7.1 =
| 7.2 =
| #default = {{#svarset:anarelease|7.0}}
}}{|class="release-table"
|-
! Release:
|
{{#if: {{#svarget:show_full}}
| 
{{ReleaseBarItem|4.6|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.0|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.1|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.2|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.3|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.4|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.0|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.1|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.2|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.3|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.4|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.5|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.6|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|7.0|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|7.1|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|7.2|{{#svarget:anarelease}}}}
| 
…

 • {{ReleaseBarItem|4.6|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.0|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.1|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.2|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.3|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|5.4|{{#svarget:anarelease}}}} • 
 • 
{{ReleaseBarItem|6.0|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.1|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.2|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.3|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.4|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.5|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|6.6|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|7.0|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|7.1|{{#svarget:anarelease}}}} • 
{{ReleaseBarItem|7.2|{{#svarget:anarelease}}}}
}}
|}{{#svarset:anamajor|{{#expr:floor{{#svarget:anarelease|7.0}}}}}}<noinclude>

To display a release bar at the top of a page, insert the following at the top:

<nowiki>{{ReleaseBar}}</nowiki>

You must have a Release Bar visible for a <nowiki>{{Release|startVer|endVer|content}}</nowiki> macro to work properly within the page.
</noinclude>

Assista - Analytica AI Assistant

2026-08-05T21:20:45Z

Lchrisman: /* See also */

''New in [[Analytica 6.5]]''

<center>[[image:assistaLogo.png|alt=|frameless|449x449px]]</center>

''Assista'' is the Analytica AI assistant -- a co-pilot that uses Artificial Intelligence to help you use Analytica and build models. You interact with Assista via a chat window. It provides help using plain English (and other natural languages). It can see your model and what variable or module you are looking at. It can can perform some tasks in the Analytica UI and make changes or additions to your model. It can also explain Analytica functions and suggest links to Analytica docs.



Here are a few examples of questions and requests it can handle:
* Describe this model -- ''explains what this model does''
* How do you change the background color?
* Change the background to white -- ''sometimes it can act on the model itself''
* Show a graph of overall company profits -- ''finds a relevant variable and displays its graph''
* How is revenue determined? -- ''explains the definition for this variable''
* Write and fill in its description -- "it describes the calculation for the currently displayed variable''
* I don't like that description. I want the description to explain what the definition means -- ''it adds a more useful description''
* Write a function for Geometric Average-- ''Shows a function to do this, and asks if you want to create the function in the current module''
* Yes -- ''Adds the function into your model, including its Description''
* How do I use the Aggregate function -- ''Describes it with links to Analytica docs pages''

'''Demos:'''
* See [https://downloads.analytica.com/Videos/AI_Series/AAIA_alpha_demo.mp4 a short demo of Assista responding to these prompts]
* Watch a demo given at Risk Awareness Year 2024 (RAW2024), [https://youtu.be/H_-Fix4V2o4 An AI assistant collaboration to develop risk management models], 10-Oct-2024.
* Watch a presentation from SDP 2025, "[https://youtu.be/zxqrTWyUWPk Advancing model-driven decision making through AI assistance], 23-March-2025, Vancouver, BC.

== Inaccuracies ==

Like other AI systems, it makes mistakes and sometimes gives wrong information. Its command of Analytica syntax and functions is not perfect. But if it leads you astray today, don't give up on it! We continue to improve it -- in part based on your questions. Over time, it will become more capable of helping you with all stages of model building and interpreting results.

== Privacy (or lack of) ==

When you use Assista, your questions and some model information are sent to Lumina's servers as well as to OpenAI's servers (also, we may on occasion include Anthropic's, Google's, Cerebras's or SambaNova's LLM servers). We use this information to see how well it's working to improve Assista. We at Lumina take privacy seriously. We will make our best effort to protect this information from any access or use other than to operate and improve Assista.

If you don't use Assista, it sends no information, so you need not worry about this when simply using Analytica.

== Scope ==

What can Assista help you with? This section identifies some areas, but these do not fully cover its full scope.

Please ask it for whatever help you need, even if it doesn't match stuff shown here! It may surprise you, but even if it fails, your questions may inform Assista's engineers about what types of capabilities would be useful to focus on.

Assista relies heavily on the documentation attributes (Title, Description, Units) in your model, and on the arrows that you have drawn between variables (even if they aren't yet defined). Keep those populated both for your own benefit, but also to increase the quality of the assistance. You can even ask it to write those descriptions for you.

=== Using Analytica's UI ===

::''How do you ... in Analytica?''

Ask it for the steps required to do something using the Analytica's UI.

Inaccuracies in its steps sometimes occur. But improving this accuracy is our first area of focus.

=== Navigating the Docs ===

The Analytica Docs are extensive. Assista can help you find what you need, even if you don't know the name of a feature or function. It shows "see also" links to relevant Docs pages.

Ask it for a list of functions of a specified type, for example. Or where you can find more information on something.

This general area is our second focus priority.

=== Actions on the model ===

In addition to explaining how to do something in Analytica GUI, Assista can sometimes do it for you! Some examples:

* Open the graph of X { or edit table, result table, object window, etc.)
* Change the color of X to blue
* Write this description
* Write this definition.
* Add a variable to calculate X.
* ... and more

=== Explaining Analytica concepts ===

Ask it to teach you more about Analytica concepts.

=== Formulating a model ===

Structuring your complex, messy, real world problem as an influence diagram and model that captures the essential elements is a challenging task for human model builders. This is also one of the most exciting use cases for this new technology, especially in a collaborative analyst-assistant partnership. Try experimenting with this. We have found it is often quite helpful -- and sometimes not.

=== Interpreting results ===

How do you interpret results, tables and graphs? How should you act based on the insights?

For now, Assista can't help much. One reason is that it doesn't yet look directly at the raw numbers or graph images in your results (or edit tables), even though it can see your graphing dimensions (axes, keys) and table pivots.

=== Custom user skills ===
''New to [[Analytica 7.1]]''

It is possible to configure your own [[Assista_-_Analytica_AI_Assistant/Custom user skills for Assista|custom user skills for Assista]] as a way to expand her abilities or knowledge.

=== Other ===

This list of ideas is by no means complete. If you could use some help while using Analytica, just try asking, even if it doesn't fall into any of these categories. It may give a useful response -- or at least, you may inspire us to extend its capabilities in new directions.

== Disabling Assista ==

If you never open the Assista window, no data is ever sent to the Assista server or to any LLM provider.

(new in [[Analytica 7.1]]) If your company has strict policies that require you to completely disable (i.e., never install) anything that might allow you access to A.I., then you can install Analytica without Assista by running the Analytica installer with the following command-line switch:
:<code>AnaSetup.exe /NoAssista</code>
If you ever want to re-enable it, then re-run the installer without the <code>/NoAssista</code> parameter.

== See also ==
* [https://www.youtube.com/watch?v=sC2xMmwy5DE An 8 minute rapid-fire tour (video) showing many of Assista's capabilities.]

Assista - Analytica AI Assistant

2026-08-05T21:17:56Z

Lchrisman: /* How Assista works */

''New in [[Analytica 6.5]]''

<center>[[image:assistaLogo.png|alt=|frameless|449x449px]]</center>

''Assista'' is the Analytica AI assistant -- a co-pilot that uses Artificial Intelligence to help you use Analytica and build models. You interact with Assista via a chat window. It provides help using plain English (and other natural languages). It can see your model and what variable or module you are looking at. It can can perform some tasks in the Analytica UI and make changes or additions to your model. It can also explain Analytica functions and suggest links to Analytica docs.



Here are a few examples of questions and requests it can handle:
* Describe this model -- ''explains what this model does''
* How do you change the background color?
* Change the background to white -- ''sometimes it can act on the model itself''
* Show a graph of overall company profits -- ''finds a relevant variable and displays its graph''
* How is revenue determined? -- ''explains the definition for this variable''
* Write and fill in its description -- "it describes the calculation for the currently displayed variable''
* I don't like that description. I want the description to explain what the definition means -- ''it adds a more useful description''
* Write a function for Geometric Average-- ''Shows a function to do this, and asks if you want to create the function in the current module''
* Yes -- ''Adds the function into your model, including its Description''
* How do I use the Aggregate function -- ''Describes it with links to Analytica docs pages''

'''Demos:'''
* See [https://downloads.analytica.com/Videos/AI_Series/AAIA_alpha_demo.mp4 a short demo of Assista responding to these prompts]
* Watch a demo given at Risk Awareness Year 2024 (RAW2024), [https://youtu.be/H_-Fix4V2o4 An AI assistant collaboration to develop risk management models], 10-Oct-2024.
* Watch a presentation from SDP 2025, "[https://youtu.be/zxqrTWyUWPk Advancing model-driven decision making through AI assistance], 23-March-2025, Vancouver, BC.

== Inaccuracies ==

Like other AI systems, it makes mistakes and sometimes gives wrong information. Its command of Analytica syntax and functions is not perfect. But if it leads you astray today, don't give up on it! We continue to improve it -- in part based on your questions. Over time, it will become more capable of helping you with all stages of model building and interpreting results.

== Privacy (or lack of) ==

When you use Assista, your questions and some model information are sent to Lumina's servers as well as to OpenAI's servers (also, we may on occasion include Anthropic's, Google's, Cerebras's or SambaNova's LLM servers). We use this information to see how well it's working to improve Assista. We at Lumina take privacy seriously. We will make our best effort to protect this information from any access or use other than to operate and improve Assista.

If you don't use Assista, it sends no information, so you need not worry about this when simply using Analytica.

== Scope ==

What can Assista help you with? This section identifies some areas, but these do not fully cover its full scope.

Please ask it for whatever help you need, even if it doesn't match stuff shown here! It may surprise you, but even if it fails, your questions may inform Assista's engineers about what types of capabilities would be useful to focus on.

Assista relies heavily on the documentation attributes (Title, Description, Units) in your model, and on the arrows that you have drawn between variables (even if they aren't yet defined). Keep those populated both for your own benefit, but also to increase the quality of the assistance. You can even ask it to write those descriptions for you.

=== Using Analytica's UI ===

::''How do you ... in Analytica?''

Ask it for the steps required to do something using the Analytica's UI.

Inaccuracies in its steps sometimes occur. But improving this accuracy is our first area of focus.

=== Navigating the Docs ===

The Analytica Docs are extensive. Assista can help you find what you need, even if you don't know the name of a feature or function. It shows "see also" links to relevant Docs pages.

Ask it for a list of functions of a specified type, for example. Or where you can find more information on something.

This general area is our second focus priority.

=== Actions on the model ===

In addition to explaining how to do something in Analytica GUI, Assista can sometimes do it for you! Some examples:

* Open the graph of X { or edit table, result table, object window, etc.)
* Change the color of X to blue
* Write this description
* Write this definition.
* Add a variable to calculate X.
* ... and more

=== Explaining Analytica concepts ===

Ask it to teach you more about Analytica concepts.

=== Formulating a model ===

Structuring your complex, messy, real world problem as an influence diagram and model that captures the essential elements is a challenging task for human model builders. This is also one of the most exciting use cases for this new technology, especially in a collaborative analyst-assistant partnership. Try experimenting with this. We have found it is often quite helpful -- and sometimes not.

=== Interpreting results ===

How do you interpret results, tables and graphs? How should you act based on the insights?

For now, Assista can't help much. One reason is that it doesn't yet look directly at the raw numbers or graph images in your results (or edit tables), even though it can see your graphing dimensions (axes, keys) and table pivots.

=== Custom user skills ===
''New to [[Analytica 7.1]]''

It is possible to configure your own [[Assista_-_Analytica_AI_Assistant/Custom user skills for Assista|custom user skills for Assista]] as a way to expand her abilities or knowledge.

=== Other ===

This list of ideas is by no means complete. If you could use some help while using Analytica, just try asking, even if it doesn't fall into any of these categories. It may give a useful response -- or at least, you may inspire us to extend its capabilities in new directions.

== Disabling Assista ==

If you never open the Assista window, no data is ever sent to the Assista server or to any LLM provider.

(new in [[Analytica 7.1]]) If your company has strict policies that require you to completely disable (i.e., never install) anything that might allow you access to A.I., then you can install Analytica without Assista by running the Analytica installer with the following command-line switch:
:<code>AnaSetup.exe /NoAssista</code>
If you ever want to re-enable it, then re-run the installer without the <code>/NoAssista</code> parameter.

== See also ==
* [https://downloads.analytica.com/Videos/AI_Series/AAIA_alpha_demo.mp4 A 7 minute (unpolished) demo video]

What's new in Analytica 7.1?

2026-08-04T15:48:43Z

Lchrisman:

Analytica release 7.1 is currently in late-stage [[Beta Tester Page|Beta Testing]]. If have have a paid desktop Analytica subscription, we encourage you to try it out from the [[Beta Tester Page]].

== Highlights of Analytica 7.1 ==

'''[[#Assista|Assista]]:''' By far the most important visible improvement is in [[#Assista|Assista]], Analytica's A.I. assistant. When first released in Analytica 6.5, Assista was already quite useful for explaining Analytica features, describing and documenting models, and building models, but it was a bit unreliable in Analytica syntax and arranging influence diagrams. We think you will find that the latest Assista is so much improved, including writing Analytica Definitions and drawing influence diagrams. You may start to use chatting with Assista as the primary way you interact with Analytica.
[[File:Assista What kinds of things can you do.png|alt=Assista dialog screen answering "What kinds of things can you do?"|thumb|600x600px]]
Other improvements include faster response time, better look and feel, a trace of its thinking, the ability to save and use conversations from previous sessions, ingesting files to provide information, including txt, pdf, csv, xlsx; understanding images and diagrams; a set of skills that you can extend and customize, and more.

'''[[#Engine|Performance]]:''' Large models start up much faster using multiple processes to parse the definitions. Arrays now use a ''tensor'' representation, similar to AI frameworks like PyTorch and TensorFlow, but with Index labels that support "Intelligent Arrays". This internal improvement isn't noticeable to users -- but enables major future performance improvements.

'''[[#Spreadsheets|CSV and spreadsheet files]] :''' You can now import [[#CSV files|CSV files]] simply by dragging them into an diagram or in a command line when you start Analytica. You can create a new [[#spreadsheets |spreadsheet]] with and add or remove sheets from it.

'''[[#Spanish|Espagnol]]:''' The user interface now supports Spanish -- with other languages in the future. Assista already supports most languages, and explains features (translating docs) in your language.

== Assista ==
[[Assista]] is an AI collaborator in Analytica, greatly improved in this release:
* The '''chat window''' s now a top-level window at the same level as Analytica's main application window.
** Click the microphone button if you want to speak your request. Click it again when you're done.
** You can '''move the chat window''' to another location on the screen or even a different screen, to make best user of screen space.
** Selected objects remain visually selected in the main window as you type into Assista.
** The window is '''faster and more responsive''', with a new look and feel and clearer formatting of responses.
** You can '''highlight, drag, and copy any text''' to paste elsewhere.
** It displays a stream of "thoughts" while processing your request giving you a peek into what it is doing.
* On the '''backend,''' Assista has:
** A new '''processing pipeline''' enabling faster response and also enabling it work longer on harder tasks.
** An extensible set of '''competencies (skills)''', including structuring decision models, drawing influence diagrams, designing user interfaces, Analytica syntax, and more.
** You can create and expose [[Assista_-_Analytica_AI_Assistant/Custom_user_skills_for_Assista|your own custom skills]] to expand capabilities, or ask it to create new skills for you.
** It '''saves dialogs''', keyed to your model. You can resume a previous session for that model from a dropdown in the UI.
* Assist can now:
** '''Ingest documents''' (<code>*.txt, *.pdf, *.md, *.docx, *.xlsx, *.xlsm</code>) or URLs into the chat using a menu in the Request box, or by dragging and dropping files into the window. Assista "ingests" the files and can extract data from a doc or image, adding tables to your model, translate a spreadsheet into Analytica, or even implement a model described in the article.
** ''' "See" images''' in your model -- pictures in nodes, images in table cells, and diagram or graph screenshots.
** Converse in most common '''languages.''' In Spanish, it can provide UI instructions referring to the Spanish-language UI elements.
** '''Explain its reasoning''' in previous requests and expand on ideas .
** '''Personalize tone''', style, level of verbosity and provide custom instructions. To do this, click on the icon in the top-left corner of the Assista window and select Personization.
** '''Generate reports''' as a downloadable PDF or Word document, which can contain tables, graphs or other images from your model and formatted equations.

== Multi-linguality: Spanish UI ==
Analytica now comes with a Spanish-language UI, in which its menus, dialogs, error messages and built-in function descriptions are all in Spanish. Also its installer runs with a Spanish-language UI when you are in a Spanish-language region. Spanish is the default when you are in a Spanish-language region.

You can override the default language by launching Analytica as:
* <code>Analytica.exe /lang:es</code>
*: or
* <code>Analytica.exe /lang:en</code>

You can also set the <code>Language</code> registry setting in the <code>"HKCU/Software/Lumina Decision Systems/Analytica"</code> hive to REG_SZ <code>"en"</code> on <code>"es"</code> for your default if different from your windows region setting.

Some of you may ask "what about my language?". Stay tuned (and let us know there is a demand for your language). Once our AI translation pipeline is solid, it shouldn't be too hard for us to add more.

== Window appearance ==
The appearance of the chrome around child MDI windows (aka the "non-client area") has been changed to more closely match the Windows 11 style of windows -- i.e., thin (1 pixel) borders, rounded corners at the top, white title bar, very plain (text-like) button images in the toolbar.

== CSV files ==
There are now a few additional ways to open CSV files in Analytica:
* On the command line: <code>Analytica.exe MyData.csv</code>
* Drag and drop a *.csv file onto the diagram (which behaves the same as using <code>File / Import...</code> on the *.csv file).

== Spreadsheets ==
* <code>[[SpreadsheetOpen]]("new")</code> now creates a blank spreadsheet in memory. Works with both the Excel and LibXl backends.
* Prefacing a sheet name with + in the call to [[SpreadsheetSetCell]] or [[SpreadsheetSetRange]] will add a new sheet by that name to the workbook (as it applies the specified change to that new worksheet). Works with either backend.
* You can also now remove a sheet from a workbook using: <code>[[SpreadsheetSetCell]](wb, "-OldSheet", col, row, Null)</code>. The «col» and «row» parameters are required but ignored in this case.

== Misc. User Interface ==
* The Node Icon editor (on the Diagram menu) is far more flexible. You can use it to edit arbitrary node images, with support for color and transparency.
* Added keyboard shortcuts for '''Set Node Style...''' and '''Set Diagram Style...'''
* There is a new option, '''Use as default arrow style''', on the right-mouse context menu for an influence diagram arrow. This sets the global arrow style default to match the selected arrow.

== Built-in functions ==
* New options for [[GetProcessInfo]]: <code>"Number of monitors"</code>, <code>"Current monitor rect"</code>, <code>"Current monitor work rect"</code>, <code>"Monitor «N» Rect"</code>, and <code>"Monitor «N» work rect"</code>.
* Several new optional parameters to [[Evaluate]].
** «throwParsingErrors»: Flag to throw a parsing error instead of returning [[Null]] when the call to [[Evaluate]] is not inside a [[Try|Try...catch]].
** «maxSeconds»: Adds a timeout if the evaluation does not complete within the specified time duration.
** «ignoreAtFirstWarning: Flag used in conjunction with «reportOutput». When set, includes the first warning text in the output reported to the «reportOutput» function, and then ignores additional warnings during the duration of the Evaluate calls (this enables [[Assista]] to see the warnings).
** «reportOutput»: Accepts a function (usually a [[Local function]]). Calls it with output that was written to the typescript window during the evaluation, including stuff written by [[ConsolePrint]].
* New optional parameter, «throwParsingErrors», to [[Evaluate]].
* [[ReadFromURL]] is a bit smarter about returning binary content (like <code>*.zip</code> files) as a [[In-memory binary data terms|Binary Data Term]].
* [[MakeJSON]] will automatically encode an image in base64 JSON, and [[ParseJSON]] will automatically decode a base64 representation into an image. Also there is a new «maxCells» parameter that can be used to prevent giagantic arrays from being encoded (resulting in immensely long text).
* <code>[[GetProcessInfo]]("UI Language")</code> returns the UI language, either <code>"en"</code> (for English) or <code>"es"</code> for Spanish.
* <code>[[QualifiedName]]( obj, nsContext )</code>: Returns the qualified identifier (as text) that uniquely identifies «obj» from the context of «nsContext».
* <code>[[Namespace]] of X</code>: A new virtual attribute that returns the namespace of «X».
* Added a syntax construct for [[Namespaces#Scoped_namespace_inclusion:_Using|Scoped namespace inclusion]] to bring a namespace into scope for only a localized expression or lexical block.
* File functions ([[ReadTextFile]], [[WriteTextFile]], [[ReadBinaryFile]], [[WriteBinaryFile]], [[ReadImageFile]] and [[WriteImageFile]]) have a new optional parameter, «extensionFilter», where you can specify which extension filters show up on a file selector dialog.

== System variables ==
* SysVar [[Graph_ColorSequence]]: Replaces [[Graph_ColorSeq]] which is now deprecated. The new sysvar contains a list of color interer with one integer (of the form <code>0x00rrggbb</code>) per color (the deprecated version used triples of numbers per color).

== Engine ==
* After loading a large model, it parses expressions in parallel, using multiple threads/cores to parse different variables. On some computers on some models, this can dramatically speed up model load time.
* Color attributes use color integers for consistently (rather than the legacy number triples for R,G,B).
* You can use a localized namespace import (for a single expression or single lexical block) with the syntax
*:<code>[[Using..Do|Using]] NS;</code>

== Model loading ==
When opening a model file, the "checking" stage (when attributes are parsed) parses different expressions on different threads, resulting in substantially faster model load times for very large models.

Note: In the event that this creates a problem with your specific model (maybe due to an as-yet-undiscovered multithreading bug), you can disable it for your model as follows:
# Temporarily turn off multithreading (Skip this step if you are able to load your model)
## New model
## Definition menu / System variables / Settings / Maximum evaluation threads
## Set to 1 (and remember the previous value)
# Open your model
# Definition menu / System variables / Settings / Disable Multithreaded Evaluations
# Press the <code>Edit Table</code> button.
# Check the checkbox for <code>Parsing</code>
# Save your model
# Definition menu / System variables / Settings / Maximum evaluation threads
#: Restore the original value from Step 1

== MCP server ==
* Added an ability to install multiple ADE-based Mcp servers that run different ADE releases. For example, you can install two MCP servers into Claude Code:
* ade-server: Runs ADE 7.1
* ade-server-70: Runs ADE 7.0
The information in the <code>«ADE install folder»\Examples\Mcp_server\README.txt</code> file explain how (with enough info for Claude code to configure this for you).

With both installed, Claude Code (or other MCP-enabled AI agents) can compare results for the same model across different releases, etc.

Side note: The Mcp server was added to ADE 7.0.

== Internals ==
This release has undergone massive internal restructuring and refactorization. Ideally (i.e., in the absence of bugs) these changes won't change functionality, but may alter some aspects of behavior, hopefully for the better.
* Internal data structures use for multi-dimensional arrays has been changed. Possible impacts:
** Likely to remove the sensitivity to the "canonical order" of indexes on evaluation speed.
** May change relative evaluation speeds of various functions and operations.
* Added system modules/namespaces: <code>SysLib_Internal</code> and <code>SysLib_Experimental</code>. Intended for Analytica-internal use.
*[[:Category:Cell format functions|Cell formatting functions]] (like [[CellSpan]], [[CellFill]], etc.) are now [[Struct]]s rather than functions. Does not impact usage, other that making it easier for code to traverse resulting data structures.

== Discontinued... ==
* Plug-in functions. (An old hook that allows you to extend Analytica with compiled functions and UI elements written it C++. We are almost certain no one is using these hooks any more.)
* The sysvar [[Graph_ColorSeq]] is now deprecated (but works for both reading and setting to preserve backward compatibility). It has been replaced by the system variable [[Graph_ColorSequence]].
* The built-in (but undocumented, unsupported) <code>ifpos</code> and <code>if0</code> functions were removed.
* The legacy (deprecated) syntax <code>Using temp:=... Do</code> for declaring locals is no longer supported. Legacy models will have such definitions automatically rewritten to use [[Local..Do]] when you load them. [[Using..Do]] now has a different meaning, which is to provide a temporary namespace import.

Beta Tester Page

2026-08-01T15:08:53Z

Lchrisman: /* How to start beta-testing */

[[Category: Beta testing]]
{{#svarset:betarelease|7.1}}
{{#svarset:prevrelease|7.0}}

We invite you to be a beta tester of [[Analytica {{#svarget:betarelease}}]] if you have Analytica {{#svarget:prevrelease}} installed on your computer with an active subscription. (Sorry, not [[Analytica Free Edition]] and not a legacy permanent license). A floating license subscription works.



== Why become a beta tester? ==
* Test drive the upcoming release {{#svarget:betarelease}} and start using its [[Analytica {{#svarget:betarelease}}|new features]] immediately.
* Participate in webinars on tips and guides on new features.
* Help improve the final release.
* Check that your models work in the new release. Find any issues while they can still be fixed, ensuring a seamless transition for you and your model users when this release becomes official.
== As a beta tester, we request that you ==
* Read [[What's new in Analytica {{#svarget:betarelease}}?]] for an overview of the new features.
* Sign up as a beta tester by filling in the form when you run the installer.
* Try out the new Analytica enhancements of interest to you.
* [[Beta_Tester_Page/Submitting_a_Bug_Report|Submit a bug report]] if you find an issue
* Keep up-to-date with the latest beta build. Analytica will show you an alert whenever there is a new build ready to install, about every 2 weeks. We may also send you email reminders. See [[Analytica {{#svarget:betarelease}} beta Release Notes| release notes]] for changes and bug fixes in each beta release.
* We encourage you to retain Analytica {{#svarget:prevrelease}} when you install Analytica {{#svarget:betarelease}} beta. That lets you compare their behavior if you suspect a new bug.

== How to start beta-testing ==
Download the installer for the latest beta build, release number 7.1.9.321, from:
* [https://downloads.analytica.com/ANA7.1/AnaSetup7_1_9_321.exe Analytica {{#svarget:betarelease}} installer]
* [https://downloads.analytica.com/ANA7.1/AnaSetup7_1_9_321.exe ADE {{#svarget:betarelease}} installer]
These beta builds use your existing {{#svarget:prevrelease}} subscription license that is already on your computer. A separate beta license is not required.

The installers for the current non-beta release can be downloaded directly from the [https://analytica.com/support-2/analytica-downloads/ Analytica Downloads] page.

== Improve Analytica docs ==

During the alpha and beta testing period, we are still updating these Analytica Docs to reflect new features. [[What's new in Analytica {{#svarget:betarelease}}?]] is the most complete listing of new features, and is also a work in progress. As we approach final release date, this information will be more complete.

As an Analytica user, you are invited to contribute to the docs! Since it's on a wiki (using Mediawiki software, just like Wikipedia), you can add or edit any content. If you find something unclear, incomplete, or just wrong, feel free to fix it yourself. Or add comments, asking someone else to. And you are welcome to add tips or interesting examples.

== Known issues ==

If you find an issue, please let us know about it at <code>support@lumina.com</code>. Please see [[/Submitting a Bug Report|Submitting a bug report]] for instructions on reporting bugs.

'''Note:''' We list only the most important issues here (ones that might impact your ability to use it, or which are likely to be found and reported multiple times). We maintain a comprehensive bug base in-house, which is not accessible outside of Lumina.

== FAQs: Frequently Asked Questions ==

See [[Analytica User FAQs]] for frequently asked questions not specific to {{#svarget:betarelease}} or to beta testing.

Beta Tester Page

2026-08-01T15:08:43Z

Lchrisman: /* How to start beta-testing */

[[Category: Beta testing]]
{{#svarset:betarelease|7.1}}
{{#svarset:prevrelease|7.0}}

We invite you to be a beta tester of [[Analytica {{#svarget:betarelease}}]] if you have Analytica {{#svarget:prevrelease}} installed on your computer with an active subscription. (Sorry, not [[Analytica Free Edition]] and not a legacy permanent license). A floating license subscription works.



== Why become a beta tester? ==
* Test drive the upcoming release {{#svarget:betarelease}} and start using its [[Analytica {{#svarget:betarelease}}|new features]] immediately.
* Participate in webinars on tips and guides on new features.
* Help improve the final release.
* Check that your models work in the new release. Find any issues while they can still be fixed, ensuring a seamless transition for you and your model users when this release becomes official.
== As a beta tester, we request that you ==
* Read [[What's new in Analytica {{#svarget:betarelease}}?]] for an overview of the new features.
* Sign up as a beta tester by filling in the form when you run the installer.
* Try out the new Analytica enhancements of interest to you.
* [[Beta_Tester_Page/Submitting_a_Bug_Report|Submit a bug report]] if you find an issue
* Keep up-to-date with the latest beta build. Analytica will show you an alert whenever there is a new build ready to install, about every 2 weeks. We may also send you email reminders. See [[Analytica {{#svarget:betarelease}} beta Release Notes| release notes]] for changes and bug fixes in each beta release.
* We encourage you to retain Analytica {{#svarget:prevrelease}} when you install Analytica {{#svarget:betarelease}} beta. That lets you compare their behavior if you suspect a new bug.

== How to start beta-testing ==
Download the installer for the latest beta build, release number 7.1..321, from:
* [https://downloads.analytica.com/ANA7.1/AnaSetup7_1_9_321.exe Analytica {{#svarget:betarelease}} installer]
* [https://downloads.analytica.com/ANA7.1/AnaSetup7_1_9_321.exe ADE {{#svarget:betarelease}} installer]
These beta builds use your existing {{#svarget:prevrelease}} subscription license that is already on your computer. A separate beta license is not required.

The installers for the current non-beta release can be downloaded directly from the [https://analytica.com/support-2/analytica-downloads/ Analytica Downloads] page.

== Improve Analytica docs ==

During the alpha and beta testing period, we are still updating these Analytica Docs to reflect new features. [[What's new in Analytica {{#svarget:betarelease}}?]] is the most complete listing of new features, and is also a work in progress. As we approach final release date, this information will be more complete.

As an Analytica user, you are invited to contribute to the docs! Since it's on a wiki (using Mediawiki software, just like Wikipedia), you can add or edit any content. If you find something unclear, incomplete, or just wrong, feel free to fix it yourself. Or add comments, asking someone else to. And you are welcome to add tips or interesting examples.

== Known issues ==

If you find an issue, please let us know about it at <code>support@lumina.com</code>. Please see [[/Submitting a Bug Report|Submitting a bug report]] for instructions on reporting bugs.

'''Note:''' We list only the most important issues here (ones that might impact your ability to use it, or which are likely to be found and reported multiple times). We maintain a comprehensive bug base in-house, which is not accessible outside of Lumina.

== FAQs: Frequently Asked Questions ==

See [[Analytica User FAQs]] for frequently asked questions not specific to {{#svarget:betarelease}} or to beta testing.

What's new in Analytica 7.1?

2026-07-30T14:29:01Z

Lchrisman: /* Built-in functions */ Evaluate's new parameters

Analytica release 7.1 is currently in [[Beta Tester Page|Beta Testing]]. If have have a paid desktop Analytica subscription, we encourage you to try it out from the [[Beta Tester Page]].

== Highlights of Analytica 7.1 ==

'''[[#Assista|Assista]]:''' By far the most important visible improvement is in [[#Assista|Assista]], Analytica's A.I. assistant. When first released in Analytica 6.5, Assista was already quite useful for explaining Analytica features, describing and documenting models, and building models, but it was a bit unreliable in Analytica syntax and arranging influence diagrams. We think you will find that the latest Assista is so much improved, including writing Analytica Definitions and drawing influence diagrams. You may start to use chatting with Assista as the primary way you interact with Analytica.
[[File:Assista What kinds of things can you do.png|alt=Assista dialog screen answering "What kinds of things can you do?"|thumb|600x600px]]
Other improvements include faster response time, better look and feel, a trace of its thinking, the ability to save and use conversations from previous sessions, ingesting files to provide information, including txt, pdf, csv, xlsx; understanding images and diagrams; a set of skills that you can extend and customize, and more.

'''[[#Engine|Performance]]:''' Large models start up much faster using multiple processes to parse the definitions. Arrays now use a ''tensor'' representation, similar to AI frameworks like PyTorch and TensorFlow, but with Index labels that support "Intelligent Arrays". This internal improvement isn't noticeable to users -- but enables major future performance improvements.

'''[[#Spreadsheets|CSV and spreadsheet files]] :''' You can now import [[#CSV files|CSV files]] simply by dragging them into an diagram or in a command line when you start Analytica. You can create a new [[#spreadsheets |spreadsheet]] with and add or remove sheets from it.

'''[[#Spanish|Espagnol]]:''' The user interface now supports Spanish -- with other languages in the future. Assista already supports most languages, and explains features (translating docs) in your language.

== Assista ==
[[Assista]] is an AI collaborator in Analytica, greatly improved in this release:
* The '''chat window''' s now a top-level window at the same level as Analytica's main application window.
** Click the microphone button if you want to speak your request. Click it again when you're done.
** You can '''move the chat window''' to another location on the screen or even a different screen, to make best user of screen space.
** Selected objects remain visually selected in the main window as you type into Assista.
** The window is '''faster and more responsive''', with a new look and feel and clearer formatting of responses.
** You can '''highlight, drag, and copy any text''' to paste elsewhere.
** It displays a stream of "thoughts" while processing your request giving you a peek into what it is doing.
* On the '''backend,''' Assista has:
** A new '''processing pipeline''' enabling faster response and also enabling it work longer on harder tasks.
** An extensible set of '''competencies (skills)''', including structuring decision models, drawing influence diagrams, designing user interfaces, Analytica syntax, and more.
** You can create and expose [[Assista_-_Analytica_AI_Assistant/Custom_user_skills_for_Assista|your own custom skills]] to expand capabilities, or ask it to create new skills for you.
** It '''saves dialogs''', keyed to your model. You can resume a previous session for that model from a dropdown in the UI.
* Assist can now:
** '''Ingest documents''' (<code>*.txt, *.pdf, *.md, *.docx, *.xlsx, *.xlsm</code>) or URLs into the chat using a menu in the Request box, or by dragging and dropping files into the window. Assista "ingests" the files and can extract data from a doc or image, adding tables to your model, translate a spreadsheet into Analytica, or even implement a model described in the article.
** ''' "See" images''' in your model -- pictures in nodes, images in table cells, and diagram or graph screenshots.
** Converse in most common '''languages.''' In Spanish, it can provide UI instructions referring to the Spanish-language UI elements.
** '''Explain its reasoning''' in previous requests and expand on ideas .
** '''Personalize tone''', style, level of verbosity and provide custom instructions. To do this, click on the icon in the top-left corner of the Assista window and select Personization.
** '''Generate reports''' as a downloadable PDF or Word document, which can contain tables, graphs or other images from your model and formatted equations.

== Multi-linguality: Spanish UI ==
Analytica now comes with a Spanish-language UI, in which its menus, dialogs, error messages and built-in function descriptions are all in Spanish. Also its installer runs with a Spanish-language UI when you are in a Spanish-language region. Spanish is the default when you are in a Spanish-language region.

You can override the default language by launching Analytica as:
* <code>Analytica.exe /lang:es</code>
*: or
* <code>Analytica.exe /lang:en</code>

You can also set the <code>Language</code> registry setting in the <code>"HKCU/Software/Lumina Decision Systems/Analytica"</code> hive to REG_SZ <code>"en"</code> on <code>"es"</code> for your default if different from your windows region setting.

Some of you may ask "what about my language?". Stay tuned (and let us know there is a demand for your language). Once our AI translation pipeline is solid, it shouldn't be too hard for us to add more.

== Window appearance ==
The appearance of the chrome around child MDI windows (aka the "non-client area") has been changed to more closely match the Windows 11 style of windows -- i.e., thin (1 pixel) borders, rounded corners at the top, white title bar, very plain (text-like) button images in the toolbar.

== CSV files ==
There are now a few additional ways to open CSV files in Analytica:
* On the command line: <code>Analytica.exe MyData.csv</code>
* Drag and drop a *.csv file onto the diagram (which behaves the same as using <code>File / Import...</code> on the *.csv file).

== Spreadsheets ==
* <code>[[SpreadsheetOpen]]("new")</code> now creates a blank spreadsheet in memory. Works with both the Excel and LibXl backends.
* Prefacing a sheet name with + in the call to [[SpreadsheetSetCell]] or [[SpreadsheetSetRange]] will add a new sheet by that name to the workbook (as it applies the specified change to that new worksheet). Works with either backend.
* You can also now remove a sheet from a workbook using: <code>[[SpreadsheetSetCell]](wb, "-OldSheet", col, row, Null)</code>. The «col» and «row» parameters are required but ignored in this case.

== Misc. User Interface ==
* The Node Icon editor (on the Diagram menu) is far more flexible. You can use it to edit arbitrary node images, with support for color and transparency.
* Added keyboard shortcuts for '''Set Node Style...''' and '''Set Diagram Style...'''
* There is a new option, '''Use as default arrow style''', on the right-mouse context menu for an influence diagram arrow. This sets the global arrow style default to match the selected arrow.

== Built-in functions ==
* New options for [[GetProcessInfo]]: <code>"Number of monitors"</code>, <code>"Current monitor rect"</code>, <code>"Current monitor work rect"</code>, <code>"Monitor «N» Rect"</code>, and <code>"Monitor «N» work rect"</code>.
* Several new optional parameters to [[Evaluate]].
** «throwParsingErrors»: Flag to throw a parsing error instead of returning [[Null]] when the call to [[Evaluate]] is not inside a [[Try|Try...catch]].
** «maxSeconds»: Adds a timeout if the evaluation does not complete within the specified time duration.
** «ignoreAtFirstWarning: Flag used in conjunction with «reportOutput». When set, includes the first warning text in the output reported to the «reportOutput» function, and then ignores additional warnings during the duration of the Evaluate calls (this enables [[Assista]] to see the warnings).
** «reportOutput»: Accepts a function (usually a [[Local function]]). Calls it with output that was written to the typescript window during the evaluation, including stuff written by [[ConsolePrint]].
* New optional parameter, «throwParsingErrors», to [[Evaluate]].
* [[ReadFromURL]] is a bit smarter about returning binary content (like <code>*.zip</code> files) as a [[In-memory binary data terms|Binary Data Term]].
* [[MakeJSON]] will automatically encode an image in base64 JSON, and [[ParseJSON]] will automatically decode a base64 representation into an image. Also there is a new «maxCells» parameter that can be used to prevent giagantic arrays from being encoded (resulting in immensely long text).
* <code>[[GetProcessInfo]]("UI Language")</code> returns the UI language, either <code>"en"</code> (for English) or <code>"es"</code> for Spanish.
* <code>[[QualifiedName]]( obj, nsContext )</code>: Returns the qualified identifier (as text) that uniquely identifies «obj» from the context of «nsContext».
* <code>[[Namespace]] of X</code>: A new virtual attribute that returns the namespace of «X».
* Added a syntax construct for [[Namespaces#Scoped_namespace_inclusion:_Using|Scoped namespace inclusion]] to bring a namespace into scope for only a localized expression or lexical block.
* File functions ([[ReadTextFile]], [[WriteTextFile]], [[ReadBinaryFile]], [[WriteBinaryFile]], [[ReadImageFile]] and [[WriteImageFile]]) have a new optional parameter, «extensionFilter», where you can specify which extension filters show up on a file selector dialog.

== System variables ==
* SysVar [[Graph_ColorSequence]]: Replaces [[Graph_ColorSeq]] which is now deprecated. The new sysvar contains a list of color interer with one integer (of the form <code>0x00rrggbb</code>) per color (the deprecated version used triples of numbers per color).

== Engine ==
* After loading a large model, it parses expressions in parallel, using multiple threads/cores to parse different variables. On some computers on some models, this can dramatically speed up model load time.
* Color attributes use color integers for consistently (rather than the legacy number triples for R,G,B).
* You can use a localized namespace import (for a single expression or single lexical block) with the syntax
*:<code>[[Using..Do|Using]] NS;</code>

== Model loading ==
When opening a model file, the "checking" stage (when attributes are parsed) parses different expressions on different threads, resulting in substantially faster model load times for very large models.

Note: In the event that this creates a problem with your specific model (maybe due to an as-yet-undiscovered multithreading bug), you can disable it for your model as follows:
# Temporarily turn off multithreading (Skip this step if you are able to load your model)
## New model
## Definition menu / System variables / Settings / Maximum evaluation threads
## Set to 1 (and remember the previous value)
# Open your model
# Definition menu / System variables / Settings / Disable Multithreaded Evaluations
# Press the <code>Edit Table</code> button.
# Check the checkbox for <code>Parsing</code>
# Save your model
# Definition menu / System variables / Settings / Maximum evaluation threads
#: Restore the original value from Step 1

== MCP server ==
* Added an ability to install multiple ADE-based Mcp servers that run different ADE releases. For example, you can install two MCP servers into Claude Code:
* ade-server: Runs ADE 7.1
* ade-server-70: Runs ADE 7.0
The information in the <code>«ADE install folder»\Examples\Mcp_server\README.txt</code> file explain how (with enough info for Claude code to configure this for you).

With both installed, Claude Code (or other MCP-enabled AI agents) can compare results for the same model across different releases, etc.

Side note: The Mcp server was added to ADE 7.0.

== Internals ==
This release has undergone massive internal restructuring and refactorization. Ideally (i.e., in the absence of bugs) these changes won't change functionality, but may alter some aspects of behavior, hopefully for the better.
* Internal data structures use for multi-dimensional arrays has been changed. Possible impacts:
** Likely to remove the sensitivity to the "canonical order" of indexes on evaluation speed.
** May change relative evaluation speeds of various functions and operations.
* Added system modules/namespaces: <code>SysLib_Internal</code> and <code>SysLib_Experimental</code>. Intended for Analytica-internal use.
*[[:Category:Cell format functions|Cell formatting functions]] (like [[CellSpan]], [[CellFill]], etc.) are now [[Struct]]s rather than functions. Does not impact usage, other that making it easier for code to traverse resulting data structures.

== Discontinued... ==
* Plug-in functions. (An old hook that allows you to extend Analytica with compiled functions and UI elements written it C++. We are almost certain no one is using these hooks any more.)
* The sysvar [[Graph_ColorSeq]] is now deprecated (but works for both reading and setting to preserve backward compatibility). It has been replaced by the system variable [[Graph_ColorSequence]].
* The built-in (but undocumented, unsupported) <code>ifpos</code> and <code>if0</code> functions were removed.
* The legacy (deprecated) syntax <code>Using temp:=... Do</code> for declaring locals is no longer supported. Legacy models will have such definitions automatically rewritten to use [[Local..Do]] when you load them. [[Using..Do]] now has a different meaning, which is to provide a temporary namespace import.

Evaluate

2026-07-30T14:25:02Z

Lchrisman: Document the throwParsingErrors parameter, new to 7.1

[[category:Evaluation Functions]]
{{ReleaseBar}}

Evaluate(t) is a powerful, but rarely needed function. If t is text, it parses it as an Analytica expression and evaluates it. If t is a handle to a variable, it evaluates and returns its value.
== Evaluate(t) ==

If parameter «t» is a [[Text values|text value]], [[Evaluate]](«t») tries to parse «t» as an Analytica [[expression]] (as in the [[definition]] of a Variable), evaluates it, and returns the resulting [[value]]. For example:

:<code>Evaluate('10 * 10') → 100</code>

If parameter «t» is a [[Handle]] to a variable, [[Evaluate]](«t») evaluates the variable and returns its value:
:<code>Variable A := 100</code>
:<code>[[Evaluate]]([[Handle]](A)) → 100</code>

You can also use it to evaluate a function passed as an object or handle:
:<code>Function Add(a, b) := a+b</code>
:<code>[[Evaluate]]([[Handle]](Add), 2, 10) → 12</code>
This can be useful when you want to define a function that takes a function as a parameter and applies the function in its body.
See [[#Using Evaluate on a Function]] below.

== Handling errors ==
As of [[Analytica 6.6]], when an error occurs during the parsing or evaluation of «t» ''and'' the call to [[Evaluate]] appears within a [[Try]], evaluation transfers to the «catch» expression of the [[Try]] without presenting any error message dialog to the user. But this isn't true when the only surrounding (possibly nested) [[Try]]s have «errorNum» filters that do not match the occurring error.

If error is not caught by a [[Try]], then a parsing error silently returns [[Null]] and an evaluation error appears to the user like any other evaluation error, typically terminating the computation.

In [[Analytica 6.5]] and earlier, parsing errors are not caught by a surrounding [[Try]] -- they return Null as if there were no surrounding [[Try]].

{{Release|1=7.1|2=|3=
=== Throwing parsing errors ===
''New to [[Analytica 7.1]].''

Set the optional «throwParsingErrors» parameter to <code>true</code> to make [[Evaluate]] throw a parsing error instead of silently returning [[Null]]:

:<code>[[Evaluate]]( 'Sqrt((' ) → [[Null]]</code>
:<code>[[Evaluate]]( 'Sqrt((', throwParsingErrors: true ) →</code> ''reports the syntax error''

This is useful when the text being evaluated is typed by a user or constructed by code (such as an AI agent), where a silent [[Null]] hides the fact that the text did not parse. Since the error is thrown like any other evaluation error, a surrounding [[Try]] catches it.

The parameter makes no difference when the call to [[Evaluate]] already appears within a [[Try]] that catches the error, since a parsing error is thrown in that case anyway (see above).
}}

{{Release|1=7.1|2=|3=
== Capturing console output ==
''New to [[Analytica 7.1]].''

To capture the text of everything printed to the console while «t» is evaluated, such as the output of any [[ConsolePrint]]() calls, pass a function that accepts one parameter to the optional «reportOutput» parameter. After the evaluation completes, your function is called with the captured console text:

:<code>[[Local]] consoleText;</code>
:<code>[[Local]] result {{eq}} [[Evaluate]]('ConsolePrint(2 + 2)', reportOutput: (Function(out) ::= (consoleText := out)));</code>

Here <code>result</code> is the value of the evaluated expression (here <code>4</code>), and <code>consoleText</code> receives the captured console output (here the text <code>"4"</code> followed by a newline). You can pass any function that accepts one parameter to «reportOutput» -- a local function as shown, or a handle to a user-defined function. Capturing the output does not prevent it from also appearing in the typescript window as it normally does.

«reportOutput» receives only output produced ''during'' this evaluation. If «t» refers to a variable whose value is already cached, the variable is not recomputed, so it produces no console output and the reported text is empty.

If the expression «t» returns multiple values using the <code>_(..)</code> operator, [[Evaluate]] passes these through to its own caller, so you can capture them in the usual way:

:<code>[[Local]] (a, b) {{eq}} [[Evaluate]]("_(1, 2)") Do b → 2</code>
}}

{{Release|1=7.1|2=|3=
== Limiting evaluation time ==
''New to [[Analytica 7.1]].''

The optional «maxSeconds» parameter sets an approximate limit, in seconds, on how long the evaluation of «t» may run. «maxSeconds» may be fractional, so <code>maxSeconds: 0.1</code> limits evaluation to roughly 100 milliseconds. The default of <code>0</code> means no time limit.

If the evaluation does not complete within «maxSeconds», it is aborted and [[Evaluate]] throws an error reading ''"Evaluate reached the maximum time limit of N seconds without completing."'' Because this is an ordinary evaluation error, you can catch it with a surrounding [[Try]]:

:<code>[[Try]]( [[Evaluate]]('Sum(Sqrt(1..100M))', maxSeconds: 0.5), catch: 'Timed out' )</code>

The timing is approximate -- evaluation stops the next time it checks for interruption -- so the limit adds no measurable overhead to normal evaluation. This makes «maxSeconds» well suited to probing how far a long-running evaluation gets within a time budget, rather than to enforcing a precise deadline.
}}

{{Release|1=7.1|2=|3=
== Controlling warnings ==
''New to [[Analytica 7.1]].''

Normally, a warning that occurs while «t» is being evaluated is shown to the user, just as it would be during any other evaluation. The optional «ignoreAtFirstWarning» parameter, when <code>true</code>, silently does what pressing the ''Ignore warnings'' button would do when the first warning occurs: no warning dialog is shown, evaluation continues, and any further warnings during the same call are ignored entirely (so that, for example, a warning that occurs in every cell of a million-cell array does not repeat a million times).

The text of the first warning still goes to the console output, so by also capturing the console output with «reportOutput» (see [[#Capturing console output|Capturing console output]] above) the calling code receives the warning text as feedback:

:<code>[[Local]] warnText;</code>
:<code>[[Local]] result {{eq}} [[Evaluate]]('Sqrt(-1)', ignoreAtFirstWarning: true, reportOutput: (Function(out) ::= (warnText := out)));</code>

Here <code>result</code> is <code>NaN</code> and <code>warnText</code> contains the text ''"Warning: Square root of a negative number."'' No dialog interrupts the user.

The suppression applies only for the duration of the [[Evaluate]] call -- the previous warning setting is restored when [[Evaluate]] returns, so the user still sees warnings from later evaluations unless they had already silenced them. This parameter is particularly useful when code (such as an AI agent) calls [[Evaluate]] and wants feedback about warnings without showing dialogs to the user.
}}

== Limitations of Evaluate(t) ==

There are some subtleties and limitations to Evaluate(«t») when «t» is a text value.

{{Release|1=|2=6.5|3=If text «t» contains a [[syntax]] error, [[Evaluate]](«t») gives no error message, and returns [[Null]].}}

The context inside the Evaluate parameter is global, not local. So:
:<code>Variable A := 100</code>
:<code>Variable B := ([[Local]] A := 0; [[Evaluate]]('A + 1'))</code>
:<code>B → 101</code>

The Variable <code>A</code> inside <code>Evaluate('A + 1')</code> refers to the global <code>A</code>, not the local <code>A</code> defined in <code>B</code>. More generally:

* [[Evaluate]](t) creates its own context for [[Parsed Expressions|parsing]] «t» (at evaluation time), which is not the context of the expression in which the [[Evaluate]](t) appears -- e.g., the definition of <code>B</code> above.
* So, text «t» cannot refer to [[Local Values|local value]]s, [[index]]es, or [[function parameters]] defined in the context in which the [[Evaluate]](t) function appears.
* Text «t» may itself define local values and indexes, and refer to them, but these will not be available outside «t».
* If the text value of «t» refers to a global variable —e.g., <code>A</code> in the definition of <code>B</code> above—these do not appear as Inputs of <code>B</code>.
* More generally, Analytica cannot track the dependency of any variable name that appears inside the text. So, for example, any change to <code>A</code> will not cause automatic re-evaluation of <code>B</code>:
:<code>A := 3</code>
:<code>B := A + 1</code>
:<code>C := Evaluate('A + 1')</code>
:<code>A := 5</code>

When <code>A</code> changes, Analytica will automatically ensure that <code>B</code> is updated, but it has no way of knowing <code>C</code> should also be recomputed.

The parameter «t» may itself be an expression that creates a text value to be evaluated by [[Evaluate]]. This text expression appears in the definition of <code>V</code> and is not subject to the above limitations, so, for example:

:<code>Variable V :=([[Local]] x:= ’10’; [[Evaluate]](x & x))</code>
:<code>V → 1010</code>

== When to Use ==

The cases in which you should use [[Evaluate]] are rare. You should be reluctant to use it due to the caveats listed in the previous section. Typical cases when it is useful include:
* Parsing simple expressions.
* (advanced) Use in [[Meta-Inference]] algorithms where you are manipulating handles to objects in your model.
* (rare) Cases where you really do wish to by-pass dependency maintenance. You want it to compute something the first time the result is requested after the model is first loaded, but not update when parent values are changes.

== Non-text Parameters ==

A non-text value can also be passed to [[Evaluate]], which can be of use in some [[Meta-Inference]] applications. You need to keep in mind that the parameter to evaluate is evaluated BEFORE the function itself gets it, so evaluating a non-text value is only meaningful when the evaluated parameter is itself something that can still be evaluated. One instance of this that is often useful is the case of a [[handle]] an object.

For example, suppose
:<code>Variable A := 2 + 3</code>
:<code>Variable TheVar := [[Handle]](A)</code>

In the more general case, you might have a [[Meta-Inference]] algorithm that identifies a single variable object through some computation. Having identified the object, <code>TheVar</code> now holds a handle to the object. You then may want to access values or properties of the object pointed to by <code>TheVar</code>, rather than just values or properties of <code>TheVar</code> itself. Evaluate serves this purpose:

:<code>TheVar → A { A -- i.e., a handle to the object A }</code>
:<code>[[Evaluate]](TheVar) → 5 { evaluates A }</code>

It is worth nothing that an alternative method also exists for evaluating a [[handle]]. You can declare a [[LocalAlias]] set to the handle, and then use its identifier as if it were the identifier of the object.

:<code>[[LocalAlias]] x := TheVar Do x → 5 { x is an alias for A, so "x" in the body is the value of A }</code>

When accessing attributes of an object in a [[Meta-Inference]] algorithm, where your algorithm has a handle to an object (again, say it is in <code>TheVar</code>), you can access the attribute using e.g.,

:<code>Description Of Evaluate(TheVar) → "Description of A"</code>
:<code>Description Of TheVar → "Description of TheVar"</code>

(the result of using <code>TheVar</code> alone is shown for comparison).

== Using Evaluate on a Function ==

Given a [[handle]] to a function object, you can use [[Evaluate]] to call the function. If the function expects ''N'' parameters, you would provide ''N+1'' parameters to [[Evaluate]] -- the first parameter being the handle to the function, and the remaining parameters being the values passed to the function. Example:

:<code>[[Local]] fn := [[If]] opt = 1 [[Then]] [[Handle]]([[Max]]) [[Else]] [[If]] opt = 2 [[Then]] [[Handle]]([[Min]]) [[Else]] [[Handle]]([[Sum]]);</code>
:<code>[[Evaluate]](fn, A, I)</code>

Parameters to the function being called are always passed by position, i.e., you cannot use a named-parameter calling syntax as you might if you were calling the function directly.

If the function being called contains repeated (or variable number of) parameters, and you need to include a parameter that follows the [[repeated parameter]], then you must place brackets around the repeated parameters. For example,

:<code> Function Fu1(x; y: repeated; z: optional) := ...</code>
:<code> </code>
:<code>[[Evaluate]](fn, 1, 2, 3, 4) →</code>
::''Equivalent to <code>Fu1(1, 2, 3, 4)</code>, where <code>[2, 3, 4]</code> are values for <code>y</code> and <code>z</code> is omitted''
:<code>[[Evaluate]](fn, 1, [2, 3], 4) →</code>
::''Equivalent to <code>Fu1(1, 2, 3, y: 4)</code>, where <code>[2, 3]</code> are values for <code>y</code>, and <code>z</code> is 4''.

However, there is a limitation that the first supplied parameter (i.e., the second parameter to [[Evaluate]]) cannot be placed inside brackets. Likewise, you cannot pass an literal list by specifying the first parameter as a bracketed list. This is because the repeated-parameter syntax applies equally to [[Evaluate]]. If you specify the first parameter to [[Evaluate]] in brackets, those become the parameters to the function, i.e.,:

:<code>[[Evaluate]]([[Handle]](F), [1, 2, 3, 4]) →</code>
::''Equivalent to <code>F(1, 2, 3, 4)''</code>

Several common built-in functions, including [[Sum]], [[Max]], and [[Min]], allow a variable number of indexes, so that you can use <code>[[Sum]](A, I, J, K)</code> to sum over 3 dimensions in a single call. These functions also have [[optional parameter]]s, such as «ignoreNonNumbers», so that if you need to specify these optional parameters, you will need to place brackets around the index(es), even if only one (or zero) index is specified. For example, the following examples show how to to specify «ignoreNonNumbers» as true to [[Sum]], when summing over a single index, and when summing over the [[implicit dimension]]:

:<code>[[Evaluate]]([[Handle]]([[Sum]]), A, [I], true)</code>
:<code>[[Local]] x := [3, 2, 'a', 'b', 6] do [[Evaluate]]([[Handle]]([[Sum]]), x, [], true)</code>

Notice that if you don't need to specify the optional «ignoreNonNumbers» parameter (or any parameters that follow the repeated index parameters), then it is more natural to omit the brackets:

:<code>[[Evaluate]]([[Handle]]([[Sum]]), A, I)</code>
:<code>[[Local]] x := [3, 2, 5, 3, 6] do [[Evaluate]]([[Handle]]([[Sum]]), x)</code>

{{Release|6.5||
== Evaluating in a different namespace context ==
''New to [[Analytica 6.5]]''

Suppose there are two variables that both have the identifier X, but which live in different [[Namespaces]]. Then
:<code>[[Evaluate]]( "X+1" )</code>
would differ depending on where it appears. By default it resolves the identifier <code>X</code> from the namespace of the object containing the expression. In some esoteric situations, you may need to interpret the expression from a different namespace context. You can do this by first obtaining a handle to the other namespace module, or to any object inside that namespace, and passing that handle to the «nsContext» parameter.
:<code>[[Evaluate]]( "X+1", nsContext: [[Handle]]("NS2") )</code>
}}

== See Also ==
<div style="column-count:2;-moz-column-count:2;-webkit-column-count:2">
* [[EvaluateScript]]
* [[Proactive Evaluation]]
* [[Evaluation Modes]]
* [[Handle]]
* [[Expression Syntax]]
* [[Expression Assist]]
* [[Parsed Expressions]]
* [[Function calls and parameters]]
* [[Summary of Programming Constructs]]
* [[Procedural Programming]]
* [[Meta-Inference]]{{Release|6.5||
* [[Namespaces]]}}
</div>

What's new in Analytica 7.1?

2026-07-30T14:07:22Z

Lchrisman: /* Built-in functions */

Analytica release 7.1 is currently in [[Beta Tester Page|Beta Testing]]. If have have a paid desktop Analytica subscription, we encourage you to try it out from the [[Beta Tester Page]].

== Highlights of Analytica 7.1 ==

'''[[#Assista|Assista]]:''' By far the most important visible improvement is in [[#Assista|Assista]], Analytica's A.I. assistant. When first released in Analytica 6.5, Assista was already quite useful for explaining Analytica features, describing and documenting models, and building models, but it was a bit unreliable in Analytica syntax and arranging influence diagrams. We think you will find that the latest Assista is so much improved, including writing Analytica Definitions and drawing influence diagrams. You may start to use chatting with Assista as the primary way you interact with Analytica.
[[File:Assista What kinds of things can you do.png|alt=Assista dialog screen answering "What kinds of things can you do?"|thumb|600x600px]]
Other improvements include faster response time, better look and feel, a trace of its thinking, the ability to save and use conversations from previous sessions, ingesting files to provide information, including txt, pdf, csv, xlsx; understanding images and diagrams; a set of skills that you can extend and customize, and more.

'''[[#Engine|Performance]]:''' Large models start up much faster using multiple processes to parse the definitions. Arrays now use a ''tensor'' representation, similar to AI frameworks like PyTorch and TensorFlow, but with Index labels that support "Intelligent Arrays". This internal improvement isn't noticeable to users -- but enables major future performance improvements.

'''[[#Spreadsheets|CSV and spreadsheet files]] :''' You can now import [[#CSV files|CSV files]] simply by dragging them into an diagram or in a command line when you start Analytica. You can create a new [[#spreadsheets |spreadsheet]] with and add or remove sheets from it.

'''[[#Spanish|Espagnol]]:''' The user interface now supports Spanish -- with other languages in the future. Assista already supports most languages, and explains features (translating docs) in your language.

== Assista ==
[[Assista]] is an AI collaborator in Analytica, greatly improved in this release:
* The '''chat window''' s now a top-level window at the same level as Analytica's main application window.
** Click the microphone button if you want to speak your request. Click it again when you're done.
** You can '''move the chat window''' to another location on the screen or even a different screen, to make best user of screen space.
** Selected objects remain visually selected in the main window as you type into Assista.
** The window is '''faster and more responsive''', with a new look and feel and clearer formatting of responses.
** You can '''highlight, drag, and copy any text''' to paste elsewhere.
** It displays a stream of "thoughts" while processing your request giving you a peek into what it is doing.
* On the '''backend,''' Assista has:
** A new '''processing pipeline''' enabling faster response and also enabling it work longer on harder tasks.
** An extensible set of '''competencies (skills)''', including structuring decision models, drawing influence diagrams, designing user interfaces, Analytica syntax, and more.
** You can create and expose [[Assista_-_Analytica_AI_Assistant/Custom_user_skills_for_Assista|your own custom skills]] to expand capabilities, or ask it to create new skills for you.
** It '''saves dialogs''', keyed to your model. You can resume a previous session for that model from a dropdown in the UI.
* Assist can now:
** '''Ingest documents''' (<code>*.txt, *.pdf, *.md, *.docx, *.xlsx, *.xlsm</code>) or URLs into the chat using a menu in the Request box, or by dragging and dropping files into the window. Assista "ingests" the files and can extract data from a doc or image, adding tables to your model, translate a spreadsheet into Analytica, or even implement a model described in the article.
** ''' "See" images''' in your model -- pictures in nodes, images in table cells, and diagram or graph screenshots.
** Converse in most common '''languages.''' In Spanish, it can provide UI instructions referring to the Spanish-language UI elements.
** '''Explain its reasoning''' in previous requests and expand on ideas .
** '''Personalize tone''', style, level of verbosity and provide custom instructions. To do this, click on the icon in the top-left corner of the Assista window and select Personization.
** '''Generate reports''' as a downloadable PDF or Word document, which can contain tables, graphs or other images from your model and formatted equations.

== Multi-linguality: Spanish UI ==
Analytica now comes with a Spanish-language UI, in which its menus, dialogs, error messages and built-in function descriptions are all in Spanish. Also its installer runs with a Spanish-language UI when you are in a Spanish-language region. Spanish is the default when you are in a Spanish-language region.

You can override the default language by launching Analytica as:
* <code>Analytica.exe /lang:es</code>
*: or
* <code>Analytica.exe /lang:en</code>

You can also set the <code>Language</code> registry setting in the <code>"HKCU/Software/Lumina Decision Systems/Analytica"</code> hive to REG_SZ <code>"en"</code> on <code>"es"</code> for your default if different from your windows region setting.

Some of you may ask "what about my language?". Stay tuned (and let us know there is a demand for your language). Once our AI translation pipeline is solid, it shouldn't be too hard for us to add more.

== Window appearance ==
The appearance of the chrome around child MDI windows (aka the "non-client area") has been changed to more closely match the Windows 11 style of windows -- i.e., thin (1 pixel) borders, rounded corners at the top, white title bar, very plain (text-like) button images in the toolbar.

== CSV files ==
There are now a few additional ways to open CSV files in Analytica:
* On the command line: <code>Analytica.exe MyData.csv</code>
* Drag and drop a *.csv file onto the diagram (which behaves the same as using <code>File / Import...</code> on the *.csv file).

== Spreadsheets ==
* <code>[[SpreadsheetOpen]]("new")</code> now creates a blank spreadsheet in memory. Works with both the Excel and LibXl backends.
* Prefacing a sheet name with + in the call to [[SpreadsheetSetCell]] or [[SpreadsheetSetRange]] will add a new sheet by that name to the workbook (as it applies the specified change to that new worksheet). Works with either backend.
* You can also now remove a sheet from a workbook using: <code>[[SpreadsheetSetCell]](wb, "-OldSheet", col, row, Null)</code>. The «col» and «row» parameters are required but ignored in this case.

== Misc. User Interface ==
* The Node Icon editor (on the Diagram menu) is far more flexible. You can use it to edit arbitrary node images, with support for color and transparency.
* Added keyboard shortcuts for '''Set Node Style...''' and '''Set Diagram Style...'''
* There is a new option, '''Use as default arrow style''', on the right-mouse context menu for an influence diagram arrow. This sets the global arrow style default to match the selected arrow.

== Built-in functions ==
* New options for [[GetProcessInfo]]: <code>"Number of monitors"</code>, <code>"Current monitor rect"</code>, <code>"Current monitor work rect"</code>, <code>"Monitor «N» Rect"</code>, and <code>"Monitor «N» work rect"</code>.
* Several new optional parameters to [[Evaluate]].
** «throwParsingErrors»: Flag
** «maxSeconds»: Adds a timeout if the evaluation does not complete within the specified time duration.
** «ignoreAtFirstWarning: Flag used in conjunction with «reportOutput». When set, includes the first warning text in the output reported to the «reportOutput» function, and then ignores additional warnings during the duration of the Evaluate calls (this enables [[Assista]] to see the warnings).
** «reportOutput»: Accepts a function (usually a [[Local function]]). Calls it with output that was written to the typescript window during the evaluation, including stuff written by [[ConsolePrint]].
* New optional parameter, «throwParsingErrors», to [[Evaluate]].
* [[ReadFromURL]] is a bit smarter about returning binary content (like <code>*.zip</code> files) as a [[In-memory binary data terms|Binary Data Term]].
* [[MakeJSON]] will automatically encode an image in base64 JSON, and [[ParseJSON]] will automatically decode a base64 representation into an image. Also there is a new «maxCells» parameter that can be used to prevent giagantic arrays from being encoded (resulting in immensely long text).
* <code>[[GetProcessInfo]]("UI Language")</code> returns the UI language, either <code>"en"</code> (for English) or <code>"es"</code> for Spanish.
* <code>[[QualifiedName]]( obj, nsContext )</code>: Returns the qualified identifier (as text) that uniquely identifies «obj» from the context of «nsContext».
* <code>[[Namespace]] of X</code>: A new virtual attribute that returns the namespace of «X».
* Added a syntax construct for [[Namespaces#Scoped_namespace_inclusion:_Using|Scoped namespace inclusion]] to bring a namespace into scope for only a localized expression or lexical block.
* File functions ([[ReadTextFile]], [[WriteTextFile]], [[ReadBinaryFile]], [[WriteBinaryFile]], [[ReadImageFile]] and [[WriteImageFile]]) have a new optional parameter, «extensionFilter», where you can specify which extension filters show up on a file selector dialog.

== System variables ==
* SysVar [[Graph_ColorSequence]]: Replaces [[Graph_ColorSeq]] which is now deprecated. The new sysvar contains a list of color interer with one integer (of the form <code>0x00rrggbb</code>) per color (the deprecated version used triples of numbers per color).

== Engine ==
* After loading a large model, it parses expressions in parallel, using multiple threads/cores to parse different variables. On some computers on some models, this can dramatically speed up model load time.
* Color attributes use color integers for consistently (rather than the legacy number triples for R,G,B).
* You can use a localized namespace import (for a single expression or single lexical block) with the syntax
*:<code>[[Using..Do|Using]] NS;</code>

== Model loading ==
When opening a model file, the "checking" stage (when attributes are parsed) parses different expressions on different threads, resulting in substantially faster model load times for very large models.

Note: In the event that this creates a problem with your specific model (maybe due to an as-yet-undiscovered multithreading bug), you can disable it for your model as follows:
# Temporarily turn off multithreading (Skip this step if you are able to load your model)
## New model
## Definition menu / System variables / Settings / Maximum evaluation threads
## Set to 1 (and remember the previous value)
# Open your model
# Definition menu / System variables / Settings / Disable Multithreaded Evaluations
# Press the <code>Edit Table</code> button.
# Check the checkbox for <code>Parsing</code>
# Save your model
# Definition menu / System variables / Settings / Maximum evaluation threads
#: Restore the original value from Step 1

== MCP server ==
* Added an ability to install multiple ADE-based Mcp servers that run different ADE releases. For example, you can install two MCP servers into Claude Code:
* ade-server: Runs ADE 7.1
* ade-server-70: Runs ADE 7.0
The information in the <code>«ADE install folder»\Examples\Mcp_server\README.txt</code> file explain how (with enough info for Claude code to configure this for you).

With both installed, Claude Code (or other MCP-enabled AI agents) can compare results for the same model across different releases, etc.

Side note: The Mcp server was added to ADE 7.0.

== Internals ==
This release has undergone massive internal restructuring and refactorization. Ideally (i.e., in the absence of bugs) these changes won't change functionality, but may alter some aspects of behavior, hopefully for the better.
* Internal data structures use for multi-dimensional arrays has been changed. Possible impacts:
** Likely to remove the sensitivity to the "canonical order" of indexes on evaluation speed.
** May change relative evaluation speeds of various functions and operations.
* Added system modules/namespaces: <code>SysLib_Internal</code> and <code>SysLib_Experimental</code>. Intended for Analytica-internal use.
*[[:Category:Cell format functions|Cell formatting functions]] (like [[CellSpan]], [[CellFill]], etc.) are now [[Struct]]s rather than functions. Does not impact usage, other that making it easier for code to traverse resulting data structures.

== Discontinued... ==
* Plug-in functions. (An old hook that allows you to extend Analytica with compiled functions and UI elements written it C++. We are almost certain no one is using these hooks any more.)
* The sysvar [[Graph_ColorSeq]] is now deprecated (but works for both reading and setting to preserve backward compatibility). It has been replaced by the system variable [[Graph_ColorSequence]].
* The built-in (but undocumented, unsupported) <code>ifpos</code> and <code>if0</code> functions were removed.
* The legacy (deprecated) syntax <code>Using temp:=... Do</code> for declaring locals is no longer supported. Legacy models will have such definitions automatically rewritten to use [[Local..Do]] when you load them. [[Using..Do]] now has a different meaning, which is to provide a temporary namespace import.

Evaluate

2026-07-30T13:59:39Z

Lchrisman:

[[category:Evaluation Functions]]
{{ReleaseBar}}

Evaluate(t) is a powerful, but rarely needed function. If t is text, it parses it as an Analytica expression and evaluates it. If t is a handle to a variable, it evaluates and returns its value.
== Evaluate(t) ==

If parameter «t» is a [[Text values|text value]], [[Evaluate]](«t») tries to parse «t» as an Analytica [[expression]] (as in the [[definition]] of a Variable), evaluates it, and returns the resulting [[value]]. For example:

:<code>Evaluate('10 * 10') → 100</code>

If parameter «t» is a [[Handle]] to a variable, [[Evaluate]](«t») evaluates the variable and returns its value:
:<code>Variable A := 100</code>
:<code>[[Evaluate]]([[Handle]](A)) → 100</code>

You can also use it to evaluate a function passed as an object or handle:
:<code>Function Add(a, b) := a+b</code>
:<code>[[Evaluate]]([[Handle]](Add), 2, 10) → 12</code>
This can be useful when you want to define a function that takes a function as a parameter and applies the function in its body.
See [[#Using Evaluate on a Function]] below.

== Handling errors ==
As of [[Analytica 6.6]], when an error occurs during the parsing or evaluation of «t» ''and'' the call to [[Evaluate]] appears within a [[Try]], evaluation transfers to the «catch» expression of the [[Try]] without presenting any error message dialog to the user. But this isn't true when the only surrounding (possibly nested) [[Try]]s have «errorNum» filters that do not match the occurring error.

If error is not caught by a [[Try]], then a parsing error silently returns [[Null]] and an evaluation error appears to the user like any other evaluation error, typically terminating the computation.

In [[Analytica 6.5]] and earlier, parsing errors are not caught by a surrounding [[Try]] -- they return Null as if there were no surrounding [[Try]].

{{Release|1=7.1|2=|3=
== Capturing console output ==
''New to [[Analytica 7.1]].''

To capture the text of everything printed to the console while «t» is evaluated, such as the output of any [[ConsolePrint]]() calls, pass a function that accepts one parameter to the optional «reportOutput» parameter. After the evaluation completes, your function is called with the captured console text:

:<code>[[Local]] consoleText;</code>
:<code>[[Local]] result {{eq}} [[Evaluate]]('ConsolePrint(2 + 2)', reportOutput: (Function(out) ::= (consoleText := out)));</code>

Here <code>result</code> is the value of the evaluated expression (here <code>4</code>), and <code>consoleText</code> receives the captured console output (here the text <code>"4"</code> followed by a newline). You can pass any function that accepts one parameter to «reportOutput» -- a local function as shown, or a handle to a user-defined function. Capturing the output does not prevent it from also appearing in the typescript window as it normally does.

«reportOutput» receives only output produced ''during'' this evaluation. If «t» refers to a variable whose value is already cached, the variable is not recomputed, so it produces no console output and the reported text is empty.

If the expression «t» returns multiple values using the <code>_(..)</code> operator, [[Evaluate]] passes these through to its own caller, so you can capture them in the usual way:

:<code>[[Local]] (a, b) {{eq}} [[Evaluate]]("_(1, 2)") Do b → 2</code>
}}

{{Release|1=7.1|2=|3=
== Limiting evaluation time ==
''New to [[Analytica 7.1]].''

The optional «maxSeconds» parameter sets an approximate limit, in seconds, on how long the evaluation of «t» may run. «maxSeconds» may be fractional, so <code>maxSeconds: 0.1</code> limits evaluation to roughly 100 milliseconds. The default of <code>0</code> means no time limit.

If the evaluation does not complete within «maxSeconds», it is aborted and [[Evaluate]] throws an error reading ''"Evaluate reached the maximum time limit of N seconds without completing."'' Because this is an ordinary evaluation error, you can catch it with a surrounding [[Try]]:

:<code>[[Try]]( [[Evaluate]]('Sum(Sqrt(1..100M))', maxSeconds: 0.5), catch: 'Timed out' )</code>

The timing is approximate -- evaluation stops the next time it checks for interruption -- so the limit adds no measurable overhead to normal evaluation. This makes «maxSeconds» well suited to probing how far a long-running evaluation gets within a time budget, rather than to enforcing a precise deadline.
}}

{{Release|1=7.1|2=|3=
== Controlling warnings ==
''New to [[Analytica 7.1]].''

Normally, a warning that occurs while «t» is being evaluated is shown to the user, just as it would be during any other evaluation. The optional «ignoreAtFirstWarning» parameter, when <code>true</code>, silently does what pressing the ''Ignore warnings'' button would do when the first warning occurs: no warning dialog is shown, evaluation continues, and any further warnings during the same call are ignored entirely (so that, for example, a warning that occurs in every cell of a million-cell array does not repeat a million times).

The text of the first warning still goes to the console output, so by also capturing the console output with «reportOutput» (see [[#Capturing console output|Capturing console output]] above) the calling code receives the warning text as feedback:

:<code>[[Local]] warnText;</code>
:<code>[[Local]] result {{eq}} [[Evaluate]]('Sqrt(-1)', ignoreAtFirstWarning: true, reportOutput: (Function(out) ::= (warnText := out)));</code>

Here <code>result</code> is <code>NaN</code> and <code>warnText</code> contains the text ''"Warning: Square root of a negative number."'' No dialog interrupts the user.

The suppression applies only for the duration of the [[Evaluate]] call -- the previous warning setting is restored when [[Evaluate]] returns, so the user still sees warnings from later evaluations unless they had already silenced them. This parameter is particularly useful when code (such as an AI agent) calls [[Evaluate]] and wants feedback about warnings without showing dialogs to the user.
}}

== Limitations of Evaluate(t) ==

There are some subtleties and limitations to Evaluate(«t») when «t» is a text value.

{{Release|1=|2=6.5|3=If text «t» contains a [[syntax]] error, [[Evaluate]](«t») gives no error message, and returns [[Null]].}}

The context inside the Evaluate parameter is global, not local. So:
:<code>Variable A := 100</code>
:<code>Variable B := ([[Local]] A := 0; [[Evaluate]]('A + 1'))</code>
:<code>B → 101</code>

The Variable <code>A</code> inside <code>Evaluate('A + 1')</code> refers to the global <code>A</code>, not the local <code>A</code> defined in <code>B</code>. More generally:

* [[Evaluate]](t) creates its own context for [[Parsed Expressions|parsing]] «t» (at evaluation time), which is not the context of the expression in which the [[Evaluate]](t) appears -- e.g., the definition of <code>B</code> above.
* So, text «t» cannot refer to [[Local Values|local value]]s, [[index]]es, or [[function parameters]] defined in the context in which the [[Evaluate]](t) function appears.
* Text «t» may itself define local values and indexes, and refer to them, but these will not be available outside «t».
* If the text value of «t» refers to a global variable —e.g., <code>A</code> in the definition of <code>B</code> above—these do not appear as Inputs of <code>B</code>.
* More generally, Analytica cannot track the dependency of any variable name that appears inside the text. So, for example, any change to <code>A</code> will not cause automatic re-evaluation of <code>B</code>:
:<code>A := 3</code>
:<code>B := A + 1</code>
:<code>C := Evaluate('A + 1')</code>
:<code>A := 5</code>

When <code>A</code> changes, Analytica will automatically ensure that <code>B</code> is updated, but it has no way of knowing <code>C</code> should also be recomputed.

The parameter «t» may itself be an expression that creates a text value to be evaluated by [[Evaluate]]. This text expression appears in the definition of <code>V</code> and is not subject to the above limitations, so, for example:

:<code>Variable V :=([[Local]] x:= ’10’; [[Evaluate]](x & x))</code>
:<code>V → 1010</code>

== When to Use ==

The cases in which you should use [[Evaluate]] are rare. You should be reluctant to use it due to the caveats listed in the previous section. Typical cases when it is useful include:
* Parsing simple expressions.
* (advanced) Use in [[Meta-Inference]] algorithms where you are manipulating handles to objects in your model.
* (rare) Cases where you really do wish to by-pass dependency maintenance. You want it to compute something the first time the result is requested after the model is first loaded, but not update when parent values are changes.

== Non-text Parameters ==

A non-text value can also be passed to [[Evaluate]], which can be of use in some [[Meta-Inference]] applications. You need to keep in mind that the parameter to evaluate is evaluated BEFORE the function itself gets it, so evaluating a non-text value is only meaningful when the evaluated parameter is itself something that can still be evaluated. One instance of this that is often useful is the case of a [[handle]] an object.

For example, suppose
:<code>Variable A := 2 + 3</code>
:<code>Variable TheVar := [[Handle]](A)</code>

In the more general case, you might have a [[Meta-Inference]] algorithm that identifies a single variable object through some computation. Having identified the object, <code>TheVar</code> now holds a handle to the object. You then may want to access values or properties of the object pointed to by <code>TheVar</code>, rather than just values or properties of <code>TheVar</code> itself. Evaluate serves this purpose:

:<code>TheVar → A { A -- i.e., a handle to the object A }</code>
:<code>[[Evaluate]](TheVar) → 5 { evaluates A }</code>

It is worth nothing that an alternative method also exists for evaluating a [[handle]]. You can declare a [[LocalAlias]] set to the handle, and then use its identifier as if it were the identifier of the object.

:<code>[[LocalAlias]] x := TheVar Do x → 5 { x is an alias for A, so "x" in the body is the value of A }</code>

When accessing attributes of an object in a [[Meta-Inference]] algorithm, where your algorithm has a handle to an object (again, say it is in <code>TheVar</code>), you can access the attribute using e.g.,

:<code>Description Of Evaluate(TheVar) → "Description of A"</code>
:<code>Description Of TheVar → "Description of TheVar"</code>

(the result of using <code>TheVar</code> alone is shown for comparison).

== Using Evaluate on a Function ==

Given a [[handle]] to a function object, you can use [[Evaluate]] to call the function. If the function expects ''N'' parameters, you would provide ''N+1'' parameters to [[Evaluate]] -- the first parameter being the handle to the function, and the remaining parameters being the values passed to the function. Example:

:<code>[[Local]] fn := [[If]] opt = 1 [[Then]] [[Handle]]([[Max]]) [[Else]] [[If]] opt = 2 [[Then]] [[Handle]]([[Min]]) [[Else]] [[Handle]]([[Sum]]);</code>
:<code>[[Evaluate]](fn, A, I)</code>

Parameters to the function being called are always passed by position, i.e., you cannot use a named-parameter calling syntax as you might if you were calling the function directly.

If the function being called contains repeated (or variable number of) parameters, and you need to include a parameter that follows the [[repeated parameter]], then you must place brackets around the repeated parameters. For example,

:<code> Function Fu1(x; y: repeated; z: optional) := ...</code>
:<code> </code>
:<code>[[Evaluate]](fn, 1, 2, 3, 4) →</code>
::''Equivalent to <code>Fu1(1, 2, 3, 4)</code>, where <code>[2, 3, 4]</code> are values for <code>y</code> and <code>z</code> is omitted''
:<code>[[Evaluate]](fn, 1, [2, 3], 4) →</code>
::''Equivalent to <code>Fu1(1, 2, 3, y: 4)</code>, where <code>[2, 3]</code> are values for <code>y</code>, and <code>z</code> is 4''.

However, there is a limitation that the first supplied parameter (i.e., the second parameter to [[Evaluate]]) cannot be placed inside brackets. Likewise, you cannot pass an literal list by specifying the first parameter as a bracketed list. This is because the repeated-parameter syntax applies equally to [[Evaluate]]. If you specify the first parameter to [[Evaluate]] in brackets, those become the parameters to the function, i.e.,:

:<code>[[Evaluate]]([[Handle]](F), [1, 2, 3, 4]) →</code>
::''Equivalent to <code>F(1, 2, 3, 4)''</code>

Several common built-in functions, including [[Sum]], [[Max]], and [[Min]], allow a variable number of indexes, so that you can use <code>[[Sum]](A, I, J, K)</code> to sum over 3 dimensions in a single call. These functions also have [[optional parameter]]s, such as «ignoreNonNumbers», so that if you need to specify these optional parameters, you will need to place brackets around the index(es), even if only one (or zero) index is specified. For example, the following examples show how to to specify «ignoreNonNumbers» as true to [[Sum]], when summing over a single index, and when summing over the [[implicit dimension]]:

:<code>[[Evaluate]]([[Handle]]([[Sum]]), A, [I], true)</code>
:<code>[[Local]] x := [3, 2, 'a', 'b', 6] do [[Evaluate]]([[Handle]]([[Sum]]), x, [], true)</code>

Notice that if you don't need to specify the optional «ignoreNonNumbers» parameter (or any parameters that follow the repeated index parameters), then it is more natural to omit the brackets:

:<code>[[Evaluate]]([[Handle]]([[Sum]]), A, I)</code>
:<code>[[Local]] x := [3, 2, 5, 3, 6] do [[Evaluate]]([[Handle]]([[Sum]]), x)</code>

{{Release|6.5||
== Evaluating in a different namespace context ==
''New to [[Analytica 6.5]]''

Suppose there are two variables that both have the identifier X, but which live in different [[Namespaces]]. Then
:<code>[[Evaluate]]( "X+1" )</code>
would differ depending on where it appears. By default it resolves the identifier <code>X</code> from the namespace of the object containing the expression. In some esoteric situations, you may need to interpret the expression from a different namespace context. You can do this by first obtaining a handle to the other namespace module, or to any object inside that namespace, and passing that handle to the «nsContext» parameter.
:<code>[[Evaluate]]( "X+1", nsContext: [[Handle]]("NS2") )</code>
}}

== See Also ==
<div style="column-count:2;-moz-column-count:2;-webkit-column-count:2">
* [[EvaluateScript]]
* [[Proactive Evaluation]]
* [[Evaluation Modes]]
* [[Handle]]
* [[Expression Syntax]]
* [[Expression Assist]]
* [[Parsed Expressions]]
* [[Function calls and parameters]]
* [[Summary of Programming Constructs]]
* [[Procedural Programming]]
* [[Meta-Inference]]{{Release|6.5||
* [[Namespaces]]}}
</div>

Evaluate

2026-07-30T00:58:46Z

Lchrisman: Bug 22393: Evaluate() again passes through multiple return values of the evaluated expression; console-output capture moved from 2nd return value to new reportOutput parameter

[[category:Evaluation Functions]]
{{ReleaseBar}}

Evaluate(t) is a powerful, but rarely needed function. If t is text, it parses it as an Analytica expression and evaluates it. If t is a handle to a variable, it evaluates and returns its value.
== Evaluate(t) ==

If parameter «t» is a [[Text values|text value]], [[Evaluate]](«t») tries to parse «t» as an Analytica [[expression]] (as in the [[definition]] of a Variable), evaluates it, and returns the resulting [[value]]. For example:

:<code>Evaluate('10 * 10') → 100</code>

If parameter «t» is a [[Handle]] to a variable, [[Evaluate]](«t») evaluates the variable and returns its value:
:<code>Variable A := 100</code>
:<code>[[Evaluate]]([[Handle]](A)) → 100</code>

You can also use it to evaluate a function passed as an object or handle:
:<code>Function Add(a, b) := a+b</code>
:<code>[[Evaluate]]([[Handle]](Add), 2, 10) → 12</code>
This can be useful when you want to define a function that takes a function as a parameter and applies the function in its body.
See [[#Using Evaluate on a Function]] below.

== Handling errors ==
As of [[Analytica 6.6]], when an error occurs during the parsing or evaluation of «t» ''and'' the call to [[Evaluate]] appears within a [[Try]], evaluation transfers to the «catch» expression of the [[Try]] without presenting any error message dialog to the user. But this isn't true when the only surrounding (possibly nested) [[Try]]s have «errorNum» filters that do not match the occurring error.

If error is not caught by a [[Try]], then a parsing error silently returns [[Null]] and an evaluation error appears to the user like any other evaluation error, typically terminating the computation.

In [[Analytica 6.5]] and earlier, parsing errors are not caught by a surrounding [[Try]] -- they return Null as if there were no surrounding [[Try]].

{{Release|1=7.1|2=|3=
== Capturing console output ==
''New to [[Analytica 7.1]].''

To capture the text of everything printed to the console while «t» is evaluated, such as the output of any [[ConsolePrint]]() calls, pass a function that accepts one parameter to the optional «reportOutput» parameter. After the evaluation completes, your function is called with the captured console text:

:<code>[[Local]] consoleText;</code>
:<code>[[Local]] result {{eq}} [[Evaluate]]('ConsolePrint(2 + 2)', reportOutput: (Function(out) ::= (consoleText := out)));</code>

Here <code>result</code> is the value of the evaluated expression (here <code>4</code>), and <code>consoleText</code> receives the captured console output (here the text <code>"4"</code> followed by a newline). You can pass any function that accepts one parameter to «reportOutput» -- a local function as shown, or a handle to a user-defined function. Capturing the output does not prevent it from also appearing in the typescript window as it normally does.

«reportOutput» receives only output produced ''during'' this evaluation. If «t» refers to a variable whose value is already cached, the variable is not recomputed, so it produces no console output and the reported text is empty.

If the expression «t» returns multiple values using the <code>_(..)</code> operator, [[Evaluate]] passes these through to its own caller, so you can capture them in the usual way:

:<code>[[Local]] (a, b) {{eq}} [[Evaluate]]("_(1, 2)") Do b → 2</code>

''(Note: earlier Analytica 7.1 builds instead returned the console output as a second return value from [[Evaluate]]. That interfered with passing through the multiple return values of «t», and was replaced by the «reportOutput» parameter.)''
}}

{{Release|1=7.1|2=|3=
== Limiting evaluation time ==
''New to [[Analytica 7.1]].''

The optional «maxSeconds» parameter sets an approximate limit, in seconds, on how long the evaluation of «t» may run. «maxSeconds» may be fractional, so <code>maxSeconds: 0.1</code> limits evaluation to roughly 100 milliseconds. The default of <code>0</code> means no time limit.

If the evaluation does not complete within «maxSeconds», it is aborted and [[Evaluate]] throws an error reading ''"Evaluate reached the maximum time limit of N seconds without completing."'' Because this is an ordinary evaluation error, you can catch it with a surrounding [[Try]]:

:<code>[[Try]]( [[Evaluate]]('Sum(Sqrt(1..100M))', maxSeconds: 0.5), catch: 'Timed out' )</code>

The timing is approximate -- evaluation stops the next time it checks for interruption -- so the limit adds no measurable overhead to normal evaluation. This makes «maxSeconds» well suited to probing how far a long-running evaluation gets within a time budget, rather than to enforcing a precise deadline.
}}

{{Release|1=7.1|2=|3=
== Controlling warnings ==
''New to [[Analytica 7.1]].''

Normally, a warning that occurs while «t» is being evaluated is shown to the user, just as it would be during any other evaluation. The optional «ignoreAtFirstWarning» parameter, when <code>true</code>, silently does what pressing the ''Ignore warnings'' button would do when the first warning occurs: no warning dialog is shown, evaluation continues, and any further warnings during the same call are ignored entirely (so that, for example, a warning that occurs in every cell of a million-cell array does not repeat a million times).

The text of the first warning still goes to the console output, so by also capturing the console output with «reportOutput» (see [[#Capturing console output|Capturing console output]] above) the calling code receives the warning text as feedback:

:<code>[[Local]] warnText;</code>
:<code>[[Local]] result {{eq}} [[Evaluate]]('Sqrt(-1)', ignoreAtFirstWarning: true, reportOutput: (Function(out) ::= (warnText := out)));</code>

Here <code>result</code> is <code>NaN</code> and <code>warnText</code> contains the text ''"Warning: Square root of a negative number."'' No dialog interrupts the user.

The suppression applies only for the duration of the [[Evaluate]] call -- the previous warning setting is restored when [[Evaluate]] returns, so the user still sees warnings from later evaluations unless they had already silenced them. This parameter is particularly useful when code (such as an AI agent) calls [[Evaluate]] and wants feedback about warnings without showing dialogs to the user.
}}

== Limitations of Evaluate(t) ==

There are some subtleties and limitations to Evaluate(«t») when «t» is a text value.

{{Release|1=|2=6.5|3=If text «t» contains a [[syntax]] error, [[Evaluate]](«t») gives no error message, and returns [[Null]].}}

The context inside the Evaluate parameter is global, not local. So:
:<code>Variable A := 100</code>
:<code>Variable B := ([[Local]] A := 0; [[Evaluate]]('A + 1'))</code>
:<code>B → 101</code>

The Variable <code>A</code> inside <code>Evaluate('A + 1')</code> refers to the global <code>A</code>, not the local <code>A</code> defined in <code>B</code>. More generally:

* [[Evaluate]](t) creates its own context for [[Parsed Expressions|parsing]] «t» (at evaluation time), which is not the context of the expression in which the [[Evaluate]](t) appears -- e.g., the definition of <code>B</code> above.
* So, text «t» cannot refer to [[Local Values|local value]]s, [[index]]es, or [[function parameters]] defined in the context in which the [[Evaluate]](t) function appears.
* Text «t» may itself define local values and indexes, and refer to them, but these will not be available outside «t».
* If the text value of «t» refers to a global variable —e.g., <code>A</code> in the definition of <code>B</code> above—these do not appear as Inputs of <code>B</code>.
* More generally, Analytica cannot track the dependency of any variable name that appears inside the text. So, for example, any change to <code>A</code> will not cause automatic re-evaluation of <code>B</code>:
:<code>A := 3</code>
:<code>B := A + 1</code>
:<code>C := Evaluate('A + 1')</code>
:<code>A := 5</code>

When <code>A</code> changes, Analytica will automatically ensure that <code>B</code> is updated, but it has no way of knowing <code>C</code> should also be recomputed.

The parameter «t» may itself be an expression that creates a text value to be evaluated by [[Evaluate]]. This text expression appears in the definition of <code>V</code> and is not subject to the above limitations, so, for example:

:<code>Variable V :=([[Local]] x:= ’10’; [[Evaluate]](x & x))</code>
:<code>V → 1010</code>

== When to Use ==

The cases in which you should use [[Evaluate]] are rare. You should be reluctant to use it due to the caveats listed in the previous section. Typical cases when it is useful include:
* Parsing simple expressions.
* (advanced) Use in [[Meta-Inference]] algorithms where you are manipulating handles to objects in your model.
* (rare) Cases where you really do wish to by-pass dependency maintenance. You want it to compute something the first time the result is requested after the model is first loaded, but not update when parent values are changes.

== Non-text Parameters ==

A non-text value can also be passed to [[Evaluate]], which can be of use in some [[Meta-Inference]] applications. You need to keep in mind that the parameter to evaluate is evaluated BEFORE the function itself gets it, so evaluating a non-text value is only meaningful when the evaluated parameter is itself something that can still be evaluated. One instance of this that is often useful is the case of a [[handle]] an object.

For example, suppose
:<code>Variable A := 2 + 3</code>
:<code>Variable TheVar := [[Handle]](A)</code>

In the more general case, you might have a [[Meta-Inference]] algorithm that identifies a single variable object through some computation. Having identified the object, <code>TheVar</code> now holds a handle to the object. You then may want to access values or properties of the object pointed to by <code>TheVar</code>, rather than just values or properties of <code>TheVar</code> itself. Evaluate serves this purpose:

:<code>TheVar → A { A -- i.e., a handle to the object A }</code>
:<code>[[Evaluate]](TheVar) → 5 { evaluates A }</code>

It is worth nothing that an alternative method also exists for evaluating a [[handle]]. You can declare a [[LocalAlias]] set to the handle, and then use its identifier as if it were the identifier of the object.

:<code>[[LocalAlias]] x := TheVar Do x → 5 { x is an alias for A, so "x" in the body is the value of A }</code>

When accessing attributes of an object in a [[Meta-Inference]] algorithm, where your algorithm has a handle to an object (again, say it is in <code>TheVar</code>), you can access the attribute using e.g.,

:<code>Description Of Evaluate(TheVar) → "Description of A"</code>
:<code>Description Of TheVar → "Description of TheVar"</code>

(the result of using <code>TheVar</code> alone is shown for comparison).

== Using Evaluate on a Function ==

Given a [[handle]] to a function object, you can use [[Evaluate]] to call the function. If the function expects ''N'' parameters, you would provide ''N+1'' parameters to [[Evaluate]] -- the first parameter being the handle to the function, and the remaining parameters being the values passed to the function. Example:

:<code>[[Local]] fn := [[If]] opt = 1 [[Then]] [[Handle]]([[Max]]) [[Else]] [[If]] opt = 2 [[Then]] [[Handle]]([[Min]]) [[Else]] [[Handle]]([[Sum]]);</code>
:<code>[[Evaluate]](fn, A, I)</code>

Parameters to the function being called are always passed by position, i.e., you cannot use a named-parameter calling syntax as you might if you were calling the function directly.

If the function being called contains repeated (or variable number of) parameters, and you need to include a parameter that follows the [[repeated parameter]], then you must place brackets around the repeated parameters. For example,

:<code> Function Fu1(x; y: repeated; z: optional) := ...</code>
:<code> </code>
:<code>[[Evaluate]](fn, 1, 2, 3, 4) →</code>
::''Equivalent to <code>Fu1(1, 2, 3, 4)</code>, where <code>[2, 3, 4]</code> are values for <code>y</code> and <code>z</code> is omitted''
:<code>[[Evaluate]](fn, 1, [2, 3], 4) →</code>
::''Equivalent to <code>Fu1(1, 2, 3, y: 4)</code>, where <code>[2, 3]</code> are values for <code>y</code>, and <code>z</code> is 4''.

However, there is a limitation that the first supplied parameter (i.e., the second parameter to [[Evaluate]]) cannot be placed inside brackets. Likewise, you cannot pass an literal list by specifying the first parameter as a bracketed list. This is because the repeated-parameter syntax applies equally to [[Evaluate]]. If you specify the first parameter to [[Evaluate]] in brackets, those become the parameters to the function, i.e.,:

:<code>[[Evaluate]]([[Handle]](F), [1, 2, 3, 4]) →</code>
::''Equivalent to <code>F(1, 2, 3, 4)''</code>

Several common built-in functions, including [[Sum]], [[Max]], and [[Min]], allow a variable number of indexes, so that you can use <code>[[Sum]](A, I, J, K)</code> to sum over 3 dimensions in a single call. These functions also have [[optional parameter]]s, such as «ignoreNonNumbers», so that if you need to specify these optional parameters, you will need to place brackets around the index(es), even if only one (or zero) index is specified. For example, the following examples show how to to specify «ignoreNonNumbers» as true to [[Sum]], when summing over a single index, and when summing over the [[implicit dimension]]:

:<code>[[Evaluate]]([[Handle]]([[Sum]]), A, [I], true)</code>
:<code>[[Local]] x := [3, 2, 'a', 'b', 6] do [[Evaluate]]([[Handle]]([[Sum]]), x, [], true)</code>

Notice that if you don't need to specify the optional «ignoreNonNumbers» parameter (or any parameters that follow the repeated index parameters), then it is more natural to omit the brackets:

:<code>[[Evaluate]]([[Handle]]([[Sum]]), A, I)</code>
:<code>[[Local]] x := [3, 2, 5, 3, 6] do [[Evaluate]]([[Handle]]([[Sum]]), x)</code>

{{Release|6.5||
== Evaluating in a different namespace context ==
''New to [[Analytica 6.5]]''

Suppose there are two variables that both have the identifier X, but which live in different [[Namespaces]]. Then
:<code>[[Evaluate]]( "X+1" )</code>
would differ depending on where it appears. By default it resolves the identifier <code>X</code> from the namespace of the object containing the expression. In some esoteric situations, you may need to interpret the expression from a different namespace context. You can do this by first obtaining a handle to the other namespace module, or to any object inside that namespace, and passing that handle to the «nsContext» parameter.
:<code>[[Evaluate]]( "X+1", nsContext: [[Handle]]("NS2") )</code>
}}

== See Also ==
<div style="column-count:2;-moz-column-count:2;-webkit-column-count:2">
* [[EvaluateScript]]
* [[Proactive Evaluation]]
* [[Evaluation Modes]]
* [[Handle]]
* [[Expression Syntax]]
* [[Expression Assist]]
* [[Parsed Expressions]]
* [[Function calls and parameters]]
* [[Summary of Programming Constructs]]
* [[Procedural Programming]]
* [[Meta-Inference]]{{Release|6.5||
* [[Namespaces]]}}
</div>

AcpStyles

2026-07-27T23:37:02Z

Lchrisman: Document 14 AcpStyles used by the ACP client but missing from this page: the flex box diagram layout family, show_toolbar, text_inputs_white, Show_row_col_header, row_pivoter_loc, blue_handle_links, acp_large_table_scroll, acp_max_table_size_to_show

[[Category: Analytica Cloud Platform]]
[[Category: Attributes]]
[[Analytica_Cloud_Player|<<Analytica Cloud Platform ]]

::{{ReleaseBar}}

ACP offers a wide variety of styles and options to control the look and functioning of the user interface. Many of these go beyond what is (currently) available in Desktop Analytica (DTA).

The easiest way to set these styles and options is to use the [[ACP Style Library]], which you can load into your model within ACP from the hamburger menu. As you change styles in ACP, you can see their effects immediately.

If you use the [[ACP Style Library]] you don't need to learn about the ACP Styles described below. The only reason to read the rest of this page is if you want to do something esoteric with AcpStyles, or use one of the few AcpStyles not accessible in the [[ACP_Style_Library]].

You can also load the [[ACP Style Library]] in Analytica on the desktop from the '''Add Library...' option from the '''File''' menu. But, you won't be able to see the effects until you upload the model into ACP.

The styles and options are specified as keywords and tags in the AcpStyles attribute. Most styles and options apply to the whole Model and are specified in the AcpStyles attribute of the Model. When you want to specify special styles for individual modules or variables, you apply them to the ACPStyles attribute of the relevant object.

The easiest way to view and edit the AcpStyles attribute in Desktop Analytica is to use the [[Attribute panel]]. Select AcpStyles from the list of Attributes at the top of that panel. By default, AcpStyles is not shown in the [[Object window]], so you first need to set it to be shown either with the [[Object_Window|right click menu]] in the Object window, or in the [[Manage attributes|Attributes dialog]].

The AcpStyles and their flags are not case sensitive.

When you put multiple flags in a AcpStyles attribute, put each flag on a separate line.

== Model level styles ==

These styles apply to the entire model. You set them in the AcpStyles attribute for the Main Model. (They have no effect when set for a submodule.)

=== Navigation style ===

These Navigation_style options control how a user can view and access the module hierarchy:
* '''<code>Navigation_style: Outline</code>''' -- Show an expandable tree of modules on the left of the ACP window, similar to the outline view in desktop Analytica (showing only modules not other objects). This is the default style when you upload a model with no ACP styles set or no Acp styles library embedded, or if you have not yet set the Navigation style in the Acp styles library. A navigation flag is not needed for this style, but if you want to explicitly set this style you can add '''<code>Navigation_style: Outline</code>''' to the top diagram's AcpStyles attribute.

*'''<code>Navigation_style: Top diagram only</code>''' -- Show only the top diagram, with no Outline and no tabs. This lets you make a simple web application with a single UI page.
 

For the next two 'Tabbed application' styles, each module in the main model becomes a tab. The order of the tabs follows the sequence of the module nodes in the main diagram, from left to right then top to bottom.

* '''<code>Navigation_style: Top_tabs</code>''' -- The main modules in the top model appear as a row of tabs across the top of the window. Click a tab to show the diagram for that module.

*'''<code>Navigation_style: Side_tabs</code>''' -- The main modules in the top model appear as a column of tabs on the left of the window. Click a tab to show the diagram for that module.


We describe each in more detail below.

===Outline Tree===

By default, when using the Outline Navigation style, ACP shows an expandable outline tree of modules on the left hand side of the window, similar to the Outline view in Analytica on the desktop. This makes it easy to navigate a model with an extensive hierarchy of modules.

*'''<code>Show_outline: yes</code>''' -- The default, and unecessary for Outline Navigation style. It is generally redundant with other Navigation styles since the tabs or hierarchy show the same information, and the Outline takes up screen space. But you can add it to the top diagram's AcpStyles attribute if you want to show the Outline tree with other Navigation styles.

{{CalloutAnnotationBlock|[[File:Outline tree 6.0 01.png]]|{{CalloutAnnotation|Market model with Outline Tree|v=80|pt=10,106}}}}
*'''<code>show_outline: no</code>''' -- When using the Acp Style library this is set by default for Navigation styles other than Outline. For small models, and most web apps, you may want to suppress the Outline view even when using the Outline Navigation style. Do this by inserting this text into the top diagram's AcpStyles attribute (See image below). (If a model has only one diagram, i.e. with no modules, it never shows the outline tree.) 
{{CalloutAnnotationBlock|[[File:Outline tree 6.0 02.png]]|{{CalloutAnnotation|Market model with '''<code>show_outline: no</code>'''|v=80}}}}

===Top Diagram Only===

Set by adding '''<code>navigation_style: top_diagram_only</code>''' to the AcpStyles attribute of the top diagram.  The Styles library will set the flag  '''<code>show_outline:no</code>''' .

===Tabbed Module Navigation===

As an alternative to the Outline view, you can set the '''<code>Navigation_style</code>''' to use use a tabbed interface which is often more convenient and familiar for web applications. By default, the main model appears as the first tab. You can change this with the style [[AcpStyles_Attribute_Values#Exclude_the_top_level_diagram_from_tabs|show_as_tab:no]] described below.


There are two tabbed styles, Top_tabs, with a row of tabs across the top; and Side_tabs with a column of tabs down the side. Top_tabs works well if you have up to 5 to 8 modules in the main diagram (tabs), depending on the length of their titles and the width of the ACP window. If you have a lot of modules, or they have long titles, it may be better to use Side_tabs.

'Top tabs or side tabs.' The first tab displays the top level diagram, and the remaining tabs display the modules present on the top level diagram of the model. (The modules will not display on the diagram, so you need to tweak your diagram for playing in ACP so that it looks right without these present).

* '''<code>navigation_style: top_tabs</code>''' -- This setting instructs ACP to use the 'Tabs across top' navigation style.

[[File:Top tabs 6.0 01.png]]

* '''<code>navigation_style: side_tabs</code>''' -- This setting instructs ACP to use the 'Side tabs' navigation style. Side tabs work better than top tabs when there are more module nodes present.

[[File:Side tabs 6.0 01.png]]

=== Toolbar Tabs ===
*'''<code>show_tabs: no</code>''' -- By default, with the Outline Navigation style. ACP shows navigation tabs for "Diagram", "Object", "Table", "Graph" along the top. Use this flag to hide those tabs. If you display the model inputs and outputs on the diagram -- using embedded tables and graphs on the diagram -- your users may not need those tabs. (You can also use '''<code>show_tabs: yes</code>''' to explicitly show the tabs in Outline and Top diagram only Navigation styles.)
*'''<code>show_toolbar: no</code>''' -- A synonym for '''<code>show_tabs: no</code>'''. Either style hides these tabs, and either one set to '''<code>yes</code>''' shows them.
{{CalloutAnnotationBlock|[[File:Show tabs no 6.0 0.1.png]]|{{CalloutAnnotation|Market model with '''<code>show_tabs: no</code>'''|v=80|pt=232,37|path=t!-}}}}
 

===Module hierarchy bar ===
Using tabbed navigation, ACP shows the model hierarchy in a bar at the top of the diagram by default. The model hierarchy header shows you where you are in a large model by listing the titles of the ancestor modules in which the current diagram is nested. You can click any ancestor to click up levels in the hierarchy. The Hierarchy Bar takes up much less screen real estate than the Outline Tree. ACP doesn't show the hierarchy bar when you are viewing a top level module, or if the module title is already in the selected tab. 

Note that this setting is not based on a AcpStyles attribute, but rather on the ''Show module hierarchy'' check box in the model [[Preferences]] in Analytica. If you want to set this preference manually, with the model opened in Analytica, on the [[Edit menu]], select '''Preference...''', and check (or uncheck) the ''Show module hierarchy'' checkbox.

If you are using the ACP styles library, the Styles library will set this to the default setting automatically once you select a Navigation style. But you have the option of changing it if, for instance you want to show the Outline and the Hierarchy bar.


===Auto zoom ===
*'''<code>auto_zoom_diagrams: yes</code>''' -- ACP automatically zooms the UI to fit the browser window -- the most constraining of width or height so it retains the aspect ratio of the diagram. Works with zoom in and zoom out. Auto Zoom will allow a model to go down to 50% of its size or up to 200% of its size. If the model does not fit at 50% size, the window will show scroll bars. This Acp style has no effect if '''<code>Use_top_diagram_size:Yes </code>''' is present, you can use only one or the other. You can also set '''<code>auto_zoom_diagrams: no</code>''' which is the default. (This is a model level setting and is added to the top diagram of a model).

===Customize zoom levels===
AcpStyles for controlling the max/min zoom when '''<code>auto_zoom_diagram: yes</code>''' is set. The default if these styles are not set is as above - 50% and 200%. The easiest way to set these is with the [[ACP_Style_Library]] - where the controls are in the Esoteric ACP styles module. This is available from the Hamburger menu in ACP. Note that in order to see this effect, the '''<code>Browser window size</code>''' needs to have the screen size pulldown menu set to '''<code>Auto zoom</code>''' as well.
*'''<code>zoom_min_percent: 75</code>''' (means that the minimum zoom level will be 75% or .75)
*'''<code>zoom_max_percent: 125</code>''' (means the that max zoom level will be 125% or 1.25)

===Use top diagram size for all ACP windows===
*'''<code>Use_top_diagram_size:Yes </code>''' -- Sets the size of all diagrams based on the size of the diagram window of the top level when the model was last viewed in Desktop Analytica (in non-maximized mode). '''<code>Use_top_diagram_size:No </code>''' is the same as if the flag is not set, and is the default - the ACP diagram will use the entire browser window.


===Show or hide the Dashboard Title and Model title===
*'''<code>show_model_title: no</code>''' -- Hide the title of the model, which appears by default in the top Teal bar.

*'''<code>show_diagram_title: yes</code>''' -- Use to show the dashboard title at the top of the diagram. Or <code>show_diagram_title: no</code> to suppress the diagram title, but not really necessary because ACP does not show the diagram title by default.


===Exclude diagram(s) from tabs===

When using tabbed navigation, you can select those modules (from the top model diagram) that you want to appear as a tab in ACP. The default is for all to appear as tabs. You should use the ''Show modules as tabs'' choice menu in the '''<code>ACP Navigation styles</code>''' section of the [[ACP Style Library]] if you want to set this flag,, and if you also want to hide the modules corresponding to these tabs [[ChangeNodeVisibility|hidden]], so that the model viewer cannot see them.

*Optionally, Enter the text '''<code>Show_as_tab: no</code>''' in the AcpStyles attribute of the modules you don't wish to show as a tab. The modules themselves will not be hidden with this setting, only the tabs.

===Tab color===

When using Tabbed Navigation, you can use these flags to control how the color of the tabs display on your model in ACP. To use, add one of them to the AcpStyles attribute of the top level diagram of your model. They have no effect if added to a module other than the top diagram.

*'''<code>Tab_color: Default </code>''' The default. Non-selected tabs are bluish white. The selected tab uses the background color for that diagram.
*'''<code>Tab_color: Background </code>''' All tabs use their diagram background color, whether selected or not
*'''<code>Tab_color: Node </code>''' The selected Tab uses its diagram background color; The other tabs use the color of their Module node (not their diagram background color). You can use this to change the color of the tabs by modifying their node color in an Analytica functions.

== Model level styles for diagram nodes. ==

These model-level styles affect how all nodes are displayed in diagrams.
===Default view for Frame nodes===
*'''<code>Frame_default_view:object</code>''' Shows the default view as the object view for all frame nodes (until you click another option e.g. graph or table) .
*'''<code>Frame_default_view:no</code>''' The default.
=== Node shadows and bevels ===

By default ACP displays nodes without shadows or bevels (for now) , so they look like this:
:[[Image:Nodes no shadow or bevel.png]]

Set this flag to show a drop shadow behind each node, giving a kind of 3D effect:

*'''<code>node_drop_shadow: yes</code>'''

:[[Image:Nodes drop shadow.png]]

Set this flag to display a bevel border for each node, giving another kind of 3-D effect:
*'''<code>bevel_node_border: yes</code>'''

:[[Image:Nodes beveled border.png]]

===Node hover highlighting===

By default, ACP displays a highlight -- a contrasting light rectangle behind a node -- when you move the cursor over the node:

[[File:acp hover hl.png]]

You can switch it off by setting:
*'''<code>show_hover_highlight: No</code>'''

=== Balloon Help ===

When you move the cursor over a node, ACP usually shows a "balloon" popup next to the node with the description of the node (if it has one) to help end users understand what its for, or what to enter for a user input. If the node has no description, the [[help balloons|balloon help]] will not appear.

*'''<code>show_id_in_balloon: yes</code>''' Use this flag to show each node's identifier below its title in the balloon -- unless the identifier and title are identical (except for spaces which are replaced by underscores). This flag goes in the AcpStyles of the model and apply to all nodes in the model.



*'''<code>show_hover_balloon: no</code>'''
::Insert this flag in the AcpStyles for a node, to suppress display of its balloon.


===Flex box diagram layout===

By default, ACP places every node at the position it has in the Analytica diagram. As an alternative, you can lay a diagram out as a ''flex box'', in which the nodes flow across the diagram and wrap onto more lines as the browser window changes size. Unlike most of the styles above, you set this on the AcpStyles attribute of the module whose diagram you want laid out this way, so different diagrams in one model can use different layouts.

*'''<code>display: flex</code>''' -- Lay this diagram out as a flex box.

Frame nodes, tall form nodes and text nodes become the items of the flex box. ACP does not draw influence arrows on a flex diagram.

These styles adjust the layout. They have no effect unless '''<code>display: flex</code>''' is also set on the same diagram:
*'''<code>flex_direction: row</code>''' -- The default. Items flow from left to right. Use '''<code>flex_direction: column</code>''' to make them flow from top to bottom.
*'''<code>flex_wrap: wrap</code>''' -- The default. Items wrap onto more lines when they don't fit. Use '''<code>flex_wrap: no_wrap</code>''' to keep them all on one line.
*'''<code>flex_h_align: left</code>''' -- The default. Use '''<code>center</code>''' or '''<code>right</code>''' to change the horizontal alignment of the items.
*'''<code>flex_v_align: top</code>''' -- The default. Use '''<code>center</code>''' or '''<code>bottom</code>''' to change the vertical alignment of the items.
*'''<code>flex_gap: n</code>''' -- The spacing around each item. ACP divides ''n'' by four to get the margin and the padding in pixels, so the default of 16 gives four pixels of each. Set this one on the top model rather than on the individual diagram.

You can include or exclude an individual node by setting this style in the AcpStyles attribute of that node:
*'''<code>flex_box_item: yes</code>''' -- Make this node an item of the flex box even though it would not otherwise be one.
*'''<code>flex_box_item: no</code>''' -- Keep this node out of the flex box.

===Background of text input boxes===
*'''<code>text_inputs_white: no</code>''' -- The box for typing into a text input node takes the background color of the node it sits on. By default, '''<code>text_inputs_white: yes</code>''', the box is white.

==ACP styles inheritance==
This is the order of inheritance for Acpstyles below that apply to tables and graphs. Styles at a higher level take precedence over the lower precedence styles. (Inheritance doesn't apply to the ACPstyles described above tbecause they work only at the Model level.)
# '''Variable''' (includes Tall nodes): Acpstyles applied to an individual variable will take precedence over all other styles. A variable with a style of <code>show_title:no</code> will not show the title, even if the model level style is <code>show_title:yes</code>, and if that node shows it's result in a frame node the variable style will override the frame node style.
# '''Frame''' : An Acpstyle set for a frame node will affect any variable shown in that frame that doesn't have its own settings. These will also override any styles at the model level.
# '''Model ACP style defaults''': Acpstyles that you can enter into the Acptyles attribute of the top diagram of your model. These will override the ACP defaults, and will be inherited by frame nodes and variables in the model that don't have their own Acpstyle.
# '''ACP style defaults for ACP''': The default style ACP uses if you have no specific setting for that style. Eg for show_index_menus the default is fly-in and that is what will show if you don't enter a different show_index_menus: Acpstyle flag in the Acpstyle for the top diagram (model level) or for frame nodes or variables.

==ACP Styles for tables and graphs==

These styles affect how result graphs and tables are displayed in ACP, including in [[Embed_table_or_graph_with_ACP#Frame_nodes|Tall nodes]] and [[Embed_table_or_graph_with_ACP#Tall_nodes|˞Frame nodes]]. They provide options not (yet) available in Desktop Analytica. ACP has default settings for these. You can override these settings for the entire model. You can also set them for [[Embed_table_or_graph_with_ACP#Frame_nodes|˞Frame nodes]], which will apply to all results shown in the Frame and override the ACP and model level settings. And you can set these styles for individual variables, which will override any settings in the Model or Frame. As always, it's easiest to set the using the [[ACP Style Library]].

None of these styles apply to tab result views using the default Navigation_style: Outline.

===Show or hide the Description===

*'''<code>Show_description: n</code>''' If <code>n > 0 </code> it shows the Description of the variable above the table or graph using up to n% of the vertical space available. If that's not big enough to show the entire description, it shows a vertical scroll bar. Iif you don't want to show the description at all, set <code>n = 0</code>. Default if not mentioned, is one third, i.e. <code>Show_description: 33</code>. You can set this style at the model level for all Frame or Tall nodes, and you can override this default for any individual node.

===Show or hide the Object view icon===
*'''<code>Object_in_Frame:yes/no</code>''': With this style set, it shows an object view hover icon at the top right of a frame node or tall node when showing a graph or table view. Click this icon to show the object window view. The object view shows the Table and Graph hover icon to go back to the table or graph view. You can set '''<code>Object_in_frame</code>''' style at either the top level of the model or in an individual frame node, which overrides the top level setting. When working with tall nodes, you can set '''<code>Object_in_frame</code>''' style at the top level or in the original variable's ACP style setting, which overrides the top level setting.

===Show or hide the title===

*'''<code>Show_title</code>''': Set <code>Show_title: yes</code> to show or <code>Show_title: no</code> to stop showing the Title and units of a selected variable. This style can be used at the model level, for frame nodes or for individual nodes, but controls whether or not the Title and units show in Frame nodes or tall nodes.

===Show or hide the Graph-Table icon===

*'''<code>Show_graph_table_icon:no</code>''' Hides the icon in the top right of a Result that lets you toggle between Graph and Table view. This applies to [[Embed_table_or_graph_with_ACP|Frame nodes and tall nodes]]. This style can be used for the entire model, for frame nodes or for individual nodes . You set them in the AcpStyles attribute. Conversely, you can set '''<code>Show_graph_table_icon:yes</code>'''. This is the default so not usually necessary at the model level, but can be used in a frame node or variable to override the model default or override a frame node setting.

===Show or hide the Uncertainty view menu===
By default, in ACP, as in desktop Analytica, the [[Uncertainty views]] menu appears above each result graph or table to let you select [[Mid]] to display its deterministic value, or Mean, Probability distribution, and other ways to display a probabilistic value.

You can override this default behavior with this ACP style for the entire model, [[Embed_table_or_graph_with_ACP#Frame_nodes|Frame nodes]], or for individual variables. The Uncertainty view menu is always present in tab result views.
*'''<code>Show_uncertainty_view: No</code>''' Never show the uncertainty menu in frame nodes or tall result nodes. Suitable for models with no probabilistic values, or if you want to fix a particular probabilistic view for each frame node or variable so that ACP users can't change it.
*'''<code>Show_uncertainty_view: Yes</code>''' Always show the uncertainty menu even for variables that are not probabilistic, as in Desktop Analytica. This is the default and not normally necessary at the model level, but can be used to customize which frame nodes or variables to show the uncertainty view menu when the model level style is set to '''<code>Show_uncertainty_view: No</code>'''

===Show or hide the Index menus and Pivoters/slicers===
*'''<code>Show_index_menus: Fly-in</code>''' By default (the same as if there is no show_index_menu: setting) the index menus are not shown in [[https://wiki.analytica.com/index.php?title=Embed_table_or_graph_with_ACP|frame nodes or tall nodes]] (but slicers are), since often the modeler has already chosen the pivot they want to use. And because these menus take up valuable screen space. But if you hover over the frame node (or tall node) there is a fly-in pivoter control. If you click this it toggles - on or off - the visibility of the pivoters; allowing you to pivot the result table or graph and then close the pivoters to give you more space.
*'''<code>Show_index_menus: Yes</code>''' If you do want to allow users to be able to pivot or change the slice of the table or graph, without using the fly-in, then use use show_index_menus:yes. Always present in tab result views.
*'''<code>Show_index_menus: No</code>''' If show_index_menus:no is set then the indexes and pivoters will not show and there is no fly-in, but the slicers will still be present.
*'''<code>Show_index_menus: Not_even_slicers</code>''' If you don't want to show any pivoters or slicers, you can set show_index_menus:Not_even_slicers.

===Table filtering===
'''<code>Show_Table_Filtering: no</code>''' Turns off the ability to filter tables by column, and reverts to the previous sort functionality. [[Tables_in_ACP#Sort_columns]] 
'''<code>Show_Table_Filtering: yes</code>''' The default - shows the table filtering icons

===Show or hide the Rows and Columns pivot controls===
*'''<code>Show_row_col_header: no</code>''' -- Hides the "Rows" and "Columns" pivot controls above a result table, while still showing any slicers.
*'''<code>Show_row_col_header: yes</code>''' -- The default.

===Position of the row pivoter===
*'''<code>row_pivoter_loc: header</code>''' -- Puts the pivoter for the row index inside the top left header cell of the table itself, rather than among the pivot controls above the table. Set it for the model, or for an individual variable to move the pivoter of just that table.

===Links from table headers===
*'''<code>blue_handle_links: no</code>''' -- A row or column header whose value is a handle to an object normally appears as a blue link, and clicking it jumps to that node in its diagram. This style shows those headers as ordinary text instead. It is a model level style.

===Very large tables===
*'''<code>acp_large_table_scroll: yes</code>''' -- Turns on virtual scrolling, so that ACP fetches and renders only the cells of a table that are actually in view. This makes a very large table usable. It applies only to tables bigger than the cell limit configured on the ACP server. Set it for the model, or for an individual variable.
*'''<code>acp_max_table_size_to_show: n</code>''' -- The largest number of body cells (rows times columns) that ACP shows in a table. A bigger table is truncated. When you don't set it, the limit configured in the [[Customizing_an_ACP_server#The_acpConfig.json_file|AcpConfig.json]] file applies. This is a model level style.

===Autocalc===

In the [[ACP Style Library]], Autocalc looks like a style you can set for a model, module or variable. It controls whether ACP evaluates each variable and shows its results automatically when you view a Diagram or tab showing the -- instead of the default Analytica behavior where the end user has to click on a Calc button to compute a result. With Autocalc on, a result in view also recomputes automatically when you change an input that influences it.

Autocalc is not actually an ACPStyle in ACP3. (It was in ACP1.) Autocalc is implemented using the Desktop Analytica functionality for [[Proactive_Evaluation]].

== Node Level Settings ==

These style flags and options apply to individual nodes (variables), rather than the model as a whole. So, you set these flags on the AcpStyles for selected objects (nodes).

=== Other node level flags ===

===Date Picker===
Show a date picker for input nodes.
* '''<code>date_picker:none</code>''' [default]
* '''<code>date_picker:date</code>''' [for only date]
* '''<code>date_picker:datetime</code>''' [for date and time]

=== Prevent nodes from showing on the diagram ===

*'''<code>Show_Object: no</code>'''
You can prevent nodes or modules from showing on the diagram of your model, by adding this flag to the AcpStyles attribute of the object you wish to hide. Once the model is shown in ACP the objects aren't visible.

== Modifying ACP menus==

Normally, ACP offers menus that appear when you press one of the three icons on the right of the top teal bar. These ACP styles let you modify these menus.

===Hide the Save options===

*'''<code>Hide_save_button: yes </code>''' Set this model ACP style option to exclude the 'Save this model' and 'Save model as...' from the ACP Close menu. It prevents users from saving over your models or saving other versions.
*''This style cannot currently be set from the ACP style library, since it would allow users to show the save and save as menu options and then save changes even if the modeler does not want to allow it.''

===Remove Help menu items===

These styles add menu items to or remove items from the help (?) menu if added to the AcpStyles of the top diagram of your model. For [[ACP_Server_License|ACP installations]] on an intranet, these standard links may not be accessible. On the other hand you may want to offer a special help page for a particular model.

*'''<code>Remove_help_menu_options: Text</code>
This style allows you to list one or more of the standard options to remove from the help (?) menu. Replace <code>Text</code> with one or more of the following: <code>ACP_Online_docs, Analytica_Q_A_forum, Tech_support</code>.

(Note: The help menu item <code>Connection status</code> cannot currently be removed).

===Add Help menu item===
*'''<code>Add_help_menu_option: Text|URL</code>'''
Adds another menu item, for example: <code>Add_help_menu_option: How to use this model...|https://www.lumina.com</code> adds a menu item to the help (?) menu with the text "How to use this model..." and opens the link when clicked.

===Add download this model to the Close menu===
*'''<code>save_menu_download: yes</code>'''
This AcpStyle is controlled by a setting in the [[Customizing_an_ACP_server#The_acpConfig.json_file|AcpConfig.json]] file. On Lumina's acp.analytica.com server it is turned on.
With this AcpStyle in the model, ''<code>"download this model"</code>'' is added to the close menu at the top right of the ACP GUI.
When set, this will allow anyone to download the model - even a reviewer, and even from an email invite.
*'''<code>save_menu_download: no</code>''' (default if not set)
*'''<code>save_menu_download:Prompt_to_download_free</code>'''. This adds a popup dialog with a download link and prompt to download the Analytica free installer.
''This style cannot be set from the ACP Style library, since it would allow reviewers to change the style and download the model, even if the modeler does not want to allow that.''

==See Also==
* [[ACP Style Library]]
* [[media:ACP style library.ana]]
* [[Analytica Cloud Platform]]
* [[ACP Rendering tables and graphs on the diagram]]
* [[Putting ACP in a Web Page]]
* [[Help balloons]]
* [[Attributes]]
* [[Manage attributes]]