Struct NDFAEpsilon 

pub struct NDFAEpsilon { /* private fields */ }

Automate a état fini déterministe

Implementations

impl NDFAEpsilon

pub fn new( _starts: BTSet<State>, _delta: HashMap<Transition<State>, BTSet<State>>, _fsm: FSM, ) -> Self

Créer un automate a état fini non déterministe

Arguments

• _starts - Les états initiaux de l’automate
• _delta - Une HashMap decrivant les differentes transitions de l’automate
• _fsm - Une machine à état fini

Examples

Le contenu du json

{
    "states" : ["q_0", "q_1", "q_2"],
    "alphabet" : ["0","1", "ε"],
    "ends" : [],
    "starts" : ["q_0"],
    "delta" : [
      {
        "state" : "q_0",
        "symbol" : "ε",
        "images" : ["q_1"]
      },
      {
        "state" : "q_1",
        "symbol" : "ε",
        "images" : ["q_2"]
      },
      {
        "state" : "q_2",
        "symbol" : "ε",
        "images" : ["q_0"]
      }
    ]
  }

Le chargement dans le code

use automaters::*;
use std::fs;
use serde_json::{Value, from_str};
fn main() {

    let link_file: &str = "src/automates/NFA1e.json";
    let content_json: Value = {
        // Charge le contenu du fichier en tant que String
        let content : String = fs::read_to_string(link_file).unwrap();
        // Parse le texte en structure Json
        from_str::<Value>(&content).unwrap()
    };
    //creation depuis un lien
    let nfae : NDFAEpsilon = NDFAEpsilon::from_json_file(link_file);  
    //creation depuis du json
    let nfae2 : NDFAEpsilon = NDFAEpsilon::from_json(&content_json);
    let fsm: FSM = FSM::from_json(&content_json);
    //creation depuis new
    let nfae3 : NDFAEpsilon = NDFAEpsilon::new(nfae.get_starts().clone(), nfae.get_delta().clone(), fsm.clone());  

}

Return

• NDFAEpsilon - L’automate non déterministe à état fini avec Epsilon transition correspondante

pub fn apply_delta(&self, transition: Transition<State>) -> Option<BTSet<State>>

Applique une transition et renvoie un set d’etat (representant l’image de la transition)

pub fn apply_deltas( &self, set_transition: Transition<BTSet<State>>, ) -> Option<BTSet<State>>

Applique les transition et renvoie un set d’etat (representant l’image de la transition)

Trait Implementations

impl AutomateJsonIO for NDFAEpsilon

fn from_json(content_json: &Value) -> Self

Créer un automate à état fini non détérministe depuis un chemin du json

Arguments

• _starts - Les états initiaux de l’automate
• _delta - Une HashMap decrivant les differentes transitions de l’automate
• _fsm - Une machine à état fini

Examples

Le contenu du json

{
    "states" : ["s","t", "u", "v"],
    "alphabet" :  ["b","a"],
    "ends" : ["q_0"],
    "starts" : ["s"],
    "delta" : [
            {
             "state" : "s",         
             "symbol" : "a",         
             "images" : ["s", "t", "u", "v"]        
            },         
            {
             "state" : "t",         
             "symbol" : "b",         
             "images" : ["s"]        
            },
            {
             "state" : "u",         
             "symbol" : "b",         
             "images" : ["t"]        
            },
            {
             "state" : "v",         
             "symbol" : "b",         
             "images" : ["u"]        
            }
    ]
}

Le chargement dans le code

use automaters::*;
use std::fs;
use serde_json::{Value, from_str};
fn main() {

    let link_file: &str = "src/automates/NFA1e.json";
    let content_json: Value = {
        // Charge le contenu du fichier en tant que String
        let content : String = fs::read_to_string(link_file).unwrap();
        // Parse le texte en structure Json
        from_str::<Value>(&content).unwrap()
    };
    //creation depuis du json
    let nfae : NDFAEpsilon = NDFAEpsilon::from_json(&content_json);

}

Return

• NDFAEpsilon - L’automate non déterministe à état fini avec Epsilon transition correspondante

fn from_json_file(path: &str) -> Self

Créer un automate à état fini détérministe depuis un chemin vers un fichier json

Arguments

• _starts - Les états initiaux de l’automate
• _delta - Une HashMap decrivant les differentes transitions de l’automate
• _fsm - Une machine à état plusieur état fini décrivant l’automate

Examples

Le contenu du json

{
    "states" : ["s","t", "u", "v"],
    "alphabet" :  ["b","a"],
    "ends" : ["q_0"],
    "starts" : ["s"],
    "delta" : [
            {
             "state" : "s",         
             "symbol" : "a",         
             "images" : ["s", "t", "u", "v"]        
            },         
            {
             "state" : "t",         
             "symbol" : "b",         
             "images" : ["s"]        
            },
            {
             "state" : "u",         
             "symbol" : "b",         
             "images" : ["t"]        
            },
            {
             "state" : "v",         
             "symbol" : "b",         
             "images" : ["u"]        
            }
    ]
}

Le chargement dans le code

use automaters::*;
use std::fs;
use serde_json::{Value, from_str};
fn main() {

    let link_file: &str = "src/automates/NFA1e.json";
    let content_json: Value = {
        // Charge le contenu du fichier en tant que String
        let content : String = fs::read_to_string(link_file).unwrap();
        // Parse le texte en structure Json
        from_str::<Value>(&content).unwrap()
    };
    //creation depuis un lien
    let nfae : NDFAEpsilon = NDFAEpsilon::from_json_file(link_file);  

}

Return

• NDFAEpsilon - L’automate déterministe à état fini correspondante

impl AutomateTrait<BTSet<State>> for NDFAEpsilon

fn get_starts(&self) -> &BTSet<State>

Retourne les états de départ de l’automate

fn get_start(&self) -> &BTSet<State>

Alias de self.get_start

fn get_fsm(&self) -> &FSM

Retourne la machine de l’automate

fn get_delta(&self) -> &HashMap<Transition<State>, BTSet<State>>

Retourne les transitions de l’automate

fn get_states(&self) -> &BTSet<State>

Retournes les differents états de l’automate

fn get_alphabet(&self) -> &BTSet<Symbol>

Retourne l’alphabet de l’automate

fn get_ends(&self) -> &BTSet<State>

Retourne les états finaux de l’automate

fn accept(&self, _word: &str) -> bool

indique si un mot est accepté dans la langue de l’automate

fn to_dfa(&self) -> DFA

Convertit le NFA en DFA

use automaters::*;
use std::fs;
use serde_json::{Value, from_str};
fn main() {
 
    let link_file: &str = "src/automates/NFA1.json";
    let content_json: Value = {
        // Charge le contenu du fichier en tant que String
        let content : String = fs::read_to_string(link_file).unwrap();
        // Parse le texte en structure Json
        from_str::<Value>(&content).unwrap()
    };
    //creation depuis un lien
    let nfa : NDFA = NDFA::from_json_file(link_file);  
    dbg!(nfa.to_dfa());
}

Return

• NDFA - L’automate déterministe à état fini qui correspondante

impl Clone for NDFAEpsilon

fn clone(&self) -> NDFAEpsilon

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NDFAEpsilon

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

Formats the value using the given formatter.