classiq 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/interface/generator/visitor.py

@@ -1,14 +1,9 @@
 from collections import abc
+from collections.abc import Collection, Mapping, Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
-    Collection,
-    Dict,
-    List,
-    Mapping,
     Optional,
-    Sequence,
-    Tuple,
     TypeVar,
     Union,
 )
@@ -21,7 +16,7 @@ NodeType = Union[
     BaseModel,
     int,
     bool,
-    Tuple["NodeType", ...],
+    tuple["NodeType", ...],
     Mapping[Key, "NodeType"],
     Sequence["NodeType"],
 ]
@@ -47,19 +42,19 @@ class Visitor:
 
         return node
 
-    def visit_list(self, node: List[NodeType]) -> Optional[RetType]:
+    def visit_list(self, node: list[NodeType]) -> Optional[RetType]:
         for elem in node:
             self.visit(elem)
 
         return None
 
-    def visit_dict(self, node: Dict[Key, NodeType]) -> Optional[RetType]:
+    def visit_dict(self, node: dict[Key, NodeType]) -> Optional[RetType]:
         for value in node.values():
             self.visit(value)
 
         return None
 
-    def visit_tuple(self, node: Tuple[NodeType, ...]) -> Optional[Tuple[RetType, ...]]:
+    def visit_tuple(self, node: tuple[NodeType, ...]) -> Optional[tuple[RetType, ...]]:
         for value in node:
             self.visit(value)
 
@@ -83,13 +78,13 @@ class Transformer(Visitor):
 
         def visit(self, node: NodeType) -> Any: ...
 
-    def visit_list(self, node: List[NodeType]) -> List[RetType]:
+    def visit_list(self, node: list[NodeType]) -> list[RetType]:
         return [self.visit(elem) for elem in node]
 
-    def visit_dict(self, node: Dict[Key, NodeType]) -> Dict[Key, RetType]:
+    def visit_dict(self, node: dict[Key, NodeType]) -> dict[Key, RetType]:
         return {key: self.visit(value) for key, value in node.items()}
 
-    def visit_tuple(self, node: Tuple[NodeType, ...]) -> Tuple[RetType, ...]:
+    def visit_tuple(self, node: tuple[NodeType, ...]) -> tuple[RetType, ...]:
         return tuple(self.visit(value) for value in node)
 
     def visit_BaseModel(
@@ -97,7 +92,7 @@ class Transformer(Visitor):
     ) -> RetType:
         fields_to_skip = fields_to_skip or set()
 
-        result: Dict[str, Any] = dict()
+        result: dict[str, Any] = dict()
         for name, value in node:
             if name not in fields_to_skip:
                 result[name] = self.visit(value)

classiq/interface/hardware.py

@@ -1,8 +1,7 @@
 import datetime
-from typing import TYPE_CHECKING, List, Optional, Tuple
+from typing import TYPE_CHECKING, Annotated, Optional
 
 import pydantic
-from typing_extensions import Annotated
 
 from classiq.interface.enum_utils import StrEnum
 
@@ -75,9 +74,9 @@ class HardwareStatus(pydantic.BaseModel):
 
 
 if TYPE_CHECKING:
-    ConnectivityMapEntry = Tuple[int, int]
+    ConnectivityMapEntry = tuple[int, int]
 else:
-    ConnectivityMapEntry = List[int]
+    ConnectivityMapEntry = list[int]
 
 
 class HardwareInformation(pydantic.BaseModel):
@@ -87,8 +86,8 @@ class HardwareInformation(pydantic.BaseModel):
     display_name: str
     device_type: DeviceType
     number_of_qubits: int
-    connectivity_map: Optional[List[ConnectivityMapEntry]] = None
-    basis_gates: List[str]
+    connectivity_map: Optional[list[ConnectivityMapEntry]] = None
+    basis_gates: list[str]
     status: HardwareStatus
 
     def is_simulator(self) -> bool:

classiq/interface/helpers/custom_encoders.py

@@ -1,3 +1,3 @@
-from typing import Any, Callable, Dict
+from typing import Any, Callable
 
-CUSTOM_ENCODERS: Dict[type, Callable[[Any], Any]] = {complex: str}
+CUSTOM_ENCODERS: dict[type, Callable[[Any], Any]] = {complex: str}

classiq/interface/helpers/custom_pydantic_types.py

@@ -1,8 +1,7 @@
-from typing import TYPE_CHECKING, Any, List, Tuple
+from typing import TYPE_CHECKING, Annotated, Any
 
 import pydantic
 from pydantic import Field, StrictStr, StringConstraints
-from typing_extensions import Annotated
 
 from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
 from classiq.interface.generator.parameters import ParameterComplexType
@@ -57,7 +56,7 @@ else:
 if TYPE_CHECKING:
     PydanticPauliMonomial = tuple
 else:
-    PydanticPauliMonomial = Annotated[List[Any], Field(min_length=2, max_length=2)]
+    PydanticPauliMonomial = Annotated[list[Any], Field(min_length=2, max_length=2)]
 
 if TYPE_CHECKING:
     PydanticPauliMonomialStr = str
@@ -68,16 +67,16 @@ else:
     ]
 
 PydanticPauliList = Annotated[
-    List[Tuple[PydanticPauliMonomialStr, ParameterComplexType]], Field(min_length=1)
+    list[tuple[PydanticPauliMonomialStr, ParameterComplexType]], Field(min_length=1)
 ]
 
 if TYPE_CHECKING:
-    PydanticFloatTuple = Tuple[float, float]
+    PydanticFloatTuple = tuple[float, float]
 else:
-    PydanticFloatTuple = Annotated[List[float], Field(min_length=2, max_length=2)]
+    PydanticFloatTuple = Annotated[list[float], Field(min_length=2, max_length=2)]
 
 PydanticNonNegIntTuple = Annotated[
-    List[pydantic.NonNegativeInt], Field(min_length=2, max_length=2)
+    list[pydantic.NonNegativeInt], Field(min_length=2, max_length=2)
 ]
 
 if TYPE_CHECKING:
@@ -90,9 +89,9 @@ else:
         ),
     ]
 if TYPE_CHECKING:
-    AtomType = Tuple[str, List[float]]
+    AtomType = tuple[str, list[float]]
 else:
-    AtomType = Annotated[List[Any], Field(min_length=2, max_length=2)]
+    AtomType = Annotated[list[Any], Field(min_length=2, max_length=2)]
 
 
 if TYPE_CHECKING:

classiq/interface/helpers/dotdict.py

@@ -0,0 +1,18 @@
+from typing import Any
+
+
+class DotDict(dict):
+    def __getattr__(self, key: str) -> Any:
+        return super().get(key)
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        super().__setitem__(key, value)
+
+    def __delattr__(self, key: str) -> None:
+        super().__delitem__(key)
+
+
+def get_recursive_dotdict(obj: Any) -> Any:
+    if not isinstance(obj, dict):
+        return obj
+    return DotDict({k: get_recursive_dotdict(v) for k, v in obj.items()})

classiq/interface/helpers/hashable_mixin.py

@@ -1,7 +1,8 @@
 import itertools
 import numbers
+from collections.abc import Iterator
 from enum import EnumMeta
-from typing import Any, Iterator, Tuple
+from typing import Any
 
 
 def immutable_version(value: Any) -> Any:
@@ -29,5 +30,5 @@ class HashableMixin:
         for val in self._values_to_hash():
             yield immutable_version(val)
 
-    def _value_tuple(self) -> Tuple[Any, ...]:
+    def _value_tuple(self) -> tuple[Any, ...]:
         return tuple(itertools.chain((str(type(self))), self._immutable_fields()))

classiq/interface/helpers/hashable_pydantic_base_model.py

@@ -1,4 +1,5 @@
-from typing import Any, Collection, Iterator
+from collections.abc import Collection, Iterator
+from typing import Any
 
 import pydantic
 

classiq/interface/helpers/pydantic_model_helpers.py

@@ -1,9 +1,10 @@
-from typing import Any, Dict, Protocol, Sequence, TypeVar
+from collections.abc import Sequence
+from typing import Any, Protocol, TypeVar
 
 
 def values_with_discriminator(
     values: Any, discriminator: str, discriminator_value: Any
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     if isinstance(values, dict):
         values.setdefault(discriminator, discriminator_value)
     return values
@@ -16,5 +17,5 @@ class Nameable(Protocol):
 NameableType = TypeVar("NameableType", bound=Nameable)
 
 
-def nameables_to_dict(nameables: Sequence[NameableType]) -> Dict[str, NameableType]:
+def nameables_to_dict(nameables: Sequence[NameableType]) -> dict[str, NameableType]:
     return {value.name: value for value in nameables}

classiq/interface/helpers/validation_helpers.py

@@ -1,10 +1,10 @@
-from typing import Hashable, List, Mapping
+from collections.abc import Hashable, Mapping
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.pydantic_model_helpers import Nameable
 
 
-def is_list_unique(lst: List[Hashable]) -> bool:
+def is_list_unique(lst: list[Hashable]) -> bool:
     return len(set(lst)) == len(lst)
 
 

classiq/interface/ide/ide_data.py

@@ -1,13 +1,14 @@
 from enum import IntEnum
-from typing import Dict, List, Optional, Union
+from typing import Optional, Union
 
 import pydantic
 
 from classiq.interface.generator.generated_circuit_data import GeneratedFunction
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
 from classiq.interface.helpers.versioned_model import VersionedModel
+from classiq.interface.ide.visual_model import CircuitMetrics
 
-GateCount = Dict[str, int]
+GateCount = dict[str, int]
 Depth = int
 
 
@@ -51,17 +52,17 @@ class ConditionalRender(IntEnum):
 class IDEDataOperation(pydantic.BaseModel):
     gate: str
     displayName: str
-    children: List["IDEDataOperation"]
+    children: list["IDEDataOperation"]
     depth: Depth
     width: int
     gate_count: GateCount
     _qubits: list = pydantic.PrivateAttr()  # list[Qubit]
 
     displayArgs: str = ""
-    targets: Union[List[IDEQubitDef], List[IDEClassicalBitDef]] = pydantic.Field(
+    targets: Union[list[IDEQubitDef], list[IDEClassicalBitDef]] = pydantic.Field(
         default_factory=list
     )
-    controls: List[IDEQubitDef] = list()
+    controls: list[IDEQubitDef] = list()
     dataAttributes: DataAttributes = pydantic.Field(default_factory=DataAttributes)
     isControlled: bool = False
     isMeasurement: bool = False
@@ -81,7 +82,7 @@ class IDEDataProperties(pydantic.BaseModel):
 
 
 class RegisterData(pydantic.BaseModel):
-    segmentIds: List[str]
+    segmentIds: list[str]
     properties: IDEDataProperties
     registerId: str
 
@@ -91,16 +92,11 @@ class InterfaceSegmentData(pydantic.BaseModel):
     properties: IDEDataProperties
 
 
-class CircuitMetrics(pydantic.BaseModel):
-    depth: int
-    count_ops: Dict[str, int]
-
-
 class IDEData(VersionedModel):
-    qubits: List[IDEDataQubit]
-    operations: List[IDEDataOperation]
-    register_data: List[RegisterData]
-    segment_data: List[InterfaceSegmentData]
+    qubits: list[IDEDataQubit]
+    operations: list[IDEDataOperation]
+    register_data: list[RegisterData]
+    segment_data: list[InterfaceSegmentData]
     circuit_metrics: Optional[CircuitMetrics]
     hardware_data: SynthesisHardwareData
     creation_time: str

classiq/interface/ide/visual_model.py

@@ -1,20 +1,17 @@
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 import pydantic
 from pydantic import ConfigDict
 
 from classiq.interface.enum_utils import StrEnum
+from classiq.interface.generator.generated_circuit_data import (
+    OperationLevel,
+    OperationParameter,
+)
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 
-class OperationLevel(StrEnum):
-    QMOD_FUNCTION_CALL = "QMOD_CALL"
-    QMOD_STATEMENT = "QMOD_STATEMENT"
-    ENGINE_FUNCTION_CALL = "ENGINE_CALL"
-    UNKNOWN = "UNKNOWN"
-
-
 class OperationType(StrEnum):
     REGULAR = "REGULAR"
     ALLOCATE = "ALLOCATE"
@@ -26,22 +23,23 @@ class OperationType(StrEnum):
 class OperationData(pydantic.BaseModel):
     approximated_depth: Optional[int] = None
     width: int
-    gate_count: Dict[str, int] = pydantic.Field(default_factory=dict)
+    gate_count: dict[str, int] = pydantic.Field(default_factory=dict)
 
 
-class ProgramData(pydantic.BaseModel):
-    hardware_data: SynthesisHardwareData
+class CircuitMetrics(pydantic.BaseModel):
+    depth: int
+    count_ops: dict[str, int]
 
 
-class OperationParameter(pydantic.BaseModel):
-    label: str
-    value: Optional[str] = None
+class ProgramData(pydantic.BaseModel):
+    hardware_data: SynthesisHardwareData
+    circuit_metrics: CircuitMetrics
 
 
 class OperationLink(pydantic.BaseModel):
     label: str
     inner_label: Optional[str] = None
-    qubits: Tuple[int, ...]
+    qubits: tuple[int, ...]
     type: str
 
     model_config = ConfigDict(frozen=True)
@@ -56,8 +54,16 @@ class OperationLink(pydantic.BaseModel):
 
 
 class OperationLinks(pydantic.BaseModel):
-    inputs: List[OperationLink]
-    outputs: List[OperationLink]
+    inputs: list[OperationLink]
+    outputs: list[OperationLink]
+
+    @property
+    def input_width(self) -> int:
+        return sum(len(link.qubits) for link in self.inputs)
+
+    @property
+    def output_width(self) -> int:
+        return sum(len(link.qubits) for link in self.outputs)
 
 
 class AtomicGate(StrEnum):
@@ -89,17 +95,22 @@ class AtomicGate(StrEnum):
     CPHASE = "CPHASE"
     SWAP = "SWAP"
     IDENTITY = "IDENTITY"
+    U = "U"
+
+    @property
+    def is_control_gate(self) -> bool:
+        return self.startswith("C")
 
 
 class Operation(pydantic.BaseModel):
     name: str
-    children: List["Operation"]
+    children: list["Operation"]
     operation_data: Optional[OperationData] = None
     operation_links: OperationLinks
-    control_qubits: Tuple[int, ...] = pydantic.Field(default_factory=tuple)
-    auxiliary_qubits: Tuple[int, ...]
-    target_qubits: Tuple[int, ...]
-    parameters: List[OperationParameter] = pydantic.Field(default_factory=list)
+    control_qubits: tuple[int, ...] = pydantic.Field(default_factory=tuple)
+    auxiliary_qubits: tuple[int, ...]
+    target_qubits: tuple[int, ...]
+    parameters: list[OperationParameter] = pydantic.Field(default_factory=list)
     operation_level: OperationLevel
     operation_type: OperationType = pydantic.Field(
         description="Identifies unique operations that are visualized differently"

classiq/interface/jobs.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Generic, Optional, TypeVar, Union
+from typing import Any, Generic, Optional, TypeVar, Union
 
 import pydantic
 from pydantic import BaseModel
@@ -8,7 +8,7 @@ from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqAPIError
 from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
 
-JSONObject = Dict[str, Any]
+JSONObject = dict[str, Any]
 T = TypeVar("T", bound=Union[pydantic.BaseModel, JSONObject])
 AUTH_HEADER = "Classiq-BE-Auth"
 INVALID_RESPONSE_ERROR_MSG = "Invalid response from Classiq API"

classiq/interface/model/bind_operation.py

@@ -1,4 +1,5 @@
-from typing import List, Literal, Mapping, Sequence
+from collections.abc import Mapping, Sequence
+from typing import Literal
 
 import pydantic
 
@@ -13,8 +14,8 @@ BIND_OUTPUT_NAME = "bind_output"
 class BindOperation(QuantumOperation):
     kind: Literal["BindOperation"]
 
-    in_handles: List[ConcreteHandleBinding]
-    out_handles: List[ConcreteHandleBinding]
+    in_handles: list[ConcreteHandleBinding]
+    out_handles: list[ConcreteHandleBinding]
 
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:
@@ -51,7 +52,7 @@ class BindOperation(QuantumOperation):
 
     @pydantic.field_validator("in_handles", "out_handles")
     @classmethod
-    def validate_handle(cls, handles: List[HandleBinding]) -> List[HandleBinding]:
+    def validate_handle(cls, handles: list[HandleBinding]) -> list[HandleBinding]:
         for handle in handles:
             if not handle.is_bindable():
                 raise ClassiqValueError(f"Cannot bind '{handle}'")

classiq/interface/model/classical_parameter_declaration.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Literal
+from typing import Any, Literal
 
 import pydantic
 
@@ -14,7 +14,7 @@ class AnonClassicalParameterDeclaration(Parameter):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(
             values, "kind", "ClassicalParameterDeclaration"
         )

classiq/interface/model/handle_binding.py

@@ -1,5 +1,6 @@
+from collections.abc import Sequence
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Dict, Sequence, Union
+from typing import TYPE_CHECKING, Any, Union
 
 import pydantic
 from pydantic import ConfigDict, Field
@@ -51,7 +52,7 @@ class NestedHandleBinding(HandleBinding):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_name(cls, values: Any) -> Dict[str, Any]:
+    def _set_name(cls, values: Any) -> dict[str, Any]:
         if isinstance(values, dict):
             orig = values
             while "base_handle" in values:

classiq/interface/model/inplace_binary_operation.py

@@ -1,4 +1,5 @@
-from typing import Literal, Mapping, Sequence, Union
+from collections.abc import Mapping, Sequence
+from typing import Literal, Union
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.expressions.expression import Expression

classiq/interface/model/model.py

@@ -1,5 +1,6 @@
 from collections import Counter
-from typing import Any, List, Literal, Mapping, NewType
+from collections.abc import Mapping
+from typing import Any, Literal, NewType
 
 import pydantic
 
@@ -58,23 +59,23 @@ class Model(VersionedModel, ASTNode):
     kind: Literal["user"] = pydantic.Field(default=USER_MODEL_MARKER)
 
     # Must be validated before logic_flow
-    functions: List[NativeFunctionDefinition] = pydantic.Field(
+    functions: list[NativeFunctionDefinition] = pydantic.Field(
         default_factory=list,
         description="The user-defined custom type library.",
         validate_default=True,
     )
 
-    enums: List[EnumDeclaration] = pydantic.Field(
+    enums: list[EnumDeclaration] = pydantic.Field(
         default_factory=list,
         description="user-defined enums",
     )
 
-    types: List[StructDeclaration] = pydantic.Field(
+    types: list[StructDeclaration] = pydantic.Field(
         default_factory=list,
         description="user-defined structs",
     )
 
-    qstructs: List[QStructDeclaration] = pydantic.Field(
+    qstructs: list[QStructDeclaration] = pydantic.Field(
         default_factory=list,
         description="user-defined quantum structs",
     )
@@ -83,7 +84,7 @@ class Model(VersionedModel, ASTNode):
         description="The classical execution code of the model", default=""
     )
 
-    constants: List[Constant] = pydantic.Field(
+    constants: list[Constant] = pydantic.Field(
         default_factory=list,
     )
 
@@ -133,8 +134,8 @@ class Model(VersionedModel, ASTNode):
     @pydantic.field_validator("functions")
     @classmethod
     def _add_empty_main(
-        cls, functions: List[NativeFunctionDefinition]
-    ) -> List[NativeFunctionDefinition]:
+        cls, functions: list[NativeFunctionDefinition]
+    ) -> list[NativeFunctionDefinition]:
         function_dict = nameables_to_dict(functions)
         if MAIN_FUNCTION_NAME not in function_dict:
             functions.append(_create_empty_main_function())
@@ -146,8 +147,8 @@ class Model(VersionedModel, ASTNode):
     @pydantic.field_validator("functions")
     @classmethod
     def _validate_entry_point(
-        cls, functions: List[NativeFunctionDefinition]
-    ) -> List[NativeFunctionDefinition]:
+        cls, functions: list[NativeFunctionDefinition]
+    ) -> list[NativeFunctionDefinition]:
         function_dict = nameables_to_dict(functions)
         if MAIN_FUNCTION_NAME not in function_dict:
             raise ClassiqValueError("The model must contain a `main` function")
@@ -161,7 +162,7 @@ class Model(VersionedModel, ASTNode):
 
     @pydantic.field_validator("constants")
     @classmethod
-    def _validate_constants(cls, constants: List[Constant]) -> List[Constant]:
+    def _validate_constants(cls, constants: list[Constant]) -> list[Constant]:
         constant_definition_counts = Counter(
             [constant.name for constant in constants]
         ).items()

classiq/interface/model/native_function_definition.py

@@ -10,6 +10,13 @@ if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
 
+class FunctionSynthesisData(pydantic.BaseModel):
+    should_synthesize_separately: bool = pydantic.Field(
+        default=False,
+        description="Whether the function should be synthesized separately.",
+    )
+
+
 class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
     """
     Facilitates the creation of a user-defined composite function
@@ -21,3 +28,6 @@ class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
     body: "StatementBlock" = pydantic.Field(
         default_factory=list, description="List of function calls to perform."
     )
+    synthesis_data: FunctionSynthesisData = pydantic.Field(
+        default_factory=FunctionSynthesisData,
+    )

classiq/interface/model/port_declaration.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Literal
+from typing import Any, Literal
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -19,7 +19,7 @@ class AnonPortDeclaration(Parameter):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "PortDeclaration")
 
     @pydantic.field_validator("direction", mode="before")

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -1,4 +1,5 @@
-from typing import Dict, Literal, Mapping, Sequence
+from collections.abc import Mapping, Sequence
+from typing import Literal
 
 import pydantic
 
@@ -61,7 +62,7 @@ class AmplitudeLoadingOperation(QuantumAssignmentOperation):
 
     def initialize_var_types(
         self,
-        var_types: Dict[str, QuantumType],
+        var_types: dict[str, QuantumType],
         machine_precision: int,
     ) -> None:
         if len(var_types) != 1:

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,4 +1,5 @@
-from typing import Dict, Literal, Mapping, Optional, Sequence
+from collections.abc import Mapping, Sequence
+from typing import Literal, Optional
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -60,7 +61,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
 
     def initialize_var_types(
         self,
-        var_types: Dict[str, QuantumType],
+        var_types: dict[str, QuantumType],
         machine_precision: int,
     ) -> None:
         super().initialize_var_types(var_types, machine_precision)