IsAntipodal

java.lang.Object
- cusack.hcg.graph.algorithm.AbstractAlgorithm<PuzzleInstance>
- - cusack.hcg.graph.algorithm.standard.IsAntipodal

All Implemented Interfaces:

AlgorithmInterface<PuzzleInstance>
```
public class IsAntipodal
extends AbstractAlgorithm<PuzzleInstance>
```
An Algorithm to check if a graph has the antipodal property (See "On Pebbling Graphs")

Author:

mark.powers - 7/2017

Constructor Summary

Constructors
Constructor and Description

IsAntipodal()

Constructors
Constructor and Description
`IsAntipodal()`

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()`
`java.lang.Class<PuzzleInstance>`	`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.
`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`	`initializeData()` setProblemData is already implemented for you, but you might need to initialize other data related to your 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.

Methods inherited from class cusack.hcg.graph.algorithm.AbstractAlgorithm
getNumberOfOperations, getState, isDone, isNotDone, isQuit, setProblemData, setState

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

- Constructor Detail
  - IsAntipodal
```
public IsAntipodal()
```
- Method Detail
  - 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.
    
    Returns:
  - 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.
    
    Returns:
    
    the result
  - 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.)
    
    Returns:
  - getProblemType
```
public java.lang.Class<PuzzleInstance> getProblemType()
```
    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.
  - runAlgorithm
```
public void runAlgorithm()
```
    Description copied from interface: AlgorithmInterface
    
    Runs the Algorithm. This is the most important method.
  - getCurrentProblemData
```
public java.lang.String getCurrentProblemData()
```
    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).
  - quit
```
public void quit()
```
    Description copied from interface: AlgorithmInterface
    
    (Hopefully) gracefully stop the computation.
  - countsOperations
```
public boolean countsOperations()
```
    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.
  - initializeData
```
public void initializeData()
```
    Description copied from class: AbstractAlgorithm
    
    setProblemData is already implemented for you, but you might need to initialize other data related to your algorithm. This method is called in setProblemData.
    
    Specified by:
    
    initializeData in class AbstractAlgorithm<PuzzleInstance>
  - 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.
  - argumentFormat
```
public java.lang.String argumentFormat()
```
    Description copied from interface: AlgorithmInterface
    
    Describe how the argument(s) to the algorithm should be formatted, if applicable.
    
    Returns:

Class IsAntipodal

Constructor Summary

Method Summary

Methods inherited from class cusack.hcg.graph.algorithm.AbstractAlgorithm

Methods inherited from class java.lang.Object

Constructor Detail

IsAntipodal

Method Detail

getProgressReport

getResult

getVersion

getProblemType

runAlgorithm

getCurrentProblemData

quit

countsOperations

initializeData

parseArguments

argumentFormat