Struct Orphos 

pub struct Orphos<S: TrainingState> {
    pub config: OrphosConfig,
    /* private fields */
}

Main Orphos configuration and execution engine.

This struct uses the type-state pattern with the S type parameter to ensure training is performed before gene prediction. The state transitions from Untrained to Trained via the training methods.

Type Parameters

• S - The training state, either Untrained or Trained

Examples

use orphos_core::engine::UntrainedOrphos;
use orphos_core::config::OrphosConfig;
use orphos_core::sequence::encoded::EncodedSequence;

// Create an untrained instance
let mut orphos = UntrainedOrphos::new();

// Encode a sequence
let sequence = b"ATGAAACGCATTAGCACCACCATT...";
let encoded = EncodedSequence::without_masking(sequence);

// Train on the sequence and get results
let trained = orphos.train_single_genome(&encoded)?;

// Use the higher-level API to analyze sequences
use orphos_core::OrphosAnalyzer;
let mut analyzer = OrphosAnalyzer::new(OrphosConfig::default());
let results = analyzer.analyze_sequence("ATGAAACGCATTAGCACCACCATT...", None)?;
println!("Found {} genes", results.genes.len());

Fields

config: OrphosConfig

Configuration options for gene prediction

Implementations

impl Orphos<Untrained>

pub fn new() -> Self

Creates a new untrained Orphos instance with default configuration.

Examples

use orphos_core::engine::UntrainedOrphos;

let orphos = UntrainedOrphos::new();

pub fn with_config(config: OrphosConfig) -> Result<Self, OrphosError>

Creates a new untrained Orphos instance with custom configuration.

Arguments

• config - Configuration options for gene prediction

Errors

Returns OrphosError if thread pool configuration fails.

Examples

use orphos_core::engine::UntrainedOrphos;
use orphos_core::config::{OrphosConfig, OutputFormat};

let config = OrphosConfig {
    closed_ends: true,
    output_format: OutputFormat::Gff,
    ..Default::default()
};

let orphos = UntrainedOrphos::with_config(config)?;

pub fn train_single_genome( &mut self, encoded_sequence: &EncodedSequence, ) -> Result<TrainedOrphos, OrphosError>

Trains the model on a single complete genome sequence.

This method analyzes the sequence to build a statistical model of gene characteristics including:

• Start codon usage (ATG, GTG, TTG)
• Ribosome binding site motifs
• Codon usage patterns
• GC content bias

Arguments

• encoded_sequence - The genome sequence encoded in bitmap format

Returns

A TrainedOrphos instance ready for gene prediction.

Errors

Returns OrphosError::InvalidSequence if:

• The sequence is shorter than MIN_SEQUENCE_LENGTH
• The sequence contains invalid characters
• Training fails to converge

Examples

use orphos_core::engine::UntrainedOrphos;
use orphos_core::sequence::encoded::EncodedSequence;

let mut orphos = UntrainedOrphos::new();
let sequence = b"ATGAAACGCATTAGCACCACCATT...";
let encoded = EncodedSequence::without_masking(sequence);

let trained = orphos.train_single_genome(&encoded)?;

impl Orphos<Trained>

pub const fn new(config: OrphosConfig, training: Training) -> Self

Creates a new trained Orphos instance with pre-computed training data.

This is useful when you have previously computed training data that you want to reuse for gene prediction on multiple sequences.

Arguments

• config - Configuration options for gene prediction
• training - Pre-computed training data

Examples

use orphos_core::engine::TrainedOrphos;
use orphos_core::config::OrphosConfig;
use orphos_core::types::Training;

let config = OrphosConfig::default();
let training = Training::default(); // In practice, load from file

let trained = TrainedOrphos::new(config, training);

Trait Implementations

impl<S: Debug + TrainingState> Debug for Orphos<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Default + TrainingState> Default for Orphos<S>

fn default() -> Orphos<S>

Returns the “default value” for a type.