From 7586eace19c4e4c1e2a68fee5698f68442b9ace4 Mon Sep 17 00:00:00 2001 From: Thomas Walker Lynch Date: Fri, 10 Jan 2025 11:11:05 +0000 Subject: [PATCH] most examples running, working on simplifying diagonalization --- .../CountingNumber/CountingNumber.java | 101 +++++++-------- developer/example/CountingNumber/temp.java | 44 +++++++ developer/example/IndexTree/Example_4x4 | 2 + developer/example/IndexTree/Example_4x4.class | Bin 0 -> 1817 bytes developer/example/IndexTree/Example_4x4.java | 41 ++++++ .../IndexTree/Example_IndexTree_4x4.java | 46 ------- .../example/IndexTree/Example_SRTM_Diagonal | 2 + .../IndexTree/Example_SRTM_Diagonal.class | Bin 0 -> 1799 bytes ...al_SRM.java => Example_SRTM_Diagonal.java} | 6 +- developer/example/IndexTree/Graph.class | Bin 0 -> 808 bytes developer/example/IndexTree/Graph.java | 22 ++++ .../example/IndexTree/IndexTree_Graph.java | 21 ---- .../example/IndexTree/IndexTree_Node.java | 23 ---- .../IndexTree/IndexTree_SRTM_Diagonal.java | 118 ------------------ developer/example/IndexTree/Label.class | Bin 0 -> 2227 bytes .../{IndexTree_Label.java => Label.java} | 24 ++-- developer/example/IndexTree/Node.class | Bin 0 -> 856 bytes developer/example/IndexTree/Node.java | 22 ++++ .../example/IndexTree/SRTM_Child$1.class | Bin 0 -> 1317 bytes .../example/IndexTree/SRTM_Child$2.class | Bin 0 -> 1256 bytes .../example/IndexTree/SRTM_Child$3.class | Bin 0 -> 1339 bytes developer/example/IndexTree/SRTM_Child.class | Bin 0 -> 1549 bytes ...exTree_SRTM_Child.java => SRTM_Child.java} | 32 +++-- .../example/IndexTree/SRTM_Diagonal.java | 114 +++++++++++++++++ .../example/SRTM/Example_SRTMI_Array.java | 2 +- developer/example/SRTM/Example_SRTM_List.java | 2 +- .../javac\360\237\226\211/Ariadne_Graph.java" | 16 ++- .../javac\360\237\226\211/Ariadne_SRTM.java" | 5 +- .../Ariadne_SRTM_Label.java" | 5 + .../Ariadne_SRTM_List.java" | 3 +- 30 files changed, 359 insertions(+), 292 deletions(-) create mode 100644 developer/example/CountingNumber/temp.java create mode 100755 developer/example/IndexTree/Example_4x4 create mode 100644 developer/example/IndexTree/Example_4x4.class create mode 100644 developer/example/IndexTree/Example_4x4.java delete mode 100644 developer/example/IndexTree/Example_IndexTree_4x4.java create mode 100755 developer/example/IndexTree/Example_SRTM_Diagonal create mode 100644 developer/example/IndexTree/Example_SRTM_Diagonal.class rename developer/example/IndexTree/{Example_IndexTree_Diagonal_SRM.java => Example_SRTM_Diagonal.java} (90%) create mode 100644 developer/example/IndexTree/Graph.class create mode 100644 developer/example/IndexTree/Graph.java delete mode 100644 developer/example/IndexTree/IndexTree_Graph.java delete mode 100644 developer/example/IndexTree/IndexTree_Node.java delete mode 100644 developer/example/IndexTree/IndexTree_SRTM_Diagonal.java create mode 100644 developer/example/IndexTree/Label.class rename developer/example/IndexTree/{IndexTree_Label.java => Label.java} (75%) create mode 100644 developer/example/IndexTree/Node.class create mode 100644 developer/example/IndexTree/Node.java create mode 100644 developer/example/IndexTree/SRTM_Child$1.class create mode 100644 developer/example/IndexTree/SRTM_Child$2.class create mode 100644 developer/example/IndexTree/SRTM_Child$3.class create mode 100644 developer/example/IndexTree/SRTM_Child.class rename developer/example/IndexTree/{IndexTree_SRTM_Child.java => SRTM_Child.java} (71%) create mode 100644 developer/example/IndexTree/SRTM_Diagonal.java diff --git a/developer/example/CountingNumber/CountingNumber.java b/developer/example/CountingNumber/CountingNumber.java index 3255c30..e5e2184 100644 --- a/developer/example/CountingNumber/CountingNumber.java +++ b/developer/example/CountingNumber/CountingNumber.java @@ -1,7 +1,10 @@ import com.ReasoningTechnology.Ariadne.Ariadne_SRTM; import java.math.BigInteger; -public class CountingNumber extends Ariadne_SRTM{ +public class CountingNumber extends Ariadne_SRTM{ + + // Static + // public static CountingNumber make(BigInteger maximum){ return new CountingNumber(maximum); @@ -11,18 +14,24 @@ public class CountingNumber extends Ariadne_SRTM{ return new CountingNumber(); } + // Instance data + // + private BigInteger i; private BigInteger maximum; - private final TopoIface state_null = new ASRTM_Null(); - private final TopoIface state_segment = new ASRTM_Segment(); - private final TopoIface state_rightmost = new ASRTM_Rightmost(); - private final TopoIface state_infinite = new ASRTM_Infinite(); + private final TopoIface topo_null = new Topo_Null(); + private final TopoIface topo_segment = new Topo_Segment(); + private final TopoIface topo_rightmost = new Topo_Rightmost(); + private final TopoIface topo_infinite = new Topo_Infinite(); + + // Constructor(s) + // public CountingNumber(){ this.i = BigInteger.ONE; this.maximum = maximum; - set_topology(state_infinite); + set_topology(topo_infinite); } public CountingNumber(BigInteger maximum){ @@ -30,110 +39,92 @@ public class CountingNumber extends Ariadne_SRTM{ this.maximum = maximum; if( maximum.compareTo(BigInteger.ZERO) <= 0 ){ - set_topology( state_null ); + set_topology( topo_null ); return; } if( maximum.equals(BigInteger.ONE) ){ - set_topology(state_rightmost); + set_topology(topo_rightmost); return; } - set_topology(state_segment); + set_topology(topo_segment); } + // Instance interface implementation + // - private class ASRTM_Null implements TopoIface{ - @Override - public boolean can_read(){ + private class Topo_Null implements TopoIface{ + @Override public boolean can_read(){ return false; } - @Override - public BigInteger read(){ + @Override public BigInteger read(){ return i; } - @Override - public boolean can_step(){ + @Override public boolean can_step(){ return false; } - @Override - public void step(){ - throw new UnsupportedOperationException( "Cannot step from NULL state." ); + @Override public void step(){ + throw new UnsupportedOperationException( "Cannot step over NULL topology." ); } - @Override - public Topology topology(){ + @Override public Topology topology(){ return Topology.NULL; } } - private class ASRTM_Segment implements TopoIface{ - @Override - public boolean can_read(){ + private class Topo_Segment implements TopoIface{ + @Override public boolean can_read(){ return true; } - @Override - public BigInteger read(){ + @Override public BigInteger read(){ return i; } - @Override - public boolean can_step(){ + @Override public boolean can_step(){ return true; } - @Override - public void step(){ + @Override public void step(){ i = i.add( BigInteger.ONE ); if( i.equals( maximum ) ){ - set_topology( state_rightmost ); + set_topology( topo_rightmost ); } } - @Override - public Topology topology(){ + @Override public Topology topology(){ return Topology.SEGMENT; } } - private class ASRTM_Rightmost implements TopoIface{ - @Override - public boolean can_read(){ + private class Topo_Rightmost implements TopoIface{ + @Override public boolean can_read(){ return true; } - @Override - public BigInteger read(){ + @Override public BigInteger read(){ return i; } - @Override - public boolean can_step(){ + @Override public boolean can_step(){ return false; } - @Override - public void step(){ + @Override public void step(){ throw new UnsupportedOperationException( "Cannot step from RIGHTMOST." ); } - @Override - public Topology topology(){ + @Override public Topology topology(){ return Topology.RIGHTMOST; } } - private class ASRTM_Infinite implements TopoIface{ - @Override - public boolean can_read(){ + private class Topo_Infinite implements TopoIface{ + @Override public boolean can_read(){ return true; } - @Override - public BigInteger read(){ + @Override public BigInteger read(){ return i; } - @Override - public boolean can_step(){ + @Override public boolean can_step(){ return true; } - @Override - public void step(){ + @Override public void step(){ i = i.add( BigInteger.ONE ); } - @Override - public Topology topology(){ + @Override public Topology topology(){ return Topology.INFINITE; } } diff --git a/developer/example/CountingNumber/temp.java b/developer/example/CountingNumber/temp.java new file mode 100644 index 0000000..db47630 --- /dev/null +++ b/developer/example/CountingNumber/temp.java @@ -0,0 +1,44 @@ + // Implementation of instance interface. + // + + @Override public List read(){ + return diagonal; + } + + @Override public void step(){ + diagonal.clear(); + + // Process unopened nodes + while( !list_of__unopened_node.isEmpty() ){ + BigInteger[] label = list_of__unopened_node.remove(0); + + // Retrieve the node using lookup + Ariadne_Node node = lookup(label); + + // Descend by getting neighbors + List child_labels = fetch_child_labels(node); + if( !child_labels.isEmpty() ){ + list_of__opened_incomplete_child_list.add(child_labels); + } + } + + // Process incomplete child lists + while( !list_of__opened_incomplete_child_list.isEmpty() ){ + List child_labels = list_of__opened_incomplete_child_list.remove(0); + if( !child_labels.isEmpty() ){ + BigInteger[] label = child_labels.remove(0); + diagonal.add(label); + + // Retrieve node and check its neighbors + Ariadne_Node node = lookup(label); + if( !fetch_child_labels(node).isEmpty() ){ + list_of__unopened_node.add(label); + } + } + } + } + + private Ariadne_Node lookup(BigInteger[] label){ + // Perform a lookup to retrieve the node corresponding to the label + return Ariadne_Node.make(label); + } diff --git a/developer/example/IndexTree/Example_4x4 b/developer/example/IndexTree/Example_4x4 new file mode 100755 index 0000000..263380a --- /dev/null +++ b/developer/example/IndexTree/Example_4x4 @@ -0,0 +1,2 @@ +#!/bin/bash +java Example_4x4 diff --git a/developer/example/IndexTree/Example_4x4.class b/developer/example/IndexTree/Example_4x4.class new file mode 100644 index 0000000000000000000000000000000000000000..0b68688dbcc3b069e07ab54b90d8683a8a17b317 GIT binary patch literal 1817 zcmaJ>-%}e^6#gzGyCGc)gkPntEk&qFp^YMt*&4uViNi1PLr zG-^hPY%hP$x81N5`qF9?QaCAa;?6Ux(RAeY!n1`m1~H@~V_+B~0>fQ`1oWm#;keA2 zjnhW_nA3J^h1^yeV;I+Q%D@Cp3ncIQRapf8&`>ze1$yB{>8+Zrv z9HQfSyL(N6fvg#`&zb99RkDZ$yr*N)!27B%31t*WxzeuH%buUcRV?W!7`TQH*|sQ_ z{?Loh6&PU$k3`dAlYzjTYUW1 z=~XOe%kpitZy6I|-DcVSW}9*fOwzDyiefDLsFOf$i+;JVto0ZgJmFO*T2pH`` zAiz;W<_uf?Vm>z_t;LO_5-LhF+ksEj3!A@Hax8^bWp~YLM$~nfN<`kCUy;kUs&BBZ zge$6TG~M#NFbGL!O@?)^8l>=;!i)q;flpfD(xgaXo3pzugNk&kvN{=hk&)rX&5G{@ zL2Mb&P)VZ-spF}VQB7d_XgIdJ@9oNbJfm1y%T^`y`~!iX+XdPJ#(Y*Rx9Z4X+Kd!b z=c~ohmvzPR$W*6MaK#P8R*y%nCYmg8&w?~-?{&X z^2>8oBRqRc;`GWv)gHz+J3x*N0VnObdg> zH%z9}_S0|BGyR7cc)^=-_7G>*<_>XwomTaJfti<>1?W#KYO|LQkzYzoBo6WJQgR~M z0@C`yOI(joqnh>$wCCviUK7t>{ly>!yYU+KRu}Bws)Amq3bruHHN}TlIiDf)^THTH z79%7xhIx$h<3EKPyjIt78V_&=U*Ier<2;_QT@q8+I9~rGWvJzK~ zPhfIq;9IOQhhX*t-oG2{${0f2!>8mjkB7LA5_@@-`%QY2JbxRXk)g&@fkkMqXwr2& z)G?-GQYTdPyu+$vfo^(|JyS{M{+!W0Wc`Tm5$?;3`Z8L-iq child_srm; - - // Descend 3 more levels - int i = 1; - do{ - node = graph.lookup(label); - child_srm = node.neighbor(); - label = child_srm.read(); - System.out.println("Descend: " + label.toString()); - if(i == 3) break; - i++; - }while(true); - - // Move across three more nodes - i = 1; - do{ - child_srm.step(); - label = child_srm.read(); - System.out.println("Across: " + label.toString()); - if(i == 3) break; - i++; - }while(true); - - } -} diff --git a/developer/example/IndexTree/Example_SRTM_Diagonal b/developer/example/IndexTree/Example_SRTM_Diagonal new file mode 100755 index 0000000..b170dce --- /dev/null +++ b/developer/example/IndexTree/Example_SRTM_Diagonal @@ -0,0 +1,2 @@ +#!/bin/bash +java Example_SRTM_Diagonal diff --git a/developer/example/IndexTree/Example_SRTM_Diagonal.class b/developer/example/IndexTree/Example_SRTM_Diagonal.class new file mode 100644 index 0000000000000000000000000000000000000000..8eb90330a048fc70d7c58ebcd3428a8f8e18613a GIT binary patch literal 1799 zcmaJ>ZBrXn6n-uV*$|dM0|miYB81npL~DH`ZB=No(a_cg!HP&P$u(@*>}EEbPWkSS zaQxsn{leGQai~*g_yPV0Klv}5sr9+p)B?#!hI{v%dtRRNoOACV|2#VaunZYP7eWTY zCb|(37`QJV$gC}$O7_;yeO2-WB9|@4@~;YnX6M#>5JiuHn2BDPC(MicbzfC!Sa zw$Kb@x!K#E<@iP4Q?iFh%Ie{or&OwVXKgig{h_SZY!$-*&KO9T z7{rjkV23~gMoovc9cG#hQZ+F%4+H1s)?*mPh=JEkjABfnPbb*EX32`{NLwIWm3vCy z%Qq^uG)NCz}T&K2|sl{iuZ|dOGhNGMV8;{ z)bryT`)f)u`DOGevjdr3dB7TtzdQY)6`aI7Ou3%c>V zhfA*O*L_dcR+Yc&mg`Zh@sbo-Yf3EkN5BiQfv*hQ)wBJzK>F3dSk41?Pi2E?3dVg! zmVDRS7x>}$z_bj53^$}xwpBe{aNWH|E!S4Xam@+Gwf&kpei-DcZmMq_+EytP)dgH zJ;Un&b;-!jh#a8r`!10=#Q4FBzjT^VGtD%^>5x$-F%jo)07<@dX^dfp{uxROY_x`v z3Q}Q-ue}B}iEFq{AaT~Vf=>zj2KBuNJxAQYusGX;81ne6h4t4K)|L6A9}!7RJpLW& zyNT(im?h%m{Lv#!X6BO@4>5m;w>GE}>;OtFAV{9eQ~xtjS8{t)HQn@~Z>1+3CDLCc%CMU)zT9O3A5^cqNu@xR%o e5N=c3g)eZ2dz4mR^1p~pN-=(YgKu#UqyGXOO1QBA literal 0 HcmV?d00001 diff --git a/developer/example/IndexTree/Example_IndexTree_Diagonal_SRM.java b/developer/example/IndexTree/Example_SRTM_Diagonal.java similarity index 90% rename from developer/example/IndexTree/Example_IndexTree_Diagonal_SRM.java rename to developer/example/IndexTree/Example_SRTM_Diagonal.java index 5e6bbf6..f7f15db 100644 --- a/developer/example/IndexTree/Example_IndexTree_Diagonal_SRM.java +++ b/developer/example/IndexTree/Example_SRTM_Diagonal.java @@ -1,13 +1,15 @@ + + import java.math.BigInteger; import java.util.Queue; -public class Example_IndexTree_Diagonal_SRTM { +public class Example_SRTM_Diagonal { public static void main(String[] args){ System.out.println("Starting IndexTree SRTM Example"); // Instantiate the IndexTree Diagonal SRTM - IndexTree_Diagonal_SRTM srm = IndexTree_Diagonal_SRTM.make(); + SRTM_Diagonal srm = SRTM_Diagonal.make(); int step_count = 0; do{ diff --git a/developer/example/IndexTree/Graph.class b/developer/example/IndexTree/Graph.class new file mode 100644 index 0000000000000000000000000000000000000000..79b4c847e2f8dd2eeced2df5caf31c1b738deef5 GIT binary patch literal 808 zcma))OK;Oa6ot;G!(>x~GSY(?E@M9L5*zpf`whq%XcSnn|eoad00y7B~mb#k_|FEV7HQ zxZSAh6k7Gv%(9`SmKL<&sXMcJZD~IRz=PfQThq-=?3|)Tnnm!BBS{h%!6C?A)~1} zdpB^uagj@x a node extending each child list discovered thus far. - -Hence, each diagonal extends the tree down one, and over one. - -*/ - -import java.math.BigInteger; -import java.util.ArrayList; -import java.util.List; -import com.ReasoningTechnology.Ariadne.Ariadne_Test; -import com.ReasoningTechnology.Ariadne.Ariadne_SRTM; -import com.ReasoningTechnology.Ariadne.Ariadne_IndexTree_Node; - -public class IndexTree_Diagonal_SRTM extends Ariadne_SRTM_Label>{ - - // Static - // - - public static IndexTree_Diagonal_SRTM make(){ - return new IndexTree_Diagonal_SRTM(); - } - - //Instance data - // - - private final List list_of__unopened_node; - // each node has a child list, this is a list of child lists - private final List list_of__opened_incomplete_child_list; - // Each diagonal is a list of nodes, referenced by their label - private final List read_list; - - // Constructor(s) - // - - protected IndexTree_Diagonal_SRTM(){ - list_of__unopened_node = new ArrayList<>(); - list_of__opened_incomplete_child_list = new ArrayList<>(); - read_list = new ArrayList<>(); - enqueue_root(); - } - - // Implementation of instance interface. - // - - private void enqueue_root(){ - Ariadne_IndexTree_Label root_label = Ariadne_IndexTree_Label.root(); - read_list.add(root_label); - - Ariadne_IndexTree_Node root_node = lookup(root_label); - if( !fetch_child_labels(root_node).isEmpty() ){ - list_of__unopened_node.add(root_label); - } - } - - // lol! This can not be done on an infinite list! - private List fetch_child_labels(Ariadne_IndexTree_Node node){ - List child_labels = new ArrayList<>(); - if(node != null){ - IndexTree_Diagonal_SRTM child_srm = node.neighbor(); - if( child_srm.can_read() ){ - do{ - child_labels.add(child_srm.read()); - if( !srm.can_step ) break; - child_srm.step(); - }while(true); - } - } - return child_labels; - } - - @Override public List read(){ - return read_list; - } - - @Override public void step(){ - read_list.clear(); - - // Process unopened nodes - while( !list_of__unopened_node.isEmpty() ){ - BigInteger[] label = list_of__unopened_node.remove(0); - - // Retrieve the node using lookup - Ariadne_IndexTree_Node node = lookup(label); - - // Descend by getting neighbors - List child_labels = fetch_child_labels(node); - if( !child_labels.isEmpty() ){ - list_of__opened_incomplete_child_list.add(child_labels); - } - } - - // Process incomplete child lists - while( !list_of__opened_incomplete_child_list.isEmpty() ){ - List child_labels = list_of__opened_incomplete_child_list.remove(0); - if( !child_labels.isEmpty() ){ - BigInteger[] label = child_labels.remove(0); - read_list.add(label); - - // Retrieve node and check its neighbors - Ariadne_IndexTree_Node node = lookup(label); - if( !fetch_child_labels(node).isEmpty() ){ - list_of__unopened_node.add(label); - } - } - } - } - - private Ariadne_IndexTree_Node lookup(BigInteger[] label){ - // Perform a lookup to retrieve the node corresponding to the label - return Ariadne_IndexTree_Node.make(label); - } - -} diff --git a/developer/example/IndexTree/Label.class b/developer/example/IndexTree/Label.class new file mode 100644 index 0000000000000000000000000000000000000000..501d30121160f5c24fe1a88401238a8cd89d6785 GIT binary patch literal 2227 zcmb7FT~`}b6x}x;Q5L&vmX8P0Wv{*ily`}`r#*0{5koj0m^%h9WPBbO>i5M}6X_hlS$bVi^E zumnTWjWM}Z%@#NB>zcz597&bq=teSvQwn-;n&HfU5Rp91v@M;uMpB*@A5<GzO@^prmz;)SRT+j4&gaMU(|Cco2rf|Y z(LwH7%~ri`HypiEtm_T#7`CQ<1q1SZFQMuNzn@yEls$Q!* z+bS1w#^M;jd!kZ9bdV9>0VQ*)976=}EBFAzRJh{uB12#Mp2R6Ir67$A1@cOTVN3$P z)xGurQCw!YAcgaKUAHQ#W2;=XTBdoZ_bjpsKEycLM6>JL#qSwX?aG)>$(H(SD-Lr- z!AIgSq4mX;qA<%<1s`LI8dKGs1(P?aN2iZ9+uh8G&VH&OhiRhLe`s-&0^3rzAx^D} z^y>;{FiT8Zyt%btSIAaYx0DIPdQddj*BhNUmJYMXjvm2aAq+f%SL zZk9O_(7W6WyGEj{hHcYqg`6#e>JpJsX=OAQh2h+>TW3g=9IicB;&qvSe6FPJ7~29eMcgn~P? z5%h@}_8ll8;Z`Unj6mnC$Ulz~eTw2t&{N<=1>PRcoUBd82Nji2Obmz2zbcFC)<$5o zsc+VYp&VkYA|WvzlQ5xSO60#rr+DoDjKm8Jto2-chQYtYj=LMG_?8n-acLJLB~exH z_&rol&>ho_Nt~mrg)SE#_mr;`Aq2X`PsrUv6+aP%=-Gr|cq7?IkF$TbhcW78A(Pn; zRi0v^l+MVmdi?$50AQM~x@+X384O_-qnN`u=3O0LhbN?tA<|i!9A(vgiWpqD*p%-ePxz5NzRc?zLxn} YdWsf@=>T&lJr?&RhY$VnjZ5+EzukboWB>pF literal 0 HcmV?d00001 diff --git a/developer/example/IndexTree/IndexTree_Label.java b/developer/example/IndexTree/Label.java similarity index 75% rename from developer/example/IndexTree/IndexTree_Label.java rename to developer/example/IndexTree/Label.java index d416e71..e94a16f 100644 --- a/developer/example/IndexTree/IndexTree_Label.java +++ b/developer/example/IndexTree/Label.java @@ -1,23 +1,23 @@ /* Implementation of Ariadne_Label for BigInteger array-based labels. */ - -package com.ReasoningTechnology.Ariadne; - import java.math.BigInteger; import java.util.Arrays; -public class IndexTree_Label implements Ariadne_Label{ +import com.ReasoningTechnology.Ariadne.Ariadne_Label; + + +public class Label implements Ariadne_Label{ // Owned by class // - public static IndexTree_Label make(BigInteger[] array){ - return new IndexTree_Label(array); + public static Label make(BigInteger[] array){ + return new Label(array); } - public static IndexTree_Label root(){ - return new IndexTree_Label(new BigInteger[0]); + public static Label root(){ + return new Label(new BigInteger[0]); } // Instance data @@ -28,7 +28,7 @@ public class IndexTree_Label implements Ariadne_Label{ // Constructor // - private IndexTree_Label(BigInteger[] array){ + private Label(BigInteger[] array){ this.value = array.clone(); } @@ -43,8 +43,8 @@ public class IndexTree_Label implements Ariadne_Label{ return Arrays.toString(value); } - @Override public IndexTree_Label copy(){ - return new IndexTree_Label(value); + @Override public Label copy(){ + return new Label(value); } // Increment last element by one, modifying in place @@ -71,7 +71,7 @@ public class IndexTree_Label implements Ariadne_Label{ @Override public boolean equals(Object o){ if(this == o) return true; if( o == null || getClass() != o.getClass() ) return false; - IndexTree_Label that = (IndexTree_Label) o; + Label that = (Label) o; return Arrays.equals(value, that.value); } diff --git a/developer/example/IndexTree/Node.class b/developer/example/IndexTree/Node.class new file mode 100644 index 0000000000000000000000000000000000000000..cd5ec53d6d1694fe42bf2634a4f48d17be078f1b GIT binary patch literal 856 zcma)5%Wl(96r7vH@dGzWQ&QfK@^l<%q$05iLaHLMGF_BViIwFzCb{6)$Vox{E07>X zAn^fw6k@JpNYqs~_jS&hnKQ@!{pZIo0DbK0C<#;!(otlA2OAoy0@Y_Sk@M#Qmg9NB zFp7KaBMSyh9hOSDAn+(mr`^LSn5BtK#)BxFBx#(EPrCb=3`R-xZ}%0pz@Fosw_ruM zftrrGjRrOawEUeK!}P<6fa$agX(okl*|><7z~)<-&E|eMk@3inm2v^S$g{A4OExa! zihv=L&>y9r5`nU#db@_}I&RpwiCgUY)#2c!-&Y{yn+EUMKm>y?g^g=31Q=#p?3qA(eVM7K#4eC&i@>GFISMKrUK5tJ@ z<_R!=LcDQLQU1(J2@kkd^MHz=)+8@DFby@Xb!utkz}w4WwBa&Nn4Ch8jx*q@DE7E3jfO(~j;m)SZmmf)mPn0# c)_02fZc(qf3*0_iTv;pD3K{$xNLRw+zb%}g!~g&Q literal 0 HcmV?d00001 diff --git a/developer/example/IndexTree/Node.java b/developer/example/IndexTree/Node.java new file mode 100644 index 0000000..2cf225c --- /dev/null +++ b/developer/example/IndexTree/Node.java @@ -0,0 +1,22 @@ +import java.util.Arrays; +import com.ReasoningTechnology.Ariadne.Ariadne_Node; + +public class Node extends Ariadne_Node{ + + public static Node make(Label label){ + return new Node(label); + } + + private final Label first_child_label; + + public Node(Label label){ + super(label); + first_child_label = label.copy(); + first_child_label.inc_down(); + } + + @Override public SRTM_Child neighbor(){ + return SRTM_Child.make(first_child_label); + } + +} diff --git a/developer/example/IndexTree/SRTM_Child$1.class b/developer/example/IndexTree/SRTM_Child$1.class new file mode 100644 index 0000000000000000000000000000000000000000..1a8f77267393ba677bed25c8865bff46d81db1d9 GIT binary patch literal 1317 zcmbVLTTc@~6#k~SEp?>@K>;rmtFCgo^pCq;afl zY~Y%S5sWe{+Nx9E65LmkNSeZK%P?I1h3D{=6sP;%_EvMf)a)n2kkZL9JhA=@zhdA9 zgQ+?98g0jImF5kMGb~-2ZS8>Df+1hFA~L!PO0c0?+F?0TY#ev?h1cZ!E?I^xWpj6z zQ+=fOjj5pR_zZ(FmeTwR^;FwSbChe$L-xYD2->RkntQw>0^t!hYje4$n->niTgsrP zjFc;}X7z@J7{cSaNp!HcWlvkpuuPasUxl6$BF=5AW6u^Z9bIfbx|N!q7_zKN+f_a_ zyH|pNy2hM!f->6>e(*~9G}7jpl)`Jc-1miV;4wq>GHDT4G%*8O4BLewuG4E`7^A0^ zp+AiY(r=QqOxA?9%$$IIAt8ZVv}VW*OyV}J8mb|8NY`JQ=%&bjSIczlV}X==DAB4J ztF&uyBKb+LF}kUc&g^;nbPV_LppRTYGW6xX!+0}1aDpp8&oPu@47oFg>3@hl9YZG0 zkmayYo%P?b2QP>{6Jv;CS1{AhzDB#QJM|TX&*$=67g}nV Yr+tEMV+fD1@O+$F(EG+nU(A?)0B@5RApigX literal 0 HcmV?d00001 diff --git a/developer/example/IndexTree/SRTM_Child$2.class b/developer/example/IndexTree/SRTM_Child$2.class new file mode 100644 index 0000000000000000000000000000000000000000..7f0bdcba9c0dd812efc122b98451a83a4bc479a0 GIT binary patch literal 1256 zcmbVMO>fgc5Ph3Ev6Gl4lu~H}h0}W{v868>Z4EbaJj#q5%993R*kA)c!Zp(74V4Gp8SUOB& z8aWkt9TzdfkQp;EByHXmHiK#yQX%SDTvjos?KWG@_71~_@n0O9 zDsC~<&W&xp<)&cB72`)*I%H59ZcjQ4%Mq>9L05Qf-nGdxW4I=_4>@&2`^c!s(J)NM zSPIomn#P_8`fl$v_xL~r!lM|?n4P_c`W{V|ba(2WJhWmjyp}?Wgg3-Cv z33Kk2!Vg}$KHVt2={Uk`*xdJp zuVS5H={#i+*Le16sfJ^~ZMyy%7;b{)^YRJMtB_wd^xPqBn<5eUnFz} zw-}Z$jNLlqhF}=Zgr&;vGbkmeE(2xL7CR@+nsBSUX3@$>*)h1a&uL3E?<^`(a)zN0 zOM0x`7Nx(X)z!k!8uGd|LF{$Mxv~y%7IHG)#V~B1epwrvY4jsd6 zfRMF;5Hiw5<{^8Ll^-G+bfx{k=$n!8GhF%A zS9>SKpmiAvnC~#;JH0DkG1cGqs}NS{U==(FDlA};tU@0s*@Zl>AuN%dqK>3E@;8lT OJbF4wQZ8dPrvC*ggBTkC literal 0 HcmV?d00001 diff --git a/developer/example/IndexTree/SRTM_Child.class b/developer/example/IndexTree/SRTM_Child.class new file mode 100644 index 0000000000000000000000000000000000000000..be56ddb78a4f52f694a72e51d062663fe00d43e5 GIT binary patch literal 1549 zcmbVMYflqF6g|_|(lSs$Q51Y3YN?M3C_d^7>kBQK03q>_G|Mu;>UNiO7ZZPq|3VYN zL=)pT6Muj|M?H7D3iwIwhu%9g_ug~wnKS$K`-e{eYN%UCDHP^r=VuzVRo7c8Kp~@% zMNT1i#r56j8qZ7hy1i(;>gYlN9mrcKNJyu`xDzxhv&Ies-}P7KjkD?pUa<12GSzbJ zCExtAjTj*=qL40)E?DSN&|A18V+CjwrEHHvu~gqWB5Iyp^=a(FZiRdltOX5!-SZSK z*8c^6WS*JR%eG^x7WV9fA1|OEMZwvpv0rd@#W=3NEF_pl%UxNGEDY^TnoKj2%`dqan!5p>^tjVk4;Amv+Uo{guk2#plL}sv`ejz2%rY zu0R&Igm*?_6*?c9Fq$#amOxDVzG>AwI}A-|;hw_e-|`}rw=`(sKCks(a;cZ!3dRxA z+rc-SL7%9GUZ1>=*iyf-r66gu$m0?&Grr2z1k&_?{70zA<@ZRx;Ua}A{LjS)Ib5Z$ z+d;S%m(IusAt~^UkSRtyW3pBL2rX5*H_%JJU;Mor7@$8W{(%h~ET7!Okqw+Ezr%?y z&}G`*O`Loy>rGT%x3><)TihEEhxOBOPm}1P-$~3v=%H4J_|Yn{yR+!V1r%|eyEi!a zeU3WICp?D%JjK3vhCS^*8FPa**l|3K!W8`;q<(NaWkFed2P994RFfIUX@#T?jxg~V z!+&x#w2h;VcKx0yc`r$RCCSg0H*w+5mNKXm{A literal 0 HcmV?d00001 diff --git a/developer/example/IndexTree/IndexTree_SRTM_Child.java b/developer/example/IndexTree/SRTM_Child.java similarity index 71% rename from developer/example/IndexTree/IndexTree_SRTM_Child.java rename to developer/example/IndexTree/SRTM_Child.java index a9fbffe..009cf45 100644 --- a/developer/example/IndexTree/IndexTree_SRTM_Child.java +++ b/developer/example/IndexTree/SRTM_Child.java @@ -1,15 +1,26 @@ -package com.ReasoningTechnology.Ariadne; +import com.ReasoningTechnology.Ariadne.Ariadne_SRTM_Label; -public class IndexTree_SRTM_Child extends Ariadne_SRTM_Label { +public class SRTM_Child extends Ariadne_SRTM_Label { - public static IndexTree_SRTM_Child make( IndexTree_Label first_child_label ){ - return new IndexTree_SRTM_Child( first_child_label ); + // Static + // + + public static SRTM_Child make( Label first_child_label ){ + return new SRTM_Child( first_child_label ); } - private final IndexTree_Label label; + // Instance data + // + + // Label is a container of co-ordinates to a node, so the only thing 'final' + // is the container, not its contents. + private final Label label; + + // Constructor(s) + // - protected IndexTree_SRTM_Child( IndexTree_Label first_child_label ){ - this.label = first_child_label.copy(); + protected SRTM_Child( Label leftmost_child_label ){ + this.label = leftmost_child_label.copy(); if( label == null ){ set_topology( topo_null ); @@ -24,6 +35,13 @@ public class IndexTree_SRTM_Child extends Ariadne_SRTM_Label { set_topology( topo_infinite_right ); } + // Implementation of the instance interface + // + + @Override public Label read(){ + return (Label)super.read(); + } + private final TopoIface topo_null = new TopoIface(){ @Override public boolean can_read(){ return false; diff --git a/developer/example/IndexTree/SRTM_Diagonal.java b/developer/example/IndexTree/SRTM_Diagonal.java new file mode 100644 index 0000000..490cbb4 --- /dev/null +++ b/developer/example/IndexTree/SRTM_Diagonal.java @@ -0,0 +1,114 @@ +/* +An Index Tree is infinite both in depth and breadth. As a tree is a +graph, and Index Tree is an infinite graph. The label for each node in +an index tree is an array of integers that explain how to traverse the +tree to arrive at the node. `[]` is the root node. `[[0] ,[1] ,[2] +...] is a list of the children to the root node, etc. + + All parts of a node can be computed from its label. Hence + the SRM_Diagonal only manipulates labels. + + Label::inc_down turns a given label into the leftmost + child lavel. + + Label::inc_across turns a child label into its right neighbor + sibling label. + + An infinite child list is represented by an SRM_Child. The + SRM_Child is made from the label for the leftmost child in the + list. From each child label it is possible to generate the label for + the right neighbor child. This is be done by calling `inc_across()`. + +Diagonalization can be used to traverse the infinite Index Tree, while +always enumerating a next layer of nodes nearest the root. This +differs from depth first, which would never return to visit the child +to the right of the leftmost child, and from breadth first, which +would never descend to the grandchildren level of the tree. + +How diagonalization works: + + The `diagonal` list is the read value. It is initialized to the + label for the root node, '[]'. + + Each time SRTM_Diagonal is stepped + + 1. For each given label on the diagonal, inc_down is called, thus + turning the label into the label for the leftmost child of the + given node's child list. + + 2.Each given SRTM_Child kept on the incomplete_list is `inc_across`ed. + This turns each label into the label for its right neighbor. + + The SRTM_Child.read() value is then appended to the `diagonal`. + +*/ + +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + +import com.ReasoningTechnology.Ariadne.Ariadne_Test; +import com.ReasoningTechnology.Ariadne.Ariadne_SRTM; +import com.ReasoningTechnology.Ariadne.Ariadne_SRTM_Label; +import com.ReasoningTechnology.Ariadne.Ariadne_Node; +import com.ReasoningTechnology.Ariadne.Ariadne_Label; + +public class SRTM_Diagonal extends Ariadne_SRTM_Label{ + + // Static + // + + public static SRTM_Diagonal make(){ + return new SRTM_Diagonal(); + } + + // Instance data + // + + private final List