← back to LeandroPG19__cuba-memorys

Function bodies 2,528 total

All specs Real LLM only Function bodies
boost_on_access function · rust · L30-L51 (22 LOC)
rust/src/cognitive/hebbian.rs
pub async fn boost_on_access(pool: &PgPool, entity_id: uuid::Uuid) -> Result<()> {
    sqlx::query(
        "UPDATE brain_entities SET
            bcm_theta = GREATEST($5, (1.0 - $6) * COALESCE(bcm_theta, $5) + $6 * access_count::float8),
            importance = LEAST(
                importance + $1 * GREATEST(0.1, 1.0 - (access_count::float8 / GREATEST(COALESCE(bcm_theta, $2), access_count::float8)) * $3),
                1.0
            ),
            access_count = access_count + 1,
            updated_at = NOW()
         WHERE id = $4"
    )
    .bind(HEBBIAN_ACCESS_BOOST)  // $1
    .bind(BCM_THETA_MIN)         // $2
    .bind(BCM_THROTTLE_SCALE)    // $3
    .bind(entity_id)             // $4
    .bind(BCM_THETA_MIN)         // $5 (floor)
    .bind(BCM_EMA_ALPHA)         // $6
    .execute(pool)
    .await?;
    Ok(())
}
boost_on_access function · rust · L30-L51 (22 LOC)
rust/src/cognitive/hebbian.rs
pub async fn boost_on_access(pool: &PgPool, entity_id: uuid::Uuid) -> Result<()> {
    sqlx::query(
        "UPDATE brain_entities SET
            bcm_theta = GREATEST($5, (1.0 - $6) * COALESCE(bcm_theta, $5) + $6 * access_count::float8),
            importance = LEAST(
                importance + $1 * GREATEST(0.1, 1.0 - (access_count::float8 / GREATEST(COALESCE(bcm_theta, $2), access_count::float8)) * $3),
                1.0
            ),
            access_count = access_count + 1,
            updated_at = NOW()
         WHERE id = $4"
    )
    .bind(HEBBIAN_ACCESS_BOOST)  // $1
    .bind(BCM_THETA_MIN)         // $2
    .bind(BCM_THROTTLE_SCALE)    // $3
    .bind(entity_id)             // $4
    .bind(BCM_THETA_MIN)         // $5 (floor)
    .bind(BCM_EMA_ALPHA)         // $6
    .execute(pool)
    .await?;
    Ok(())
}
boost_on_access function · rust · L30-L51 (22 LOC)
rust/src/cognitive/hebbian.rs
pub async fn boost_on_access(pool: &PgPool, entity_id: uuid::Uuid) -> Result<()> {
    sqlx::query(
        "UPDATE brain_entities SET
            bcm_theta = GREATEST($5, (1.0 - $6) * COALESCE(bcm_theta, $5) + $6 * access_count::float8),
            importance = LEAST(
                importance + $1 * GREATEST(0.1, 1.0 - (access_count::float8 / GREATEST(COALESCE(bcm_theta, $2), access_count::float8)) * $3),
                1.0
            ),
            access_count = access_count + 1,
            updated_at = NOW()
         WHERE id = $4"
    )
    .bind(HEBBIAN_ACCESS_BOOST)  // $1
    .bind(BCM_THETA_MIN)         // $2
    .bind(BCM_THROTTLE_SCALE)    // $3
    .bind(entity_id)             // $4
    .bind(BCM_THETA_MIN)         // $5 (floor)
    .bind(BCM_EMA_ALPHA)         // $6
    .execute(pool)
    .await?;
    Ok(())
}
boost_on_access function · rust · L30-L51 (22 LOC)
rust/src/cognitive/hebbian.rs
pub async fn boost_on_access(pool: &PgPool, entity_id: uuid::Uuid) -> Result<()> {
    sqlx::query(
        "UPDATE brain_entities SET
            bcm_theta = GREATEST($5, (1.0 - $6) * COALESCE(bcm_theta, $5) + $6 * access_count::float8),
            importance = LEAST(
                importance + $1 * GREATEST(0.1, 1.0 - (access_count::float8 / GREATEST(COALESCE(bcm_theta, $2), access_count::float8)) * $3),
                1.0
            ),
            access_count = access_count + 1,
            updated_at = NOW()
         WHERE id = $4"
    )
    .bind(HEBBIAN_ACCESS_BOOST)  // $1
    .bind(BCM_THETA_MIN)         // $2
    .bind(BCM_THROTTLE_SCALE)    // $3
    .bind(entity_id)             // $4
    .bind(BCM_THETA_MIN)         // $5 (floor)
    .bind(BCM_EMA_ALPHA)         // $6
    .execute(pool)
    .await?;
    Ok(())
}
boost_neighbors function · rust · L62-L83 (22 LOC)
rust/src/cognitive/hebbian.rs
pub async fn boost_neighbors(pool: &PgPool, entity_id: uuid::Uuid) -> Result<usize> {
    let result = sqlx::query(
        "UPDATE brain_entities SET
            importance = LEAST(importance + $1 * 0.5 * sub.max_strength, 1.0),
            updated_at = NOW()
         FROM (
             SELECT
                 CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END AS neighbor_id,
                 MAX(strength) AS max_strength
             FROM brain_relations
             WHERE from_entity = $2 OR to_entity = $2
             GROUP BY CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END
         ) sub
         WHERE brain_entities.id = sub.neighbor_id",
    )
    .bind(HEBBIAN_ACCESS_BOOST)
    .bind(entity_id)
    .execute(pool)
    .await?;

    Ok(result.rows_affected() as usize)
}
boost_neighbors function · rust · L62-L83 (22 LOC)
rust/src/cognitive/hebbian.rs
pub async fn boost_neighbors(pool: &PgPool, entity_id: uuid::Uuid) -> Result<usize> {
    let result = sqlx::query(
        "UPDATE brain_entities SET
            importance = LEAST(importance + $1 * 0.5 * sub.max_strength, 1.0),
            updated_at = NOW()
         FROM (
             SELECT
                 CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END AS neighbor_id,
                 MAX(strength) AS max_strength
             FROM brain_relations
             WHERE from_entity = $2 OR to_entity = $2
             GROUP BY CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END
         ) sub
         WHERE brain_entities.id = sub.neighbor_id",
    )
    .bind(HEBBIAN_ACCESS_BOOST)
    .bind(entity_id)
    .execute(pool)
    .await?;

    Ok(result.rows_affected() as usize)
}
boost_neighbors function · rust · L62-L83 (22 LOC)
rust/src/cognitive/hebbian.rs
pub async fn boost_neighbors(pool: &PgPool, entity_id: uuid::Uuid) -> Result<usize> {
    let result = sqlx::query(
        "UPDATE brain_entities SET
            importance = LEAST(importance + $1 * 0.5 * sub.max_strength, 1.0),
            updated_at = NOW()
         FROM (
             SELECT
                 CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END AS neighbor_id,
                 MAX(strength) AS max_strength
             FROM brain_relations
             WHERE from_entity = $2 OR to_entity = $2
             GROUP BY CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END
         ) sub
         WHERE brain_entities.id = sub.neighbor_id",
    )
    .bind(HEBBIAN_ACCESS_BOOST)
    .bind(entity_id)
    .execute(pool)
    .await?;

    Ok(result.rows_affected() as usize)
}
Repobility — the code-quality scanner for AI-generated software · https://repobility.com
boost_neighbors function · rust · L62-L83 (22 LOC)
rust/src/cognitive/hebbian.rs
pub async fn boost_neighbors(pool: &PgPool, entity_id: uuid::Uuid) -> Result<usize> {
    let result = sqlx::query(
        "UPDATE brain_entities SET
            importance = LEAST(importance + $1 * 0.5 * sub.max_strength, 1.0),
            updated_at = NOW()
         FROM (
             SELECT
                 CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END AS neighbor_id,
                 MAX(strength) AS max_strength
             FROM brain_relations
             WHERE from_entity = $2 OR to_entity = $2
             GROUP BY CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END
         ) sub
         WHERE brain_entities.id = sub.neighbor_id",
    )
    .bind(HEBBIAN_ACCESS_BOOST)
    .bind(entity_id)
    .execute(pool)
    .await?;

    Ok(result.rows_affected() as usize)
}
boost_neighbors function · rust · L62-L83 (22 LOC)
rust/src/cognitive/hebbian.rs
pub async fn boost_neighbors(pool: &PgPool, entity_id: uuid::Uuid) -> Result<usize> {
    let result = sqlx::query(
        "UPDATE brain_entities SET
            importance = LEAST(importance + $1 * 0.5 * sub.max_strength, 1.0),
            updated_at = NOW()
         FROM (
             SELECT
                 CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END AS neighbor_id,
                 MAX(strength) AS max_strength
             FROM brain_relations
             WHERE from_entity = $2 OR to_entity = $2
             GROUP BY CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END
         ) sub
         WHERE brain_entities.id = sub.neighbor_id",
    )
    .bind(HEBBIAN_ACCESS_BOOST)
    .bind(entity_id)
    .execute(pool)
    .await?;

    Ok(result.rows_affected() as usize)
}
boost_neighbors function · rust · L62-L83 (22 LOC)
rust/src/cognitive/hebbian.rs
pub async fn boost_neighbors(pool: &PgPool, entity_id: uuid::Uuid) -> Result<usize> {
    let result = sqlx::query(
        "UPDATE brain_entities SET
            importance = LEAST(importance + $1 * 0.5 * sub.max_strength, 1.0),
            updated_at = NOW()
         FROM (
             SELECT
                 CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END AS neighbor_id,
                 MAX(strength) AS max_strength
             FROM brain_relations
             WHERE from_entity = $2 OR to_entity = $2
             GROUP BY CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END
         ) sub
         WHERE brain_entities.id = sub.neighbor_id",
    )
    .bind(HEBBIAN_ACCESS_BOOST)
    .bind(entity_id)
    .execute(pool)
    .await?;

    Ok(result.rows_affected() as usize)
}
boost_neighbors function · rust · L62-L83 (22 LOC)
rust/src/cognitive/hebbian.rs
pub async fn boost_neighbors(pool: &PgPool, entity_id: uuid::Uuid) -> Result<usize> {
    let result = sqlx::query(
        "UPDATE brain_entities SET
            importance = LEAST(importance + $1 * 0.5 * sub.max_strength, 1.0),
            updated_at = NOW()
         FROM (
             SELECT
                 CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END AS neighbor_id,
                 MAX(strength) AS max_strength
             FROM brain_relations
             WHERE from_entity = $2 OR to_entity = $2
             GROUP BY CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END
         ) sub
         WHERE brain_entities.id = sub.neighbor_id",
    )
    .bind(HEBBIAN_ACCESS_BOOST)
    .bind(entity_id)
    .execute(pool)
    .await?;

    Ok(result.rows_affected() as usize)
}
boost_neighbors function · rust · L62-L83 (22 LOC)
rust/src/cognitive/hebbian.rs
pub async fn boost_neighbors(pool: &PgPool, entity_id: uuid::Uuid) -> Result<usize> {
    let result = sqlx::query(
        "UPDATE brain_entities SET
            importance = LEAST(importance + $1 * 0.5 * sub.max_strength, 1.0),
            updated_at = NOW()
         FROM (
             SELECT
                 CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END AS neighbor_id,
                 MAX(strength) AS max_strength
             FROM brain_relations
             WHERE from_entity = $2 OR to_entity = $2
             GROUP BY CASE WHEN from_entity = $2 THEN to_entity ELSE from_entity END
         ) sub
         WHERE brain_entities.id = sub.neighbor_id",
    )
    .bind(HEBBIAN_ACCESS_BOOST)
    .bind(entity_id)
    .execute(pool)
    .await?;

    Ok(result.rows_affected() as usize)
}
gate function · rust · L29-L37 (9 LOC)
rust/src/cognitive/prediction_error.rs
pub fn gate(similarity: f64) -> GatingAction {
    if similarity >= PRED_ERROR_REINFORCE {
        GatingAction::Reinforce
    } else if similarity >= PRED_ERROR_UPDATE {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
gate function · rust · L29-L37 (9 LOC)
rust/src/cognitive/prediction_error.rs
pub fn gate(similarity: f64) -> GatingAction {
    if similarity >= PRED_ERROR_REINFORCE {
        GatingAction::Reinforce
    } else if similarity >= PRED_ERROR_UPDATE {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
gate function · rust · L29-L37 (9 LOC)
rust/src/cognitive/prediction_error.rs
pub fn gate(similarity: f64) -> GatingAction {
    if similarity >= PRED_ERROR_REINFORCE {
        GatingAction::Reinforce
    } else if similarity >= PRED_ERROR_UPDATE {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
Generated by Repobility's multi-pass static-analysis pipeline (https://repobility.com)
gate function · rust · L29-L37 (9 LOC)
rust/src/cognitive/prediction_error.rs
pub fn gate(similarity: f64) -> GatingAction {
    if similarity >= PRED_ERROR_REINFORCE {
        GatingAction::Reinforce
    } else if similarity >= PRED_ERROR_UPDATE {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
gate function · rust · L29-L37 (9 LOC)
rust/src/cognitive/prediction_error.rs
pub fn gate(similarity: f64) -> GatingAction {
    if similarity >= PRED_ERROR_REINFORCE {
        GatingAction::Reinforce
    } else if similarity >= PRED_ERROR_UPDATE {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
gate function · rust · L29-L37 (9 LOC)
rust/src/cognitive/prediction_error.rs
pub fn gate(similarity: f64) -> GatingAction {
    if similarity >= PRED_ERROR_REINFORCE {
        GatingAction::Reinforce
    } else if similarity >= PRED_ERROR_UPDATE {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
gate function · rust · L29-L37 (9 LOC)
rust/src/cognitive/prediction_error.rs
pub fn gate(similarity: f64) -> GatingAction {
    if similarity >= PRED_ERROR_REINFORCE {
        GatingAction::Reinforce
    } else if similarity >= PRED_ERROR_UPDATE {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
gate function · rust · L29-L37 (9 LOC)
rust/src/cognitive/prediction_error.rs
pub fn gate(similarity: f64) -> GatingAction {
    if similarity >= PRED_ERROR_REINFORCE {
        GatingAction::Reinforce
    } else if similarity >= PRED_ERROR_UPDATE {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
adaptive_gate function · rust · L55-L65 (11 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_gate(similarity: f64, recent_similarities: &[f64]) -> GatingAction {
    let (reinforce_thresh, update_thresh) = adaptive_thresholds_zscore(recent_similarities);

    if similarity >= reinforce_thresh {
        GatingAction::Reinforce
    } else if similarity >= update_thresh {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
adaptive_gate function · rust · L55-L65 (11 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_gate(similarity: f64, recent_similarities: &[f64]) -> GatingAction {
    let (reinforce_thresh, update_thresh) = adaptive_thresholds_zscore(recent_similarities);

    if similarity >= reinforce_thresh {
        GatingAction::Reinforce
    } else if similarity >= update_thresh {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
adaptive_gate function · rust · L55-L65 (11 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_gate(similarity: f64, recent_similarities: &[f64]) -> GatingAction {
    let (reinforce_thresh, update_thresh) = adaptive_thresholds_zscore(recent_similarities);

    if similarity >= reinforce_thresh {
        GatingAction::Reinforce
    } else if similarity >= update_thresh {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
All rows scored by the Repobility analyzer (https://repobility.com)
adaptive_gate function · rust · L55-L65 (11 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_gate(similarity: f64, recent_similarities: &[f64]) -> GatingAction {
    let (reinforce_thresh, update_thresh) = adaptive_thresholds_zscore(recent_similarities);

    if similarity >= reinforce_thresh {
        GatingAction::Reinforce
    } else if similarity >= update_thresh {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
adaptive_gate function · rust · L55-L65 (11 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_gate(similarity: f64, recent_similarities: &[f64]) -> GatingAction {
    let (reinforce_thresh, update_thresh) = adaptive_thresholds_zscore(recent_similarities);

    if similarity >= reinforce_thresh {
        GatingAction::Reinforce
    } else if similarity >= update_thresh {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
adaptive_gate function · rust · L55-L65 (11 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_gate(similarity: f64, recent_similarities: &[f64]) -> GatingAction {
    let (reinforce_thresh, update_thresh) = adaptive_thresholds_zscore(recent_similarities);

    if similarity >= reinforce_thresh {
        GatingAction::Reinforce
    } else if similarity >= update_thresh {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
adaptive_gate function · rust · L55-L65 (11 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_gate(similarity: f64, recent_similarities: &[f64]) -> GatingAction {
    let (reinforce_thresh, update_thresh) = adaptive_thresholds_zscore(recent_similarities);

    if similarity >= reinforce_thresh {
        GatingAction::Reinforce
    } else if similarity >= update_thresh {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
adaptive_gate function · rust · L55-L65 (11 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_gate(similarity: f64, recent_similarities: &[f64]) -> GatingAction {
    let (reinforce_thresh, update_thresh) = adaptive_thresholds_zscore(recent_similarities);

    if similarity >= reinforce_thresh {
        GatingAction::Reinforce
    } else if similarity >= update_thresh {
        GatingAction::Update
    } else {
        GatingAction::Create
    }
}
adaptive_thresholds_zscore function · rust · L77-L96 (20 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_thresholds_zscore(recent_similarities: &[f64]) -> (f64, f64) {
    if recent_similarities.len() < 5 {
        return (PRED_ERROR_REINFORCE, PRED_ERROR_UPDATE);
    }

    let n = recent_similarities.len() as f64;
    let mean = recent_similarities.iter().sum::<f64>() / n;
    let variance = recent_similarities
        .iter()
        .map(|x| (x - mean).powi(2))
        .sum::<f64>()
        / n;
    let sigma = variance.sqrt();

    // V5.2: Z-score thresholds — μ + Nσ
    let reinforce = (mean + 2.0 * sigma).clamp(0.80, 0.98);
    let update = (mean + 1.0 * sigma).clamp(0.50, reinforce - 0.05);

    (reinforce, update)
}
adaptive_thresholds_zscore function · rust · L77-L96 (20 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_thresholds_zscore(recent_similarities: &[f64]) -> (f64, f64) {
    if recent_similarities.len() < 5 {
        return (PRED_ERROR_REINFORCE, PRED_ERROR_UPDATE);
    }

    let n = recent_similarities.len() as f64;
    let mean = recent_similarities.iter().sum::<f64>() / n;
    let variance = recent_similarities
        .iter()
        .map(|x| (x - mean).powi(2))
        .sum::<f64>()
        / n;
    let sigma = variance.sqrt();

    // V5.2: Z-score thresholds — μ + Nσ
    let reinforce = (mean + 2.0 * sigma).clamp(0.80, 0.98);
    let update = (mean + 1.0 * sigma).clamp(0.50, reinforce - 0.05);

    (reinforce, update)
}
adaptive_thresholds_zscore function · rust · L77-L96 (20 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_thresholds_zscore(recent_similarities: &[f64]) -> (f64, f64) {
    if recent_similarities.len() < 5 {
        return (PRED_ERROR_REINFORCE, PRED_ERROR_UPDATE);
    }

    let n = recent_similarities.len() as f64;
    let mean = recent_similarities.iter().sum::<f64>() / n;
    let variance = recent_similarities
        .iter()
        .map(|x| (x - mean).powi(2))
        .sum::<f64>()
        / n;
    let sigma = variance.sqrt();

    // V5.2: Z-score thresholds — μ + Nσ
    let reinforce = (mean + 2.0 * sigma).clamp(0.80, 0.98);
    let update = (mean + 1.0 * sigma).clamp(0.50, reinforce - 0.05);

    (reinforce, update)
}
Repobility's GitHub App fixes findings like these · https://github.com/apps/repobility-bot
adaptive_thresholds_zscore function · rust · L77-L96 (20 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_thresholds_zscore(recent_similarities: &[f64]) -> (f64, f64) {
    if recent_similarities.len() < 5 {
        return (PRED_ERROR_REINFORCE, PRED_ERROR_UPDATE);
    }

    let n = recent_similarities.len() as f64;
    let mean = recent_similarities.iter().sum::<f64>() / n;
    let variance = recent_similarities
        .iter()
        .map(|x| (x - mean).powi(2))
        .sum::<f64>()
        / n;
    let sigma = variance.sqrt();

    // V5.2: Z-score thresholds — μ + Nσ
    let reinforce = (mean + 2.0 * sigma).clamp(0.80, 0.98);
    let update = (mean + 1.0 * sigma).clamp(0.50, reinforce - 0.05);

    (reinforce, update)
}
adaptive_thresholds_zscore function · rust · L77-L96 (20 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_thresholds_zscore(recent_similarities: &[f64]) -> (f64, f64) {
    if recent_similarities.len() < 5 {
        return (PRED_ERROR_REINFORCE, PRED_ERROR_UPDATE);
    }

    let n = recent_similarities.len() as f64;
    let mean = recent_similarities.iter().sum::<f64>() / n;
    let variance = recent_similarities
        .iter()
        .map(|x| (x - mean).powi(2))
        .sum::<f64>()
        / n;
    let sigma = variance.sqrt();

    // V5.2: Z-score thresholds — μ + Nσ
    let reinforce = (mean + 2.0 * sigma).clamp(0.80, 0.98);
    let update = (mean + 1.0 * sigma).clamp(0.50, reinforce - 0.05);

    (reinforce, update)
}
adaptive_thresholds_zscore function · rust · L77-L96 (20 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_thresholds_zscore(recent_similarities: &[f64]) -> (f64, f64) {
    if recent_similarities.len() < 5 {
        return (PRED_ERROR_REINFORCE, PRED_ERROR_UPDATE);
    }

    let n = recent_similarities.len() as f64;
    let mean = recent_similarities.iter().sum::<f64>() / n;
    let variance = recent_similarities
        .iter()
        .map(|x| (x - mean).powi(2))
        .sum::<f64>()
        / n;
    let sigma = variance.sqrt();

    // V5.2: Z-score thresholds — μ + Nσ
    let reinforce = (mean + 2.0 * sigma).clamp(0.80, 0.98);
    let update = (mean + 1.0 * sigma).clamp(0.50, reinforce - 0.05);

    (reinforce, update)
}
adaptive_thresholds_zscore function · rust · L77-L96 (20 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_thresholds_zscore(recent_similarities: &[f64]) -> (f64, f64) {
    if recent_similarities.len() < 5 {
        return (PRED_ERROR_REINFORCE, PRED_ERROR_UPDATE);
    }

    let n = recent_similarities.len() as f64;
    let mean = recent_similarities.iter().sum::<f64>() / n;
    let variance = recent_similarities
        .iter()
        .map(|x| (x - mean).powi(2))
        .sum::<f64>()
        / n;
    let sigma = variance.sqrt();

    // V5.2: Z-score thresholds — μ + Nσ
    let reinforce = (mean + 2.0 * sigma).clamp(0.80, 0.98);
    let update = (mean + 1.0 * sigma).clamp(0.50, reinforce - 0.05);

    (reinforce, update)
}
adaptive_thresholds_zscore function · rust · L77-L96 (20 LOC)
rust/src/cognitive/prediction_error.rs
pub fn adaptive_thresholds_zscore(recent_similarities: &[f64]) -> (f64, f64) {
    if recent_similarities.len() < 5 {
        return (PRED_ERROR_REINFORCE, PRED_ERROR_UPDATE);
    }

    let n = recent_similarities.len() as f64;
    let mean = recent_similarities.iter().sum::<f64>() / n;
    let variance = recent_similarities
        .iter()
        .map(|x| (x - mean).powi(2))
        .sum::<f64>()
        / n;
    let sigma = variance.sqrt();

    // V5.2: Z-score thresholds — μ + Nσ
    let reinforce = (mean + 2.0 * sigma).clamp(0.80, 0.98);
    let update = (mean + 1.0 * sigma).clamp(0.50, reinforce - 0.05);

    (reinforce, update)
}
assess_novelty_adaptive function · rust · L99-L108 (10 LOC)
rust/src/cognitive/prediction_error.rs
pub fn assess_novelty_adaptive(
    similarity_scores: &[f64],
    recent_similarities: &[f64],
) -> (bool, f64, GatingAction) {
    let max_sim = similarity_scores.iter().cloned().fold(0.0f64, f64::max);
    let action = adaptive_gate(max_sim, recent_similarities);

    let should_store = !matches!(action, GatingAction::Reinforce);
    (should_store, max_sim, action)
}
assess_novelty_adaptive function · rust · L99-L108 (10 LOC)
rust/src/cognitive/prediction_error.rs
pub fn assess_novelty_adaptive(
    similarity_scores: &[f64],
    recent_similarities: &[f64],
) -> (bool, f64, GatingAction) {
    let max_sim = similarity_scores.iter().cloned().fold(0.0f64, f64::max);
    let action = adaptive_gate(max_sim, recent_similarities);

    let should_store = !matches!(action, GatingAction::Reinforce);
    (should_store, max_sim, action)
}
assess_novelty_adaptive function · rust · L99-L108 (10 LOC)
rust/src/cognitive/prediction_error.rs
pub fn assess_novelty_adaptive(
    similarity_scores: &[f64],
    recent_similarities: &[f64],
) -> (bool, f64, GatingAction) {
    let max_sim = similarity_scores.iter().cloned().fold(0.0f64, f64::max);
    let action = adaptive_gate(max_sim, recent_similarities);

    let should_store = !matches!(action, GatingAction::Reinforce);
    (should_store, max_sim, action)
}
Repobility — the code-quality scanner for AI-generated software · https://repobility.com
assess_novelty_adaptive function · rust · L99-L108 (10 LOC)
rust/src/cognitive/prediction_error.rs
pub fn assess_novelty_adaptive(
    similarity_scores: &[f64],
    recent_similarities: &[f64],
) -> (bool, f64, GatingAction) {
    let max_sim = similarity_scores.iter().cloned().fold(0.0f64, f64::max);
    let action = adaptive_gate(max_sim, recent_similarities);

    let should_store = !matches!(action, GatingAction::Reinforce);
    (should_store, max_sim, action)
}
assess_novelty_adaptive function · rust · L99-L108 (10 LOC)
rust/src/cognitive/prediction_error.rs
pub fn assess_novelty_adaptive(
    similarity_scores: &[f64],
    recent_similarities: &[f64],
) -> (bool, f64, GatingAction) {
    let max_sim = similarity_scores.iter().cloned().fold(0.0f64, f64::max);
    let action = adaptive_gate(max_sim, recent_similarities);

    let should_store = !matches!(action, GatingAction::Reinforce);
    (should_store, max_sim, action)
}
assess_novelty_adaptive function · rust · L99-L108 (10 LOC)
rust/src/cognitive/prediction_error.rs
pub fn assess_novelty_adaptive(
    similarity_scores: &[f64],
    recent_similarities: &[f64],
) -> (bool, f64, GatingAction) {
    let max_sim = similarity_scores.iter().cloned().fold(0.0f64, f64::max);
    let action = adaptive_gate(max_sim, recent_similarities);

    let should_store = !matches!(action, GatingAction::Reinforce);
    (should_store, max_sim, action)
}
assess_novelty_adaptive function · rust · L99-L108 (10 LOC)
rust/src/cognitive/prediction_error.rs
pub fn assess_novelty_adaptive(
    similarity_scores: &[f64],
    recent_similarities: &[f64],
) -> (bool, f64, GatingAction) {
    let max_sim = similarity_scores.iter().cloned().fold(0.0f64, f64::max);
    let action = adaptive_gate(max_sim, recent_similarities);

    let should_store = !matches!(action, GatingAction::Reinforce);
    (should_store, max_sim, action)
}
assess_novelty_adaptive function · rust · L99-L108 (10 LOC)
rust/src/cognitive/prediction_error.rs
pub fn assess_novelty_adaptive(
    similarity_scores: &[f64],
    recent_similarities: &[f64],
) -> (bool, f64, GatingAction) {
    let max_sim = similarity_scores.iter().cloned().fold(0.0f64, f64::max);
    let action = adaptive_gate(max_sim, recent_similarities);

    let should_store = !matches!(action, GatingAction::Reinforce);
    (should_store, max_sim, action)
}
test_gate_reinforce function · rust · L115-L118 (4 LOC)
rust/src/cognitive/prediction_error.rs
    fn test_gate_reinforce() {
        assert_eq!(gate(0.95), GatingAction::Reinforce);
        assert_eq!(gate(0.92), GatingAction::Reinforce);
    }
test_gate_reinforce function · rust · L115-L118 (4 LOC)
rust/src/cognitive/prediction_error.rs
    fn test_gate_reinforce() {
        assert_eq!(gate(0.95), GatingAction::Reinforce);
        assert_eq!(gate(0.92), GatingAction::Reinforce);
    }
test_gate_reinforce function · rust · L115-L118 (4 LOC)
rust/src/cognitive/prediction_error.rs
    fn test_gate_reinforce() {
        assert_eq!(gate(0.95), GatingAction::Reinforce);
        assert_eq!(gate(0.92), GatingAction::Reinforce);
    }
Generated by Repobility's multi-pass static-analysis pipeline (https://repobility.com)
test_gate_reinforce function · rust · L115-L118 (4 LOC)
rust/src/cognitive/prediction_error.rs
    fn test_gate_reinforce() {
        assert_eq!(gate(0.95), GatingAction::Reinforce);
        assert_eq!(gate(0.92), GatingAction::Reinforce);
    }
test_gate_reinforce function · rust · L115-L118 (4 LOC)
rust/src/cognitive/prediction_error.rs
    fn test_gate_reinforce() {
        assert_eq!(gate(0.95), GatingAction::Reinforce);
        assert_eq!(gate(0.92), GatingAction::Reinforce);
    }
test_gate_reinforce function · rust · L115-L118 (4 LOC)
rust/src/cognitive/prediction_error.rs
    fn test_gate_reinforce() {
        assert_eq!(gate(0.95), GatingAction::Reinforce);
        assert_eq!(gate(0.92), GatingAction::Reinforce);
    }
‹ prevpage 3 / 51next ›