// Static
//
- public static SRTM_Diagonal make(){
- return new SRTM_Diagonal();
+ public static SRTM_Diagonal make(Label start_node){
+ return new SRTM_Diagonal(start_node);
}
// Instance data
//
- private List<Label> diagonal; // the read value
- private final List<SRTM_Child> child_srtm_list;
-
- private final TopoIface topo_infinite_right = new Topo_InfiniteRight();
+ private List<Label> diagonal = new ArrayList<>(); // the read value
+ private final List<SRTM_Child> child_srtm_list = new ArrayList<>();
// Constructor(s)
//
// the diagonal will never be null nor empty
- protected SRTM_Diagonal(){
- diagonal = new ArrayList<>();
- diagonal.add(Label.root());
- child_srtm_list = new ArrayList<>();
+ protected SRTM_Diagonal(Label start_node){
+
+ if( start_node == null ){
+ set_topology(topo_null);
+ return;
+ }
+
set_topology(topo_infinite_right);
+ diagonal.add(start_node);
}
// Implementation of instance interface
return (List<Label>)super.read(); // Cast to ensure type consistency
}
- private class Topo_InfiniteRight implements TopoIface{
- @Override public boolean can_read(){
- return true;
- }
- @Override public List read(){
- return diagonal;
- }
- @Override public boolean can_step(){
- return true;
- }
-
- @Override public void step(){
-
- List<Label> diagonal_1 = new ArrayList<>();
-
- // inc_down from each node on diagonal_0 -> entry on child_strm list
- Ariadne_SRTM_List<Label> diagonal_srtm = Ariadne_SRTM_List.make(diagonal);
- if( diagonal_srtm.can_read() ){
- do{
- Node node = Node.make(diagonal_srtm.read());
- child_srtm_list.add(node.neighbor()); // graph node neighbor == tree node child
- if( !diagonal_srtm.can_step() ) break;
- diagonal_srtm.step();
- }while(true);
+ 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;
+ }
+ };
- // add to diagonal_1 from each on entry on the child_strm list
- Ariadne_SRTM_List<SRTM_Child> child_srtm_srtm = Ariadne_SRTM_List.make(child_srtm_list);
- if( child_srtm_srtm.can_read() ){
- do{
- SRTM_Child child_srtm = child_srtm_srtm.read();
- Label label = child_srtm.read();
- diagonal_1.add(label.copy());
- child_srtm.step();
- if( !child_srtm_srtm.can_step() ) break;
- child_srtm_srtm.step();
- }while(true);
+ private final TopoIface topo_infinite_right = new TopoIface(){
+ @Override public boolean can_read(){
+ return true;
+ }
+ @Override public List read(){
+ return diagonal;
+ }
+ @Override public boolean can_step(){
+ return true;
}
- // Update the state for the next step
- diagonal = diagonal_1;
- }
+ @Override public void step(){
+
+ List<Label> diagonal_1 = new ArrayList<>();
+
+ // inc_down from each node on diagonal_0 -> entry on child_strm list
+ Ariadne_SRTM_List<Label> diagonal_srtm = Ariadne_SRTM_List.make(diagonal);
+ if( diagonal_srtm.can_read() ){
+ do{
+ Node node = Node.make(diagonal_srtm.read());
+ child_srtm_list.add(node.neighbor()); // graph node neighbor == tree node child
+ if( !diagonal_srtm.can_step() ) break;
+ diagonal_srtm.step();
+ }while(true);
+ }
+
+ // add to diagonal_1 from each on entry on the child_strm list
+ Ariadne_SRTM_List<SRTM_Child> child_srtm_srtm = Ariadne_SRTM_List.make(child_srtm_list);
+ if( child_srtm_srtm.can_read() ){
+ do{
+ SRTM_Child child_srtm = child_srtm_srtm.read();
+ Label label = child_srtm.read();
+ diagonal_1.add(label.copy());
+ child_srtm.step();
+ if( !child_srtm_srtm.can_step() ) break;
+ child_srtm_srtm.step();
+ }while(true);
+ }
+
+ // Update the state for the next step
+ diagonal = diagonal_1;
+ }
- @Override public Topology topology(){
- return Topology.INFINITE;
- }
+ @Override public Topology topology(){
+ return Topology.INFINITE;
+ }
- }
+ };
}
System.out.println("Starting IndexTree SRTM Example");
// Instantiate the IndexTree Diagonal SRTM
- SRTM_Diagonal srtm = SRTM_Diagonal.make();
- int step_count = 0;
- if( srtm.can_read() ){
- do{
- System.out.println(step_count + ": " + srtm.read());
- if( !srtm.can_step() ) break;
- if( step_count == 4 ) break; // Stop after 5 diagonals
- step_count++;
- srtm.step();
- }while(true);
+ Graph g = Graph.make();
+ SRTM_Child start_srtm = g.start();
+ if( !start_srtm.can_read() ){
+ System.out.println("Graph provides no start nodes. Thought you might want to know.");
+ return;
}
+
+ do{
+ Label start_label = start_srtm.read();
+ System.out.println("Graph diagonalization starting from: " + start_label);
+ SRTM_Diagonal srtm = SRTM_Diagonal.make(start_label);
+ int step_count = 0;
+ if( srtm.can_read() ){
+ do{
+ System.out.println(step_count + ": " + srtm.read());
+ if( !srtm.can_step() ) break;
+ if( step_count == 4 ) break; // Stop after 5 diagonals
+ step_count++;
+ srtm.step();
+ }while(true);
+ }
+ if( !start_srtm.can_step() ) break;
+ System.out.println();
+ start_srtm.step();
+ }while(true);
+
}
}
--- /dev/null
+Starting IndexTree SRTM Example
+Graph diagonalization starting from: Label([])
+0: [Label([])]
+1: [Label([0])]
+2: [Label([1]), Label([0 ,0])]
+3: [Label([2]), Label([0 ,1]), Label([1 ,0]), Label([0 ,0 ,0])]
+4: [Label([3]), Label([0 ,2]), Label([1 ,1]), Label([0 ,0 ,1]), Label([2 ,0]), Label([0 ,1 ,0]), Label([1 ,0 ,0]), Label([0 ,0 ,0 ,0])]
--- /dev/null
+Example_4x4
+starting at: Label([])
+Descended to: Label([0])
+Descended to: Label([0 ,0])
+Descended to: Label([0 ,0 ,0])
+Across to: Label([0 ,0 ,1])
+Across to: Label([0 ,0 ,2])
+Across to: Label([0 ,0 ,3])
List<String> label_array = Arrays.asList( "A", "B", "C", "D" );
// Attach SRTMI to the array
- Ariadne_SRTMI_Array srm = Ariadne_SRTMI_Array.make( label_array );
+ Ariadne_SRTMI_Array<String> srm = Ariadne_SRTMI_Array.make( label_array );
if( srm.can_read() ){
do{
System.out.println( "Reading: " + srm.read() );
--- /dev/null
+import com.ReasoningTechnology.Ariadne.Ariadne_SRTM_Set;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class SRTM_Set_CLI {
+ public static void main( String[] args ){
+ // Create a Set
+ Set<String> label_set = new HashSet<>();
+ label_set.add("A");
+ label_set.add("B");
+ label_set.add("C");
+
+ // Attach SRTM to the set and traverse
+ Ariadne_SRTM_Set<String> srm = Ariadne_SRTM_Set.make(label_set);
+ if( srm.can_read() ){
+ do{
+ System.out.println( "Reading: " + srm.read() );
+ System.out.println( "Topology: " + srm.topology() );
+ if( !srm.can_step() ) break;
+ srm.step();
+ }while(true);
+ }
+ }
+}
+Aeloria
/*
IndexTree_SRTM_Diagonal
read_list = new ArrayList<>();
breadth_srm = Ariadne_SRTM_Label.make();
enqueue_root();
- }
+ }Aeloria
// Instance Methods
import java.math.BigInteger;
import java.util.List;
-public class Ariadne_SRTMI_Array extends Ariadne_SRTMI{
+public class Ariadne_SRTMI_Array<T> extends Ariadne_SRTMI{
// Static methods
- public static Ariadne_SRTMI_Array make(List array){
- return new Ariadne_SRTMI_Array( array );
+ //
+
+ public static <T> Ariadne_SRTMI_Array<T> make(List<T> array){
+ return new Ariadne_SRTMI_Array<>(array);
}
// Instance data
- private final List array;
+ //
+
+ private final List<T> array;
private final TopoIface topo_null = new TopoNull();
private final TopoIface topo_segment = new TopoSegment();
private final TopoIface topo_rightmost = new TopoRightmost();
// Constructor
- protected Ariadne_SRTMI_Array(List array){
+ protected Ariadne_SRTMI_Array(List<T> array){
super();
this.array = array;
// TopoNull
private class TopoNull implements TopoIface{
- @Override
- public boolean can_read(){
+ @Override public boolean can_read(){
return false;
}
- @Override
- public Object read(){
+ @Override public Object read(){
throw new UnsupportedOperationException( "Cannot read from NULL topo." );
}
- @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 NULL topo." );
}
- @Override
- public Topology topology(){
+ @Override public Topology topology(){
return Topology.NULL;
}
}
// TopoSegment
private class TopoSegment implements TopoIface{
- @Override
- public boolean can_read(){
+ @Override public boolean can_read(){
return true;
}
- @Override
- public Object read(){
+ @Override public Object read(){
return array.get( index().intValueExact() );
}
- @Override
- public boolean can_step(){
+ @Override public boolean can_step(){
return true;
}
- @Override
- public void step(){
+ @Override public void step(){
increment();
if( index().compareTo(BigInteger.valueOf(array.size() - 1)) == 0 )
set_topology(topo_rightmost);
}
- @Override
- public Topology topology(){
+ @Override public Topology topology(){
return Topology.SEGMENT;
}
}
// TopoRightmost
private class TopoRightmost implements TopoIface{
- @Override
- public boolean can_read(){
+ @Override public boolean can_read(){
return true;
}
- @Override
- public Object read(){
+ @Override public Object read(){
return array.get( index().intValueExact() );
}
- @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 topo." );
}
- @Override
- public Topology topology(){
+ @Override public Topology topology(){
return Topology.RIGHTMOST;
}
}
package com.ReasoningTechnology.Ariadne;
-import java.util.ArrayList;
+import java.util.Iterator;
import java.util.Set;
-public class Ariadne_SRTM_Set extends Ariadne_SRTMI_Array{
+public class Ariadne_SRTM_Set<T> extends Ariadne_SRTM{
// Static factory method
- public static Ariadne_SRTM_Set make(Set set){
- return new Ariadne_SRTM_Set( set );
+ public static <T> Ariadne_SRTM_Set<T> make(Set<T> set){
+ return new Ariadne_SRTM_Set<>(set);
}
- protected Ariadne_SRTM_Set(Set set){
- super( new ArrayList(set) );
+ // Instance data
+ private final Set<T> set;
+ private final Iterator<T> iterator;
+ private T current_value;
+
+ private final TopoIface topo_null = new TopoNull();
+ private final TopoIface topo_segment = new TopoSegment();
+ private final TopoIface topo_rightmost = new TopoRightmost();
+
+ // Constructor
+ protected Ariadne_SRTM_Set(Set<T> set){
+ this.set = set;
+
+ if( set == null || set.isEmpty() ){
+ this.iterator = null;
+ set_topology(topo_null);
+ return;
+ }
+
+ this.iterator = set.iterator();
+ this.current_value = iterator.hasNext() ? iterator.next() : null;
+
+ if( set.size() == 1 ){
+ set_topology(topo_rightmost);
+ }else{
+ set_topology(topo_segment);
+ }
}
+ // Instance interface implementation
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public T read(){
+ return (T)current_topology.read();
+ }
+
+ private class TopoNull implements TopoIface{
+ @Override public boolean can_read(){
+ return false;
+ }
+ @Override public T read(){
+ throw new UnsupportedOperationException("Cannot read from NULL topo.");
+ }
+ @Override public boolean can_step(){
+ return false;
+ }
+ @Override public void step(){
+ throw new UnsupportedOperationException("Cannot step from NULL topo.");
+ }
+ @Override public Topology topology(){
+ return Topology.NULL;
+ }
+ }
+
+ private class TopoSegment implements TopoIface{
+ @Override public boolean can_read(){
+ return true;
+ }
+ @Override public T read(){
+ return current_value;
+ }
+ @Override public boolean can_step(){
+ return iterator.hasNext();
+ }
+ @Override public void step(){
+ current_value = iterator.next();
+ if( !iterator.hasNext() ) set_topology(topo_rightmost);
+ }
+ @Override public Topology topology(){
+ return Topology.SEGMENT;
+ }
+ }
+
+ private class TopoRightmost implements TopoIface{
+ @Override public boolean can_read(){
+ return true;
+ }
+ @Override public T read(){
+ return current_value;
+ }
+ @Override public boolean can_step(){
+ return false;
+ }
+ @Override public void step(){
+ throw new UnsupportedOperationException("Cannot step from RIGHTMOST topo.");
+ }
+ @Override public Topology topology(){
+ return Topology.RIGHTMOST;
+ }
+ }
}
# remove main build files
# rm_na currently does not handle links correctly
- rm -r scratchpad/*
- rm_na jvm/*
- rm_na bash/*
+ rm -rf scratchpad/*
+ rm_na -f jvm/*
+ rm_na -f bash/*
set +x
for file in *_CLI.class; do
echo "file: " $file
wrapper_name=$(basename "$file" .class)
- rm_na "$wrapper_name"
+ rm_na -f "$wrapper_name"
done
- rm_na *.class
+ rm_na -f *.class
echo "$(script_fn) done."
projects / Ariadne / commitdiff