What's new in Analytica 7.0?


Analytica 7.0 will be the next major Analytica release and is currently in beta testing. Go to Beta Tester Page to try it. The current official release is Analytica 6.6.

Highlights of Analytica 7.0

  • 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: 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, 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.
  • Read and write spreadsheets without Excel: This is faster and more robust, and you don't need Excel installed.

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 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 

Index Animal := ['Cat', 'Dog']
Variable Sound := IF Animal = 'Cat' THEN 'Miaow' ELSE 'Woof'

If you change 'Cat' to 'Feline' in Index Animal, the Definition of Sound will now automatically update to 

IF Animal = 'Feline' THEN 'Miaow' ELSE 'Woof'

It does this wherever it sees Animal= 'Cat'<label>. 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 (Animal . 'Cat'). By associating the label with its index it will automatically update when needed. These 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, X, you could call it using the syntax X->(a,b,c). 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 X(a,b,c) 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 Expression 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 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 Structs, 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 'LibXl', 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 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

ADE

  • Added a new example: Mcp_server. 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.
Comments


You are not allowed to post comments.