Struct DFA

Source

pub struct DFA { /* private fields */ }

Expand description

Automate a état fini déterministe

Implementations§

Source §

impl DFA

Source

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

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

§Arguments

_start - L’état initial de l’automate
_delta - Une HashMap decrivant les differentes transition de l’automate
_fsm - Une machine à état fini décrivant l’automate

§Examples

Le contenu du json

{
    "states" : ["q_0","q_1"],
    "alphabet" : ["b","a"],
    "ends" : ["q_0"],
    "start" : "q_0", 
    "delta" : [
    	{
    		"state" : "q_0",         
    		"symbol" : "a",         
    		"image" : "q_1"         
    	},         
    	{         
    		"state" : "q_1",         
    		"symbol" : "b",         
    		"image" : "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/DFA1.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 dfa : DFA = DFA::from_json_file(link_file);  
    //creation depuis du json
    let dfa2 : DFA = DFA::from_json(&content_json);
    let fsm: FSM = FSM::from_json(&content_json);
    //creation depuis new
    let dfa3 : DFA = DFA::new(dfa.get_start().clone(), dfa.get_delta().clone(), fsm.clone());  
 
}

§Return

DFA - L’automate déterministe à état fini correspondante

Source

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

Source

pub fn to_transpose(&self) -> NDFA

Réalise la transposition de l’automate

use automaters::*;
use std::fs;
use serde_json::{Value, from_str};
fn main() {
    let link_file: &str = "src/automates/DFA1.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 dfa : DFA = DFA::from_json_file(link_file);  
    let nfa : NDFA = dfa.to_transpose();
}

§Return

NDFA - Un NDFA correspondant a la transposition de self

Source

pub fn to_minimize(&self) -> DFA

Renvoie la version minimize de l’automate

use automaters::*;
use std::fs;
use serde_json::{Value, from_str};
fn main() {
    let link_file: &str = "src/automates/DFA1.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 mut dfa : DFA = DFA::from_json_file(link_file);  
    // minimisation
    dfa = dfa.to_minimize();
}

§Return

DFA - Le DFA apres avoir été minimizé

Trait Implementations§

Source §

impl AutomateJsonIO for DFA

Source §

fn from_json(content_json: &Value) -> Self

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

§Arguments

_start - L’état initial de l’automate
_delta - Une HashMap decrivant les differentes transition de l’automate
_fsm - Une machine à état fini décrivant l’automate

§Examples

Le contenu du json

{
    "states" : ["q_0","q_1"],
    "alphabet" : ["b","a"],
    "ends" : ["q_0"],
    "start" : "q_0", 
    "delta" : [
    	{
    		"state" : "q_0",         
    		"symbol" : "a",         
    		"image" : "q_1"         
    	},         
    	{         
    		"state" : "q_1",         
    		"symbol" : "b",         
    		"image" : "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/DFA1.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 dfa : DFA = DFA::from_json(&content_json);
 
}

§Return

DFA - L’automate déterministe à état fini correspondante

Source §

fn from_json_file(path: &str) -> Self

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

§Arguments

_start - L’état initial de l’automate
_delta - Une HashMap decrivant les differentes transition de l’automate
_fsm - Une machine à état fini décrivant l’automate

§Examples

Le contenu du json

{
    "states" : ["q_0","q_1"],
    "alphabet" : ["b","a"],
    "ends" : ["q_0"],
    "start" : "q_0", 
    "delta" : [
    	{
    		"state" : "q_0",         
    		"symbol" : "a",         
    		"image" : "q_1"         
    	},         
    	{         
    		"state" : "q_1",         
    		"symbol" : "b",         
    		"image" : "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/DFA1.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 dfa : DFA = DFA::from_json_file(link_file);  
 
}