From: Thomas Walker Lynch Date: Fri, 10 Jan 2025 11:11:05 +0000 (+0000) Subject: most examples running, working on simplifying diagonalization X-Git-Url: https://git.reasoningtechnology.com/style/static/gitweb.css?a=commitdiff_plain;h=7586eace19c4e4c1e2a68fee5698f68442b9ace4;p=Ariadne most examples running, working on simplifying diagonalization --- 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 0000000..0b68688 Binary files /dev/null and b/developer/example/IndexTree/Example_4x4.class differ diff --git a/developer/example/IndexTree/Example_4x4.java b/developer/example/IndexTree/Example_4x4.java new file mode 100644 index 0000000..f484ae0 --- /dev/null +++ b/developer/example/IndexTree/Example_4x4.java @@ -0,0 +1,41 @@ +import com.ReasoningTechnology.Ariadne.Ariadne_SRTM; +import com.ReasoningTechnology.Ariadne.Ariadne_SRTM_List; + +public class Example_4x4{ + + public static void main(String[] args){ + + System.out.println("Example_4x4"); + + // Initialize graph and start at root + Graph graph = Graph.make(); + SRTM_Child start = graph.start(); + Label label = start.read(); + Node node; + SRTM_Child child_srm; + + System.out.println("starting at: " + start.read()); + + // Descend 3 more levels + int i = 1; + do{ + node = graph.lookup(label); + child_srm = node.neighbor(); + label = child_srm.read(); + System.out.println("Descended to: " + 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 to: " + label.toString()); + if(i == 3) break; + i++; + }while(true); + + } +} diff --git a/developer/example/IndexTree/Example_IndexTree_4x4.java b/developer/example/IndexTree/Example_IndexTree_4x4.java deleted file mode 100644 index 233532f..0000000 --- a/developer/example/IndexTree/Example_IndexTree_4x4.java +++ /dev/null @@ -1,46 +0,0 @@ -import com.ReasoningTechnology.Ariadne.Ariadne_SRTM; -import com.ReasoningTechnology.Ariadne.Ariadne_SRTM_List; -import com.ReasoningTechnology.Ariadne.IndexTree_SRTM_Child; -import com.ReasoningTechnology.Ariadne.IndexTree_Graph; -import com.ReasoningTechnology.Ariadne.IndexTree_Node; - -public class Example_IndexTree_4x4{ - - public static void main(String[] args){ - - System.out.println("Example_IndexTree_4x4"); - - // Initialize graph and start at root - IndexTree_Graph graph = IndexTree_Graph.make(); - IndexTree_SRTM_Child root = graph.start(); - - System.out.println("root: " + root.read().toString()); - - // Variables for traversal - IndexTree_Label label = root.read(); - IndexTree_Node node; - Ariadne_SRTM 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_IndexTree_Diagonal_SRM.java b/developer/example/IndexTree/Example_IndexTree_Diagonal_SRM.java deleted file mode 100644 index 5e6bbf6..0000000 --- a/developer/example/IndexTree/Example_IndexTree_Diagonal_SRM.java +++ /dev/null @@ -1,39 +0,0 @@ -import java.math.BigInteger; -import java.util.Queue; - -public class Example_IndexTree_Diagonal_SRTM { - - 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(); - - int step_count = 0; - do{ - System.out.println("Step " + (step_count + 1) + ":"); - /* - Queue read_list = srm.read(); - if(!read_list.isEmpty()){ - for(BigInteger[] label : read_list){ - System.out.println(" Node Label: " + format_label(label)); - } - } - */ - if(step_count == 3) break; // Mid-loop test for inclusive bounds - step_count++; - srm.step(); - }while(true); - } - - private static String format_label(BigInteger[] label){ - if(label.length == 0) return "[]"; - StringBuilder formatted = new StringBuilder("["); - for(int i = 0; i < label.length; i++){ - formatted.append(label[i].toString()); - if(i < label.length - 1) formatted.append(" ,"); - } - formatted.append("]"); - return formatted.toString(); - } -} 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 0000000..8eb9033 Binary files /dev/null and b/developer/example/IndexTree/Example_SRTM_Diagonal.class differ diff --git a/developer/example/IndexTree/Example_SRTM_Diagonal.java b/developer/example/IndexTree/Example_SRTM_Diagonal.java new file mode 100644 index 0000000..f7f15db --- /dev/null +++ b/developer/example/IndexTree/Example_SRTM_Diagonal.java @@ -0,0 +1,41 @@ + + +import java.math.BigInteger; +import java.util.Queue; + +public class Example_SRTM_Diagonal { + + public static void main(String[] args){ + System.out.println("Starting IndexTree SRTM Example"); + + // Instantiate the IndexTree Diagonal SRTM + SRTM_Diagonal srm = SRTM_Diagonal.make(); + + int step_count = 0; + do{ + System.out.println("Step " + (step_count + 1) + ":"); + /* + Queue read_list = srm.read(); + if(!read_list.isEmpty()){ + for(BigInteger[] label : read_list){ + System.out.println(" Node Label: " + format_label(label)); + } + } + */ + if(step_count == 3) break; // Mid-loop test for inclusive bounds + step_count++; + srm.step(); + }while(true); + } + + private static String format_label(BigInteger[] label){ + if(label.length == 0) return "[]"; + StringBuilder formatted = new StringBuilder("["); + for(int i = 0; i < label.length; i++){ + formatted.append(label[i].toString()); + if(i < label.length - 1) formatted.append(" ,"); + } + formatted.append("]"); + return formatted.toString(); + } +} diff --git a/developer/example/IndexTree/Graph.class b/developer/example/IndexTree/Graph.class new file mode 100644 index 0000000..79b4c84 Binary files /dev/null and b/developer/example/IndexTree/Graph.class differ diff --git a/developer/example/IndexTree/Graph.java b/developer/example/IndexTree/Graph.java new file mode 100644 index 0000000..808ad78 --- /dev/null +++ b/developer/example/IndexTree/Graph.java @@ -0,0 +1,22 @@ +import com.ReasoningTechnology.Ariadne.Ariadne_Graph; + +public class Graph extends Ariadne_Graph{ + + public static Graph make(){ + return new Graph(); + } + protected Graph(){ + } + + @Override public SRTM_Child start(){ + Label root_label = Label.root(); + return SRTM_Child.make(root_label); + } + + // no override, this graph does not lookup Ariadne_Label, only Label + Node lookup(Label label){ + return Node.make(label); + } + +} + diff --git a/developer/example/IndexTree/IndexTree_Graph.java b/developer/example/IndexTree/IndexTree_Graph.java deleted file mode 100644 index 96e92f5..0000000 --- a/developer/example/IndexTree/IndexTree_Graph.java +++ /dev/null @@ -1,21 +0,0 @@ -package com.ReasoningTechnology.Ariadne; - -public class IndexTree_Graph{ - - public static IndexTree_Graph make(){ - return new IndexTree_Graph(); - } - protected IndexTree_Graph(){ - } - - public IndexTree_SRTM_Child start(){ - IndexTree_Label root_label = IndexTree_Label.root(); - return IndexTree_SRTM_Child.make(root_label); - } - - IndexTree_Node lookup(IndexTree_Label label){ - return IndexTree_Node.make(label); - } - -} - diff --git a/developer/example/IndexTree/IndexTree_Label.java b/developer/example/IndexTree/IndexTree_Label.java deleted file mode 100644 index d416e71..0000000 --- a/developer/example/IndexTree/IndexTree_Label.java +++ /dev/null @@ -1,81 +0,0 @@ -/* - 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{ - - // Owned by class - // - - public static IndexTree_Label make(BigInteger[] array){ - return new IndexTree_Label(array); - } - - public static IndexTree_Label root(){ - return new IndexTree_Label(new BigInteger[0]); - } - - // Instance data - // - - private BigInteger[] value; - - // Constructor - // - - private IndexTree_Label(BigInteger[] array){ - this.value = array.clone(); - } - - // Instance interface implementation - // - - @Override public boolean isEmpty(){ - return value == null; - } - - @Override public String toString(){ - return Arrays.toString(value); - } - - @Override public IndexTree_Label copy(){ - return new IndexTree_Label(value); - } - - // Increment last element by one, modifying in place - public void inc_across(){ - if(value == null || value.length == 0){ - throw new UnsupportedOperationException("Cannot increment across an empty array."); - } - value[value.length - 1] = value[value.length - 1].add(BigInteger.ONE); - } - - // Append a zero element, modifying in place - public void inc_down(){ - if(value == null){ - throw new UnsupportedOperationException("Cannot append to a null array."); - } - BigInteger[] newValue = Arrays.copyOf(value, value.length + 1); - newValue[newValue.length - 1] = BigInteger.ZERO; - value = newValue; - } - - // Good object citizenship - // - - @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; - return Arrays.equals(value, that.value); - } - - @Override public int hashCode(){ - return Arrays.hashCode(value); - } -} diff --git a/developer/example/IndexTree/IndexTree_Node.java b/developer/example/IndexTree/IndexTree_Node.java deleted file mode 100644 index f1ddd30..0000000 --- a/developer/example/IndexTree/IndexTree_Node.java +++ /dev/null @@ -1,23 +0,0 @@ -package com.ReasoningTechnology.Ariadne; -import java.util.Arrays; - -public class IndexTree_Node extends Ariadne_Node{ - - public static IndexTree_Node make(IndexTree_Label label){ - return new IndexTree_Node(label); - } - - private final IndexTree_Label first_child_label; - - public IndexTree_Node(IndexTree_Label label){ - super(label); - first_child_label = label.copy(); - first_child_label.inc_down(); - } - - // public IndexTree_SRTM_Child neighbor(){ - public IndexTree_SRTM_Child neighbor(){ - return IndexTree_SRTM_Child.make(first_child_label); - } - -} diff --git a/developer/example/IndexTree/IndexTree_SRTM_Child.java b/developer/example/IndexTree/IndexTree_SRTM_Child.java deleted file mode 100644 index a9fbffe..0000000 --- a/developer/example/IndexTree/IndexTree_SRTM_Child.java +++ /dev/null @@ -1,81 +0,0 @@ -package com.ReasoningTechnology.Ariadne; - -public class IndexTree_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 ); - } - - private final IndexTree_Label label; - - protected IndexTree_SRTM_Child( IndexTree_Label first_child_label ){ - this.label = first_child_label.copy(); - - if( label == null ){ - set_topology( topo_null ); - return; - } - - if( label.isEmpty() ){ - set_topology( topo_rightmost ); - return; - } - - set_topology( topo_infinite_right ); - } - - private final TopoIface topo_null = new TopoIface(){ - @Override public boolean can_read(){ - return false; - } - @Override public Object read(){ - throw new UnsupportedOperationException( "Cannot read from NULL topology." ); - } - @Override public boolean can_step(){ - return false; - } - @Override public void step(){ - throw new UnsupportedOperationException( "Cannot step from NULL topology." ); - } - @Override public Topology topology(){ - return Topology.NULL; - } - }; - - private final TopoIface topo_infinite_right = new TopoIface(){ - @Override public boolean can_read(){ - return true; - } - @Override public Object read(){ - return label; - } - @Override public boolean can_step(){ - return true; - } - @Override public void step(){ - label.inc_across(); - } - @Override public Topology topology(){ - return Topology.INFINITE; - } - }; - - private final TopoIface topo_rightmost = new TopoIface(){ - @Override public boolean can_read(){ - return true; - } - @Override public Object read(){ - return label; - } - @Override public boolean can_step(){ - return false; - } - @Override public void step(){ - throw new UnsupportedOperationException( "Cannot step from RIGHTMOST topology." ); - } - @Override public Topology topology(){ - return Topology.RIGHTMOST; - } - }; - -} diff --git a/developer/example/IndexTree/IndexTree_SRTM_Diagonal.java b/developer/example/IndexTree/IndexTree_SRTM_Diagonal.java deleted file mode 100644 index 5bebc07..0000000 --- a/developer/example/IndexTree/IndexTree_SRTM_Diagonal.java +++ /dev/null @@ -1,118 +0,0 @@ -/* -An index Tree is infinite. - -A tree diagonal consists of -a) a node descending from each child discovered thus far -b> 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 0000000..501d301 Binary files /dev/null and b/developer/example/IndexTree/Label.class differ diff --git a/developer/example/IndexTree/Label.java b/developer/example/IndexTree/Label.java new file mode 100644 index 0000000..e94a16f --- /dev/null +++ b/developer/example/IndexTree/Label.java @@ -0,0 +1,81 @@ +/* + Implementation of Ariadne_Label for BigInteger array-based labels. +*/ +import java.math.BigInteger; +import java.util.Arrays; + +import com.ReasoningTechnology.Ariadne.Ariadne_Label; + + +public class Label implements Ariadne_Label{ + + // Owned by class + // + + public static Label make(BigInteger[] array){ + return new Label(array); + } + + public static Label root(){ + return new Label(new BigInteger[0]); + } + + // Instance data + // + + private BigInteger[] value; + + // Constructor + // + + private Label(BigInteger[] array){ + this.value = array.clone(); + } + + // Instance interface implementation + // + + @Override public boolean isEmpty(){ + return value == null; + } + + @Override public String toString(){ + return Arrays.toString(value); + } + + @Override public Label copy(){ + return new Label(value); + } + + // Increment last element by one, modifying in place + public void inc_across(){ + if(value == null || value.length == 0){ + throw new UnsupportedOperationException("Cannot increment across an empty array."); + } + value[value.length - 1] = value[value.length - 1].add(BigInteger.ONE); + } + + // Append a zero element, modifying in place + public void inc_down(){ + if(value == null){ + throw new UnsupportedOperationException("Cannot append to a null array."); + } + BigInteger[] newValue = Arrays.copyOf(value, value.length + 1); + newValue[newValue.length - 1] = BigInteger.ZERO; + value = newValue; + } + + // Good object citizenship + // + + @Override public boolean equals(Object o){ + if(this == o) return true; + if( o == null || getClass() != o.getClass() ) return false; + Label that = (Label) o; + return Arrays.equals(value, that.value); + } + + @Override public int hashCode(){ + return Arrays.hashCode(value); + } +} diff --git a/developer/example/IndexTree/Node.class b/developer/example/IndexTree/Node.class new file mode 100644 index 0000000..cd5ec53 Binary files /dev/null and b/developer/example/IndexTree/Node.class differ 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 0000000..1a8f772 Binary files /dev/null and b/developer/example/IndexTree/SRTM_Child$1.class differ diff --git a/developer/example/IndexTree/SRTM_Child$2.class b/developer/example/IndexTree/SRTM_Child$2.class new file mode 100644 index 0000000..7f0bdcb Binary files /dev/null and b/developer/example/IndexTree/SRTM_Child$2.class differ diff --git a/developer/example/IndexTree/SRTM_Child$3.class b/developer/example/IndexTree/SRTM_Child$3.class new file mode 100644 index 0000000..115cf24 Binary files /dev/null and b/developer/example/IndexTree/SRTM_Child$3.class differ diff --git a/developer/example/IndexTree/SRTM_Child.class b/developer/example/IndexTree/SRTM_Child.class new file mode 100644 index 0000000..be56ddb Binary files /dev/null and b/developer/example/IndexTree/SRTM_Child.class differ diff --git a/developer/example/IndexTree/SRTM_Child.java b/developer/example/IndexTree/SRTM_Child.java new file mode 100644 index 0000000..009cf45 --- /dev/null +++ b/developer/example/IndexTree/SRTM_Child.java @@ -0,0 +1,99 @@ +import com.ReasoningTechnology.Ariadne.Ariadne_SRTM_Label; + +public class SRTM_Child extends Ariadne_SRTM_Label { + + // Static + // + + public static SRTM_Child make( Label first_child_label ){ + return new SRTM_Child( first_child_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 SRTM_Child( Label leftmost_child_label ){ + this.label = leftmost_child_label.copy(); + + if( label == null ){ + set_topology( topo_null ); + return; + } + + if( label.isEmpty() ){ + set_topology( topo_rightmost ); + return; + } + + 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; + } + @Override public Object read(){ + throw new UnsupportedOperationException( "Cannot read from NULL topology." ); + } + @Override public boolean can_step(){ + return false; + } + @Override public void step(){ + throw new UnsupportedOperationException( "Cannot step from NULL topology." ); + } + @Override public Topology topology(){ + return Topology.NULL; + } + }; + + private final TopoIface topo_infinite_right = new TopoIface(){ + @Override public boolean can_read(){ + return true; + } + @Override public Object read(){ + return label; + } + @Override public boolean can_step(){ + return true; + } + @Override public void step(){ + label.inc_across(); + } + @Override public Topology topology(){ + return Topology.INFINITE; + } + }; + + private final TopoIface topo_rightmost = new TopoIface(){ + @Override public boolean can_read(){ + return true; + } + @Override public Object read(){ + return label; + } + @Override public boolean can_step(){ + return false; + } + @Override public void step(){ + throw new UnsupportedOperationException( "Cannot step from RIGHTMOST topology." ); + } + @Override public Topology topology(){ + return Topology.RIGHTMOST; + } + }; + +} 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