Class Index



AbstractNode<A, S, N extends AbstractNode<A, S, N>> Basic implementation of the interface Node
ActionFunction<A, S> Interface that defines an action function that computes applicable actions for a given state. 
ActionStateTransitionFunction<A, S> Interface to define a transition function that takes an action and a concrete state and returns the new state. 
ADStarForward<A, S, C extends Comparable<C>, N extends ADStarNode<A, S, C, N>>

Iterative implementation of the forward Anytime Dynamic A* (AD*-f) search algorithm. 

ADStarForward.Iterator Internal iterator that implements all the logic of the A* search  
ADStarNode<A, S, C extends Comparable<C>, N extends ADStarNode<A, S, C, N>> Implementation of Node to be used with the AD* algorithm, implemented in ADStarForward
ADStarNode.Key<C extends Comparable<C>> Inner class defining the key of the node, which depends on the values of G and V. 
ADStarNodeExpander<A, S, C extends Comparable<C>, N extends ADStarNode<A, S, C, N>> This class is an implementation of NodeExpander for nodes of type ADStarNode
ADStarNodeFactory<A, S, C extends Comparable<C>> The ADStarNodeBuilder is used for instantiate new ADStarNodeImpl
ADStarNodeImpl<A, S, C extends Comparable<C>> Interface defining the basic operations for Node to be used with ADStarForward
ADStarNodeUpdater<A, S, C extends Comparable<C>> The ADStarNodeUpdater is used by the ADStarForward algorithm to update the G and V values of the ADStarNodeImpl explored by the algorithm. 
Algorithm<A, S, N extends Node<A, S, N>> Abstract class implemented by each search algorithm. 
Algorithm.SearchResult Holds information about the search process. 
AnnealingSearch<A, S, N extends HeuristicNode<A, S, Double, N>> Implementation of the simulated annealing search that is a probabilistic technique for approximating the global optimum of a given function. 
AnnealingSearch.AcceptanceProbability Interface to compute the acceptance probability. 
AnnealingSearch.SuccessorFinder<A, S, N extends Node<A, S, N>> Interface to find the successor of a node. 
AStar<A, S, C extends Comparable<C>, N extends HeuristicNode<A, S, C, N>>

Implementation of the A* algorithm. 

AStar.Iterator Internal iterator that implements all the logic of the A* search  


BellmanFord<A, S, C extends Comparable<C>, N extends CostNode<A, S, C, N>>

Optimized implementation of the Bellman-Ford algorithm. 

BellmanFord.Iterator Bellman-Ford iterator. 
BinaryFunction<T> A binary operation takes two elements of the same type and combines them returning an element of the same type. 
BinaryOperation<E extends Comparable<E>> A implementation of BinaryFunction used to define a custom cost algebra that also has the following definitions:
  • identity element (A*I = A)
  • maximum element (A*M = M)

Simple example that loads a GraphML example graph from GitHub, loads it with the Blueprints API and then solves the multiobjective problem with Hipster

A full description of the problem is published on Hipster's wiki
BlueprintsHipsterDirectedGraphAdapter Simple adapter implementation between a Hipster graph and a Blueprints graph. 
BlueprintsHipsterGraphAdapter Simple graph adapter between a Blueprints graph and a HipsterGraph. 
BreadthFirstSearch<A, S, N extends Node<A, S, N>>

Breadth First Search (BFS) implementation. 

BreadthFirstSearch.Iterator Implements all the BFS search logic as an iterator  


CostFunction<A, S, C extends Comparable<C>> The cost function evaluates a transition between states. 
CostNode<A, S, C extends Comparable<C>, N extends CostNode<A, S, C, N>> Defines a node which stores an attribute for the cost, extending the interface of a basic node Node


DepthFirstSearch<A, S, N extends Node<A, S, N>>

Depth First Search (DFS) is a blind algorithm that performs an exploration of the graph in a way that always reaches the deepest node before backtracking. 

DepthFirstSearch.Iterator DFS iterator used to expand always the deepest non-visited node. 
DepthLimitedSearch<A, S, N extends Node<A, S, N>> Copyright 2015 Centro de Investigación en Tecnoloxías da Información (CITIUS), University of Santiago de Compostela (USC). 
DirectedEdge<V, E>  
DirectedGraphSearchExample Example that creates a HipsterDirectedGraph, creates a search problem to be used with Hipster search iterators and performs a search using the Dijkstra algorithm. 


EightPuzzleProblemExample Example of the N-Puzzle (3x3 tiles) search problem solved with the A* algorithm. 
EightQueensProblemExample Example using the N-Queens problem (size 8x8) solved using the Hill Climbing and Enforced Hill Climbing algorithms. 
EightQueensProblemExampleWithAnnealingSearch Example using the N-Queens problem (size 8x8) solved using the Annealing search. 


F This class contains a very limited set of functions to process iterables and iterators in a lazy way. 

Author: Keith Schwarz ([email protected])

An implementation of a priority queue backed by a Fibonacci heap, as described by Fredman and Tarjan. 
Function<E, V>  


GraphBuilder<V, E>

Graph builder assistant to create a Hipster graph. 

GraphEdge<V, E> Hipster graph edge implementation to represent edges (or arcs) of a directed or undirected graph. 
GraphSearchProblem Builder to generate a SearchProblem but using a HipsterGraph. 
GraphSearchProblem.FromVertex.CostType.HeuristicType<C extends Comparable<C>>  


HashBasedHipsterDirectedGraph<V, E> Implementation of a HipsterDirectedGraph using a Guava Hash Table. 
HashBasedHipsterGraph<V, E> Lightweight implementation of an in-memory, mutable graph backed to a HashMap where keys are vertices and edges are GraphEdges  
HashQueue<S> Implementation of a java.util.Queue backed by a java.util.LinkedHashSet 
HashTableHipsterDirectedGraph<V, E> Implementation of a HipsterDirectedGraph using a Guava Hash Table. 
HashTableHipsterGraph<V, E> Implementation of a HipsterGraph using a Guava Hash Table. 
HeuristicFunction<S, C> Defines a function that takes a state and estimates the distance to the goal of the problem. 
HeuristicNode<A, S, C extends Comparable<C>, N extends HeuristicNode<A, S, C, N>> Type of node which stores an estimated (heuristic) cost to the goal, extending the interface of a cost node CostNode
HeuristicNodePriorityEvaluator<A, S, C extends Comparable<C>, N extends HeuristicNode<A, S, C, N>> Calculates the priority (double) of a HeuristicNode based translating on a cost extending java.lang.Number. 
HillClimbing<A, S, C extends Comparable<C>, N extends HeuristicNode<A, S, C, N>> Implementation of the Hill Climbing algorithm. 
Hipster Util class to create algorithms easily. 
HipsterDirectedGraph<V, E> A simple representation of a directed graph with two methods for retrieving the outgoing edges and the incoming edges for a vertex. 
HipsterGraph<V, E> Basic definition of the read-only methods for a graph in terms of edges and vertices. 
HipsterMutableGraph<V, E> Interface that defines the basic mutable methods to manipulate graphs 


IDAStar<A, S, C extends Comparable<C>, N extends HeuristicNode<A, S, C, N>>

Implementation of the IDA* algorithm. 

IDAStar.Iterator IDA iterator. 


JUNGHipsterDirectedGraphAdapter<V, E> An adapter class to adapt a JUNG graph to the Hipster Graph interface. 
JUNGHipsterGraphAdapter<V, E> An adapter to adapt a JUNG graph to a general HipsterGraph interface. 


LazyActionStateTransitionFunction<A, S> Implementation of a TransitionFunction generates an java.lang.Iterable of Transition which are instantiated in a lazy way, as the elements are iterated by the algorithms, and not in advance. 
LazyNodeExpander<A, S, N extends Node<A, S, N>> Implementation of a NodeExpander which generates an java.lang.Iterable of Node which are instantiated in a lazy way, as required by the algorithms, and not in advance. 



This class defines a 2D ASCII Maze used to easily validate the search algorithms. 

Maze2D.Symbol Symbols allowed to create a maze  
Mazes Class containing a set of Maze2D to execute in the tests of the search iterators. 
Mazes.TestMaze ASCII Maze examples with the shortest path distance. 
MazeSearch This class executes the search iterators over maps of type Maze2D
MazeSearch.Result Inner class to define the results of the search process over Maze2D
MazeShortestPathExample Example using a bidimensional maze, solved using the A* algorithm. 
MultiobjectiveLS<A, S, C extends Comparable<C>, N extends HeuristicNode<A, S, C, N>>

Implementation of the multi-objective label setting algorithm described by Martins and Santos. 

MultiobjectiveLS.Iterator MultiobjectiveLS iterator. 


Node<A, S, N extends Node<A, S, N>> A node encapsulates the information generated by the search algorithms during their execution. 
NodeExpander<A, S, N extends Node<A, S, N>> Defines a function that takes a Node and expands it in order to generate all the possible successors. 
NodeFactory<A, S, N> Generator of nodes. 

General N-Puzzle problem. 

NPuzzle.Puzzle Puzzle class represents the state codification for this game. 
NPuzzle.PuzzleMove Actions that can be used in the N-Puzzle game. 

General N-Queens problem. 


Predicate<T> Definition of predictcate to be used with search iterators implementing the class Algorithm
PriorityEvaluator<N> This interface is intended for the definition of evaluators to calculate the priority (double) of a concrete element. 
PriorityFibonacciQueue<N> Implementation of java.util.Queue based on the Fibonacci heap concept, described in 
ProblemBuilder Problem builder that is used to guide the user through the creation of a SearchProblem with the main components required to instantiate an algorithm. 
ProblemBuilder.Wizard Internal wizard assistant class. 
ProblemBuilder.Wizard.ActionState<S> Step to define the initial state of the problem. 
ProblemBuilder.Wizard.ActionState.Uninformed<A> Creates a uninformed problem (a problem without a cost/heuristic evaluator) to be used with uninformed algorithms like DFS, BFS. 
ProblemBuilder.Wizard.ActionState.Uninformed.Informed<C extends Comparable<C>> An informed search problem builder generates informed search problems with a generic cost  
ProblemBuilder.Wizard.ActionState.Uninformed.Informed.Heuristic Defines the heuristic function to be used. 
ProblemBuilder.Wizard.ActionState.WithAction Builder step to define a search problem with actions. 
ProblemBuilder.Wizard.ActionState.WithAction.Action<A> Builder step to select the transition function of a action-explicit search problem. 
ProblemBuilder.Wizard.ActionState.WithoutAction Builder step to define a search problem without actions. 
Product Implementation of ScalarFunction product for java.lang.Double elements. 



Definition of the states, transitions, costs and heuristics for the Romania Problem as described in 

RomanianProblem.City Enum with all the cities of the problem. 
RomanianProblemExample Example of graph search using the Romania problem described here


ScalarFunction<T> A scalar function takes an object and modifies its magnitude by a numeric factor without changing its type. 
ScalarOperation<E extends Comparable<E>> A scalar operation is an implementation of ScalarFunction that also defines:
  • identity element (A*i = A)
SearchComponents<A, S, C extends Comparable<C>> This class should be used to instantiate an ADStar algorithm through the Hipster.createADStar method. 
SearchProblem<A, S, N extends Node<A, S, N>> Defines a search problems in terms of a initial node to start with and the node expander function that generates new successor nodes. 
SimpleEightPuzzleExample Example of using Hipster to solve the 8-puzzle search problem problem using the Dijkstra's algorithm. 
SimpleTransition<S> A SimpleTransition is just a transition without explicit actions Transition<Void,S>
StateTransitionFunction<S> Implementation of a TransitionFunction which generates an java.lang.Iterable of Transition which are instantiated in a lazy way, as the elements are iterated by the algorithms, and not in advance. 


Transition<A, S> Defines a transition between states. 
TransitionFunction<A, S> Defines a function that returns the possible transitions from a given state. 


UndirectedEdge<V, E>  
UndirectedGraphSearchExample Example of graph search with manual creation of the graph structure. 
UniqueEdge<V> Dumb class that can be used to generate unique edges for a graph with a value. 
UnweightedNode<A, S> Simple implementation of a search node which does not keep any information about costs. 


WeightedNode<A, S, C extends Comparable<C>> Basic implementation of a node which does not which keeps information about the cost. 
WeightedNodeFactory<A, S, C extends Comparable<C>> Implementation of NodeFactory for nodes of type WeightedNode