SYMBOL INDEX (527 symbols across 59 files)

FILE: demo/BiharmonicHHJ.py
  function b (line 37) | def b(sigma, v):

FILE: demo/BiharmonicRegge.py
  function S (line 38) | def S(mu):
  function b (line 43) | def b(mu, v):

FILE: demo/test_demos.py
  function skip_unsupported (line 21) | def skip_unsupported(test):
  function test_C (line 39) | def test_C(file, scalar_type):
  function test_numba (line 83) | def test_numba(file, scalar_type):

FILE: ffcx/analysis.py
  class UFLData (line 30) | class UFLData(typing.NamedTuple):
  function analyze_ufl_objects (line 45) | def analyze_ufl_objects(
  function _analyze_expression (line 128) | def _analyze_expression(
  function _analyze_form (line 152) | def _analyze_form(form: ufl.Form, scalar_type: npt.DTypeLike) -> FormData:
  function _has_custom_integrals (line 256) | def _has_custom_integrals(

FILE: ffcx/codegeneration/C/expression.py
  function generator (line 25) | def generator(ir: ExpressionIR, options):

FILE: ffcx/codegeneration/C/file.py
  function generator (line 26) | def generator(options):

FILE: ffcx/codegeneration/C/form.py
  function generator (line 24) | def generator(ir: FormIR, options):

FILE: ffcx/codegeneration/C/formatter.py
  class Formatter (line 147) | class Formatter(FormatterInterface):
    method __init__ (line 153) | def __init__(self, dtype: npt.DTypeLike) -> None:
    method _dtype_to_name (line 158) | def _dtype_to_name(self, dtype) -> str:
    method _format_number (line 170) | def _format_number(self, x):
    method _build_initializer_lists (line 179) | def _build_initializer_lists(self, values):
    method __call__ (line 190) | def __call__(self, obj: L.LNode) -> str:
    method _ (line 195) | def _(self, slist: L.StatementList) -> str:
    method _ (line 200) | def _(self, section: L.Section) -> str:
    method _ (line 222) | def _(self, c: L.Comment) -> str:
    method _ (line 227) | def _(self, arr: L.ArrayDecl) -> str:
    method _ (line 243) | def _(self, arr: L.ArrayAccess) -> str:
    method _ (line 250) | def _(self, v: L.VariableDecl) -> str:
    method _ (line 258) | def _(self, oper: L.NaryOp) -> str:
    method _ (line 272) | def _(self, oper: L.BinOp) -> str:
    method _ (line 289) | def _(self, oper: L.Neg | L.Not) -> str:
    method _ (line 297) | def _(self, val: L.LiteralFloat) -> str:
    method _ (line 303) | def _(self, val: L.LiteralInt) -> str:
    method _ (line 308) | def _(self, r: L.ForRange) -> str:
    method _ (line 323) | def _(self, s: L.Statement) -> str:
    method _ (line 329) | def _(self, expr: L.Assign | L.AssignAdd) -> str:
    method _ (line 336) | def _(self, s: L.Conditional) -> str:
    method _ (line 355) | def _(self, s: L.Symbol) -> str:
    method _ (line 360) | def _(self, mi: L.MultiIndex) -> str:
    method _ (line 365) | def _(self, c: L.MathFunction) -> str:

FILE: ffcx/codegeneration/C/integral.py
  function generator (line 25) | def generator(

FILE: ffcx/codegeneration/__init__.py
  function get_include_path (line 16) | def get_include_path():
  function _compute_signature (line 21) | def _compute_signature():
  function get_signature (line 32) | def get_signature():

FILE: ffcx/codegeneration/access.py
  class FFCXBackendAccess (line 23) | class FFCXBackendAccess:
    method __init__ (line 28) | def __init__(self, entity_type: entity_types, integral_type: str, symb...
    method get (line 59) | def get(
    method coefficient (line 81) | def coefficient(
    method constant (line 106) | def constant(
    method spatial_coordinate (line 117) | def spatial_coordinate(
    method cell_coordinate (line 148) | def cell_coordinate(self, mt, tabledata, num_points):
    method facet_coordinate (line 174) | def facet_coordinate(self, mt, tabledata, num_points):
    method jacobian (line 210) | def jacobian(self, mt, tabledata, num_points):
    method reference_cell_volume (line 216) | def reference_cell_volume(self, mt, tabledata, access):
    method reference_facet_volume (line 224) | def reference_facet_volume(self, mt, tabledata, access):
    method reference_normal (line 232) | def reference_normal(self, mt, tabledata, access):
    method cell_facet_jacobian (line 242) | def cell_facet_jacobian(self, mt, tabledata, num_points):
    method cell_ridge_jacobian (line 261) | def cell_ridge_jacobian(self, mt, tabledata, num_points):
    method reference_cell_edge_vectors (line 273) | def reference_cell_edge_vectors(self, mt, tabledata, num_points):
    method reference_facet_edge_vectors (line 286) | def reference_facet_edge_vectors(self, mt, tabledata, num_points):
    method facet_orientation (line 300) | def facet_orientation(self, mt, tabledata, num_points):
    method cell_vertices (line 310) | def cell_vertices(self, mt, tabledata, num_points):
    method cell_edge_vectors (line 334) | def cell_edge_vectors(self, mt, tabledata, num_points):
    method facet_edge_vectors (line 374) | def facet_edge_vectors(self, mt, tabledata, num_points):
    method _pass (line 419) | def _pass(self, *args, **kwargs):
    method table_access (line 423) | def table_access(

FILE: ffcx/codegeneration/backend.py
  class FFCXBackend (line 16) | class FFCXBackend:
    method __init__ (line 19) | def __init__(self, ir: IntegralIR | ExpressionIR, options):

FILE: ffcx/codegeneration/codegeneration.py
  class CodeBlocks (line 27) | class CodeBlocks(typing.NamedTuple):
  function generate_code (line 41) | def generate_code(

FILE: ffcx/codegeneration/common.py
  function template_keys (line 19) | def template_keys(template: str) -> set[str]:
  class IntegralData (line 24) | class IntegralData(NamedTuple):
  function integral_data (line 33) | def integral_data(ir: FormIR) -> IntegralData:
  class KernelTensorSizes (line 51) | class KernelTensorSizes(NamedTuple):
  function tensor_sizes (line 63) | def tensor_sizes(ir: IntegralIR | ExpressionIR) -> KernelTensorSizes:
  function _ (line 69) | def _(ir: IntegralIR) -> KernelTensorSizes:
  function _ (line 85) | def _(ir: ExpressionIR) -> KernelTensorSizes:

FILE: ffcx/codegeneration/definitions.py
  function create_quadrature_index (line 21) | def create_quadrature_index(quadrature_rule, quadrature_index_symbol):
  function create_dof_index (line 36) | def create_dof_index(tabledata, dof_index_symbol):
  class FFCXBackendDefinitions (line 50) | class FFCXBackendDefinitions:
    method __init__ (line 55) | def __init__(self, entity_type: entity_types, integral_type: str, acce...
    method symbols (line 84) | def symbols(self):
    method get (line 88) | def get(
    method coefficient (line 113) | def coefficient(
    method _define_coordinate_dofs_lincomb (line 173) | def _define_coordinate_dofs_lincomb(
    method spatial_coordinate (line 229) | def spatial_coordinate(
    method jacobian (line 255) | def jacobian(
    method pass_through (line 265) | def pass_through(

FILE: ffcx/codegeneration/expression_generator.py
  class ExpressionGenerator (line 24) | class ExpressionGenerator:
    method __init__ (line 27) | def __init__(self, ir: ExpressionIR, backend: FFCXBackend):
    method generate (line 40) | def generate(self):
    method generate_geometry_tables (line 62) | def generate_geometry_tables(self):
    method generate_element_tables (line 96) | def generate_element_tables(self):
    method generate_quadrature_loop (line 120) | def generate_quadrature_loop(self):
    method generate_varying_partition (line 146) | def generate_varying_partition(self):
    method generate_piecewise_partition (line 159) | def generate_piecewise_partition(self):
    method generate_dofblock_partition (line 172) | def generate_dofblock_partition(self):
    method generate_block_parts (line 199) | def generate_block_parts(self, blockmap, blockdata):
    method get_arg_factors (line 288) | def get_arg_factors(self, blockdata, block_rank, indices):
    method new_temp_symbol (line 317) | def new_temp_symbol(self, basename):
    method get_var (line 323) | def get_var(self, v):
    method generate_partition (line 330) | def generate_partition(self, symbol, F, mode):

FILE: ffcx/codegeneration/geometry.py
  function write_table (line 14) | def write_table(tablename, cellname):
  function facet_edge_vertices (line 37) | def facet_edge_vertices(tablename, cellname):
  function cell_facet_jacobian (line 61) | def cell_facet_jacobian(tablename, cellname):
  function cell_ridge_jacobian (line 69) | def cell_ridge_jacobian(tablename, cellname):
  function reference_cell_volume (line 77) | def reference_cell_volume(tablename, cellname):
  function reference_facet_volume (line 85) | def reference_facet_volume(tablename, cellname):
  function reference_cell_edge_vectors (line 96) | def reference_cell_edge_vectors(tablename, cellname):
  function reference_facet_edge_vectors (line 107) | def reference_facet_edge_vectors(tablename, cellname):
  function reference_normals (line 134) | def reference_normals(tablename, cellname):
  function facet_orientation (line 142) | def facet_orientation(tablename, cellname):

FILE: ffcx/codegeneration/integral_generator.py
  function extract_dtype (line 30) | def extract_dtype(v, vops: list[Any]):
  class IntegralGenerator (line 51) | class IntegralGenerator:
    method __init__ (line 54) | def __init__(self, ir: IntegralIR, backend):
    method init_scopes (line 79) | def init_scopes(self):
    method set_var (line 87) | def set_var(self, quadrature_rule, domain, v, vaccess):
    method get_var (line 101) | def get_var(self, quadrature_rule, domain, v):
    method new_temp_symbol (line 123) | def new_temp_symbol(self, basename):
    method get_temp_symbol (line 129) | def get_temp_symbol(self, tempname, key):
    method generate (line 139) | def generate(self, domain: basix.CellType):
    method generate_quadrature_tables (line 185) | def generate_quadrature_tables(self, domain: basix.CellType, expressio...
    method generate_geometry_tables (line 204) | def generate_geometry_tables(self):
    method generate_element_tables (line 236) | def generate_element_tables(self, domain: basix.CellType):
    method declare_table (line 265) | def declare_table(self, name, table):
    method generate_quadrature_loop (line 276) | def generate_quadrature_loop(self, quadrature_rule: QuadratureRule, do...
    method generate_piecewise_partition (line 309) | def generate_piecewise_partition(self, quadrature_rule, domain: basix....
    method generate_varying_partition (line 316) | def generate_varying_partition(self, quadrature_rule, domain: basix.Ce...
    method generate_partition (line 323) | def generate_partition(self, symbol, F, mode, quadrature_rule, domain):
    method generate_dofblock_partition (line 370) | def generate_dofblock_partition(
    method get_arg_factors (line 415) | def get_arg_factors(self, blockdata, block_rank, quadrature_rule, doma...
    method generate_block_parts (line 446) | def generate_block_parts(

FILE: ffcx/codegeneration/interface.py
  class Formatter (line 22) | class Formatter(Protocol):
    method __init__ (line 25) | def __init__(self, dtype: npt.DTypeLike) -> None:
    method __call__ (line 29) | def __call__(self, obj: L.LNode) -> str:

FILE: ffcx/codegeneration/jit.py
  function _compute_option_signature (line 81) | def _compute_option_signature(options):
  function get_cached_module (line 86) | def get_cached_module(module_name, object_names, cache_dir, timeout):
  function _compilation_signature (line 128) | def _compilation_signature(cffi_extra_compile_args, cffi_debug):
  function compile_forms (line 152) | def compile_forms(
  function compile_expressions (line 250) | def compile_expressions(
  function _compile_objects (line 330) | def _compile_objects(
  function _load_objects (line 421) | def _load_objects(cache_dir, module_name, object_names):

FILE: ffcx/codegeneration/lnodes.py
  class PRECEDENCE (line 34) | class PRECEDENCE:
  function is_zero_lexpr (line 64) | def is_zero_lexpr(lexpr):
  function is_one_lexpr (line 71) | def is_one_lexpr(lexpr):
  function is_negative_one_lexpr (line 78) | def is_negative_one_lexpr(lexpr):
  function float_product (line 85) | def float_product(factors):
  class DataType (line 99) | class DataType(Enum):
  function merge_dtypes (line 113) | def merge_dtypes(dtypes: list[DataType]):
  class LNode (line 129) | class LNode:
    method __eq__ (line 132) | def __eq__(self, other):
    method __ne__ (line 136) | def __ne__(self, other):
  class LExpr (line 141) | class LExpr(LNode):
    method __getitem__ (line 149) | def __getitem__(self, indices):
    method __neg__ (line 153) | def __neg__(self):
    method __add__ (line 161) | def __add__(self, other):
    method __radd__ (line 172) | def __radd__(self, other):
    method __sub__ (line 183) | def __sub__(self, other):
    method __rsub__ (line 196) | def __rsub__(self, other):
    method __mul__ (line 207) | def __mul__(self, other):
    method __rmul__ (line 226) | def __rmul__(self, other):
    method __div__ (line 243) | def __div__(self, other):
    method __rdiv__ (line 252) | def __rdiv__(self, other):
  class LExprOperator (line 268) | class LExprOperator(LExpr):
  class LExprTerminal (line 276) | class LExprTerminal(LExpr):
  class LiteralFloat (line 284) | class LiteralFloat(LExprTerminal):
    method __init__ (line 291) | def __init__(self, value):
    method __eq__ (line 300) | def __eq__(self, other):
    method __float__ (line 304) | def __float__(self):
    method __repr__ (line 308) | def __repr__(self):
  class LiteralInt (line 313) | class LiteralInt(LExprTerminal):
    method __init__ (line 318) | def __init__(self, value):
    method __eq__ (line 324) | def __eq__(self, other):
    method __hash__ (line 328) | def __hash__(self):
    method __repr__ (line 332) | def __repr__(self):
  class Symbol (line 337) | class Symbol(LExprTerminal):
    method __init__ (line 342) | def __init__(self, name: str, dtype):
    method __eq__ (line 349) | def __eq__(self, other):
    method __hash__ (line 353) | def __hash__(self):
    method __repr__ (line 357) | def __repr__(self):
  class MultiIndex (line 362) | class MultiIndex(LExpr):
    method __init__ (line 367) | def __init__(self, symbols: list, sizes: list):
    method dim (line 383) | def dim(self):
    method size (line 387) | def size(self):
    method local_index (line 391) | def local_index(self, idx):
    method intersection (line 396) | def intersection(self, other):
    method union (line 408) | def union(self, other):
    method difference (line 425) | def difference(self, other):
    method __hash__ (line 435) | def __hash__(self):
  class PrefixUnaryOp (line 440) | class PrefixUnaryOp(LExprOperator):
    method __init__ (line 443) | def __init__(self, arg):
    method __eq__ (line 447) | def __eq__(self, other):
  class BinOp (line 452) | class BinOp(LExprOperator):
    method __init__ (line 457) | def __init__(self, lhs, rhs):
    method __eq__ (line 462) | def __eq__(self, other):
    method __hash__ (line 466) | def __hash__(self):
    method __repr__ (line 470) | def __repr__(self):
  class ArithmeticBinOp (line 475) | class ArithmeticBinOp(BinOp):
    method __init__ (line 478) | def __init__(self, lhs, rhs):
  class NaryOp (line 485) | class NaryOp(LExprOperator):
    method __init__ (line 490) | def __init__(self, args):
    method __eq__ (line 497) | def __eq__(self, other):
    method __repr__ (line 505) | def __repr__(self) -> str:
    method __hash__ (line 509) | def __hash__(self):
  class Neg (line 514) | class Neg(PrefixUnaryOp):
    method __init__ (line 520) | def __init__(self, arg):
  class Not (line 526) | class Not(PrefixUnaryOp):
  class Add (line 533) | class Add(ArithmeticBinOp):
  class Sub (line 540) | class Sub(ArithmeticBinOp):
  class Mul (line 547) | class Mul(ArithmeticBinOp):
  class Div (line 554) | class Div(ArithmeticBinOp):
  class EQ (line 561) | class EQ(BinOp):
  class NE (line 568) | class NE(BinOp):
  class LT (line 575) | class LT(BinOp):
  class GT (line 582) | class GT(BinOp):
  class LE (line 589) | class LE(BinOp):
  class GE (line 596) | class GE(BinOp):
  class And (line 603) | class And(BinOp):
  class Or (line 610) | class Or(BinOp):
  class Sum (line 617) | class Sum(NaryOp):
  class Product (line 624) | class Product(NaryOp):
  class MathFunction (line 631) | class MathFunction(LExprOperator):
    method __init__ (line 636) | def __init__(self, func, args):
    method __eq__ (line 642) | def __eq__(self, other):
  class AssignOp (line 652) | class AssignOp(BinOp):
    method __init__ (line 658) | def __init__(self, lhs, rhs):
  class Assign (line 664) | class Assign(AssignOp):
  class AssignAdd (line 670) | class AssignAdd(AssignOp):
  class AssignSub (line 676) | class AssignSub(AssignOp):
  class AssignMul (line 682) | class AssignMul(AssignOp):
  class AssignDiv (line 688) | class AssignDiv(AssignOp):
  class ArrayAccess (line 694) | class ArrayAccess(LExprOperator):
    method __init__ (line 699) | def __init__(self, array, indices):
    method __getitem__ (line 731) | def __getitem__(self, indices):
    method __eq__ (line 739) | def __eq__(self, other):
    method __hash__ (line 747) | def __hash__(self):
    method __repr__ (line 751) | def __repr__(self):
  class Conditional (line 756) | class Conditional(LExprOperator):
    method __init__ (line 761) | def __init__(self, condition, true, false):
    method __eq__ (line 768) | def __eq__(self, other):
  function as_lexpr (line 778) | def as_lexpr(node):
  class Statement (line 794) | class Statement(LNode):
    method __init__ (line 797) | def __init__(self, expr):
    method __eq__ (line 801) | def __eq__(self, other):
    method __hash__ (line 805) | def __hash__(self) -> int:
  function as_statement (line 810) | def as_statement(node):
  class Annotation (line 840) | class Annotation(Enum):
  class Declaration (line 849) | class Declaration(Statement):
    method __init__ (line 852) | def __init__(self, symbol):
    method __eq__ (line 856) | def __eq__(self, other):
  function is_declaration (line 861) | def is_declaration(node) -> bool:
  class Section (line 866) | class Section(LNode):
    method __init__ (line 869) | def __init__(
    method __eq__ (line 891) | def __eq__(self, other):
  class StatementList (line 899) | class StatementList(LNode):
    method __init__ (line 902) | def __init__(self, statements):
    method __eq__ (line 906) | def __eq__(self, other):
    method __hash__ (line 910) | def __hash__(self) -> int:
    method __repr__ (line 914) | def __repr__(self):
  class Comment (line 919) | class Comment(Statement):
    method __init__ (line 922) | def __init__(self, comment: str):
    method __eq__ (line 927) | def __eq__(self, other):
  function commented_code_list (line 932) | def commented_code_list(code, comments):
  class VariableDecl (line 948) | class VariableDecl(Declaration):
    method __init__ (line 951) | def __init__(self, symbol, value=None):
    method __eq__ (line 961) | def __eq__(self, other):
  class ArrayDecl (line 971) | class ArrayDecl(Declaration):
    method __init__ (line 982) | def __init__(self, symbol, sizes=None, values=None, const=False):
    method __eq__ (line 1007) | def __eq__(self, other):
    method __hash__ (line 1014) | def __hash__(self) -> int:
  function is_simple_inner_loop (line 1019) | def is_simple_inner_loop(code):
  function depth (line 1028) | def depth(code) -> int:
  class ForRange (line 1037) | class ForRange(Statement):
    method __init__ (line 1040) | def __init__(self, index, begin, end, body):
    method as_tuple (line 1049) | def as_tuple(self):
    method __eq__ (line 1053) | def __eq__(self, other):
    method __hash__ (line 1060) | def __hash__(self) -> int:
  function _math_function (line 1065) | def _math_function(op, *args):
  function ufl_to_lnodes (line 1125) | def ufl_to_lnodes(operator, *args):
  function create_nested_for_loops (line 1134) | def create_nested_for_loops(indices: list[MultiIndex], body):

FILE: ffcx/codegeneration/numba/expression.py
  function generator (line 23) | def generator(ir: ExpressionIR, options: dict[str, int | float | npt.DTy...

FILE: ffcx/codegeneration/numba/file.py
  function generator (line 28) | def generator(

FILE: ffcx/codegeneration/numba/form.py
  function generator (line 22) | def generator(ir: FormIR, options: dict[str, int | float | npt.DTypeLike...

FILE: ffcx/codegeneration/numba/formatter.py
  function build_initializer_lists (line 18) | def build_initializer_lists(values: npt.NDArray) -> str:
  class Formatter (line 29) | class Formatter(FormatterInterface):
    method __init__ (line 35) | def __init__(self, dtype: npt.DTypeLike) -> None:
    method _dtype_to_name (line 40) | def _dtype_to_name(self, dtype: L.DataType) -> str:
    method __call__ (line 53) | def __call__(self, obj: L.LNode) -> str:
    method _ (line 58) | def _(self, section: L.Section) -> str:
    method _ (line 77) | def _(self, slist: L.StatementList) -> str:
    method _format_comment_str (line 81) | def _format_comment_str(self, comment: str) -> str:
    method _ (line 86) | def _(self, c: L.Comment) -> str:
    method _ (line 91) | def _(self, arr: L.ArrayDecl) -> str:
    method _ (line 106) | def _(self, arr: L.ArrayAccess) -> str:
    method _ (line 113) | def _(self, index: L.MultiIndex) -> str:
    method _ (line 118) | def _(self, v: L.VariableDecl) -> str:
    method _ (line 125) | def _(self, oper: L.NaryOp) -> str:
    method _ (line 139) | def _(self, oper: L.BinOp) -> str:
    method _ (line 156) | def _(self, oper: L.Not | L.Neg) -> str:
    method _ (line 165) | def _(self, oper: L.And | L.Or) -> str:
    method _ (line 183) | def _(self, val: L.LiteralFloat) -> str:
    method _ (line 188) | def _(self, val: L.LiteralInt) -> str:
    method _ (line 193) | def _(self, r: L.ForRange) -> str:
    method _ (line 205) | def _(self, s: L.Statement) -> str:
    method _ (line 211) | def _(self, expr: L.Assign | L.AssignAdd) -> str:
    method _ (line 218) | def _(self, s: L.Conditional) -> str:
    method _ (line 237) | def _(self, s: L.Symbol) -> str:
    method _ (line 242) | def _(self, f: L.MathFunction) -> str:

FILE: ffcx/codegeneration/numba/integral.py
  function generator (line 24) | def generator(

FILE: ffcx/codegeneration/optimizer.py
  function optimize (line 9) | def optimize(code: list[L.LNode], quadrature_rule: QuadratureRule) -> li...
  function fuse_sections (line 33) | def fuse_sections(code: list[L.LNode], name: str) -> list[L.LNode]:
  function fuse_loops (line 77) | def fuse_loops(code: L.Section) -> L.Section:
  function get_statements (line 101) | def get_statements(statement: L.Statement | L.StatementList) -> list[L.L...
  function check_dependency (line 116) | def check_dependency(statement: L.Statement, index: L.Symbol) -> bool:
  function licm (line 144) | def licm(section: L.Section, quadrature_rule: QuadratureRule) -> L.Section:

FILE: ffcx/codegeneration/symbols.py
  function ufcx_restriction_postfix (line 18) | def ufcx_restriction_postfix(restriction):
  function format_mt_name (line 30) | def format_mt_name(basename, mt):
  class FFCXBackendSymbols (line 65) | class FFCXBackendSymbols:
    method __init__ (line 68) | def __init__(self, coefficient_numbering, coefficient_offsets, origina...
    method entity (line 99) | def entity(self, entity_type: entity_types, restriction):
    method argument_loop_index (line 117) | def argument_loop_index(self, iarg):
    method weights_table (line 122) | def weights_table(self, quadrature_rule):
    method points_table (line 131) | def points_table(self, quadrature_rule):
    method x_component (line 135) | def x_component(self, mt):
    method J_component (line 139) | def J_component(self, mt):
    method domain_dof_access (line 146) | def domain_dof_access(self, dof, component, gdim, num_scalar_dofs, res...
    method coefficient_dof_access (line 154) | def coefficient_dof_access(self, coefficient, dof_index):
    method coefficient_dof_access_blocked (line 160) | def coefficient_dof_access_blocked(
    method coefficient_value (line 171) | def coefficient_value(self, mt):
    method constant_index_access (line 176) | def constant_index_access(self, constant, index):
    method element_table (line 183) | def element_table(self, tabledata, entity_type: entity_types, restrict...

FILE: ffcx/codegeneration/ufcx.h
  type ufcx_integral_type (line 48) | typedef enum
  type ufcx_integral (line 134) | typedef struct ufcx_integral
  type ufcx_expression (line 151) | typedef struct ufcx_expression
  type ufcx_form (line 220) | typedef struct ufcx_form

FILE: ffcx/codegeneration/utils.py
  function dtype_to_c_type (line 17) | def dtype_to_c_type(dtype: npt.DTypeLike | str) -> str:
  function dtype_to_scalar_dtype (line 43) | def dtype_to_scalar_dtype(dtype: npt.DTypeLike | str) -> np.dtype:
  function numba_ufcx_kernel_signature (line 62) | def numba_ufcx_kernel_signature(dtype: npt.DTypeLike, xdtype: npt.DTypeL...
  function empty_void_pointer (line 95) | def empty_void_pointer(typingctx):
  function get_void_pointer (line 116) | def get_void_pointer(typingctx, arr):

FILE: ffcx/compiler.py
  function _print_timing (line 82) | def _print_timing(stage: int, timing: float) -> None:
  function compile_ufl_objects (line 86) | def compile_ufl_objects(

FILE: ffcx/element_interface.py
  function basix_index (line 15) | def basix_index(indices: tuple[int]) -> int:
  function create_quadrature (line 20) | def create_quadrature(
  function reference_cell_vertices (line 36) | def reference_cell_vertices(cellname: str) -> npt.NDArray[np.float64]:
  function map_facet_points (line 41) | def map_facet_points(
  function map_edge_points (line 57) | def map_edge_points(

FILE: ffcx/formatting.py
  function format_code (line 23) | def format_code(code_blocks: CodeBlocks) -> list[str]:
  function write_code (line 41) | def write_code(code: list[str], prefix: str, suffixes: tuple[str, ...], ...

FILE: ffcx/ir/analysis/factorization.py
  function build_argument_indices (line 20) | def build_argument_indices(S):
  function graph_insert (line 41) | def graph_insert(F, expr):
  function handler (line 56) | def handler(v, fac, sf, F):
  function handle_sum (line 69) | def handle_sum(v, fac, sf, F):
  function handle_product (line 105) | def handle_product(v, fac, sf, F):
  function handle_conj (line 145) | def handle_conj(v, fac, sf, F):
  function handle_division (line 160) | def handle_division(v, fac, sf, F):
  function handle_conditional (line 181) | def handle_conditional(v, fac, sf, F):
  function compute_argument_factorization (line 218) | def compute_argument_factorization(S, rank):

FILE: ffcx/ir/analysis/graph.py
  class ExpressionGraph (line 20) | class ExpressionGraph:
    method __init__ (line 27) | def __init__(self):
    method number_of_nodes (line 35) | def number_of_nodes(self):
    method add_node (line 39) | def add_node(self, key, **kwargs):
    method add_edge (line 45) | def add_edge(self, node1, node2):
  function build_graph_vertices (line 54) | def build_graph_vertices(expressions, skip_terminal_modifiers=False) -> ...
  function build_scalar_graph (line 77) | def build_scalar_graph(expression) -> ExpressionGraph:
  function rebuild_with_scalar_subexpressions (line 107) | def rebuild_with_scalar_subexpressions(G):
  function _count_nodes_with_unique_post_traversal (line 208) | def _count_nodes_with_unique_post_traversal(expressions, skip_terminal_m...

FILE: ffcx/ir/analysis/indexing.py
  function map_indexed_arg_components (line 14) | def map_indexed_arg_components(indexed):
  function map_component_tensor_arg_components (line 87) | def map_component_tensor_arg_components(tensor):

FILE: ffcx/ir/analysis/modified_terminals.py
  class ModifiedTerminal (line 29) | class ModifiedTerminal:
    method __init__ (line 32) | def __init__(
    method as_tuple (line 90) | def as_tuple(self):
    method argument_ordering_key (line 108) | def argument_ordering_key(self):
    method __hash__ (line 130) | def __hash__(self):
    method __eq__ (line 134) | def __eq__(self, other):
    method __str__ (line 138) | def __str__(self):
  function is_modified_terminal (line 150) | def is_modified_terminal(v):
  function strip_modified_terminal (line 160) | def strip_modified_terminal(v):
  function analyse_modified_terminal (line 170) | def analyse_modified_terminal(expr):

FILE: ffcx/ir/analysis/reconstruct.py
  function handle_scalar_nary (line 11) | def handle_scalar_nary(o, ops):
  function handle_condition (line 19) | def handle_condition(o, ops):
  function handle_conditional (line 26) | def handle_conditional(o, ops):
  function handle_elementwise_unary (line 41) | def handle_elementwise_unary(o, ops):
  function handle_division (line 48) | def handle_division(o, ops):
  function handle_sum (line 58) | def handle_sum(o, ops):
  function handle_product (line 67) | def handle_product(o, ops):
  function handle_index_sum (line 115) | def handle_index_sum(o, ops):
  function reconstruct (line 173) | def reconstruct(o, *args):

FILE: ffcx/ir/analysis/valuenumbering.py
  class ValueNumberer (line 22) | class ValueNumberer:
    method __init__ (line 30) | def __init__(self, G):
    method new_symbols (line 51) | def new_symbols(self, n):
    method new_symbol (line 58) | def new_symbol(self):
    method get_node_symbols (line 64) | def get_node_symbols(self, expr):
    method compute_symbols (line 69) | def compute_symbols(self):
    method expr (line 93) | def expr(self, v):
    method form_argument (line 98) | def form_argument(self, v):
    method _modified_terminal (line 125) | def _modified_terminal(self, v):
    method indexed (line 198) | def indexed(self, Aii):
    method component_tensor (line 214) | def component_tensor(self, A):
    method list_tensor (line 227) | def list_tensor(self, v):
    method variable (line 234) | def variable(self, v):

FILE: ffcx/ir/analysis/visualise.py
  function visualise_graph (line 22) | def visualise_graph(Gx, filename):

FILE: ffcx/ir/elementtables.py
  class ModifiedTerminalElement (line 46) | class ModifiedTerminalElement(typing.NamedTuple):
  class UniqueTableReferenceT (line 55) | class UniqueTableReferenceT(typing.NamedTuple):
    method has_tensor_factorisation (line 72) | def has_tensor_factorisation(self):
    method is_piecewise (line 77) | def is_piecewise(self) -> bool:
    method is_uniform (line 82) | def is_uniform(self) -> bool:
  function equal_tables (line 87) | def equal_tables(a, b, rtol=default_rtol, atol=default_atol):
  function clamp_table_small_numbers (line 97) | def clamp_table_small_numbers(
  function get_ffcx_table_values (line 108) | def get_ffcx_table_values(
  function generate_psi_table_name (line 211) | def generate_psi_table_name(
  function get_modified_terminal_element (line 247) | def get_modified_terminal_element(mt) -> ModifiedTerminalElement | None:
  function permute_quadrature_interval (line 311) | def permute_quadrature_interval(points, reflections=0):
  function permute_quadrature_triangle (line 323) | def permute_quadrature_triangle(points, reflections=0, rotations=0):
  function permute_quadrature_quadrilateral (line 337) | def permute_quadrature_quadrilateral(points, reflections=0, rotations=0):
  function build_optimized_tables (line 351) | def build_optimized_tables(
  function is_zeros_table (line 656) | def is_zeros_table(table, rtol=default_rtol, atol=default_atol):
  function is_ones_table (line 663) | def is_ones_table(table, rtol=default_rtol, atol=default_atol):
  function is_quadrature_table (line 668) | def is_quadrature_table(table, rtol=default_rtol, atol=default_atol):
  function is_permuted_table (line 677) | def is_permuted_table(table, rtol=default_rtol, atol=default_atol):
  function is_piecewise_table (line 685) | def is_piecewise_table(table, rtol=default_rtol, atol=default_atol):
  function is_uniform_table (line 693) | def is_uniform_table(table, rtol=default_rtol, atol=default_atol):
  function analyse_table_type (line 701) | def analyse_table_type(table, rtol=default_rtol, atol=default_atol):

FILE: ffcx/ir/integral.py
  class TensorPart (line 43) | class TensorPart(Enum):
    method from_str (line 50) | def from_str(cls, value: str):
    method __str__ (line 59) | def __str__(self) -> str:
    method __int__ (line 68) | def __int__(self) -> int:
  class ModifiedArgumentDataT (line 73) | class ModifiedArgumentDataT(typing.NamedTuple):
  class BlockDataT (line 80) | class BlockDataT(typing.NamedTuple):
  class IntermediateIntegrandIR (line 94) | class IntermediateIntegrandIR(typing.TypedDict):
  class IntermediateIntegralIR (line 102) | class IntermediateIntegralIR(typing.TypedDict):
  class CommonExpressionIR (line 111) | class CommonExpressionIR(typing.NamedTuple):
  function _compute_integral_ir (line 135) | def _compute_integral_ir(
  function compute_integral_ir (line 387) | def compute_integral_ir(
  function analyse_dependencies (line 467) | def analyse_dependencies(F, mt_unique_table_reference):
  function replace_quadratureweight (line 524) | def replace_quadratureweight(expression):

FILE: ffcx/ir/representation.py
  function basix_cell_from_string (line 49) | def basix_cell_from_string(string: str) -> basix.CellType:
  class FormIR (line 73) | class FormIR(typing.NamedTuple):
  class QuadratureIR (line 94) | class QuadratureIR(typing.NamedTuple):
  class IntegralIR (line 102) | class IntegralIR(typing.NamedTuple):
  class ExpressionIR (line 111) | class ExpressionIR(typing.NamedTuple):
  class DataIR (line 121) | class DataIR(typing.NamedTuple):
  function _group_integrands_by_quadrature_rule (line 129) | def _group_integrands_by_quadrature_rule(
  function compute_ir (line 231) | def compute_ir(
  function _compute_integral_ir (line 311) | def _compute_integral_ir(
  function _compute_form_ir (line 490) | def _compute_form_ir(
  function _compute_expression_ir (line 574) | def _compute_expression_ir(

FILE: ffcx/ir/representationutils.py
  class QuadratureRule (line 25) | class QuadratureRule:
    method __init__ (line 28) | def __init__(self, points, weights, tensor_factors=None):
    method __hash__ (line 36) | def __hash__(self):
    method __eq__ (line 43) | def __eq__(self, other):
    method id (line 47) | def id(self):
  function create_quadrature_points_and_weights (line 57) | def create_quadrature_points_and_weights(
  function integral_type_to_entity_dim (line 112) | def integral_type_to_entity_dim(integral_type, tdim):
  function map_integral_points (line 131) | def map_integral_points(points, integral_type, cell, entity):

FILE: ffcx/main.py
  function main (line 78) | def main(args: Sequence[str] | None = None) -> int:

FILE: ffcx/naming.py
  function compute_signature (line 22) | def compute_signature(
  function integral_name (line 84) | def integral_name(
  function form_name (line 96) | def form_name(original_form: ufl.form.Form, form_id: int, prefix: str) -...
  function expression_name (line 102) | def expression_name(

FILE: ffcx/options.py
  function _load_options (line 55) | def _load_options() -> tuple[dict, dict]:
  function get_options (line 76) | def get_options(
  function get_language (line 128) | def get_language(options: dict[str, int | float | npt.DTypeLike]) -> str:

FILE: test/conftest.py
  function compile_args (line 14) | def compile_args():

FILE: test/test_add_mode.py
  function test_additive_facet_integral (line 41) | def test_additive_facet_integral(dtype, compile_args):
  function test_additive_cell_integral (line 117) | def test_additive_cell_integral(dtype, compile_args):

FILE: test/test_cache.py
  function test_cache_modes (line 15) | def test_cache_modes(compile_args):

FILE: test/test_cmdline.py
  function test_cmdline_simple (line 14) | def test_cmdline_simple():
  function test_visualise (line 22) | def test_visualise():

FILE: test/test_custom_data.py
  function test_tabulate_tensor_integral_add_values (line 11) | def test_tabulate_tensor_integral_add_values():

FILE: test/test_jit_expression.py
  function test_matvec (line 17) | def test_matvec(compile_args):
  function test_rank1 (line 88) | def test_rank1(compile_args):
  function test_elimiate_zero_tables_tensor (line 158) | def test_elimiate_zero_tables_tensor(compile_args):
  function test_grad_constant (line 224) | def test_grad_constant(compile_args):
  function test_facet_expression (line 273) | def test_facet_expression(compile_args):
  function test_facet_geometry_expressions (line 335) | def test_facet_geometry_expressions(compile_args):
  function test_facet_geometry_expressions_3D (line 402) | def test_facet_geometry_expressions_3D(compile_args):
  function test_coordinate_free_expression (line 444) | def test_coordinate_free_expression(compile_args):
  function test_mixed_mesh_expression (line 487) | def test_mixed_mesh_expression(compile_args):

FILE: test/test_jit_forms.py
  function test_laplace_bilinear_form_2d (line 48) | def test_laplace_bilinear_form_2d(dtype, expected_result, compile_args):
  function test_mass_bilinear_form_2d (line 165) | def test_mass_bilinear_form_2d(dtype, expected_result, compile_args):
  function test_helmholtz_form_2d (line 198) | def test_helmholtz_form_2d(dtype, expected_result, compile_args):
  function test_laplace_bilinear_form_3d (line 280) | def test_laplace_bilinear_form_3d(dtype, expected_result, compile_args):
  function test_form_coefficient (line 319) | def test_form_coefficient(compile_args):
  function test_subdomains (line 360) | def test_subdomains(compile_args):
  function test_interior_facet_integral (line 415) | def test_interior_facet_integral(dtype, compile_args):
  function test_conditional (line 480) | def test_conditional(dtype, compile_args):
  function test_custom_quadrature (line 549) | def test_custom_quadrature(compile_args):
  function test_curl_curl (line 601) | def test_curl_curl(compile_args):
  function lagrange_triangle_symbolic (line 614) | def lagrange_triangle_symbolic(order, corners=((1, 0), (2, 0), (0, 1)), ...
  function test_lagrange_triangle (line 671) | def test_lagrange_triangle(compile_args, order, dtype, sym_fun, ufl_fun):
  function lagrange_tetrahedron_symbolic (line 711) | def lagrange_tetrahedron_symbolic(
  function test_lagrange_tetrahedron (line 797) | def test_lagrange_tetrahedron(compile_args, order, dtype, sym_fun, ufl_f...
  function test_prism (line 839) | def test_prism(compile_args):
  function test_complex_operations (line 877) | def test_complex_operations(compile_args):
  function test_invalid_function_name (line 944) | def test_invalid_function_name(compile_args):
  function test_interval_vertex_quadrature (line 968) | def test_interval_vertex_quadrature(compile_args):
  function test_facet_vertex_quadrature (line 1005) | def test_facet_vertex_quadrature(compile_args):
  function test_manifold_derivatives (line 1066) | def test_manifold_derivatives(compile_args):
  function test_integral_grouping (line 1112) | def test_integral_grouping(compile_args):
  function test_derivative_domains (line 1151) | def test_derivative_domains(compile_args):
  function test_mixed_dim_form (line 1177) | def test_mixed_dim_form(compile_args, dtype, permutation):
  function test_ds_prism (line 1296) | def test_ds_prism(compile_args, dtype):
  function test_vertex_integral (line 1456) | def test_vertex_integral(compile_args, geometry, rank, dtype, element_ty...
  function test_vertex_mesh (line 1537) | def test_vertex_mesh(compile_args, dtype):
  function test_mixed_dim_form_codim2 (line 1586) | def test_mixed_dim_form_codim2(compile_args, dtype, permutation, local_e...
  function test_mixed_dim_form_codim2_2D (line 1678) | def test_mixed_dim_form_codim2_2D(compile_args, dtype, local_entity_index):
  function test_ridge_integral (line 1778) | def test_ridge_integral(compile_args, dtype, permutation):
  function test_diagonal_form (line 1869) | def test_diagonal_form(dtype, compile_args):
  function test_diagonal_mixed_form (line 1944) | def test_diagonal_mixed_form(dtype, compile_args):
  function test_diagonal_mixed_block (line 2025) | def test_diagonal_mixed_block(dtype, compile_args, shape):
  function test_multiple_integrands_same_quadrature (line 2101) | def test_multiple_integrands_same_quadrature(compile_args, dtype):
  function test_ufl_complex_extraction (line 2213) | def test_ufl_complex_extraction(

FILE: test/test_lnodes.py
  function test_gemm (line 13) | def test_gemm(dtype):
  function test_gemv (line 60) | def test_gemv(dtype):

FILE: test/test_numba.py
  function wrap_kernel (line 21) | def wrap_kernel(scalar_type, real_type):
  function as_C_array (line 26) | def as_C_array(np_array: npt.NDArray):
  function test_external_module (line 31) | def test_external_module():
  function generate_poisson (line 39) | def generate_poisson() -> None:
  function test_integral (line 45) | def test_integral(scalar_type: str, generate_poisson) -> None:
  function test_expression (line 98) | def test_expression(scalar_type: str, generate_poisson) -> None:

FILE: test/test_signatures.py
  function generate_kernel (line 19) | def generate_kernel(forms, scalar_type, options):
  function test_numba_kernel_signature (line 63) | def test_numba_kernel_signature(dtype):

FILE: test/test_submesh.py
  function compute_tensor (line 20) | def compute_tensor(forms: list[ufl.form.Form], dtype: str, compile_args:...
  function test_multiple_mesh_codim0 (line 71) | def test_multiple_mesh_codim0(dtype, compile_args):

FILE: test/test_tensor_product.py
  function cell_to_gdim (line 16) | def cell_to_gdim(cell_type):
  function create_tensor_product_element (line 26) | def create_tensor_product_element(cell_type, degree, variant, shape=None):
  function generate_kernel (line 37) | def generate_kernel(forms, dtype, options):
  function test_bilinear_form (line 64) | def test_bilinear_form(dtype, P, cell_type):