tivars.types.real.RealEntry

class documentation

class RealEntry(TIEntry): (source)

Known subclasses: tivars.types.real.GraphRealEntry, tivars.types.real.TIReal, tivars.types.real.TIRealRadical

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

Base class for real 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 the subtype_id, the first six bits of the first data byte.

Two RealEntry types are used to form a single ComplexEntry corresponding to a complex number.

Method	`__float__`	Undocumented
Method	`__format__`	Formats this entry for string representations
Method	`__init__`	Creates an empty entry with specified meta and data values
Method	`__int__`	Undocumented
Method	`__neg__`	Undocumented
Method	`calc_data`	The data section of the entry which is loaded on-calc
Method	`clear`	Clears this entry's data
Method	`coerce`	Coerces this entry to a subclass if possible using the entry's type ID
Method	`decimal`	No summary
Method	`float`	No summary
Method	`get_min_os`	Determines the minimum OS that supports this entry's data
Method	`graph_bit`	Whether the entry is used during graphing
Method	`json_number`	Encoder for JSON implementations with potentially low precision
Method	`load_decimal`	Loads a `decimal` into this real number
Method	`load_float`	Loads a `float` into this real number, upcasting as necessary
Method	`sign_bit`	The sign bit for the number
Method	`subtype_id`	The subtype ID of the number
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	`imag_subtype_id`	The subtype ID this type receives if used as an imaginary part
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	`min_exponent`	The smallest allowed floating point exponent
Property	`sign`	The sign of this real number
Property	`subtype`	The subtype of this real number
Constant	`_T`	Undocumented

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	`get_version`	Determines the version byte corresponding to given data for this entry type
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	`load_string`	Loads this entry from a string representation
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
Class Variable	`versions`	The possible versions 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
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 __float__(self) -> float: (source) ¶

Undocumented

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

overrides tivars.var.TIEntry.__format__

overridden in tivars.types.real.TIRealFraction, tivars.types.real.TIRealPi, tivars.types.real.TIRealRadical

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)

def __int__(self) -> int: (source) ¶

Undocumented

def __neg__(self) -> RealEntry: (source) ¶

Undocumented

@Section(min_data_length)

def calc_data(self) -> bytes: (source) ¶

overrides tivars.var.TIEntry.calc_data

overridden in tivars.types.real.TIReal, tivars.types.real.TIRealRadical

The data section of the entry which is loaded on-calc

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 decimal(self) -> Decimal: (source) ¶

overridden in tivars.types.real.TIReal, tivars.types.real.TIRealRadical

Returns
`Decimal`	A `decimal` object corresponding to this real number

def float(self) -> float: (source) ¶

Returns
`float`	The `float` corresponding to this real number

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

@View(calc_data, Bits[6:7])[0:1]

def graph_bit(self) -> int: (source) ¶

Whether the entry is used during graphing

def json_number(self) -> float | str: (source) ¶

Encoder for JSON implementations with potentially low precision

Returns
`float \| str`	A `float` or `str` depending on whether this real number can be stored in a single-precision float

@Loader[Decimal]

def load_decimal(self, decimal: Decimal): (source) ¶

overridden in tivars.types.real.TIReal, tivars.types.real.TIRealRadical

Loads a decimal into this real number

Parameters
decimal:`Decimal`	The decimal to load

@Loader[float, int]

def load_float(self, decimal: float): (source) ¶

Loads a float into this real number, upcasting as necessary

Parameters
decimal:`float`	The float to load

@View(calc_data, Bits[7:8])[0:1]

def sign_bit(self) -> int: (source) ¶

The sign bit for the number

If this bit is used, the number is negative when set.

@View(calc_data, Bits[0:6])[0:1]

def subtype_id(self) -> bytes: (source) ¶

The subtype ID of the number

Differentiates the exact radical and fraction formats.

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

imag_subtype_id = (source) ¶

overridden in tivars.types.real.TIReal, tivars.types.real.TIRealRadical

The subtype ID this type receives if used as an imaginary part

is_exact: bool = (source) ¶

overridden in tivars.types.real.TIRealFraction, tivars.types.real.TIRealPi, tivars.types.real.TIRealRadical

Whether this numeric type is exact

min_data_length: int = (source) ¶

overrides tivars.var.TIEntry.min_data_length

overridden in tivars.types.real.TIReal, tivars.types.real.TIRealRadical

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

min_exponent: int = (source) ¶

overridden in tivars.types.real.TIRealFraction, tivars.types.real.TIRealPi

The smallest allowed floating point exponent

@property

sign: int = (source) ¶

overridden in tivars.types.real.TIRealRadical

The sign of this real number

@property

subtype: type[RealEntry] = (source) ¶

The subtype of this real number

_T: str = (source) ¶

overrides tivars.var.TIEntry._T

overridden in tivars.types.real.GraphRealEntry

Undocumented

Value

'RealEntry'