Add code

Author: alexvbrdn

Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "regexsolver"
+version = "0.1.0"
+edition = "2021"
+authors = ["Alexandre van Beurden"]
+repository = "https://github.com/RegexSolver/regexsolver"
+license = "MIT"
+keywords = ["automaton", "intersection", "union", "difference", "regex"]
+description = "Manipulate regex and automaton as if they were sets."
+readme = "README.md"
+
+[dependencies]
+env_logger = "0.11.3"
+serde = "1.0.197"
+serde_derive = "1.0.197"
+serde_json = "1.0.114"
+ciborium = "0.2.2"
+z85 = "3.0.5"
+aes-gcm-siv = "0.11.1"
+sha2 = "0.10.8"
+nohash-hasher = "0.2"
+ahash = "0.8.11"
+regex-syntax = "0.8.5"
+petgraph = "0.6.4"
+log = "0.4.21"
+rand = "0.8.5"
+lazy_static = "1.4.0"
+flate2 = { version = "1.0.30", features = [
+    "zlib-ng",
+], default-features = false }
+regex = "1.10.3"
+regex-charclass = { version = "1.0.3", features = ["serde"] }
+
+[dev-dependencies]
+criterion = { version = "0.5", features = ["html_reports"] }
+
+[[bench]]
+name = "my_benchmark"
+harness = false

README.md

@@ -0,0 +1,13 @@
+# RegexSolver
+
+[Homepage](https://regexsolver.com) | [Online Demo](https://regexsolver.com/demo) | [Documentation](https://docs.regexsolver.com) | [Developer Console](https://console.regexsolver.com)
+
+RegexSolver is a comprehensive toolkit designed for working with regular expressions, enabling you to manipulate them as sets.
+
+## Features
+
+- **Intersection**: Find the common patterns between multiple regular expressions.
+- **Union**: Combine multiple regular expressions into a single, unified expression.
+- **Subtraction/Difference**: Subtract one regular expression from another.
+- **Equivalence**: Determine if two regular expressions match the same set of strings.
+- **Subset**: Check if one regular expression is a subset of another.

benches/my_benchmark.rs

@@ -0,0 +1,87 @@
+use ahash::AHashSet;
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use regexsolver::{fast_automaton::FastAutomaton, regex::RegularExpression};
+
+fn parse_regex(regex: &str) -> RegularExpression {
+    RegularExpression::new(regex).unwrap()
+}
+
+fn to_regex(automaton: &FastAutomaton) -> RegularExpression {
+    automaton.to_regex().unwrap()
+}
+
+fn determinize(automaton: &FastAutomaton) -> FastAutomaton {
+    automaton.determinize().unwrap()
+}
+
+fn intersection(automaton_1: &FastAutomaton, automaton_2: &FastAutomaton) -> FastAutomaton {
+    automaton_1.intersection(automaton_2).unwrap()
+}
+
+fn generate_strings(automaton: &FastAutomaton) -> AHashSet<String> {
+    automaton.generate_strings(2000).unwrap()
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    {
+        c.bench_function("parse_regex", |b| {
+            b.iter(|| parse_regex(black_box("a(bcfe|bcdg|mkv)*(abc){2,3}(abc){2}")))
+        });
+    }
+
+    {
+        let input_regex = RegularExpression::new("a(bcfe|bcdg|mkv)*(abc){2,3}").unwrap();
+        let input_automaton = input_regex.to_automaton().unwrap();
+
+        c.bench_function("to_regex", |b| {
+            b.iter(|| to_regex(black_box(&input_automaton)))
+        });
+    }
+
+    {
+        let input_regex = RegularExpression::new(
+            "((aad|ads|a)*abc.*def.*uif(aad|ads|x)*abc.*oxs.*def(aad|ads|ax)*abc.*def.*ksd|q)",
+        )
+        .unwrap();
+        let input_automaton = input_regex.to_automaton().unwrap();
+
+        c.bench_function("determinize", |b| {
+            b.iter(|| determinize(black_box(&input_automaton)))
+        });
+    }
+
+    /*{
+        let input_regex = RegularExpression::new("((aad|ads|a)*abc.*def.*uif(aad|ads|x)*abc.*oxs.*def(aad|ads|ax)*abc.*def.*ksd|q){1,5}").unwrap();
+        let input_automaton = input_regex.to_automaton().unwrap();
+
+        c.bench_function("test_determinize", |b| {
+            b.iter(|| determinize(black_box(&input_automaton)))
+        });
+    }*/
+
+    {
+        let automaton1 = RegularExpression::new("a(bcfe|bcdg|mkv)*(abc){1,3}")
+            .unwrap()
+            .to_automaton().unwrap();
+        let automaton2 = RegularExpression::new("a(bcfe|mkv|opr)*(abc){2,4}")
+            .unwrap()
+            .to_automaton().unwrap();
+
+        c.bench_function("intersection", |b| {
+            b.iter(|| intersection(black_box(&automaton1), black_box(&automaton2)))
+        });
+    }
+
+    {
+        let automaton = RegularExpression::new("a(bcfe|bcdg|mkv)*(abc){1,3}")
+            .unwrap()
+            .to_automaton().unwrap();
+
+        c.bench_function("generate_strings", |b| {
+            b.iter(|| generate_strings(black_box(&automaton)))
+        });
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

src/cardinality/mod.rs

@@ -0,0 +1,14 @@
+use serde_derive::{Deserialize, Serialize};
+
+pub trait IntegerTrait {}
+
+impl IntegerTrait for u128 {}
+impl IntegerTrait for u32 {}
+
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", content = "value")]
+pub enum Cardinality<U: IntegerTrait> {
+    Infinite,
+    Integer(U),
+    BigInteger,
+}

src/condition/fast_bit_vec/mod.rs

@@ -0,0 +1,124 @@
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub struct FastBitVec {
+    bits: Vec<u64>,
+    n: usize,
+}
+
+impl std::fmt::Display for FastBitVec {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        for a in &self.bits {
+            write!(f, "{:b}", a)?;
+        }
+        Ok(())
+    }
+}
+
+impl FastBitVec {
+    #[inline]
+    pub fn from_elem(n: usize, bit: bool) -> Self {
+        let nblocks = if n % 64 == 0 { n / 64 } else { n / 64 + 1 };
+        let bits = vec![if bit { !0_u64 } else { 0_u64 }; nblocks];
+        let mut bit_vec = FastBitVec { bits, n };
+        bit_vec.fix_last_block();
+        bit_vec
+    }
+
+    fn fix_last_block(&mut self) {
+        if let Some((last_block, used_bits)) = self.last_block_mut_with_mask() {
+            *last_block &= used_bits;
+        }
+    }
+
+    #[inline]
+    fn last_block_mut_with_mask(&mut self) -> Option<(&mut u64, u64)> {
+        let extra_bits = self.len() % 64;
+        if extra_bits > 0 {
+            let mask = (1 << extra_bits) - 1;
+            let storage_len = self.bits.len();
+            Some((&mut self.bits[storage_len - 1], mask))
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.n
+    }
+
+    #[inline]
+    pub fn get(&self, i: usize) -> Option<bool> {
+        if i >= self.n {
+            return None;
+        }
+        let w = i / 64;
+        let b = i % 64;
+        self.bits.get(w).map(|&block| (block & (1 << b)) != 0)
+    }
+
+    #[inline]
+    pub fn set(&mut self, i: usize, x: bool) {
+        let w = i / 64;
+        let b = i % 64;
+        let flag = 1 << b;
+        let val = if x {
+            self.bits[w] | flag
+        } else {
+            self.bits[w] & !flag
+        };
+        self.bits[w] = val;
+    }
+
+    #[inline]
+    pub fn complement(&mut self) {
+        for w in &mut self.bits {
+            *w = !*w;
+        }
+        self.fix_last_block();
+    }
+
+    #[inline]
+    pub fn union(&mut self, other: &Self) {
+        for (a, b) in self.bits.iter_mut().zip(&other.bits) {
+            let w = *a | b;
+            *a = w;
+        }
+    }
+
+    #[inline]
+    pub fn intersection(&mut self, other: &Self) {
+        for (a, b) in self.bits.iter_mut().zip(&other.bits) {
+            let w = *a & b;
+            *a = w;
+        }
+    }
+
+    #[inline]
+    pub fn has_intersection(&self, other: &Self) -> bool {
+        for (a, b) in self.bits.iter().zip(&other.bits) {
+            if *a & b != 0 {
+                return true;
+            }
+        }
+        false
+    }
+
+    #[inline]
+    pub fn empty(&self) -> bool {
+        self.bits.iter().all(|w| w == &0)
+    }
+
+    #[inline]
+    pub fn total(&self) -> bool {
+        let mut last_word = !0;
+        self.bits.iter().all(|elem| {
+            let tmp = last_word;
+            last_word = *elem;
+            tmp == !0
+        }) && (last_word == Self::mask_for_bits(self.n))
+    }
+
+    fn mask_for_bits(bits: usize) -> u64 {
+        (!0) >> ((64 - bits % 64) % 64)
+    }
+}