HowellAlgorithm

java.lang.Object
- cusack.hcg.games.lights.algorithms.HowellAlgorithm

All Implemented Interfaces:: AlgorithmInterface<LightsInstance>

public class HowellAlgorithm
extends java.lang.Object
implements AlgorithmInterface<LightsInstance>

Constructor Summary

Constructors
Constructor and Description

HowellAlgorithm()

Constructors
Constructor and Description
`HowellAlgorithm()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`java.lang.String`	`argumentFormat()` Describe how the argument(s) to the algorithm should be formatted, if applicable.
`boolean`	`countsOperations()`
`java.lang.String`	`getCurrentProblemData()`
`long`	`getNumberOfOperations()` Assuming the subclasses keep track, get the number of operations performed so far, where "operation" is defined however the algorithm would like.
`java.lang.Class<LightsInstance>`	`getProblemType()`
`java.lang.String`	`getProgressReport()` HTML text that will be displayed in the Algorithm Runner that explains what the algorithm is doing.
`java.lang.String`	`getResult()` Return the result of the algorithm in the context of the problem.
`AlgorithmStates`	`getState()` Get the current state of the algorithm.
`double`	`getVersion()` Mostly for use in comparing results from previous versions of algorithms, and/or so we can know whether or not data in the database is based on an older version of the algorithm.
`void`	`parseArguments(java.lang.String args)` Sends a string that the user can enter to the algorithm.
`void`	`quit()` (Hopefully) gracefully stop the computation.
`void`	`runAlgorithm()` Runs the Algorithm.
`void`	`setProblemData(LightsInstance puzzle)`
`void`	`setState(AlgorithmStates state)` Sets the state of the algorithm to state.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - HowellAlgorithm
```
public HowellAlgorithm()
```
- Method Detail
  - getResult
```
public java.lang.String getResult()
```
    Description copied from interface: AlgorithmInterface
    
    Return the result of the algorithm in the context of the problem. i.e. Solvable, Unsolvable, Unknown. This tells more than "Done" or "Not_Done" that is given in the more general sense. This might just be "true" or "false", it might be the encoding of a series of moves, etc.
    
    Specified by:
    
    getResult in interface AlgorithmInterface<LightsInstance>
    
    Returns:
    
    the result
  - setProblemData
```
public void setProblemData(LightsInstance puzzle)
```
    Specified by:
    
    setProblemData in interface AlgorithmInterface<LightsInstance>
    
    Parameters:
    
    puzzle - the puzzle to run the algorithm on. The algorithm may or may not use this directly, so there should be no expectation that either the puzzle you pass in will be updated/changed by the algorithm or that it won't.
  - getProgressReport
```
public java.lang.String getProgressReport()
```
    Description copied from interface: AlgorithmInterface
    
    HTML text that will be displayed in the Algorithm Runner that explains what the algorithm is doing.
    
    Specified by:
    
    getProgressReport in interface AlgorithmInterface<LightsInstance>
    
    Returns:
  - runAlgorithm
```
public void runAlgorithm()
```
    Description copied from interface: AlgorithmInterface
    
    Runs the Algorithm. This is the most important method.
    
    Specified by:
    
    runAlgorithm in interface AlgorithmInterface<LightsInstance>
  - getCurrentProblemData
```
public java.lang.String getCurrentProblemData()
```
    Specified by:
    
    getCurrentProblemData in interface AlgorithmInterface<LightsInstance>
    
    Returns:
    
    A string representation of the current state of the problem data. This should be in the same format as it was passed in to setProblemData, but updated to give the current state based on the algorithm progress so far. The idea is that this can be used to show the progress of the algorithm by some GUI (or in text form, I suppose).
  - getState
```
public AlgorithmStates getState()
```
    Description copied from interface: AlgorithmInterface
    
    Get the current state of the algorithm.
    
    Specified by:
    
    getState in interface AlgorithmInterface<LightsInstance>
    
    Returns:
  - countsOperations
```
public boolean countsOperations()
```
    Specified by:
    
    countsOperations in interface AlgorithmInterface<LightsInstance>
    
    Returns:
    
    True if and only if the algorithm intends to keep track of the number of operations it is performing. Each algorithm is free to decide what it considers an "operation" to be.
  - getNumberOfOperations
```
public long getNumberOfOperations()
```
    Description copied from interface: AlgorithmInterface
    
    Assuming the subclasses keep track, get the number of operations performed so far, where "operation" is defined however the algorithm would like.
    
    Specified by:
    
    getNumberOfOperations in interface AlgorithmInterface<LightsInstance>
    
    Returns:
  - getVersion
```
public double getVersion()
```
    Description copied from interface: AlgorithmInterface
    
    Mostly for use in comparing results from previous versions of algorithms, and/or so we can know whether or not data in the database is based on an older version of the algorithm. Start with "return 1.0". Go up by whatever increments you like (e.g. 1.1, 1.2, etc. or 1, 2, 3, etc.)
    
    Specified by:
    
    getVersion in interface AlgorithmInterface<LightsInstance>
    
    Returns:
  - setState
```
public void setState(AlgorithmStates state)
```
    Description copied from interface: AlgorithmInterface
    
    Sets the state of the algorithm to state. The choices are DONE, NOT_DONE, PAUSED, and QUIT. Currently anything related to PAUSED is not implemented fully.
    
    Specified by:
    
    setState in interface AlgorithmInterface<LightsInstance>
    
    Parameters:
    
    state - What state the algorithm should be set to.
  - getProblemType
```
public java.lang.Class<LightsInstance> getProblemType()
```
    Specified by:
    
    getProblemType in interface AlgorithmInterface<LightsInstance>
    
    Returns:
    
    The class object representing the subclass of PuzzleInstance that this algorithm runs on. The implementation should probably be something like "return Blah.class;", where Blah is the subclass of PuzzleInstance used in place of T.
  - quit
```
public void quit()
```
    Description copied from interface: AlgorithmInterface
    
    (Hopefully) gracefully stop the computation.
    
    Specified by:
    
    quit in interface AlgorithmInterface<LightsInstance>
  - parseArguments
```
public void parseArguments(java.lang.String args)
```
    Description copied from interface: AlgorithmInterface
    
    Sends a string that the user can enter to the algorithm. The string will be in whatever format the user enters. Implementation can assume this method is called after the problem data has been set. Throw an exception if different arguments are required.
    
    Specified by:
    
    parseArguments in interface AlgorithmInterface<LightsInstance>
  - argumentFormat
```
public java.lang.String argumentFormat()
```
    Description copied from interface: AlgorithmInterface
    
    Describe how the argument(s) to the algorithm should be formatted, if applicable.
    
    Specified by:
    
    argumentFormat in interface AlgorithmInterface<LightsInstance>
    
    Returns:

Class HowellAlgorithm

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

HowellAlgorithm

Method Detail

getResult

setProblemData

getProgressReport

runAlgorithm

getCurrentProblemData

getState

countsOperations

getNumberOfOperations

getVersion

setState

getProblemType

quit

parseArguments

argumentFormat