Struct Rope 

pub struct Rope {
    pub dims: i32,
    pub traditional: bool,
    pub base: f32,
    pub scale: f32,
    /* private fields */
}

Rotary position embedding of the first dims features (MLX’s nn.RoPE, the fused fast::rope), optionally with a frequency scaling (Rope::scaled: mlx-lm’s Llama3RoPE, YarnRoPE, SuScaledRoPE, ProportionalRoPE). No parameters: the frequencies are computed from the settings, never loaded or saved.

Fields

dims: i32

Rotated features.

traditional: bool

Rotate consecutive pairs (true) or the two halves (false, MLX’s default).

base: f32

The frequency base (MLX’s default 10000).

scale: f32

Scale applied to positions.

Implementations

impl Rope

pub fn new(dims: i32) -> Self

RoPE over dims features with MLX’s defaults (halves, base 10000, scale 1).

pub fn scaled(dims: i32, base: f32, scaling: &RopeScaling) -> Self

RoPE over dims features with base and a frequency scaling, as mlx-lm’s scaled RoPE layers (for RopeScaling::Proportional dims is the whole head’s).

use nuvec_nn::{Rope, RopeScaling, Yarn};

// gpt-oss: YaRN over 64 features, base 150000, factor 32 over 4096 positions.
let yarn = Yarn { factor: 32.0, original_max_position_embeddings: 4096.0, ..Yarn::default() };
let rope = Rope::scaled(64, 150_000.0, &RopeScaling::Yarn(yarn));
assert!((rope.mscale() - 1.3466).abs() < 1e-4);

pub fn mscale(&self) -> f32

The input scale the scaling applies to the rotated features (YaRN, LongRoPE; else 1). Callers that rotate queries and keys with Rope::rotation (one fused kernel each) instead multiply the attention scale by mscale()², which is the same up to rounding when the rotated features are the whole head. In half precision mlx-lm multiplies q and k by the mscale rounded to their dtype, which the fold does not reproduce: nuvec-lm multiplies explicitly there and folds only in float32.

pub fn rotation(&self) -> Rotation<'_>

The rotation for the fused ops (fast::rope, fast::norm_rope), without the input scale (Rope::mscale).

pub fn traditional(self) -> Self

Rotates consecutive pairs of features (MLX’s traditional=True).

pub fn base(self, base: f32) -> Self

Sets the frequency base (recomputing a scaling’s frequencies).

pub fn scale(self, scale: f32) -> Self

Sets the scale applied to positions.

pub fn forward(&self, x: &Array, offset: i32) -> Array

x ([..., sequence, features]) rotated for positions offset, offset + 1, …, its rotated features first multiplied by Rope::mscale (as mlx-lm).

Trait Implementations

impl Clone for Rope

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Rope

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

Formats the value using the given formatter.

impl Leaves for Rope

fn visit(&self, __v: &mut Visit<'_>)

Reports every leaf (and child tree, enum variant, mode flag and static field) to v, in order.

impl Tree for Rope

where Self: Clone,

fn visit_mut(&mut self, __v: &mut VisitMut<'_>)

Reports every leaf (and child tree and mode flag) to v mutably, in the order of Leaves::visit.

fn for_each(&self, f: impl FnMut(&str, &Array))

Calls f(path, leaf) for every leaf, in order.

fn map(&self, f: impl FnMut(&str, &Array) -> Array) -> Self

The tree with every leaf replaced by f(path, leaf) (same structure; parameters keep their frozen flag).

fn leaves(&self) -> Vec<Array>

The leaves, in order.

fn paths(&self) -> Vec<String>

The leaves’ paths, in order.

fn flatten(&self) -> Vec<(String, Array)>

The leaves with their paths, in order (MLX’s tree_flatten).

fn unflatten( &self, leaves: impl IntoIterator<Item = Array>, ) -> Result<Self, Error>

A tree of this structure (self is the template) with leaves in order: exactly Tree::len of them, else an error naming both counts.

fn load_flat( &mut self, named: impl IntoIterator<Item = (String, Array)>, mode: LoadMode, ) -> Result<(), Error>

Replaces leaves by path. LoadMode::Strict requires exactly the tree’s paths with matching shapes; LoadMode::Partial assigns the matching names and ignores unknown ones (shapes must still match). Loaded dtypes are kept. On any problem the error lists every one (missing, unknown and mismatched names, sorted) and the tree is unchanged. Duplicate paths (in the tree or in named) are an error.

fn len(&self) -> usize

The number of leaves.

fn is_empty(&self) -> bool

Whether the tree has no leaves.

fn def(&self) -> TreeDef

The tree’s structure.