---
-The Step Right Machine
+The Step Right Tape Machine
This is a conventional iterator for traversing through containers. The items visited
during the traversal are as though values in cells on a single linked tape.
-import com.ReasoningTechnology.Ariadne.Ariadne_SRMT;
+import com.ReasoningTechnology.Ariadne.Ariadne_SRTM;
import java.math.BigInteger;
-public class CountingNumber extends Ariadne_SRMT<BigInteger>{
+public class CountingNumber extends Ariadne_SRTM<BigInteger>{
public static CountingNumber make(BigInteger maximum){
return new CountingNumber(maximum);
private BigInteger i;
private BigInteger maximum;
- private final TopoIface<BigInteger> state_null = new ASRMT_Null();
- private final TopoIface<BigInteger> state_segment = new ASRMT_Segment();
- private final TopoIface<BigInteger> state_rightmost = new ASRMT_Rightmost();
- private final TopoIface<BigInteger> state_infinite = new ASRMT_Infinite();
+ private final TopoIface<BigInteger> state_null = new ASRTM_Null();
+ private final TopoIface<BigInteger> state_segment = new ASRTM_Segment();
+ private final TopoIface<BigInteger> state_rightmost = new ASRTM_Rightmost();
+ private final TopoIface<BigInteger> state_infinite = new ASRTM_Infinite();
public CountingNumber(){
this.i = BigInteger.ONE;
}
- private class ASRMT_Null implements TopoIface<BigInteger>{
+ private class ASRTM_Null implements TopoIface<BigInteger>{
@Override
public boolean can_read(){
return false;
}
}
- private class ASRMT_Segment implements TopoIface<BigInteger>{
+ private class ASRTM_Segment implements TopoIface<BigInteger>{
@Override
public boolean can_read(){
return true;
}
}
- private class ASRMT_Rightmost implements TopoIface<BigInteger>{
+ private class ASRTM_Rightmost implements TopoIface<BigInteger>{
@Override
public boolean can_read(){
return true;
}
}
- private class ASRMT_Infinite implements TopoIface<BigInteger>{
+ private class ASRTM_Infinite implements TopoIface<BigInteger>{
@Override
public boolean can_read(){
return true;
-import com.ReasoningTechnology.Ariadne.Ariadne_SRMT;
+import com.ReasoningTechnology.Ariadne.Ariadne_SRTM;
import java.math.BigInteger;
public class Example_CountingNumber_0{
if( !n.can_read() ) return;
- if( n.topology() == Ariadne_SRMT.Topology.SEGMENT ){
+ if( n.topology() == Ariadne_SRTM.Topology.SEGMENT ){
do{
System.out.println("Current Number: " + n.read());
if( !n.can_step() ) break;
n.step();
}while( true );
- }else if( n.topology() == Ariadne_SRMT.Topology.INFINITE ){
+ }else if( n.topology() == Ariadne_SRTM.Topology.INFINITE ){
int count = 0;
do{
System.out.println("Current Number: " + n.read());
-import com.ReasoningTechnology.Ariadne.Ariadne_SRMT;
-import com.ReasoningTechnology.Ariadne.Ariadne_SRMT_List;
-import com.ReasoningTechnology.Ariadne.IndexTree_SRMT_Child;
+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;
// Initialize graph and start at root
IndexTree_Graph graph = IndexTree_Graph.make();
- IndexTree_SRMT_Child root = graph.start();
+ 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_SRMT<IndexTree_Label> child_srm;
+ Ariadne_SRTM<IndexTree_Label> child_srm;
// Descend 3 more levels
int i = 1;
import java.math.BigInteger;
import java.util.Queue;
-public class Example_IndexTree_Diagonal_SRMT {
+public class Example_IndexTree_Diagonal_SRTM {
public static void main(String[] args){
- System.out.println("Starting IndexTree SRMT Example");
+ System.out.println("Starting IndexTree SRTM Example");
- // Instantiate the IndexTree Diagonal SRMT
- IndexTree_Diagonal_SRMT srm = IndexTree_Diagonal_SRMT.make();
+ // Instantiate the IndexTree Diagonal SRTM
+ IndexTree_Diagonal_SRTM srm = IndexTree_Diagonal_SRTM.make();
int step_count = 0;
do{
protected IndexTree_Graph(){
}
- public IndexTree_SRMT_Child start(){
+ public IndexTree_SRTM_Child start(){
IndexTree_Label root_label = IndexTree_Label.root();
- return IndexTree_SRMT_Child.make(root_label);
+ return IndexTree_SRTM_Child.make(root_label);
}
IndexTree_Node lookup(IndexTree_Label label){
first_child_label.inc_down();
}
- // public IndexTree_SRMT_Child neighbor(){
- public IndexTree_SRMT_Child neighbor(){
- return IndexTree_SRMT_Child.make(first_child_label);
+ // public IndexTree_SRTM_Child neighbor(){
+ public IndexTree_SRTM_Child neighbor(){
+ return IndexTree_SRTM_Child.make(first_child_label);
}
}
package com.ReasoningTechnology.Ariadne;
-public class IndexTree_SRMT_Child extends Ariadne_SRMT_Label {
+public class IndexTree_SRTM_Child extends Ariadne_SRTM_Label {
- public static IndexTree_SRMT_Child make( IndexTree_Label first_child_label ){
- return new IndexTree_SRMT_Child( first_child_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_SRMT_Child( IndexTree_Label first_child_label ){
+ protected IndexTree_SRTM_Child( IndexTree_Label first_child_label ){
this.label = first_child_label.copy();
if( label == null ){
import java.util.ArrayList;
import java.util.List;
import com.ReasoningTechnology.Ariadne.Ariadne_Test;
-import com.ReasoningTechnology.Ariadne.Ariadne_SRMT;
+import com.ReasoningTechnology.Ariadne.Ariadne_SRTM;
import com.ReasoningTechnology.Ariadne.Ariadne_IndexTree_Node;
-public class IndexTree_Diagonal_SRMT extends Ariadne_SRMT_Label>{
+public class IndexTree_Diagonal_SRTM extends Ariadne_SRTM_Label>{
// Static
//
- public static IndexTree_Diagonal_SRMT make(){
- return new IndexTree_Diagonal_SRMT();
+ public static IndexTree_Diagonal_SRTM make(){
+ return new IndexTree_Diagonal_SRTM();
}
//Instance data
private final List<Ariadne_Label> list_of__unopened_node;
// each node has a child list, this is a list of child lists
- private final List<Ariadne_SRMT> list_of__opened_incomplete_child_list;
+ private final List<Ariadne_SRTM> list_of__opened_incomplete_child_list;
// Each diagonal is a list of nodes, referenced by their label
private final List<Ariadne_Label> read_list;
// Constructor(s)
//
- protected IndexTree_Diagonal_SRMT(){
+ protected IndexTree_Diagonal_SRTM(){
list_of__unopened_node = new ArrayList<>();
list_of__opened_incomplete_child_list = new ArrayList<>();
read_list = new ArrayList<>();
private List<BigInteger[]> fetch_child_labels(Ariadne_IndexTree_Node node){
List<BigInteger[]> child_labels = new ArrayList<>();
if(node != null){
- IndexTree_Diagonal_SRMT child_srm = node.neighbor();
+ IndexTree_Diagonal_SRTM child_srm = node.neighbor();
if( child_srm.can_read() ){
do{
child_labels.add(child_srm.read());
-import com.ReasoningTechnology.Ariadne.Ariadne_SRMT;
-import com.ReasoningTechnology.Ariadne.Ariadne_SRMTI_Array;
+import com.ReasoningTechnology.Ariadne.Ariadne_SRTM;
+import com.ReasoningTechnology.Ariadne.Ariadne_SRTMI_Array;
import java.util.Arrays;
import java.util.List;
-public class Example_SRMTI_Array {
+public class Example_SRTMI_Array {
public static void main( String[] args ){
// Create an Array
List<String> label_array = Arrays.asList( "A", "B", "C", "D" );
- // Attach SRMTI to the array
- Ariadne_SRMTI_Array<String> srm = Ariadne_SRMTI_Array.make( label_array );
+ // Attach SRTMI to the array
+ Ariadne_SRTMI_Array<String> srm = Ariadne_SRTMI_Array.make( label_array );
if( srm.can_read() ){
do{
System.out.println( "Reading: " + srm.read() );
-import com.ReasoningTechnology.Ariadne.Ariadne_SRMT;
-import com.ReasoningTechnology.Ariadne.Ariadne_SRMT_List;
+import com.ReasoningTechnology.Ariadne.Ariadne_SRTM;
+import com.ReasoningTechnology.Ariadne.Ariadne_SRTM_List;
import java.util.LinkedList;
-public class Example_SRMT_List {
+public class Example_SRTM_List {
public static void main( String[] args ){
// Create a linked list
LinkedList<String> label_list = new LinkedList<>();
label_list.add( "B" );
label_list.add( "C" );
- // Attach SRMT to the linked list and traverse
- Ariadne_SRMT_List<String> srm = Ariadne_SRMT_List.make(label_list);
+ // Attach SRTM to the linked list and traverse
+ Ariadne_SRTM_List<String> srm = Ariadne_SRTM_List.make(label_list);
if( srm.can_read() ){
do{
System.out.println( "Reading: " + srm.read() );
/*
- IndexTree_SRMT_Diagonal
+ IndexTree_SRTM_Diagonal
An index tree is infinite.
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-import com.ReasoningTechnology.Ariadne.Ariadne_SRMT;
+import com.ReasoningTechnology.Ariadne.Ariadne_SRTM;
import com.ReasoningTechnology.Ariadne.IndexTree_Node;
-public class IndexTree_SRMT_Diagonal extends Ariadne_SRMT_Label {
+public class IndexTree_SRTM_Diagonal extends Ariadne_SRTM_Label {
// Static
- public static IndexTree_SRMT_Diagonal make(){
- return new IndexTree_SRMT_Diagonal();
+ public static IndexTree_SRTM_Diagonal make(){
+ return new IndexTree_SRTM_Diagonal();
}
// Instance Data
private final List<Ariadne_Label> list_of__unopened_node;
private final List<List<Ariadne_Label>> list_of__opened_incomplete_child_list;
private final List<Ariadne_Label> read_list;
- private final Ariadne_SRMT_Label breadth_srm;
+ private final Ariadne_SRTM_Label breadth_srm;
// Constructor
- protected IndexTree_SRMT_Diagonal(){
+ protected IndexTree_SRTM_Diagonal(){
list_of__unopened_node = new ArrayList<>();
list_of__opened_incomplete_child_list = new ArrayList<>();
read_list = new ArrayList<>();
- breadth_srm = Ariadne_SRMT_Label.make();
+ breadth_srm = Ariadne_SRTM_Label.make();
enqueue_root();
}
// Retrieve the node using lookup
IndexTree_Node node = lookup( label );
- // Mount a new breadth-first SRMT for children
+ // Mount a new breadth-first SRTM for children
breadth_srm.mount( node.neighbor() );
if( breadth_srm.can_read() ){
public interface Ariadne_Graph {
- Ariadne_SRMT start();
+ Ariadne_SRTM start();
Ariadne_Node lookup(Ariadne_Label label);
return this.label;
}
- public Ariadne_SRMT_Label neighbor(){
+ public Ariadne_SRTM_Label neighbor(){
throw new UnsupportedOperationException("Ariadne_Node::neighbor not implemented in the base class.");
}
// Marks representation
if( !mark_set.isEmpty() ){
- Ariadne_SRMT_Set srm = Ariadne_SRMT_Set.make(mark_set);
+ Ariadne_SRTM_Set srm = Ariadne_SRTM_Set.make(mark_set);
output.append( " Mark(" );
do{
/*
- Step Right Machine
+ Step Right Tape Machine
This is a mostly abstract base class.
*/
package com.ReasoningTechnology.Ariadne;
-public class Ariadne_SRMT{
+public class Ariadne_SRTM{
// static
//
,INFINITE
}
- public static Ariadne_SRMT make(){
- return new Ariadne_SRMT();
+ public static Ariadne_SRTM make(){
+ return new Ariadne_SRTM();
}
// instance data
// constructor(s)
//
- protected Ariadne_SRMT(){
+ protected Ariadne_SRTM(){
set_topology( not_mounted );
}
return false;
}
@Override public Object read(){
- throw new UnsupportedOperationException("Ariadne_SRMT::NotMounted::read.");
+ throw new UnsupportedOperationException("Ariadne_SRTM::NotMounted::read.");
}
@Override public boolean can_step(){
return false;
}
@Override public void step(){
- throw new UnsupportedOperationException("Ariadne_SRMT::NotMounted::step.");
+ throw new UnsupportedOperationException("Ariadne_SRTM::NotMounted::step.");
}
@Override public Topology topology(){
- throw new UnsupportedOperationException("Ariadne_SRMT::NotMounted::topology.");
+ throw new UnsupportedOperationException("Ariadne_SRTM::NotMounted::topology.");
}
}
/*
-Ariadne_SRMT with index
+Ariadne_SRTM with index
*/
package com.ReasoningTechnology.Ariadne;
import java.math.BigInteger;
-public abstract class Ariadne_SRMTI extends Ariadne_SRMT{
+public abstract class Ariadne_SRTMI extends Ariadne_SRTM{
private BigInteger current_index;
- public Ariadne_SRMTI(){
+ public Ariadne_SRTMI(){
this.current_index = BigInteger.ZERO;
}
import java.math.BigInteger;
import java.util.List;
-public class Ariadne_SRMTI_Array extends Ariadne_SRMTI{
+public class Ariadne_SRTMI_Array extends Ariadne_SRTMI{
// Static methods
- public static Ariadne_SRMTI_Array make(List array){
- return new Ariadne_SRMTI_Array( array );
+ public static Ariadne_SRTMI_Array make(List array){
+ return new Ariadne_SRTMI_Array( array );
}
// Instance data
private final TopoIface topo_rightmost = new TopoRightmost();
// Constructor
- protected Ariadne_SRMTI_Array(List array){
+ protected Ariadne_SRTMI_Array(List array){
super();
this.array = array;
package com.ReasoningTechnology.Ariadne;
-public class Ariadne_SRMT_Label extends Ariadne_SRMT {
+public class Ariadne_SRTM_Label extends Ariadne_SRTM {
- public static Ariadne_SRMT_Label make(){
- return new Ariadne_SRMT_Label();
+ public static Ariadne_SRTM_Label make(){
+ return new Ariadne_SRTM_Label();
}
@Override public Ariadne_Label read(){
/*
- The Ariadne_SRMT_List class provides a Step Right Machine (SRMT) for linked lists.
+ The Ariadne_SRTM_List class provides a Step Right Tape Machine (SRTMT) for linked lists.
This implementation uses Java's ListIterator, which lacks a direct method
to read the current element without advancing the iterator.
import java.util.List;
import java.util.ListIterator;
-public class Ariadne_SRMT_List extends Ariadne_SRMT{
+public class Ariadne_SRTM_List extends Ariadne_SRTM{
// Static methods
- public static Ariadne_SRMT_List make(List list){
- return new Ariadne_SRMT_List(list);
+ public static Ariadne_SRTM_List make(List list){
+ return new Ariadne_SRTM_List(list);
}
private List list; // The attached linked list
private final TopoIface topo_segment = new TopoSegment();
private final TopoIface topo_rightmost = new TopoRightmost();
- protected Ariadne_SRMT_List(List list){
+ protected Ariadne_SRTM_List(List list){
this.list = list;
if( list == null || list.isEmpty() ){
import java.util.ArrayList;
import java.util.Set;
-public class Ariadne_SRMT_Set extends Ariadne_SRMTI_Array{
+public class Ariadne_SRTM_Set extends Ariadne_SRTMI_Array{
// Static factory method
- public static Ariadne_SRMT_Set make(Set set){
- return new Ariadne_SRMT_Set( set );
+ public static Ariadne_SRTM_Set make(Set set){
+ return new Ariadne_SRTM_Set( set );
}
- protected Ariadne_SRMT_Set(Set set){
+ protected Ariadne_SRTM_Set(Set set){
super( new ArrayList(set) );
}
projects / Ariadne / commitdiff