--- a/Spiral.scala Thu May 07 11:36:15 2020 +0100
+++ b/Spiral.scala Wed May 27 22:23:52 2020 +0100
@@ -1,244 +1,19 @@
+
+import Spiral._
import Element.elem
import RexpRelated._
import RexpRelated.Rexp._
-import Partial._
+//import Partial._
import scala.collection.mutable.ListBuffer
+
object Spiral{
- val space = elem(" ")
- val corner = elem("+")
- def spiral(nEdges: Int, direction: Int): Element = {
- if(nEdges == 1)
- elem("+")
- else {
- val sp = spiral(nEdges - 1, (direction + 3) % 4)
- def verticalBar = elem('|', 1, sp.height)
- def horizontalBar = elem('-', sp.width, 1)
- if(direction == 0)
- (corner beside horizontalBar) above sp//(sp beside space)
- else if (direction == 1)
- sp beside (corner above verticalBar)
- else if (direction == 2)
- (space beside sp) above (horizontalBar beside corner)
- else
- (verticalBar above corner) beside (space above sp)
- }
- }
val alphabet = ("""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.:"=()\;-+*!<>\/%{} """+"\n\t").toSet//Set('a','b','c')
- def regx_tree(r: Rexp): Element = aregx_tree(internalise(r))
- def annotated_tree(r: ARexp): Element = {
- r match {
- case ACHAR(bs, d) => {
- //val Some(d) = alphabet.find(f)
- d match {
- case '\n' => elem("\\n")
- case '\t' => elem("\\t")
- case ' ' => elem("space")
- case d => if(bs.isEmpty) elem(d.toString) else elem(d.toString++" ") beside elem(bs.toString)
- }
- }
- case AONE(bs) => {
- if(bs.isEmpty) elem("ONE") else elem("ONE ") beside elem(bs.toString)
- }
- case AZERO => {
- elem("ZERO")
- }
- case ASEQ(bs, r1, r2) => {
- annotated_binary_print("SEQ", r1, r2, bs)
- }
- case AALTS(bs, rs) => {
- //elem("Awaiting completion")
- annotated_list_print("ALT", rs, bs)
- }
- case ASTAR(bs, r) => {
- annotated_list_print("STA", List(r), bs)
- }
- }
- }
- def aregx_tree(r: ARexp): Element = {
- r match {
- case ACHAR(bs, d) => {
- //val Some(d) = alphabet.find(f)
- d match {
- case '\n' => elem("\\n")
- case '\t' => elem("\\t")
- case ' ' => elem("space")
- case d => elem(d.toString)
- }
- }
- case AONE(bs) => {
- elem("ONE")
- }
- case AZERO => {
- elem("ZERO")
- }
- case ASEQ(bs, r1, r2) => {
- binary_print("SEQ", r1, r2)
- }
- case AALTS(bs, rs) => {
- //elem("Awaiting completion")
- list_print("ALT", rs)
- }
- case ASTAR(bs, r) => {
- list_print("STA", List(r))
- }
- }
- }
- val port = elem(" └-")
- def list_print(name: String, rs: List[ARexp]): Element = {
- rs match {
- case r::Nil => {
- val pref = aregx_tree(r)
- val head = elem(name)
- (head left_align (port up_align pref) )
- }
- case r2::r1::Nil => {
- binary_print(name, r2, r1)
- }
- case r::rs1 => {
- val pref = aregx_tree(r)
- val head = elem(name)
- if (pref.height > 1){
- val link = elem('|', 1, pref.height - 1)
- (head left_align ((port above link) beside pref)) left_align tail_print(rs1)
- }
- else{
- (head left_align (port beside pref) ) left_align tail_print(rs1)
- }
- }
- }
- }
- def annotated_list_print(name: String, rs: List[ARexp], bs: List[Bit]): Element = {
- rs match {
- case r::Nil => {
- val pref = annotated_tree(r)
- val head = if(bs.isEmpty) elem(name) else elem(name ++ " ") beside elem(bs.toString)
- (head left_align (port up_align pref) )
- }
- case r2::r1::Nil => {
- annotated_binary_print(name, r2, r1, bs)
- }
- case r::rs1 => {
- val pref = annotated_tree(r)
- val head = if (bs.isEmpty) elem(name) else elem(name ++ " ") beside elem(bs.toString)
- if (pref.height > 1){
- val link = elem('|', 1, pref.height - 1)
- (head left_align ((port above link) beside pref)) left_align annotated_tail_print(rs1)
- }
- else{
- (head left_align (port beside pref) ) left_align annotated_tail_print(rs1)
- }
- }
- }
- }
-
- def annotated_tail_print(rs: List[ARexp]): Element = {
- rs match {
- case r2::r1::Nil => {
- val pref = annotated_tree(r2)
- val suff = annotated_tree(r1)
- if (pref.height > 1){
- val link = elem('|', 1, pref.height - 1)
- ((port above link) beside pref) left_align (port up_align suff)
- }
- else{
- (port beside pref) left_align (port up_align suff)
- }
- }
- case r2::rs1 => {
- val pref = annotated_tree(r2)
-
- if (pref.height > 1){
- val link = elem('|', 1, pref.height - 1)
- ((port above link) beside pref) left_align annotated_tail_print(rs1)//(port up_align tail_print(rs1) )
- }
- else{
- (port beside pref) left_align annotated_tail_print(rs1)//(port up_align tail_print(rs1))
- }
- //pref left_align tail_print(rs1)
- }
- }
- }
-
- def tail_print(rs: List[ARexp]): Element = {
- rs match {
- case r2::r1::Nil => {
- val pref = aregx_tree(r2)
- val suff = aregx_tree(r1)
- if (pref.height > 1){
- val link = elem('|', 1, pref.height - 1)
- ((port above link) beside pref) left_align (port up_align suff)
- }
- else{
- (port beside pref) left_align (port up_align suff)
- }
- }
- case r2::rs1 => {
- val pref = aregx_tree(r2)
-
- if (pref.height > 1){
- val link = elem('|', 1, pref.height - 1)
- ((port above link) beside pref) left_align tail_print(rs1)//(port up_align tail_print(rs1) )
- }
- else{
- (port beside pref) left_align tail_print(rs1)//(port up_align tail_print(rs1))
- }
- //pref left_align tail_print(rs1)
- }
- }
- }
-
- def binary_print(name: String, r1: ARexp, r2: ARexp): Element = {
- val pref = aregx_tree(r1)
- val suff = aregx_tree(r2)
- val head = elem(name)
- if (pref.height > 1){
- val link = elem('|', 1, pref.height - 1)
- (head left_align ((port above link) beside pref) ) left_align (port up_align suff)
- }
- else{
- (head left_align (port beside pref) ) left_align (port up_align suff)
- }
- }
- def annotated_binary_print(name: String, r1: ARexp, r2: ARexp, bs: List[Bit]): Element = {
- val pref = annotated_tree(r1)
- val suff = annotated_tree(r2)
- val head = if (bs.isEmpty) elem(name) else elem(name ++ " ") beside elem(bs.toString)
- if (pref.height > 1){
- val link = elem('|', 1, pref.height - 1)
- (head left_align ((port above link) beside pref) ) left_align (port up_align suff)
- }
- else{
- (head left_align (port beside pref) ) left_align (port up_align suff)
- }
- }
-
+
val arr_of_size = ListBuffer.empty[Int]
- def pC(r: Rexp): Set[Rexp] = {//PD's companion
- r match {
- case SEQ(r1, r2) => pC(r2)
- case ALTS(rs) => rs.flatMap(a => pC(a) ).toSet
- case CHAR(c) => Set(r)
- case r => Set()
- }
- }
- def illustration(r: Rexp, s: String){
- var i_like_imperative_style = internalise(r)
- val all_chars = s.toList
- for (i <- 0 to s.length - 1){
- val der_res = bder(all_chars(i), i_like_imperative_style)
- val simp_res = bsimp(der_res)
- println("The original regex, the regex after derivative w.r.t " + all_chars(i) + " and the simplification of the derivative.")
- println(aregx_tree(i_like_imperative_style) up_align aregx_tree(der_res) up_align aregx_tree(simp_res))
- //println(asize(i_like_imperative_style), asize(der_res), asize(simp_res))
- arr_of_size += asize(i_like_imperative_style)
- //println(asize(simp_res), asize(simp_res) / arr_of_size(0) )
- i_like_imperative_style = simp_res
- }
- arr_of_size += asize(i_like_imperative_style)
- }
+
val ran = scala.util.Random
var alphabet_size = 3
def balanced_seq_star_gen(depth: Int, star: Boolean): Rexp = {
@@ -252,20 +27,15 @@
SEQ(balanced_seq_star_gen(depth - 1, true), balanced_seq_star_gen(depth - 1, true))
}
}
- def max(i: Int, j: Int): Int = {
- if(i > j)
- i
- else
- j
- }
def random_struct_gen(depth:Int): Rexp = {
val dice = ran.nextInt(3)
val dice2 = ran.nextInt(3)
- (dice, depth) match {
+ val new_depth = (List(0, depth - 1 - dice2)).max
+ (dice, new_depth) match {
case (_, 0) => ((ran.nextInt(3) + 97).toChar).toString
- case (0, i) => STAR(random_struct_gen(max(0, i - 1 - dice2)))
- case (1, i) => SEQ(random_struct_gen(max(0, i - 1 - dice2)), random_struct_gen(max(0, i - 1 - dice2)))
- case (2, i) => ALTS( List(random_struct_gen(max(0, i - 1 - dice2)), random_struct_gen(max(0, i - 1 - dice2))) )
+ case (0, i) => STAR(random_struct_gen(new_depth))
+ case (1, i) => SEQ(random_struct_gen(new_depth), random_struct_gen(new_depth))
+ case (2, i) => ALTS( List(random_struct_gen(new_depth), random_struct_gen(new_depth)) )
}
}
def balanced_struct_gen(depth: Int): Rexp = {
@@ -297,41 +67,8 @@
println(b(0),b.max)
}
- def dep_exp(depth: List[Int]){
- for(i <- depth){
- arr_of_size.clear()
- val s = rd_string_gen(alphabet_size, (i-8)*(i-8)+10)
- val r = random_struct_gen(i)
- println("depth: "+i)
- illustration(r, s) //"abcabadaaadcabdbabcdaadbabbcbbdabdabbcbdbabdbcdb")
- //println("depth: " + i + " general stats:"+ arr_of_size(0), arr_of_size.max, arr_of_size.max/arr_of_size(0))
- //println("x y label alignment")
- /*for(i <- 0 to s.length - 1){
- if(s(i) == '\n')
- println(i+" "+arr_of_size(i)+" "+"nl"+" -140")
- else if(s(i) == ' ')
- println(i+" "+arr_of_size(i)+" "+"sp"+" -140")
- else
- println(i+" "+arr_of_size(i)+" "+s(i)+" -140")
- }*/
- //println(s.length + " " + arr_of_size(s.length) + " ]" + " -140")
- }
- }
- def case_study(ss: List[String], r: Rexp){
- for(s <- ss){
- arr_of_size.clear()
- illustration(r, s)
- println("x y label alignment")
- for(i <- 0 to s.length - 1){
- if(s(i) == '\n')
- println(i+" "+arr_of_size(i)+" "+"nl"+" -140")
- else if(s(i) == ' ')
- println(i+" "+arr_of_size(i)+" "+"sp"+" -140")
- else
- println(i+" "+arr_of_size(i)+" "+s(i)+" -140")
- }
- }
- }
+
+
def star_gen(dp: Int): Rexp = {
if(dp > 0)
STAR(star_gen(dp - 1))
@@ -346,48 +83,9 @@
Nil
}
}
- def regx_print(r: Rexp): String = {
- r match {
- case ZERO =>
- "ZERO"
- case CHAR(c) => {
- //val Some(c) = alphabet.find(f)
- "\"" + c.toString + "\""
- }
- case ONE => {
- "ONE"
- }
- case ALTS(rs) => {
- "ALTS(List("+(rs.map(regx_print)).foldLeft("")((a, b) => if(a == "") b else a + "," + b)+"))"
- }
- case SEQ(r1, r2) => {
- "SEQ(" + regx_print(r1) + "," + regx_print(r2) + ")"
- }
- case STAR(r) => {
- "STAR(" + regx_print(r) + ")"
- }
- }
- }
+
val mkst = "abcdefghijklmnopqrstuvwxyz"
-
- def inclusion_truth(anatomy: List[Rexp], pd: Set[Rexp]): Boolean = {
- val aset = anatomy.toSet
- if(aset subsetOf pd){
- true
- }
- else{
- println("inclusion not true")
- false
- }
- }
- def size_comp(anatomy: List[Rexp], pd: Set[Rexp]):Boolean = {println("size of PD and bspilled simp regx: ", pd.size, anatomy.size); true}
- def size_expansion_rate(r: List[Rexp], pd: Set[Rexp]): Boolean = if(size(r(0)) > (pd.map(size).sum) * 3 ) { false }else {true}
- def ders_simp(r: ARexp, s: List[Char]): ARexp = {
- s match {
- case Nil => r
- case c::cs => ders_simp(bsimp(bder(c, r)), cs)
- }
- }
+
val big_panda = STAR(STAR(STAR(ALTS(List(ALTS(List(CHAR('c'), CHAR('b'))), SEQ(CHAR('c'),CHAR('c')))))))
val str_panda = "ccccb"
@@ -396,28 +94,28 @@
case b::bs1 => elem(b.toString) beside bstostick(bs1)
case Nil => elem(' ', 1, 1)
}
- def bits_print(r: ARexp): Element = r match {
+ def aregex_simple_print(r: ARexp): Element = r match {
case AALTS(bs,rs) => {
val bitstick = bstostick(bs)
rs match {
case r::rs1 =>
rs1.foldLeft(
((elem("(") left_align bitstick) beside
- bits_print(r)) )( (acc, r2) => acc beside ((elem(" + ") above elem(" ")) beside bits_print(r2) )) beside
+ aregex_simple_print(r)) )( (acc, r2) => acc beside ((elem(" + ") above elem(" ")) beside aregex_simple_print(r2) )) beside
elem(")")
case Nil => elem(' ', 1, 1)
}
}
case ASEQ(bs, r1, r2) => {
- ((elem("[") left_align bstostick(bs)) beside bits_print(r1) beside elem("~") beside bits_print(r2) beside (elem("]") above elem(" ")))
+ ((elem("[") left_align bstostick(bs)) beside aregex_simple_print(r1) beside elem("~") beside aregex_simple_print(r2) beside (elem("]") above elem(" ")))
}
case ASTAR(bs, r) => {
r match {
case AONE(_) | AZERO | ACHAR(_, _) => {
- (elem("{") left_align bstostick(bs)) beside (bits_print(r) beside elem("}*"))
+ (elem("{") left_align bstostick(bs)) beside (aregex_simple_print(r) beside elem("}*"))
}
case _ => {
- (elem("{") left_align bstostick(bs)) beside (bits_print(r) beside elem("}*"))
+ (elem("{") left_align bstostick(bs)) beside (aregex_simple_print(r) beside elem("}*"))
}
}
}
@@ -432,30 +130,30 @@
elem ("0") above elem(" ")
}
}
- def happy_print(r: Rexp): Unit = r match {
+ def regex_simple_print(r: Rexp): Unit = r match {
case ALTS( r::rs ) => {
print("(")
- happy_print(r)
+ regex_simple_print(r)
rs.map(r2=>{
print(" + ")
- happy_print(r2)
+ regex_simple_print(r2)
})
print(")")
}
case SEQ(r1, r2) => {
- happy_print(r1)
+ regex_simple_print(r1)
print("~")
- happy_print(r2)
+ regex_simple_print(r2)
}
case STAR(r) => {
r match {
case ONE | ZERO | CHAR(_) => {
- happy_print(r)
+ regex_simple_print(r)
print("*")
}
case _ => {
print("[")
- happy_print(r)
+ regex_simple_print(r)
print("]*")
}
}
@@ -470,42 +168,30 @@
print(c)
}
}
- def bits_slide(s: String, r: Rexp){
- val nangao = ders_simp(internalise(r), s.toList)
- val easy = bsimp(bders(s.toList, internalise(r)))
- println(s)
- println(r)
- happy_print(r)
- println()
- print(bits_print(nangao))
- println()
- print(bits_print(easy))
- println()
- }
//found r = SEQ(ALTS(List(CHAR(c), CHAR(a))),SEQ(ALTS(List(CHAR(a), CHAR(c))),ALTS(List(CHAR(b), CHAR(c))))) s = "aa"
def bsimp_print(r: ARexp): Unit = r match {
case ASEQ(bs, r1, r2) =>
{
println("0.r or r.0 to 0 or bs1 1.r to fuse bs++bs1 r")
- bits_print(bsimp(r1))
- bits_print(bsimp(r2))
+ aregex_simple_print(bsimp(r1))
+ aregex_simple_print(bsimp(r2))
}
case AALTS(bs, rs) => {
println("rs.map(bsimp) equals *************")
val rs_simp = rs.map(bsimp)
for(r <- rs_simp){
- println(bits_print(r))
+ println(aregex_simple_print(r))
}
println("*************")
println("flts(rs_simp)")
val flat_res = flats(rs_simp)
for(r <- flat_res){
- println(bits_print(r))
+ println(aregex_simple_print(r))
}
println("dB(flat_res)")
val dist_res = distinctBy(flat_res, erase)
for(r <- dist_res){
- println(bits_print(r))
+ println(aregex_simple_print(r))
}
dist_res match {
case Nil => println("AZERO")
@@ -515,99 +201,16 @@
}
case _ => println("No simp at this level")
}
- def tellmewhy(){
- //val r = SEQ(ALTS(List(CHAR('a'), CHAR('b'))),ALTS(List(ALTS(List(CHAR('a'), CHAR('a'))), STAR(CHAR('a')))))
- //val r = SEQ(ALTS(List(CHAR('a'), CHAR('b'))),ALTS(List(CHAR('a'), STAR(CHAR('a')) ) ))
- val r = ("ab" | ( (("a")%) | "aa") )
- //val r = ("a"|"b")~("a")
- val s = "aa"
- for(i <- 0 to s.length-1){
- val ss = s.slice(0, i+1)
- val nangao = bders_simp_rf(ss.toList, internalise(r))
- val easy = (bders(ss.toList, internalise(r)))
- println("iteration starts")
- println("bders_simp")
- println(bits_print(nangao))
- println()
- println("bders")
- println(bits_print(easy))
- println()
- println("new simp")
- println(bits_print(bsimp_rf(easy)))
- println("iteration ends")
- }
- println("old simp ders")
- println(bits_print(bsimp(bders(s.toList, internalise(r)))))
- println("old derssimp")
- println(bits_print(ders_simp(internalise(r), s.toList)))
- }
- def find_re(){
- for (i <- 1 to 10000){
- val r = balanced_struct_gen(3)
- val s = rd_string_gen(2,1)
- val nangao = ders_simp(internalise(r), s.toList)
- val easy = bsimp(bders(s.toList, internalise(r)))
- if(nangao != easy){
- bits_slide(s, r)
- }
- }
- }
+
+
//simplified regex size 291, so called pd_simp size 70 (did not do simplification to terms in the PD set)
def pushbits(r: ARexp): ARexp = r match {
case AALTS(bs, rs) => AALTS(Nil, rs.map(r=>fuse(bs, pushbits(r))))
case ASEQ(bs, r1, r2) => ASEQ(bs, pushbits(r1), pushbits(r2))
case r => r
}
- def correctness_proof_convenient_path(){
- for(i <- 1 to 19999){
- val s = rd_string_gen(alphabet_size, 3)//"abaa"//rd_string_gen(alphabet_size, 3)
- val r = internalise(random_struct_gen(4))//ASTAR(List(),AALTS(List(),List(ASTAR(List(Z),ACHAR(List(),'a')), ASEQ(List(S),ACHAR(List(),'a'),ACHAR(List(),'b')))))//internalise(balanced_struct_gen(3))//SEQ(ALTS(List(STAR("a"),ALTS(List("a","c")))),SEQ(ALTS(List("c","a")),ALTS(List("c","b")))) //random_struct_gen(7)
- for(j <- 0 to s.length - 1){
- val ss = s.slice(0, j+ 1)
- val nangao = bders_simp_rf(ss.toList, r)
- val easy = bsimp_rf(bders_rf(ss.toList, r))
- if(!(nangao == easy)){
- println(j)
- println("not equal")
- println("string")
- println(ss)
- println("original regex")
- println(annotated_tree(r))
- println("regex after ders simp")
- println(annotated_tree(nangao))
- println("regex after ders")
- println(annotated_tree(bders(ss.toList, r)))//flats' fuse when opening up AALTS causes the difference
- println("regex after ders and then a single simp")
- println(annotated_tree(easy))
- }
- }
- }
- }
- /* if(bts == cdbts){//test of equality code v = retrieve internalise(r) v if |- v : r
- println(bts)
- println(cdbts)
- println("code v = retrieve internalise(r) v if |- v : r")
- }
- val r_der_s = bders(st.toList, rg)
- println(aregx_tree(r_der_s))
- val bts = retrieve(r_der_s, unsimplified_vl)
- val cdbts = code(unsimplified_vl)
- val simprg = bsimp(r_der_s)
- val frectv = decode(erase(simprg), cdbts)
- val simpbts = retrieve(simprg, frectv)
- if(bts == simpbts){
- println("retrieve r v = retrieve (bsimp r) (decode bsimp(r) code(v))")
- println("bits:")
- //println(bts)
- println(simpbts)
- println("v = ")
- println(unsimplified_vl)
- println("frect v = ")
- println(frectv)
- }
- *///KH8W5BXL
def nice_lex(r: Rexp, s: List[Char], ar: ARexp) : Val = s match {
case Nil =>
if (nullable(r)){
@@ -688,17 +291,6 @@
println(s"bsimp(bder c r) = ${unsimp}, whereas bsimp(bder c bsimp r) = ${simped}")
}
}
- def essence_posix(){
- //val s = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"//rd_string_gen(alphabet_size, 3)//"abaa"//rd_string_gen(alphabet_size, 3)
- val s0 = "a"
- val r = SEQ(STAR(ALT("a", "aa")), "b")//internalise(random_struct_gen(4))//ASTAR(List(),AALTS(List(),List(ASTAR(List(Z),ACHAR(List(),'a')), ASEQ(List(S),ACHAR(List(),'a'),ACHAR(List(),'b')))))//internalise(balanced_struct_gen(3))//SEQ(ALTS(List(STAR("a"),ALTS(List("a","c")))),SEQ(ALTS(List("c","a")),ALTS(List("c","b")))) //random_struct_gen(7)
- for(i <- 1 to 40){
- val s = s0*i
- //printf("%d %d\n",i, size(ders(s.toList, r)))
- printf("%d %d\n",i, asize(ders_simp( internalise(r), s.toList)))
- //println(asize(ders_simp( internalise(r), s.toList)))
- }
- }
def speed_test(){
val s0 = "a"*1000
@@ -825,11 +417,11 @@
val v1 = inj(erase(r), c, v0)
val v2 = fuzzy_inj(r, c, v)
println("regular expression original")
- println(bits_print(r))
+ println(aregex_simple_print(r))
println("regular expression derivative")
- println(bits_print(dr))
+ println(aregex_simple_print(dr))
println("regular expression simped derivative")
- println(bits_print(sdr))
+ println(aregex_simple_print(sdr))
println("simplified value")
println(v)
println("unsimplified value")
@@ -842,36 +434,32 @@
println("fuzzy_inj "+r+c+v)
}
def vunsimp_test(){
- for(i <- 1 to 1000){
- val r = random_struct_gen(5)//[{ a}*~{{a}*}*]
- val c = (ran.nextInt(3) + 97).toChar//Sequ(Stars(List()),Stars(List()))
- val dr = der(c, r)
- val bdr = bder(c, internalise(r))
- if(nullable(dr)){
- println("bohooooooooooooooooo!")
- val dv = mkeps(dr)
- val target_vr = bsimp2(bdr, dv)
- println(bits_print(target_vr._1))
- println(target_vr._2)
- println(vunsimp(bdr, dv)(target_vr._2))
- }
- }
+ /*val bdr = AALTS(
+ List(),
+ List(
+ AONE(List(S,Z)),
+ ASTAR(List(Z,Z,S), ACHAR(List(),'c')),
+ ASEQ(List(Z), ASTAR(List(S), ACHAR(List(), 'c')), ASTAR(List(S), ACHAR(List(), 'c') ) )
+ )
+ )*/
+ val bdr = AALTS(List(),List(AALTS(List(Z),List(ASEQ(List(),
+ ASEQ(List(),AONE(List(S)),ASTAR(List(),ACHAR(List(),'c'))),ASTAR(List(),ACHAR(List(),'c'))),
+ ASEQ(List(Z),AONE(List(S)),ASTAR(List(),ACHAR(List(),'c'))))), AALTS(List(S),List(AONE(List(Z)), AZERO))))
+ val dr = erase(bdr)
+ val dv = mkeps(dr)
+ //val bdr = bder(c, internalise(r))
+ //val dv = mkeps(dr)
+ println(aregex_simple_print(bdr))
+ println(dv)
+ val target_vr = bsimp2(bdr, dv)
+ println(aregex_simple_print(target_vr._1))
+ println(target_vr._2)
+ println(vunsimp(bdr, dv)(target_vr._2))
}
+
+
def main(args: Array[String]) {
- //finj_test0('b', fuse(List(S, Z), internalise( ( ("a"|"b")% ) ) ))
- //finj_test0('a', fuse(List(S, Z), internalise( ( ("a"|"b")% ) ) ))
- //finj_test0('b', bder('a', internalise( (("c" | "ab")%) )))
- //finj_test0('a', internalise( (("c" | "ab")%) ))
- //this example gives us an exception
- //val r = internalise(ALTS(List(STAR(CHAR('c')), STAR(CHAR('b')))))
- //val c = 'c'
- //if(bder(c, r) != internalise(der(c, erase(r))))
- //println("noooooo!")
- //println(bits_print(r))
- //println(c)
- //finj_test0(c, r)
vunsimp_test()
}
}
-//List( ASTAR(List(Z),ACHAR(List(),a)), AALTS(List(S),List(ACHAR(List(Z),b), ACHAR(List(S),a))) )