Início / coding / Perguntas / 79564695
Accepted
knods
Asked: 2025-04-09 23:05:20 +0800 CST

Existe alguma maneira de evitar clonagens/alocações repetidas neste método Runge-Kutta-Fehlberg?

  • 772

Estou implementando o método Runge-Kutta-Fehlberg 5(4) em Rust, então tenho que monitorar o estado atual do sistema que estou tentando modelar, executar vários cálculos com base no estado atual e, como resultado desses cálculos, atualizar o estado.

No processo, me deparei com problemas de propriedade, porque o nalgebratipo que estou usando não implementa copy. O compilador sugeriu que eu cloneusasse os dados. Acabei com quatro .clone()instruções dentro de um loop e estou pensando sobre o impacto no desempenho, por um lado, e possíveis alternativas, por outro.

Você pode encontrar a função relevante abaixo.

pub fn rkf54(
    initial_time: f64,
    initial_state: State<f64>,
    initial_step_size: f64,
    control: bool,
    tolerance: f64,
    final_time: f64,
    f: &dyn Fn(f64, &State<f64>) -> State<f64>)
    -> Vec<State<f64>> {

    let mut output: Vec<State<f64>> = vec![];

    let mut time = initial_time;
    let mut state = initial_state;
    let mut step_size = initial_step_size;

    while time < final_time  {
        if control {
            // CLONE 1
            step_size = rkf_control(time, state.clone(), initial_step_size, tolerance, f);
        }
        
        // CLONE 2
        let stages = rkf_stages(time, &state.clone(), step_size, A, C, f);

        // CLONE 3
        state = rkf_step(&state.clone(), step_size, &stages, B_PRIMARY);
        time += step_size;


        // CLONE 4
        output.push(state.clone())
    }
    let stages = rkf_stages(final_time, &state.clone(), step_size, A, C, f);
    state = rkf_step(&state.clone(), step_size, &stages, B_PRIMARY);
    output.push(state.clone());

return output;
}

A clonagem repetida afetará significativamente o desempenho? Se entendi corretamente, isso copia os mesmos dados de e para diferentes áreas da memória 4 vezes por iteração.

Se sim, como posso evitar esse tipo de clonagem/alocação?

Aqui está um exemplo funcional completo, juntamente com definições de tipo e constante.

#![allow(dead_code)]

extern crate nalgebra; // 0.33.2

use nalgebra::DVector; // 0.33.2
use std::f64::INFINITY;

type Stages<T, const D: usize> = [DVector<T>; D];
pub type State<T> = DVector<T>;
pub type StageCoefficients<T, const D: usize> = [&'static [T]; D];
pub type Weights<T, const D: usize> = [T; D];

pub const A: StageCoefficients<f64, 6> = [
    &[],
    &[1./4.],
    &[3./32.,       9./32.],
    &[1932./2197.,  -7200./2197.,   7296./2197.],
    &[439./216.,    8.,             3680./513.,     -845./4104.],
    &[-8./27.,      2.,             -3544./2565.,   1859./4104.,    -11./40.]
];

pub const C: Weights<f64, 6> =  [0.0,           1./4.,          3./8.,          12./13.,        1.,         1./2.   ];
pub const B_PRIMARY: Weights<f64, 6> =  [16./135.,      0.,             6656./12825.,   28561./56430.,  -9./50.,    2./55.  ];
pub const B_EMBEDDED: Weights<f64, 6> =     [25./216.,      0.,             1408./2565.,    2197./4104.,    -1./5.,     0.      ];


const K: f64 = 0.02;
const B0: f64 = 3.5;
const B1: f64 = 16.72;

pub fn f(t:f64, state: &State<f64>) -> State<f64> {   
    let x = state[0];
    let y = state [1];
    
    let x_dot = y;
    let y_dot = (-K*y) - (x.powf(3.)) + (B0) + (B1 * t.cos());

    return State::from(vec![x_dot, y_dot]);
}

pub fn rkf54(
    initial_time: f64,
    initial_state: State<f64>,
    initial_step_size: f64,
    control: bool,
    tolerance: f64,
    final_time: f64,
    f: &dyn Fn(f64, &State<f64>) -> State<f64>)
    -> Vec<State<f64>> {

    let mut output: Vec<State<f64>> = vec![];

    let mut time = initial_time;
    let mut state = initial_state;
    let mut step_size = initial_step_size;

    while time < final_time  {
        if control {
            // CLONE 1
            step_size = rkf_control(time, state.clone(), initial_step_size, tolerance, f);
        }
        
        // CLONE 2
        let stages = rkf_stages(time, &state.clone(), step_size, A, C, f);

        // CLONE 3
        state = rkf_step(&state.clone(), step_size, &stages, B_PRIMARY);
        time += step_size;


        // CLONE 4
        output.push(state.clone())
    }
    let stages = rkf_stages(final_time, &state.clone(), step_size, A, C, f);
    state = rkf_step(&state.clone(), step_size, &stages, B_PRIMARY);
    output.push(state.clone());

return output;
}
fn rkf_stages<const D: usize>(
    time: f64,
    state: &State<f64>,
    step_size: f64,
    stage_coefficients: StageCoefficients<f64, D>,
    time_fractions: Weights<f64, D>,
    f: &dyn Fn(f64, &State<f64>) -> State<f64>
    ) -> Stages<f64, D> {

    let mut k: Stages<f64, D> = std::array::from_fn(|_| DVector::zeros(state.nrows()));
    
    for i in 0..stage_coefficients.len() {
        let mut x: State<f64> = DVector::zeros(state.nrows());
        for j in 0..stage_coefficients[i].len() {
            x += &k[j] * stage_coefficients[i][j];
        }
        x = state + step_size*(x);
        let t = time + (step_size*time_fractions[i]);
        k[i] = f(t,&x);
    }

    return k;
}

fn rkf_step<const D: usize>(state: &State<f64>, step_size: f64, stages: &Stages<f64, D>, weights: Weights<f64, D>) -> State<f64> {
    
    let mut x_out = 0.0 * DVector::zeros(state.nrows());

    for i in 0..A.len() {
        x_out += &stages[i] * weights[i];
    }
    x_out *= step_size;
    x_out += state;
    
    return x_out;
}

fn rkf_control(time: f64, state: State<f64>, initial_step_size: f64, tolerance: f64,
    f: &dyn Fn(f64, &State<f64>) -> State<f64>) -> f64 {

    let mut error_estimate = INFINITY;
    let mut step_size = initial_step_size;

    while error_estimate > tolerance {
        let k = rkf_stages(time, &state, step_size, A, C, f);
        let x_primary = rkf_step(&state, step_size, &k, B_PRIMARY);
        let x_embedded = rkf_step(&state, step_size, &k, B_EMBEDDED);

        error_estimate = (x_primary - x_embedded).norm();
        step_size = 0.9 * step_size * (tolerance / error_estimate).powf(1. / 5.);
    }

    return step_size;
}

fn main() {
    let initial_time = 0.;
    let initial_state = State::from(vec![2., 2.]);
    let initial_step_size = 1.;
    let control = true;
    let tolerance = 10e-3;
    let final_time = 1.;

    let output = rkf54(initial_time, initial_state, initial_step_size, control, tolerance, final_time, &f);
    for state in output {
        println!("{state:1.3e}");
    }

}
rust

1 respostas

  1. Best Answer

    Acho que você pode evitar todos os clones. Mas não posso testar porque você não forneceu definições para seus tipos e constantes personalizados.

    Em todos os casos em que você fizer isso, &state.clone()você pode simplesmente fazer &state.

    Você pode modificar o rkf_steppara tomar &State<f64>como argumento e passar o estado para ele novamente, apenas com &stateem vez de state.clone().

    No caso do último clone, você pode modificar o loop assim:

    pub fn rkf54(
    initial_time: f64,
    initial_state: State<f64>,
    initial_step_size: f64,
    control: bool,
    tolerance: f64,
    final_time: f64,
    f: &dyn Fn(f64, &State<f64>) -> State<f64>)
    -> Vec<State<f64>> {
    let A: StageCoefficients<f64, 1> = [Default::default()];

    let mut output: Vec<State<f64>> = vec![];

    let mut time = initial_time;
    let mut state = initial_state;
    let mut step_size = initial_step_size;

    while time < final_time  {
        if control {
            // Just use &state here
            step_size = rkf_control(time, &state, initial_step_size, tolerance, f);
        }

        // Again just &state
        let stages = rkf_stages(time, &state, step_size, A, C, f);

        // Modified to take &state.
        let new_state = rkf_step(&state, step_size, &stages, B_PRIMARY);
        output.push(state); // Push the state from previous iteration.
        state = new_state; // Overwrite the old state to the new state.
        time += step_size;
    }
    let stages = rkf_stages(final_time, &state, step_size, A, C, f);
    let new_state = rkf_step(&state, step_size, &stages, B_PRIMARY);
    output.push(state); // Push state from the last iteration.
    output.push(new_state); // Here you will need to clone only if you plan to use new_state later

    return output;
}

    Observe que, nesta nova versão, o estado inicial também é armazenado na saída. Esse não é o caso no seu código original. Se quiser evitar isso, você pode simplesmente verificar a primeira iteração e não fazer isso output.push(state)na primeira iteração.

    EDITAR:

    Para responder às outras perguntas: a clonagem costuma ser uma operação cara. Às vezes é necessária, mas é bom evitá-la sempre que possível.

    Se você tiver algum tipo de dado ( DataType) que não precise modificar, for caro cloná-lo e não estiver claro onde ele deve ser possuído, você pode usar Rc<DataType>(ou Arc<DataType>se for compartilhado entre threads). Isso criará um ponteiro de referência contado. Você ainda precisará usar .clone(), mas este clone é, neste caso, bem barato comparado ao custo do clone de DataType.

    • 7

relate perguntas