scribbledecobble: Simple Simon

README

Ponder the following epigraphs presented by Donald Ervin Knuth in volume one of The Art of Computer Programming as you say hello to Patrick Joseph McGovern’s brain quest, which Edmund C. Berkeley’s book Giant Brains; or, Machines That Think inspired.

CHAPTER ONE

BASIC CONCEPTS
Many persons who are not conversant with mathematical studies
imagine that because the business of [Babbage’s Analytical Engine] is to
give its results in numerical notation, the nature of its processes must
consequently be arithmetical and numerical, rather than algebraical and
analytical. This is an error. The engine can arrange and combine its
numerical quantities exactly as if they were letters or any other general
symbols; and in fact it might bring out its results in algebraic notation,
were provisions made accordingly.

— AGUSTA ADA, Countess of Lovelace (1843)

Practice yourself for heaven’s sake, in little things;
and thence proceed to greater.

— EPICTETUS (Discourses IV.i)

Code

package Simple;
import Simple.Simon10;
import Simple.Simon10Help;

/**
 * The <code>Computer</code> class is a controller that
 * starts simulations of models of simple computers
 * similar to the computer called Simon described by
 * Edmund Berkeley in the book <cite>Giant Brains, or
 * Machines That Think</cite>, published in 1949.
 *
 * @author  Spurgeon (John)
 * @version 1.0
 */
public class Computer {

  /**
   * Starts a program that simulates a computer if the computer
   * model specified is supported and one or more arguments to
   * be passed to the simulation program are provided; if no such
   * arguments are provided, then the help documentation for the
   * computer model is displayed if it exists. If the specified
   * computer model is not supported, the program outputs a message
   * informing the user of that fact.
   *
   * @param args a list of strings that begins with
   *             a model name (e.g. <code>Simon10</code>)
   *             followed by a list of arguments to be
   *             passed to the method that simulates
   *             the indicated computer model.
   */
  public static void main(String[] args) {

    final String SIMON10 = "Simon10";
    final String SIMON100 = "Simon100";
    final String SIMON101 = "Simon101";
    final int ARGS_COUNT = args.length;

    String whichModel = "";
    String s = "";
    String[] tailArgs = {};
    int i;

    if (ARGS_COUNT == 0) {
      System.out.println("Usage: Simon <which model> [args]");
    }
    else {
      whichModel = args[0];
      if (whichModel.equals(SIMON10) || whichModel.equals(SIMON100)) {
        for (i = 1; i < ARGS_COUNT; i++) {
          if (i > 1) {
            s = s + " ";
          }
          s = s + args[i]; 
        }
        if (ARGS_COUNT > 1) {
          tailArgs = s.split(" "); // convert string to array of strings
        }
      }
      if (whichModel.equals(SIMON10)) {
        if (tailArgs.length > 0) {
          Simon10.main(tailArgs);
        }
        else {
          Simon10Help.main(tailArgs);
        }
      }
      else {
        System.out.println("Model not supported: " + whichModel);
      }
    }
  }
}

// package Simple;
import java.util.Scanner;

/**
 * The <code>Simon10</code> class simulates the operations that can be
 * performed by the computer called Simon that Edmund Berkeley describes
 * in <cite>Giant Brains; or, Machines that Think</cite>, published by
 * John Wiley and Sons in 1949.
 *
 * @author
 * 
 *   Spurgeon (John)
 *
 * @version
 *
 *   1.1
 */
public class Simon10 {

  /*****************/
  /* PUBLIC FIELDS */
  /*****************/

  /**
   * A register used to store an operand.
   */
  public static int c1 = 0;

  /**
   * A register used to store an operand.
   */
  public static int c2 = 0;

  /**
   * A register used to store an operand.
   */
  public static int c3 = 0;

  /**
   * A register used to store an opcode.
   */
  public static int c4 = 0;

  /**
   * A register used to store the result of performing
   * an operation on zero or more operands.
   */
  public static int c5 = 0;

  /**
   * Standard error output buffer.
   */
  public static String stderr = "";

  /**
   * Standard out output buffer.
   */
  public static String stdout = "";

  /******************/
  /* PRIVATE FIELDS */
  /******************/

  // Truth values.

  final private static int TRUE = 1;
  final private static int FALSE = 0;

  // Opcodes.

  final private static int ADDITION = 0;
  final private static int NEGATION = 1;
  final private static int GREATER_THAN = 2;
  final private static int SELECTION = 3;

  // Number of numbers Simon knows.

  final private static int MENTALITY = 4;

  /******************/
  /* PUBLIC METHODS */
  /******************/

  /**
   * Executes one or more programs.
   *
   * @param args
   *
   *   A sequence of programs where each program is
   *   composed of a sequence of digits in the form
   *   of a string of characters.
   *
   */
  public static void main(String[] args) {

    final int NUM_PROGRAMS = args.length;
    String program;

    if (NUM_PROGRAMS == 0) {
      Scanner input = new Scanner(System.in);
      program = "";
      while(input.hasNext()) {
        program += input.next();
      }
      Simon10.run(program);
    }
    else {
      for (int i = 0; i < NUM_PROGRAMS; i++) {
        program = args[i];
        Simon10.run(program);
      }
    }
  }

  /**
   * Executes the loaded program, and prints the output
   * or an error message in the event of errors.
   *
   * <p>Algorithm</p>
   *
   * <p>First, set the value of the program counter equal
   * to zero so that it refers to the first possible digit
   * of the program, which is presumably an opcode value.</p>
   *
   * <p>For as long as the program counter points to a potential
   * instruction, attempt to perform the next instruction:
   * <ol>
   *   <li> Load the opcode and operand values into registers.
   *   <li> If the method that loads the registers indicates
   *        that an error occurred, then flush stderr and
   *        terminate.
   *   <li> Execute the instruction. Pass the values of registers
   *        c4 (the opcode value), c3, c2, and c1 (possible operand
   *        values) to a method that computes and returns the result.
   *   <li> If the method that computes the result indicates that
   *        an error occurred, then flush stderr and terminate;
   *        otherwise, store the result in register c5.
   *   <li> If necessary, flush the stdout buffer.
   * </ol>
   *
   * <p>Finally, flush any unflushed output.</p>
   */
  public static void run(String program) {

    final int PROG_SIZE = program.length();

    int pc;            // program counter
    int result;        // result of executing an operation
    int numRegLoaded;  // number of registers loaded

    for (pc = 0; pc < PROG_SIZE; pc += numRegLoaded) {

      numRegLoaded = Simon10.loadRegisters(program, pc);

      if (numRegLoaded < 0) {
        Simon10.flushStderr();
        return;
      }

      result = Simon10.computeResult(c4, c3, c2, c1);

      if (result < 0) {
        Simon10.flushStderr();
        return;
      }
      else {
        c5 = result;
      }

      if (shouldFlush(stdout)) {
        Simon10.flushStdout();
      }
    }

    Simon10.flushStdout();      
  }

  /*******************/
  /* PRIVATE METHODS */
  /*******************/

  private static boolean shouldFlush(String buffer) {
    return buffer.length() > 1000;
  }

  private static void flushStdout() {
    System.out.println(Simon10.stdout);
    Simon10.stdout = "";
  }

  private static void flushStderr() {
    System.out.println(Simon10.stderr);
    Simon10.stderr = "";
  }
  
  private static int outOfRangeError(String thing, int value) {
    Simon10.stderr += thing + " is out of range: " + value;
    return -1;
  }

  private static int operandMissingError(int n) {
    Simon10.stderr += "Operand " + n + " is missing.";
    return -2;
  }

  private static int notAnIntegerError() {
    Simon10.stderr += "Argument is not an integer.";
    return -3;
  }

  /**
   * Returns the number of operands needed to perform
   * a particular operation.
   *
   * @param opcode
   *
   *   An value denoting an operation.
   *
   * @return
   *
   *   The number of operands.
   */
  private static int numOperandsNeeded(int opcode) {
    if (opcode == Simon10.NEGATION) {
      return 1;
    }
    else if (opcode == Simon10.SELECTION) {
      return 3;
    }
    else {
      return 2;
    }
  }

  /**
   * Loads an opcode value into register c4, and loads
   * operand values required by the operation determined
   * by the opcode value into registers c1, c2, and c3.
   *
   * @param prog
   *
   *   A program comprised of a series of digits, subsets
   *   of which define individual instructions. An instruction
   *   begins with a digit representing an opcode (i.e. an
   *   operation) followed by zero or more operand values,
   *   also represented by digits.
   *
   * @param pc
   *
   *   A program counter (instruction pointer) value
   *   used as an index into the sequence of digits that
   *   defines the program referenced by the parameter
   *   <code>prog</code>.
   *
   * @return
   *
   *   The number of registers loaded.
   */
  private static int loadRegisters(String program, int pc) {

    final int PROG_SIZE = program.length();

    try {

      // Parse and load the opcode.

      Simon10.c4 = Integer.parseInt("" + program.charAt(pc + 0));
      if (Simon10.c4 < 0 || Simon10.c4 >= Simon10.MENTALITY) {
        return Simon10.outOfRangeError("Opcode", Simon10.c4);
      }

      // Get the number of required operands.

      final int NUM_OPERANDS = Simon10.numOperandsNeeded(Simon10.c4);

      // Parse and load the required operands.

      if (NUM_OPERANDS > 0) {
        if (PROG_SIZE > pc + 1) {
          Simon10.c1 = Integer.parseInt("" + program.charAt(pc + 1));
          if (Simon10.c1 < 0 || Simon10.c1 >= Simon10.MENTALITY) {
            return Simon10.outOfRangeError("Operand", Simon10.c1);
          }
        }
        else {
          return Simon10.operandMissingError(1);
        }
      }

      if (NUM_OPERANDS > 1) {
        if (PROG_SIZE > pc + 2) {
          Simon10.c2 = Integer.parseInt("" + program.charAt(pc + 2));
          if (Simon10.c2 < 0 || Simon10.c2 >= Simon10.MENTALITY) {
            return Simon10.outOfRangeError("Operand", Simon10.c2);
          }
        }
        else {
          return Simon10.operandMissingError(2);
        }
      }

      if (NUM_OPERANDS > 2) {
        if (PROG_SIZE > pc + 3) {
          Simon10.c3 = Integer.parseInt("" + program.charAt(pc + 3));
          if (Simon10.c3 != TRUE && Simon10.c3 != FALSE) {
            return Simon10.outOfRangeError("Operand", Simon10.c3);
          }
        }
        else {
          return Simon10.operandMissingError(3);
        }
      }

      // Return the number of registers loaded.

      return NUM_OPERANDS + 1; // + 1 is for the opcode
    }
    catch (Exception e) {
      return Simon10.notAnIntegerError();
    }
  }

  /**
   * Uses operands to compute the result of an operation
   * denoted by an opcode; returns the result. Produces
   * output in the process.
   *
   * @param oc   An opcode.
   * @param op3  An operand.
   * @param op2  An operand.
   * @param op1  An operand.
   *
   * @return
   *
   *   The result of performing the operation indicated by
   *   the value of the parameter <code>oc</code> on zero
   *   or more of the provided operands.
   */
  private static int computeResult(int oc, int op3, int op2, int op1) {

    int result = -1;

    if (oc == Simon10.ADDITION) {
      Simon10.stdout += op1 + " + " + op2;
      result = (op1 + op2) % Simon10.MENTALITY;
    }
    else if (oc == Simon10.NEGATION) {
      Simon10.stdout += "-" + op1;
      result = (Simon10.MENTALITY - op1) % Simon10.MENTALITY;
    }
    else if (oc == Simon10.GREATER_THAN) {
      Simon10.stdout += op1 + " > " + op2;
      result = op1 > op2 ? TRUE : FALSE;
    }
    else if (oc == Simon10.SELECTION) {
      Simon10.stdout += op3 + " ? " + op1 + " : " + op2;
      if (op3 == Simon10.TRUE) {
        result = c1;
      }
      else {
        result = c2;
      }
    }

    Simon10.stdout += " is " + result + "\n";

    if (result < 0 || result >= Simon10.MENTALITY) {
      return outOfRangeError("Result", result);
    }
    else {
      return result;
    }
  }

}

package Simple;

public class Simon10Help {
  public static void main(String[] args) {
    Simon10AdditionHelp.main(args);
    Simon10NegationHelp.main(args);
    Simon10GreaterThanHelp.main(args);
    Simon10SelectionHelp.main(args);
  }
}

class Simon10AdditionHelp {

  public static String getOpcodeInfo() {
    return "\nThe addition opcode is 0.";
  }

  public static String getRegisterInfo() {
    String s = "";
    s += "\nRegister c1: operand";
    s += "\nRegister c2: operand";
    s += "\nRegister c3: not used";
    s += "\nRegister c4: opcode";
    s += "\nRegister c5: result";
    return s;
  }

  public static String getRulesTable() {
    String s = "\nc = a + b";
    s += "\n";
    s += "\n b: 0 1 2 3 ";
    s += "\na ----------";
    s += "\n0 | 0 1 2 3 ";
    s += "\n1 | 1 2 3 0 ";
    s += "\n2 | 2 3 0 1 ";
    s += "\n3 | 3 0 1 2 ";
    return s;
  }

  public static void main(String[] args) {
    String s = "Addition";
    s += "\n" + getOpcodeInfo();
    s += "\n" + getRegisterInfo();
    s += "\n" + getRulesTable();
    s += "\n";
    System.out.println(s);
  }
}

class Simon10NegationHelp {

  public static String getOpcodeInfo() {
    return "\nThe negation opcode is 1.";
  }

  public static String getRegisterInfo() {
    String s = "";
    s += "\nRegister c1: operand";
    s += "\nRegister c2: not used";
    s += "\nRegister c3: not used";
    s += "\nRegister c4: opcode";
    s += "\nRegister c5: result";
    return s;
  }

  public static String getRulesTable() {
    String s = "\nc = -a";
    s += "\n";
    s += "\na | c ";
    s += "\n------";
    s += "\n0 | 0 ";
    s += "\n1 | 3 ";
    s += "\n2 | 2 ";
    s += "\n3 | 1 ";
    return s;
  }

  public static void main(String[] args) {
    String s = "Negation";
    s += "\n" + getOpcodeInfo();
    s += "\n" + getRegisterInfo();
    s += "\n" + getRulesTable();
    s += "\n";
    System.out.println(s);
  }
}

class Simon10GreaterThanHelp {

  public static String getOpcodeInfo() {
    return "\nThe greater than opcode is 2.";
  }

  public static String getRegisterInfo() {
    String s = "";
    s += "\nRegister c1: operand";
    s += "\nRegister c2: operand";
    s += "\nRegister c3: not used";
    s += "\nRegister c4: opcode";
    s += "\nRegister c5: result";
    return s;
  }

  public static String getRulesTable() {
    String s = "\nc = a > b";
    s += "\n";
    s += "\n b: 0 1 2 3 ";
    s += "\na ----------";
    s += "\n0 | 0 0 0 0 ";
    s += "\n1 | 1 0 0 0 ";
    s += "\n2 | 1 1 0 0 ";
    s += "\n3 | 1 1 1 0 ";
    return s;
  }

  public static void main(String[] args) {
    String s = "Greater Than";
    s += "\n" + getOpcodeInfo();
    s += "\n" + getRegisterInfo();
    s += "\n" + getRulesTable();
    s += "\n";
    System.out.println(s);
  }
}

class Simon10SelectionHelp {

  public static String getOpcodeInfo() {
    return "\nThe selection opcode is 3.";
  }

  public static String getRegisterInfo() {
    String s = "";
    s += "\nRegister c1: operand";
    s += "\nRegister c2: operand";
    s += "\nRegister c3: operand";
    s += "\nRegister c4: opcode";
    s += "\nRegister c5: result";
    return s;
  }

  public static String getRulesTable() {
    String s = "\nc = a*p + b*(1 - p)";
    s += "\n";
    s += "\n p: 0 0 0 0  1 1 1 1 ";
    s += "\n b: 0 1 2 3  0 1 2 3 ";
    s += "\na -------------------";
    s += "\n0 | 0 1 2 3  0 0 0 0 ";
    s += "\n1 | 0 1 2 3  1 1 1 1 ";
    s += "\n2 | 0 1 2 3  2 2 2 2 ";
    s += "\n3 | 0 1 2 3  3 3 3 3 ";
    return s;
  }

  public static void main(String[] args) {
    String s = "Selection";
    s += "\n" + getOpcodeInfo();
    s += "\n" + getRegisterInfo();
    s += "\n" + getRulesTable();
    s += "\n";
    System.out.println(s);
  }
}

package Simple;
import Simple.Simon10;

public class Simon10Tests {
  public static void main(String[] args) {
    Simon10PositiveTests.main(args);
    Simon10NegativeTests.main(args);
  }
}

class Simon10TestRunner {

  public static int passCount = 0;
  public static int failCount = 0;

  public static void runPositiveTests(String[][][] testSet) {
    for (int i = testSet.length - 1; i >= 0; i--) {
      String[][] testCase = testSet[i];
      String[] args = testCase[0];
      int expectedValue = Integer.parseInt(testCase[1][0]);
      Simon10.main(args);
      if (Simon10.c5 == expectedValue) {
        passCount++;
        System.out.println("pass");
      }
      else {
        failCount++;
        System.out.println("fail");
      }
    }
    System.out.println();
    System.out.println("Passed: " + passCount);
    System.out.println("Failed: " + failCount);
    System.out.println();
  }

  public static void runNegativeTests(String[][][] testSet) {
    for (int i = testSet.length - 1; i >= 0; i--) {
      String[][] testCase = testSet[i];
      String[] args = testCase[0];
      String expectedError = testCase[1][0];
      Simon10.main(args);
      if (Simon10.stderr.equals(expectedError)) {
        passCount++;
        System.out.println("pass");
      }
      else {
        failCount++;
        System.out.println("fail");
      }
    }
    System.out.println();
    System.out.println("Passed: " + passCount);
    System.out.println("Failed: " + failCount);
    System.out.println();
  }
}

class Simon10AdditionTests {

  private static String[][][] positiveTests = {
    {{"0", "0", "0"}, {"0"}},
    {{"0", "0", "1"}, {"1"}},
    {{"0", "0", "2"}, {"2"}},
    {{"0", "0", "3"}, {"3"}},
    {{"0", "1", "0"}, {"1"}},
    {{"0", "1", "1"}, {"2"}},
    {{"0", "1", "2"}, {"3"}},
    {{"0", "1", "3"}, {"0"}},
    {{"0", "2", "0"}, {"2"}},
    {{"0", "2", "1"}, {"3"}},
    {{"0", "2", "2"}, {"0"}},
    {{"0", "2", "3"}, {"1"}},
    {{"0", "3", "0"}, {"3"}},
    {{"0", "3", "1"}, {"0"}},
    {{"0", "3", "2"}, {"1"}},
    {{"0", "3", "3"}, {"2"}}
  };

  public static void runPositiveTests() {
    Simon10TestRunner.runPositiveTests(positiveTests);
  }

  public static void runNegativeTests() {
  }

  public static void main(String[] args) {
    runPositiveTests();
    runNegativeTests();
  }
}

class Simon10NegationTests {

  static String[][][] positiveTests = {
    {{"1", "0"}, {"0"}},
    {{"1", "1"}, {"3"}},
    {{"1", "2"}, {"2"}},
    {{"1", "3"}, {"1"}},
  };

  public static void runPositiveTests() {
    Simon10TestRunner.runPositiveTests(positiveTests);
  }

  public static void runNegativeTests() {
  }

  public static void main(String[] args) {
    runPositiveTests();
    runNegativeTests();
  }
}

class Simon10GreaterThanTests {

  private static String[][][] positiveTests = {
    {{"2", "0", "0"}, {"0"}},
    {{"2", "0", "1"}, {"0"}},
    {{"2", "0", "2"}, {"0"}},
    {{"2", "0", "3"}, {"0"}},
    {{"2", "1", "0"}, {"1"}},
    {{"2", "1", "1"}, {"0"}},
    {{"2", "1", "2"}, {"0"}},
    {{"2", "1", "3"}, {"0"}},
    {{"2", "2", "0"}, {"1"}},
    {{"2", "2", "1"}, {"1"}},
    {{"2", "2", "2"}, {"0"}},
    {{"2", "2", "3"}, {"0"}},
    {{"2", "3", "0"}, {"1"}},
    {{"2", "3", "1"}, {"1"}},
    {{"2", "3", "2"}, {"1"}},
    {{"2", "3", "3"}, {"0"}}
  };

  public static void runPositiveTests() {
    Simon10TestRunner.runPositiveTests(positiveTests);
  }

  public static void runNegativeTests() {
  }

  public static void main(String[] args) {
    runPositiveTests();
    runNegativeTests();
  }
}

class Simon10SelectionTests {

  private static String[][][] positiveTests = {
    {{"3", "0", "0", "1"}, {"0"}},
    {{"3", "0", "1", "1"}, {"0"}},
    {{"3", "0", "2", "1"}, {"0"}},
    {{"3", "0", "3", "1"}, {"0"}},
    {{"3", "1", "0", "1"}, {"1"}},
    {{"3", "1", "1", "1"}, {"1"}},
    {{"3", "1", "2", "1"}, {"1"}},
    {{"3", "1", "3", "1"}, {"1"}},
    {{"3", "2", "0", "1"}, {"2"}},
    {{"3", "2", "1", "1"}, {"2"}},
    {{"3", "2", "2", "1"}, {"2"}},
    {{"3", "2", "3", "1"}, {"2"}},
    {{"3", "3", "0", "1"}, {"3"}},
    {{"3", "3", "1", "1"}, {"3"}},
    {{"3", "3", "2", "1"}, {"3"}},
    {{"3", "3", "3", "1"}, {"3"}},

    {{"3", "0", "0", "0"}, {"0"}},
    {{"3", "0", "1", "0"}, {"1"}},
    {{"3", "0", "2", "0"}, {"2"}},
    {{"3", "0", "3", "0"}, {"3"}},
    {{"3", "1", "0", "0"}, {"0"}},
    {{"3", "1", "1", "0"}, {"1"}},
    {{"3", "1", "2", "0"}, {"2"}},
    {{"3", "1", "3", "0"}, {"3"}},
    {{"3", "2", "0", "0"}, {"0"}},
    {{"3", "2", "1", "0"}, {"1"}},
    {{"3", "2", "2", "0"}, {"2"}},
    {{"3", "2", "3", "0"}, {"3"}},
    {{"3", "3", "0", "0"}, {"0"}},
    {{"3", "3", "1", "0"}, {"1"}},
    {{"3", "3", "2", "0"}, {"2"}},
    {{"3", "3", "3", "0"}, {"3"}}
  };

  public static void runPositiveTests() {
    Simon10TestRunner.runPositiveTests(positiveTests);
  }

  public static void runNegativeTests() {
  }

  public static void main(String[] args) {
    runPositiveTests();
    runNegativeTests();
  }
}

class Simon10PositiveTests {
  public static void main(String[] args) {
    Simon10AdditionTests.runPositiveTests();
    Simon10NegationTests.runPositiveTests();
    Simon10GreaterThanTests.runPositiveTests();
    Simon10SelectionTests.runPositiveTests();
  }
}

class Simon10NegativeTests {

  private static String[][][] missingValueTests = {
    {{"0"}, {"Operand 1 is missing."}},
    {{"1"}, {"Operand 1 is missing."}},
    {{"2"}, {"Operand 1 is missing."}},
    {{"3"}, {"Operand 1 is missing."}},
    {{"0", "1", "2", "0"}, {"Operand 1 is missing."}},
    {{"1", "0", "1"}, {"Operand 1 is missing."}},
    {{"0", "0"}, {"Operand 2 is missing."}},
    {{"2", "0"}, {"Operand 2 is missing."}},
    {{"3", "0"}, {"Operand 2 is missing."}},
    {{"3", "0", "1"}, {"Operand 3 is missing."}}
  };

  public static void main(String[] args) {
    Simon10TestRunner.runNegativeTests(missingValueTests);
    Simon10AdditionTests.runNegativeTests();
    Simon10NegationTests.runNegativeTests();
    Simon10GreaterThanTests.runNegativeTests();
    Simon10SelectionTests.runNegativeTests();
  }
}

public class Bits {
    
    public static int toInt(String bits) {
        
        try {
            return Integer.parseInt(bits, 2);
        }
        catch (Exception e) {
            return -1;
        }
    }
    
    public static String toInts(String bits, int perInt, String delim) {
        
        final int BIT_COUNT = bits.length();

        String subStr;
        String stringOfInts = "";
        int integer;
        int i = 0;
        int j = perInt;
        
        while (j <= BIT_COUNT) {
            subStr = bits.substring(i, j);
            integer = Bits.toInt(subStr);
            if (integer >= 0) {
                if (stringOfInts.length() > 0) {
                    stringOfInts += delim;
                }
                stringOfInts += integer;
            }
            i += perInt;
            j = i + perInt;
        }
        
        return stringOfInts;
    }
    
    public static void main(String[] args) {
        
        final int NUM_ARGS = args.length;
        int perInt = 0;
        String output;

        if (NUM_ARGS > 0) {
            perInt = Bits.toInt(args[0]);
        }
        if (perInt <= 0) {
            return;
        }
        for (int i = 1; i < NUM_ARGS; i++) {
            output = Bits.toInts(args[i], perInt, " ");
            System.out.println(output);
        }
    }
}

Q&A

Notes

Exercises

Learn about about Simon the computer and Simon’s designer, Edmund Berkeley.
BONUS: Peruse Edmund Berkeley’s book, Giant Brains, or Machines That Think.
- If you have a .djvu viewer utility installed on your computer, you can download an electronic copy of the book from:
  http://history-computer.com/Library/Berkeley_Giant_brains.djvu
- For help viewing .djvu files, see: http://djvu.org/.
- Used copies of the book are available. For example, see:
  https://www.amazon.com/Giant-Brains-Machines-That-Think/dp/B003R4WOLY/ref=sr_1_2
Familiarize yourself with the source code that makes up this MESS.
1. On a computer that has a Java Development Kit (JDK) installed, create a directory called Simple.
2. Compile and execute the program defined by the source code labeled Simon10Help.java.
  1. Copy the Simon10Help.java source code from this MESS and paste it into a text editor such as Notepad.
  2. Save the code to a file named Simon10Help.java in the Simple directory, which you just created.
  3. Using a command-line utility such as PowerShell, change directories if necessary so that you are in the Simple directory, and compile the Simon10Help.java code using the javac compiler:
    javac Simon10Help.java
  4. Assuming you are still in the Simple directory, execute the main method using the following command. (Get comfortable using the -classpath option with the java command. You may need to use the -classpath option when working with files that components of a Java package.)
    java -classpath .. Simon10Help
  5. Run the program by using other class names besides Simon10Help as arguments to the java interpreter. How many different starting points (i.e. classes with main methods) are there in the file?
  6. Try to understand what the output of the Simon10Help.java program is telling you.
3. Compile execute the program Simon10.java. Execute the program by passing a variety of command-line arguments to the java interpreter including the ones shown below. How do specific argument values affect the behavior of the program?
  - 0
  - 00
  - 000
  - 012
  - 112
  - 321012 0123210
4. Use the javadoc utility to create HTML documentation for the code stored in the files you have compiled. Study the documentation produced carefully, especially the index file(s). Hint:
  javadoc *.java
5. Try to compile and execute Simon10Tests.java. What does this program do?

scribbledecobble

Pages

Simple Simon

README

See Also

Patience

Code

Q&A

Notes

Exercises