Struct RopeFreqs 

pub struct RopeFreqs {
    pub full: Vec<f32>,
    pub swa: Option<Vec<f32>>,
}

The resolved per-band RoPE divisors, for BOTH kinds of layer.

llama.cpp splits RoPE per layer in two places, not one:

// src/llama-model.cpp:2029-2035
float llama_model::get_rope_freq_base (const llama_cparams & cparams, int il) const {
    return hparams.is_swa(il) ? hparams.rope_freq_base_train_swa  : cparams.rope_freq_base;
}
float llama_model::get_rope_freq_scale(const llama_cparams & cparams, int il) const {
    return hparams.is_swa(il) ? hparams.rope_freq_scale_train_swa : cparams.rope_freq_scale;
}

and every alternating-SWA graph calls both, per layer (gemma3.cpp:112-121, gemma2.cpp:79-80, laguna.cpp:182-183). ferrox folds llama.cpp’s freq_scale into these divisors – linear scaling by s is exactly “divide every band by s” – so the SCALE half of that split has to live here, beside the BASE half in ModelConfig::rope_theta_swa.

It did not, and Gemma-3 4B/12B/27B paid for it: their headers declare rope.scaling.type = linear, factor = 8, gemma3.cpp never assigns rope_freq_scale_train_swa so it keeps its 1.0f default (src/llama-hparams.h:129), and five layers in every six are sliding (sliding_window_pattern = 6, last-dense). ferrox rotated all of them at p/8 where llama.cpp rotates at p – fluent, and worse the longer the prompt. Invisible to the audit because the fixture is Gemma-3-1B, the one size with no rope_scaling at all.

The two fields are one struct so that answering the base question without answering the scale question does not compile.

Fields

full: Vec<f32>

What the FULL-ATTENTION layers divide each band’s theta by.

swa: Option<Vec<f32>>

What the SLIDING layers divide by, when the architecture does not let them inherit the model’s trained RoPE scale (capability::swa_rope_scale_follows_model). None means they inherit Self::full, which is llama.cpp’s behaviour for every architecture that assigns rope_freq_scale_train_swa from rope_freq_scale_train.

“No divisors at all” is spelled as an all-ones vector rather than a third state: dividing by one is exactly not dividing, and one fewer state is one fewer thing two call sites can disagree about.

Implementations

impl RopeFreqs

pub fn for_layer(&self, sliding: bool) -> &[f32]

The divisors layer il uses, given whether it slides.

pub fn varies_by_layer(&self) -> bool

True when the sliding layers use a different set from the full ones, i.e. when one freq_factors buffer cannot serve a whole stack of layers.

Trait Implementations

impl Clone for RopeFreqs

fn clone(&self) -> RopeFreqs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RopeFreqs

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

Formats the value using the given formatter.

impl PartialEq for RopeFreqs

fn eq(&self, other: &RopeFreqs) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RopeFreqs