Struct vlfeat_sys::_VlAIB

#[repr(C)]
pub struct _VlAIB {
    pub nodes: *mut vl_uint,
    pub nentries: vl_uint,
    pub beta: *mut f64,
    pub bidx: *mut vl_uint,
    pub which: *mut vl_uint,
    pub nwhich: vl_uint,
    pub Pcx: *mut f64,
    pub Px: *mut f64,
    pub Pc: *mut f64,
    pub nvalues: vl_uint,
    pub nlabels: vl_uint,
    pub parents: *mut vl_uint,
    pub costs: *mut f64,
    pub verbosity: vl_uint,
}

---

** @internal ** @brief AIB algorithm data ** ** The implementation is quite straightforward, but the way feature ** values are handled in order to support efficient joins, ** deletions and re-arrangement needs to be explained. This is ** achieved by adding a layer of indirection: ** - Call each feature value (either original or obtained by a join ** operation) a node. Nodes are identified by numbers. ** - Call each element of the various arrays (such as VlAIB::Px) ** an entry. ** - Entries are dynamically associated to nodes as specified by ** VlAIB::nodes. For example, @c Px[i] refers to the node @c ** nodes[i].

Fields

nodes: *mut vl_uint

< Entires to nodes

nentries: vl_uint

< Total number of entries (= # active nodes)

beta: *mut f64

< Minimum distance to an entry

bidx: *mut vl_uint

< Closest entry

which: *mut vl_uint

< List of entries to update

nwhich: vl_uint

< Number of entries to update

Pcx: *mut f64

< Joint probability table

Px: *mut f64

< Marginal.

Pc: *mut f64

< Marginal.

nvalues: vl_uint

< Number of feature values

nlabels: vl_uint

< Number of labels

parents: *mut vl_uint

< Array of parents

costs: *mut f64

< Cost of each merge

verbosity: vl_uint

Trait Implementations

impl Debug for _VlAIB

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Copy for _VlAIB

impl Clone for _VlAIB

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.