Complete callable index

Find native module functions and value methods in one place. Each group links to its reference for signatures, supported receiver types, overloads, errors, complexity and execution limits. Methods on native values may also use receiver syntax, as shown in the owning guide. A name in this index does not enable an optional backend or install map data.

This index follows the current documented development runtime; check downloads and the development status before choosing an executable.

The catalogue covers 22 native root modules and 855 distinct module and value method names across 1087 native signatures or generic families. Core constructors, operators, numeric casts and language intrinsics are described in the language reference, numeric guide and individual value references.

Module directory

Choose a module to jump to its complete signature list, or open the reference for worked examples and constraints.

Module signatures	API reference	Callable names
`aner.api`	Reference	13
`aner.data`	Reference	70
`aner.dataset`	Reference	46
`aner.db`	Reference	31
`aner.dev`	Reference	4
`aner.gen`	Reference	72
`aner.geo`	Reference	11
`aner.llm`	Reference	14
`aner.math`	Reference	8
`aner.metrics`	Reference	4
`aner.ml`	Reference	55
`aner.nn`	Reference	60
`aner.parallel`	Reference	17
`aner.plot`	Reference	49
`aner.quantum`	Reference	28
`aner.random`	Reference	18
`aner.science`	Reference	20
`aner.secrets`	Reference	4
`aner.tensor`	Reference	31
`aner.token`	Reference	20
`aner.units`	Reference	6
`aner.viz`	Reference	1

aner.api

Open the aner.api reference.

Signatures list supported native overloads. T, E and unit parameters describe a checked generic family; the owning reference defines which element types, unit combinations and operations are admitted. Default argument insertion and implicit receiver syntax follow that guide.

`api.app`

api.app(title: String) -> APIApp

`api.auth`

api.auth(app: APIApp, key: SecretRef) -> APIApp

`api.bind`

api.bind(app: APIApp, host: String, port: Int64) -> APIApp

`api.hostname`

api.hostname(app: APIApp, hostname: String) -> APIApp

`api.limits`

api.limits(app: APIApp, max_rows: Int64, timeout_ms: Int64) -> APIApp

`api.llm`

api.llm(app: APIApp, path: String, client: LLMClient) -> APIApp

`api.model`

api.model(app: APIApp, path: String, model: FittedClassifier) -> APIApp

`api.openapi`

api.openapi(app: APIApp) -> String

`api.output_limit`

api.output_limit(app: APIApp, max_tokens: Int64) -> APIApp

`api.rate_limit`

api.rate_limit(app: APIApp, requests_per_minute: Int64) -> APIApp

`api.serve`

api.serve(app: APIApp, port: Int64) -> Unit
api.serve(app: APIApp) -> Unit

`api.tls`

api.tls(app: APIApp, certificate: String, private_key: String) -> APIApp

`api.tls_available`

api.tls_available() -> Bool

aner.data

Open the aner.data reference.

`data.batch`

data.batch(self: AdaptiveFrame, max_output_bytes: Int64, copy: String) -> ContextBatch
data.batch(self: AdaptiveFrame, max_output_bytes: Int64) -> ContextBatch

`data.boolean`

data.boolean(table: DataTable, row: Int64, column: String) -> Bool

`data.bounded`

data.bounded(scan: DataScan, max_scanned_rows: Int64, max_read_bytes: Int64, timeout_ms: Int64) -> DataScan

`data.cancel`

data.cancel(execution: DataExecution) -> Unit

`data.collect`

data.collect(scan: DataScan, max_rows: Int64, max_bytes: Int64, batch_rows: Int64) -> DataTable

`data.cols`

data.cols(self: AdaptiveFrame) -> Int64
data.cols(table: DataTable) -> Int64

`data.column`

data.column(schema: DataSchema, name: String, type: String, nullable: Bool) -> DataSchema

`data.column_name`

data.column_name(self: AdaptiveFrame, column: Int64) -> String
data.column_name(table: DataTable, index: Int64) -> String

`data.column_nullable`

data.column_nullable(self: DataTable, column: Int64) -> Bool

`data.column_type`

data.column_type(self: DataTable, column: Int64) -> String

`data.column_unit`

data.column_unit(self: AdaptiveFrame, column: Int64) -> String
data.column_unit(table: DataTable, index: Int64) -> String

`data.complete`

data.complete(value: DataExecution) -> Bool
data.complete(value: DataReport) -> Bool
data.complete(value: DataTable) -> Bool

`data.convert_unit`

data.convert_unit(scan: DataScan, column: String, target_unit: String) -> DataScan

`data.describe`

data.describe(report: DataReport) -> String

`data.elapsed_ms`

data.elapsed_ms(value: DataExecution) -> Int64
data.elapsed_ms(value: DataReport) -> Int64
data.elapsed_ms(value: DataTable) -> Int64

`data.execution`

data.execution(timeout_ms: Int64) -> DataExecution

`data.explain`

data.explain(scan: DataScan) -> String
data.explain(self: AdaptiveFrame) -> String
data.explain(self: ContextBatch) -> String
data.explain(self: FramePartition) -> String

`data.features`

data.features(self: AdaptiveFrame) -> AdaptiveFrame

`data.frame`

data.frame(table: DataTable, row_id: String, group: String, target: String, units: List) -> AdaptiveFrame
data.frame(table: DataTable, row_id: String, group: String, target: String) -> AdaptiveFrame

`data.gather_rows`

data.gather_rows(self: AdaptiveFrame, indices: List) -> AdaptiveFrame

`data.include`

data.include(scan: DataScan, column: String) -> DataScan

`data.inputs`

data.inputs(self: ContextBatch) -> SemanticTensor

`data.integer`

data.integer(table: DataTable, row: Int64, column: String) -> Int64

`data.is_cancelled`

data.is_cancelled(execution: DataExecution) -> Bool

`data.is_missing`

data.is_missing(table: DataTable, row: Int64, column: String) -> Bool

`data.max`

data.max(report: DataReport, column: String) -> Float64

`data.mean`

data.mean(report: DataReport, column: String) -> Float64

`data.min`

data.min(report: DataReport, column: String) -> Float64

`data.missing`

data.missing(report: DataReport, column: String) -> Int64

`data.number`

data.number(table: DataTable, row: Int64, column: String) -> Float64

`data.partition_groups`

data.partition_groups(self: AdaptiveFrame, train: List, validation: List, test: List) -> FramePartition

`data.peak_bytes`

data.peak_bytes(report: DataExecution) -> Int64
data.peak_bytes(report: DataReport) -> Int64
data.peak_bytes(report: DataTable) -> Int64

`data.preview`

data.preview(scan: DataScan, max_rows: Int64, max_bytes: Int64, batch_rows: Int64) -> DataTable

`data.read_bytes`

data.read_bytes(value: DataExecution) -> Int64
data.read_bytes(value: DataReport) -> Int64
data.read_bytes(value: DataTable) -> Int64

`data.receipt`

data.receipt(value: DataExecution) -> String
data.receipt(value: DataReport) -> String
data.receipt(value: DataTable) -> String

`data.rename`

data.rename(self: AdaptiveFrame, from: String, to: String) -> AdaptiveFrame

`data.returned_rows`

data.returned_rows(value: DataExecution) -> Int64
data.returned_rows(value: DataReport) -> Int64
data.returned_rows(value: DataTable) -> Int64

`data.role`

data.role(self: AdaptiveFrame) -> String

`data.row_id`

data.row_id(self: AdaptiveFrame, index: Int64) -> Int64
data.row_id(self: ContextBatch, index: Int64) -> Int64

`data.row_ids`

data.row_ids(self: AdaptiveFrame) -> List
data.row_ids(self: ContextBatch) -> List

`data.rows`

data.rows(self: AdaptiveFrame) -> Int64
data.rows(value: DataReport) -> Int64
data.rows(value: DataTable) -> Int64

`data.scan_csv`

data.scan_csv(path: String, schema: DataSchema, missing: String) -> DataScan

`data.scanned_rows`

data.scanned_rows(report: DataExecution) -> Int64
data.scanned_rows(report: DataReport) -> Int64
data.scanned_rows(report: DataTable) -> Int64

`data.schema`

data.schema() -> DataSchema

`data.select`

data.select(scan: DataScan, column: String) -> DataScan
data.select(self: AdaptiveFrame, fields: List) -> AdaptiveFrame

`data.selected_rows`

data.selected_rows(value: DataExecution) -> Int64
data.selected_rows(value: DataReport) -> Int64
data.selected_rows(value: DataTable) -> Int64

`data.shuffle`

data.shuffle(self: ContextBatch, seed: Int64) -> ContextBatch

`data.slice`

data.slice(self: AdaptiveFrame, start: Int64, stop: Int64) -> AdaptiveFrame

`data.std`

data.std(report: DataReport, column: String) -> Float64

`data.stop_reason`

data.stop_reason(value: DataExecution) -> String
data.stop_reason(value: DataReport) -> String
data.stop_reason(value: DataTable) -> String

`data.summarize`

data.summarize(scan: DataScan, max_bytes: Int64, batch_rows: Int64) -> DataReport

`data.summary`

data.summary(self: AdaptiveFrame) -> String
data.summary(self: ContextBatch) -> String
data.summary(self: FramePartition) -> String

`data.targets`

data.targets(self: ContextBatch) -> SemanticTensor

`data.test`

data.test(self: FramePartition) -> AdaptiveFrame

`data.text`

data.text(table: DataTable, row: Int64, column: String) -> String

`data.to_tensor`

data.to_tensor(table: DataTable, max_bytes: Int64) -> Tensor

`data.train`

data.train(self: FramePartition) -> AdaptiveFrame

`data.unit_column`

data.unit_column(schema: DataSchema, name: String, unit: String, nullable: Bool) -> DataSchema

`data.unit_max`

data.unit_max(report: DataReport, column: String, target_unit: String) -> Quantity<TargetUnit> | Point<TargetUnit>

`data.unit_mean`

data.unit_mean(report: DataReport, column: String, target_unit: String) -> Quantity<TargetUnit> | Point<TargetUnit>

`data.unit_min`

data.unit_min(report: DataReport, column: String, target_unit: String) -> Quantity<TargetUnit> | Point<TargetUnit>

`data.unit_std`

data.unit_std(report: DataReport, column: String, target_unit: String) -> Quantity<TargetUnit>

`data.unit_value`

data.unit_value(table: DataTable, row: Int64, column: String, target_unit: String) -> Quantity<TargetUnit> | Point<TargetUnit>

`data.unit_values`

data.unit_values(table: DataTable, column: String, target_unit: String) -> Array<Quantity<TargetUnit>> | Array<Point<TargetUnit>>

`data.valid`

data.valid(report: DataReport, column: String) -> Int64

`data.validation`

data.validation(self: FramePartition) -> AdaptiveFrame

`data.where_eq`

data.where_eq(scan: DataScan, column: String, value: String) -> DataScan

`data.where_ge`

data.where_ge(scan: DataScan, column: String, value: Float64) -> DataScan
data.where_ge(scan: DataScan, column: String, value: Int64) -> DataScan
data.where_ge(scan: DataScan, column: String, value: T) -> DataScan

`data.where_present`

data.where_present(scan: DataScan, column: String) -> DataScan

`data.with_execution`

data.with_execution(scan: DataScan, execution: DataExecution) -> DataScan

aner.dataset

Open the aner.dataset reference.

`dataset.audit`

dataset.audit(partition: DatasetFolds) -> String
dataset.audit(partition: DatasetPartition) -> String

`dataset.batch`

dataset.batch(schedule: DatasetBatches, index: Int64) -> Dataset

`dataset.batches`

dataset.batches(data: Dataset, size: Int64, seed: Int64, shuffle: Bool) -> DatasetBatches

`dataset.center`

dataset.center(scaler: Standardizer) -> Tensor

`dataset.citation`

dataset.citation(data: Dataset) -> String

`dataset.class_name`

dataset.class_name(data: Dataset, index: Int64) -> String

`dataset.classes`

dataset.classes(data: Dataset) -> Int64

`dataset.cols`

dataset.cols(data: Dataset) -> Int64

`dataset.count`

dataset.count() -> Int64
dataset.count(value: DatasetBatches) -> Int64
dataset.count(value: DatasetFolds) -> Int64

`dataset.description`

dataset.description(data: Dataset) -> String

`dataset.diabetes`

dataset.diabetes() -> Dataset

`dataset.feature_name`

dataset.feature_name(data: Dataset, index: Int64) -> String

`dataset.feature_unit`

dataset.feature_unit(data: Dataset, index: Int64) -> String

`dataset.features`

dataset.features(data: Dataset) -> Tensor

`dataset.fit_standardizer`

dataset.fit_standardizer(features: Dataset) -> Standardizer
dataset.fit_standardizer(features: Tensor) -> Standardizer

`dataset.fold`

dataset.fold(folds: DatasetFolds, index: Int64) -> DatasetPartition

`dataset.from_tensors`

dataset.from_tensors(features: Tensor, targets: Tensor) -> Dataset

`dataset.id`

dataset.id(index: Int64) -> String

`dataset.iris`

dataset.iris() -> Dataset

`dataset.kfold`

dataset.kfold(data: Dataset, count: Int64, seed: Int64, stratify: Bool, group_aware: Bool) -> DatasetFolds
dataset.kfold(data: Dataset, count: Int64, seed: Int64) -> DatasetFolds

`dataset.license`

dataset.license(data: Dataset) -> String

`dataset.load`

dataset.load(name: String) -> Dataset

`dataset.mnist`

dataset.mnist(directory: String, partition: String) -> Dataset

`dataset.name`

dataset.name(data: Dataset) -> String

`dataset.one_hot`

dataset.one_hot(data: Dataset) -> Tensor

`dataset.partition`

dataset.partition(data: Dataset, validation: Float64, test: Float64, seed: Int64, stratify: Bool, group_aware: Bool) -> DatasetPartition
dataset.partition(data: Dataset, validation: Float64, test: Float64, seed: Int64) -> DatasetPartition

`dataset.provenance`

dataset.provenance(data: Dataset) -> String

`dataset.require_disjoint`

dataset.require_disjoint(left: Dataset, right: Dataset) -> Unit

`dataset.require_training`

dataset.require_training(data: Dataset) -> Unit

`dataset.role`

dataset.role(data: Dataset) -> String

`dataset.row_ids`

dataset.row_ids(data: Dataset) -> Tensor

`dataset.rows`

dataset.rows(data: Dataset) -> Int64

`dataset.scale`

dataset.scale(scaler: Standardizer) -> Tensor

`dataset.sha256`

dataset.sha256(data: Dataset) -> String

`dataset.source`

dataset.source(data: Dataset) -> String

`dataset.split`

dataset.split(data: Dataset, test: Float64, seed: Int64) -> DatasetSplit

`dataset.synthetic`

dataset.synthetic(rows: Int64, inputs: Int64, classes: Int64, seed: Int64) -> Dataset

`dataset.targets`

dataset.targets(data: Dataset) -> Tensor

`dataset.test`

dataset.test(split: DatasetPartition) -> Dataset
dataset.test(split: DatasetSplit) -> Dataset

`dataset.titanic`

dataset.titanic() -> Dataset

`dataset.train`

dataset.train(split: DatasetPartition) -> Dataset
dataset.train(split: DatasetSplit) -> Dataset

`dataset.transform`

dataset.transform(scaler: Standardizer, features: Tensor) -> Tensor

`dataset.validation`

dataset.validation(partition: DatasetPartition) -> Dataset

`dataset.version`

dataset.version(data: Dataset) -> String

`dataset.wine`

dataset.wine() -> Dataset

`dataset.with_groups`

dataset.with_groups(data: Dataset, keys: List) -> Dataset

aner.db

Open the aner.db reference.

`db.available`

db.available(driver: String) -> Bool

`db.boolean`

db.boolean(result: DBResult, row: Int64, column: Int64) -> Bool

`db.close`

db.close(connection: DBConnection) -> Unit

`db.cols`

db.cols(result: DBResult) -> Int64

`db.column_name`

db.column_name(result: DBResult, column: Int64) -> String

`db.column_type`

db.column_type(result: DBResult, column: Int64) -> String

`db.connected`

db.connected(connection: DBConnection) -> Bool

`db.execute`

db.execute(connection: DBConnection, sql: String, parameters: List) -> Int64
db.execute(connection: DBConnection, sql: String) -> Int64

`db.integer`

db.integer(result: DBResult, row: Int64, column: Int64) -> Int64

`db.is_null`

db.is_null(result: DBResult, row: Int64, column: Int64) -> Bool

`db.mongodb.command`

db.mongodb.command(connection: DBConnection, command_json: String, max_bytes: Int64) -> String
db.mongodb.command(connection: DBConnection, command_json: String) -> String

`db.mongodb.connect`

db.mongodb.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, auth_database: String, tls: Bool, timeout_seconds: Int64) -> DBConnection
db.mongodb.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, auth_database: String, tls: Bool) -> DBConnection
db.mongodb.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, auth_database: String) -> DBConnection
db.mongodb.connect(host: String, port: Int64, database: String, user: String, password: SecretRef) -> DBConnection

`db.mongodb.document`

db.mongodb.document(result: DBResult, row: Int64) -> String

`db.mongodb.find`

db.mongodb.find(connection: DBConnection, collection: String, filter_json: String, options_json: String, max_documents: Int64, max_bytes: Int64) -> DBResult
db.mongodb.find(connection: DBConnection, collection: String, filter_json: String, options_json: String, max_documents: Int64) -> DBResult
db.mongodb.find(connection: DBConnection, collection: String, filter_json: String, options_json: String) -> DBResult
db.mongodb.find(connection: DBConnection, collection: String, filter_json: String) -> DBResult

`db.mongodb.insert_one`

db.mongodb.insert_one(connection: DBConnection, collection: String, document_json: String) -> Int64

`db.mssql.connect`

db.mssql.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, sslmode: String, timeout_seconds: Int64) -> DBConnection
db.mssql.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, sslmode: String) -> DBConnection
db.mssql.connect(host: String, port: Int64, database: String, user: String, password: SecretRef) -> DBConnection

`db.mysql.connect`

db.mysql.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, sslmode: String, timeout_seconds: Int64) -> DBConnection
db.mysql.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, sslmode: String) -> DBConnection
db.mysql.connect(host: String, port: Int64, database: String, user: String, password: SecretRef) -> DBConnection

`db.number`

db.number(result: DBResult, row: Int64, column: Int64) -> Float64

`db.postgres.connect`

db.postgres.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, sslmode: String, timeout_seconds: Int64) -> DBConnection
db.postgres.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, sslmode: String) -> DBConnection
db.postgres.connect(host: String, port: Int64, database: String, user: String, password: SecretRef) -> DBConnection

`db.query`

db.query(connection: DBConnection, sql: String, parameters: List, max_rows: Int64, max_bytes: Int64) -> DBResult
db.query(connection: DBConnection, sql: String, parameters: List, max_rows: Int64) -> DBResult
db.query(connection: DBConnection, sql: String, parameters: List) -> DBResult
db.query(connection: DBConnection, sql: String) -> DBResult

`db.rows`

db.rows(result: DBResult) -> Int64

`db.text`

db.text(result: DBResult, row: Int64, column: Int64) -> String

`db.to_table`

db.to_table(result: DBResult, memory_bytes: Int64) -> DataTable

`mongodb.command`

mongodb.command(connection: DBConnection, command_json: String, max_bytes: Int64) -> String
mongodb.command(connection: DBConnection, command_json: String) -> String

`mongodb.connect`

mongodb.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, auth_database: String, tls: Bool, timeout_seconds: Int64) -> DBConnection
mongodb.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, auth_database: String, tls: Bool) -> DBConnection
mongodb.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, auth_database: String) -> DBConnection
mongodb.connect(host: String, port: Int64, database: String, user: String, password: SecretRef) -> DBConnection

`mongodb.document`

mongodb.document(result: DBResult, row: Int64) -> String

`mongodb.find`

mongodb.find(connection: DBConnection, collection: String, filter_json: String, options_json: String, max_documents: Int64, max_bytes: Int64) -> DBResult
mongodb.find(connection: DBConnection, collection: String, filter_json: String, options_json: String, max_documents: Int64) -> DBResult
mongodb.find(connection: DBConnection, collection: String, filter_json: String, options_json: String) -> DBResult
mongodb.find(connection: DBConnection, collection: String, filter_json: String) -> DBResult

`mongodb.insert_one`

mongodb.insert_one(connection: DBConnection, collection: String, document_json: String) -> Int64

`mssql.connect`

mssql.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, sslmode: String, timeout_seconds: Int64) -> DBConnection
mssql.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, sslmode: String) -> DBConnection
mssql.connect(host: String, port: Int64, database: String, user: String, password: SecretRef) -> DBConnection

`mysql.connect`

mysql.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, sslmode: String, timeout_seconds: Int64) -> DBConnection
mysql.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, sslmode: String) -> DBConnection
mysql.connect(host: String, port: Int64, database: String, user: String, password: SecretRef) -> DBConnection

`postgres.connect`

postgres.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, sslmode: String, timeout_seconds: Int64) -> DBConnection
postgres.connect(host: String, port: Int64, database: String, user: String, password: SecretRef, sslmode: String) -> DBConnection
postgres.connect(host: String, port: Int64, database: String, user: String, password: SecretRef) -> DBConnection

aner.dev

Open the aner.dev reference.

`dev.automatic`

dev.automatic(enabled: Bool) -> Unit

`dev.capture`

dev.capture(label: String, value: Any) -> Unit

`dev.enabled`

dev.enabled() -> Bool

`dev.progress`

dev.progress(epoch: Int64, epochs: Int64, loss: Float64, accuracy: Float64, seconds: Float64, validation_loss: Float64) -> Unit
dev.progress(epoch: Int64, epochs: Int64, loss: Float64, accuracy: Float64, seconds: Float64) -> Unit

aner.gen

Open the aner.gen reference.

`gen.averaged_parameter`

gen.averaged_parameter(model: ScientificModel, name: String) -> Tensor

`gen.baseline`

gen.baseline() -> String
gen.baseline(model: LanguageModel) -> String

`gen.calibrate_diffusion`

gen.calibrate_diffusion(model: ScientificModel, training: ScientificData, samples_per_timestep: Int64, seed: Int64, ridge: Float64) -> ScientificModel

`gen.calibrate_diffusion_gaussian`

gen.calibrate_diffusion_gaussian(model: ScientificModel, training: ScientificData) -> ScientificModel

`gen.calibrate_diffusion_neural`

gen.calibrate_diffusion_neural(model: ScientificModel, training: ScientificData, draws: Int64, seed: Int64, strength: Float64) -> ScientificModel
gen.calibrate_diffusion_neural(model: ScientificModel, training: ScientificData, draws: Int64, seed: Int64) -> ScientificModel

`gen.calibrate_diffusion_variance`

gen.calibrate_diffusion_variance(model: ScientificModel, training: ScientificData, samples_per_timestep: Int64, seed: Int64) -> ScientificModel

`gen.conserve_mass`

gen.conserve_mass(fields: Tensor, target_mass: Tensor, dx: Float64, dy: Float64) -> Tensor

`gen.decoder`

gen.decoder(codec: Tokenizer, context: Int64, width: Int64, heads: Int64, layers: Int64, seed: Int64, dropout: Float64) -> LanguageModel
gen.decoder(codec: Tokenizer, context: Int64, width: Int64, heads: Int64, layers: Int64, seed: Int64) -> LanguageModel

`gen.device`

gen.device(model: LanguageModel) -> String
gen.device(model: ScientificModel) -> String

`gen.device_supported`

gen.device_supported(device: String, dtype: String) -> Bool

`gen.diffusion_covariance`

gen.diffusion_covariance(model: ScientificModel) -> Tensor

`gen.diffusion_model`

gen.diffusion_model(rows: Int64, cols: Int64, condition_size: Int64, width: Int64, diffusion_steps: Int64, beta_start: Float64, beta_end: Float64, seed: Int64) -> ScientificModel

`gen.diffusion_noise`

gen.diffusion_noise(clean: Tensor, noise: Tensor, schedule: Tensor, timesteps: List) -> Tensor

`gen.diffusion_reverse`

gen.diffusion_reverse(noisy: Tensor, predicted_epsilon: Tensor, innovation: Tensor, schedule: Tensor, timesteps: List, variance_table: Tensor) -> Tensor
gen.diffusion_reverse(noisy: Tensor, predicted_epsilon: Tensor, innovation: Tensor, schedule: Tensor, timesteps: List) -> Tensor

`gen.diffusion_schedule`

gen.diffusion_schedule(steps: Int64, beta_start: Float64, beta_end: Float64) -> Tensor

`gen.diffusion_variance`

gen.diffusion_variance(model: ScientificModel) -> Tensor

`gen.dtype`

gen.dtype(model: LanguageModel) -> String
gen.dtype(model: ScientificModel) -> String

`gen.field_data`

gen.field_data(values: Tensor, conditions: Tensor, role: String) -> ScientificData

`gen.field_elliptic_residual`

gen.field_elliptic_residual(fields: Tensor, forcing: Tensor, kx_faces: Tensor, ky_faces: Tensor, reaction: Tensor, dx: Float64, dy: Float64) -> Tensor

`gen.field_laplacian`

gen.field_laplacian(fields: Tensor, dx: Float64, dy: Float64) -> Tensor

`gen.field_mass`

gen.field_mass(fields: Tensor, dx: Float64, dy: Float64) -> Tensor

`gen.field_statistics`

gen.field_statistics(fields: Tensor, dx: Float64, dy: Float64) -> Dictionary

`gen.fine_tune`

gen.fine_tune(model: LanguageModel, corpus: TokenCorpus, steps: Int64, batch: Int64, rate: Float64, seed: Int64, clip_norm: Float64, warmup_steps: Int64, weight_decay: Float64) -> LanguageModel
gen.fine_tune(model: LanguageModel, corpus: TokenCorpus, steps: Int64, batch: Int64, rate: Float64, seed: Int64) -> LanguageModel

`gen.fingerprint`

gen.fingerprint(model: LanguageModel) -> String
gen.fingerprint(model: ScientificData) -> String
gen.fingerprint(model: ScientificModel) -> String

`gen.freeze`

gen.freeze(model: LanguageModel, names: List) -> LanguageModel

`gen.generate`

gen.generate(model: LanguageModel, prompt: List, max_new_tokens: Int64, temperature: Float64, top_k: Int64, top_p: Float64, seed: Int64, use_cache: Bool) -> List
gen.generate(model: LanguageModel, prompt: List, max_new_tokens: Int64, temperature: Float64, top_k: Int64, top_p: Float64, seed: Int64) -> List

`gen.generate_batch`

gen.generate_batch(model: LanguageModel, prompts: List, max_new_tokens: Int64, temperature: Float64, top_k: Int64, top_p: Float64, seeds: List, use_cache: Bool, cuda_graph: Bool) -> List
gen.generate_batch(model: LanguageModel, prompts: List, max_new_tokens: Int64, temperature: Float64, top_k: Int64, top_p: Float64, seeds: List, use_cache: Bool) -> List
gen.generate_batch(model: LanguageModel, prompts: List, max_new_tokens: Int64, temperature: Float64, top_k: Int64, top_p: Float64, seeds: List) -> List
gen.generate_batch(model: LanguageModel, prompts: List, max_new_tokens: List, temperature: Float64, top_k: Int64, top_p: Float64, seeds: List, use_cache: Bool, cuda_graph: Bool) -> List
gen.generate_batch(model: LanguageModel, prompts: List, max_new_tokens: List, temperature: Float64, top_k: Int64, top_p: Float64, seeds: List, use_cache: Bool) -> List
gen.generate_batch(model: LanguageModel, prompts: List, max_new_tokens: List, temperature: Float64, top_k: Int64, top_p: Float64, seeds: List) -> List

`gen.import_gpt2`

gen.import_gpt2(directory: String, context: Int64) -> LanguageModel

`gen.last_loss`

gen.last_loss(model: LanguageModel) -> Float64
gen.last_loss(model: ScientificModel) -> Float64

`gen.load`

gen.load(path: String, device: String) -> LanguageModel
gen.load(path: String) -> LanguageModel

`gen.load_adapter`

gen.load_adapter(base: LanguageModel, path: String) -> LanguageModel

`gen.load_scientific`

gen.load_scientific(path: String, device: String) -> ScientificModel
gen.load_scientific(path: String) -> ScientificModel

`gen.logits`

gen.logits(model: LanguageModel, ids: List, batch: Int64, length: Int64, training: Bool) -> Tensor

`gen.lora`

gen.lora(model: LanguageModel, targets: List, rank: Int64, alpha: Float64, seed: Int64) -> LanguageModel

`gen.loss`

gen.loss(model: LanguageModel, corpus: TokenCorpus) -> Float64
gen.loss(model: ScientificModel, corpus: ScientificData, seed: Int64) -> Float64
gen.loss(model: ScientificModel, corpus: ScientificData) -> Float64

`gen.memory_estimate`

gen.memory_estimate(model: LanguageModel, batch: Int64, length: Int64, training: Bool) -> Dictionary

`gen.memory_summary`

gen.memory_summary(model: LanguageModel, batch: Int64, length: Int64, training: Bool) -> String

`gen.merge_lora`

gen.merge_lora(model: LanguageModel) -> LanguageModel

`gen.parameter`

gen.parameter(model: LanguageModel, name: String) -> Tensor
gen.parameter(model: ScientificModel, name: String) -> Tensor

`gen.parameter_names`

gen.parameter_names(model: LanguageModel) -> List
gen.parameter_names(model: ScientificModel) -> List

`gen.perplexity`

gen.perplexity(model: LanguageModel, corpus: TokenCorpus) -> Float64

`gen.poisson_residual`

gen.poisson_residual(fields: Tensor, forcing: Tensor, dx: Float64, dy: Float64) -> Float64

`gen.predict_noise`

gen.predict_noise(model: ScientificModel, noisy: Tensor, conditions: Tensor, timesteps: List, training: Bool) -> Tensor

`gen.predict_series`

gen.predict_series(model: ScientificModel, history: Tensor, conditions: Tensor, training: Bool) -> Tensor

`gen.resume`

gen.resume(model: LanguageModel, corpus: TokenCorpus, steps: Int64) -> LanguageModel
gen.resume(model: ScientificModel, corpus: ScientificData, steps: Int64) -> ScientificModel

`gen.role`

gen.role(value: ScientificData) -> String

`gen.sample_fields`

gen.sample_fields(model: ScientificModel, conditions: Tensor, seed: Int64) -> Tensor

`gen.sample_series`

gen.sample_series(model: ScientificModel, conditions: Tensor, prefix: Tensor, new_steps: Int64, seed: Int64) -> Tensor

`gen.samples`

gen.samples(value: ScientificData) -> Int64

`gen.save`

gen.save(model: LanguageModel, path: String) -> Unit
gen.save(model: ScientificModel, path: String) -> Unit

`gen.save_adapter`

gen.save_adapter(model: LanguageModel, path: String) -> Unit

`gen.scientific_memory`

gen.scientific_memory(model: ScientificModel, batch: Int64, training: Bool) -> Dictionary

`gen.scored_tokens`

gen.scored_tokens(corpus: TokenCorpus) -> Int64

`gen.series_data`

gen.series_data(values: Tensor, conditions: Tensor, role: String) -> ScientificData

`gen.series_model`

gen.series_model(channels: Int64, history: Int64, condition_size: Int64, width: Int64, innovation_sigma: Float64, seed: Int64) -> ScientificModel

`gen.series_spectrum`

gen.series_spectrum(values: Tensor) -> Tensor

`gen.series_statistics`

gen.series_statistics(values: Tensor, lag: Int64) -> Dictionary

`gen.steps`

gen.steps(model: LanguageModel) -> Int64
gen.steps(model: ScientificModel) -> Int64

`gen.summary`

gen.summary(model: LanguageModel) -> String
gen.summary(model: ScientificData) -> String
gen.summary(model: ScientificModel) -> String

`gen.to`

gen.to(model: LanguageModel, device: String, dtype: String) -> LanguageModel
gen.to(model: ScientificModel, device: String, dtype: String) -> ScientificModel

`gen.tokenizer`

gen.tokenizer(model: LanguageModel) -> Tokenizer

`gen.train`

gen.train(model: LanguageModel, corpus: TokenCorpus, steps: Int64, batch: Int64, rate: Float64, seed: Int64, clip_norm: Float64, warmup_steps: Int64, weight_decay: Float64) -> LanguageModel
gen.train(model: LanguageModel, corpus: TokenCorpus, steps: Int64, batch: Int64, rate: Float64, seed: Int64) -> LanguageModel
gen.train(model: ScientificModel, corpus: ScientificData, steps: Int64, batch: Int64, rate: Float64, seed: Int64, clip_norm: Float64, warmup_steps: Int64, weight_decay: Float64) -> ScientificModel
gen.train(model: ScientificModel, corpus: ScientificData, steps: Int64, batch: Int64, rate: Float64, seed: Int64) -> ScientificModel

`gen.trainable_parameters`

gen.trainable_parameters(model: LanguageModel) -> List

`gen.trained_samples`

gen.trained_samples(model: ScientificModel) -> Int64

`gen.trained_tokens`

gen.trained_tokens(model: LanguageModel) -> Int64

`gen.unfreeze`

gen.unfreeze(model: LanguageModel, names: List) -> LanguageModel

`gen.with_diffusion_ema`

gen.with_diffusion_ema(model: ScientificModel, decay: Float64) -> ScientificModel

`gen.with_diffusion_schedule_features`

gen.with_diffusion_schedule_features(model: ScientificModel) -> ScientificModel

`gen.with_diffusion_sobolev_loss`

gen.with_diffusion_sobolev_loss(model: ScientificModel, dx: Float64, dy: Float64, laplacian_weight: Float64) -> ScientificModel

`gen.with_diffusion_velocity_prediction`

gen.with_diffusion_velocity_prediction(model: ScientificModel, loss_weighting: String) -> ScientificModel
gen.with_diffusion_velocity_prediction(model: ScientificModel) -> ScientificModel

`gen.with_mass_constraint`

gen.with_mass_constraint(model: ScientificModel, condition_index: Int64, scale: Float64, offset: Float64, dx: Float64, dy: Float64) -> ScientificModel

`gen.with_parameter`

gen.with_parameter(model: LanguageModel, name: String, value: Tensor) -> LanguageModel
gen.with_parameter(model: ScientificModel, name: String, value: Tensor) -> ScientificModel

aner.geo

Open the aner.geo reference.

`geo.contains`

geo.contains(extent: GeoExtent, position: GeoPosition) -> Bool

`geo.east`

geo.east(extent: GeoExtent) -> Float64

`geo.extent`

geo.extent(west: Float64, south: Float64, east: Float64, north: Float64) -> GeoExtent

`geo.geojson`

geo.geojson(position: GeoPosition) -> String

`geo.great_circle_distance`

geo.great_circle_distance(a: GeoPosition, b: GeoPosition) -> Quantity<m>

`geo.latitude`

geo.latitude(position: GeoPosition) -> Float64

`geo.longitude`

geo.longitude(position: GeoPosition) -> Float64

`geo.north`

geo.north(extent: GeoExtent) -> Float64

`geo.position`

geo.position(longitude: Float64, latitude: Float64) -> GeoPosition

`geo.south`

geo.south(extent: GeoExtent) -> Float64

`geo.west`

geo.west(extent: GeoExtent) -> Float64

aner.llm

Open the aner.llm reference.

`llm.cache_write_input_tokens`

llm.cache_write_input_tokens(response: LLMResponse) -> Int64

`llm.cached_input_tokens`

llm.cached_input_tokens(response: LLMResponse) -> Int64

`llm.chat`

llm.chat(client: LLMClient, messages: List, max_tokens: Int64, temperature: Float64) -> LLMResponse
llm.chat(client: LLMClient, messages: List, max_tokens: Int64) -> LLMResponse
llm.chat(client: LLMClient, messages: List) -> LLMResponse

`llm.client`

llm.client(provider: String, model: String, endpoint: String, key: SecretRef, timeout_ms: Int64) -> LLMClient
llm.client(provider: String, model: String, endpoint: String, key: SecretRef) -> LLMClient
llm.client(provider: String, model: String, endpoint: String, timeout_ms: Int64) -> LLMClient
llm.client(provider: String, model: String, endpoint: String) -> LLMClient
llm.client(provider: String, model: String, key: SecretRef, timeout_ms: Int64) -> LLMClient
llm.client(provider: String, model: String, key: SecretRef) -> LLMClient
llm.client(provider: String, model: String, timeout_ms: Int64) -> LLMClient
llm.client(provider: String, model: String) -> LLMClient

`llm.finish_reason`

llm.finish_reason(response: LLMResponse) -> String

`llm.generate`

llm.generate(client: LLMClient, prompt: String, max_tokens: Int64, temperature: Float64) -> LLMResponse
llm.generate(client: LLMClient, prompt: String, max_tokens: Int64) -> LLMResponse
llm.generate(client: LLMClient, prompt: String) -> LLMResponse

`llm.input_tokens`

llm.input_tokens(response: LLMResponse) -> Int64

`llm.message`

llm.message(role: String, content: String) -> LLMMessage

`llm.model`

llm.model(value: LLMClient) -> String
llm.model(value: LLMResponse) -> String

`llm.output_tokens`

llm.output_tokens(response: LLMResponse) -> Int64

`llm.provider`

llm.provider(client: LLMClient) -> String

`llm.reasoning_tokens`

llm.reasoning_tokens(response: LLMResponse) -> Int64

`llm.text`

llm.text(response: LLMResponse) -> String

`llm.total_tokens`

llm.total_tokens(response: LLMResponse) -> Int64

aner.math

Open the aner.math reference.

`math.abs`

math.abs(value: Float64) -> Float64

`math.cos`

math.cos(value: Float64) -> Float64

`math.exp`

math.exp(value: Float64) -> Float64

`math.log`

math.log(value: Float64) -> Float64

`math.pow`

math.pow(base: Float64, exponent: Float64) -> Float64

`math.sin`

math.sin(value: Float64) -> Float64

`math.sqrt`

math.sqrt(value: Float64) -> Float64

`math.tan`

math.tan(value: Float64) -> Float64

aner.metrics

Open the aner.metrics reference.

`metrics.accuracy`

metrics.accuracy(predicted: Tensor, actual: Tensor) -> Float64

`metrics.adjusted_rand_index`

metrics.adjusted_rand_index(predicted: Tensor, actual: Tensor) -> Float64

`metrics.confusion_matrix`

metrics.confusion_matrix(predicted: Tensor, actual: Tensor, classes: Int64) -> Tensor

`metrics.mean_squared_error`

metrics.mean_squared_error(predicted: Tensor, actual: Tensor) -> Float64

aner.ml

Open the aner.ml reference.

`ml.accuracy`

ml.accuracy(report: EvaluationReport) -> Float64

`ml.bias`

ml.bias(model: FittedClassifier, layer: Int64) -> Tensor

`ml.center`

ml.center(model: FittedClassifier) -> Tensor
ml.center(self: FeatureLedger) -> Tensor

`ml.centers`

ml.centers(model: KMeansModel) -> Tensor

`ml.classes`

ml.classes(model: DecisionTreeClassifier) -> Tensor
ml.classes(model: KNNClassifier) -> Tensor

`ml.classifier`

ml.classifier(network: NeuralNetwork, standardize: Bool, loss: String, optimizer: String) -> ClassifierPipeline
ml.classifier(network: NeuralNetwork, standardize: Bool, loss: String) -> ClassifierPipeline
ml.classifier(network: NeuralNetwork, standardize: Bool) -> ClassifierPipeline

`ml.converged`

ml.converged(model: KMeansModel) -> Bool

`ml.depth`

ml.depth(model: DecisionTreeClassifier) -> Int64

`ml.evaluate`

ml.evaluate(model: FittedClassifier, testing: Dataset) -> EvaluationReport

`ml.explain`

ml.explain(self: ContextLinearModel) -> String
ml.explain(self: ContextPrediction) -> String
ml.explain(self: FeatureLedger) -> String

`ml.export_tree`

ml.export_tree(model: DecisionTreeClassifier, path: String) -> Unit

`ml.fit`

ml.fit(pipeline: ClassifierPipeline, training: Dataset, config: TrainingConfig, execution: ParallelContext, progress: Bool) -> FittedClassifier
ml.fit(pipeline: ClassifierPipeline, training: Dataset, config: TrainingConfig, execution: ParallelContext) -> FittedClassifier
ml.fit(pipeline: ClassifierPipeline, training: Dataset, config: TrainingConfig, progress: Bool) -> FittedClassifier
ml.fit(pipeline: ClassifierPipeline, training: Dataset, config: TrainingConfig) -> FittedClassifier
ml.fit(pipeline: ClassifierPipeline, training: Dataset, epochs: Int64, rate: Float64, progress: Bool) -> FittedClassifier
ml.fit(pipeline: ClassifierPipeline, training: Dataset, epochs: Int64, rate: Float64) -> FittedClassifier

`ml.fit_exploratory_standardizer`

ml.fit_exploratory_standardizer(data: AdaptiveFrame) -> FeatureLedger

`ml.fit_kmeans`

ml.fit_kmeans(features: Tensor, clusters: Int64, max_iterations: Int64, tolerance: Float64, seed: Int64) -> KMeansModel

`ml.fit_knn`

ml.fit_knn(features: Tensor, labels: Tensor, k: Int64) -> KNNClassifier

`ml.fit_linear`

ml.fit_linear(training: ContextBatch) -> ContextLinearModel

`ml.fit_standardizer`

ml.fit_standardizer(training: AdaptiveFrame) -> FeatureLedger

`ml.fit_tree`

ml.fit_tree(features: Tensor, labels: Tensor, criterion: String, max_depth: Int64, min_samples_split: Int64, min_samples_leaf: Int64) -> DecisionTreeClassifier
ml.fit_tree(features: Tensor, labels: Tensor, criterion: String, max_depth: Int64, min_samples_split: Int64) -> DecisionTreeClassifier
ml.fit_tree(features: Tensor, labels: Tensor, criterion: String, max_depth: Int64) -> DecisionTreeClassifier
ml.fit_tree(features: Tensor, labels: Tensor, criterion: String) -> DecisionTreeClassifier
ml.fit_tree(features: Tensor, labels: Tensor) -> DecisionTreeClassifier

`ml.inertia`

ml.inertia(model: KMeansModel) -> Float64

`ml.initial_loss`

ml.initial_loss(model: FittedClassifier) -> Float64

`ml.iterations`

ml.iterations(model: KMeansModel) -> Int64

`ml.labels`

ml.labels(model: KMeansModel) -> Tensor

`ml.load_classifier`

ml.load_classifier(path: String) -> FittedClassifier

`ml.load_linear`

ml.load_linear(path: String, training_anchor: ContextBatch) -> ContextLinearModel

`ml.load_standardizer`

ml.load_standardizer(path: String, training_anchor: AdaptiveFrame) -> FeatureLedger

`ml.loss`

ml.loss(report: EvaluationReport) -> Float64

`ml.neighbor_distances`

ml.neighbor_distances(model: KNNClassifier, input: Tensor) -> Tensor

`ml.neighbor_indices`

ml.neighbor_indices(model: KNNClassifier, input: Tensor) -> Tensor

`ml.node_count`

ml.node_count(model: DecisionTreeClassifier) -> Int64

`ml.on`

ml.on(pipeline: ClassifierPipeline, device: String, precision: String, policy: String) -> ClassifierPipeline
ml.on(pipeline: ClassifierPipeline, device: String) -> ClassifierPipeline

`ml.predict`

ml.predict(model: DecisionTreeClassifier, input: Tensor) -> Tensor
ml.predict(model: FittedClassifier, input: Dataset) -> Tensor
ml.predict(model: KMeansModel, input: Tensor) -> Tensor
ml.predict(model: KNNClassifier, input: Tensor) -> Tensor
ml.predict(self: ContextLinearModel, samples: ContextBatch) -> ContextPrediction

`ml.predict_proba`

ml.predict_proba(model: DecisionTreeClassifier, input: Tensor) -> Tensor
ml.predict_proba(model: KNNClassifier, input: Tensor) -> Tensor

`ml.probabilities`

ml.probabilities(model: FittedClassifier, input: Dataset) -> Tensor

`ml.rmse`

ml.rmse(self: ContextPrediction, targets: ContextBatch) -> Float64

`ml.row_id`

ml.row_id(self: ContextPrediction, index: Int64) -> Int64

`ml.row_ids`

ml.row_ids(report: EvaluationReport) -> Tensor
ml.row_ids(self: ContextPrediction) -> List

`ml.rows`

ml.rows(report: EvaluationReport) -> Int64

`ml.save`

ml.save(model: FittedClassifier, path: String) -> Unit
ml.save(self: ContextLinearModel, path: String) -> Unit
ml.save(self: FeatureLedger, path: String) -> Unit

`ml.scale`

ml.scale(model: FittedClassifier) -> Tensor
ml.scale(self: FeatureLedger) -> Tensor

`ml.select_best`

ml.select_best(config: TrainingConfig, enabled: Bool) -> TrainingConfig

`ml.summary`

ml.summary(self: ContextLinearModel) -> String
ml.summary(self: ContextPrediction) -> String
ml.summary(self: FeatureLedger) -> String
ml.summary(value: ClassifierPipeline) -> String
ml.summary(value: EvaluationReport) -> String
ml.summary(value: FittedClassifier) -> String
ml.summary(value: NeuralNetwork) -> String
ml.summary(value: TrainingConfig) -> String

`ml.training`

ml.training(epochs: Int64, batch: Int64, rate: Float64, seed: Int64) -> TrainingConfig

`ml.training_accuracy`

ml.training_accuracy(model: FittedClassifier) -> Float64

`ml.training_loss`

ml.training_loss(model: FittedClassifier) -> Float64

`ml.training_row_ids`

ml.training_row_ids(model: FittedClassifier) -> Tensor

`ml.training_seconds`

ml.training_seconds(model: FittedClassifier) -> Float64

`ml.transform`

ml.transform(self: FeatureLedger, data: AdaptiveFrame) -> AdaptiveFrame

`ml.tree_dot`

ml.tree_dot(model: DecisionTreeClassifier) -> String

`ml.tree_svg`

ml.tree_svg(model: DecisionTreeClassifier) -> String

`ml.tree_text`

ml.tree_text(model: DecisionTreeClassifier) -> String

`ml.unit`

ml.unit(self: ContextPrediction) -> String

`ml.validation`

ml.validation(config: TrainingConfig, data: Dataset) -> TrainingConfig

`ml.values`

ml.values(self: ContextPrediction) -> SemanticTensor

`ml.warm_start`

ml.warm_start(pipeline: ClassifierPipeline, model: FittedClassifier) -> ClassifierPipeline

`ml.weights`

ml.weights(model: FittedClassifier, layer: Int64) -> Tensor

aner.nn

Open the aner.nn reference.

`nn.accuracy`

nn.accuracy(scores: Tensor, labels: Tensor) -> Float64

`nn.add`

nn.add(a: Tensor, b: Tensor) -> Tensor

`nn.add_bias`

nn.add_bias(value: Tensor, bias: Tensor) -> Tensor

`nn.argmax`

nn.argmax(value: Tensor) -> Tensor

`nn.astype`

nn.astype(value: Tensor, dtype: String) -> Tensor

`nn.attention`

nn.attention(query: Tensor, key: Tensor, value: Tensor, mask: Tensor, causal: Bool, offset: Int64) -> Tensor

`nn.backend`

nn.backend() -> String
nn.backend(value: Tensor) -> String

`nn.backend_details`

nn.backend_details() -> String

`nn.backward`

nn.backward(loss: Tensor) -> Unit

`nn.clip_grad_norm`

nn.clip_grad_norm(parameters: List, max_norm: Float64) -> Float64

`nn.clock`

nn.clock() -> Float64

`nn.cols`

nn.cols(value: Tensor) -> Int64

`nn.configure`

nn.configure(device: String, precision: String, policy: String) -> Unit

`nn.cross_entropy`

nn.cross_entropy(logits: Tensor, targets: Tensor) -> Tensor

`nn.cross_entropy_ids`

nn.cross_entropy_ids(logits: Tensor, targets: List, ignore_index: Int64) -> Tensor

`nn.dense`

nn.dense(network: NeuralNetwork, inputs: Int64, outputs: Int64, initialization: String) -> NeuralNetwork
nn.dense(network: NeuralNetwork, inputs: Int64, outputs: Int64, weights: Tensor, bias: Tensor) -> NeuralNetwork
nn.dense(network: NeuralNetwork, inputs: Int64, outputs: Int64) -> NeuralNetwork

`nn.detach`

nn.detach(value: Tensor) -> Tensor

`nn.device`

nn.device(value: Tensor) -> String

`nn.device_available`

nn.device_available(device: String) -> Bool

`nn.devices`

nn.devices() -> String

`nn.dropout`

nn.dropout(value: Tensor, probability: Float64, seed: Int64, training: Bool) -> Tensor

`nn.dtype`

nn.dtype(value: Tensor) -> String

`nn.embedding`

nn.embedding(table: Tensor, ids: List, shape: List) -> Tensor

`nn.execution`

nn.execution() -> String

`nn.execution_context`

nn.execution_context() -> ParallelContext
nn.execution_context(device: String, dtype: String) -> ParallelContext

`nn.gelu`

nn.gelu(value: Tensor) -> Tensor

`nn.grad`

nn.grad(value: Tensor) -> Tensor

`nn.item`

nn.item(value: Tensor) -> Float64

`nn.layer_norm`

nn.layer_norm(value: Tensor, gain: Tensor, bias: Tensor, epsilon: Float64) -> Tensor

`nn.masked_softmax`

nn.masked_softmax(scores: Tensor, mask: Tensor, causal: Bool, offset: Int64) -> Tensor

`nn.matmul`

nn.matmul(a: Tensor, b: Tensor) -> Tensor

`nn.mean`

nn.mean(value: Tensor) -> Tensor

`nn.memory`

nn.memory() -> String

`nn.mlp`

nn.mlp(inputs: Int64, hidden: List, outputs: Int64, seed: Int64) -> NeuralNetwork

`nn.mse`

nn.mse(prediction: Tensor, target: Tensor) -> Tensor

`nn.multiply`

nn.multiply(a: Tensor, b: Tensor) -> Tensor

`nn.optimizer`

nn.optimizer(name: String, rate: Float64) -> Optimizer

`nn.parameter`

nn.parameter(value: Tensor) -> Tensor

`nn.place`

nn.place(value: Tensor) -> Tensor

`nn.random`

nn.random(rows: Int64, cols: Int64, seed: Int64, scale: Float64) -> Tensor

`nn.relu`

nn.relu(value: NeuralNetwork) -> NeuralNetwork
nn.relu(value: Tensor) -> Tensor

`nn.require_device`

nn.require_device(device: String) -> Unit

`nn.reset`

nn.reset(optimizer: Optimizer) -> Unit

`nn.reset_memory_peaks`

nn.reset_memory_peaks() -> Unit

`nn.rows`

nn.rows(value: Tensor) -> Int64

`nn.scale`

nn.scale(value: Tensor, factor: Float64) -> Tensor

`nn.sequential`

nn.sequential(seed: Int64) -> NeuralNetwork

`nn.sgd`

nn.sgd(parameter: Tensor, rate: Float64) -> Tensor

`nn.sigmoid`

nn.sigmoid(value: NeuralNetwork) -> NeuralNetwork
nn.sigmoid(value: Tensor) -> Tensor

`nn.softmax`

nn.softmax(value: Tensor) -> Tensor

`nn.subtract`

nn.subtract(a: Tensor, b: Tensor) -> Tensor

`nn.summary`

nn.summary(network: NeuralNetwork) -> String
nn.summary(network: Optimizer) -> String

`nn.synchronize`

nn.synchronize(device: String) -> Unit

`nn.tanh`

nn.tanh(value: NeuralNetwork) -> NeuralNetwork
nn.tanh(value: Tensor) -> Tensor

`nn.to`

nn.to(value: Tensor, device: String) -> Tensor

`nn.transpose`

nn.transpose(value: Tensor) -> Tensor

`nn.update`

nn.update(optimizer: Optimizer, parameter: Tensor, key: String) -> Tensor

`nn.value`

nn.value(tensor: Tensor, row: Int64, column: Int64) -> Float64

`nn.xavier`

nn.xavier(rows: Int64, cols: Int64, seed: Int64) -> Tensor

`nn.zeros`

nn.zeros(rows: Int64, cols: Int64) -> Tensor

aner.parallel

Open the aner.parallel reference.

`parallel.cluster`

parallel.cluster(config: String) -> ParallelContext

`parallel.cols`

parallel.cols(result: SimulationResults) -> Int64

`parallel.column`

parallel.column(result: SimulationResults, column: Int64) -> List

`parallel.inventory`

parallel.inventory() -> String

`parallel.local`

parallel.local() -> ParallelContext
parallel.local(workers: Int64) -> ParallelContext

`parallel.mean`

parallel.mean(result: SimulationResults, column: Int64) -> Float64
parallel.mean(result: SimulationResults) -> Float64

`parallel.repeat`

parallel.repeat(iterations: Int64, task: ParallelTask, parameters: List, execution: ParallelContext, seed: Int64, max_bytes: Int64) -> SimulationResults
parallel.repeat(iterations: Int64, task: ParallelTask, parameters: List, execution: ParallelContext, seed: Int64) -> SimulationResults
parallel.repeat(iterations: Int64, task: ParallelTask, parameters: List, execution: ParallelContext) -> SimulationResults
parallel.repeat(iterations: Int64, task: ParallelTask, parameters: List) -> SimulationResults

`parallel.row`

parallel.row(result: SimulationResults, iteration: Int64) -> List

`parallel.rows`

parallel.rows(result: SimulationResults) -> Int64

`parallel.save_csv`

parallel.save_csv(result: SimulationResults, path: String) -> Unit

`parallel.seconds`

parallel.seconds(result: SimulationResults) -> Float64

`parallel.seed`

parallel.seed(result: SimulationResults, iteration: Int64) -> Int64
parallel.seed(result: SimulationResults) -> Int64

`parallel.std`

parallel.std(result: SimulationResults, column: Int64, sample: Bool) -> Float64
parallel.std(result: SimulationResults, column: Int64) -> Float64
parallel.std(result: SimulationResults) -> Float64

`parallel.summary`

parallel.summary(result: SimulationResults) -> String

`parallel.value`

parallel.value(result: SimulationResults, iteration: Int64, column: Int64) -> Float64

`parallel.variance`

parallel.variance(result: SimulationResults, column: Int64, sample: Bool) -> Float64
parallel.variance(result: SimulationResults, column: Int64) -> Float64
parallel.variance(result: SimulationResults) -> Float64

`parallel.workers`

parallel.workers(result: SimulationResults) -> Int64

aner.plot

Open the aner.plot reference.

`plot.add_line`

plot.add_line(chart: Chart, x: Any, y: Any, name: String) -> Chart

`plot.add_points`

plot.add_points(chart: Chart, positions: List, values: Any, labels: List) -> Chart
plot.add_points(chart: Chart, positions: List, values: Any) -> Chart

`plot.annotate`

plot.annotate(chart: Chart, x: Float64, y: Float64, text: String) -> Chart

`plot.aspect`

plot.aspect(chart: Chart, mode: String) -> Chart

`plot.bar`

plot.bar(labels: List, values: Any) -> Chart

`plot.boundaries`

plot.boundaries(region: String) -> String

`plot.box`

plot.box(values: Any) -> Chart

`plot.caption`

plot.caption(chart: Chart, text: String) -> Chart

`plot.choropleth`

plot.choropleth(geojson: String, property: String, keys: List, values: Any) -> Chart

`plot.color_label`

plot.color_label(chart: Chart, text: String) -> Chart

`plot.color_limits`

plot.color_limits(chart: Chart, minimum: Float64, maximum: Float64) -> Chart

`plot.company`

plot.company(theme: ChartTheme, name: String, background: String, foreground: String, colors: List) -> ChartTheme

`plot.extent`

plot.extent(chart: Chart, bounds: GeoExtent) -> Chart
plot.extent(chart: Chart, west: Float64, south: Float64, east: Float64, north: Float64) -> Chart

`plot.focus`

plot.focus(chart: Chart, key: String, padding: Float64) -> Chart
plot.focus(chart: Chart, key: String) -> Chart

`plot.geo_scatter`

plot.geo_scatter(positions: List, values: Any, labels: List) -> Chart
plot.geo_scatter(positions: List, values: Any) -> Chart

`plot.geojson`

plot.geojson(path: String) -> String

`plot.heatmap`

plot.heatmap(values: Any, rows: Int64, columns: Int64) -> Chart

`plot.histogram`

plot.histogram(values: Any, bins: Int64) -> Chart
plot.histogram(values: Any) -> Chart

`plot.html`

plot.html(chart: Chart) -> String

`plot.labels`

plot.labels(chart: Chart, x: String, y: String, z: String) -> Chart
plot.labels(chart: Chart, x: String, y: String) -> Chart

`plot.line`

plot.line(x: Any, y: Any) -> Chart

`plot.line3d`

plot.line3d(x: Any, y: Any, z: Any) -> Chart

`plot.link`

plot.link(chart: Chart, group: String, ids: List) -> Chart

`plot.map`

plot.map(region: String, keys: List, values: Any) -> Chart

`plot.palette`

plot.palette(theme: ChartTheme, colors: List) -> ChartTheme

`plot.point_labels`

plot.point_labels(chart: Chart, mode: String) -> Chart

`plot.point_size`

plot.point_size(chart: Chart, radius: Float64) -> Chart

`plot.point_sizes`

plot.point_sizes(chart: Chart, values: Any, max_radius: Float64) -> Chart
plot.point_sizes(chart: Chart, values: Any) -> Chart

`plot.projection`

plot.projection(chart: Chart, name: String) -> Chart

`plot.rotation`

plot.rotation(chart: Chart, x: Float64, y: Float64, z: Float64) -> Chart

`plot.save`

plot.save(chart: Chart, path: String) -> Unit

`plot.scatter`

plot.scatter(x: Any, y: Any) -> Chart

`plot.scatter3d`

plot.scatter3d(x: Any, y: Any, z: Any, values: Any) -> Chart
plot.scatter3d(x: Any, y: Any, z: Any) -> Chart

`plot.scatter3d_frames`

plot.scatter3d_frames(times: List, x: Any, y: Any, z: Any, values: Any) -> Chart

`plot.scatter3d_frames_table`

plot.scatter3d_frames_table(table: DataTable) -> Chart

`plot.show`

plot.show(chart: Chart) -> Unit

`plot.site_dashboard`

plot.site_dashboard(dates: List, sites: List, positions: List, counts: List, map: Chart) -> Chart
plot.site_dashboard(dates: List, sites: List, positions: List, counts: List) -> Chart

`plot.site_dashboard_table`

plot.site_dashboard_table(table: DataTable, map: Chart) -> Chart
plot.site_dashboard_table(table: DataTable) -> Chart

`plot.size`

plot.size(chart: Chart, width: Int64, height: Int64) -> Chart

`plot.summary`

plot.summary(value: Chart) -> String
plot.summary(value: ChartTheme) -> String

`plot.surface3d`

plot.surface3d(x: Any, y: Any, z: Any) -> Chart

`plot.svg`

plot.svg(chart: Chart) -> String

`plot.theme`

plot.theme(chart: Chart, theme: ChartTheme) -> Chart
plot.theme(name: String) -> ChartTheme

`plot.time_frame`

plot.time_frame(chart: Chart, frame: Int64) -> Chart

`plot.title`

plot.title(chart: Chart, text: String) -> Chart

`plot.usa`

plot.usa(keys: List, values: Any) -> Chart

`plot.view`

plot.view(chart: Chart, azimuth: Float64, elevation: Float64) -> Chart

`plot.view_zoom`

plot.view_zoom(chart: Chart, zoom: Float64) -> Chart

`plot.world`

plot.world(keys: List, values: Any) -> Chart

aner.quantum

Open the aner.quantum reference.

`quantum.available`

quantum.available(backend: QuantumBackend) -> Bool

`quantum.circuit`

quantum.circuit(qubits: Int64) -> QuantumCircuit

`quantum.cluster`

quantum.cluster() -> QuantumBackend

`quantum.count`

quantum.count(result: QuantumResult, bits: String) -> Int64

`quantum.counts`

quantum.counts(result: QuantumResult) -> Dictionary

`quantum.cpu`

quantum.cpu() -> QuantumBackend

`quantum.cx`

quantum.cx(circuit: QuantumCircuit, control: Int64, target: Int64) -> QuantumCircuit

`quantum.cz`

quantum.cz(circuit: QuantumCircuit, control: Int64, target: Int64) -> QuantumCircuit

`quantum.expectation_z`

quantum.expectation_z(result: QuantumResult, qubit: Int64) -> Float64

`quantum.gates`

quantum.gates(circuit: QuantumCircuit) -> Int64

`quantum.gpu`

quantum.gpu() -> QuantumBackend

`quantum.h`

quantum.h(circuit: QuantumCircuit, qubit: Int64) -> QuantumCircuit

`quantum.hardware`

quantum.hardware(target: String) -> QuantumBackend

`quantum.probability`

quantum.probability(result: QuantumResult, bits: String) -> Float64

`quantum.qubits`

quantum.qubits(circuit: QuantumCircuit) -> Int64

`quantum.run`

quantum.run(circuit: QuantumCircuit, backend: QuantumBackend, shots: Int64, seed: Int64) -> QuantumResult

`quantum.rx`

quantum.rx(circuit: QuantumCircuit, qubit: Int64, angle: Float64) -> QuantumCircuit

`quantum.ry`

quantum.ry(circuit: QuantumCircuit, qubit: Int64, angle: Float64) -> QuantumCircuit

`quantum.rz`

quantum.rz(circuit: QuantumCircuit, qubit: Int64, angle: Float64) -> QuantumCircuit

`quantum.s`

quantum.s(circuit: QuantumCircuit, qubit: Int64) -> QuantumCircuit

`quantum.sampled_z`

quantum.sampled_z(result: QuantumResult, qubit: Int64) -> Float64

`quantum.shots`

quantum.shots(result: QuantumResult) -> Int64

`quantum.summary`

quantum.summary(value: QuantumBackend) -> String
quantum.summary(value: QuantumCircuit) -> String
quantum.summary(value: QuantumResult) -> String

`quantum.swap`

quantum.swap(circuit: QuantumCircuit, a: Int64, b: Int64) -> QuantumCircuit

`quantum.t`

quantum.t(circuit: QuantumCircuit, qubit: Int64) -> QuantumCircuit

`quantum.x`

quantum.x(circuit: QuantumCircuit, qubit: Int64) -> QuantumCircuit

`quantum.y`

quantum.y(circuit: QuantumCircuit, qubit: Int64) -> QuantumCircuit

`quantum.z`

quantum.z(circuit: QuantumCircuit, qubit: Int64) -> QuantumCircuit

aner.random

Open the aner.random reference.

`RandomGenerator.bernoulli`

RandomGenerator.bernoulli(generator: RandomGenerator, probability: Float64) -> Bool

`RandomGenerator.choice`

RandomGenerator.choice(generator: RandomGenerator, values: List, weights: List) -> Any
RandomGenerator.choice(generator: RandomGenerator, values: List) -> Any

`RandomGenerator.integer`

RandomGenerator.integer(generator: RandomGenerator, low: Int64, high: Int64) -> Int64

`RandomGenerator.normal`

RandomGenerator.normal(generator: RandomGenerator, mean: Float64, stddev: Float64) -> Float64

`RandomGenerator.position`

RandomGenerator.position(generator: RandomGenerator) -> Int64

`RandomGenerator.reseed`

RandomGenerator.reseed(generator: RandomGenerator, seed: Int64) -> Unit

`RandomGenerator.seed`

RandomGenerator.seed(generator: RandomGenerator) -> Int64

`RandomGenerator.uniform`

RandomGenerator.uniform(generator: RandomGenerator) -> Float64

`RandomGenerator.weighted_index`

RandomGenerator.weighted_index(generator: RandomGenerator, weights: List) -> Int64

`random.bernoulli`

random.bernoulli(probability: Float64, seed: Int64, draw: Int64) -> Bool
random.bernoulli(probability: Float64, seed: Int64) -> Bool

`random.choice`

random.choice(values: List, seed: Int64, draw: Int64) -> Any
random.choice(values: List, seed: Int64) -> Any
random.choice(values: List, weights: List, seed: Int64, draw: Int64) -> Any
random.choice(values: List, weights: List, seed: Int64) -> Any

`random.engine`

random.engine() -> String

`random.generator`

random.generator() -> RandomGenerator
random.generator(seed: Int64) -> RandomGenerator

`random.integer`

random.integer(low: Int64, high: Int64, seed: Int64, draw: Int64) -> Int64
random.integer(low: Int64, high: Int64, seed: Int64) -> Int64

`random.normal`

random.normal(mean: Float64, stddev: Float64, seed: Int64, draw: Int64) -> Float64
random.normal(mean: Float64, stddev: Float64, seed: Int64) -> Float64

`random.seed`

random.seed() -> Int64

`random.uniform`

random.uniform(seed: Int64, draw: Int64) -> Float64
random.uniform(seed: Int64) -> Float64

`random.weighted_index`

random.weighted_index(weights: List, seed: Int64, draw: Int64) -> Int64
random.weighted_index(weights: List, seed: Int64) -> Int64

aner.science

Open the aner.science reference.

`science.add`

science.add(self: EvidenceTensor, other: EvidenceTensor) -> EvidenceTensor

`science.affine`

science.affine(self: EvidenceTensor, slope: Float64, intercept: Float64, slope_unit: String, output_unit: String) -> EvidenceTensor

`science.calibrated`

science.calibrated(values: Tensor, unit: String, noise_stddev: Float64, calibration_stddev: Float64) -> EvidenceTensor

`science.convert`

science.convert(self: EvidenceTensor, unit: String) -> EvidenceTensor

`science.covariance`

science.covariance(self: EvidenceTensor, row: Int64, column: Int64, other: EvidenceTensor, other_row: Int64, other_column: Int64) -> Float64

`science.exact`

science.exact(values: SemanticTensor) -> EvidenceTensor

`science.explain`

science.explain(self: EvidenceTensor) -> String

`science.export_values`

science.export_values(self: EvidenceTensor, reason: String) -> ContextExport

`science.gather_rows`

science.gather_rows(self: EvidenceTensor, indices: List) -> EvidenceTensor

`science.item`

science.item(self: EvidenceTensor) -> Float64

`science.mean`

science.mean(self: EvidenceTensor, other: EvidenceTensor) -> EvidenceTensor

`science.measurements`

science.measurements(values: SemanticTensor, source_names: List, stddevs: List, coefficients: Tensor, error_unit: String, independence: String) -> EvidenceTensor

`science.source_bytes`

science.source_bytes(self: EvidenceTensor) -> Int64

`science.source_entries`

science.source_entries(self: EvidenceTensor) -> Int64

`science.standard_uncertainty`

science.standard_uncertainty(self: EvidenceTensor, row: Int64, column: Int64) -> Float64
science.standard_uncertainty(self: EvidenceTensor) -> Float64

`science.subtract`

science.subtract(self: EvidenceTensor, other: EvidenceTensor) -> EvidenceTensor

`science.summary`

science.summary(self: EvidenceTensor) -> String

`science.unit`

science.unit(self: EvidenceTensor) -> String

`science.unknown`

science.unknown(values: SemanticTensor) -> EvidenceTensor

`science.variance`

science.variance(self: EvidenceTensor, row: Int64, column: Int64) -> Float64
science.variance(self: EvidenceTensor) -> Float64

aner.secrets

Open the aner.secrets reference.

`secrets.dotenv`

secrets.dotenv(path: String, name: String) -> SecretRef

`secrets.env`

secrets.env(name: String) -> SecretRef

`secrets.file`

secrets.file(name: String) -> SecretRef

`secrets.stored`

secrets.stored(name: String) -> SecretRef

aner.tensor

Open the aner.tensor reference.

`tensor.add`

tensor.add(self: SemanticTensor, other: SemanticTensor) -> SemanticTensor

`tensor.argmax`

tensor.argmax(value: Tensor) -> Tensor

`tensor.astype`

tensor.astype(self: SemanticTensor, dtype: String) -> SemanticTensor

`tensor.batched_matmul`

tensor.batched_matmul(a: Tensor, b: Tensor) -> Tensor

`tensor.broadcast_to`

tensor.broadcast_to(value: Tensor, shape: List) -> Tensor

`tensor.cols`

tensor.cols(self: SemanticTensor) -> Int64
tensor.cols(value: Tensor) -> Int64

`tensor.concatenate`

tensor.concatenate(a: Tensor, b: Tensor, axis: Int64) -> Tensor

`tensor.convert`

tensor.convert(self: SemanticTensor, unit: String) -> SemanticTensor

`tensor.coordinates`

tensor.coordinates(self: SemanticTensor) -> List

`tensor.device`

tensor.device(self: SemanticTensor) -> String

`tensor.dim`

tensor.dim(value: Tensor, axis: Int64) -> Int64

`tensor.dtype`

tensor.dtype(self: SemanticTensor) -> String

`tensor.explain`

tensor.explain(self: SemanticTensor) -> String

`tensor.export_values`

tensor.export_values(self: SemanticTensor, reason: String) -> ContextExport

`tensor.gather_rows`

tensor.gather_rows(self: SemanticTensor, indices: List) -> SemanticTensor

`tensor.item`

tensor.item(value: Tensor) -> Float64

`tensor.permute`

tensor.permute(value: Tensor, axes: List) -> Tensor

`tensor.random`

tensor.random(rows: Int64, cols: Int64, seed: Int64, scale: Float64) -> Tensor

`tensor.rank`

tensor.rank(value: Tensor) -> Int64

`tensor.reindex_like`

tensor.reindex_like(self: SemanticTensor, reference: SemanticTensor) -> SemanticTensor

`tensor.reshape`

tensor.reshape(value: Tensor, shape: List) -> Tensor

`tensor.rows`

tensor.rows(self: SemanticTensor) -> Int64
tensor.rows(value: Tensor) -> Int64

`tensor.semantic`

tensor.semantic(values: Tensor, axis: String, coordinates: List, unit: String) -> SemanticTensor

`tensor.slice`

tensor.slice(value: Tensor, axis: Int64, start: Int64, length: Int64) -> Tensor

`tensor.subtract`

tensor.subtract(self: SemanticTensor, other: SemanticTensor) -> SemanticTensor

`tensor.sum`

tensor.sum(value: Tensor, axis: Int64) -> Tensor

`tensor.summary`

tensor.summary(self: SemanticTensor) -> String

`tensor.to`

tensor.to(self: SemanticTensor, device: String) -> SemanticTensor

`tensor.unit`

tensor.unit(self: SemanticTensor) -> String

`tensor.value`

tensor.value(self: SemanticTensor, row: Int64, column: Int64) -> Float64
tensor.value(tensor: Tensor, row: Int64, column: Int64) -> Float64

`tensor.zeros`

tensor.zeros(rows: Int64, cols: Int64) -> Tensor

aner.token

Open the aner.token reference.

`token.bos`

token.bos(value: Tokenizer) -> Int64

`token.bpe`

token.bpe(training: TokenCorpus, vocabulary: Int64, min_frequency: Int64) -> Tokenizer

`token.byte_tokenizer`

token.byte_tokenizer() -> Tokenizer

`token.corpus`

token.corpus(codec: Tokenizer, documents: List, role: String) -> TokenCorpus

`token.decode`

token.decode(codec: Tokenizer, ids: List, skip_special: Bool) -> String

`token.decode_bytes`

token.decode_bytes(codec: Tokenizer, ids: List, skip_special: Bool) -> Bytes

`token.documents`

token.documents(value: TokenCorpus) -> Int64

`token.encode`

token.encode(codec: Tokenizer, text: String, bos: Bool, eos: Bool) -> List

`token.encode_bytes`

token.encode_bytes(codec: Tokenizer, data: Bytes, bos: Bool, eos: Bool) -> List

`token.eos`

token.eos(value: Tokenizer) -> Int64

`token.files`

token.files(codec: Tokenizer, paths: List, role: String, max_bytes: Int64) -> TokenCorpus

`token.fingerprint`

token.fingerprint(value: TokenCorpus) -> String
token.fingerprint(value: Tokenizer) -> String

`token.import_gpt2`

token.import_gpt2(vocabulary_path: String, merges_path: String) -> Tokenizer

`token.load`

token.load(path: String) -> Tokenizer

`token.pad`

token.pad(value: Tokenizer) -> Int64

`token.role`

token.role(value: TokenCorpus) -> String

`token.save`

token.save(codec: Tokenizer, path: String) -> Unit

`token.summary`

token.summary(value: TokenCorpus) -> String

`token.tokens`

token.tokens(value: TokenCorpus) -> Int64

`token.vocabulary`

token.vocabulary(value: Tokenizer) -> Int64

aner.units

Open the aner.units reference.

`units.convert`

units.convert(value: Quantity<Unit> | Point<Unit>, target_unit: String) -> Quantity<TargetUnit> | Point<TargetUnit>

`units.point`

units.point(value: Float64, unit: String) -> Point<Unit>

`units.quantity`

units.quantity(value: Float64, unit: String) -> Quantity<Unit>

`units.to`

units.to(self: Quantity<Unit> | Point<Unit>, target_unit: String) -> Quantity<TargetUnit> | Point<TargetUnit>

`units.unit`

units.unit(value: Quantity<Unit> | Point<Unit>) -> String

`units.value`

units.value(value: Quantity<Unit> | Point<Unit>) -> Float64

aner.viz

Open the aner.viz reference.

`viz.capture`

viz.capture(step: Int64, loss: Tensor) -> Unit

Array

Open the Array reference.

`Array`

Array(size: Int64, fill: T) -> Array<T>

`Array.add`

Array.add(self: Array<T>, other: Any) -> Array<T>
Array.add(self: Array<T>, other: Array<T>) -> Array<T>

`Array.argmax`

Array.argmax(self: Array<T>) -> Int64

`Array.argmin`

Array.argmin(self: Array<T>) -> Int64

`Array.astype`

Array.astype(self: Array<T>, dtype: String) -> Array<T>

`Array.capacity`

Array.capacity(self: Array<T>) -> Int64

`Array.contains`

Array.contains(self: Array<T>, value: T) -> Bool

`Array.copy`

Array.copy(self: Array<T>) -> Array<T>

`Array.cumsum`

Array.cumsum(self: Array<T>) -> Array<T>

`Array.div`

Array.div(self: Array<T>, other: Any) -> Array<T>
Array.div(self: Array<T>, other: Array<T>) -> Array<T>

`Array.dot`

Array.dot(self: Array<T>, other: Any) -> T
Array.dot(self: Array<T>, other: Array<T>) -> T

`Array.fill`

Array.fill(self: Array<T>, value: T) -> Unit

`Array.find`

Array.find(self: Array<T>, value: T) -> Int64

`Array.from_tensor`

Array.from_tensor(tensor: Tensor) -> Array<T>

`Array.get`

Array.get(self: Array<T>, index: Int64) -> T

`Array.is_empty`

Array.is_empty(self: Array<T>) -> Bool

`Array.is_sorted`

Array.is_sorted(self: Array<T>) -> Bool

`Array.len`

Array.len(self: Array<T>) -> Int64

`Array.max`

Array.max(self: Array<T>) -> T

`Array.mean`

Array.mean(self: Array<T>) -> Float64
Array.mean(self: Array<T>) -> T

`Array.min`

Array.min(self: Array<T>) -> T

`Array.mul`

Array.mul(self: Array<T>, other: Any) -> Array<T>
Array.mul(self: Array<T>, other: Array<T>) -> Array<T>

`Array.reshape`

Array.reshape(self: Array<T>, shape: List) -> NDArray<T>

`Array.reverse`

Array.reverse(self: Array<T>) -> Unit

`Array.scale`

Array.scale(self: Array<T>, factor: Float64) -> Array<T>
Array.scale(self: Array<T>, factor: T) -> Array<T>

`Array.set`

Array.set(self: Array<T>, index: Int64, value: T) -> Unit

`Array.slice`

Array.slice(self: Array<T>, start: Int64, stop: Int64) -> Array<T>

`Array.sort`

Array.sort(self: Array<T>) -> Unit

`Array.std`

Array.std(self: Array<T>) -> Float64
Array.std(self: Array<T>) -> Quantity<DifferenceUnit>

`Array.sub`

Array.sub(self: Array<T>, other: Any) -> Array<T>
Array.sub(self: Array<T>, other: Array<T>) -> Array<T>

`Array.sum`

Array.sum(self: Array<T>) -> T

`Array.to`

Array.to(self: Array<T>, target_unit: String) -> Array<T>

`Array.to_float`

Array.to_float(self: Array<T>) -> Array<Float64>

`Array.to_list`

Array.to_list(self: Array<T>) -> List

`Array.to_tensor`

Array.to_tensor(self: Array<T>, rows: Int64, cols: Int64) -> Tensor

`Array.unit`

Array.unit(self: Array<T>) -> String

`Array.values`

Array.values(self: Array<T>) -> Array<Float64>

`Array.variance`

Array.variance(self: Array<T>) -> Float64
Array.variance(self: Array<T>) -> Quantity<SquaredDifferenceUnit>

Bytes

Open the Bytes reference.

`Bytes`

Bytes() -> Bytes

`Bytes.compare`

Bytes.compare(self: Bytes, other: Bytes) -> Int64

`Bytes.concat`

Bytes.concat(self: Bytes, other: Bytes) -> Bytes

`Bytes.contains`

Bytes.contains(self: Bytes, needle: Bytes) -> Bool

`Bytes.decode_utf8`

Bytes.decode_utf8(self: Bytes) -> String

`Bytes.encode_utf8`

Bytes.encode_utf8(text: String) -> Bytes

`Bytes.find`

Bytes.find(self: Bytes, needle: Bytes) -> Int64

`Bytes.from_hex`

Bytes.from_hex(text: String) -> Bytes

`Bytes.from_i64`

Bytes.from_i64(value: Int64, byte_order: String) -> Bytes

`Bytes.from_values`

Bytes.from_values(values: List) -> Bytes

`Bytes.get`

Bytes.get(self: Bytes, index: Int64) -> Int64

`Bytes.hex`

Bytes.hex(self: Bytes) -> String

`Bytes.is_empty`

Bytes.is_empty(self: Bytes) -> Bool

`Bytes.len`

Bytes.len(self: Bytes) -> Int64

`Bytes.slice`

Bytes.slice(self: Bytes, start: Int64, end: Int64) -> Bytes

`Bytes.to_i64`

Bytes.to_i64(self: Bytes, byte_order: String) -> Int64

`Bytes.try_decode_utf8`

Bytes.try_decode_utf8(self: Bytes) -> Result<String, String>

`Bytes.try_from_hex`

Bytes.try_from_hex(text: String) -> Result<Bytes, String>

ContextExport

Open the ContextExport reference.

`ContextExport.report`

ContextExport.report(self: ContextExport) -> String

`ContextExport.values`

ContextExport.values(self: ContextExport) -> Tensor

Date

Open the Date reference.

`Date`

Date(year: Int64, month: Int64, day: Int64) -> Date

`Date.add_days`

Date.add_days(self: Date, count: Int64) -> Date

`Date.day`

Date.day(self: Date) -> Int64

`Date.days_until`

Date.days_until(self: Date, other: Date) -> Int64

`Date.epoch_days`

Date.epoch_days(self: Date) -> Int64

`Date.from_epoch_days`

Date.from_epoch_days(days: Int64) -> Date

`Date.month`

Date.month(self: Date) -> Int64

`Date.parse`

Date.parse(text: String) -> Date

`Date.str`

Date.str(self: Date) -> String

`Date.try_parse`

Date.try_parse(text: String) -> Result<Date, String>

`Date.weekday`

Date.weekday(self: Date) -> Int64

`Date.year`

Date.year(self: Date) -> Int64

DateTime

Open the DateTime reference.

`DateTime`

DateTime(date: Date, time: Time, offset_minutes: Int64) -> DateTime
DateTime(date: Date, time: Time) -> DateTime

`DateTime.add`

DateTime.add(self: DateTime, duration: Duration) -> DateTime

`DateTime.date`

DateTime.date(self: DateTime) -> Date

`DateTime.from_unix`

DateTime.from_unix(seconds: Int64, nanosecond: Int64) -> DateTime
DateTime.from_unix(seconds: Int64) -> DateTime

`DateTime.nanosecond`

DateTime.nanosecond(self: DateTime) -> Int64

`DateTime.now`

DateTime.now() -> DateTime

`DateTime.offset_minutes`

DateTime.offset_minutes(self: DateTime) -> Int64

`DateTime.parse`

DateTime.parse(text: String) -> DateTime

`DateTime.str`

DateTime.str(self: DateTime) -> String

`DateTime.time`

DateTime.time(self: DateTime) -> Time

`DateTime.try_parse`

DateTime.try_parse(text: String) -> Result<DateTime, String>

`DateTime.unix_seconds`

DateTime.unix_seconds(self: DateTime) -> Int64

`DateTime.until`

DateTime.until(self: DateTime, other: DateTime) -> Duration

`DateTime.with_offset`

DateTime.with_offset(self: DateTime, offset_minutes: Int64) -> DateTime

Dictionary

Open the Dictionary reference.

`Dictionary`

Dictionary() -> Dictionary

`Dictionary.clear`

Dictionary.clear(self: Dictionary) -> Unit

`Dictionary.contains`

Dictionary.contains(self: Dictionary, key: Any) -> Bool

`Dictionary.copy`

Dictionary.copy(self: Dictionary) -> Dictionary

`Dictionary.get`

Dictionary.get(self: Dictionary, key: Any) -> Any

`Dictionary.get_or`

Dictionary.get_or(self: Dictionary, key: Any, default: Any) -> Any

`Dictionary.is_empty`

Dictionary.is_empty(self: Dictionary) -> Bool

`Dictionary.items`

Dictionary.items(self: Dictionary) -> List

`Dictionary.keys`

Dictionary.keys(self: Dictionary) -> List

`Dictionary.len`

Dictionary.len(self: Dictionary) -> Int64

`Dictionary.remove`

Dictionary.remove(self: Dictionary, key: Any) -> Unit

`Dictionary.set`

Dictionary.set(self: Dictionary, key: Any, value: Any) -> Unit

`Dictionary.values`

Dictionary.values(self: Dictionary) -> List

Duration

Open the Duration reference.

`Duration`

Duration(nanoseconds: Int64) -> Duration

`Duration.add`

Duration.add(self: Duration, other: Duration) -> Duration

`Duration.from_milliseconds`

Duration.from_milliseconds(milliseconds: Int64) -> Duration

`Duration.from_seconds`

Duration.from_seconds(seconds: Int64) -> Duration

`Duration.monotonic`

Duration.monotonic() -> Duration

`Duration.multiply`

Duration.multiply(self: Duration, factor: Int64) -> Duration

`Duration.nanoseconds`

Duration.nanoseconds(self: Duration) -> Int64

`Duration.negate`

Duration.negate(self: Duration) -> Duration

`Duration.parse`

Duration.parse(text: String) -> Duration

`Duration.str`

Duration.str(self: Duration) -> String

`Duration.subtract`

Duration.subtract(self: Duration, other: Duration) -> Duration

`Duration.total_seconds`

Duration.total_seconds(self: Duration) -> Float64

`Duration.try_parse`

Duration.try_parse(text: String) -> Result<Duration, String>

DynamicArray

Open the DynamicArray reference.

`DynamicArray`

DynamicArray(capacity: Int64) -> DynamicArray<T>

`DynamicArray.add`

DynamicArray.add(self: DynamicArray<T>, other: Any) -> DynamicArray<T>
DynamicArray.add(self: DynamicArray<T>, other: DynamicArray<T>) -> DynamicArray<T>

`DynamicArray.append`

DynamicArray.append(self: DynamicArray<T>, value: T) -> Unit

`DynamicArray.argmax`

DynamicArray.argmax(self: DynamicArray<T>) -> Int64

`DynamicArray.argmin`

DynamicArray.argmin(self: DynamicArray<T>) -> Int64

`DynamicArray.astype`

DynamicArray.astype(self: DynamicArray<T>, dtype: String) -> DynamicArray<T>

`DynamicArray.capacity`

DynamicArray.capacity(self: DynamicArray<T>) -> Int64

`DynamicArray.clear`

DynamicArray.clear(self: DynamicArray<T>) -> Unit

`DynamicArray.contains`

DynamicArray.contains(self: DynamicArray<T>, value: T) -> Bool

`DynamicArray.copy`

DynamicArray.copy(self: DynamicArray<T>) -> DynamicArray<T>

`DynamicArray.cumsum`

DynamicArray.cumsum(self: DynamicArray<T>) -> DynamicArray<T>

`DynamicArray.div`

DynamicArray.div(self: DynamicArray<T>, other: Any) -> DynamicArray<T>
DynamicArray.div(self: DynamicArray<T>, other: DynamicArray<T>) -> DynamicArray<T>

`DynamicArray.dot`

DynamicArray.dot(self: DynamicArray<T>, other: Any) -> T
DynamicArray.dot(self: DynamicArray<T>, other: DynamicArray<T>) -> T

`DynamicArray.fill`

DynamicArray.fill(self: DynamicArray<T>, value: T) -> Unit

`DynamicArray.find`

DynamicArray.find(self: DynamicArray<T>, value: T) -> Int64

`DynamicArray.from_tensor`

DynamicArray.from_tensor(tensor: Tensor) -> DynamicArray<T>

`DynamicArray.get`

DynamicArray.get(self: DynamicArray<T>, index: Int64) -> T

`DynamicArray.insert`

DynamicArray.insert(self: DynamicArray<T>, index: Int64, value: T) -> Unit

`DynamicArray.is_empty`

DynamicArray.is_empty(self: DynamicArray<T>) -> Bool

`DynamicArray.is_sorted`

DynamicArray.is_sorted(self: DynamicArray<T>) -> Bool

`DynamicArray.len`

DynamicArray.len(self: DynamicArray<T>) -> Int64

`DynamicArray.max`

DynamicArray.max(self: DynamicArray<T>) -> T

`DynamicArray.mean`

DynamicArray.mean(self: DynamicArray<T>) -> Float64
DynamicArray.mean(self: DynamicArray<T>) -> T

`DynamicArray.min`

DynamicArray.min(self: DynamicArray<T>) -> T

`DynamicArray.mul`

DynamicArray.mul(self: DynamicArray<T>, other: Any) -> DynamicArray<T>
DynamicArray.mul(self: DynamicArray<T>, other: DynamicArray<T>) -> DynamicArray<T>

`DynamicArray.pop`

DynamicArray.pop(self: DynamicArray<T>) -> T

`DynamicArray.remove_at`

DynamicArray.remove_at(self: DynamicArray<T>, index: Int64) -> T

`DynamicArray.reserve`

DynamicArray.reserve(self: DynamicArray<T>, capacity: Int64) -> Unit

`DynamicArray.reshape`

DynamicArray.reshape(self: DynamicArray<T>, shape: List) -> NDArray<T>

`DynamicArray.resize`

DynamicArray.resize(self: DynamicArray<T>, size: Int64, fill: T) -> Unit

`DynamicArray.reverse`

DynamicArray.reverse(self: DynamicArray<T>) -> Unit

`DynamicArray.scale`

DynamicArray.scale(self: DynamicArray<T>, factor: Float64) -> DynamicArray<T>
DynamicArray.scale(self: DynamicArray<T>, factor: T) -> DynamicArray<T>

`DynamicArray.set`

DynamicArray.set(self: DynamicArray<T>, index: Int64, value: T) -> Unit

`DynamicArray.slice`

DynamicArray.slice(self: DynamicArray<T>, start: Int64, stop: Int64) -> DynamicArray<T>

`DynamicArray.sort`

DynamicArray.sort(self: DynamicArray<T>) -> Unit

`DynamicArray.std`

DynamicArray.std(self: DynamicArray<T>) -> Float64
DynamicArray.std(self: DynamicArray<T>) -> Quantity<DifferenceUnit>

`DynamicArray.sub`

DynamicArray.sub(self: DynamicArray<T>, other: Any) -> DynamicArray<T>
DynamicArray.sub(self: DynamicArray<T>, other: DynamicArray<T>) -> DynamicArray<T>

`DynamicArray.sum`

DynamicArray.sum(self: DynamicArray<T>) -> T

`DynamicArray.to`

DynamicArray.to(self: DynamicArray<T>, target_unit: String) -> DynamicArray<T>

`DynamicArray.to_float`

DynamicArray.to_float(self: DynamicArray<T>) -> DynamicArray<Float64>

`DynamicArray.to_list`

DynamicArray.to_list(self: DynamicArray<T>) -> List

`DynamicArray.to_tensor`

DynamicArray.to_tensor(self: DynamicArray<T>, rows: Int64, cols: Int64) -> Tensor

`DynamicArray.unit`

DynamicArray.unit(self: DynamicArray<T>) -> String

`DynamicArray.values`

DynamicArray.values(self: DynamicArray<T>) -> DynamicArray<Float64>

`DynamicArray.variance`

DynamicArray.variance(self: DynamicArray<T>) -> Float64
DynamicArray.variance(self: DynamicArray<T>) -> Quantity<SquaredDifferenceUnit>

List

Open the List reference.

`List`

List(value: Any...) -> List

`List.append`

List.append(self: List, value: Any) -> Unit

`List.clear`

List.clear(self: List) -> Unit

`List.contains`

List.contains(self: List, value: Any) -> Bool

`List.copy`

List.copy(self: List) -> List

`List.extend`

List.extend(self: List, other: List) -> Unit

`List.get`

List.get(self: List, index: Int64) -> Any

`List.get_or`

List.get_or(self: List, index: Int64, default: Any) -> Any

`List.insert`

List.insert(self: List, index: Int64, value: Any) -> Unit

`List.is_empty`

List.is_empty(self: List) -> Bool

`List.len`

List.len(self: List) -> Int64

`List.pop`

List.pop(self: List) -> Any

`List.remove_at`

List.remove_at(self: List, index: Int64) -> Any

`List.set`

List.set(self: List, index: Int64, value: Any) -> Unit

`List.sort`

List.sort(self: List) -> Unit

NDArray

Open the NDArray reference.

`NDArray`

NDArray(shape: List, fill: T) -> NDArray<T>

`NDArray.add`

NDArray.add(self: NDArray<T>, other: Any) -> NDArray<T>
NDArray.add(self: NDArray<T>, other: NDArray<T>) -> NDArray<T>

`NDArray.argmax`

NDArray.argmax(self: NDArray<T>) -> Int64

`NDArray.argmin`

NDArray.argmin(self: NDArray<T>) -> Int64

`NDArray.astype`

NDArray.astype(self: NDArray<T>, dtype: String) -> NDArray<T>

`NDArray.copy`

NDArray.copy(self: NDArray<T>) -> NDArray<T>

`NDArray.div`

NDArray.div(self: NDArray<T>, other: Any) -> NDArray<T>
NDArray.div(self: NDArray<T>, other: NDArray<T>) -> NDArray<T>

`NDArray.fill`

NDArray.fill(self: NDArray<T>, value: T) -> Unit

`NDArray.flatten`

NDArray.flatten(self: NDArray<T>) -> Array<T>

`NDArray.from_tensor`

NDArray.from_tensor(tensor: Tensor) -> NDArray<T>

`NDArray.get`

NDArray.get(self: NDArray<T>, indices: List) -> T

`NDArray.is_contiguous`

NDArray.is_contiguous(self: NDArray<T>) -> Bool

`NDArray.is_empty`

NDArray.is_empty(self: NDArray<T>) -> Bool

`NDArray.len`

NDArray.len(self: NDArray<T>) -> Int64

`NDArray.matmul`

NDArray.matmul(self: NDArray<T>, other: Any) -> T
NDArray.matmul(self: NDArray<T>, other: NDArray<T>) -> NDArray<T>

`NDArray.max`

NDArray.max(self: NDArray<T>) -> T

`NDArray.mean`

NDArray.mean(self: NDArray<T>) -> Float64
NDArray.mean(self: NDArray<T>) -> T

`NDArray.min`

NDArray.min(self: NDArray<T>) -> T

`NDArray.mul`

NDArray.mul(self: NDArray<T>, other: Any) -> NDArray<T>
NDArray.mul(self: NDArray<T>, other: NDArray<T>) -> NDArray<T>

`NDArray.ndim`

NDArray.ndim(self: NDArray<T>) -> Int64

`NDArray.permute`

NDArray.permute(self: NDArray<T>, axes: List) -> NDArray<T>

`NDArray.reshape`

NDArray.reshape(self: NDArray<T>, shape: List) -> NDArray<T>

`NDArray.scale`

NDArray.scale(self: NDArray<T>, factor: Float64) -> NDArray<T>
NDArray.scale(self: NDArray<T>, factor: T) -> NDArray<T>

`NDArray.set`

NDArray.set(self: NDArray<T>, indices: List, value: T) -> Unit

`NDArray.shape`

NDArray.shape(self: NDArray<T>) -> List

`NDArray.std`

NDArray.std(self: NDArray<T>) -> Float64
NDArray.std(self: NDArray<T>) -> Quantity<DifferenceUnit>

`NDArray.strides`

NDArray.strides(self: NDArray<T>) -> List

`NDArray.sub`

NDArray.sub(self: NDArray<T>, other: Any) -> NDArray<T>
NDArray.sub(self: NDArray<T>, other: NDArray<T>) -> NDArray<T>

`NDArray.sum`

NDArray.sum(self: NDArray<T>) -> T

`NDArray.to`

NDArray.to(self: NDArray<T>, target_unit: String) -> NDArray<T>

`NDArray.to_float`

NDArray.to_float(self: NDArray<T>) -> NDArray<Float64>

`NDArray.to_list`

NDArray.to_list(self: NDArray<T>) -> List

`NDArray.to_tensor`

NDArray.to_tensor(self: NDArray<T>) -> Tensor

`NDArray.transpose`

NDArray.transpose(self: NDArray<T>) -> NDArray<T>

`NDArray.unit`

NDArray.unit(self: NDArray<T>) -> String

`NDArray.values`

NDArray.values(self: NDArray<T>) -> NDArray<Float64>

`NDArray.variance`

NDArray.variance(self: NDArray<T>) -> Float64
NDArray.variance(self: NDArray<T>) -> Quantity<SquaredDifferenceUnit>

Optional

Open the Optional reference.

`Optional.is_none`

Optional.is_none(self: Optional<T>) -> Bool

`Optional.is_some`

Optional.is_some(self: Optional<T>) -> Bool

`Optional.none`

Optional.none() -> Optional<T>

`Optional.some`

Optional.some(value: T) -> Optional<T>

`Optional.unwrap`

Optional.unwrap(self: Optional<T>) -> T

`Optional.unwrap_or`

Optional.unwrap_or(self: Optional<T>, default: T) -> T

Range

Open the Range reference.

`Range`

Range(start: Int64, stop: Int64, step: Int64) -> Range
Range(start: Int64, stop: Int64) -> Range
Range(stop: Int64) -> Range

`Range.contains`

Range.contains(self: Range, value: Int64) -> Bool

`Range.find`

Range.find(self: Range, value: Int64) -> Int64

`Range.get`

Range.get(self: Range, index: Int64) -> Int64

`Range.is_empty`

Range.is_empty(self: Range) -> Bool

`Range.len`

Range.len(self: Range) -> Int64

`Range.start`

Range.start(self: Range) -> Int64

`Range.step`

Range.step(self: Range) -> Int64

`Range.stop`

Range.stop(self: Range) -> Int64

Result

Open the Result reference.

`Result.err`

Result.err(error: E) -> Result<T, E>

`Result.is_err`

Result.is_err(self: Result<T, E>) -> Bool

`Result.is_ok`

Result.is_ok(self: Result<T, E>) -> Bool

`Result.ok`

Result.ok(value: T) -> Result<T, E>

`Result.unwrap`

Result.unwrap(self: Result<T, E>) -> T

`Result.unwrap_err`

Result.unwrap_err(self: Result<T, E>) -> E

`Result.unwrap_or`

Result.unwrap_or(self: Result<T, E>, default: T) -> T

Set

Open the Set reference.

`Set`

Set(value: Any...) -> Set

`Set.add`

Set.add(self: Set, value: Any) -> Unit

`Set.clear`

Set.clear(self: Set) -> Unit

`Set.contains`

Set.contains(self: Set, value: Any) -> Bool

`Set.copy`

Set.copy(self: Set) -> Set

`Set.difference`

Set.difference(self: Set, other: Set) -> Set

`Set.intersection`

Set.intersection(self: Set, other: Set) -> Set

`Set.is_empty`

Set.is_empty(self: Set) -> Bool

`Set.len`

Set.len(self: Set) -> Int64

`Set.remove`

Set.remove(self: Set, value: Any) -> Unit

`Set.symmetric_difference`

Set.symmetric_difference(self: Set, other: Set) -> Set

`Set.to_list`

Set.to_list(self: Set) -> List

`Set.union`

Set.union(self: Set, other: Set) -> Set

String

Open the String reference.

`String.byte_len`

String.byte_len(self: String) -> Int64

`String.casefold`

String.casefold(self: String) -> String

`String.compare`

String.compare(self: String, other: String) -> Int64

`String.concat`

String.concat(self: String, other: String) -> String

`String.contains`

String.contains(self: String, needle: String) -> Bool

`String.count`

String.count(self: String, needle: String) -> Int64

`String.ends_with`

String.ends_with(self: String, suffix: String) -> Bool

`String.find`

String.find(self: String, needle: String) -> Int64

`String.get`

String.get(self: String, index: Int64) -> String

`String.is_empty`

String.is_empty(self: String) -> Bool

`String.join`

String.join(self: String, parts: List) -> String

`String.len`

String.len(self: String) -> Int64

`String.lower`

String.lower(self: String) -> String

`String.repeat`

String.repeat(self: String, count: Int64) -> String

`String.replace`

String.replace(self: String, old: String, new: String) -> String

`String.slice`

String.slice(self: String, start: Int64, end: Int64) -> String

`String.split`

String.split(self: String, separator: String) -> List

`String.starts_with`

String.starts_with(self: String, prefix: String) -> Bool

`String.trim`

String.trim(self: String) -> String

`String.trim_end`

String.trim_end(self: String) -> String

`String.trim_start`

String.trim_start(self: String) -> String

`String.upper`

String.upper(self: String) -> String

Time

Open the Time reference.

`Time`

Time(hour: Int64, minute: Int64, second: Int64, nanosecond: Int64) -> Time
Time(hour: Int64, minute: Int64, second: Int64) -> Time

`Time.day_nanoseconds`

Time.day_nanoseconds(self: Time) -> Int64

`Time.hour`

Time.hour(self: Time) -> Int64

`Time.minute`

Time.minute(self: Time) -> Int64

`Time.nanosecond`

Time.nanosecond(self: Time) -> Int64

`Time.parse`

Time.parse(text: String) -> Time

`Time.second`

Time.second(self: Time) -> Int64

`Time.str`

Time.str(self: Time) -> String

`Time.try_parse`

Time.try_parse(text: String) -> Result<Time, String>