#include <Grammar.h>

Classes
class	RuleIterator

Public Types
using	input_t = _input_t

using	output_t = _output_t

using	this_t = Grammar< input_t, output_t, GRAMMAR_TYPES... >

using	TypeTuple = std::tuple< GRAMMAR_TYPES... >

using	VirtualMachineState_t = VirtualMachineState< input_t, output_t, GRAMMAR_TYPES... >

using	FT = typename VirtualMachineState_t::FT

Public Member Functions
	Grammar ()

	Grammar (const Grammar &g)=delete

	Grammar (const Grammar &&g)=delete

RuleIterator	begin () const

RuleIterator	end () const

constexpr nonterminal_t	start ()
	The start nonterminal type. More...

constexpr size_t	count_nonterminals () const

size_t	count_rules (const nonterminal_t nt) const

size_t	count_rules () const

void	change_probability (const std::string &s, const double newp)

size_t	count_terminals (nonterminal_t nt) const

size_t	count_nonterminals (nonterminal_t nt) const

template<typename T , typename... args>
void	add_vms (std::string fmt, FT *f, double p=1.0, Op o=Op::Standard, int a=0)

template<typename T , typename... args>
void	add (std::string fmt, Primitive< T, args... > &b, double p=1.0, int a=0)

template<typename T , typename... args>
void	add (std::string fmt, std::function< T(args...)> f, double p=1.0, Op o=Op::Standard, int a=0)

template<typename T , typename... args>
void	add (std::string fmt, T(*_f)(args...), double p=1.0, Op o=Op::Standard, int a=0)

template<typename T >
void	add_terminal (std::string fmt, T x, double p=1.0, Op o=Op::Standard, int a=0)
	Add a variable that is NOT A function – simplification for adding alphabets etc. This just wraps stuff in a thunk for us to make it easier. NOTE: x is copied by value. More...

void	remove_all (nonterminal_t nt)
	Remove all the nonterminals of this type from the grammar. NOTE: This is generally a really bad idea unless you know what you are doing. More...

size_t	get_index_of (const Rule *r) const

virtual Rule *	get_rule (const nonterminal_t nt, size_t k) const

virtual Rule *	get_rule (const nonterminal_t nt, const Op o, const int a=0)

virtual Rule *	get_rule (const nonterminal_t nt, size_t i)

virtual Rule *	get_rule (const nonterminal_t nt, const std::string s) const

virtual Rule *	get_rule (const std::string s) const

double	rule_normalizer (const nonterminal_t nt) const

virtual Rule *	sample_rule (const nonterminal_t nt) const

Node	makeNode (const Rule *r) const

Node	__generate (const nonterminal_t ntfrom=nt< output_t >(), unsigned long depth=0) const

Node	generate (const nonterminal_t ntfrom=nt< output_t >(), unsigned long depth=0) const
	A wrapper to catch DepthExcpetions and retry. This means that defaultly we try to generate GENERATE_DEPTH_EXCEPTION_RETRIES times and if ALL of them fail, we throw an assert error. Presumably, unless the grammar is terrible one of them will work. This makes our DepthExceptions generally silent to the outside since they won't call __generate typically. More...

Node	copy_resample (const Node &node, bool f(const Node &n)) const

std::vector< size_t >	get_cumulative_indices () const

std::vector< size_t >	get_counts (const Node &node) const

template<typename T >
std::vector< size_t >	get_counts (const std::vector< T > &v) const
	Compute a vector of counts of how often each rule was used, in a standard order given by iterating over nts and then iterating over rules. More...

template<typename K , typename T >
std::vector< size_t >	get_counts (const std::map< K, T > &v) const

double	log_probability (const Node &n) const
	This computes the expected length of productions from this grammar, counting terminals and nonterminals as 1 each NOTE: We can do this smarter with a matrix eigenvalues, but its a bit less flexible/extensible. More...

Node	from_parseable (std::deque< std::string > &q) const

Node	from_parseable (std::string s) const

Node	from_parseable (const char *c) const

size_t	neighbors (const Node &node) const

void	expand_to_neighbor (Node &node, int &which)

double	neighbor_prior (const Node &node, int &which) const

void	complete (Node &node)

std::tuple< int, std::vector< int >, int >	find_open_commas_close (const std::string s)

Node	simple_parse (std::string s)
	Very simple parsing routine that takes a string like "and(not(or(eq_pos(pos(parent(x)),'NP-POSS'),eq_pos('NP-S',pos(x)))),corefers(x))" (from the Binding example) and parses it into a Node. More...

Static Public Member Functions
template<class T >
static constexpr nonterminal_t	nt ()

template<typename X >
static constexpr bool	is_in_GRAMMAR_TYPES ()
	For a given nt, returns the number of finite trees that nt can expand to if its finite; 0 if its infinite. *. More...

Public Attributes
std::vector< Rule >	rules [N_NTs]

std::array< double, N_NTs >	Z

size_t	GRAMMAR_MAX_DEPTH = 64

Static Public Attributes
static constexpr size_t	N_NTs = std::tuple_size<TypeTuple>::value

static const size_t	GENERATE_DEPTH_EXCEPTION_RETRIES = 1000

Detailed Description

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>
class Grammar< _input_t, _output_t, GRAMMAR_TYPES >

Author: Steven Piantadosi

Date: 05/09/20

Member Typedef Documentation

◆ FT

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

using Grammar< _input_t, _output_t, GRAMMAR_TYPES >::FT = typename VirtualMachineState_t::FT

◆ input_t

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

using Grammar< _input_t, _output_t, GRAMMAR_TYPES >::input_t = _input_t

◆ output_t

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

using Grammar< _input_t, _output_t, GRAMMAR_TYPES >::output_t = _output_t

◆ this_t

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

using Grammar< _input_t, _output_t, GRAMMAR_TYPES >::this_t = Grammar<input_t, output_t, GRAMMAR_TYPES...>

◆ TypeTuple

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

using Grammar< _input_t, _output_t, GRAMMAR_TYPES >::TypeTuple = std::tuple<GRAMMAR_TYPES...>

◆ VirtualMachineState_t

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

using Grammar< _input_t, _output_t, GRAMMAR_TYPES >::VirtualMachineState_t = VirtualMachineState<input_t, output_t, GRAMMAR_TYPES...>

Constructor & Destructor Documentation

◆ Grammar() [1/3]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

Grammar< _input_t, _output_t, GRAMMAR_TYPES >::Grammar ( )

inline

◆ Grammar() [2/3]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

Grammar< _input_t, _output_t, GRAMMAR_TYPES >::Grammar ( const Grammar< _input_t, _output_t, GRAMMAR_TYPES > & g )

delete

◆ Grammar() [3/3]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

Grammar< _input_t, _output_t, GRAMMAR_TYPES >::Grammar ( const Grammar< _input_t, _output_t, GRAMMAR_TYPES > && g )

delete

Member Function Documentation

◆ __generate()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

Node Grammar< _input_t, _output_t, GRAMMAR_TYPES >::__generate	(	const nonterminal_t	ntfrom = `nt<output_t>()`,
		unsigned long	depth = `0`
	)		const

inline

Sample an entire tree from this grammar (keeping track of depth in case we recurse too far) of return type nt. This samples a rule, makes them with makeNode, and then recurses.

Parameters

nt
depth

Returns: Returns a Node sampled from the grammar.

NOTE: this may throw a if the grammar recurses too far (usually that means the grammar is improper)

◆ add() [1/3]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

template<typename T , typename... args>

void Grammar< _input_t, _output_t, GRAMMAR_TYPES >::add	(	std::string	fmt,
		Primitive< T, args... > &	b,
		double	p = `1.0`,
		int	a = `0`
	)

inline

Parameters

fmt
b
p

◆ add() [2/3]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

template<typename T , typename... args>

void Grammar< _input_t, _output_t, GRAMMAR_TYPES >::add	(	std::string	fmt,
		std::function< T(args...)>	f,
		double	p = `1.0`,
		Op	o = `Op::Standard`,
		int	a = `0`
	)

inline

Parameters

fmt
f
p
o

◆ add() [3/3]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

template<typename T , typename... args>

void Grammar< _input_t, _output_t, GRAMMAR_TYPES >::add	(	std::string	fmt,
		T(*)(args...)	_f,
		double	p = `1.0`,
		Op	o = `Op::Standard`,
		int	a = `0`
	)

inline

Parameters

fmt
p
o

◆ add_terminal()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

template<typename T >

void Grammar< _input_t, _output_t, GRAMMAR_TYPES >::add_terminal	(	std::string	fmt,
		T	x,
		double	p = `1.0`,
		Op	o = `Op::Standard`,
		int	a = `0`
	)

inline

Add a variable that is NOT A function – simplification for adding alphabets etc. This just wraps stuff in a thunk for us to make it easier. NOTE: x is copied by value.

Parameters

fmt
x
p
o
a

◆ add_vms()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

template<typename T , typename... args>

void Grammar< _input_t, _output_t, GRAMMAR_TYPES >::add_vms	(	std::string	fmt,
		FT *	f,
		double	p = `1.0`,
		Op	o = `Op::Standard`,
		int	a = `0`
	)

inline

Parameters

fmt
f
p
o

◆ begin()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

RuleIterator Grammar< _input_t, _output_t, GRAMMAR_TYPES >::begin ( ) const

inline

◆ change_probability()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

void Grammar< _input_t, _output_t, GRAMMAR_TYPES >::change_probability	(	const std::string &	s,
		const double	newp
	)

inline

◆ complete()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

void Grammar< _input_t, _output_t, GRAMMAR_TYPES >::complete ( Node & node )

inline

◆ copy_resample()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

Node Grammar< _input_t, _output_t, GRAMMAR_TYPES >::copy_resample	(	const Node &	node,
		bool	fconst Node &n
	)		const

inline

Make a copy of node where all nodes satisfying f are regenerated from the grammar.

Parameters

node
f	- a function saying what we should resample

Returns: NOTE: this does NOT allow f to apply to nullptr children (so cannot be used to fill in)

◆ count_nonterminals() [1/2]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

constexpr size_t Grammar< _input_t, _output_t, GRAMMAR_TYPES >::count_nonterminals ( ) const

inline

How many nonterminals are there in the grammar.

Returns

◆ count_nonterminals() [2/2]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

size_t Grammar< _input_t, _output_t, GRAMMAR_TYPES >::count_nonterminals ( nonterminal_t nt ) const

inline

Count th enumber of non-terminal rules of return type nt

Parameters

nt

Returns

◆ count_rules() [1/2]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

size_t Grammar< _input_t, _output_t, GRAMMAR_TYPES >::count_rules ( const nonterminal_t nt ) const

inline

Returns the number of rules of return type nt

Parameters

nt

Returns

◆ count_rules() [2/2]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

size_t Grammar< _input_t, _output_t, GRAMMAR_TYPES >::count_rules ( ) const

inline

Total number of rules

Returns

◆ count_terminals()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

size_t Grammar< _input_t, _output_t, GRAMMAR_TYPES >::count_terminals ( nonterminal_t nt ) const

inline

Count the number of terminal rules of return type nt

Parameters

nt

Returns

◆ end()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

RuleIterator Grammar< _input_t, _output_t, GRAMMAR_TYPES >::end ( ) const

inline

◆ expand_to_neighbor()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

void Grammar< _input_t, _output_t, GRAMMAR_TYPES >::expand_to_neighbor	(	Node &	node,
		int &	which
	)

inline

◆ find_open_commas_close()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

std::tuple<int,std::vector<int>,int> Grammar< _input_t, _output_t, GRAMMAR_TYPES >::find_open_commas_close ( const std::string s )

inline

◆ from_parseable() [1/3]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

Node Grammar< _input_t, _output_t, GRAMMAR_TYPES >::from_parseable ( std::deque< std::string > & q ) const

inline

Fills an entire tree using the string format prefixes – see get_rule(std::string). Here q should contain strings like "3:'a'" which says expand nonterminal type 3 to the rule matching 'a' NOTE: This is not a Serializable interface because the Node needs to know which grammar

Parameters

q

Returns

◆ from_parseable() [2/3]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

Node Grammar< _input_t, _output_t, GRAMMAR_TYPES >::from_parseable ( std::string s ) const

inline

Expand from names where s is delimited by ':'

Parameters

s

Returns

◆ from_parseable() [3/3]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

Node Grammar< _input_t, _output_t, GRAMMAR_TYPES >::from_parseable ( const char * c ) const

inline

◆ generate()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

Node Grammar< _input_t, _output_t, GRAMMAR_TYPES >::generate	(	const nonterminal_t	ntfrom = `nt<output_t>()`,
		unsigned long	depth = `0`
	)		const

inline

A wrapper to catch DepthExcpetions and retry. This means that defaultly we try to generate GENERATE_DEPTH_EXCEPTION_RETRIES times and if ALL of them fail, we throw an assert error. Presumably, unless the grammar is terrible one of them will work. This makes our DepthExceptions generally silent to the outside since they won't call __generate typically.

Parameters

ntfrom
depth

Returns

◆ get_counts() [1/3]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

std::vector<size_t> Grammar< _input_t, _output_t, GRAMMAR_TYPES >::get_counts ( const Node & node ) const

inline

Compute a vector of counts of how often each rule was used, in a standard order given by iterating over nts and then iterating over rules

Parameters

node

Returns

◆ get_counts() [2/3]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

template<typename T >

std::vector<size_t> Grammar< _input_t, _output_t, GRAMMAR_TYPES >::get_counts ( const std::vector< T > & v ) const

inline

Compute a vector of counts of how often each rule was used, in a standard order given by iterating over nts and then iterating over rules.

Parameters

v

Returns

◆ get_counts() [3/3]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

template<typename K , typename T >

std::vector<size_t> Grammar< _input_t, _output_t, GRAMMAR_TYPES >::get_counts ( const std::map< K, T > & v ) const

inline

◆ get_cumulative_indices()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

std::vector<size_t> Grammar< _input_t, _output_t, GRAMMAR_TYPES >::get_cumulative_indices ( ) const

inline

◆ get_index_of()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

size_t Grammar< _input_t, _output_t, GRAMMAR_TYPES >::get_index_of ( const Rule * r ) const

inline

Find the index in rules of where r is.

Parameters

r

Returns

◆ get_rule() [1/5]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

virtual Rule* Grammar< _input_t, _output_t, GRAMMAR_TYPES >::get_rule	(	const nonterminal_t	nt,
		size_t	k
	)		const

inlinevirtual

Get the k'th rule of type nt

Parameters

nt
k

Returns

◆ get_rule() [2/5]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

virtual Rule* Grammar< _input_t, _output_t, GRAMMAR_TYPES >::get_rule	(	const nonterminal_t	nt,
		const Op	o,
		const int	a = `0`
	)

inlinevirtual

Get rule of type nt with a given BuiltinOp and argument a

Parameters

nt
o
a

Returns

◆ get_rule() [3/5]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

virtual Rule* Grammar< _input_t, _output_t, GRAMMAR_TYPES >::get_rule	(	const nonterminal_t	nt,
		size_t	i
	)

inlinevirtual

◆ get_rule() [4/5]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

virtual Rule* Grammar< _input_t, _output_t, GRAMMAR_TYPES >::get_rule	(	const nonterminal_t	nt,
		const std::string	s
	)		const

inlinevirtual

Return a rule based on s, which must uniquely be a prefix of the rule's format of a given nonterminal type. If s is the empty string, however, it must match exactly.

Parameters

s

Returns

◆ get_rule() [5/5]

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

virtual Rule* Grammar< _input_t, _output_t, GRAMMAR_TYPES >::get_rule ( const std::string s ) const

inlinevirtual

Return a rule based on s, which must uniquely be a prefix of the rule's format. If s is the empty string, however, it must match exactly.

Parameters

s

Returns

◆ is_in_GRAMMAR_TYPES()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

template<typename X >

static constexpr bool Grammar< _input_t, _output_t, GRAMMAR_TYPES >::is_in_GRAMMAR_TYPES ( )

inlinestatic

For a given nt, returns the number of finite trees that nt can expand to if its finite; 0 if its infinite. *.

Parameters

nt	- the type of this nonterminal

◆ log_probability()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

double Grammar< _input_t, _output_t, GRAMMAR_TYPES >::log_probability ( const Node & n ) const

inline

This computes the expected length of productions from this grammar, counting terminals and nonterminals as 1 each NOTE: We can do this smarter with a matrix eigenvalues, but its a bit less flexible/extensible.

Parameters

max_depth

Returns

Compute the log probability of a tree according to the grammar. NOTE: here we ignore nodes that are Null meaning that we compute the partial probability

Parameters

n

Returns

◆ makeNode()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

Node Grammar< _input_t, _output_t, GRAMMAR_TYPES >::makeNode ( const Rule * r ) const

inline

Helper function to create a node according to this grammar. This is how nodes get their log probabilities.

Parameters

r

Returns

◆ neighbor_prior()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

double Grammar< _input_t, _output_t, GRAMMAR_TYPES >::neighbor_prior	(	const Node &	node,
		int &	which
	)		const

inline

◆ neighbors()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

size_t Grammar< _input_t, _output_t, GRAMMAR_TYPES >::neighbors ( const Node & node ) const

inline

◆ nt()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

template<class T >

static constexpr nonterminal_t Grammar< _input_t, _output_t, GRAMMAR_TYPES >::nt ( )

inlinestatic

◆ remove_all()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

void Grammar< _input_t, _output_t, GRAMMAR_TYPES >::remove_all ( nonterminal_t nt )

inline

Remove all the nonterminals of this type from the grammar. NOTE: This is generally a really bad idea unless you know what you are doing.

Parameters

nt

◆ rule_normalizer()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

double Grammar< _input_t, _output_t, GRAMMAR_TYPES >::rule_normalizer ( const nonterminal_t nt ) const

inline

Return the normalizing constant (NOT log) for all rules of type nt

Parameters

nt

Returns

◆ sample_rule()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

virtual Rule* Grammar< _input_t, _output_t, GRAMMAR_TYPES >::sample_rule ( const nonterminal_t nt ) const

inlinevirtual

Randomly sample a rule of type nt.

Parameters

nt

Returns

◆ simple_parse()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

Node Grammar< _input_t, _output_t, GRAMMAR_TYPES >::simple_parse ( std::string s )

inline

Very simple parsing routine that takes a string like "and(not(or(eq_pos(pos(parent(x)),'NP-POSS'),eq_pos('NP-S',pos(x)))),corefers(x))" (from the Binding example) and parses it into a Node.

NOTE: The resulting Node must then be put into a LOTHypothesis or Lexicon. NOTE: This is not very robust or debugged. Just a quick ipmlementation.

Parameters

s

Returns

◆ start()

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

constexpr nonterminal_t Grammar< _input_t, _output_t, GRAMMAR_TYPES >::start ( )

inline

The start nonterminal type.

Member Data Documentation

◆ GENERATE_DEPTH_EXCEPTION_RETRIES

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

const size_t Grammar< _input_t, _output_t, GRAMMAR_TYPES >::GENERATE_DEPTH_EXCEPTION_RETRIES = 1000

static

◆ GRAMMAR_MAX_DEPTH

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

size_t Grammar< _input_t, _output_t, GRAMMAR_TYPES >::GRAMMAR_MAX_DEPTH = 64

◆ N_NTs

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

constexpr size_t Grammar< _input_t, _output_t, GRAMMAR_TYPES >::N_NTs = std::tuple_size<TypeTuple>::value

static

◆ rules

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

std::vector<Rule> Grammar< _input_t, _output_t, GRAMMAR_TYPES >::rules[N_NTs]

◆ Z

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>

std::array<double,N_NTs> Grammar< _input_t, _output_t, GRAMMAR_TYPES >::Z

The documentation for this class was generated from the following file:

src/Grammar/Grammar.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES> class Grammar< _input_t, _output_t, GRAMMAR_TYPES >

Member Typedef Documentation

◆ FT

◆ input_t

◆ output_t

◆ this_t

◆ TypeTuple

◆ VirtualMachineState_t

Constructor & Destructor Documentation

◆ Grammar() [1/3]

◆ Grammar() [2/3]

◆ Grammar() [3/3]

Member Function Documentation

◆ __generate()

◆ add() [1/3]

◆ add() [2/3]

◆ add() [3/3]

◆ add_terminal()

◆ add_vms()

◆ begin()

◆ change_probability()

◆ complete()

◆ copy_resample()

◆ count_nonterminals() [1/2]

◆ count_nonterminals() [2/2]

◆ count_rules() [1/2]

◆ count_rules() [2/2]

◆ count_terminals()

◆ end()

◆ expand_to_neighbor()

◆ find_open_commas_close()

◆ from_parseable() [1/3]

◆ from_parseable() [2/3]

◆ from_parseable() [3/3]

◆ generate()

◆ get_counts() [1/3]

◆ get_counts() [2/3]

◆ get_counts() [3/3]

◆ get_cumulative_indices()

◆ get_index_of()

◆ get_rule() [1/5]

◆ get_rule() [2/5]

◆ get_rule() [3/5]

◆ get_rule() [4/5]

◆ get_rule() [5/5]

◆ is_in_GRAMMAR_TYPES()

◆ log_probability()

◆ makeNode()

◆ neighbor_prior()

◆ neighbors()

◆ nt()

◆ remove_all()

◆ rule_normalizer()

◆ sample_rule()

◆ simple_parse()

◆ start()

Member Data Documentation

◆ GENERATE_DEPTH_EXCEPTION_RETRIES

◆ GRAMMAR_MAX_DEPTH

◆ N_NTs

◆ rules

◆ Z

template<typename _input_t, typename _output_t, typename... GRAMMAR_TYPES>
class Grammar< _input_t, _output_t, GRAMMAR_TYPES >