DynamicExpressions v2.4.0

Diff since v2.3.0

Merged pull requests: - feat: get parse_expressions to work with aliases (#139) (@MilesCranmer)

- Julia
Published by github-actions[bot] 6 months ago

DynamicExpressions v2.3.0

Diff since v2.2.1

Merged pull requests: - Parse expressions without interpolation (#137) (@MilesCranmer)

- Julia
Published by github-actions[bot] 7 months ago

DynamicExpressions v2.2.1

Diff since v2.2.0

Merged pull requests: - fix: precompilation warning (#136) (@MilesCranmer)

- Julia
Published by github-actions[bot] 8 months ago

DynamicExpressions v2.2.0

Diff since v2.1.0

Merged pull requests: - feat: option to skip fused kernels (#128) (@MilesCranmer)

- Julia
Published by github-actions[bot] 8 months ago

DynamicExpressions v2.1.0

Diff since v2.0.1

Merged pull requests: - fix: default_node_type should not prescribe degree (#133) (@MilesCranmer) - test: fix issue where test eval fails due to incomplete eval (#134) (@MilesCranmer)

- Julia
Published by github-actions[bot] 8 months ago

DynamicExpressions v2.0.1

Diff since v2.0.0

Merged pull requests: - Permit n-argument operators (#127) (@MilesCranmer) - fix: recursive type inference issue (#132) (@MilesCranmer)

- Julia
Published by github-actions[bot] 8 months ago

DynamicExpressions.jl v2.0 introduces support for n-arity operators (nodes with arbitrary numbers of children), which required some breaking changes to implement. This guide will help you migrate your code from v1.x to v2.0.

Summary

Types
- Node{T} is now Node{T,D} where D is the maximum degree
- AbstractExpressionNode{T} is now AbstractExpressionNode{T,D}
- AbstractNode is now AbstractNode{D}
- Before, Node{T} had fields l::Node{T} and r::Node{T}. Now, the type is Node{T,D}, and it has the field children::NTuple{D,Nullable{Node{T,D}}}.
Accessors
- You can now access children by index with get_child(tree, i)
  - tree.l can now be written as get_child(tree, 1)
  - tree.r can now be written as get_child(tree, 2)
  - note: you can access multiple children with `getchildren(tree, Val(degree))`_
- You can now set children by index with set_child!(tree, child, i)
  - tree.l = child should now be written as set_child!(tree, child, 1)
  - tree.r = child should now be written as set_child!(tree, child, 2)
  - note: you can set multiple children with `setchildren!(tree, children)`_
Constructors
- Node{T}(; op=1, l=x) should now be written as Node{T}(; op=1, children=(x,))
- Node{T}(; op=1, l=x, r=y) should now be written as Node{T}(; op=1, children=(x, y))
- You may now use Node{T,D}(; op=1, children=(x,)) to specify degree other than the default of 2.
OperatorEnum
- OperatorEnum (and GenericOperatorEnum) now uses a single ops field: this is a tuple of tuples, indexed by arity.
  - operators.unaops is now written as operators.ops[1], and operators.binops is now written as operators.ops[2].
- OperatorEnum(binary_operators=(+, -, *), unary_operators=(sin, cos)) can now be written as OperatorEnum(2 => (+, -, *), 1 => (sin, cos))
  - This API permits higher-arity operators: OperatorEnum(1 => (sin, cos), 2 => (+, -, *), 3 => (fma, max)).

Breaking Changes

The main breaking change is that Node{T} is now Node{T,D} where D is the maximum degree of any possible node in the tree. node.degree is still the same as before, and is such that node.degree <= D.

Similarly, AbstractExpressionNode{T} is now AbstractExpressionNode{T,D}, and AbstractNode is now AbstractNode{D}.

Before, Node{T} had fields l::Node{T} and r::Node{T}. Now, it has a single combined field children::NTuple{D,Nullable{Node{T,D}}}. This is a tuple of wrapped node objects, which should be accessed with get_child(tree, i) and set with set_child!(tree, child, i). However, the old getters and setters will still function for binary trees (.l and .r).

You may now use Node{T,D}(; op=1, children=(x,)) to specify degree other than the default of 2. However, the default Node{T}(; op=1, children=(x,)) is still available and will result in type Node{T,2}.

Necessary Changes to Your Code

The main breaking change that requires some modifications is patterns that explicitly match tree.degree in conditional logic. The tree.degree == 0 branch can be left alone, but higher arity nodes should be generalized.

For code like this:

```julia

This pattern ONLY works for binary trees (degree ≤ 2)

if tree.degree == 0 # leaf node elseif tree.degree == 1
# unary operator else # tree.degree == 2 # <-- This violates the assumption in 2.0 # binary operator end ```

You have two options for upgrading

Constrain your type signatures: Use ::AbstractExpressionNode{T,2} to only accept binary trees, and refuse higher-arity nodes

julia function my_function(tree::AbstractExpressionNode{T,2}) where T if tree.degree == 0 # leaf elseif tree.degree == 1 # unary else # tree.degree == 2, guaranteed # binary end end
Rewrite your code to be more generic. (Note that for recursive algorithms, you can often do things with a `treemapreduce`, which already handles the general case._)

```julia

2: Handle arbitrary arity

function myfunction(tree::AbstractExpressionNode{T}) where T if tree.degree == 0 # leaf else # higher arity deg = tree.degree for i in 1:deg child = getchild(tree, i) # process child... end end end ```

However, normally what is done internally for max efficiency for the general approach is to use patterns like:

julia @generated function my_function(tree::AbstractExpressionNode{T,D}) where {T,D} quote deg = tree.degree deg == 0 && process_leaf(tree) Base.Cartesian.@nif( $deg, i -> i == deg, i -> let children = get_children(tree, Val(i)) # Now, `children` is a type-stable tuple of children end, ) end end

Note that the @generated is needed to pass D to the Cartesian macro.

Property Access (Non-Breaking)

Note: .l and .r property access still work and will continue to be supported on types with D == 2. However, the generic accessors are more flexible, so upgrading to them is recommended.

```julia

old_child = tree.l

oldchild = getchild(tree, 1)

tree.r = new_child

setchild!(tree, newchild, 2) ```

This lets you write code that prescribes arbitrary arity.

Node Construction (Non-Breaking)

For binary trees, you can still use the syntax:

julia x = Node{Float64}(; feature=1) tree = Node{Float64}(; op=1, children=(x,))

For higher-arity trees, you may pass D to specify the maximum degree in the tree:

julia x = Node{Float64,3}(; feature=1) y = Node{Float64,3}(; feature=2) z = Node{Float64,3}(; feature=3) tree = Node{Float64,3}(; op=1, children=(x, y, z))

OperatorEnum redesign (Non-Breaking)

OperatorEnum (and GenericOperatorEnum) now uses a single ops field: this is a tuple of tuples, indexed by arity. operators.unaops is now written as operators.ops[1], and operators.binops is now written as operators.ops[2].

However, the properties are aliased, so the old syntax will still work.

Along with this, there is a new API for constructing OperatorEnums:

```julia

operators = OperatorEnum(binaryoperators=(+, -, *), unaryoperators=(sin, cos)) # old

operators = OperatorEnum(2 => (+, -, *), 1 => (sin, cos)) ```

This API permits higher-arity operators:

julia operators = OperatorEnum(1 => (sin, cos), 2 => (+, -, *), 3 => (fma, max))

(Note that the order you pass the pairs is not important.)

Full Changelog: https://github.com/SymbolicML/DynamicExpressions.jl/compare/v1.10.3...v2.0.0

- Julia
Published by MilesCranmer 9 months ago

DynamicExpressions - v1.10.3

DynamicExpressions v1.10.3

Diff since v1.10.2

Merged pull requests: - fix: mutation error for Zygote (#130) (@MilesCranmer) - fix: move non_differentiable to special module for JET masking (#131) (@MilesCranmer)

- Julia
Published by github-actions[bot] 9 months ago

DynamicExpressions - v1.10.2

DynamicExpressions v1.10.2

Diff since v1.10.1

Merged pull requests: - CompatHelper: bump compat for Zygote in [weakdeps] to 0.7, (keep existing compat) (#119) (@github-actions[bot])

- Julia
Published by github-actions[bot] 9 months ago

DynamicExpressions - v1.10.1

DynamicExpressions v1.10.1

Diff since v1.10.0

Merged pull requests: - fix: avoid returning view for generic operators (#126) (@MilesCranmer)

- Julia
Published by github-actions[bot] 10 months ago

DynamicExpressions - v1.10.0

DynamicExpressions v1.10.0

Diff since v1.9.4

Merged pull requests: - Fix minute typo (#120) (@sunxd3) - feat: allow separate operator names for pretty printing (#122) (@MilesCranmer)

- Julia
Published by github-actions[bot] about 1 year ago

DynamicExpressions - v1.9.4

DynamicExpressions v1.9.4

Diff since v1.9.3

- Julia
Published by github-actions[bot] about 1 year ago

DynamicExpressions - v1.9.3

DynamicExpressions v1.9.3

Diff since v1.9.2

Closed issues: - Base Operator Overloading - Question (#121)

- Julia
Published by github-actions[bot] about 1 year ago

DynamicExpressions - v1.9.2

DynamicExpressions v1.9.2

Diff since v1.9.1

Merged pull requests: - Copyable buffer and eval options (#118) (@MilesCranmer)

- Julia
Published by github-actions[bot] about 1 year ago

DynamicExpressions - v1.9.1

DynamicExpressions v1.9.1

Diff since v1.9.0

Merged pull requests: - fix: missing extraction of operators in SymbolicUtils convert (#117) (@MilesCranmer)

- Julia
Published by github-actions[bot] about 1 year ago

DynamicExpressions - v1.9.0

DynamicExpressions v1.9.0

Diff since v1.8.0

Merged pull requests: - Some quality of life API updates (#116) (@MilesCranmer)

- Julia
Published by github-actions[bot] about 1 year ago

DynamicExpressions - v1.8.0

DynamicExpressions v1.8.0

Diff since v1.7.0

Merged pull requests: - Create preallocation utility functions for expressions (#114) (@MilesCranmer)

- Julia
Published by github-actions[bot] about 1 year ago

DynamicExpressions - v1.7.0

DynamicExpressions v1.7.0

Diff since v1.6.0

Merged pull requests: - Zero-allocation tree evaluation with buffer (#112) (@MilesCranmer) - in-place copy for trees (#113) (@MilesCranmer)

- Julia
Published by github-actions[bot] about 1 year ago

DynamicExpressions - v1.6.0

DynamicExpressions v1.6.0

Diff since v1.5.1

Merged pull requests: - Prettier printing for gradient operators (#111) (@MilesCranmer)

- Julia
Published by github-actions[bot] about 1 year ago

DynamicExpressions - v1.5.1

DynamicExpressions v1.5.1

Diff since v1.5.0

Merged pull requests: - fix: non-finite .val evaluation issue (#110) (@MilesCranmer)

- Julia
Published by github-actions[bot] about 1 year ago