- Band - Class in factorization
-
Contains methods that are useful for handling band conditions.
- Band() - Constructor for class factorization.Band
-
- band_grouping(List<DP_State_Node>, List<DP_State_Node>, Join_Predicate) - Static method in class factorization.Band
-
Given two DP stages that correspond to the tuples of two relations
and a band condition, translates the band into multiple inequalities that give the same result.
- belongs_to() - Method in class entities.paths.DP_Decision
-
- belongs_to() - Method in class entities.trees.TDP_Decision
-
- best_decision - Variable in class entities.paths.DP_DecisionSet
-
The decision that can lead to the optimal cost.
- best_decision - Variable in class entities.trees.TDP_DecisionSet
-
The decision that can lead to the optimal cost.
- Binary_Partitioning - Class in factorization
-
Contains methods for efficiently representing (or factorizing) the query results of a join between 2 relations
where the join condition is a conjunction of equalities/inequalities/non-equalities/bands.
- Binary_Partitioning() - Constructor for class factorization.Binary_Partitioning
-
- binary_search_max(List<DP_State_Node>, int, double, boolean) - Static method in class util.Common
-
Binary search for the maximum element that is less than a max value
on a stage of DP that corresponds to the tuples of a relation
(i.e., @link{entities.paths.DP_State_Node#state_info} is @link{entities.Tuple}).
- binary_search_min(List<DP_State_Node>, int, double, boolean) - Static method in class util.Common
-
Binary search for the minimum element that is greater than a min value
on a stage of DP that corresponds to the tuples of a relation
(i.e., @link{entities.paths.DP_State_Node#state_info} is @link{entities.Tuple}).
- BinaryRandomPattern - Class in data
-
- BinaryRandomPattern(int, int, int, String) - Constructor for class data.BinaryRandomPattern
-
- BinaryStar_Equijoin - Class in experiments
-
This class provides a main function that receives execution parameters from the command line
and runs experiments for equi-join queries where the joined relations are binary and organized in a star.
- BinaryStar_Equijoin() - Constructor for class experiments.BinaryStar_Equijoin
-
- boolean_query() - Method in class entities.paths.Path_Equijoin_Query
-
Returns whether there is any valid solution at all.
- bottom_up() - Method in class entities.paths.DP_Problem_Instance
-
Goes through all states from the last stage to the first stage,
while computing the minimum achievable cost and the best decision per state.
- bottom_up() - Method in class entities.trees.TDP_BinaryStar_Equijoin_Instance
-
- bottom_up() - Method in class entities.trees.TDP_Problem_Instance
-
The bottom-up phase of T-DP creates a T-DP state/node for each tuple.
- bottom_up() - Method in class entities.trees.TDP_Star_Equijoin_Instance
-
- bottom_up_compute(List<DP_State_Node>) - Method in class entities.paths.DP_Problem_Instance
-
Given a topological order of the nodes s.t.
- bottom_up_implementation - Variable in class entities.paths.DP_Problem_Instance
-
Can be "recursive" or "iterative".
- bottom_up_iter() - Method in class entities.paths.DP_Problem_Instance
-
Iterative implementation of bottom-up phase.
- bottom_up_rec() - Method in class entities.paths.DP_Problem_Instance
-
Recursive implementation of bottom-up phase.
- branch_index - Variable in class entities.trees.TDP_Problem_Instance
-
An auxiliary data structure that stores the index of a stage as a branch from its parent
For example stage 2 could have 3 children stages: 5, 6, 7.
- branches_opt_cost - Variable in class entities.trees.TDP_State_Node
-
A list of minimum achievable costs, one for each branch.
- carry_through_join(List<Relation>) - Method in class algorithms.cycles.SimpleCycle_Anyk_Iterator
-
Instantiates a particular tree decomposition of the cycle as a new query.
- cartesian_product(int, List<Tuple>) - Method in class algorithms.cycles.NPRR
-
Performs a for loop for each relation in the Cartesian Product.
- cartesian_start - Variable in class algorithms.cycles.NPRR
-
Indexes on the relations that indicate which ones we use for cartesian product and which ones for filtering.
- Common - Class in util
-
This class contains static methods that are generally useful and may be used by multiple other classes.
- Common() - Constructor for class util.Common
-
- compareAgainst(DP_Solution) - Method in class entities.paths.DP_Solution
-
Two solutions are compared according to their cost.
- compareTo(DP_Decision) - Method in class entities.paths.DP_Decision
-
Two decisions from the same parent state are compared according to the minimum achievable cost
starting from the parent and (as a first step) taking each decision.
- compareTo(DP_Prefix_Solution) - Method in class entities.paths.DP_Prefix_Solution
-
Two prefix solutions are compared according to the cost that they will have when fully expanded.
- compareTo(DP_Suffix_Solution) - Method in class entities.paths.DP_Suffix_Solution
-
- compareTo(Path_Query_Solution) - Method in class entities.paths.Path_Query_Solution
-
- compareTo(TDP_Decision) - Method in class entities.trees.TDP_Decision
-
Two decisions from the same parent state are compared according to the minimum achievable cost
starting from the parent and (as a first step) taking each decision.
- compareTo(TDP_Prefix_Solution) - Method in class entities.trees.TDP_Prefix_Solution
-
Two prefix solutions are compared according to the cost that they will have when fully expanded.
- compareTo(TDP_Subtree_Solution) - Method in class entities.trees.TDP_Subtree_Solution
-
- compareTo(Tree_Query_Solution) - Method in class entities.trees.Tree_Query_Solution
-
- compareTo(Tuple) - Method in class entities.Tuple
-
A tuple is compared with another according to their associated cost
- compute_no_solutions(DP_State_Node, Map<DP_State_Node, BigInteger>) - Method in class entities.paths.DP_Problem_Instance
-
Recursively computes the total number of solutions starting from some specific node.
- compute_opt_cost(DP_State_Node) - Method in class entities.paths.DP_Problem_Instance
-
Recursively computes the optimal achievable cost starting from some specific node.
- concatenate_double_arrays(double[], double[]) - Static method in class util.Common
-
- concatenate_int_arrays(int[], int[]) - Static method in class util.Common
-
- concatenate_string_arrays(String[], String[]) - Static method in class util.Common
-
- conf - Variable in class algorithms.paths.DP_Anyk_Iterator
-
The DP problem to run any-k on.
- Configuration - Class in algorithms
-
This class contains parameters that configure the execution of any-k algorithms.
- Configuration() - Constructor for class algorithms.Configuration
-
- cost - Variable in class entities.paths.DP_Decision
-
The cost incurred immediately by this decision.
- cost - Variable in class entities.paths.DP_Solution
-
The associated cost of the solution.
- cost - Variable in class entities.trees.TDP_Decision
-
The cost incurred immediately by this decision.
- cost - Variable in class entities.trees.TDP_Solution
-
The associated cost of the solution.
- cost - Variable in class entities.trees.TDP_Subtree_Collection
-
The total cost of the solutions in the collection.
- cost - Variable in class entities.Tuple
-
- count_distinct_vals(List<DP_State_Node>, List<DP_State_Node>, int, int, double) - Static method in class util.Common
-
Given two stages of DP that correspond to relations,
counts the number of distinct values of the tuples.
- count_solutions() - Method in class entities.paths.DP_Problem_Instance
-
Computes the total number of DP solutions to the problem instance.
- create() - Method in class data.Database_Query_Generator
-
Creates the database.
- create_successor(DP_Decision) - Method in class entities.paths.DP_Prefix_Solution
-
A successor solution has the same length but replaces the last decision with an alternative
- create_successor(TDP_Decision) - Method in class entities.trees.TDP_Prefix_Solution
-
A successor solution has the same length but replaces the last decision with an alternative.
- create_successor(TDP_Subtree_Solution) - Method in class entities.trees.TDP_Subtree_Collection
-
A successor solution has the same size but replaces the last solution with an alternative.
- createSublist(double[], int[]) - Static method in class util.Common
-
Given an array of doubles, returns only the elements located at the specified indices.
- createSublist(int[], int[]) - Static method in class util.Common
-
Given an array of integers, returns only the elements located at the specified indices.
- current_index - Variable in class algorithms.cycles.NPRR
-
Index of last output tuple enumerated.
- current_index - Variable in class algorithms.paths.Path_Batch
-
- current_index - Variable in class algorithms.trees.Tree_Batch
-
- cyc_length - Variable in class algorithms.cycles.NPRR
-
The length of the cycle.
- cyc_length - Variable in class algorithms.cycles.SimpleCycle_Anyk_Iterator
-
The length of the cycle.
- Cycle_HeavyLightPattern - Class in data
-
A subclass of the data generator @link data.Database_Query_Generator} for simple cycle queries.
- Cycle_HeavyLightPattern(int, int) - Constructor for class data.Cycle_HeavyLightPattern
-
- data - package data
-
- database - Variable in class data.Database_Query_Generator
-
The generated database as a list of relations.
- Database_Query_Generator - Class in data
-
Abstract class for a synthetic data generator.
- Database_Query_Generator(int, int) - Constructor for class data.Database_Query_Generator
-
Constructor for when all the relations have the same size n.
- Database_Query_Generator(List<Integer>, int) - Constructor for class data.Database_Query_Generator
-
Constructor that allows for a different size per relation.
- DatabaseParser - Class in util
-
A class that reads a database as a list of relations from an input file.
- DatabaseParser(Integer) - Constructor for class util.DatabaseParser
-
- decision_set - Variable in class entities.paths.DP_Decision
-
The set of decisions that this decision belongs to.
- decision_set - Variable in class entities.trees.TDP_Decision
-
The set of decisions that this decision belongs to.
- decisions - Variable in class entities.paths.DP_State_Node
-
All the decisions that can be made at this state.
- decisions - Variable in class entities.trees.TDP_State_Node
-
All the decisions (edges) that can be made from this state, one set for each branch.
- decompose_heavy_light() - Method in class algorithms.cycles.SimpleCycle_Anyk_Iterator
-
Decomposes the cyclic query into a union of acyclic queries.
- DFS(DP_State_Node, LinkedList<Tuple>) - Method in class algorithms.paths.Path_Batch
-
- DFS(TDP_State_Node, LinkedList<TDP_State_Node>) - Method in class algorithms.trees.Tree_Batch
-
- domain - Variable in class data.BinaryRandomPattern
-
The size of the domain of the attributes.
- DP_All - Class in algorithms.paths
-
- DP_All(DP_Problem_Instance, Configuration) - Constructor for class algorithms.paths.DP_All
-
- DP_Anyk_Iterator - Class in algorithms.paths
-
- DP_Anyk_Iterator(DP_Problem_Instance, Configuration) - Constructor for class algorithms.paths.DP_Anyk_Iterator
-
- DP_Decision - Class in entities.paths
-
A DP decision that corresponds to an edge in the multi-stage graph.
- DP_Decision(DP_State_Node, double, DP_DecisionSet) - Constructor for class entities.paths.DP_Decision
-
Instantiates a new decision with a given cost.
- DP_DecisionSet - Class in entities.paths
-
Class that represents a set of decisions (outgoing edges in the DP graph), each one leading to a different target.
- DP_DecisionSet() - Constructor for class entities.paths.DP_DecisionSet
-
- DP_Eager - Class in algorithms.paths
-
- DP_Eager(DP_Problem_Instance, Configuration) - Constructor for class algorithms.paths.DP_Eager
-
- DP_Lazy - Class in algorithms.paths
-
- DP_Lazy(DP_Problem_Instance, Configuration) - Constructor for class algorithms.paths.DP_Lazy
-
- DP_Part - Class in algorithms.paths
-
Implementation of Anyk-Part for DP, a ranked enumeration algorithm that relies on the Lawler procedure.
- DP_Part(DP_Problem_Instance, Configuration) - Constructor for class algorithms.paths.DP_Part
-
- DP_Path_Equijoin_Instance - Class in entities.paths
-
A class for DP problems that are equi-join path queries.
- DP_Path_Equijoin_Instance(Path_Equijoin_Query) - Constructor for class entities.paths.DP_Path_Equijoin_Instance
-
For each tuple, we create a DP state.
- DP_Path_ThetaJoin_Instance - Class in entities.paths
-
A class for DP problems that are theta-join path queries.
- DP_Path_ThetaJoin_Instance(Path_ThetaJoin_Query, String) - Constructor for class entities.paths.DP_Path_ThetaJoin_Instance
-
For each tuple, we create a DP state.
- DP_Prefix_Solution - Class in entities.paths
-
A prefix representation of DP solutions that allows for sharing common prefixes.
- DP_Prefix_Solution(DP_Decision) - Constructor for class entities.paths.DP_Prefix_Solution
-
Constructor for initializing a prefix solution of length 1.
- DP_Prefix_Solution(DP_Prefix_Solution, DP_Decision) - Constructor for class entities.paths.DP_Prefix_Solution
-
Constructor that instantiates a prefix solution of length greater than 1
from another prefix solution concatenated with one more decision.
- DP_Problem_Instance - Class in entities.paths
-
An instance of a DP problem realized as a multi-stage graph of state-nodes
where the stages are organized in a path (chain).
- DP_Problem_Instance() - Constructor for class entities.paths.DP_Problem_Instance
-
Creates a new problem instance by constructing all states from the last stage to the first stage.
- DP_Quick - Class in algorithms.paths
-
- DP_Quick(DP_Problem_Instance, Configuration) - Constructor for class algorithms.paths.DP_Quick
-
- DP_Recursive - Class in algorithms.paths
-
Implementation of Anyk-Rec for DP, a ranked enumeration algorithm that relies
on recursion: a node finds the next best solution by
recursively finding the next best solutions of its children.
Brief description of the algorithm:
Each node maintains a priority queue
DP_DecisionSet.pq_rec
with the current candidates for the next best suffix solution
(from the current node to the terminal).
- DP_Recursive(DP_Problem_Instance, Configuration) - Constructor for class algorithms.paths.DP_Recursive
-
- DP_Solution - Class in entities.paths
-
A solution to a DP problem is a path from the source node to the terminal node in the state-space graph.
- DP_Solution() - Constructor for class entities.paths.DP_Solution
-
- DP_Solution_Iterator - Class in algorithms.paths
-
- DP_Solution_Iterator(DP_Problem_Instance) - Constructor for class algorithms.paths.DP_Solution_Iterator
-
- DP_State_Node - Class in entities.paths
-
- DP_State_Node(Object) - Constructor for class entities.paths.DP_State_Node
-
Creates a new DP state.
- DP_Suffix_Solution - Class in entities.paths
-
A suffix representation of DP solutions that allows for sharing common suffixes.
- DP_Suffix_Solution(DP_Decision) - Constructor for class entities.paths.DP_Suffix_Solution
-
Constructor for initializing a suffix solution of length 1.
- DP_Suffix_Solution(DP_Suffix_Solution, DP_Decision) - Constructor for class entities.paths.DP_Suffix_Solution
-
Instantiates a suffix solution of length greater than 1
from another suffix solution concatenated with one more decision.
- DP_Take2 - Class in algorithms.paths
-
- DP_Take2(DP_Problem_Instance, Configuration) - Constructor for class algorithms.paths.DP_Take2
-
- dummy_counter - Variable in class util.Measurements
-
This counter adds up the result values.
- factorization - package factorization
-
- factorize_band(List<DP_State_Node>, List<DP_State_Node>, List<Join_Predicate>) - Static method in class factorization.Multiway_Partitioning
-
Given two DP stages that correspond to the tuples of two relations
and a list that contains many equalities and a single band,
constructs an efficient representation of the join results.
- factorize_conjunction(List<DP_State_Node>, List<DP_State_Node>, List<Join_Predicate>) - Static method in class factorization.Binary_Partitioning
-
Given two DP stages that correspond to the tuples of two relations
and a list that contains a conjunction of join conditions,
constructs an efficient representation of the join results.
- factorize_equality(List<DP_State_Node>, List<DP_State_Node>, List<Join_Predicate>) - Static method in class factorization.Equality
-
Given two DP stages that correspond to the tuples of two relations
and a list of equality join conditions,
constructs an efficient representation of the join results.
- factorize_inequality(List<DP_State_Node>, List<DP_State_Node>, List<Join_Predicate>) - Static method in class factorization.Multiway_Partitioning
-
Given two DP stages that correspond to the tuples of two relations
and a list that contains many equalities and a single inequality,
constructs an efficient representation of the join results.
- factorize_inequality(List<DP_State_Node>, List<DP_State_Node>, List<Join_Predicate>) - Static method in class factorization.Shared_Ranges
-
Given two DP stages that correspond to the tuples of two relations
and a list that contains many equalities and a single inequality,
constructs an efficient representation of the join results.
- factorize_next_condition(List<DP_State_Node>, List<DP_State_Node>, List<Join_Predicate>) - Static method in class factorization.Binary_Partitioning
-
Performs flow control by choosing the appropriate method according to the predicate.
- factorize_nonequality(List<DP_State_Node>, List<DP_State_Node>, List<Join_Predicate>) - Static method in class factorization.Multiway_Partitioning
-
Given two DP stages that correspond to the tuples of two relations
and a list that contains many equalities and a single non-equality,
constructs an efficient representation of the join results.
- filter(int, List<Tuple>, double) - Method in class algorithms.cycles.NPRR
-
Given a list of tuples from the Cartesian Product of half the relations,
this recursive function filters the result against the other half.
- filter_start - Variable in class algorithms.cycles.NPRR
-
Indexes on the relations that indicate which ones we use for cartesian product and which ones for filtering.
- find_all_solutions() - Method in class algorithms.paths.Path_Batch
-
- find_all_solutions() - Method in class algorithms.trees.Tree_Batch
-
- find_next_recursive(DP_Suffix_Solution) - Method in class algorithms.paths.DP_Recursive
-
Determines the next best suffix solution that starts from a node recursively.
- find_next_recursive(TDP_Subtree_Solution) - Method in class algorithms.trees.TDP_Recursive
-
Determines the next best subtree solution that starts from a node recursively.
- first_decision - Variable in class entities.paths.DP_Suffix_Solution
-
The first decision contained in the solution.
- flat_format() - Method in class entities.Tuple
-
- future_cost - Variable in class entities.paths.DP_Prefix_Solution
-
The cost of the prefix if it is expanded optimally to a full solution.
- future_cost - Variable in class entities.trees.TDP_Prefix_Solution
-
The cost of the prefix if it is expanded optimally to a full solution.
- get(int) - Method in class entities.Relation
-
- get_alg() - Method in class algorithms.cycles.SimpleCycle_Anyk_Iterator
-
- get_best_child() - Method in class entities.paths.DP_State_Node
-
Returns the best child (state-node) we can hop to from the current state-node.
- get_best_child(int) - Method in class entities.trees.TDP_State_Node
-
Returns the best child (state-node) in a specific branch we can hop to from the current state-node.
- get_best_children() - Method in class entities.trees.TDP_State_Node
-
Returns the best children (state-nodes) from all branches we can hop to from the current state-node.
- get_best_decision() - Method in class entities.paths.DP_State_Node
-
- get_best_decision(int) - Method in class entities.trees.TDP_State_Node
-
Returns the best available decision from this state for a particular branch.
- get_best_subtree_solution(TDP_State_Node, int) - Method in class algorithms.trees.TDP_Recursive
-
Computes the best subtree solution starting from a node for one particular branch.
- get_best_subtree_solutions(TDP_State_Node) - Method in class algorithms.trees.TDP_Recursive
-
Computes a collection of the best subtree solutions starting from a node,
one for each of its branches.
- get_best_suffix_solution(DP_State_Node) - Method in class algorithms.paths.DP_Recursive
-
Computes the best suffix solution that starts from a node
- get_branch_index(int) - Method in class entities.trees.TDP_Problem_Instance
-
- get_children() - Method in class entities.paths.DP_State_Node
-
CAUTION: expensive because it allocates a new list.
- get_children_no(int) - Method in class entities.trees.TDP_Problem_Instance
-
- get_children_of_one_branch(int) - Method in class entities.trees.TDP_State_Node
-
CAUTION: expensive because it allocates a new list.
- get_children_stages(int) - Method in class entities.trees.TDP_Problem_Instance
-
- get_cost() - Method in class entities.paths.DP_Solution
-
- get_cost() - Method in class entities.trees.TDP_Solution
-
- get_cost() - Method in class entities.Tuple
-
- get_database() - Method in class data.Database_Query_Generator
-
Returns the database as a list of relations
- get_decision_cost(DP_State_Node) - Method in class entities.paths.DP_State_Node
-
CAUTION: expensive operation, use only for debugging.
- get_decision_cost(TDP_State_Node, int) - Method in class entities.trees.TDP_State_Node
-
CAUTION: expensive operation, use only for debugging.
- get_decisions() - Method in class entities.paths.DP_State_Node
-
- get_decisions(int) - Method in class entities.trees.TDP_State_Node
-
Returns the decisions that can be taken from this state for a particular branch
(that can lead to leaf stage nodes).
- get_first_decision() - Method in class entities.paths.DP_Suffix_Solution
-
- get_future_cost() - Method in class entities.trees.TDP_Prefix_Solution
-
- get_latest_decision() - Method in class entities.paths.DP_Prefix_Solution
-
- get_latest_decision() - Method in class entities.trees.TDP_Prefix_Solution
-
- get_memory() - Method in class util.Measurements
-
Helper function that records the state of the memory.
- get_name() - Method in class algorithms.paths.DP_Anyk_Iterator
-
- get_name() - Method in class algorithms.trees.TDP_Anyk_Iterator
-
- get_next() - Method in class algorithms.cycles.NPRR
-
- get_next() - Method in class algorithms.cycles.SimpleCycle_Anyk_Iterator
-
- get_next() - Method in class algorithms.paths.DP_Anyk_Iterator
-
- get_next() - Method in class algorithms.paths.DP_Part
-
- get_next() - Method in class algorithms.paths.DP_Recursive
-
- get_next() - Method in class algorithms.paths.DP_Solution_Iterator
-
- get_next() - Method in class algorithms.paths.Path_Batch
-
- get_next() - Method in class algorithms.paths.Path_BatchHeap
-
- get_next() - Method in class algorithms.paths.Path_BatchSorting
-
- get_next() - Method in class algorithms.trees.TDP_Anyk_Iterator
-
- get_next() - Method in class algorithms.trees.TDP_Part
-
- get_next() - Method in class algorithms.trees.TDP_Recursive
-
- get_next() - Method in class algorithms.trees.Tree_Batch
-
- get_next_iqs(DP_DecisionSet) - Method in class algorithms.paths.DP_Quick
-
Implementation of the core method of IQS for incremental sorting.
- get_number_of_children() - Method in class entities.paths.DP_State_Node
-
- get_opt_cost() - Method in class entities.paths.DP_Decision
-
- get_opt_cost() - Method in class entities.paths.DP_State_Node
-
- get_parent_decision() - Method in class entities.trees.TDP_Subtree_Solution
-
- get_parent_stage(int) - Method in class entities.trees.TDP_Problem_Instance
-
Returns the parent stage of a particular stage
- get_shorter() - Method in class entities.paths.DP_Prefix_Solution
-
- get_shorter() - Method in class entities.paths.DP_Suffix_Solution
-
- get_shorter() - Method in class entities.trees.TDP_Prefix_Solution
-
- get_shorter_subtree_collection() - Method in class entities.trees.TDP_Subtree_Solution
-
- get_shorter_subtree_solutions() - Method in class entities.trees.TDP_Subtree_Solution
-
- get_size() - Method in class entities.Relation
-
- get_solutions() - Method in class entities.trees.TDP_Subtree_Collection
-
Returns a list of all the solutions in this collection by traversing the pointers to prefixes.
- get_subtree_opt_cost() - Method in class entities.trees.TDP_State_Node
-
Returns the minimum achievable cost starting from this state.
- get_successors(DP_Decision) - Method in class algorithms.paths.DP_All
-
- get_successors(DP_Decision) - Method in class algorithms.paths.DP_Eager
-
- get_successors(DP_Decision) - Method in class algorithms.paths.DP_Lazy
-
- get_successors(DP_Decision) - Method in class algorithms.paths.DP_Part
-
Find the successors of a given decision among the other decisions in the
DP_DecisionSet
.
- get_successors(DP_Decision) - Method in class algorithms.paths.DP_Quick
-
- get_successors(DP_Decision) - Method in class algorithms.paths.DP_Solution_Iterator
-
Find the successor of a given decision among the other decisions in the
DP_DecisionSet
.
- get_successors(DP_Decision) - Method in class algorithms.paths.DP_Take2
-
- get_successors(TDP_Decision) - Method in class algorithms.trees.TDP_All
-
- get_successors(TDP_Decision) - Method in class algorithms.trees.TDP_Eager
-
- get_successors(TDP_Decision) - Method in class algorithms.trees.TDP_Lazy
-
- get_successors(TDP_Decision) - Method in class algorithms.trees.TDP_Part
-
Find the successors of a given decision among the other decisions in the
TDP_DecisionSet
.
- get_successors(TDP_Decision) - Method in class algorithms.trees.TDP_Take2
-
- get_tuple_weight(String, int, int) - Method in class data.Database_Query_Generator
-
Returns the weight of the tuple according to the weight distribution specified
- get_uniform_tuple_weight() - Method in class data.Database_Query_Generator
-
Returns a random number in a specific range (uniform distribution)
Used whenever tuple costs are generated uniformly at random
Hardcoded maximum cost = 10,000
- getName() - Static method in class algorithms.paths.DP_Anyk_Iterator
-
- getName() - Static method in class algorithms.paths.DP_Solution_Iterator
-
- getName() - Static method in class algorithms.trees.TDP_Anyk_Iterator
-
- getName() - Static method in class data.Database_Query_Generator
-
Utility method for help messages.
- getName() - Static method in class experiments.BinaryStar_Equijoin
-
Utility method for help messages.
- getName() - Static method in class experiments.Path_Equijoin
-
Utility method for help messages.
- getName() - Static method in class experiments.Path_Inequalities
-
Utility method for help messages.
- getName() - Static method in class experiments.Path_Inequalities_Disjunction
-
Utility method for help messages.
- getName() - Static method in class experiments.SimpleCycle_Equijoin
-
Utility method for help messages.
- global_pq - Variable in class algorithms.paths.DP_Part
-
Maintains all the prefix solutions that are candidates for the next best solution.
- global_pq - Variable in class algorithms.trees.TDP_Part
-
Maintains all the prefix solutions that are candidates for the next best solution.
- global_q - Variable in class algorithms.paths.DP_Solution_Iterator
-
Maintains all the prefix solutions that are not yet expanded.
- graph_size() - Method in class entities.paths.DP_Problem_Instance
-
Computes the total size of the DP state graph as the sum of nodes (states) and edges (decisions) with a DFS traversal.
- initialization_laziness - Variable in class algorithms.Configuration
-
Used to specify whether the any-k algorithms initialize their data structures lazily
(i.e., the first time they are accessed).
- initialize_data_structures() - Method in class algorithms.paths.DP_Part
-
Initializes the data structures needed for all nodes.
- initialize_iterator(DP_Problem_Instance) - Method in class algorithms.cycles.SimpleCycle_Anyk_Iterator
-
- initialize_partial_order(DP_DecisionSet) - Method in class algorithms.paths.DP_All
-
- initialize_partial_order(DP_DecisionSet) - Method in class algorithms.paths.DP_Eager
-
- initialize_partial_order(DP_DecisionSet) - Method in class algorithms.paths.DP_Lazy
-
- initialize_partial_order(DP_DecisionSet) - Method in class algorithms.paths.DP_Part
-
Initialization of the data structures needed at each DP_DesicionSet
in order to compute a partial order among decisions.
- initialize_partial_order(DP_DecisionSet) - Method in class algorithms.paths.DP_Quick
-
- initialize_partial_order(DP_DecisionSet) - Method in class algorithms.paths.DP_Solution_Iterator
-
Initialization of the data structures needed at each DP_DesicionSet
in order to compute a (total) order among decisions.
- initialize_partial_order(DP_DecisionSet) - Method in class algorithms.paths.DP_Take2
-
- initialize_partial_order(TDP_DecisionSet) - Method in class algorithms.trees.TDP_All
-
- initialize_partial_order(TDP_DecisionSet) - Method in class algorithms.trees.TDP_Eager
-
- initialize_partial_order(TDP_DecisionSet) - Method in class algorithms.trees.TDP_Lazy
-
- initialize_partial_order(TDP_DecisionSet) - Method in class algorithms.trees.TDP_Part
-
Initialization of the data structures needed at each TDP_DesicionSet
in order to compute a partial order among decisions.
- initialize_partial_order(TDP_DecisionSet) - Method in class algorithms.trees.TDP_Take2
-
- initialize_pq(DP_DecisionSet) - Method in class algorithms.paths.DP_Recursive
-
Initializes the data strucures that the algorithm needs.
- initialize_pq(TDP_DecisionSet) - Method in class algorithms.trees.TDP_Recursive
-
Initializes the data strucures that the algorithm needs.
- input_relations - Variable in class algorithms.cycles.SimpleCycle_Anyk_Iterator
-
The relations that form the cycle.
- insert(Relation) - Method in class entities.paths.Path_Equijoin_Query
-
Inserts a relation to the path (on the right).
- insert(Tuple) - Method in class entities.Relation
-
- insert(Relation) - Method in class entities.trees.Star_Equijoin_Query
-
Inserts a relation to the star.
- insert_wConjunction(Relation, List<Join_Predicate>) - Method in class entities.paths.Path_ThetaJoin_Query
-
Inserts a relation to the path (on the right) with a conjunction as the join condition.
- insert_wDNF(Relation, List<List<Join_Predicate>>) - Method in class entities.paths.Path_ThetaJoin_Query
-
Inserts a relation to the path (on the right) with a DNF as the join condition.
- insertAll(Collection<Tuple>) - Method in class entities.Relation
-
- instance - Variable in class algorithms.paths.DP_Anyk_Iterator
-
The DP problem to run any-k on.
- instance - Variable in class algorithms.paths.DP_Solution_Iterator
-
The DP problem to run any-k on.
- instance - Variable in class algorithms.trees.TDP_Anyk_Iterator
-
The T-DP problem to run any-k on.
- int_range(int, int) - Static method in class util.Common
-
- is_terminal() - Method in class entities.paths.DP_State_Node
-
- parameter - Variable in class entities.Join_Predicate
-
Specifies the epsilon parameter.
- parent_decision - Variable in class entities.trees.TDP_Subtree_Solution
-
The first decision contained in the solution.
- parents - Variable in class entities.trees.TDP_Problem_Instance
-
An auxiliary data structure that encodes the tree with reverse edges,
i.e., it gives us the parent of each stage (its index).
- parse_file(String) - Method in class util.DatabaseParser
-
Given the path of an input file as a string, returns a database as a list of relations.
- parse_file(InputStream) - Method in class util.DatabaseParser
-
Given an input stream, returns a database as a list of relations.
- parse_file(File) - Method in class util.DatabaseParser
-
Given a file object, returns a database as a list of relations.
- parse_file(BufferedReader) - Method in class util.DatabaseParser
-
Given a buffered reader object, returns a database as a list of relations.
- partial_order_computed - Variable in class entities.paths.DP_DecisionSet
-
For Anyk-Part variants: flag is set to true when we are done computing successors for this set of decisions.
- partial_order_computed - Variable in class entities.trees.TDP_DecisionSet
-
For Anyk-Part variants: flag is set to true when we are done computing successors for this set of decisions.
- partition(List<DP_Decision>, int, int, int) - Method in class algorithms.paths.DP_Quick
-
- partition_inequality_rec(List<DP_State_Node>, List<DP_State_Node>, Join_Predicate, List<Join_Predicate>) - Static method in class factorization.Binary_Partitioning
-
A recursive method for encoding the query results of an inequality join.
- partition_inequality_rec(List<DP_State_Node>, List<DP_State_Node>, Join_Predicate) - Static method in class factorization.Multiway_Partitioning
-
A recursive method for encoding the query results of an inequality join.
- Path_Batch - Class in algorithms.paths
-
This algorithm produces all the solutions to a DP problem specified
as a
DP_Problem_Instance
object.
- Path_Batch(DP_Problem_Instance, Configuration) - Constructor for class algorithms.paths.Path_Batch
-
- Path_Batch(Path_Batch) - Constructor for class algorithms.paths.Path_Batch
-
- Path_BatchHeap - Class in algorithms.paths
-
This algorithm produces all the solutions to a DP problem specified
as a
DP_Problem_Instance
object and then puts them into a PQ (heap)
so that it can return them in ranked order.
- Path_BatchHeap(DP_Problem_Instance, Configuration) - Constructor for class algorithms.paths.Path_BatchHeap
-
- Path_BatchHeap(Path_Batch) - Constructor for class algorithms.paths.Path_BatchHeap
-
- Path_BatchSorting - Class in algorithms.paths
-
This algorithm produces all the solutions to a DP problem specified
as a
DP_Problem_Instance
object and then sorts them
so that it can return them in ranked order.
- Path_BatchSorting(DP_Problem_Instance, Configuration) - Constructor for class algorithms.paths.Path_BatchSorting
-
- Path_BatchSorting(Path_Batch) - Constructor for class algorithms.paths.Path_BatchSorting
-
- Path_Equijoin - Class in experiments
-
This class provides a main function that receives execution parameters from the command line
and runs experiments for equi-join queries where the joined relations are organized in a path.
- Path_Equijoin() - Constructor for class experiments.Path_Equijoin
-
- Path_Equijoin_Query - Class in entities.paths
-
An equi-join query where the relational atoms are organized in a path.
- Path_Equijoin_Query(Relation) - Constructor for class entities.paths.Path_Equijoin_Query
-
A path query initialized with a single relation.
- Path_Equijoin_Query(Collection<Relation>) - Constructor for class entities.paths.Path_Equijoin_Query
-
A path query initialized with a collection of relations.
- Path_Equijoin_Query() - Constructor for class entities.paths.Path_Equijoin_Query
-
Returns a small example for debugging purposes.
- Path_Inequalities - Class in experiments
-
This class provides a main function that receives execution parameters from the command line
and runs experiments for join queries with inequalities (without disjunctions)
where the joined relations are organized in a path.
- Path_Inequalities() - Constructor for class experiments.Path_Inequalities
-
- Path_Inequalities_Disjunction - Class in experiments
-
This class provides a main function that receives execution parameters from the command line
and runs experiments for join queries with inequalities (that include disjunctions)
where the joined relations are organized in a path.
- Path_Inequalities_Disjunction() - Constructor for class experiments.Path_Inequalities_Disjunction
-
- path_query - Variable in class entities.paths.DP_Path_Equijoin_Instance
-
The query that creates the DP problem.
- path_query - Variable in class entities.paths.DP_Path_ThetaJoin_Instance
-
The query that creates the DP problem.
- Path_Query_Solution - Class in entities.paths
-
A DP solution for problems that are equi-join path queries.
- Path_Query_Solution(List<Tuple>) - Constructor for class entities.paths.Path_Query_Solution
-
- Path_ThetaJoin_Query - Class in entities.paths
-
A theta-join query where the relational atoms are organized in a path.
- Path_ThetaJoin_Query(Relation) - Constructor for class entities.paths.Path_ThetaJoin_Query
-
A path query initialized with a single relation.
- Path_ThetaJoin_Query(Collection<Relation>) - Constructor for class entities.paths.Path_ThetaJoin_Query
-
A path query initialized with a collection of relations.
- Path_ThetaJoin_Query(Path_Equijoin_Query) - Constructor for class entities.paths.Path_ThetaJoin_Query
-
A path query constructed from an existing equi-join query.
- Path_ThetaJoin_Query(int) - Constructor for class entities.paths.Path_ThetaJoin_Query
-
Returns a small example for debugging purposes.
- pivot_stack - Variable in class entities.paths.DP_DecisionSet
-
A stack that stores the indexes of the pivot elements used by
DP_Quick
.
- populate_database() - Method in class data.BinaryRandomPattern
-
- populate_database() - Method in class data.Cycle_HeavyLightPattern
-
- populate_database() - Method in class data.Database_Query_Generator
-
Populates the relations of the database according to a subclass logic.
- pq - Variable in class algorithms.cycles.SimpleCycle_Anyk_Iterator
-
A top-level priority queue that compares the solutions between the different acyclic queries of the decomposition.
- pq_lazysort - Variable in class entities.paths.DP_DecisionSet
-
A priority queue that is used to incrementally sort the set of decisions by
DP_Lazy
.
- pq_lazysort - Variable in class entities.trees.TDP_DecisionSet
-
A priority queue that is used to incrementally sort the set of decisions by
TDP_Lazy
.
- pq_rec - Variable in class entities.paths.DP_DecisionSet
-
- pq_rec - Variable in class entities.trees.TDP_DecisionSet
-
- prefix - Variable in class entities.trees.TDP_Subtree_Collection
-
A prefix containing a subtree collection with @{link #size} - 1 solutions.
- print() - Method in class util.Measurements
-
Prints out (in the standard output) the measurements that have been sampled from the execution.
- print_database() - Method in class data.Database_Query_Generator
-
Prints the database to the specified output stream
- print_edges() - Method in class entities.paths.DP_Problem_Instance
-
Prints the entire constructed graph.
- print_edges() - Method in class entities.trees.TDP_Problem_Instance
-
Use this after the bottom-up phase to print all the feasible decisions between the state nodes.
- print_to_csv() - Method in class util.Measurements
-
Prints out (in the standard output) in csv format
the measurements that have been sampled from the execution.
- printRelation(Relation) - Method in class data.Database_Query_Generator
-
Prints a relation to the specified output stream
- sample_rate - Variable in class util.Measurements
-
The sample rate determines how often the measurements will be recorded and stored.
- satisfied_by(Tuple, Tuple) - Method in class entities.Join_Predicate
-
Tests if two tuples satisfy this predicate.
- schema - Variable in class entities.Relation
-
- set_bottom_up_implementation(String) - Method in class entities.paths.DP_Problem_Instance
-
Chooses how the bottom-up phase will be executed.
- set_heap_type(String) - Method in class algorithms.Configuration
-
- set_initialization_laziness(boolean) - Method in class algorithms.Configuration
-
- set_join_conditions(int[], int[]) - Method in class entities.paths.Path_Equijoin_Query
-
Sets the same join conditions between all the relations in the path.
- set_join_conditions(List<Pair<int[], int[]>>) - Method in class entities.paths.Path_Equijoin_Query
-
Sets the join conditions for the query.
- set_join_conditions_as_conjunction(List<Join_Predicate>) - Method in class entities.paths.Path_ThetaJoin_Query
-
Sets the same join condition between all the relations in the path.
- set_join_conditions_as_dnf(List<List<Join_Predicate>>) - Method in class entities.paths.Path_ThetaJoin_Query
-
Sets the same join condition between all the relations in the path.
- set_name(String) - Method in class algorithms.paths.DP_Anyk_Iterator
-
- set_name(String) - Method in class algorithms.trees.TDP_Anyk_Iterator
-
- set_opt_cost(double) - Method in class entities.paths.DP_State_Node
-
- set_shorter_subtree_collection(TDP_Subtree_Collection) - Method in class entities.trees.TDP_Subtree_Solution
-
Sets the collection of subtree solutions after the parent decision.
- set_to_terminal() - Method in class entities.paths.DP_State_Node
-
Sets the minimum achievable cost from this node to 0.
- set_to_terminal() - Method in class entities.trees.TDP_State_Node
-
Sets the minimum achievable cost from this node to 0.
- setOutputFile(String) - Method in class data.Database_Query_Generator
-
Set the output file that will be created.
- share_decisions(DP_State_Node) - Method in class entities.paths.DP_State_Node
-
Makes this state share the same decisions with another state.
- share_decisions(TDP_State_Node, int) - Method in class entities.trees.TDP_State_Node
-
Makes this state share the same decisions with another state in the specified branch.
- share_inequality(List<DP_State_Node>, List<DP_State_Node>, Join_Predicate) - Static method in class factorization.Shared_Ranges
-
A method for encoding the query results of an inequality join.
- Shared_Ranges - Class in factorization
-
Contains methods for efficiently representing (or factorizing) the query results of a join between 2 relations
where the join condition is an arbitrary number of equalities and a single inequality predicate.
- Shared_Ranges() - Constructor for class factorization.Shared_Ranges
-
- shorter_prefix - Variable in class entities.paths.DP_Prefix_Solution
-
- shorter_prefix - Variable in class entities.trees.TDP_Prefix_Solution
-
- shorter_suffix - Variable in class entities.paths.DP_Suffix_Solution
-
- simple_join(List<Relation>, String) - Method in class algorithms.cycles.SimpleCycle_Anyk_Iterator
-
Performs the join of binary relations in a path.
- SimpleCycle_Anyk_Iterator - Class in algorithms.cycles
-
A ranked enumeration algorithm for a conjunctive query that is a simple cycle of binary relations
specified by a
SimpleCycle_Equijoin_Query
object.
- SimpleCycle_Anyk_Iterator(SimpleCycle_Equijoin_Query, String, String) - Constructor for class algorithms.cycles.SimpleCycle_Anyk_Iterator
-
Inserts a relation to the path (on the right).
- SimpleCycle_Equijoin - Class in experiments
-
This class provides a main function that receives execution parameters from the command line
and runs experiments for equi-join queries where the joined relations are binary and organized in a simple cycle.
- SimpleCycle_Equijoin() - Constructor for class experiments.SimpleCycle_Equijoin
-
- SimpleCycle_Equijoin_Query - Class in entities.cycles
-
An equi-join query where the relational atoms are binary and organized in a cycle.
- SimpleCycle_Equijoin_Query(Relation) - Constructor for class entities.cycles.SimpleCycle_Equijoin_Query
-
A cycle query initialized with a single relation.
- SimpleCycle_Equijoin_Query(Collection<Relation>) - Constructor for class entities.cycles.SimpleCycle_Equijoin_Query
-
A cycle query initialized with a collection of relations.
- SimpleCycle_Equijoin_Query() - Constructor for class entities.cycles.SimpleCycle_Equijoin_Query
-
Returns a small example for debugging purposes.
- size - Variable in class entities.trees.Star_Equijoin_Query
-
The number of relations.
- size - Variable in class entities.trees.TDP_Subtree_Collection
-
The number of solutions in the collection.
- solutionToNodes_strict_order() - Method in class entities.trees.TDP_Prefix_Solution
-
- solutionToString() - Method in class entities.paths.DP_Prefix_Solution
-
- solutionToString() - Method in class entities.paths.DP_Solution
-
- solutionToString() - Method in class entities.paths.DP_Suffix_Solution
-
- solutionToString() - Method in class entities.paths.Path_Query_Solution
-
- solutionToString() - Method in class entities.trees.TDP_Prefix_Solution
-
- solutionToString() - Method in class entities.trees.TDP_Solution
-
- solutionToString() - Method in class entities.trees.TDP_Subtree_Solution
-
Uses a DFS traversal.
- solutionToString() - Method in class entities.trees.Tree_Query_Solution
-
- solutionToTuples() - Method in class entities.paths.DP_Prefix_Solution
-
- solutionToTuples() - Method in class entities.paths.DP_Solution
-
- solutionToTuples() - Method in class entities.paths.DP_Suffix_Solution
-
- solutionToTuples() - Method in class entities.paths.Path_Query_Solution
-
- solutionToTuples() - Method in class entities.trees.TDP_Prefix_Solution
-
- solutionToTuples() - Method in class entities.trees.TDP_Solution
-
- solutionToTuples() - Method in class entities.trees.TDP_Subtree_Solution
-
Uses a DFS traversal.
- solutionToTuples() - Method in class entities.trees.Tree_Query_Solution
-
- solutionToTuples_strict_order() - Method in class entities.paths.DP_Prefix_Solution
-
- solutionToTuples_strict_order() - Method in class entities.paths.DP_Solution
-
- solutionToTuples_strict_order() - Method in class entities.paths.DP_Suffix_Solution
-
- solutionToTuples_strict_order() - Method in class entities.paths.Path_Query_Solution
-
- solutionToTuples_strict_order() - Method in class entities.trees.TDP_Prefix_Solution
-
- solutionToTuples_strict_order() - Method in class entities.trees.TDP_Solution
-
- solutionToTuples_strict_order() - Method in class entities.trees.TDP_Subtree_Solution
-
- solutionToTuples_strict_order() - Method in class entities.trees.Tree_Query_Solution
-
- sort() - Method in class entities.Relation
-
Sorts the tuples in the relation according to their compareTo() method
- sort_results() - Method in class algorithms.paths.Path_Batch
-
Sorts the set of results in ascending cost order.
- sort_stage(List<DP_State_Node>, int) - Static method in class util.Common
-
Sorts the nodes of a stage of DP that corresponds to the tuples of a relation
(i.e., @link{entities.paths.DP_State_Node#state_info} is @link{entities.Tuple}).
- split_by_distinct(List<DP_State_Node>, List<DP_State_Node>, Join_Predicate, int, int) - Static method in class util.Common
-
For 2 stages of DP that correspond to the tuples of relations,
splits the left-right tuples into multiple partitions according to the inequality condition attributes.
- split_by_epsilon(List<DP_State_Node>, int, double) - Static method in class factorization.Band
-
Splits the tuples of a DP stage that corresponds to the tuples of a relations
into groups according to an attribute of a band condition and its epsilon.
- split_by_equality(List<DP_State_Node>, List<DP_State_Node>, List<Join_Predicate>) - Static method in class factorization.Equality
-
Given a list of equality conditions between the attributes of the left-right tuples,
this method partitions the tuples in disjoint components based on equality.
- split_join(List<Relation>) - Method in class algorithms.cycles.SimpleCycle_Anyk_Iterator
-
Instantiates a particular tree decomposition of the cycle as a new query.
- stage - Variable in class entities.trees.TDP_State_Node
-
The stage of T-DP the node belongs to.
- stage_tree - Variable in class entities.trees.TDP_Problem_Instance
-
A data structure (similar to an adjacency list) that stores the tree structure of the problem.
- stages - Variable in class entities.trees.TDP_Problem_Instance
-
The T-DP states are partitioned in stages.
- stages_no - Variable in class algorithms.trees.TDP_Anyk_Iterator
-
The number of stages of the TDP problem (partitions of states organized in a tree).
- stages_no - Variable in class entities.trees.TDP_Problem_Instance
-
The number of stages of the T-DP problem.
- Star_Equijoin_Query - Class in entities.trees
-
An equi-join query where the relational atoms are organized in a star.
- Star_Equijoin_Query(Relation) - Constructor for class entities.trees.Star_Equijoin_Query
-
A star query initialized with a single relation (the center one).
- Star_Equijoin_Query(Collection<Relation>) - Constructor for class entities.trees.Star_Equijoin_Query
-
A star query initialized with a collection of relations.
- Star_Equijoin_Query() - Constructor for class entities.trees.Star_Equijoin_Query
-
Returns a small example for debugging purposes.
- star_query - Variable in class entities.trees.TDP_BinaryStar_Equijoin_Instance
-
The query that creates the T-DP problem.
- star_query - Variable in class entities.trees.TDP_Star_Equijoin_Instance
-
The query that creates the T-DP problem.
- starting_node - Variable in class entities.paths.DP_Problem_Instance
-
Single source (there is also a single target but no need to represent it).
- starting_node - Variable in class entities.trees.TDP_Problem_Instance
-
Single source node located at stage 0.
- startTime - Variable in class util.Measurements
-
- state_info - Variable in class entities.paths.DP_State_Node
-
Holds local information about the state, depends on the DP problem.
- state_info - Variable in class entities.trees.TDP_State_Node
-
Holds local information about the state, depends on the T-DP problem.
- subtree_opt_cost - Variable in class entities.trees.TDP_State_Node
-
The optimal achievable cost starting from this node and traversing its subtree.
- subtrees - Variable in class entities.trees.TDP_Subtree_Solution
-
- successors - Variable in class entities.paths.DP_Decision
-
The successors are decisions in the same stage and from the same parent.
- successors - Variable in class entities.trees.TDP_Decision
-
The successors are decisions in the same stage and from the same parent.
- target - Variable in class entities.paths.DP_Decision
-
The state we end up in by following this decision.
- target - Variable in class entities.trees.TDP_Decision
-
The state we end up in by following this decision.
- TDP_All - Class in algorithms.trees
-
- TDP_All(TDP_Problem_Instance, String) - Constructor for class algorithms.trees.TDP_All
-
- TDP_Anyk_Iterator - Class in algorithms.trees
-
- TDP_Anyk_Iterator(TDP_Problem_Instance) - Constructor for class algorithms.trees.TDP_Anyk_Iterator
-
- TDP_BinaryStar_Equijoin_Instance - Class in entities.trees
-
A class for Τ-DP problems that are equi-join star queries with *binary relations*:
A star query of size l involves one parent relation R1 and l-1 other relations hanging off of it.
- TDP_BinaryStar_Equijoin_Instance(Star_Equijoin_Query) - Constructor for class entities.trees.TDP_BinaryStar_Equijoin_Instance
-
For each tuple, we create a T-DP state.
- TDP_Decision - Class in entities.trees
-
A T-DP decision that corresponds to an edge in the tree-staged graph of T-DP.
- TDP_Decision(TDP_State_Node, double, TDP_DecisionSet) - Constructor for class entities.trees.TDP_Decision
-
Instantiates a new decision with a given cost.
- TDP_DecisionSet - Class in entities.trees
-
Class that represents a set of decisions (edges) in the tree-staged graph of T-DP.
- TDP_DecisionSet() - Constructor for class entities.trees.TDP_DecisionSet
-
- TDP_Eager - Class in algorithms.trees
-
- TDP_Eager(TDP_Problem_Instance, String) - Constructor for class algorithms.trees.TDP_Eager
-
- TDP_Lazy - Class in algorithms.trees
-
- TDP_Lazy(TDP_Problem_Instance, String) - Constructor for class algorithms.trees.TDP_Lazy
-
- TDP_Part - Class in algorithms.trees
-
Implementation of Anyk-Part for T-DP, a ranked enumeration algorithm that relies on the Lawler procedure.
- TDP_Part(TDP_Problem_Instance, String) - Constructor for class algorithms.trees.TDP_Part
-
- TDP_Prefix_Solution - Class in entities.trees
-
A prefix representation of T-DP solutions that allows for sharing common prefixes.
- TDP_Prefix_Solution(TDP_Decision) - Constructor for class entities.trees.TDP_Prefix_Solution
-
Constructor for initializing a prefix solution of length 1.
- TDP_Prefix_Solution(TDP_Prefix_Solution, TDP_Decision, double) - Constructor for class entities.trees.TDP_Prefix_Solution
-
Instantiates a prefix solution from another one by changing only the last decision.
- TDP_Prefix_Solution(TDP_Prefix_Solution, TDP_Decision) - Constructor for class entities.trees.TDP_Prefix_Solution
-
Constructor that instantiates a prefix solution by expanding optimally another one by one stage.
- TDP_Problem_Instance - Class in entities.trees
-
An instance of a T-DP problem realized as a multi-stage graph of state-nodes
where the stages are organized in a tree structure.
- TDP_Problem_Instance(int) - Constructor for class entities.trees.TDP_Problem_Instance
-
- TDP_Recursive - Class in algorithms.trees
-
Implementation of Anyk-Rec for T-DP, a ranked enumeration algorithm that relies
on recursion: a node finds the next best solution by
recursively finding the next best solutions of its children.
Brief description of the algorithm:
Each node maintains a priority queue
TDP_DecisionSet.pq_rec
for each branch of the tree
with the current candidates for the next best subtree solution.
- TDP_Recursive(TDP_Problem_Instance) - Constructor for class algorithms.trees.TDP_Recursive
-
- TDP_Solution - Class in entities.trees
-
A solution to a T-DP problem is a tree from the source node to terminal nodes (one for each leaf stage)
in the state-space graph.
- TDP_Solution() - Constructor for class entities.trees.TDP_Solution
-
- TDP_Star_Equijoin_Instance - Class in entities.trees
-
A class for Τ-DP problems that are equi-join star queries:
A star query of size l involves one parent relation R1 and l-1 other relations hanging off of it.
- TDP_Star_Equijoin_Instance(Star_Equijoin_Query) - Constructor for class entities.trees.TDP_Star_Equijoin_Instance
-
- TDP_State_Node - Class in entities.trees
-
- TDP_State_Node(int, int, Object) - Constructor for class entities.trees.TDP_State_Node
-
Creates a new T-DP state.
- TDP_Subtree_Collection - Class in entities.trees
-
A collection of subtree solutions encoded as one solution plus a pointer to a shorter prefix.
- TDP_Subtree_Collection() - Constructor for class entities.trees.TDP_Subtree_Collection
-
Constructor for an empty collection of solutions.
- TDP_Subtree_Collection(TDP_Subtree_Solution) - Constructor for class entities.trees.TDP_Subtree_Collection
-
Constructor for a collection with only one solution.
- TDP_Subtree_Collection(TDP_Subtree_Collection, TDP_Subtree_Solution) - Constructor for class entities.trees.TDP_Subtree_Collection
-
Constructor that creates a new collection from a prefix concatenated with one more solution.
- TDP_Subtree_Solution - Class in entities.trees
-
A subtree representation of T-DP solutions that allows for sharing common subtrees.
- TDP_Subtree_Solution(TDP_Decision) - Constructor for class entities.trees.TDP_Subtree_Solution
-
Constructor for initializing a subtree solution of size 1.
- TDP_Subtree_Solution(TDP_Decision, TDP_Subtree_Collection) - Constructor for class entities.trees.TDP_Subtree_Solution
-
Instantiates a subtree solution of length greater than 1
from a given decision and the subsequent subtree solutions.
- TDP_Take2 - Class in algorithms.trees
-
- TDP_Take2(TDP_Problem_Instance, String) - Constructor for class algorithms.trees.TDP_Take2
-
- terminal - Variable in class entities.paths.DP_State_Node
-
A flag that indicates whether this node is part of the last stage of DP.
- threshold - Variable in class algorithms.cycles.SimpleCycle_Anyk_Iterator
-
The numerical value used by the decomposition to differentiate between "heavy" and "light".
- time_list - Variable in class util.Measurements
-
For each sampled time point, we record the time.
- to_Quadratic_Equijoin() - Method in class entities.paths.Path_ThetaJoin_Query
-
Transforms the theta-join query to an equivalent equi-join on quadratically larger relations.
- to_Quadratic_Equijoin_with_duplicate_filter() - Method in class entities.paths.Path_ThetaJoin_Query
-
Transforms the theta-join query to an equivalent equi-join on quadratically larger relations.
- topological_order() - Method in class entities.paths.DP_Problem_Instance
-
Produces a topological order of the state space graph.
- toString() - Method in class entities.Join_Predicate
-
- toString() - Method in class entities.paths.DP_Decision
-
Mainly for debugging.
- toString() - Method in class entities.paths.DP_Solution
-
- toString() - Method in class entities.paths.DP_State_Node
-
- toString() - Method in class entities.Relation
-
- toString() - Method in class entities.trees.TDP_Decision
-
Mainly for debugging.
- toString() - Method in class entities.trees.TDP_State_Node
-
- toString() - Method in class entities.Tuple
-
- toTuple() - Method in class entities.paths.DP_State_Node
-
Returns the tuple that is contained inside the node.
- Tree_Batch - Class in algorithms.trees
-
This algorithm produces all the solutions to a T-DP problem specified
as a
TDP_Problem_Instance
object.
- Tree_Batch(TDP_Problem_Instance) - Constructor for class algorithms.trees.Tree_Batch
-
- Tree_BatchSorting - Class in algorithms.trees
-
This algorithm produces all the solutions to a T-DP problem specified
as a
TDP_Problem_Instance
object and then sorts them
so that it can return them in ranked order.
- Tree_BatchSorting(TDP_Problem_Instance) - Constructor for class algorithms.trees.Tree_BatchSorting
-
- Tree_Query_Solution - Class in entities.trees
-
A T-DP solution for problems that are equi-join acyclic (tree) queries.
- Tree_Query_Solution(List<TDP_State_Node>) - Constructor for class entities.trees.Tree_Query_Solution
-
- Tuple - Class in entities
-
A database tuple with some associated cost
The attribute list of the tuple must agree with the schema of the relation it belongs to
- Tuple(double[], double, Relation) - Constructor for class entities.Tuple
-
Constructs a tuple based on a given list of values for the attributes
CAUTION: The object will contain a reference to the passed list of values
No deep copy is made
- Tuple(List<Tuple>, Relation) - Constructor for class entities.Tuple
-
Constructs a new tuple by concatenating a list of other tuples
The cost of the new tuple is an aggregation of the other costs
- tuple_list - Variable in class entities.paths.Path_Query_Solution
-
- tuple_list - Variable in class entities.trees.Tree_Query_Solution
-
- tuples - Variable in class entities.Relation
-
- tuples_no - Variable in class algorithms.cycles.NPRR
-
Size of the output.
- type - Variable in class entities.Join_Predicate
-
The type of the join predicate:
E: Equality of the type A = B + epsilon.
IL: Inequality of the type A < B + epsilon.
IG: Inequality of the type A > B + epsilon.
N: Non-equality of the type A != B + epsilon.<\li>
B: Band of the type |A - B| < epsilon.<\li>


The Hackathon Idea Generator was developed with the purpose of making it easier for groups and individuals to share and discover ideas for new projects. Allows for users to create an account and pin their favorite ideas to their dashboard.
Technologies Used: JQuery, NodeJS, Express, MySQL
Swords and Shields is a 1v1 King of the Hill Style Game. Players are placed into a queue where the first two players in line battle it out to be King. Winner stays, losers goes to the back of the line to wait for another chance.
Technologies Used: ReactJS, NodeJS, Express, SocketIO, MongoDB
Lets Go Biking is an app for bike routing. Plot a start and end point for your ride and a new route will be generated. Lets go Biking also provides current weather information and a list of points of interest along the generated route.
Technologies Used: Jquery, Bootstrap4, HERE API, Open Weather Map


Arrest warrant issued for Connecticut man charged in Anguilla hotel worker's death
by WABCDARIEN, Connecticut (WABC) -- An arrest warrant has been issued in Anguilla for a Connecticut man charged in the death of a hotel worker in the British Caribbean territory.
Scott Hapgood refused to return there for the latest pretrial hearing in the case, saying he feared for his life.
Hapgood's attorney says officials in Anguilla have not assured his client he will be allowed to return to the US while on bond.
Hapgood claims handyman Kenny Mitchel came to the family's hotel room saying he need to fix a sink before pulling out a knife and trying to rob him.
Hapgood says Mitchel was killed in self-defense, but officials in Anguilla are now calling him a fugitive.
A statement by the Attorney General said his claim of concerns about his personal safety and about judicial fairness in Anguilla are "totally groundless."
"Hapgood's decision to abscond will not allow him to evade justice," the statement said.


Home
About
Portfolio
Blog
Contact
CONTACT
Have a question or want to to work together?
Your message has been sent 100%!
✔
First Name should be atleast three charcter*
Last Name should be at least three charcter*
Email address is not well formatted*
message should be at least three words*
SUBMIT
: +250780850611
: +250728812255


This dialog is invoked by the General CRC command. It allows generating of CRCs of the current selection, placing the result into the calculator. You can select from several pre-defined standard CRCs or create and save your own.
The value for Bits select is very important. It determines:
maximum value for Truncated Polynomial, Initial remainder, and Final XOR fields
size of the resultant CRC and hence how good the CRC is at detecting errors
minimum number of bits used in the Calculator in order to display the result
Name
This shows the name of the last selected CRC settings. You can also enter a new name here to save your settings.
Select
Use this list to select one of the pre-defined CRC settings or CRC settings that you have saved..
Bits
Select the size of the CRC from the drop-down list. Valid sizes are currently: 4, 8, 10, 12, 16, and 32. This value determines the size of the result of the CRC calculation and is also one less than the width of the polynomial expressed below.
Truncated Polynomial
A hexadecimal value that represents the truncated polynomial. It does not include the top bit.
Initial Remainder
A hexadecimal value that represents the initial value when before the CRC algorithm is begun. This can be any value but many standard settings use all bits on or off.
Final XOR
This value is XOR'ed with the final output of the CRC calculations..
Reflect Input
This determines the bit order of the inputs. For example, if using an 8-bit CRC and this is off then bit 7 is the MSB (most significant bit). If on then bit 0 is the MSB.
Reflect Remainder
This determines the bit order of the final value (before it is XORed with the Final XOR value).
Save
Use this button to save a set of CRC settings. To use it set the CRC parameters (Bits etc) and then enter a name before clicking the Save button. (The button is not enabled until you enter a unique name.) The name should then appear in the Select list so you can recall it at any time.
Delete
You can delete any of the settings you have saved using the Save button above. To do this select the setting from the Select list and click the Delete button. (The button is not enabled unless the Name field contains the name of a CRC settings that you have previously saved.)
OK
Calculates the CRC value and places the result in the Calculator. The calculator is also set to use Hex mode and if Bits is larger than the Bits setting in the calculator it is increased..


Automatic redirection failed, please go to doc/index.html.
Revised 18 July, 2006
Copyright © 2003-2006 Andreas Huber Dönni
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)


Preparation time
less than 30 mins
Cooking time
30 mins to 1 hour
Serves
Serves 6-8
Dietary
This delicious cake is the perfect way to use up over-ripe bananas, and makes a moreish teatime treat.
Preheat the oven to 170C/150 Fan/Gas 3. Grease a 23cm/9in springform cake tin with butter. Add a tablespoon of flour to the tin and tip the tin this way and that until the base and sides are coated with flour. Shake out any excess flour.
Blend the bananas in a food processor until roughly chopped, then add 75ml/2¾fl oz of the maple syrup and blend to a smooth paste. Pour in up to 50ml/2fl oz of milk and blend again to obtain a smoother consistency, if necessary.
In a large bowl, beat together the butter and sugar until pale and fluffy. Add the eggs one at a time, beating after each addition until each egg is fully incorporated into the mixture.
Add the baking powder, flour, banana purée and three-quarters of the pecan nuts to the bowl. Gently fold the mixture together until just combined.
Spoon the cake mixture into the prepared tin. Bang the base of the tin carefully against the work surface a couple of times to settle the mixture, then sprinkle the remaining chopped pecan nuts over the top of the cake.
Bake for 45-60 minutes, or until the top is golden-brown and a skewer inserted into the centre of the cake comes out clean. Set the cake aside to cool in the tin for 10 minutes, then turn out onto a wire rack and allow to cool completely.
Meanwhile, bring the cream and remaining maple syrup to the boil in a saucepan. Continue to boil for 3-5 minutes, or until the mixture has thickened slightly, then set aside until completely cooled.
Before serving, spread the maple-syrup glaze over the top of the cake, allowing it to drizzle down the sides slightly. Set aside for 10 minutes, then cut into slices and serve.


Manual Symbolication with LLDB
LLDB is separated into a shared library that contains the core of the debugger, and a driver that implements debugging and a command interpreter. LLDB can be used to symbolicate your crash logs and can often provide more information than other symbolication programs:
- Inlined functions
- Variables that are in scope for an address, along with their locations
The simplest form of symbolication is to load an executable:
(lldb) target create --no-dependents --arch x86_64 /tmp/a.out
We use the "--no-dependents" flag with the "target create" command so that we don't load all of the dependent shared libraries from the current system. When we symbolicate, we are often symbolicating a binary that was running on another system, and even though the main executable might reference shared libraries in "/usr/lib", we often don't want to load the versions on the current computer.
Using the "image list" command will show us a list of all shared libraries associated with the current target. As expected, we currently only have a single binary:
(lldb) image list
[ 0] 73431214-6B76-3489-9557-5075F03E36B4 0x0000000100000000 /tmp/a.out
/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out
Now we can look up an address:
(lldb) image lookup --address 0x100000aa3
Address: a.out[0x0000000100000aa3] (a.out.__TEXT.__text + 131)
Summary: a.out`main + 67 at main.c:13
Since we haven't specified a slide or any load addresses for individual sections in the binary, the address that we use here is a file address. A file address refers to a virtual address as defined by each object file.
If we didn't use the "--no-dependents" option with "target create", we would have loaded all dependent shared libraries:
(lldb) image list
[ 0] 73431214-6B76-3489-9557-5075F03E36B4 0x0000000100000000 /tmp/a.out
/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out
[ 1] 8CBCF9B9-EBB7-365E-A3FF-2F3850763C6B 0x0000000000000000 /usr/lib/system/libsystem_c.dylib
[ 2] 62AA0B84-188A-348B-8F9E-3E2DB08DB93C 0x0000000000000000 /usr/lib/system/libsystem_dnssd.dylib
[ 3] C0535565-35D1-31A7-A744-63D9F10F12A4 0x0000000000000000 /usr/lib/system/libsystem_kernel.dylib
...
Now if we do a lookup using a file address, this can result in multiple matches since most shared libraries have a virtual address space that starts at zero:
(lldb) image lookup -a 0x1000
Address: a.out[0x0000000000001000] (a.out.__PAGEZERO + 4096)
Address: libsystem_c.dylib[0x0000000000001000] (libsystem_c.dylib.__TEXT.__text + 928)
Summary: libsystem_c.dylib`mcount + 9
Address: libsystem_dnssd.dylib[0x0000000000001000] (libsystem_dnssd.dylib.__TEXT.__text + 456)
Summary: libsystem_dnssd.dylib`ConvertHeaderBytes + 38
Address: libsystem_kernel.dylib[0x0000000000001000] (libsystem_kernel.dylib.__TEXT.__text + 1116)
Summary: libsystem_kernel.dylib`clock_get_time + 102
...
To avoid getting multiple file address matches, you can specify the name of the shared library to limit the search:
(lldb) image lookup -a 0x1000 a.out
Address: a.out[0x0000000000001000] (a.out.__PAGEZERO + 4096)


{% load dajaxice_templatetags %}
Track the progress of your employees regularly. Make work more efficient by using various metrics to evaluate the work done by your employees! Try out!
PES boasts of it's comprehensive and transparent evaluation system. It generates points for each evaluation and plots in a graph viewable by both students/teachers. It offers a simplistic way of tracking progress on a project.
It's really important to have conducive environment for a project. Intellectually stimulating projects right at the fingertips of users is something that we would like to boast about. We provide instant project details with our search system.
Our internal messaging system help users to communicate about each other's projects without leaving the site. We provide a full fledged messaging platform.


←
Home
About
Subscribe
Boy van Duuren
Programming, automation, infrastructure.
Golang: Vendoring and Interface Confusion
Isues when using a library that vendors dependencies
Serializing Java objects using Golang's gob encoding
Using Golang's gob encoding in Java
A nomad cluster between two AWS EC2 regions
Setting up a small nomad cluster
Population count exercise in GOPL
Counting 1's in Go
Automating my Jekyll updates
Serving Jekyll from docker + auto-updates
Initial commit... errr, post
Initial post


Box 1 content
Box 2 Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s
Box 3 Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book
Box 4 content
Box 5 Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book
Box 6 Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book


by Ajay Yadav
Page Updated on December 29, 2017 at 03:03 PM
Want to contact us for something? Either you have any questions about our website or anything special thing to say you can use the below-given email address to keep in touch with us.
Contact us at<EMAIL_ADDRESS>Note: Give us 48 hours to respond to your query.This website is not an official website for Aadhaar and doesn’t represent any official information.
Information on this website may not be 100% accurate.
Read Disclaimer.


There are special global settings that can change all of the fonts on the chart. These options are in Chart.defaults.font
. The global font settings only apply when more specific options are not included in the config.
For example, in this chart the text will all be red except for the labels in the legend.
Chart.defaults.font.size = 16;
let chart = new Chart(ctx, {
type: "line",
data: data,
options: {
plugins: {
legend: {
labels: {
// This more specific font property overrides the global property
font: {
size: 14,
},
},
},
},
},
});
| Name | Type | Default | Description |
|---|---|---|---|
family |
string |
"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif" |
Default font family for all text, follows CSS font-family options. |
size |
number |
12 |
Default font size (in px) for text. Does not apply to radialLinear scale point labels. |
style |
string |
'normal' |
Default font style. Does not apply to tooltip title or footer. Does not apply to chart title. Follows CSS font-style options (i.e. normal, italic, oblique, initial, inherit). |
weight |
string |
undefined |
Default font weight (boldness). (see MDN). |
lineHeight |
number |string |
1.2 |
Height of an individual line of text (see MDN). |
If a font is specified for a chart that does exist on the system, the browser will not apply the font when it is set. If you notice odd fonts appearing in your charts, check that the font you are applying exists on your system. See issue 3318 for more details.
If a font is not cached and needs to be loaded, charts that use the font will need to be updated once the font is loaded. This can be accomplished using the Font Loading APIs. See issue 8020 for more details.


Bitcoin
.onl
tweets deck
Home
Services
Projects
Two Columns
Three Columns
Project Single
Blog
Blog Masonry
Post Single
Pages
Our Team
Archives
Columns
404 Page
Contact
All
Influencer
Youtubers
Crypto Projects
General
Tweets by Bitcoinonl
Tweets by PeterMcCormack
Tweets by Andreas
Tweets by Meltem
Tweets by danheld
Tweets by Lolli
Tweets by Matic
Tweets by eToro
Tweets by boxmining
Tweets by Omar Bham
Tweets by Joe Pompliano
Tweets by naval
Tweets by NavalBot


--- layout: post title: Just creating two titles date: '2016-02-17T09:52:00.001+05:30' author: Pawneshwer Gupta tags: modified_time: '2016-02-20T06:53:20.670+05:30' blogger_id: tag:blogger.com,1999:blog-1967791069058877982.post-8555745897000517895 blogger_orig_url: http://www.edablogs.com/2016/02/test-post.html ---


It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout.
The generated Lorem Ipsum is therefore always free from repetition, injected humour, or non-characteristic words etc.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
The generated Lorem Ipsum is therefore always free from repetition, injected humour, or non-characteristic words etc.
The generated Lorem Ipsum is therefore always free from repetition, injected humour, or non-characteristic words etc.
The generated Lorem Ipsum is therefore always free from repetition, injected humour, or non-characteristic words etc.
The generated Lorem Ipsum is therefore always free from repetition, injected humour, or non-characteristic words etc.


{% load staticfiles %}
{% load staticfiles %} {% include "pta/siteCss.html" %}
{% csrf_token %}
Welcome to the PTA application, please login to get started
Enter your credentials:
Username:
Password:


NGX Breadcrumbs Version Bootstrap Pre-made
Below u can see demo of ngx-breadcrumbs from this repo Ngx-breadcrumbs
Since we face the need to create more customizable breadcrumb for one of your client , we decide to bring this to next level with coderbase-ngx-breadcrumbs library. The main idea is to have a library which can cover most of case and avoid to fall in trap of design. Components of library should let developpers to bring their own design , so finally to expose data and logic needed. Library have to be small in term of size and with 0 dependency expect Angular itself . We should also create a branch for each version of Angular . Many Stacblitz should present part of library and being diffuse in demo part to .


{% extends 'base.html' %} {# Not sure what goes in the menu yet... {% if not story_is_locked %}
Mary Sue is editing this article right now.


Landing Page
Special Projects
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.
NATHAN SZOCH
04.04.18
A previous version of this article incorrectly identified who owned a TV. The article has been updated to reflect the most accurate information.
Every year in April, crowds gather on Court Street to hear music and dance. It’s very different from a spring fest in which DJs blast music and students jump to the beat.
On the stage next to College Green, dancers dressed in different attire move to the music and to the audience clapping rhythmically. The dancers on stage move their feet rapidly or stomp on the floor and clap, creating their own beat and posing in ways the audience has not seen before.
They come from different countries, but they all move for the joy of it, to feel connected to their history and families miles away. The International Street Fair evokes different cultures to come out and move, all of them connected in a common language.
With more than 1,000 international students from over 150 countries, Athens is interspersed with hundreds of different cultures, each with its own music and dance. With the World Music and Dance Festival this week and the upcoming International Street Fair on Saturday, international students shared the significance behind their local dances.
Click the dots on the map to go to a specific section of the story
To Yenuel Jones Alberty, salsa dance is like the color red: vibrant, energetic and full of life.
“It’s all those emotions where you’re euphoric and ecstatic,” he said.
Alberty, a first-year graduate student studying physics, grew up in a family passionate about music and dance. Alberty’s father, who studied musical education, played him Johann Sebastian Bach since he was 2 years old. His cousin, a ballerina with experience in many different dance styles, accompanied him to his first salsa course when he was in middle school. His family always has music playing and dances together.
Like most music in Latin America, salsa is of African descent. It originated in 1950s New York City, created by Cuban and Puerto Rican musicians. Its roots are grounded in bomba and plena, dances created by slaves who were brought to the Caribbean. The Africans who were brought there used music and dance as a form of communication and also as a way to worship gods that the Europeans prohibited.
Salsa has become a melting pot of Spanish, jazz and African influences, Alberty said.
Alberty believes music and dance can act as an adhesive that connects people, an archetype with which everyone can be linked. It’s easier to understand each other if people can connect in something, he said. It also can reveal cultural characteristics about the people who perform them. The music and dance culture in Puerto Rico demonstrates the resilience and hope of the people there.
When Alberty returned home to Puerto Rico in December after Hurricane Maria struck the island, many houses, including his, were still without electricity. Everything was desolate, destroyed after the hurricane.
The few people with generators invited others inside their houses for food, Alberty said. And when he walked along the dark street, people had gathered in the center to eat, laugh, sing and dance.
“But you see all that desolation, and all these people trying to help each other,” Alberty said. “It’s amazing.”
Salsa is a cornerstone of the Caribbean identity, Alberty said, like a national flag. It’s the bread and butter of Puerto Rico, the music that everybody listens to and dances along with at parties.
“In Latin American families, there’s a party for whatever,” Alberty explained. “If someone’s sad, there’s a party. If someone’s happy, there’s a party. If you want to celebrate life in general, there’s a party.”
Heber Da Silva didn’t like to dance as a kid.  As he grew up, however, dance grew on him also.
From a touristic, modern city in northeastern Brazil — locals call it the Brazilian Miami — Silva has danced professionally as a freelance dancer in bars, clubs and private parties. Now, he has learned salsa, samba, bachata, zouk, merengue, tango and forro, a musical and dance staple in Brazilian culture. For instance, if you travel to Fortaleza and ask the taxi driver to take you to a place you can dance, the driver will take you to a forro club, Silva said.
With African roots throughout Latin America, forro involves dancers staying on the ground with their knees bent. The dance partners move together very closely to each other It’s not sexual, Silva said — it’s just relaxing.
The music is an African-based rhythm, but it also has European origins. Three instruments are present in the dance: a bass drum called a zabumba, an accordion and a triangle. Forro’s rhythm is different compared to other Latin American dances. In salsa, for example, the strongest beat is the first, but in forro, the stressed beat is the fourth one.
“I will dance my whole life. I can’t live without it. When my friends are sad or depressed, they go to bars and get drunk. I go dancing. It makes my life so much better."Heber Da Silva, a graduate student studying Latin American Studies
Silva doesn’t remember when exactly he started to dance, as it was just “always there.” When he was a teenager, he went dancing often, as it was a way to socialize and meet new people.
“Dancing in general is really important,” Silva said. “You learn tolerance and empathy. It helped me socialize, learn how to deal with other people, to become tolerant and listen to people.”
When he came to Athens in 2016, Silva, a graduate student studying Latin American Studies, felt bored. Wanting to do something related to Latin American culture, he decided to create his own club called the Samba and Salsa Project. With eight or nine regular members, Silva teaches different Latin American dances.
At lessons, he steps with an effortless grace and guides his dance partner around the room, as if he’s gliding a broom gently across the floor. Some of the students at the club are dancing for the first time, but when he leads them, pushing the small of their back to move in a certain way, their inexperience is difficult to see.
When he graduates, Silva does not plan on quitting dancing.
“I will dance my whole life,” Silva said. “I can’t live without it. When my friends are sad or depressed, they go to bars and get drunk. I go dancing. It makes my life so much better.”
 It’s something that is just in her.
Hannah Ruhoff | STAFF PHOTOGRAPHER
Gaone Manatong, a graduate student from Botswana studying communications and development, dances and poses for a portrait on April 3, 2018 in Putnam Hall.
In Botswana, people dance all the time. It’s a way to communicate, to resolve conflicts and to have fun, Manatong, a first-year graduate student studying communication development, said. Her school would have dance competitions, and she remembers practicing every day after school.
“It’s such a language that does not need any violence and you can communicate in ways that you understand each other,” Manatong said.
Phathisi is a typical dance in Botswana that regions spice up in different ways. Usually, it is a group dance in which they gather to form a horseshoe shape and start singing and clapping while people in the middle dance to that rhythm, Manatong said. The dancers always move in sync with each other. In some cases, men and women dance together, but in other dances they each perform separately.
Dance and music is deeply rooted in Botswanan culture. While Manatong was growing up, her grandmother did not have TV or radio and instead would tell each other stories, she said. She remembers visiting her grandmother. They would sit around the fire, and her grandmother would tell her folktales about her experiences as a child. Then she would sing a song, getting everybody to join in, and somebody would get up and start dancing. It was a way to bond and form connections, Manatong recalled.
“Sometimes it’s difficult to talk to new people, expressing your words and what you want to say to them,” Manatong said. “But through song, music and dance, it can be easier to communicate and express yourself that way.”
Manatong has joined with the African Students’ Union to practice different dances, and her group is planning to perform at the International Street Fair as well as the African Heroes’ Night on April 21. She wants to represent her cultural dances in the U.S.
She has seen Western pop artists somewhat appropriate African culture. Manatong watched Rihanna’s Grammy Awards 2018 performance and noticed some dance moves from Botswana that involved a lot of leg, feet and hip movements. She thought it was flattering to see someone from Barbados perform her local dance, but wondered why the Grammys did not show a dancer from South Africa.
“As much as we consume Western music and dance and everything we are shown on our TV growing up, it’s all Western talent,” Manatong said. “There’s a whole world out there that has all this as well, and it should be well-respected and viewed and consumed as much as other places.”
Sanam Azadiamin, a graduate student studying industrial engineering, said dances vary from region to region in Iran, each part practicing its own styles. From the north of Iran, in the Azerbaijani region, Azadiamin said many people dance to what she refers to as the Azeri dance. They dance happily in celebratory circumstances, like weddings and ceremonies, she said.
The tempo is usually fast-paced and involves rapid foot movements, as if the dancers are being fast-forwarded with the touch of a remote control. Drums beat briskly, driving the feet to kick and pound. Upon first glance, it’s comparable to Irish stepdancing. The foot stomping is so loud that one time the neighbors called the police while Azadiamin and her friends were dancing.
“We have this power, this joy inside, and we can show it in different ways. And dance is one of them. It shows that we are a strong people, I think, that in spite of everything we can show this joy.”Sanam Azadiamin, a graduate student studying industrial engineering
“It looks really elegant (and) nice,” Azadiamin said. “It comes from the joyful nature of our people. We want to celebrate something.”
Azadiamin danced with the Iranian Students Society during its two yearly celebrations, Nowruz — the Iranian New Year — and Yalda Night. She often feels shy, but she dances with groups of people. She loved performing for people from different cultures so that they could learn something about Iranians.
Some people have an impression that Iranians are sad because of the country’s political state, Azadiamin said. Though she said Iran may have problems, Iranians have a happy nature that is revealed through dance.
“We have this power, this joy inside, and we can show it in different ways,” Azadiamin said. “And dance is one of them. It shows that we are a strong people, I think, that in spite of everything we can show this joy.”
She bounces along the floor, claps her hands and synchronously stomps her foot to the music. Her multi-colored skirt sways back and forth. Those movements seem natural after years of learning. It isn’t until she stops dancing and her heavy breathing rings out that the dance’s difficulty is portrayed.
India is literally a land of festivals, Purva Diwanji, a first-year graduate student studying physics, said. Every month, there is at least one major festival, and no party can be complete without dancing. In the state of Gujarat, every party ends with a garba dance.
Garba, which celebrates fertility and womanhood, is a dance that was passed down to Diwanji from her mother, who won awards for the graceful way she moved. In a festival called Navratri, which means “nine nights,” people dance for four to five hours straight into the night in celebration of the victories of goddesses Durga and Shakti. The dancers don traditional dresses called chaniya cholis, elaborate and colorful skirts with detailed ornamentation. The festival is like prom night in the United States, Diwanji said — except it lasts for nine days.
“Everyone knows the popular songs and just get together and dance to that,” Diwanji said. “It’s a lot of fun. It’s important in bringing us all together.”
Traditionally in India, older men and women would sing songs passed down by word of mouth, and the younger girls would perform the dances in neighborhoods. Now, it has transformed into a grander scale in which the state government organizes a huge festival, which people come from all over to see, Diwanji said.
“They’re really energetic,” Diwanji said. “It requires a lot of stamina to be able to dance all night.”
Diwanji performed two songs at last year’s Diwali celebration in Athens with two other people, and they danced to a song called “Nagada Sang Dhol” from Ram-Leela, a popular Bollywood film. When they danced garba, some of her American friends came to watch. They had never seen any Indian dance before and were impressed.
“Just seeing that much music and energy, they were just blown away,” Diwanji said. “They thought it was really cool. So I think it’s important that we have those kinds of cultural exchanges.”
One characteristic of Indian dances, especially garba, Diwanji said, is that they tell a story.
“Every state has a different form of cultural dance, and they either stem out of a story or, in it itself, they tell a story,” Diwanji said. “If you learn a dance form from India, you’re actually learning the mythologies of ethics that we’ve been following for thousands of years.”
Garba has become part of her identity. Ever since Diwanji could walk or run, she could dance. Her mother brought her to every Navratri festival each year and taught her the steps.
“It was very fun learning to dance from my mom because it was one activity we could do together,” Diwanji said.
She remembers when her mother came to a school garba night with her and taught all her friends how to dance. The kids had a good time and were happy that an adult was willing to have fun with them.
“That’s a precious memory I have,” she said.
Landing Page
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.


JOUR 390 | Spring 2013
Application Programming Interface.
Pull in outside data
↓Send messages
↓Connect to other services (Facebook, Twitter)
↓Powerful, dynamic apps.
More specifically, today we'll cover:
The Internet – what is it
HTTP
Client + server model
REST easy
RESTful APIs
Requests
How'd it go?
What happens when you type this into your browser?
Name gets translated to IP address (involves your computer, the client, talking to a server).
After IP address gets resolved, your browser goes to eecs.northwestern.edu to request the files for the webpage.
Extremely simplified, but this leads us to ...
HyperText Transfer Protocol
Basically, rules that govern how content gets from one place to another in the depths of the intertubez.
We use HTTP to get pages on the Internet. Where do these pages come from?
YOU GUESSED IT, THE INTERNET.
But actually, other computers on the Internet: servers.
Try it yourself:
var xhr = new XMLHttpRequest();
xhr.open("GET", "http://www.codecademy.com/", false);
xhr.send();
console.log(xhr.status);
console.log(xhr.statusText);
The Internet is full of clients. They want a lot of things.
(things = web pages, files, scripts, images, audio, video ...)
Servers store this information and will send a response back to you.
HTTP is kind of like the social conventions for talking on the web.
Request: Ask and you shall receive.
Response: A good server will acknowledge your request.
Representational State Transfer.
All you need to know: set of principles around the existence of resources [anything URI addressable] and manipulation of those resources.
HTTP is built on REST principles. Most web APIs are also designed to be RESTful (adhering to REST principles).
When you (client) are on a website, and you click that link to a chill sloth gif, you are, in REST terms, making a state transition.
The server then processes this request, returns the appropriate resources to you.
APIs! That's why you're here, right?
APIs: think of as a ~~~*~code contract~~*~ that says how programs can interact with a given application or service.
Let's say you wanted get all the tweets hashtagged with #boston. You would need to use Twitter's API, which specifies how you authenticate (login), which URLs you go to get the data, and so forth.
We call an API "RESTful" if it does the following:
Google + API documentation.
Any questions?


ABOUT CLICommander is a class that enables both ANSI and xterm color support for PHP command line applications. Additionally, it offers features such as formatting template support, advanced command line options handling, and a whole lot more. CLICommander allows you to make rich command line user interfaces without having to include extentions such as ncurses. FEATURES * Full ANSI 16-Color and Style support * Xterm 256-Color support * ANSI Terminal Bell Support * ANSI Terminal Title Support * Masked Input Support * Simple User Prompts * Advanced Argument Handling * Template Driven Formatting * HTML to xterm Color Conversion VERSION HISTORY 1.0 - 2012-01-11 Initial Creation HOW TO USE Coming soon...
Documentation generated on Fri, 13 Jan 2012 10:15:20 -0600 by phpDocumentor 1.4.3


# globule [![Build Status](https://secure.travis-ci.org/cowboy/node-globule.png?branch=master)](http://travis-ci.org/cowboy/node-globule)
An easy-to-use wildcard globbing library.
## Getting Started Install the module with: npm install globule
`javascript
var globule = require('globule');
var filepaths = globule.find('**/*.js');
`
## Documentation
### globule.find Returns a unique array of all file or directory paths that match the given globbing pattern(s). This method accepts either comma separated globbing patterns or an array of globbing patterns. Paths matching patterns that begin with ! will be excluded from the returned array. Patterns are processed in order, so inclusion and exclusion order is significant.
`js
globule.find(patterns [, options])
`
The options object supports all [glob][] library options, along with a few extras. These are the most commonly used:
- filter Either a valid [fs.Stats method name](http://nodejs.org/docs/latest/api/fs.html#fs_class_fs_stats) or a function that will be passed the matched src filepath and options object as arguments. This function should return a Boolean value.
- nonull Retain globbing patterns in result set even if they fail to match files.
- matchBase Patterns without slashes will match just the basename part. Eg. this makes *.js work like **/*.js.
- srcBase Patterns will be matched relative to the specified path instead of the current working directory. This is a synonym for cwd.
- prefixBase Any specified srcBase will be prefixed to all returned filepaths.
[glob]: https://github.com/isaacs/node-glob
### globule.match Match one or more globbing patterns against one or more file paths. Returns a uniqued array of all file paths that match any of the specified globbing patterns. Both the patterns and filepaths arguments can be a single string or array of strings. Paths matching patterns that begin with ! will be excluded from the returned array. Patterns are processed in order, so inclusion and exclusion order is significant.
`js
grunt.file.match(patterns, filepaths [, options])
`
### globule.isMatch This method contains the same signature and logic as the globule.match method, but returns true if any files were matched, otherwise false.
`js
grunt.file.isMatch(patterns, filepaths [, options])
`
### globule.mapping Given a set of source file paths, returns an array of src-dest file mapping objects. Both src and dest paths may be renamed, depending on the options specified.
`js
globule.mapping(filepaths [, options])
`
In addition to the options the globule.find method supports, the options object also supports these properties:
- srcBase The directory from which patterns are matched. Any string specified as srcBase is effectively stripped from the beginning of all matched paths.
- destBase The specified path is prefixed to all dest filepaths.
- ext Remove anything after (and including) the first . in the destination path, then append this value.
- extDot Change the behavior of ext, “first” and “last” will remove anything after the first or last . in the destination filename, respectively. Defaults to “first”.
- flatten Remove the path component from all matched src files. The src file path is still joined to the specified destBase.
- rename If specified, this function will be responsible for returning the final dest filepath. By default, it flattens paths (if specified), changes extensions (if specified) and joins the matched path to the destBase.
### globule.findMapping This method is a convenience wrapper around the globule.find and globule.mapping methods.
`js
globule.findMapping(patterns [, options])
`
## Examples
Given the files foo/a.js and foo/b.js:
### srcBase and destBase
```js globule.find(“foo/*.js”) // [“foo/a.js”, “foo/b.js”]
globule.find(“*.js”, {srcBase: “foo”}) // [“a.js”, “b.js”]
globule.find(“*.js”, {srcBase: “foo”, prefixBase: true}) // [“foo/a.js”, “foo/b.js”] ```
```js globule.findMapping(“foo/*.js”) // [{src: “foo/a.js”, dest: “foo/a.js”}, {src: “foo/b.js”, dest: “foo/b.js”}]
globule.findMapping(“foo/*.js”, {destBase: “bar”}) // [{src: “foo/a.js”, dest: “bar/foo/a.js”}, {src: “foo/b.js”, dest: “bar/foo/b.js”}]
globule.findMapping(“*.js”, {srcBase: “foo”, destBase: “bar”}) // [{src: “foo/a.js”, dest: “bar/a.js”}, {src: “foo/b.js”, dest: “bar/b.js”}] ```
```js globule.mapping([“foo/a.js”, “foo/b.js”]) // [{src: “foo/a.js”, dest: “foo/a.js”}, {src: “foo/b.js”, dest: “foo/b.js”}]
globule.mapping([“foo/a.js”, “foo/b.js”], {destBase: “bar”}) // [{src: “foo/a.js”, dest: “bar/foo/a.js”}, {src: “foo/b.js”, dest: “bar/foo/b.js”}]
globule.mapping([“a.js”, “b.js”], {srcBase: “foo”, destBase: “bar”}) // [{src: “foo/a.js”, dest: “bar/a.js”}, {src: “foo/b.js”, dest: “bar/b.js”}] ```
## Contributing In lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code using [Grunt](http://gruntjs.com/).
## Release History _(Nothing yet)_
## License Copyright (c) 2013 “Cowboy” Ben Alman Licensed under the MIT license.


Enjoy & Learn & Work
Listed below our awesome services
Welcome to I Learn creative site for courses for any thing.
Our working professional partners listed below with parallax background style!