类型别名和转换在types模块中实现，并依赖于是否启用了silx-types功能

目的

Furtif在Rust中提供了一种通用的信念函数操作和合并功能的实现。此crate包括

• 定义格及其变体的特质
  • 实现了两种类型的格
    • 幂集
    • 分类
• 在不同形式的信念函数之间进行转换的工具
• 实现了评审函数的概念，从而使得
  • 能够通用地定义融合规则
  • 设计用于计算融合分配的通用引擎
    • 目前，提出了具有剪枝的精确计算方法

Furtif从一开始就设计成异步工作，与Silx库交互。默认情况下启用此功能，但可以在Cargo.toml中通过在furtif-core上应用选项default-features = false来取消选择

furtif-core的主要功能是

• default：启用特征silx
• silx : 使 furtif-core 与 silx 兼容
  • 启用了功能 silx-types、serde 和 rkyv
• serde : 为某些类型实现 serde 序列化/反序列化
• rkyv : 为某些类型实现 rkyv 序列化/零拷贝反序列化
• silx-types : 使用 silx 类型构建实现
  • 使用 Silx 类型 f64slx、u128slx、u32slx 代替原生类型 f64、u128、u32，以实现晶格、元素和赋值

Furtif 仍然是一个开发中的项目。当前版本可以作为 silx 独立版本（通过在 furtif-core 上应用选项 default-features = false）运行，或者作为 silx 集成 crate，后者允许它在异步的 silx 环境中运行。
预计将进一步改进，例如为 Matlab 或 Octave 实现 Mex 模块。此外，我们还有一些关于信念函数的发展计划。

首先，以下 silx 独立示例给出了库功能的简约概述。其他示例，特别是 silx 集成的示例，也可以在项目的 github 上找到。

简约示例（Dempster-Shafer 融合）

Cargo.toml

[package]
name = "silx_furtif_dst"
version = "0.1.2"
edition = "2021"

[dependencies]
furtif-core = { version = "0.1.2", default-features = false }

main.rs

use furtif_core::{
    structs::{DiscountedFuser, EnumRule, Powerset},
    traits::{ComplementedLattice, DiscountedFusion, IterableLattice, Lattice},
};

/// Furtif: a simple fusion of 2 masses by Dempster-Shafer rule 
pub fn main() -> Result<(),String> {
    // build a powerset generated by `A` `B` and `C`
    let powerset = Powerset::new_with_label(
        &["A".to_string(), "B".to_string(), "C".to_string()], 128
    )?;
    // List of elements in the powerset (non-decreasing for the inclusion ordering)
    println!("==== Elements -------------");
    let powerset = powerset.set_iterators();
    for e in powerset.bottom_to_top()? {
        println!("{e} -> {}", powerset.to_string(&e)?);
    }
    // Some boolean operations and results
    // * `powerset.join(...)` is the disjunction operator
    // * `powerset.not(...)` is the boolean negation
    // * `powerset.meet(...)` is the conjunction operator
    println!("\n==== operators -------------");
    let a = powerset.from_str("A")?;
    let b = powerset.from_str("B")?;
    let aub = powerset.join(&a,&b)?;
    let not_a = powerset.not(&a)?;
    let aub_n_not_a = powerset.meet(&aub, &not_a)?;
    println!("aub: {} -> {}", aub, powerset.to_string(&aub)?);
    println!("not_a: {} -> {}", not_a, powerset.to_string(&not_a)?);
    println!("aub_n_not_a: {} -> {}", aub_n_not_a, powerset.to_string(&aub_n_not_a)?);
    println!("\n==== assignments -------------");
    // Construction of two basic belief assignments
    let c = powerset.from_str("C")?;
    let buc = not_a;
    let cua = powerset.not(&b)?;
    let m1 = powerset.assignment()
        + (a, 3.0) + (aub, 3.0) + (buc, 4.0) + ();
    let m2 = powerset.assignment()
        + (c, 2.0) + (aub, 3.0) + (cua, 5.0) + ();
    println!("m1 -> {m1}");
    println!("m2 -> {m2}");
    // Computation of Dempster-Shafer fusion
    let engine = DiscountedFuser::new(512..=1024);
    let (fused,z) = engine.fuse(&powerset, &EnumRule::DempsterShafer,&[&m1,&m2])?;
    println!("fused / DS -> {fused}");
    println!("z -> {z:.3}");
    Ok(())
}

典型输出

==== Elements -------------
0 -> ⊥
4 -> C
1 -> A
2 -> B
5 -> A | C
6 -> B | C
3 -> A | B
7 -> ⊤

==== operators -------------
aub: 3 -> A | B
not_a: 6 -> B | C
aub_n_not_a: 2 -> B

==== assignments -------------
m1 -> [ 6 -> 0.4000, 3 -> 0.3000, 1 -> 0.3000, ]
m2 -> [ 3 -> 0.3000, 5 -> 0.5000, 4 -> 0.2000, ]
fused / DS -> [ 3 -> 0.1023, 4 -> 0.3182, 1 -> 0.4432, 2 -> 0.1364, ]
z -> 0.120