tivars.types.complex.ComplexEntry

class documentation

class ComplexEntry(TIEntry): (source)

Known subclasses: tivars.types.complex.TIComplex, tivars.types.complex.TIComplexRadical

Constructor: ComplexEntry(init, for_flash, name, version, ...)

Base class for complex numeric types

This class handles floating-point types as well as the exact formats for the TI-83PCE and other newer models. The format for these types varies and is handled by real_subtype_id and imag_subtype_id.

Two RealEntry types are used to form a single ComplexEntry corresponding to a complex number. These types need not be the same, and will have subtype IDs not directly corresponding to their native type IDs.

The canonical type of the entire entry is determined by the imaginary part. The entry is coerced automatically if the imaginary part is updated.

Method	`__complex__`	Undocumented
Method	`__format__`	Formats this entry for string representations
Method	`__init__`	Creates an empty entry with specified meta and data values
Method	`calc_data`	The data section of the entry
Method	`clear`	Clears this entry's data
Method	`coerce`	Coerces this entry to a subclass if possible using the entry's type ID
Method	`complex`	No summary
Method	`components`	No summary
Method	`get_min_os`	Determines the minimum OS that supports this entry's data
Method	`get_version`	Determines the version byte corresponding to given data for this entry type
Method	`imag`	The imaginary part of the complex number
Method	`imag_graph_bit`	Whether the entry is used during graphing
Method	`imag_sign_bit`	The sign bit for the complex part
Method	`imag_subtype_id`	The subtype ID of the complex part
Method	`load_complex`	Loads this complex number from a `complex`, upcasting as necessary
Method	`load_string`	Loads this entry from a string representation
Method	`real`	The real part of the complex number
Method	`real_graph_bit`	Whether the entry is used during graphing
Method	`real_sign_bit`	The sign bit for the real part
Method	`real_subtype_id`	The subtype ID of the real part
Method	`supported_by`	Determines whether a given model can support this entry
Class Variable	`extensions`	The file extension used for this entry per-model
Class Variable	`is_exact`	Whether this numeric type is exact
Class Variable	`min_data_length`	The minimum length of this entry's data
Class Variable	`versions`	The possible versions of this entry
Property	`imag_type`	The subclass of `RealEntry` corresponding to this entry's `imag_subtype_id`.
Property	`real_type`	The subclass of `RealEntry` corresponding to this entry's `real_subtype_id`.

Inherited from TIEntry:

Class	`Raw`	Raw bytes container for `TIEntry`
Class Method	`get`	Converts `bytes` -> `TIEntry`
Class Method	`get_type`	Gets the subclass corresponding to a type ID if one is registered
Class Method	`open`	Creates a new entry from a file given a filename
Class Method	`register`	Registers a subtype with this class for coercion
Class Method	`set`	Converts `TIEntry` -> `bytes`
Static Method	`next_entry_length`	Helper function to determine the length of the next entry in a bytestream
Method	`__bool__`	No summary
Method	`__bytes__`	No summary
Method	`__copy__`	No summary
Method	`__eq__`	Determines if two entries are the same type and have the same bytes
Method	`__iter__`	No summary
Method	`__len__`	No summary
Method	`__str__`	No summary
Method	`archive`	Archives this entry (if supported)
Method	`archived`	Whether the entry is archived
Method	`bytes`	The bytes contained in this entry, without any var file header or metadata.
Method	`data`	The entry's user data
Method	`dict`	No summary
Method	`export`	Exports this entry to a `TIVar` with a specified name, header, and target model
Method	`load_bytes`	Loads a byte string or bytestream into this entry
Method	`load_data_section`	Loads the data of this entry from a bytestream
Method	`load_dict`	Loads this entry from a JSON dictionary representation
Method	`load_from_file`	Loads this entry from a file given a file pointer and offset
Method	`meta_length`	The length of the meta section of the entry
Method	`name`	The name of the entry
Method	`save`	Saves this entry as a var file in the current directory given a filename and optional header and targeted model
Method	`string`	No summary
Method	`type_id`	The type ID of the entry
Method	`unarchive`	Unarchives this entry (if supported)
Method	`version`	The version number of the entry
Class Variable	`base_meta_length`	Undocumented
Class Variable	`flash_meta_length`	Undocumented
Class Variable	`flash_only`	Whether this entry only supports flash chips
Class Variable	`leading_data_bytes`	Bytes that always begin this entry's data
Class Variable	`leading_name_byte`	Byte that always begins the name of this entry
Instance Variable	`raw`	Undocumented
Property	`calc_data_length`	The length of the data section of the entry
Property	`flash_bytes`	The flash bytes of this entry if they exist
Property	`is_empty`	Whether this entry's data is empty
Property	`meta`	The meta section of this entry
Method	`__init_subclass__`	Undocumented
Constant	`_T`	Undocumented
Class Variable	`_type_id`	Undocumented
Class Variable	`_type_ids`	Undocumented

Inherited from Dock (via TIEntry):

Method	`load`	Loads data into an instance by delegating to `Loader` methods based on the input's type
Class Variable	`loaders`	Undocumented

def __complex__(self): (source) ¶

Undocumented

def __format__(self, format_spec: str) -> str: (source) ¶

overrides tivars.var.TIEntry.__format__

Formats this entry for string representations

Parameters
format_spec:`str`	The format parameters
Returns
`str`	A string representation of this entry

def __init__(self, init=None, *, for_flash: bool = True, name: str = 'A', version: int = None, archived: bool = None, data: bytes = None): (source) ¶

overrides tivars.var.TIEntry.__init__

Creates an empty entry with specified meta and data values

The entry version and archived flag are invalid if for_flash == False.

Parameters
init	Values to initialize the entry's data (defaults to `None`)
for_flash:`bool`	Whether the entry supports flash chips (defaults to `True`)
name:`str`	The name of the entry (defaults to a valid default name)
version:`int`	The entry's version (defaults to `None`)
archived:`bool`	Whether the entry is archived (defaults to entry's default state on-calc)
data:`bytes`	The entry's data (defaults to empty)

@Section(min_data_length)
def calc_data(self) -> bytes: (source) ¶

overrides tivars.var.TIEntry.calc_data

The data section of the entry

The real and imaginary parts of the complex number are stored adjacently in TIReal format.

def clear(self): (source) ¶

overrides tivars.var.TIEntry.clear

Clears this entry's data

def coerce(self): (source) ¶

overrides tivars.var.TIEntry.coerce

Coerces this entry to a subclass if possible using the entry's type ID

Valid types must be registered to be considered for coercion.

def complex(self): (source) ¶

Returns
The `complex` corresponding to this complex number

def components(self) -> (RealEntry, RealEntry): (source) ¶

Returns
`(RealEntry, RealEntry)`	The components of this complex number as a pair of `RealEntry` values

def get_min_os(self, data: bytes = None) -> OsVersion: (source) ¶

overrides tivars.var.TIEntry.get_min_os

Determines the minimum OS that supports this entry's data

Parameters
data:`bytes`	The data to find the minimum support for (defaults to this entry's data)
Returns
`OsVersion`	The minimum `OsVersion` this entry supports

def get_version(self, data: bytes = None) -> int: (source) ¶

overrides tivars.var.TIEntry.get_version

Determines the version byte corresponding to given data for this entry type

Entries which could contain non-backwards compatible data are assigned a version byte. If an entry's version exceeds the "version" of a calculator, transfer to the calculator will fail.

Parameters
data:`bytes`	The data to find the version of (defaults to this entry's data)
Returns
`int`	The version byte for `data`

@View(calc_data, ImaginaryPart)[9:18]
def imag(self) -> RealEntry: (source) ¶

The imaginary part of the complex number

@View(calc_data, Bits[6:7])[9:10]
def imag_graph_bit(self) -> int: (source) ¶

Whether the entry is used during graphing

@View(calc_data, Bits[7:8])[9:10]
def imag_sign_bit(self) -> int: (source) ¶

The sign bit for the complex part

If this bit is set, the complex part is negative.

@View(calc_data, Bits[0:6])[9:10]
def imag_subtype_id(self) -> bytes: (source) ¶

The subtype ID of the complex part

@Loader[complex, float, int]
def load_complex(self, comp: complex): (source) ¶

overridden in tivars.types.complex.TIComplex, tivars.types.complex.TIComplexRadical

Loads this complex number from a complex, upcasting as necessary

Parameters
comp:`complex`	The complex number to load

@Loader[str]
def load_string(self, string: str): (source) ¶

overrides tivars.var.TIEntry.load_string

Loads this entry from a string representation

Parameters
string:`str`	The string to load

@View(calc_data, RealPart)[0:9]
def real(self) -> RealEntry: (source) ¶

The real part of the complex number

@View(calc_data, Bits[6:7])[0:1]
def real_graph_bit(self) -> int: (source) ¶

Whether the entry is used during graphing

@View(calc_data, Bits[7:8])[0:1]
def real_sign_bit(self) -> int: (source) ¶

The sign bit for the real part

If this bit is set, the real part is negative.

@View(calc_data, Bits[0:6])[0:1]
def real_subtype_id(self) -> bytes: (source) ¶

The subtype ID of the real part

def supported_by(self, model: TIModel) -> bool: (source) ¶

overrides tivars.var.TIEntry.supported_by

Determines whether a given model can support this entry

Parameters
model:`TIModel`	The model to check support for
Returns
`bool`	Whether `model` supports this entry

extensions = (source) ¶

overrides tivars.var.TIEntry.extensions

The file extension used for this entry per-model

is_exact: bool = (source) ¶

overridden in tivars.types.complex.TIComplexFraction, tivars.types.complex.TIComplexPi, tivars.types.complex.TIComplexRadical

Whether this numeric type is exact

min_data_length: int = (source) ¶

overrides tivars.var.TIEntry.min_data_length

The minimum length of this entry's data

If an entry's data is fixed in size, this value is necessarily the length of the data

versions: list[int] = (source) ¶

overrides tivars.var.TIEntry.versions

The possible versions of this entry

@property
imag_type: type[RealEntry] = (source) ¶

The subclass of RealEntry corresponding to this entry's imag_subtype_id.

@property
real_type: type[RealEntry] = (source) ¶

The subclass of RealEntry corresponding to this entry's real_subtype_id.