Fenics-ufl

- Add call operator syntax to `Form` to replace arguments and
coefficients. This makes it easier to e.g. express the norm
defined by a bilinear form as a functional. Example usage:
python
Equivalent to replace(a, {u: f, v: f})
M = a(f, f)
Equivalent to replace(a, {f:1})
c = a(coefficients={f:1})

- Add call operator syntax to `Form` to replace arguments and
coefficients:
python
a(f, g) == replace(a, {u: f, v: g})
a(coefficients={f:1}) == replace(a, {f:1})

- Add `` operator to `Form`: `form f == action(form, f)`
(python 3.5+ only)
- Reduce noise in Mesh str such that `print(form)` gets more short and
readable
- Fix repeated `split(function)` for arbitrary nested elements
- EnrichedElement: Remove `+/*` warning

In the distant past, `A + B => MixedElement([A, B])`. The change
that `A + B => EnrichedElement([A, B])` was made in `d622c74` (22
March 2010). A warning was introduced in `fcbc5ff` (26 March 2010)
that the meaning of `+` had changed, and that users wanting a
`MixedElement` should use `*` instead. People have, presumably,
been seeing this warning for 6 1/2 years by now, so it's probably safe
to remove.
- Rework `TensorProductElement` implementation, replaces
`OuterProductElement`
- Rework `TensorProductCell` implementation, replaces
`OuterProductCell`
- Remove `OuterProductVectorElement` and `OuterProductTensorElement`
- Add `FacetElement` and `InteriorElement`
- Add `Hellan-Herrmann-Johnson` element
- Add support for double covariant and contravariant mappings in mixed
elements
- Support discontinuous Taylor elements on all simplices
- Some more performance improvements
- Minor bugfixes
- Improve Python 3 support
- More permissive in integer types accepted some places
- Make ufl pass almost all flake8 tests
- Add bitbucket pipelines testing
- Improve documentation

- Add operator A^(i,j) := as_tensor(A, (i,j))
- Updates to old manual for publishing on fenics-ufl.readthedocs.org
- Bugfix for ufl files with utf-8 encoding
- Bugfix in conditional derivatives to avoid inf/nan values in generated
code. This bugfix may break ffc if uflacs is not used, to get around
that the old workaround in ufl can be enabled by setting
ufl.algorithms.apply_derivatives.CONDITIONAL_WORKAROUND = True
at the top of your program.
- Allow sum([expressions]) where expressions are nonscalar by defining expr+0==expr
- Allow form=0; form -= other;
- Deprecate .cell(), .domain(), .element() in favour of .ufl_cell(),
.ufl_domain(), .ufl_element(), in multiple classes, to allow
closer integration with dolfin.
- Remove deprecated properties cell.{d,x,n,volume,circumradius,facet_area}.
- Remove ancient form2ufl script
- Add new class Mesh to replace Domain
- Add new class FunctionSpace(mesh, element)
- Make FiniteElement classes take Cell, not Domain.
- Large reworking of symbolic geometry pipeline
- Implement symbolic Piola mappings

- Change approach to attaching __hash__ implementation to accomodate python 3
- Implement new non-recursive traversal based hash computation
- Allow derivative(M, ListTensor(<scalars>), ...) just like list/tuple works
- Add traits is_in_reference_frame, is_restriction, is_evaluation, is_differential
- Add missing linear operators to ArgumentDependencyExtractor
- Add _ufl_is_literal_ type trait
- Add _ufl_is_terminal_modifier_ type trait and Expr._ufl_terminal_modifiers_ list
- Add new types ReferenceDiv and ReferenceCurl
- Outer product element support in degree estimation
- Add TraceElement, InteriorElement, FacetElement, BrokenElement
- Add OuterProductCell to valid Real elements
- Add _cache member to form for use by external frameworks
- Add Sobolev space HEin
- Add measures dI,dO,dC for interface, overlap, cutcell
- Remove Measure constants
- Remove cell2D and cell3D
- Implement reference_value in apply_restrictions
- Rename point integral to vertex integral and kept `*dP` syntax
- Replace lambda functions in ufl_type with named functions for nicer
stack traces
- Minor bugfixes, removal of unused code and cleanups

- Require Python 2.7
- Python 3 support
- Change to py.test
- Rewrite parts of expression representation core, providing
significant optimizations in speed and memory use, as well
as a more elaborate type metadata system for internal use
- Use expr.ufl_shape instead of ufl.shape()
- Use expr.ufl_indices instead of ufl.indices(),
returns tuple of free index ids, not Index objects
- Use expr.ufl_index_dimensions instead of ufl.index_dimensions(),
returns tuple of dimensions ordered corresponding to expr.ufl_indices, not a dict
- Rewrite core algorithms for expression traversal
- Add new core algorithms map_expr_dag(), map_integrand_dag(),
similar to python map() but applying a callable MultiFunction
recursively to each Expr node, without Python recursion
- Highly recommend rewriting algorithms based on Transformer using
map_expr_dag and MultiFunction, avoiding Python recursion overhead
- Rewrite core algorithms apply_derivatives, apply_restrictions
- Form signature is now computed without applying derivatives first,
introducing smaller overhead on jit cache hits
- Use form.signature() to compute form signature
- Use form.arguments() instead of extract_arguments(form)
- Use form.coefficients() instead of extract_coefficients(form)
- Small improvement to str and latex output of expressions
- Allow diff(expr, coefficient) without wrapping coefficient in variable
- Add keywords to measures: dx(..., degree=3, rule="canonical")
- Introduce notation from the Periodic Table of the Finite Elements
- Introduce notation for FEEC families of elements: P-, P, Q-, S
- Experimental support for high-order geometric domains
- Algorithms for symbolic rewriting of geometric quantities (used by uflacs)
- Remove the *Constant* classes, using Coefficient with a Real element instead
- Add types for MinValue and MaxValue
- Disable automatic rewriting a+a->2*a, a*a->a**2, a/a->1, these are
costly and the compiler should handle them instead
- Fix signature stability w.r.t. metadata dicts
- Minor bugfixes, removal of unused code and cleanups

- New integral type custom_integral (`*dc`)
- Add analysis of which coefficients each integral actually uses to optimize assembly
- Improved svg rendering of cells and sobolevspaces in ipython notebook
- Add sobolev spaces, use notation "element in HCurl" (HCurl, HDiv, H1, H2, L2)
- Improved error checking of facet geometry in non-facet integrals
- Improved restriction handling, restricting continuous coefficients and constants is now optional
- Introduce notation from the Periodic Table of the Finite Elements (draft)
- Remove alias "Q" for quadrature element, use "Quadrature"
- New derivative type ReferenceGrad
- New discontinuous RT element
- New geometry types Jacobian, JacobianInverse, JacobianDeterminant
- New geometry types FacetJacobian, FacetJacobianInverse, FacetJacobianDeterminant
- New geometry types CellFacetJacobian, CellFacetJacobianInverse, CellFacetJacobianDeterminant
- New geometry types FacetOrigin, CellOrigin
- New geometry types CellCoordinate, FacetCoordinate
- New geometry types CellNormal, CellOrientation, QuadratureWeight
- Argument (and TestFunction, TrialFunction) now use absolute numbering f.number() instead of relative f.count()
- New syntax: integrand*dx(domain)
- New syntax: integrand*dx(1, domain=domain)
- New syntax: integrand*dx(1, subdomain_data=domain_data)
- Using domain instead of cell in many places.
- Deprecated notation 'cell.n', 'cell.x' etc.
- Recommended new notation: FacetNormal(domain)
- Experimental: Argument (and TestFunction, TrialFunction) now can have a specified part index for representing block systems
- Experimental: Domains can now be created with a Coefficient providing coordinates: Domain(Coefficient(VectorElement("CG", domain, 2)))
- Experimental: New concept Domain: domain = Domain(triangle, geometric_dimension=3, label="MyDomain")
- Various general optimizations
- Various minor bugfixes
- Various docstring improvements

- Add cell_avg and facet_avg operators, can be applied to a Coefficient or Argument or restrictions thereof
- Fix bug in cofactor: now it is transposed the correct way.
- Add cell.min_facet_edge_length
- Add cell.max_facet_edge_length
- Simplify 0^f -> 0 if f is a non-negative scalar value
- Add atan2 function
- Allow form+0 -> form