Index

()

list<E> : 9.7

A()

d3_plane : 19.5

d3_rat_plane : 19.12

A0Coder : 12.1

A0sCoder : 12.2

abs(const bigfloat& x) : 8.3

abs(const integer& a) : 8.1

abs(const rational& q) : 8.2

abs(const real& x) : 8.4

abs(const residual& a) : 8.8

absolute(const residual& a)

residual : 8.8

accept()

leda_socket : 6.13

access(const K& k)

dictionary<K,I> : 10.1

acknowledge(string s)

GraphWin : 20.6

window : 20.2

activate(geo_scene sc)

GeoWin : 20.8

AdaptiveHuffmanCoder : 12.7

add(const residual& a, const residual& b)

residual : 8.8

add(double a, double b, double p)

residual : 8.7

add_dependence(geo_scene sc1, geo_scene sc2)

GeoWin : 20.8

add_edge_done_rule(gml_edge_rule f)

gml_graph : 14.26

add_edge_menu(string label, gw_action func)

GraphWin : 20.6

add_edge_rule(gml_edge_rule f, gml_value_type t, char* key=0)

gml_graph : 14.26

add_edge_rule_for_cur_path(gml_edge_rule f, gml_value_type t)

gml_graph : 14.26

add_export_object(geo_scene sc, geowin_export& eo, string name, string desc)

GeoWin : 20.8

add_graph_done_rule(gml_graph_rule f)

gml_graph : 14.26

add_graph_rule(gml_graph_rule f, gml_value_type t, char* key=0)

gml_graph : 14.26

add_graph_rule_for_cur_path(gml_graph_rule f, gml_value_type t)

gml_graph : 14.26

add_help_text(string name)

GeoWin : 20.8

GraphWin : 20.6

add_import_object(geo_scene sc, geowin_import& io, string name, string desc)

GeoWin : 20.8

add_key(const CryptKey& key)

CryptAutoDecoder : 13.6

add_keys_in_file(const char* file_name)

CryptAutoDecoder : 13.6

add_keys_in_stream(streambuf* key_stream)

CryptAutoDecoder : 13.6

add_member_call(void (GraphWin::*func)(), string label, int menu_id, int bm_w, int bm_h, unsigned char* bm_bits)

GraphWin : 20.6

add_member_call(void (GraphWin::*func)(), string label, int menu_id=0, char* pmap=0)

GraphWin : 20.6

add_menu(long menu_id)

GraphWin : 20.6

add_menu(string label, int menu_id=0, char* pmap=0)

GraphWin : 20.6

add_new_edge_rule(gml_edge_rule f)

gml_graph : 14.26

add_new_graph_rule(gml_graph_rule f)

gml_graph : 14.26

add_new_node_rule(gml_node_rule f)

gml_graph : 14.26

add_node_done_rule(gml_node_rule f)

gml_graph : 14.26

add_node_menu(string label, gw_action func)

GraphWin : 20.6

add_node_rule(gml_node_rule f, gml_value_type t, char* key=0)

gml_graph : 14.26

add_node_rule_for_cur_path(gml_node_rule f, gml_value_type t)

gml_graph : 14.26

add_scene_buttons(const list<geo_scene>& Ls, const list<string>& Ln)

GeoWin : 20.8

add_scene_buttons(const list<geo_scene>& Ls, int w, int h, unsigned char** bm)

GeoWin : 20.8

add_separator(int menu_id)

GraphWin : 20.6

add_simple_call(void (*func)(GraphWin& ), string label, int menu_id, int bm_w, int bm_h, unsigned char* bm_bits)

GraphWin : 20.6

add_simple_call(void (*func)(GraphWin& ), string label, int menu_id=0, char* pmap=0)

GraphWin : 20.6

add_special_help_text(string name, bool auto_display = false)

GeoWin : 20.8

add_text(const geowin_text& gt)

GeoWin : 20.8

add_text(geo_scene sc, const geowin_text& gt)

GeoWin : 20.8

add_to_day(int d)

date : 6.21

add_to_month(int m)

date : 6.21

add_to_year(int y)

date : 6.21

add_user_layer_circle(const circle& c)

GeoWin : 20.8

add_user_layer_point(const point& p)

GeoWin : 20.8

add_user_layer_rectangle(const rectangle& r)

GeoWin : 20.8

add_user_layer_segment(const segment& s)

GeoWin : 20.8

addLetter(char ch)

alphabet : 7.1

address(const_reference r)

leda_allocator<T> : 6.10

address(reference r)

leda_allocator<T> : 6.10

adj_edges(face)

graph : 14.1

adj_edges(node v)

graph : 14.1

adj_face(edge e)

graph : 14.1

adj_faces(node v)

graph : 14.1

adj_nodes(face f)

graph : 14.1

adj_nodes(node v)

graph : 14.1

adj_pred(edge e)

graph : 14.1

adj_pred(edge e, node v)

graph : 14.1

adj_succ(edge e)

graph : 14.1

adj_succ(edge e, node v)

graph : 14.1

AdjIt : 16.7

adjust_coords_to_box(node_array<double>& xpos, node_array<double>& ypos, double x0, double y0, double x1, double y1)

GraphWin : 20.6

adjust_coords_to_box(node_array<double>& xpos, node_array<double>& ypos, edge_array<list<double> >& xbends, edge_array<list<double> >& ybends, double x0, double y0, double x1, double y1)

GraphWin : 20.6

adjust_coords_to_win(node_array<double>& xpos, node_array<double>& ypos)

GraphWin : 20.6

adjust_coords_to_win(node_array<double>& xpos, node_array<double>& ypos, edge_array<list<double> >& xbends, edge_array<list<double> >& ybends)

GraphWin : 20.6

Adler32Coder : 12.16

affine_rank(const array<d3_point>& A) : 19.1

affine_rank(const array<d3_point>& L) : 19.1

affine_rank(const array<d3_rat_point>& A) : 19.8

affine_rank(const array<d3_rat_point>& L) : 19.8

affinely_independent(const array<d3_point>& A) : 19.1

affinely_independent(const array<d3_rat_point>& A) : 19.8

affinely_independent(const array<point>& A) : 17.1

affinely_independent(const array<rat_point>& A) : 17.10

affinely_independent(const array<real_point>& A) : 17.17

affinely_independent(const list<d3_point>& L) : 19.1

affinely_independent(const list<d3_rat_point>& L) : 19.8

alignment : 7.5

all_edges()

graph : 14.1

ALL_EMPTY_CIRCLES(const list<point>& L, list<circle>& CL) : 17.24

ALL_ENCLOSING_CIRCLES(const list<point>& L, list<circle>& CL) : 17.24

all_faces()

graph : 14.1

all_items()

d2_dictionary<K1,K2,I> : 18.1

all_nodes()

graph : 14.1

allocate(size_type n, const_pointer = 0)

leda_allocator<T> : 6.10

alphabet : 7.1

alt_key_down()

window : 20.2

angle()

line : 17.4

segment : 17.2

angle(const line& g)

line : 17.4

angle(const point& q, const point& r)

point : 17.1

angle(const ray& s)

ray : 17.3

angle(const segment& t)

segment : 17.2

angle(const vector& w)

vector : 8.10

animate(geo_scene sc, geowin_animation& anim)

GeoWin : 20.8

append(const char* key)

gml_graph : 14.26

append(const E& x)

b_queue<E> : 9.6

list<E> : 9.7

queue<E> : 9.4

slist<E> : 9.8

append(node v)

node_list : 14.18

append_directory_delimiter(string& dir) : 6.12

apply(void (*f)(E& x))

list<E> : 9.7

approximate(double dist)

r_circle_segment : 17.28

approximate_area()

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

r_circle_segment : 17.28

approximate_by_rat_gen_polygon(double dist)

r_circle_gen_polygon : 17.30

approximate_by_rat_point()

r_circle_point : 17.27

approximate_by_rat_points(double dist)

r_circle_segment : 17.28

approximate_by_rat_polygon(double dist)

r_circle_polygon : 17.29

approximate_by_rat_segments(double dist)

r_circle_segment : 17.28

area()

GEN_POLYGON : 17.7

POLYGON : 17.6

rat_rectangle : 17.16

rat_triangle : 17.15

real_rectangle : 17.23

real_triangle : 17.22

rectangle : 17.9

triangle : 17.8

area(const point& a, const point& b, const point& c) : 17.1

area(const point& q, const point& r)

point : 17.1

area(const rat_point& a, const rat_point& b, const rat_point& c) : 17.10

area(const rat_point& q, const rat_point& r)

rat_point : 17.10

area(const real_point& a, const real_point& b, const real_point& c) : 17.17

area(const real_point& q, const real_point& r)

real_point : 17.17

array2<E> : 9.2

array<E> : 9.1

ask_edge()

GraphWin : 20.6

ask_node()

GraphWin : 20.6

assign(edge e, const etype& x)

GRAPH<vtype,e...> : 14.2

PLANAR_MAP<vtype,e...> : 14.7

assign(face f, const ftype& x)

PLANAR_MAP<vtype,e...> : 14.7

assign(list_item it, const E& x)

list<E> : 9.7

assign(node v, const vtype& x)

GRAPH<vtype,e...> : 14.2

PLANAR_MAP<vtype,e...> : 14.7

AutoDecoder : 12.24

B()

d3_plane : 19.5

d3_rat_plane : 19.12

b_node_pq<N> : 14.21

b_priority_queue<I> : 11.2

b_queue<E> : 9.6

b_stack<E> : 9.5

back()

b_queue<E> : 9.6

list<E> : 9.7

basic_graph_alg : 15.1

begin()

STLNodeIt<DataAcc...> : 16.12

berry_ravindran()

string_matching : 7.2

BF_GEN(GRAPH<int,int>& G, int n, int m, bool non_negative = true) : 15.2

BFS(const graph& G, node s, node_array<int>& dist) : 15.1

BFS(const graph& G, node s, node_array<int>& dist, node_array<edge>& pred) : 15.1

BICONNECTED_COMPONENTS(const graph& G, edge_array<int>& compnum) : 15.1

bigfloat : 8.3

binary_entropy(double x) : 8.17.3

binary_locate(const E& x)

array<E> : 9.1

binary_locate(int (*cmp)(const E& , const E& ), const E& x)

array<E> : 9.1

binary_search(const E& x)

array<E> : 9.1

binary_search(int (*cmp)(const E& , const E& ), const E& x)

array<E> : 9.1

BlockCoder<Coder> : 12.25

bool_item(string s, bool& x, const char* hlp=0)

window : 20.2

bool_item(string s, bool& x, const window_handler& obj, const char* hlp=0)

window : 20.2

bool_item(string s, bool& x, void (*F)(int), const char* hlp=0)

window : 20.2

Bounding_Box(const list<point>& L, point& pl, point& pb, point& pr, point& pt) : 17.24

bounding_box(double& xmin, double& ymin, double& xmax, double& ymax)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

bounding_box(POINT& xmin, POINT& ymin, POINT& xmax, POINT& ymax)

POLYGON : 17.6

bounding_box(real& xmin, real& ymin, real& xmax, real& ymax)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

boyer_moore()

string_matching : 7.2

brute_force()

string_matching : 7.2

bucket_sort(int (*b)(const E& ))

list<E> : 9.7

bucket_sort(int i, int j, int (*b)(const E& ))

list<E> : 9.7

bucket_sort_edges(const edge_array<int>& A)

graph : 14.1

bucket_sort_edges(int (*ord)(const edge& ))

graph : 14.1

bucket_sort_edges(int l, int h, int (*ord)(const edge& ))

graph : 14.1

bucket_sort_nodes(const node_array<int>& A)

graph : 14.1

bucket_sort_nodes(int (*ord)(const node& ))

graph : 14.1

bucket_sort_nodes(int l, int h, int (*ord)(const node& ))

graph : 14.1

buffer(double d) : 17.29

r_circle_gen_polygon : 17.30

buffer(RAT_TYPE d, int p = 3)

GEN_POLYGON : 17.7

buffer(RAT_TYPE d, int p)

POLYGON : 17.6

button(char* pr1, char* pr2, string s, const window_handler& obj, const char* hlp=0)

window : 20.2

button(char* pr1, char* pr2, string s, int n, const char* hlp=0)

window : 20.2

button(char* pr1, char* pr2, string s, int n, const window_handler& obj, const char* hlp=0)

window : 20.2

button(char* pr1, char* pr2, string s, int n, void (*F)(int), const char* hlp=0)

window : 20.2

button(char* pr1, char* pr2, string s, int n, window& M, const char* hlp=0)

window : 20.2

button(char* pr1, char* pr2, string s, void (*F)(int), const char* hlp=0)

window : 20.2

button(char* pr1, char* pr2, string s, window& M, const char* hlp=0)

window : 20.2

button(int w, int h, unsigned char* bm, string s, const char* hlp=0)

window : 20.2

button(int w, int h, unsigned char* bm, string s, const window_handler& obj, const char* hlp=0)

window : 20.2

button(int w, int h, unsigned char* bm, string s, int n, const char* hlp=0)

window : 20.2

button(int w, int h, unsigned char* bm, string s, int n, const window_handler& obj, const char* hlp=0)

window : 20.2

button(int w, int h, unsigned char* bm, string s, int n, void (*F)(int), const char* hlp=0)

window : 20.2

button(int w, int h, unsigned char* bm, string s, int n, window& M, const char* hlp=0)

window : 20.2

button(int w, int h, unsigned char* bm, string s, void (*F)(int), const char* hlp=0)

window : 20.2

button(int w, int h, unsigned char* bm, string s, window& M, const char* hlp=0)

window : 20.2

button(string s)

menu : 20.4

button(string s, const char* hlp=0)

window : 20.2

button(string s, const window_handler& obj)

menu : 20.4

button(string s, const window_handler& obj, const char* hlp=0)

window : 20.2

button(string s, int n)

menu : 20.4

button(string s, int n, const char* hlp=0)

window : 20.2

button(string s, int n, const window_handler& obj)

menu : 20.4

button(string s, int n, const window_handler& obj, const char* hlp=0)

window : 20.2

button(string s, int n, void (*F)(int))

menu : 20.4

button(string s, int n, void (*F)(int), const char* hlp=0)

window : 20.2

button(string s, int n, window& M, const char* hlp=0)

window : 20.2

button(string s, int n, window& W)

menu : 20.4

button(string s, void (*F)(int))

menu : 20.4

button(string s, void (*F)(int), const char* hlp=0)

window : 20.2

button(string s, window& M, const char* hlp=0)

window : 20.2

button(string s, window& W)

menu : 20.4

button_press_time()

window : 20.2

button_release_time()

window : 20.2

buttons_per_line(int n)

window : 20.2

BWTCoder : 12.9

C()

d3_plane : 19.5

d3_rat_plane : 19.12

C_style()

array<E> : 9.1

calculate_length_of_encoded_data(uint32 input_length)

CBCCoder< BlkCipher > : 13.4

OMACCoder< BlkCipher > : 13.5

callback

graph_morphism_algorithm< graph_t > : 15.16

canonical_rep()

GEN_POLYGON : 17.7

cardinality_iso(const graph_t& g1, const graph_t& g2, const node_compat& _node_comp = DEFAULT_NODE_CMP, const edge_compat& _edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

cardinality_mono(const graph_t& g1, const graph_t& g2, const node_compat& _node_comp = DEFAULT_NODE_CMP, const edge_compat& _edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

cardinality_sub(const graph_t& g1, const graph_t& g2, const node_compat& _node_comp = DEFAULT_NODE_CMP, const edge_compat& _edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

cardinality_t

graph_morphism_algorithm< graph_t > : 15.16

cartesian_to_polar()

d3_point : 19.1

catch_system_errors(bool b=true) : 6.11

CBCCoder< BlkCipher > : 13.4

CCITTCoder : 12.15

ceil(const bigfloat& x) : 8.3

ceil(const rational& q) : 8.2

ceil(const real& x) : 8.4

center()

circle : 17.5

d3_rat_sphere : 19.13

d3_sphere : 19.6

r_circle_segment : 17.28

rat_circle : 17.14

rat_rectangle : 17.16

real_circle : 17.21

real_rectangle : 17.23

rectangle : 17.9

center(const d3_point& a, const d3_point& b) : 19.1

center(const point& a, const point& b) : 17.1

center(const real_point& a, const real_point& b) : 17.17

center_pixrect(char* pr)

window : 20.2

center_pixrect(double x, double y, char* pr)

window : 20.2

CGAL : 16.1.4 | 16.5

change_inf(dic2_item it, const I& i)

d2_dictionary<K1,K2,I> : 18.1

change_inf(dic_item it, const I& i)

dictionary<K,I> : 10.1

change_inf(is_item it, const I& i)

interval_set<I> : 18.4

change_inf(partition_item it, const E& x)

Partition<E> : 9.13

change_inf(pq_item it, const I& i)

p_queue<P,I> : 11.1

change_inf(seg_item it, const I& i)

rat_segment_set<I> : 18.6

segment_set<I> : 18.5

change_inf(seq_item it, const I& i)

sortseq<K,I> : 10.6

check()

checksummer_base : 12.13

OMACCoder< BlkCipher > : 13.5

check(string str)

checksummer_base : 12.13

Check_Euler_Tour(const graph& G, const list<edge>& T) : 15.12

Check_Euler_Tour(const graph& G, const list<two_tuple<edge,int> >& T) : 15.12

CHECK_HULL(const GRAPH<d3_point,int>& H) : 19.15

CHECK_HULL(const GRAPH<d3_rat_point,int>& H) : 19.15

CHECK_KURATOWSKI(const graph& G, const list<edge>& el) : 15.13

check_locate(POINT q, edge e)

POINT_LOCATOR : 18.3

CHECK_MAX_CARD_MATCHING(const graph& G, const list<edge>& M, const node_array<int>& OSC) : 15.8

CHECK_MCB(const graph& G, const list<edge>& M, const node_array<bool>& NC) : 15.6

check_representation()

GEN_POLYGON : 17.7

r_circle_gen_polygon : 17.30

check_representation(const list<POLYGON>& PL)

GEN_POLYGON : 17.7

check_representation(const list<r_circle_polygon>& polys, CHECK_TYPE check = WEAKLY_SIMPLE)

r_circle_gen_polygon : 17.30

check_simplicity()

POLYGON : 17.6

r_circle_polygon : 17.29

CheckStableMatching(const graph& G, const list<node>& A, const list<node>& B, const list<edge>& M) : 15.10

checksum_is_valid()

checksummer_base : 12.13

checksummer_base : 12.13

chmod_file(string fname, string option) : 6.12

choice_item(string s, int& x, const list<string>& L, const window_handler& obj, const char* hlp=0)

window : 20.2

choice_item(string s, int& x, const list<string>& L, void (*F)(int)=0, const char* hlp=0)

window : 20.2

choice_item(string s, int& x, int n, int w, int h, unsigned char** bm, const char* hlp=0)

window : 20.2

choice_item(string s, int& x, int n, int w, int h, unsigned char** bm, const window_handler& obj, const char* hlp=0)

window : 20.2

choice_item(string s, int& x, int n, int w, int h, unsigned char** bm, void (*F)(int), const char* hlp=0)

window : 20.2

choice_item(string s, int& x, string s1, ..., string sk)

window : 20.2

choice_mult_item(string s, int& x, const list<string>& L, const char* hlp=0)

window : 20.2

choice_mult_item(string s, int& x, const list<string>& L, const window_handler& obj, const char* hlp=0)

window : 20.2

choice_mult_item(string s, int& x, const list<string>& L, void (*F)(int), const char* hlp=0)

window : 20.2

choice_mult_item(string s, int& x, int n, int w, int h, unsigned char** bm, const char* hlp=0)

window : 20.2

choice_mult_item(string s, int& x, int n, int w, int h, unsigned char** bm, const window_handler& obj, const char* hlp=0)

window : 20.2

choice_mult_item(string s, int& x, int n, int w, int h, unsigned char** bm, void (*F)(int), const char* hlp=0)

window : 20.2

choice_mult_item(string s, int& x, string s1, const char* hlp=0)

window : 20.2

choice_mult_item(string s, int& x, string s1, string s2, const char* hlp=0)

window : 20.2

choose()

d_int_set : 9.11

edge_set : 14.17

node_set : 14.16

set<E> : 9.9

choose_edge()

graph : 14.1

choose_face()

graph : 14.1

choose_node()

graph : 14.1

circle : 17.5

circle()

r_circle_segment : 17.28

circulators : 16.5

circumscribing_sphere()

d3_rat_simplex : 19.14

d3_simplex : 19.7

clear()

b_priority_queue<I> : 11.2

b_queue<E> : 9.6

b_stack<E> : 9.5

CryptByteString : 13.1

d2_dictionary<K1,K2,I> : 18.1

d_array<I,E> : 10.2

d_int_set : 9.11

dictionary<K,I> : 10.1

edge_set : 14.17

graph : 14.1

h_array<I,E> : 10.3

int_set : 9.10

interval_set<I> : 18.4

list<E> : 9.7

map2<I1,I2,E> : 10.5

map<I,E> : 10.4

node_list : 14.18

node_pq<P> : 14.20

node_set : 14.16

p_queue<P,I> : 11.1

POINT_SET : 18.2

queue<E> : 9.4

rat_segment_set<I> : 18.6

segment_set<I> : 18.5

set<E> : 9.9

slist<E> : 9.8

sortseq<K,I> : 10.6

stack<E> : 9.3

window : 20.2

clear(color c)

window : 20.2

clear(const E& x)

h_array<I,E> : 10.3

map<I,E> : 10.4

clear(double x0, double y0, double x1, double y1)

window : 20.2

clear(double xorig, double yorig)

window : 20.2

clear_actions()

GeoWin : 20.8

GraphWin : 20.6

clear_graph()

GraphWin : 20.6

clear_keys()

CryptAutoDecoder : 13.6

clip(const line& l, segment& inter)

rectangle : 17.9

clip(const rat_line& l, rat_segment& inter)

rat_rectangle : 17.16

clip(const rat_ray& ry, rat_segment& inter)

rat_rectangle : 17.16

clip(const rat_segment& t, rat_segment& inter)

rat_rectangle : 17.16

clip(const ray& ry, segment& inter)

rectangle : 17.9

clip(const real_line& l, real_segment& inter)

real_rectangle : 17.23

clip(const real_ray& ry, real_segment& inter)

real_rectangle : 17.23

clip(const real_segment& t, real_segment& inter)

real_rectangle : 17.23

clip(const segment& t, segment& inter)

rectangle : 17.9

clip(point p, point q, segment& s)

line : 17.4

clip(rat_point p, rat_point q, rat_segment& s)

rat_line : 17.13

clip(real_point p, real_point q, real_segment& s)

real_line : 17.20

close()

decoding_ifstream<Coder> : 12.22

decoding_istream<Coder> : 12.20

encoding_ofstream<Coder> : 12.21

encoding_ostream<Coder> : 12.19

GeoWin : 20.8

GraphWin : 20.6

window : 20.2

CLOSEST_PAIR(list<point>& L, point& r1, point& r2) : 17.24

cmdline_graph(graph& G, int argc, char** argv) : 14.22

cmp_dist(const point& q, const point& r)

point : 17.1

cmp_dist(const rat_point& q, const rat_point& r)

rat_point : 17.10

cmp_dist(const real_point& q, const real_point& r)

real_point : 17.17

cmp_distances(const d3_point& p1, const d3_point& p2)

d3_plane : 19.5

cmp_distances(const d3_point& p1, const d3_point& p2, const d3_point& p3, const d3_point& p4) : 19.1

cmp_distances(const d3_rat_point& p1, const d3_rat_point& p2, const d3_rat_point& p3, const d3_rat_point& p4) : 19.8

cmp_distances(const point& p1, const point& p2, const point& p3, const point& p4) : 17.1

cmp_distances(const rat_point& p1, const rat_point& p2, const rat_point& p3, const rat_point& p4) : 17.10

cmp_distances(const real_point& p1, const real_point& p2, const real_point& p3, const real_point& p4) : 17.17

cmp_segments_at_xcoord(const rat_segment& s1, const rat_segment& s2, const rat_point& p) : 17.11

cmp_segments_at_xcoord(const real_segment& s1, const real_segment& s2, const real_point& p) : 17.18

cmp_segments_at_xcoord(const segment& s1, const segment& s2, const point& p) : 17.2

cmp_signed_dist(const point& a, const point& b, const point& c, const point& d) : 17.1

cmp_signed_dist(const rat_point& a, const rat_point& b, const rat_point& c, const rat_point& d) : 17.10

cmp_signed_dist(const real_point& a, const real_point& b, const real_point& c, const real_point& d) : 17.17

cmp_slope(const rat_segment& s1)

rat_segment : 17.11

cmp_slopes(const line& l1, const line& l2) : 17.4

cmp_slopes(const rat_line& l1, const rat_line& l2) : 17.13

cmp_slopes(const rat_ray& r1, const rat_ray& r2) : 17.12

cmp_slopes(const rat_segment& s1, const rat_segment& s2) : 17.11

cmp_slopes(const ray& r1, const ray& r2) : 17.3

cmp_slopes(const real_line& l1, const real_line& l2) : 17.20

cmp_slopes(const real_ray& r1, const real_ray& r2) : 17.19

cmp_slopes(const real_segment& s1, const real_segment& s2) : 17.18

cmp_slopes(const segment& s1, const segment& s2) : 17.2

cocircular(const point& a, const point& b, const point& c, const point& d) : 17.1

cocircular(const rat_point& a, const rat_point& b, const rat_point& c, const rat_point& d) : 17.10

cocircular(const real_point& a, const real_point& b, const real_point& c, const real_point& d) : 17.17

coder1

CoderPipe2<Coder1,...> : 12.23

coder2

CoderPipe2<Coder1,...> : 12.23

CoderPipe2<Coder1,...> : 12.23

col(int i)

integer_matrix : 8.13

matrix : 8.11

real_matrix : 8.16

collinear(const d3_point& a, const d3_point& b, const d3_point& c) : 19.1

collinear(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c) : 19.8

collinear(const point& a, const point& b, const point& c) : 17.1

collinear(const rat_point& a, const rat_point& b, const rat_point& c) : 17.10

collinear(const real_point& a, const real_point& b, const real_point& c) : 17.17

color : 20.1

color_item(string s, color& x, const char* hlp=0)

window : 20.2

color_item(string s, color& x, const window_handler& obj, const char* hlp=0)

window : 20.2

color_item(string s, color& x, void (*F)(int), const char* hlp=0)

window : 20.2

compare(...) : see User defined parameter types

compare(const real& y)

real : 8.4

compare_all(const growing_array<real>& R, int& j) : 8.4

compare_by_angle(const point& a, const point& b, const point& c, const point& d) : 17.1

compare_by_angle(const rat_point& a, const rat_point& b, const rat_point& c, const rat_point& d) : 17.10

compare_by_angle(const rat_vector& v1, const rat_vector& v2) : 8.14

compare_by_angle(const real_point& a, const real_point& b, const real_point& c, const real_point& d) : 17.17

compare_by_angle(const real_vector& v1, const real_vector& v2) : 8.15

compare_by_angle(const vector& v1, const vector& v2) : 8.10

compare_files(string fname1, string fname2) : 6.12

compare_tangent_slopes(const r_circle_segment& cs1, const r_circle_segment& cs2, const r_circle_point& p) : 17.28

complement()

GEN_POLYGON : 17.7

int_set : 9.10

POLYGON : 17.6

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

complete_bigraph(graph& G, int a, int b, list<node>& A, list<node>& B) : 14.22

complete_graph(graph& G, int n) : 14.22

complete_ugraph(graph& G, int n) : 14.22

compnumb()

GIT_SCC<Out,In,...> : 16.20

COMPONENTS(const graph& G, node_array<int>& compnum) : 15.1

CompPred<Iter,DA...> : 16.10

compute_bounding_box(real& xmin, real& ymin, real& xmax, real& ymax)

r_circle_segment : 17.28

compute_faces()

graph : 14.1

compute_MAC(string str)

OMACCoder< BlkCipher > : 13.5

COMPUTE_SHORTEST_PATH(const graph& G, node s, node t, const node_array<edge>& pred) : 15.2

compute_voronoi(GRAPH<CIRCLE,POINT>& V)

POINT_SET : 18.2

compute_with_precision(long k)

real : 8.4

conc(list<E>& L1, int dir = leda::behind)

list<E> : 9.7

conc(slist<E>& L)

slist<E> : 9.8

conc(sortseq<K,I,seq_impl>& S1, int dir = leda::behind)

sortseq<K,I> : 10.6

confirm(string s)

window : 20.2

connect(int sec = 10)

leda_socket : 6.13

constant_da<T> : 16.14

construct(pointer p, const_reference r)

leda_allocator<T> : 6.10

contained_in_affine_hull(const array<d3_point>& A, const d3_point& x) : 19.1

contained_in_affine_hull(const array<d3_rat_point>& A, const d3_rat_point& x) : 19.8

contained_in_affine_hull(const array<point>& A, const point& p) : 17.1

contained_in_affine_hull(const array<rat_point>& A, const rat_point& p) : 17.10

contained_in_affine_hull(const array<real_point>& A, const real_point& p) : 17.17

contained_in_affine_hull(const list<d3_point>& L, const d3_point& x) : 19.1

contained_in_affine_hull(const list<d3_rat_point>& L, const d3_rat_point& x) : 19.8

contained_in_linear_hull(const array<rat_vector>& A, const rat_vector& x) : 8.14

contained_in_simplex(const array<d3_point>& A, const d3_point& x) : 19.1

contained_in_simplex(const array<d3_rat_point>& A, const d3_rat_point& x) : 19.8

contained_in_simplex(const array<point>& A, const point& p) : 17.1

contained_in_simplex(const array<rat_point>& A, const rat_point& p) : 17.10

contained_in_simplex(const array<real_point>& A, const real_point& p) : 17.17

contained_in_simplex(const d3_point& a, const d3_point& b, const d3_point& c, const d3_point& d, const d3_point& x) : 19.1

contained_in_simplex(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c, const d3_rat_point& d, const d3_rat_point& x) : 19.8

contains(const d3_point& p)

d3_line : 19.4

d3_ray : 19.2

d3_segment : 19.3

d3_sphere : 19.6

contains(const d3_point& q)

d3_plane : 19.5

contains(const d3_rat_point& p)

d3_rat_line : 19.10

d3_rat_ray : 19.9

d3_rat_segment : 19.11

d3_rat_sphere : 19.13

contains(const d3_rat_point& q)

d3_rat_plane : 19.12

contains(const d3_rat_segment& s)

d3_rat_ray : 19.9

contains(const d3_segment& s)

d3_ray : 19.2

contains(const point& )

ray : 17.3

contains(const point& p)

circle : 17.5

GEN_POLYGON : 17.7

line : 17.4

POLYGON : 17.6

rectangle : 17.9

segment : 17.2

triangle : 17.8

window : 20.2

contains(const r_circle_point& p)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

r_circle_segment : 17.28

contains(const rat_point& p)

rat_circle : 17.14

rat_line : 17.13

rat_ray : 17.12

rat_rectangle : 17.16

rat_segment : 17.11

rat_triangle : 17.15

contains(const rat_segment& s)

rat_ray : 17.12

contains(const real_point& )

real_ray : 17.19

contains(const real_point& p)

real_circle : 17.21

real_line : 17.20

real_rectangle : 17.23

real_segment : 17.18

real_triangle : 17.22

contains(const real_segment& )

real_ray : 17.19

contains(const segment& )

ray : 17.3

contains(const string& s1)

string : 6.1

contains(double x)

interval : 8.5

contents(int i)

integer : 8.1

contents(item it)

slist<E> : 9.8

contents(list_item it)

list<E> : 9.7

contour()

r_circle_gen_polygon : 17.30

CONVEX_COMPONENTS(const gen_polygon& GP) : 17.24

CONVEX_COMPONENTS(const gen_polygon& GP, GRAPH<point,segment>& G, list<edge>& inner_edges, list<edge>& boundary_edges, list<edge>& hole_edges) : 17.24

CONVEX_COMPONENTS(const polygon& P, GRAPH<point,segment>& G, list<edge>& inner_edges, list<edge>& boundary) : 17.24

CONVEX_HULL(const list<d3_point>& L, GRAPH<d3_point,int>& H) : 19.15

CONVEX_HULL(const list<d3_rat_point>& L, GRAPH<d3_rat_point,int>& H) : 19.15

CONVEX_HULL(const list<point>& L) : 17.24

CONVEX_HULL_IC(const list<point>& L) : 17.24

CONVEX_HULL_POLY(const list<point>& L) : 17.24

CONVEX_HULL_RIC(const list<point>& L) : 17.24

CONVEX_HULL_S(const list<point>& L) : 17.24

coord(int i)

rat_vector : 8.14

real_vector : 8.15

vector : 8.10

coord_type

circle : 17.5

d3_rat_simplex : 19.14

d3_simplex : 19.7

GEN_POLYGON : 17.7

line : 17.4

point : 17.1

POLYGON : 17.6

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

rat_circle : 17.14

rat_line : 17.13

rat_point : 17.10

rat_ray : 17.12

rat_segment : 17.11

rat_triangle : 17.15

ray : 17.3

real_circle : 17.21

real_line : 17.20

real_point : 17.17

real_ray : 17.19

real_segment : 17.18

real_triangle : 17.22

segment : 17.2

triangle : 17.8

coplanar(const d3_point& a, const d3_point& b, const d3_point& c, const d3_point& d) : 19.1

coplanar(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c, const d3_rat_point& d) : 19.8

copy(int x, const array<E>& B, int y)

array<E> : 9.1

copy(int x, int y)

array<E> : 9.1

copy_file(string src, string dest) : 6.12

copy_rect(double x0, double y0, double x1, double y1, double x, double y)

window : 20.2

CopyGraph(GRAPH<node,edge>& H, const graph& G) : 14.23

CopyGraph(GRAPH<node,edge>& H, const graph& G, const list<edge>& E) : 14.23

CopyGraph(GRAPH<node,edge>& H, const graph& G, const list<node>& V, const list<edge>& E) : 14.23

CopyGraph(graph& H, const graph& G) : 14.23

counter : 6.17

CRC32Coder : 12.14

create_bitmap(int w, int h, unsigned char* bm_data)

window : 20.2

create_directory(string fname) : 6.12

create_pixrect(const char** xpm_str)

window : 20.2

create_pixrect(int w, int h, unsigned char* bm_data, int fg=window::fgcol, int bg=window::bgcol)

window : 20.2

create_pixrect(int w, int h, unsigned int bgra)

window : 20.2

create_pixrect(string xpm_file)

window : 20.2

CreateInputGraph(graph& G, list<node>& A, list<node>& B, node_map<int>& nodes_a, node_map<int>& nodes_b, const list<int>& InputA, const list<int>& InputB, const map<int, list<int> >& preferencesA, const map<int, list<int> >& preferencesB) : 15.10

cross_product(const rat_vector& v1, const rat_vector& v2) : 8.14

cross_product(const real_vector& v1, const real_vector& v2) : 8.15

cross_product(const vector& v1, const vector& v2) : 8.10

CRUST(const list<point>& L0, GRAPH<point,int>& G) : 17.24

CryptAutoDecoder : 13.6

CryptByteString : 13.1

CryptKey : 13.2

cs_code(const point& p)

rectangle : 17.9

cs_code(const rat_point& p)

rat_rectangle : 17.16

cs_code(const real_point& p)

real_rectangle : 17.23

ctrl_key_down()

window : 20.2

curr_adj()

AdjIt : 16.7

GIT_DIJKSTRA<OutAdjI...> : 16.21

InAdjIt : 16.6

OutAdjIt : 16.5

current()

GIT_BFS<OutAdjI...> : 16.17

GIT_DFS<OutAdjI...> : 16.18

GIT_DIJKSTRA<OutAdjI...> : 16.21

GIT_TOPOSORT<OutAdjI...> : 16.19

current_node()

dynamic_markov_chain : 14.25

GIT_SCC<Out,In,...> : 16.20

markov_chain : 14.24

current_outdeg()

dynamic_markov_chain : 14.25

markov_chain : 14.24

CUT_VALUE(const graph& G, const edge_array<int>& weight, const list<node>& C) : 15.5

cycle_found()

GIT_TOPOSORT<OutAdjI...> : 16.19

cyclic_adj_pred(edge e)

graph : 14.1

cyclic_adj_pred(edge e, node v)

graph : 14.1

cyclic_adj_succ(edge e)

graph : 14.1

cyclic_adj_succ(edge e, node v)

graph : 14.1

cyclic_in_pred(edge e)

graph : 14.1

cyclic_in_succ(edge e)

graph : 14.1

cyclic_pred(list_item it)

list<E> : 9.7

cyclic_pred(node v)

node_list : 14.18

cyclic_succ(item l)

slist<E> : 9.8

cyclic_succ(list_item it)

list<E> : 9.7

cyclic_succ(node v)

node_list : 14.18

D()

d3_plane : 19.5

d3_rat_plane : 19.12

d2(integer a, integer b, integer D)

rat_vector : 8.14

d2_dictionary<K1,K2,I> : 18.1

d3(integer a, integer b, integer c, integer D)

rat_vector : 8.14

d3_delaunay : 19.16

D3_DELAUNAY(const list<d3_rat_point>& L, GRAPH<d3_rat_point,int>& G) : 19.16

d3_grid_graph(graph& G, int n) : 14.22

d3_grid_graph(graph& G, node_array<double>& xcoord, node_array<double>& ycoord, node_array<double>& zcoord, int n) : 14.22

d3_hull : 19.15

d3_line : 19.4

d3_plane : 19.5

d3_point : 19.1

d3_rat_line : 19.10

d3_rat_plane : 19.12

d3_rat_point : 19.8

d3_rat_ray : 19.9

d3_rat_segment : 19.11

d3_rat_simplex : 19.14

d3_rat_sphere : 19.13

d3_ray : 19.2

d3_segment : 19.3

d3_simplex : 19.7

d3_sphere : 19.6

D3_SPRING_EMBEDDING(const graph& G, node_array<double>& xpos, node_array<double>& ypos, node_array<double>& zpos, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int iterations=250) : 15.14

D3_TRIANG(const list<d3_rat_point>& L, GRAPH<d3_rat_point,int>& G) : 19.16

D3_VORONOI(const list<d3_rat_point>& L0, GRAPH<d3_rat_sphere,int>& G) : 19.16

d3_window : 20.9

d_array<I,E> : 10.2

d_face_cycle_pred(edge e)

POINT_SET : 18.2

d_face_cycle_succ(edge e)

POINT_SET : 18.2

d_int_set : 9.11

damerau_levenshtein()

distance : 7.4

data accessor : 16.1.5

date : 6.21

days_until(const date& D2)

date : 6.21

deallocate(pointer p, size_type n)

leda_allocator<T> : 6.10

decode()

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

AutoDecoder : 12.24

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

CryptAutoDecoder : 13.6

DeflateCoder : 12.4

DictCoder : 12.5

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

decode_memory_chunk(const char* in_buf, uint32 in_len, char* out_buf, uint32 out_len)

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

AutoDecoder : 12.24

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

CryptAutoDecoder : 13.6

DeflateCoder : 12.4

DictCoder : 12.5

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

decoding_ifstream<Coder> : 12.22

decoding_istream<Coder> : 12.20

decrease_key(b_pq_item it, int newkey)

b_priority_queue<I> : 11.2

decrease_p(node v, const P& x)

node_pq<P> : 14.20

decrease_p(pq_item it, const P& x)

p_queue<P,I> : 11.1

define_area(double& x0, double& y0, double& x1, double& y1, const char* msg=")

GraphWin : 20.6

defined(const I1& i, const I2& j)

map2<I1,I2,E> : 10.5

defined(const I& i)

d_array<I,E> : 10.2

h_array<I,E> : 10.3

map<I,E> : 10.4

defined(const K& k)

dictionary<K,I> : 10.1

defined(node v, node w)

node_map2<E> : 14.15

DeflateCoder : 12.4

degree(node v)

graph : 14.1

del()

AdjIt : 16.7

EdgeIt : 16.3

InAdjIt : 16.6

NodeIt : 16.2

OutAdjIt : 16.5

del(const E& x)

set<E> : 9.9

del(const K1& x, const K2& y)

d2_dictionary<K1,K2,I> : 18.1

del(const K& k)

dictionary<K,I> : 10.1

sortseq<K,I> : 10.6

del(const rat_segment& s)

rat_segment_set<I> : 18.6

del(const segment& s)

segment_set<I> : 18.5

del(const string& s1, int i=1)

string : 6.1

del(double x, double y)

interval_set<I> : 18.4

del(edge x)

edge_set : 14.17

del(geo_scenegroup gs, geo_scene sc)

GeoWin : 20.8

del(int i)

string : 6.1

del(int i, int j)

string : 6.1

del(int x)

d_int_set : 9.11

int_set : 9.10

del(list_item it)

list<E> : 9.7

del(node v)

node_list : 14.18

node_pq<P> : 14.20

POINT_SET : 18.2

del(node w, int=0)

b_node_pq<N> : 14.21

del(node x)

node_set : 14.16

del(POINT p)

POINT_SET : 18.2

del_all(const string& s1)

string : 6.1

del_all_edges()

graph : 14.1

del_all_faces()

graph : 14.1

del_all_nodes()

graph : 14.1

del_bitmap(char* bm)

window : 20.2

del_dependence(geo_scene sc1, geo_scene sc2)

GeoWin : 20.8

del_edge(edge e)

graph : 14.1

GraphWin : 20.6

planar_map : 14.6

del_edges(const list<edge>& L)

graph : 14.1

del_item(b_pq_item x)

b_priority_queue<I> : 11.2

del_item(dic2_item it)

d2_dictionary<K1,K2,I> : 18.1

del_item(dic_item it)

dictionary<K,I> : 10.1

del_item(is_item it)

interval_set<I> : 18.4

del_item(list_item it)

list<E> : 9.7

del_item(pq_item it)

p_queue<P,I> : 11.1

del_item(seg_item it)

rat_segment_set<I> : 18.6

segment_set<I> : 18.5

del_item(seq_item it)

sortseq<K,I> : 10.6

del_menu(long menu_id)

GraphWin : 20.6

del_message()

GraphWin : 20.6

window : 20.2

del_min()

b_node_pq<N> : 14.21

b_priority_queue<I> : 11.2

node_pq<P> : 14.20

p_queue<P,I> : 11.1

del_min(P& x)

node_pq<P> : 14.20

del_node(node v)

graph : 14.1

GraphWin : 20.6

del_nodes(const list<node>& L)

graph : 14.1

del_pin_point()

GeoWin : 20.8

del_pixrect(char* pr)

window : 20.2

del_succ_item(item it)

slist<E> : 9.8

del_tooltip(int i)

window : 20.2

DELAUNAY_DIAGRAM(const list<point>& L, GRAPH<point,int>& DD) : 17.24

DELAUNAY_TRIANG(const list<point>& L, GRAPH<point,int>& DT) : 17.24

DELAUNAY_TRIANG(const list<segment>& L, GRAPH<point,segment>& G) : 17.24

DELAUNAY_TRIANG(GRAPH<point,segment>& G) : 17.24

delete_file(string fname) : 6.12

Delete_Loops(graph& G) : 14.23

delete_prepared_graph(prep_graph pg)

graph_morphism_algorithm< graph_t > : 15.16

delete_subsequence(seq_item a, seq_item b, sortseq<K,I,seq_impl>& S1)

sortseq<K,I> : 10.6

delLetter(char ch)

alphabet : 7.1

denominator()

rational : 8.2

deselect(edge e)

GraphWin : 20.6

deselect(node v)

GraphWin : 20.6

deselect_all()

GraphWin : 20.6

deselect_all_edges()

GraphWin : 20.6

deselect_all_nodes()

GraphWin : 20.6

design pattern : 16.1.1

destroy(pointer p)

leda_allocator<T> : 6.10

det()

matrix : 8.11

real_matrix : 8.16

det2x2(const residual& a, const residual& b, const residual& c, const residual& d) : 8.8

residual : 8.8

determinant(const integer_matrix& M) : 8.13

determinant(const integer_matrix& M, integer_matrix& L, integer_matrix& U, array<int>& q, integer_vector& c) : 8.13

DFS(const graph& G, node s, node_array<bool>& reached) : 15.1

DFS_NUM(const graph& G, node_array<int>& dfsnum, node_array<int>& compnum) : 15.1

diamond(int j, const int_Polynomial& iP, algorithm_type algorithm = isolating_algorithm, bool is_squarefree = true) : 8.4

diamond(int j, const Polynomial& P, algorithm_type algorithm, bool is_squarefree) : 8.4

diamond(rational l, rational u, const int_Polynomial& iP, algorithm_type algorithm = isolating_algorithm, bool is_squarefree = true) : 8.4

diamond(rational l, rational u, const Polynomial& P, algorithm_type algorithm, bool is_squarefree) : 8.4

diamond_short(rational l, rational u, const Polynomial& P, algorithm_type algorithm, bool is_squarefree) : 8.4

DictCoder : 12.5

dictionary<K,I> : 10.1

diff(const d_int_set& T)

d_int_set : 9.11

diff(const GEN_POLYGON& Q)

GEN_POLYGON : 17.7

diff(const int_set& T)

int_set : 9.10

diff(const r_circle_gen_polygon& Q)

r_circle_gen_polygon : 17.30

diff(const set<E,set_impl>& T)

set<E> : 9.9

diff_approximate(const r_circle_gen_polygon& Q, double dist = 1e-2)

r_circle_gen_polygon : 17.30

difference(const rat_rectangle& q, list<rat_rectangle>& L)

rat_rectangle : 17.16

difference(const real_rectangle& q, list<real_rectangle>& L)

real_rectangle : 17.23

difference(const rectangle& q, list<rectangle>& L)

rectangle : 17.9

dim()

integer_vector : 8.12

POINT_SET : 18.2

rat_vector : 8.14

real_vector : 8.15

vector : 8.10

dim1()

integer_matrix : 8.13

matrix : 8.11

real_matrix : 8.16

dim2()

integer_matrix : 8.13

matrix : 8.11

real_matrix : 8.16

direction()

line : 17.4

ray : 17.3

segment : 17.2

disable_button(int b)

window : 20.2

disable_buttons()

window : 20.2

disable_call(int id)

GraphWin : 20.6

disable_calls()

GraphWin : 20.6

disable_item(panel_item it)

window : 20.2

disable_menus()

GeoWin : 20.8

disable_panel(bool disable_every_item=true)

window : 20.2

disconnect()

leda_socket : 6.13

display()

GraphWin : 20.6

window : 20.2

display(int x = window::center, int y = window::center)

GeoWin : 20.8

display(int x, int y)

GraphWin : 20.6

window : 20.2

display(window& W0, int x, int y)

window : 20.2

display_help_text(string fname)

GraphWin : 20.6

window : 20.2

dist(const real& x, const real& y) : 8.4

dist(const real_point& p)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

r_circle_segment : 17.28

distance : 7.4

distance()

d3_point : 19.1

point : 17.1

real_point : 17.17

real_segment : 17.18

segment : 17.2

distance(const circle& D)

circle : 17.5

distance(const d3_point& p)

d3_line : 19.4

distance(const d3_point& q)

d3_plane : 19.5

d3_point : 19.1

distance(const line& l)

circle : 17.5

distance(const point& p)

circle : 17.5

GEN_POLYGON : 17.7

POLYGON : 17.6

segment : 17.2

distance(const point& q)

line : 17.4

point : 17.1

distance(const real_circle& D)

real_circle : 17.21

distance(const real_line& l)

real_circle : 17.21

distance(const real_point& p)

real_circle : 17.21

real_segment : 17.18

distance(const real_point& q)

real_line : 17.20

real_point : 17.17

div(const residual& a, const residual& b)

residual : 8.8

div(double a, double b, double p)

residual : 8.7

do_intersect(const rat_rectangle& b)

rat_rectangle : 17.16

do_intersect(const real_rectangle& b)

real_rectangle : 17.23

do_intersect(const rectangle& b)

rectangle : 17.9

double_item(string s, double& x, const char* hlp=0)

window : 20.2

double_quotient(const integer& a, const integer& b) : 8.1

draw()

d3_window : 20.9

draw_arc(const point& p, const point& q, const point& r, color c=window::fgcol)

window : 20.2

draw_arc_arrow(const point& p, const point& q, const point& r, color c=window::fgcol)

window : 20.2

draw_arrow(const point& p, const point& q, color c=window::fgcol)

window : 20.2

draw_arrow(const segment& s, color=window::fgcol)

window : 20.2

draw_arrow(double x1, double y1, double x2, double y2, color c =window::fgcol)

window : 20.2

draw_arrow_head(const point& p, double dir, color c=window::fgcol)

window : 20.2

draw_bezier(const list<point>& C, int n, color c=window::fgcol)

window : 20.2

draw_bezier_arrow(const list<point>& C, int n, color c=window::fgcol)

window : 20.2

draw_box(const rectangle& R, color c=window::fgcol)

window : 20.2

draw_box(double x0, double y0, double x1, double y1, color c=window::fgcol)

window : 20.2

draw_box(point p, point q, color c=window::fgcol)

window : 20.2

draw_circle(const circle& C, color c=window::fgcol)

window : 20.2

draw_circle(const point& p, double r, color c=window::fgcol)

window : 20.2

draw_circle(double x, double y, double r, color c=window::fgcol)

window : 20.2

draw_closed_spline(const list<point>& L, int n, color c=window::fgcol)

window : 20.2

draw_ctext(const point& p, string s, color c=window::fgcol)

window : 20.2

draw_ctext(double x, double y, string s, color c=window::fgcol)

window : 20.2

draw_ctext(string s, color c=window::fgcol)

window : 20.2

draw_disc(const circle& C, color c=window::fgcol)

window : 20.2

draw_disc(const point& p, double r, color c=window::fgcol)

window : 20.2

draw_disc(double x, double y, double r, color c=window::fgcol)

window : 20.2

draw_edge(const point& p, const point& q, color c=window::fgcol)

window : 20.2

draw_edge(const segment& s, color c=window::fgcol)

window : 20.2

draw_edge(double x1, double y1, double x2, double y2, color c=window::fgcol)

window : 20.2

draw_edge(edge e, void (*draw_diagram_edge)(const POINT& , const POINT& ), void (*draw_triang_edge) (const POINT& , const POINT& ), void (*draw_hull_dart) (const POINT& , const POINT& ))

POINT_SET : 18.2

draw_edge_arrow(const point& p, const point& q, color c=window::fgcol)

window : 20.2

draw_edge_arrow(const segment& s, color c=window::fgcol)

window : 20.2

draw_edge_arrow(double x1, double y1, double x2, double y2, color c=window::fgcol)

window : 20.2

draw_edges(const list<edge>& L, void (*draw_edge)(const POINT& , const POINT& ))

POINT_SET : 18.2

draw_edges(void (*draw_diagram_edge)(const POINT& , const POINT& ), void (*draw_triang_edge) (const POINT& , const POINT& ), void (*draw_hull_dart) (const POINT& , const POINT& ))

POINT_SET : 18.2

draw_ellipse(const point& p, double r1, double r2, color c=window::fgcol)

window : 20.2

draw_ellipse(double x, double y, double r1, double r2, color c=window::fgcol)

window : 20.2

draw_filled_circle(const circle& C, color c=window::fgcol)

window : 20.2

draw_filled_circle(const point& p, double r, color c=window::fgcol)

window : 20.2

draw_filled_circle(double x, double y, double r, color c=window::fgcol)

window : 20.2

draw_filled_ellipse(const point& p, double r1, double r2, color c=window::fgcol)

window : 20.2

draw_filled_ellipse(double x, double y, double r1, double r2, color c=window::fgcol)

window : 20.2

draw_filled_node(const point& p, color c=window::bgcol)

window : 20.2

draw_filled_node(double x0, double y0, color c=window::bgcol)

window : 20.2

draw_filled_polygon(const gen_polygon& P, color c=window::fgcol)

window : 20.2

draw_filled_polygon(const list<point>& lp, color c=window::fgcol)

window : 20.2

draw_filled_polygon(const polygon& P, color c=window::fgcol)

window : 20.2

draw_filled_rectangle(const rectangle& R, color=window::fgcol)

window : 20.2

draw_filled_rectangle(point p, point q, color=window::fgcol)

window : 20.2

draw_filled_triangle(const triangle& T, color=window::fgcol)

window : 20.2

draw_filled_triangle(point a, point b, point c, color=window::fgcol)

window : 20.2

draw_hline(double y, color c=window::fgcol)

window : 20.2

draw_hull(void (*draw_poly)(const list<POINT>& ))

POINT_SET : 18.2

draw_int_node(const point& p, int i, color c=window::bgcol)

window : 20.2

draw_int_node(double x, double y, int i, color c=window::bgcol)

window : 20.2

draw_line(const line& l, color c=window::fgcol)

window : 20.2

draw_line(const point& p, const point& q, color c=window::fgcol)

window : 20.2

draw_line(const segment& s, color c=window::fgcol)

window : 20.2

draw_line(double x1, double y1, double x2, double y2, color c=window::fgcol)

window : 20.2

draw_node(const point& p, color c=window::fgcol)

window : 20.2

draw_node(double x0, double y0, color c=window::fgcol)

window : 20.2

draw_nodes(void (*draw_node)(const POINT& ))

POINT_SET : 18.2

draw_oriented_polygon(const gen_polygon& P, color c=window::fgcol)

window : 20.2

draw_oriented_polygon(const list<point>& lp, color c=window::fgcol)

window : 20.2

draw_oriented_polygon(const polygon& P, color c=window::fgcol)

window : 20.2

draw_pixel(const point& p, color c=window::fgcol)

window : 20.2

draw_pixel(double x, double y, color c=window::fgcol)

window : 20.2

draw_pixels(const list<point>& L, color c=window::fgcol)

window : 20.2

draw_pixels(int n, double* xcoord, double* ycoord, color c=window::fgcol)

window : 20.2

draw_point(const point& p, color c=window::fgcol)

window : 20.2

draw_point(double x, double y, color c=window::fgcol)

window : 20.2

draw_polygon(const gen_polygon& P, color c=window::fgcol)

window : 20.2

draw_polygon(const list<point>& lp, color c=window::fgcol)

window : 20.2

draw_polygon(const polygon& P, color c=window::fgcol)

window : 20.2

draw_polyline(const list<point>& lp, color c=window::fgcol)

window : 20.2

draw_polyline(int n, double* xc, double* yc, color c=window::fgcol)

window : 20.2

draw_polyline_arrow(const list<point>& lp, color c=window::fgcol)

window : 20.2

draw_ray(const point& p, const point& q, color c=window::fgcol)

window : 20.2

draw_ray(const ray& r, color c=window::fgcol)

window : 20.2

draw_ray(const segment& s, color c=window::fgcol)

window : 20.2

draw_ray(double x1, double y1, double x2, double y2, color c=window::fgcol)

window : 20.2

draw_ray(point p, point q, line l, color c = window::fgcol)

window : 20.2

draw_rectangle(const rectangle& R, color=window::fgcol)

window : 20.2

draw_rectangle(double x0, double y0, double x1, double y1, color=window::fgcol)

window : 20.2

draw_rectangle(point p, point q, color=window::fgcol)

window : 20.2

draw_roundbox(double x0, double y0, double x1, double y1, double rndness, color col=window::fgcol)

window : 20.2

draw_roundbox(point p, point q, double rndness, color col=window::fgcol)

window : 20.2

draw_roundrect(double x0, double y0, double x1, double y1, double rndness, color col=window::fgcol)

window : 20.2

draw_roundrect(point p, point q, double rndness, color col=window::fgcol)

window : 20.2

draw_segment(const point& p, const point& q, color c=window::fgcol)

window : 20.2

draw_segment(const segment& s, color c=window::fgcol)

window : 20.2

draw_segment(double x1, double y1, double x2, double y2, color c=window::fgcol)

window : 20.2

draw_segment(point p, point q, line l, color c = window::fgcol)

window : 20.2

draw_segments(const list<segment>& L, color c=window::fgcol)

window : 20.2

draw_spline(const list<point>& L, int n, color c=window::fgcol)

window : 20.2

draw_spline(const polygon& P, int n, color c=window::fgcol)

window : 20.2

draw_spline_arrow(const list<point>& L, int n, color c=window::fgcol)

window : 20.2

draw_text(const point& p, string s, color c=window::fgcol)

window : 20.2

draw_text(double x, double y, string s, color c=window::fgcol)

window : 20.2

draw_text_node(const point& p, string s, color c=window::bgcol)

window : 20.2

draw_text_node(double x, double y, string s, color c=window::bgcol)

window : 20.2

draw_triangle(const triangle& T, color=window::fgcol)

window : 20.2

draw_triangle(point a, point b, point c, color=window::fgcol)

window : 20.2

draw_vline(double x, color c=window::fgcol)

window : 20.2

draw_voro(const GRAPH<CIRCLE,POINT>& , void (*draw_node)(const POINT& ), void (*draw_edge)(const POINT& , const POINT& ), void (*draw_ray) (const POINT& , const POINT& ))

POINT_SET : 18.2

draw_voro_edges(void (*draw_edge)(const POINT& , const POINT& ), void (*draw_ray) (const POINT& , const POINT& ))

POINT_SET : 18.2

dual()

line : 17.4

rat_line : 17.13

real_line : 17.20

dual_map(graph& D)

graph : 14.1

dx()

d3_rat_segment : 19.11

d3_segment : 19.3

rat_segment : 17.11

real_segment : 17.18

segment : 17.2

dxD()

rat_segment : 17.11

dy()

d3_rat_segment : 19.11

d3_segment : 19.3

rat_segment : 17.11

real_segment : 17.18

segment : 17.2

dyD()

rat_segment : 17.11

dynamic_markov_chain : 14.25

dynamic_random_variate : 6.8

dz()

d3_rat_segment : 19.11

d3_segment : 19.3

edge

graph_morphism_algorithm< graph_t > : 15.16

static_graph : 14.3.7

edge_array<E> : 14.9

edge_compat

graph_morphism_algorithm< graph_t > : 15.16

edge_data()

GRAPH<vtype,e...> : 14.2

edge_map<E> : 14.12

edge_morphism

graph_morphism_algorithm< graph_t > : 15.16

edge_set : 14.17

edge_value_type

GRAPH<vtype,e...> : 14.2

EdgeIt : 16.3

edges()

GEN_POLYGON : 17.7

r_circle_gen_polygon : 17.30

edit()

GeoWin : 20.8

GraphWin : 20.6

edit(geo_scene sc)

GeoWin : 20.8

elapsed_time() : 6.15

timer : 6.16

elapsed_time(float& T) : 6.15

element_type

d_array<I,E> : 10.2

map2<I1,I2,E> : 10.5

map<I,E> : 10.4

eliminate_cocircular_vertices()

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

eliminate_colinear_vertices()

GEN_POLYGON : 17.7

POLYGON : 17.6

empty()

b_priority_queue<I> : 11.2

b_queue<E> : 9.6

b_stack<E> : 9.5

d2_dictionary<K1,K2,I> : 18.1

d_int_set : 9.11

dictionary<K,I> : 10.1

edge_set : 14.17

GEN_POLYGON : 17.7

graph : 14.1

h_array<I,E> : 10.3

interval_set<I> : 18.4

list<E> : 9.7

node_list : 14.18

node_pq<P> : 14.20

node_set : 14.16

p_queue<P,I> : 11.1

POINT_SET : 18.2

POLYGON : 17.6

queue<E> : 9.4

rat_segment_set<I> : 18.6

segment_set<I> : 18.5

set<E> : 9.9

slist<E> : 9.8

sortseq<K,I> : 10.6

stack<E> : 9.3

string : 6.1

enable_button(int b)

window : 20.2

enable_buttons()

window : 20.2

enable_call(int id)

GraphWin : 20.6

enable_calls()

GraphWin : 20.6

enable_item(panel_item it)

window : 20.2

enable_label_box(bool b)

GraphWin : 20.6

enable_menus()

GeoWin : 20.8

enable_panel()

window : 20.2

encode()

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

DeflateCoder : 12.4

DictCoder : 12.5

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

encode_memory_chunk(const char* in_buf, uint32 in_len, char* out_buf, uint32 out_len)

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

DeflateCoder : 12.4

DictCoder : 12.5

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

encoding_ofstream<Coder> : 12.21

encoding_ostream<Coder> : 12.19

end()

rat_segment : 17.11

real_segment : 17.18

segment : 17.2

STLNodeIt<DataAcc...> : 16.12

ends_with(const string& s1)

string : 6.1

enumerate_iso(const graph_t& g1, const graph_t& g2, leda_callback_base<morphism>& _callback, const node_compat& _node_comp = DEFAULT_NODE_CMP, const edge_compat& _edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

enumerate_mono(const graph_t& g1, const graph_t& g2, leda_callback_base<morphism>& _callback, const node_compat& _node_comp = DEFAULT_NODE_CMP, const edge_compat& _edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

enumerate_sub(const graph_t& g1, const graph_t& g2, leda_callback_base<morphism>& _callback, const node_compat& _node_comp = DEFAULT_NODE_CMP, const edge_compat& _edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

eol()

AdjIt : 16.7

EdgeIt : 16.3

FaceCirc : 16.8

FaceIt : 16.4

InAdjIt : 16.6

NodeIt : 16.2

OutAdjIt : 16.5

equal_as_sets(const r_circle_segment& cs1, const r_circle_segment& cs2) : 17.28

equal_as_sets(const rat_circle& C1, const rat_circle& C2) : 17.14

equal_as_sets(const rat_line& l, const rat_line& g) : 17.13

equal_as_sets(const rat_segment& s, const rat_segment& t) : 17.11

erase(list_item it)

list<E> : 9.7

error : 6.11

error_handler(int err_no, const char* msg) : 6.11

euler_tour : 15.12

Euler_Tour(const graph& G, list<two_tuple<edge,int> >& T) : 15.12

Euler_Tour(graph& G, list<edge>& T) : 15.12

extract(list_item it1, list_item it2, list<E>& L1, bool inclusive = true)

list<E> : 9.7

F_DELAUNAY_DIAGRAM(const list<point>& L, GRAPH<point,int>& FDD) : 17.24

F_DELAUNAY_TRIANG(const list<point>& L, GRAPH<point,int>& FDT) : 17.24

F_VORONOI(const list<point>& L, GRAPH<circle,point>& FVD) : 17.24

face_array<E> : 14.10

face_cycle_pred(edge e)

graph : 14.1

face_cycle_succ(edge e)

graph : 14.1

face_map<E> : 14.13

face_of(edge e) : 14.1

graph : 14.1

FaceCirc : 16.8

FaceIt : 16.4

factorial(const integer& n) : 8.1

failed()

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

AutoDecoder : 12.24

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

CryptAutoDecoder : 13.6

DeflateCoder : 12.4

DictCoder : 12.5

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

secure_socket_streambuf : 13.7

socket_streambuf : 6.14

fbutton(string s, const char* hlp=0)

window : 20.2

fbutton(string s, int n, const char* hlp=0)

window : 20.2

fbutton(string s, int n, const window_handler& obj, const char* hlp=0)

window : 20.2

fbutton(string s, int n, void (*F)(int), const char* hlp=0)

window : 20.2

FEASIBLE_FLOW(const graph& G, const node_array<int>& supply, const edge_array<int>& cap, edge_array<int>& flow) : 15.4

FEASIBLE_FLOW(const graph& G, const node_array<int>& supply, const edge_array<int>& lcap, const edge_array<int>& ucap, edge_array<int>& flow) : 15.4

file : 6.12

file_istream : 6.2

file_ostream : 6.3

fill_win_params(double wx0, double wy0, double wx1, double wy1, double x0, double y0, double x1, double y1, double& dx, double& dy, double& fx, double& fy)

GraphWin : 20.6

fill_win_params(double wx0, double wy0, double wx1, double wy1, node_array<double>& xpos, node_array<double>& ypos, edge_array<list<double> >& xbends, edge_array<list<double> >& ybends, double& dx, double& dy, double& fx, double& fy)

GraphWin : 20.6

fill_win_params(double wx0, double wy0, double wx1, double wy1, node_array<double>& xpos, node_array<double>& ypos, node_array<double>& xrad, node_array<double>& yrad, edge_array<list<double> >& xbends, edge_array<list<double> >& ybends, double& dx, double& dy, double& fx, double& fy)

GraphWin : 20.6

fill_window()

GeoWin : 20.8

FilterNodeIt<Predica...> : 16.9

find(node v)

node_partition : 14.19

find(partition_item p)

partition : 9.12

Partition<E> : 9.13

find_all_iso(const graph_t& g1, const graph_t& g2, list<morphism*>& _isomorphisms, const node_compat& _node_comp = DEFAULT_NODE_CMP, const edge_compat& _edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

find_all_mono(const graph_t& g1, const graph_t& g2, list<morphism*>& _isomorphisms, const node_compat& _node_comp = DEFAULT_NODE_CMP, const edge_compat& _edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

find_all_sub(const graph_t& g1, const graph_t& g2, list<morphism*>& _isomorphisms, const node_compat& _node_comp = DEFAULT_NODE_CMP, const edge_compat& _edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

find_iso(const graph_t& g1, const graph_t& g2, node_morphism* _node_morph = NULL, edge_morphism* _edge_morph = NULL, const node_compat& _node_comp = DEFAULT_NODE_CMP, const edge_compat& _edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

find_min()

b_priority_queue<I> : 11.2

node_pq<P> : 14.20

p_queue<P,I> : 11.1

find_mono(const graph_t& g1, const graph_t& g2, node_morphism* _node_morph = NULL, edge_morphism* _edge_morph = NULL, const node_compat& _node_comp = DEFAULT_NODE_CMP, const edge_compat& _edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

find_sub(const graph_t& g1, const graph_t& g2, node_morphism* _node_morph = NULL, edge_morphism* _edge_morph = NULL, const node_compat& _node_comp = DEFAULT_NODE_CMP, const edge_compat& _edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

finger_locate(const K& k)

sortseq<K,I> : 10.6

finger_locate(seq_item it, const K& k)

sortseq<K,I> : 10.6

finger_locate_from_front(const K& k)

sortseq<K,I> : 10.6

finger_locate_from_rear(const K& k)

sortseq<K,I> : 10.6

finger_locate_pred(const K& k)

sortseq<K,I> : 10.6

finger_locate_pred(seq_item it, const K& k)

sortseq<K,I> : 10.6

finger_locate_pred_from_front(const K& k)

sortseq<K,I> : 10.6

finger_locate_pred_from_rear(const K& k)

sortseq<K,I> : 10.6

finger_locate_succ(const K& k)

sortseq<K,I> : 10.6

finger_locate_succ(seq_item it, const K& k)

sortseq<K,I> : 10.6

finger_locate_succ_from_front(const K& k)

sortseq<K,I> : 10.6

finger_locate_succ_from_rear(const K& k)

sortseq<K,I> : 10.6

finger_lookup(const K& k)

sortseq<K,I> : 10.6

finger_lookup(seq_item it, const K& k)

sortseq<K,I> : 10.6

finger_lookup_from_front(const K& k)

sortseq<K,I> : 10.6

finger_lookup_from_rear(const K& k)

sortseq<K,I> : 10.6

finish()

decoding_ifstream<Coder> : 12.22

decoding_istream<Coder> : 12.20

finish_algo()

GIT_BFS<OutAdjI...> : 16.17

GIT_DFS<OutAdjI...> : 16.18

GIT_DIJKSTRA<OutAdjI...> : 16.21

GIT_SCC<Out,In,...> : 16.20

GIT_TOPOSORT<OutAdjI...> : 16.19

finish_construction()

static_graph : 14.3.7

finish_menu_bar()

GraphWin : 20.6

finished()

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

AutoDecoder : 12.24

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

CryptAutoDecoder : 13.6

DeflateCoder : 12.4

DictCoder : 12.5

GIT_BFS<OutAdjI...> : 16.17

GIT_DFS<OutAdjI...> : 16.18

GIT_DIJKSTRA<OutAdjI...> : 16.21

GIT_SCC<Out,In,...> : 16.20

GIT_TOPOSORT<OutAdjI...> : 16.19

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

first()

four_tuple<A,B,C,D> : 6.20

list<E> : 9.7

slist<E> : 9.8

three_tuple<A,B,C> : 6.19

two_tuple<A,B> : 6.18

first_adj_edge(node v)

graph : 14.1

first_edge()

graph : 14.1

first_face()

graph : 14.1

first_face_edge(face f)

graph : 14.1

first_file_in_path(string fname, string path, char sep = ':') : 6.12

first_in_edge(node v)

graph : 14.1

first_node()

graph : 14.1

first_type

four_tuple<A,B,C,D> : 6.20

three_tuple<A,B,C> : 6.19

two_tuple<A,B> : 6.18

fit_pixrect(char* pr)

window : 20.2

FIVE_COLOR(graph& G, node_array<int>& C) : 15.13

flip_items(seq_item a, seq_item b)

sortseq<K,I> : 10.6

float_type

GEN_POLYGON : 17.7

POLYGON : 17.6

rat_circle : 17.14

rat_line : 17.13

rat_point : 17.10

rat_ray : 17.12

rat_segment : 17.11

real_point : 17.17

floatf : 8.9

floor(const bigfloat& x) : 8.3

floor(const rational& q) : 8.2

floor(const real& x) : 8.4

flush_buffer()

window : 20.2

flush_buffer(double dx, double dy)

window : 20.2

flush_buffer(double dx, double dy, double x0, double y0, double x1, double y1)

window : 20.2

flush_buffer(double x0, double y0, double x1, double y1)

window : 20.2

forall_edges(e, G) : 14.3.7

forall_in_edges(e, v) : 14.3.7 | 14.3.7

forall_nodes(v, G) : 14.3.7

forall_out_edges(e, v) : 14.3.7 | 14.3.7 | 14.3.7

four_tuple<A,B,C,D> : 6.20

fourth()

four_tuple<A,B,C,D> : 6.20

fourth_type

four_tuple<A,B,C,D> : 6.20

frac(double a)

residual : 8.8

from_hex_string(const char* hex_str)

CryptByteString : 13.1

from_string(const char* str)

CryptByteString : 13.1

from_string(string s)

integer : 8.1

from_string(string s, sz_t bin_prec=global_input_prec)

bigfloat : 8.3

front()

b_queue<E> : 9.6

list<E> : 9.7

full()

GEN_POLYGON : 17.7

galil_seiferas()

string_matching : 7.2

garner_sign()

residual : 8.8

gcd(const integer& a, const integer& b) : 8.1

GEN_POLYGON : 17.7

general_levenshtein()

distance : 7.4

generate()

dynamic_random_variate : 6.8

random_variate : 6.7

generate_key(uint16 key_size, const CryptByteString& passphrase, const CryptByteString& salt = CryptByteString(), uint32 num_iterations = 4096)

CryptKey : 13.2

generate_key(uint16 key_size, const CryptByteString& seed, uint32 num_iterations)

CryptKey : 13.2

generate_key_and_salt(uint16 key_size, uint16 salt_size, const CryptByteString& passphrase, CryptByteString& salt, uint32 num_iterations = 4096)

CryptKey : 13.2

generate_salt(uint16 salt_size)

CryptKey : 13.2

Genus(const graph& G) : 14.23

geo_alg : 17.24

GeoWin : 20.8

get()

random_source : 6.6

get(const constant_da<T>& ca, const Iter& it) : 16.14

get(const node_array_da<T>& da, const Iter& it) : 16.13

get(const node_attribute_da<T>& ma, const Iter& it) : 16.16

get(const node_member_da<Str,T>& ma, const Iter& it) : 16.15

get(int i)

string : 6.1

get(int x)

array<E> : 9.1

get_accepted_key_size(uint16& min, uint16& max)

CBCCoder< BlkCipher > : 13.4

OMACCoder< BlkCipher > : 13.5

get_action(long mask)

GeoWin : 20.8

GraphWin : 20.6

get_active_line_width(geo_scene sc)

GeoWin : 20.8

get_active_scene()

GeoWin : 20.8

get_arrow(edge e)

d3_window : 20.9

get_bg_color()

GeoWin : 20.8

get_bg_pixmap()

GeoWin : 20.8

get_bigfloat_error()

real : 8.4

get_block_cipher()

CBCCoder< BlkCipher > : 13.4

get_block_size()

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

checksummer_base : 12.13

get_bounding_box(const list<node>& V, const list<edge>& E, double& x0, double& y0, double& x1, double& y1)

GraphWin : 20.6

get_bounding_box(double& x0, double& y0, double& x1, double& y1)

GraphWin : 20.6

get_bounding_box(POINT& lower_left, POINT& upper_right)

POINT_SET : 18.2

get_buffer()

memory_streambuf : 12.26

get_button(string s)

window : 20.2

get_button_label(int but)

window : 20.2

get_bytes()

CryptByteString : 13.1

get_call_button()

window : 20.2

get_call_item()

window : 20.2

get_call_window()

window : 20.2

get_capacity()

memory_streambuf : 12.26

get_checksum_as_hex_string()

checksummer_base : 12.13

get_checksums_in_stream_flag()

checksummer_base : 12.13

get_client_data(geo_scene sc, int i=0)

GeoWin : 20.8

get_client_data(int i=0)

window : 20.2

get_coder()

AutoDecoder : 12.24

BlockCoder<Coder> : 12.25

CryptAutoDecoder : 13.6

decoding_ifstream<Coder> : 12.22

decoding_istream<Coder> : 12.20

encoding_ofstream<Coder> : 12.21

encoding_ostream<Coder> : 12.19

get_coder1()

CoderPipe2<Coder1,...> : 12.23

get_coder2()

CoderPipe2<Coder1,...> : 12.23

get_color(edge e)

d3_window : 20.9

get_color(geo_scene sc)

GeoWin : 20.8

get_color(node v)

d3_window : 20.9

get_compression_level()

DeflateCoder : 12.4

get_convex_hull()

POINT_SET : 18.2

get_cursor()

window : 20.2

get_cyclic_colors(geo_scene sc)

GeoWin : 20.8

get_d2_position(node_array<point>& d2pos)

d3_window : 20.9

get_d3_elimination()

GeoWin : 20.8

get_d3_fcn(geo_scene sc)

GeoWin : 20.8

get_d3_show_edges()

GeoWin : 20.8

get_d3_solid()

GeoWin : 20.8

get_date()

date : 6.21

get_day()

date : 6.21

get_day_in_year()

date : 6.21

get_day_of_week()

date : 6.21

get_dec_buffer_size()

DeflateCoder : 12.4

get_default_key_size()

CBCCoder< BlkCipher > : 13.4

OMACCoder< BlkCipher > : 13.5

get_default_value()

map<I,E> : 10.4

get_description()

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

AutoDecoder : 12.24

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

CryptAutoDecoder : 13.6

DeflateCoder : 12.4

DictCoder : 12.5

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

get_description(geo_scene sc)

GeoWin : 20.8

get_directories(string dir) : 6.12

get_directory() : 6.12

get_directory_delimiter() : 6.12

get_double_error()

interval : 8.5

real : 8.4

get_double_lower_bound()

real : 8.4

get_double_upper_bound()

real : 8.4

get_dow_name()

date : 6.21

get_draw_edges()

d3_window : 20.9

get_edge()

AdjIt : 16.7

EdgeIt : 16.3

FaceCirc : 16.8

InAdjIt : 16.6

OutAdjIt : 16.5

get_edge_param()

GraphWin : 20.6

get_edges_in_area(double x0, double y0, double x1, double y1)

GraphWin : 20.6

get_edit_edge()

GraphWin : 20.6

get_edit_mode(geo_scene sc)

GeoWin : 20.8

get_edit_node()

GraphWin : 20.6

get_edit_slider()

GraphWin : 20.6

get_effective_significant_length(void)

bigfloat : 8.3

get_element_list(list<int>& L)

d_int_set : 9.11

get_elim()

d3_window : 20.9

get_enc_buffer_size()

DeflateCoder : 12.4

get_entries(string dir) : 6.12

get_environment(string var) : 6.15

get_environment(string var, string& val) : 6.15

get_error()

secure_socket_streambuf : 13.7

socket_streambuf : 6.14

get_error_handler() : 6.11

get_event(int& val, double& x, double& y)

window : 20.2

get_exponent(void)

bigfloat : 8.3

get_face()

FaceIt : 16.4

get_files(string dir) : 6.12

get_files(string dir, string pattern) : 6.12

get_fill_color(geo_scene sc)

GeoWin : 20.8

get_garnertable()

residual : 8.8

get_geowin()

window : 20.2

get_geowin(geo_scene sc) : 20.8

get_graph()

AdjIt : 16.7

edge_array<E> : 14.9

edge_map<E> : 14.12

EdgeIt : 16.3

face_array<E> : 14.10

face_map<E> : 14.13

FaceCirc : 16.8

FaceIt : 16.4

GraphWin : 20.6

InAdjIt : 16.6

node_array<E> : 14.8

node_map<E> : 14.11

NodeIt : 16.2

OutAdjIt : 16.5

get_graphwin()

window : 20.2

get_grid_dist()

GeoWin : 20.8

window : 20.2

get_grid_mode()

window : 20.2

get_grid_style()

GeoWin : 20.8

window : 20.2

get_handle_defining_points(geo_scene sc)

GeoWin : 20.8

get_home_directory() : 6.12

get_host()

leda_socket : 6.13

get_hull_dart()

POINT_SET : 18.2

get_hull_edge()

POINT_SET : 18.2

get_in_stack()

GIT_SCC<Out,In,...> : 16.20

get_incoming_packet_size()

secure_socket_streambuf : 13.7

socket_streambuf : 6.14

get_incremental_update_limit(geo_scene sc)

GeoWin : 20.8

get_incremental_update_state(geo_scene sc)

GeoWin : 20.8

get_initialization_vector()

CBCCoder< BlkCipher > : 13.4

get_input_format()

date : 6.21

get_input_format_str()

date : 6.21

get_ip()

leda_socket : 6.13

get_item(int i)

list<E> : 9.7

get_item(string s)

window : 20.2

get_key()

CBCCoder< BlkCipher > : 13.4

OMACCoder< BlkCipher > : 13.5

get_keys()

CryptAutoDecoder : 13.6

get_language()

date : 6.21

get_limit()

leda_socket : 6.13

get_line_style()

window : 20.2

get_line_style(geo_scene sc)

GeoWin : 20.8

get_line_width()

window : 20.2

get_line_width(geo_scene sc)

GeoWin : 20.8

get_lower_bound()

real : 8.4

get_MAC_as_hex_string()

OMACCoder< BlkCipher > : 13.5

get_MAC_in_stream_flag()

OMACCoder< BlkCipher > : 13.5

get_max_scale_threshold()

A0Coder : 12.1

get_maximal_bit_length()

residual : 8.8

get_memory_consumption(uint32& mem_for_enc, uint32& mem_for_dec)

DeflateCoder : 12.4

get_memory_level()

DeflateCoder : 12.4

get_menu(string label)

GraphWin : 20.6

get_message()

d3_window : 20.9

GraphWin : 20.6

get_mode()

window : 20.2

get_model_memory_bound()

PPMIICoder : 12.3

get_model_order()

PPMIICoder : 12.3

get_model_restoration_method()

PPMIICoder : 12.3

get_month()

date : 6.21

get_month_name()

date : 6.21

get_mouse()

d3_window : 20.9

window : 20.2

get_mouse(double& x, double& y)

window : 20.2

get_mouse(point& p)

window : 20.2

get_mouse(window*& w, double& x, double& y) : 20.2

get_name()

counter : 6.17

timer : 6.16

get_name(geo_scene sc)

GeoWin : 20.8

get_name(geo_scenegroup gs)

GeoWin : 20.8

get_node()

AdjIt : 16.7

InAdjIt : 16.6

NodeIt : 16.2

OutAdjIt : 16.5

get_node_param()

GraphWin : 20.6

get_node_width()

window : 20.2

get_nodes_in_area(double x0, double y0, double x1, double y1)

GraphWin : 20.6

get_num_calls()

graph_morphism_algorithm< graph_t > : 15.16

get_observer()

ObserverNodeIt<Obs,Iter> : 16.11

get_out_stack()

GIT_SCC<Out,In,...> : 16.20

get_outgoing_packet_size()

secure_socket_streambuf : 13.7

socket_streambuf : 6.14

get_output_format()

date : 6.21

get_output_format_str()

date : 6.21

get_param(edge e)

GraphWin : 20.6

get_param(node v)

GraphWin : 20.6

get_pin_point(point& p)

GeoWin : 20.8

get_pixrect(double x1, double y1, double x2, double y2)

window : 20.2

get_pixrect_height(char* pr)

window : 20.2

get_pixrect_width(char* pr)

window : 20.2

get_point_style(geo_scene sc)

GeoWin : 20.8

get_port()

leda_socket : 6.13

get_position(node_array<point>& pos)

GraphWin : 20.6

get_precision()

bigfloat : 8.3

random_source : 6.6

get_primetable()

residual : 8.8

get_qlength()

leda_socket : 6.13

get_queue()

GIT_BFS<OutAdjI...> : 16.17

GIT_DIJKSTRA<OutAdjI...> : 16.21

GIT_TOPOSORT<OutAdjI...> : 16.19

get_representation() : 8.8

get_reset_threshold()

A0Coder : 12.1

get_rgb(int& r, int& g, int& b)

color : 20.1

get_rounding_mode()

bigfloat : 8.3

get_scale_threshold()

A0Coder : 12.1

get_scene_with_name(string nm)

GeoWin : 20.8

get_scenegroups()

GeoWin : 20.8

get_scenes()

GeoWin : 20.8

get_scenes(geo_scenegroup gs)

GeoWin : 20.8

get_selected_edges()

GraphWin : 20.6

get_selected_nodes()

GraphWin : 20.6

get_selection_color(geo_scene sc)

GeoWin : 20.8

get_selection_fill_color(geo_scene sc)

GeoWin : 20.8

get_selection_line_style(geo_scene sc)

GeoWin : 20.8

get_selection_line_width(geo_scene sc)

GeoWin : 20.8

get_show_grid()

GeoWin : 20.8

get_show_orientation()

window : 20.2

get_show_orientation(geo_scene sc)

GeoWin : 20.8

get_show_position()

GeoWin : 20.8

get_show_status()

GeoWin : 20.8

get_significant(void)

bigfloat : 8.3

get_significant_length(void)

bigfloat : 8.3

get_size()

CryptByteString : 13.1

memory_streambuf : 12.26

get_socket()

secure_socket_streambuf : 13.7

socket_streambuf : 6.14

get_solid()

d3_window : 20.9

get_src_stream()

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

AutoDecoder : 12.24

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

CryptAutoDecoder : 13.6

DeflateCoder : 12.4

DictCoder : 12.5

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

get_stack()

GIT_DFS<OutAdjI...> : 16.18

get_state()

window : 20.2

get_strategy()

DeflateCoder : 12.4

get_text_color(geo_scene sc)

GeoWin : 20.8

get_text_mode()

window : 20.2

get_tgt_stream()

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

AutoDecoder : 12.24

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

CryptAutoDecoder : 13.6

DeflateCoder : 12.4

DictCoder : 12.5

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

get_timeout()

leda_socket : 6.13

get_upper_bound()

real : 8.4

get_user_layer_color()

GeoWin : 20.8

get_user_layer_line_width()

GeoWin : 20.8

get_value()

counter : 6.17

get_visible(geo_scene sc)

GeoWin : 20.8

get_visible_scenes()

GeoWin : 20.8

get_week()

date : 6.21

get_window()

GeoWin : 20.8

GraphWin : 20.6

get_window(int but)

window : 20.2

get_window_pixrect()

window : 20.2

get_window_size()

DeflateCoder : 12.4

get_x_rotation()

d3_window : 20.9

get_xmax()

GeoWin : 20.8

GraphWin : 20.6

get_xmin()

GeoWin : 20.8

GraphWin : 20.6

get_y_rotation()

d3_window : 20.9

get_year()

date : 6.21

get_ymax()

GeoWin : 20.8

GraphWin : 20.6

get_ymin()

GeoWin : 20.8

GraphWin : 20.6

get_z_order(geo_scene sc)

GeoWin : 20.8

getAlA()

alignment : 7.5

getAlB()

alignment : 7.5

getAlInfo()

alignment : 7.5

getAllOccurences()

string_matching : 7.2

getFinished()

alphabet : 7.1

getFirstOccurence()

string_matching : 7.2

getFirstString()

distance : 7.4

getGapIncPenalty()

alignment : 7.5

score_matrix : 7.3

getGapPenalty()

alignment : 7.5

score_matrix : 7.3

getLength()

alphabet : 7.1

getLetter(unsigned i)

alphabet : 7.1

getLetters()

alphabet : 7.1

getNextOccurence(int i)

string_matching : 7.2

getPattern()

string_matching : 7.2

getResult()

string_matching : 7.2

getScore(char a, char b)

score_matrix : 7.3

getSecondString()

distance : 7.4

getSize()

alphabet : 7.1

getString()

string_matching : 7.2

getStringA()

alignment : 7.5

getStringB()

alignment : 7.5

GIT_BFS<OutAdjI...> : 16.17

GIT_DFS<OutAdjI...> : 16.18

GIT_DIJKSTRA<OutAdjI...> : 16.21

GIT_SCC<Out,In,...> : 16.20

GIT_TOPOSORT<OutAdjI...> : 16.19

global_aff_nw()

alignment : 7.5

global_nw()

alignment : 7.5

gml_graph : 14.26

goback()

gml_graph : 14.26

graph : 14.1

GRAPH<vtype,e...> : 14.2

graph_draw : 15.14

graph_gen : 14.22

graph_misc : 14.23

graph_morphism<graph_t...> : 15.15

graph_morphism_algorithm< graph_t > : 15.16

graph_of(edge e) : 14.1

graph_of(face f) : 14.1

graph_of(node v) : 14.1

GraphWin : 20.6

grid_graph(graph& G, int n) : 14.22

grid_graph(graph& G, node_array<double>& xcoord, node_array<double>& ycoord, int n) : 14.22

guarantee_relative_error(long k)

real : 8.4

h_array<I,E> : 10.3

had_overflow()

memory_streambuf : 12.26

had_underflow()

memory_streambuf : 12.26

HALFPLANE_INTERSECTION(const list<line>& L, list<line>& Lout) : 17.24

halt()

timer : 6.16

hamming()

distance : 7.4

has_edge()

FaceCirc : 16.8

has_got_EOF()

secure_socket_streambuf : 13.7

socket_streambuf : 6.14

has_key()

CBCCoder< BlkCipher > : 13.4

CryptAutoDecoder : 13.6

OMACCoder< BlkCipher > : 13.5

has_node()

AdjIt : 16.7

InAdjIt : 16.6

OutAdjIt : 16.5

has_put_EOF()

secure_socket_streambuf : 13.7

socket_streambuf : 6.14

Hash(...) : see User defined parameter types

hash(uint16 num_iterations = 1)

CryptByteString : 13.1

Hashed Types : see User defined parameter types | see h_array | see map | see map2

hasScore(char a, char b)

score_matrix : 7.3

hcoord(int i)

d3_rat_point : 19.8

rat_vector : 8.14

real_vector : 8.15

vector : 8.10

head()

list<E> : 9.7

node_list : 14.18

slist<E> : 9.8

head(int i)

string : 6.1

height()

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

window : 20.2

hex_print(ostream& o)

integer : 8.1

hidden_edges()

graph : 14.1

hidden_nodes()

graph : 14.1

hide_edge(edge e)

graph : 14.1

hide_edges(const list<edge>& el)

graph : 14.1

hide_node(node v)

graph : 14.1

hide_node(node v, list<edge>& h_edges)

graph : 14.1

high()

array<E> : 9.1

real : 8.4

high1()

array2<E> : 9.2

high2()

array2<E> : 9.2

highword()

integer : 8.1

hilbert(int n, RAT_TYPE x1, RAT_TYPE y1, RAT_TYPE x2, RAT_TYPE y2) : 17.6

homogeneous_linear_solver(const integer_matrix& M, integer_matrix& spanning_vecs) : 8.13

homogeneous_linear_solver(const integer_matrix& M, integer_vector& x) : 8.13

horspool()

string_matching : 7.2

HuffmanCoder : 12.6

identity(int n)

integer_matrix : 8.13

ilog2(const bigfloat& x) : 8.3

improve_approximation_to(const integer& q)

real : 8.4

in_avail()

memory_streambuf : 12.26

in_count()

memory_streambuf : 12.26

in_current()

GIT_SCC<Out,In,...> : 16.20

in_edges(node v)

graph : 14.1

in_pred(edge e)

graph : 14.1

in_simplex(const d3_point& p)

d3_simplex : 19.7

in_simplex(const d3_rat_point& p)

d3_rat_simplex : 19.14

in_succ(edge e)

graph : 14.1

InAdjIt : 16.6

incircle(const rat_point& a, const rat_point& b, const rat_point& c, const rat_point& d) : 17.10

include(const point& p)

rectangle : 17.9

include(const rat_point& p)

rat_rectangle : 17.16

include(const rat_rectangle& r2)

rat_rectangle : 17.16

include(const real_point& p)

real_rectangle : 17.23

include(const real_rectangle& r2)

real_rectangle : 17.23

include(const rectangle& r2)

rectangle : 17.9

increment()

counter : 6.17

indeg(node v)

graph : 14.1

static_graph : 14.3.7 | 14.3.7

independent_columns(const integer_matrix& M, array<int>& columns) : 8.13

INDEPENDENT_SET(const graph& G, list<node>& I) : 15.13

index(const d3_point& p)

d3_simplex : 19.7

index(const d3_rat_point& p)

d3_rat_simplex : 19.14

index_type

d_array<I,E> : 10.2

map<I,E> : 10.4

index_type1

map2<I1,I2,E> : 10.5

index_type2

map2<I1,I2,E> : 10.5

inf(b_pq_item x)

b_priority_queue<I> : 11.2

inf(dic2_item it)

d2_dictionary<K1,K2,I> : 18.1

inf(dic_item it)

dictionary<K,I> : 10.1

inf(edge e)

GRAPH<vtype,e...> : 14.2

PLANAR_MAP<vtype,e...> : 14.7

inf(face f)

PLANAR_MAP<vtype,e...> : 14.7

subdivision<I> : 18.7

inf(is_item it)

interval_set<I> : 18.4

inf(item it)

slist<E> : 9.8

inf(list_item it)

list<E> : 9.7

inf(node v)

GRAPH<vtype,e...> : 14.2

node_pq<P> : 14.20

PLANAR_MAP<vtype,e...> : 14.7

inf(partition_item it)

Partition<E> : 9.13

inf(pq_item it)

p_queue<P,I> : 11.1

inf(seg_item it)

rat_segment_set<I> : 18.6

segment_set<I> : 18.5

inf(seq_item it)

sortseq<K,I> : 10.6

inf_type

dictionary<K,I> : 10.1

p_queue<P,I> : 11.1

sortseq<K,I> : 10.6

init()

edge_map<E> : 14.12

face_map<E> : 14.13

node_map2<E> : 14.15

node_map<E> : 14.11

init(const E& x)

array2<E> : 9.2

array<E> : 9.1

init(const graph& G, const node_array<vector>& pos)

d3_window : 20.9

init(const graph_t& G)

edge_array<E> : 14.9

edge_map<E> : 14.12

face_array<E> : 14.10

face_map<E> : 14.13

node_array<E> : 14.8

node_map2<E> : 14.15

node_map<E> : 14.11

node_matrix<E> : 14.14

init(const graph_t& G, E x)

edge_array<E> : 14.9

edge_map<E> : 14.12

face_array<E> : 14.10

face_map<E> : 14.13

node_array<E> : 14.8

node_map2<E> : 14.15

node_map<E> : 14.11

node_matrix<E> : 14.14

init(const graph_t& G, int n, E x)

edge_array<E> : 14.9

face_array<E> : 14.10

node_array<E> : 14.8

init(const graphtype& G)

AdjIt : 16.7

init(const graphtype& G, const nodetype& n)

AdjIt : 16.7

init(const graphtype& G, const nodetype& n, const edgetype& e)

AdjIt : 16.7

init(const leda::graph& G)

EdgeIt : 16.3

FaceCirc : 16.8

FaceIt : 16.4

InAdjIt : 16.6

NodeIt : 16.2

OutAdjIt : 16.5

init(const leda::graph& G, const leda::edge& e)

EdgeIt : 16.3

FaceCirc : 16.8

init(const leda::graph& G, const leda::face& v)

FaceIt : 16.4

init(const leda::graph& G, const leda::node& n)

InAdjIt : 16.6

OutAdjIt : 16.5

init(const leda::graph& G, const leda::node& n, const leda::edge& e)

InAdjIt : 16.6

OutAdjIt : 16.5

init(const leda::graph& G, const leda::node& v)

NodeIt : 16.2

init(const list<POINT>& L)

POINT_SET : 18.2

init(const node_array<rat_vector>& pos)

d3_window : 20.9

init(const node_array<vector>& pos)

d3_window : 20.9

init(const Obs& obs, const Iter& base_it)

ObserverNodeIt<Obs,Iter> : 16.11

init(const Predicate& pred, const Iter& base_it)

FilterNodeIt<Predica...> : 16.9

init(double x0, double x1, double y0)

window : 20.2

init(double x0, double x1, double y0, int d, bool erase=true)

window : 20.2

init(double x1, double x2, double y1, double y2, int r=GEOWIN_MARGIN)

GeoWin : 20.8

init(double xmin, double xmax, double ymin)

GeoWin : 20.8

init(int n, int m)

graph : 14.1

init(OutAdjIt s)

GIT_DFS<OutAdjI...> : 16.18

GIT_DIJKSTRA<OutAdjI...> : 16.21

init_menu(window* wptr = NULL)

GeoWin : 20.8

init_rectangle(double x0, double x1, double y0, double y1)

window : 20.2

insert()

NodeIt : 16.2

insert(const AdjIt& other)

AdjIt : 16.7

insert(const E& x)

set<E> : 9.9

insert(const E& x, item pos)

slist<E> : 9.8

insert(const E& x, list_item pos, int dir=leda::behind)

list<E> : 9.7

insert(const InAdjIt& other)

InAdjIt : 16.6

insert(const K1& x, const K2& y, const I& i)

d2_dictionary<K1,K2,I> : 18.1

insert(const K& k, const I& i)

dictionary<K,I> : 10.1

sortseq<K,I> : 10.6

insert(const OutAdjIt& other)

OutAdjIt : 16.5

insert(const P& x, const I& i)

p_queue<P,I> : 11.1

insert(const rat_segment& s, const I& i)

rat_segment_set<I> : 18.6

insert(const segment& s, const I& i)

segment_set<I> : 18.5

insert(double x, double y, const I& i)

interval_set<I> : 18.4

insert(edge x)

edge_set : 14.17

insert(geo_scenegroup gs, geo_scene sc)

GeoWin : 20.8

insert(int i, string s1)

string : 6.1

insert(int key, const I& inf)

b_priority_queue<I> : 11.2

insert(int x)

d_int_set : 9.11

int_set : 9.10

insert(leda::node v1, leda::node v2)

EdgeIt : 16.3

insert(node v, const P& x)

node_pq<P> : 14.20

insert(node v, node w)

node_list : 14.18

insert(node w, int p)

b_node_pq<N> : 14.21

insert(node x)

node_set : 14.16

insert(POINT p)

POINT_SET : 18.2

insert_at(seq_item it, const K& k, const I& i)

sortseq<K,I> : 10.6

insert_at(seq_item it, const K& k, const I& i, int dir)

sortseq<K,I> : 10.6

insert_reverse_edges()

graph : 14.1

inside(const d3_point& p)

d3_sphere : 19.6

inside(const d3_rat_point& p)

d3_rat_sphere : 19.13

inside(const point& p)

circle : 17.5

GEN_POLYGON : 17.7

POLYGON : 17.6

rectangle : 17.9

triangle : 17.8

inside(const r_circle_point& p)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

inside(const rat_point& p)

rat_circle : 17.14

rat_rectangle : 17.16

rat_triangle : 17.15

inside(const real_point& p)

real_circle : 17.21

real_rectangle : 17.23

real_triangle : 17.22

inside_circle(const point& a, const point& b, const point& c, const point& d) : 17.1

inside_circle(const real_point& a, const real_point& b, const real_point& c, const real_point& d) : 17.17

inside_or_contains(const point& p)

rectangle : 17.9

inside_or_contains(const rat_point& p)

rat_rectangle : 17.16

inside_or_contains(const real_point& p)

real_rectangle : 17.23

inside_sphere(const d3_point& a, const d3_point& b, const d3_point& c, const d3_point& d, const d3_point& e) : 19.1

inside_sphere(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c, const d3_rat_point& d, const d3_rat_point& e) : 19.8

insphere(const d3_point& p)

d3_simplex : 19.7

insphere(const d3_rat_point& p)

d3_rat_simplex : 19.14

int_item(string s, int& x, const char* hlp=0)

window : 20.2

int_item(string s, int& x, int l, int h, const char* hlp=0)

window : 20.2

int_item(string s, int& x, int l, int h, const window_handler& obj, const char* hlp=0)

window : 20.2

int_item(string s, int& x, int l, int h, int step, const char* hlp=0)

window : 20.2

int_item(string s, int& x, int l, int h, int step, const window_handler& obj, const char* hlp=0)

window : 20.2

int_item(string s, int& x, int l, int h, int step, void (*F)(int), const char* hlp=0)

window : 20.2

int_item(string s, int& x, int l, int h, void (*F)(int), const char* hlp=0)

window : 20.2

int_set : 9.10

integer : 8.1

integer_matrix : 8.13

integer_vector : 8.12

integrate_function(double (*f)(double), double l, double r, double delta = 1.0e-2) : 8.17.2

intersect(const d_int_set& T)

d_int_set : 9.11

intersect(const int_set& T)

int_set : 9.10

intersect(const set<E,set_impl>& T)

set<E> : 9.9

intersect_halfplane(const LINE& l)

POLYGON : 17.6

intersection(const circle& D)

circle : 17.5

intersection(const d3_line& m)

d3_line : 19.4

intersection(const d3_line& m, d3_point& p)

d3_line : 19.4

intersection(const d3_plane& Q, d3_point& i1, d3_point& i2)

d3_plane : 19.5

intersection(const d3_point p1, const d3_point p2, d3_point& q)

d3_plane : 19.5

intersection(const d3_rat_line& m)

d3_rat_line : 19.10

intersection(const d3_rat_line& m, d3_rat_point& p)

d3_rat_line : 19.10

intersection(const d3_rat_plane& Q, d3_rat_point& i1, d3_rat_point& i2)

d3_rat_plane : 19.12

intersection(const d3_rat_point p1, const d3_rat_point p2, d3_rat_point& q)

d3_rat_plane : 19.12

intersection(const d3_rat_ray& r, d3_rat_point& inter)

d3_rat_ray : 19.9

intersection(const d3_rat_segment& s)

d3_rat_line : 19.10

intersection(const d3_rat_segment& s, d3_rat_point& inter)

d3_rat_ray : 19.9

intersection(const d3_rat_segment& s, d3_rat_point& p)

d3_rat_line : 19.10

intersection(const d3_rat_segment& t)

d3_rat_segment : 19.11

intersection(const d3_rat_segment& t, d3_rat_point& p)

d3_rat_segment : 19.11

intersection(const d3_ray& r, d3_point& inter)

d3_ray : 19.2

intersection(const d3_segment& s)

d3_line : 19.4

intersection(const d3_segment& s, d3_point& inter)

d3_ray : 19.2

intersection(const d3_segment& s, d3_point& p)

d3_line : 19.4

intersection(const d3_segment& t)

d3_segment : 19.3

intersection(const d3_segment& t, d3_point& p)

d3_segment : 19.3

intersection(const GEN_POLYGON& Q)

GEN_POLYGON : 17.7

intersection(const line& g, point& p)

line : 17.4

intersection(const line& l)

circle : 17.5

GEN_POLYGON : 17.7

POLYGON : 17.6

rectangle : 17.9

segment_set<I> : 18.5

triangle : 17.8

intersection(const r_circle_gen_polygon& Q)

r_circle_gen_polygon : 17.30

intersection(const r_circle_segment& cs2)

r_circle_segment : 17.28

intersection(const r_circle_segment& s)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

intersection(const rat_circle& c)

r_circle_segment : 17.28

intersection(const rat_circle& c, const rat_line& l, tag which, r_circle_point& p)

r_circle_point : 17.27

intersection(const rat_circle& c, const rat_line& l, tag which, real_point& p)

r_circle_point : 17.27

intersection(const rat_line& g, rat_point& inter)

rat_line : 17.13

intersection(const rat_line& l)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

r_circle_segment : 17.28

rat_rectangle : 17.16

rat_segment_set<I> : 18.6

rat_triangle : 17.15

intersection(const rat_ray& s, rat_point& inter)

rat_ray : 17.12

intersection(const rat_rectangle& s)

rat_rectangle : 17.16

intersection(const rat_segment& q)

rat_segment_set<I> : 18.6

intersection(const rat_segment& s)

rat_line : 17.13

rat_ray : 17.12

rat_rectangle : 17.16

rat_triangle : 17.15

intersection(const rat_segment& s, rat_point& inter)

rat_line : 17.13

rat_ray : 17.12

intersection(const rat_segment& t)

rat_segment : 17.11

intersection(const rat_segment& t, rat_point& p)

rat_segment : 17.11

intersection(const rat_segment& t, rat_segment& inter)

rat_segment : 17.11

intersection(const ray& s, point& inter)

ray : 17.3

intersection(const real_circle& D)

real_circle : 17.21

intersection(const real_line& g, real_point& p)

real_line : 17.20

intersection(const real_line& l)

r_circle_segment : 17.28

real_circle : 17.21

real_rectangle : 17.23

real_triangle : 17.22

intersection(const real_ray& s, real_point& inter)

real_ray : 17.19

intersection(const real_rectangle& s)

real_rectangle : 17.23

intersection(const real_segment& s)

real_circle : 17.21

real_line : 17.20

real_rectangle : 17.23

real_triangle : 17.22

intersection(const real_segment& s, real_point& inter)

real_line : 17.20

real_ray : 17.19

intersection(const real_segment& t)

real_segment : 17.18

intersection(const real_segment& t, real_point& p)

real_segment : 17.18

intersection(const rectangle& s)

rectangle : 17.9

intersection(const segment& q)

segment_set<I> : 18.5

intersection(const segment& s)

circle : 17.5

GEN_POLYGON : 17.7

line : 17.4

POLYGON : 17.6

ray : 17.3

rectangle : 17.9

triangle : 17.8

intersection(const segment& s, point& inter)

line : 17.4

ray : 17.3

intersection(const segment& t)

segment : 17.2

intersection(const segment& t, point& p)

segment : 17.2

intersection(double a, double b)

interval_set<I> : 18.4

intersection_approximate(const r_circle_gen_polygon& Q, double dist = 1e-2)

r_circle_gen_polygon : 17.30

intersection_halfplane(const rat_line& l)

r_circle_polygon : 17.29

intersection_of_lines(const d3_rat_segment& t, d3_rat_point& p)

d3_rat_segment : 19.11

intersection_of_lines(const d3_segment& t, d3_point& p)

d3_segment : 19.3

intersection_of_lines(const rat_segment& t, rat_point& p)

rat_segment : 17.11

intersection_of_lines(const real_segment& t, real_point& p)

real_segment : 17.18

intersection_of_lines(const segment& t, point& p)

segment : 17.2

intersection_sorted(const line& l)

segment_set<I> : 18.5

intersection_sorted(const rat_line& l)

rat_segment_set<I> : 18.6

intersection_sorted(const rat_segment& q)

rat_segment_set<I> : 18.6

intersection_sorted(const segment& q)

segment_set<I> : 18.5

interval : 8.5

interval_set<I> : 18.4

inv()

matrix : 8.11

real_matrix : 8.16

inverse()

rational : 8.2

inverse(const integer_matrix& M, integer& D) : 8.13

inverse(const integer_matrix& M, integer_matrix& inverse, integer& D, integer_vector& c) : 8.13

inverse(const residual& a)

residual : 8.8

inverse(double a, double p)

residual : 8.7

invert()

rational : 8.2

ipow2(const integer& p) : 8.3

is_a_point()

interval : 8.5

is_active(geo_scene sc)

GeoWin : 20.8

Is_Acyclic(const graph& G) : 14.23

Is_Acyclic(const graph& G, list<edge>& L) : 14.23

Is_Biconnected(const graph& G) : 14.23

Is_Biconnected(const graph& G, node& s) : 14.23

is_bidirected()

graph : 14.1

Is_Bidirected(const graph& G) : 14.23

Is_Bidirected(const graph& G, edge_array<edge>& rev) : 14.23

Is_Bipartite(const graph& G) : 14.23

Is_Bipartite(const graph& G, list<node>& A, list<node>& B) : 14.23

is_call_enabled(int id)

GraphWin : 20.6

Is_CCW_Ordered(const graph& G, const edge_array<int>& dx, const edge_array<int>& dy) : 15.13

Is_CCW_Ordered(const graph& G, const node_array<int>& x, const node_array<int>& y) : 15.13

is_closed_chain()

r_circle_polygon : 17.29

Is_Connected(const graph& G) : 14.23

is_convex()

GEN_POLYGON : 17.7

POLYGON : 17.6

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

Is_Convex_Subdivision(const GRAPH<point,int>& G) : 17.24

is_degenerate()

circle : 17.5

d3_rat_simplex : 19.14

d3_rat_sphere : 19.13

d3_simplex : 19.7

d3_sphere : 19.6

r_circle_segment : 17.28

rat_circle : 17.14

rat_rectangle : 17.16

rat_triangle : 17.15

real_circle : 17.21

real_rectangle : 17.23

real_triangle : 17.22

rectangle : 17.9

triangle : 17.8

Is_Delaunay_Diagram(const GRAPH<point,int>& G, delaunay_voronoi_kind kind) : 17.24

Is_Delaunay_Triangulation(const GRAPH<point,int>& G, delaunay_voronoi_kind kind) : 17.24

is_diagram_dart(edge e)

POINT_SET : 18.2

is_diagram_edge(edge e)

POINT_SET : 18.2

is_directed()

graph : 14.1

is_directory(string fname) : 6.12

is_empty()

CryptByteString : 13.1

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

is_enabled(int b)

window : 20.2

is_enabled(panel_item it)

window : 20.2

is_file(string fname) : 6.12

is_finite()

interval : 8.5

is_full()

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

is_full_circle()

r_circle_segment : 17.28

is_general()

real : 8.4

is_graph_isomorphism(const graph_t& g1, const graph_t& g2, node_morphism const* node_morph, edge_morphism const* edge_morph = NULL, const node_compat& node_comp = DEFAULT_NODE_CMP, const edge_compat& edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

is_graph_monomorphism(const graph_t& g1, const graph_t& g2, node_morphism const* node_morph, edge_morphism const* edge_morph = NULL, const node_compat& node_comp = DEFAULT_NODE_CMP, const edge_compat& edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

is_hidden(edge e)

graph : 14.1

is_hidden(node v)

graph : 14.1

is_horizontal()

line : 17.4

rat_line : 17.13

rat_ray : 17.12

rat_segment : 17.11

ray : 17.3

real_line : 17.20

real_ray : 17.19

real_segment : 17.18

segment : 17.2

is_hull_dart(edge e)

POINT_SET : 18.2

is_hull_edge(edge e)

POINT_SET : 18.2

is_in_fast_mode()

RLECoder : 12.8

is_invertible()

residual : 8.8

is_last_day_in_month()

date : 6.21

is_leap_year(int y)

date : 6.21

is_line()

circle : 17.5

rat_circle : 17.14

real_circle : 17.21

is_link(string fname) : 6.12

is_long()

integer : 8.1

residual : 8.8

Is_Loopfree(const graph& G) : 14.23

is_map()

graph : 14.1

Is_Map(const graph& G) : 14.23

is_open()

decoding_ifstream<Coder> : 12.22

encoding_ofstream<Coder> : 12.21

Is_Planar(const graph& G) : 14.23

Is_Planar_Map(const graph& G) : 14.23

Is_Plane_Map(const graph& G) : 14.23

is_point()

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

is_pred()

GIT_DIJKSTRA<OutAdjI...> : 16.21

is_proper_arc()

r_circle_segment : 17.28

is_r_circle_polygon()

r_circle_gen_polygon : 17.30

is_rat_circle()

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

is_rat_gen_polygon()

r_circle_gen_polygon : 17.30

is_rat_point()

r_circle_point : 17.27

is_rat_polygon()

r_circle_polygon : 17.29

is_rat_segment()

r_circle_segment : 17.28

is_rational()

real : 8.4

is_running()

timer : 6.16

is_segment()

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

is_selected(edge e)

GraphWin : 20.6

is_selected(node v)

GraphWin : 20.6

Is_Series_Parallel(const graph& G) : 14.23

is_simple()

GEN_POLYGON : 17.7

POLYGON : 17.6

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

Is_Simple(const graph& G) : 14.23

Is_Simple(const graph& G, list<edge>& el) : 14.23

Is_Simple_Loopfree(const graph& G) : 14.23

Is_Simple_Polygon(const list<point>& L) : 17.24

is_solvable(const integer_matrix& M, const integer_vector& b) : 8.13

is_space(char c) : 6.15

is_straight_segment()

r_circle_segment : 17.28

is_subgraph_isomorphism(const graph_t& g1, const graph_t& g2, node_morphism const* node_morph, edge_morphism const* edge_morph = NULL, const node_compat& node_comp = DEFAULT_NODE_CMP, const edge_compat& edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

Is_Triangulation(const GRAPH<point,int>& G) : 17.24

Is_Triconnected(const graph& G) : 14.23

Is_Triconnected(const graph& G, node& s1, node& s2) : 14.23

is_trivial()

circle : 17.5

d3_rat_segment : 19.11

d3_segment : 19.3

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

r_circle_segment : 17.28

rat_circle : 17.14

rat_segment : 17.11

real_circle : 17.21

real_segment : 17.18

segment : 17.2

is_undirected()

graph : 14.1

Is_Undirected_Simple(const graph& G) : 14.23

is_valid(int d, month m, int y)

date : 6.21

is_valid(string d, bool swallow=true)

date : 6.21

is_vertical()

line : 17.4

rat_line : 17.13

rat_ray : 17.12

rat_segment : 17.11

ray : 17.3

real_line : 17.20

real_ray : 17.19

real_segment : 17.18

segment : 17.2

is_vertical_segment()

r_circle_segment : 17.28

Is_Voronoi_Diagram(const GRAPH<circle,point>& G, delaunay_voronoi_kind kind) : 17.24

is_weakly_simple()

POLYGON : 17.6

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

is_weakly_simple(list<POINT>& L)

POLYGON : 17.6

is_weakly_simple(list<r_circle_point>& crossings)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

is_zero()

residual : 8.8

isDNA()

alphabet : 7.1

isFinished()

alphabet : 7.1

isInf(const bigfloat& x) : 8.3

isNaN(const bigfloat& x) : 8.3

isnInf(const bigfloat& x) : 8.3

isnZero(const bigfloat& x) : 8.3

ispInf(const bigfloat& x) : 8.3

ispZero(const bigfloat& x) : 8.3

isSpecial(const bigfloat& x) : 8.3

isStandard()

alphabet : 7.1

istream : 6

iszero()

integer : 8.1

isZero(const bigfloat& x) : 8.3

item : 4.5

array<E> : 9.1

d_array<I,E> : 10.2

dictionary<K,I> : 10.1

list<E> : 9.7

map2<I1,I2,E> : 10.5

map<I,E> : 10.4

p_queue<P,I> : 11.1

slist<E> : 9.8

sortseq<K,I> : 10.6

iteration

Graph iterator : 4.6

macros : 4.6

STL iterators : 4.6

iterator : 16.1.1

join(const d_int_set& T)

d_int_set : 9.11

join(const int_set& T)

int_set : 9.10

join(const set<E,set_impl>& T)

set<E> : 9.9

join(graph& H)

graph : 14.1

join_faces(edge e)

graph : 14.1

K_SHORTEST_PATHS(graph& G, node s, node t, const edge_array<int>& c, int k, list<list<edge>* >& sps, int& nops) : 15.2

karp_rabin()

string_matching : 7.2

key(dic_item it)

dictionary<K,I> : 10.1

key(seg_item it)

rat_segment_set<I> : 18.6

segment_set<I> : 18.5

key(seq_item it)

sortseq<K,I> : 10.6

key1(dic2_item it)

d2_dictionary<K1,K2,I> : 18.1

key2(dic2_item it)

d2_dictionary<K1,K2,I> : 18.1

key_type

dictionary<K,I> : 10.1

sortseq<K,I> : 10.6

kind()

GEN_POLYGON : 17.7

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

knuth_morris_pratt()

string_matching : 7.2

KURATOWSKI(graph& G, list<node>& V, list<edge>& E, node_array<int>& deg) : 15.13

lagrange_sign()

residual : 8.8

LARGEST_EMPTY_CIRCLE(const list<point>& L) : 17.24

last()

list<E> : 9.7

slist<E> : 9.8

STLNodeIt<DataAcc...> : 16.12

last_adj_edge(node v)

graph : 14.1

last_edge()

graph : 14.1

last_face()

graph : 14.1

last_in_edge(node v)

graph : 14.1

last_node()

graph : 14.1

lattice_d3_rat_points(int n, int maxc, list<d3_rat_point>& L) : 19.8

lattice_points(int n, int maxc, list<POINT>& L) : 17.26

leda_allocator<T> : 6.10

leda_assert(bool cond, const char* err_msg, int err_no=0) : 6.11

leda_socket : 6.13

left(is_item it)

interval_set<I> : 18.4

left_tangent(const point& p)

circle : 17.5

left_tangent(const real_point& p)

real_circle : 17.21

left_turn(const point& a, const point& b, const point& c) : 17.1

left_turn(const rat_point& a, const rat_point& b, const rat_point& c) : 17.10

left_turn(const real_point& a, const real_point& b, const real_point& c) : 17.17

length()

b_queue<E> : 9.6

d3_segment : 19.3

integer : 8.1

list<E> : 9.7

queue<E> : 9.4

real_segment : 17.18

real_vector : 8.15

residual : 8.8

segment : 17.2

slist<E> : 9.8

string : 6.1

vector : 8.10

levenshtein()

distance : 7.4

line : 17.4

Linear Orders : see User defined parameter types | see dictionary | see sortseq

linear_base(const array<rat_vector>& A) : 8.14

linear_rank(const array<rat_vector>& A) : 8.14

linear_solver(const integer_matrix& M, const integer_vector& b, integer_vector& x, integer& D) : 8.13

linear_solver(const integer_matrix& M, const integer_vector& b, integer_vector& x, integer& D, integer_matrix& spanning_vectors, integer_vector& c) : 8.13

linear_solver(const integer_matrix& M, const integer_vector& b, integer_vector& x, integer& D, integer_vector& c) : 8.13

linearly_independent(const array<rat_vector>& A) : 8.14

list<E> : 9.7

listen()

leda_socket : 6.13

load_layout(istream& istr)

GraphWin : 20.6

local_aff_sw()

alignment : 7.5

local_sw()

alignment : 7.5

locate(const K& k)

sortseq<K,I> : 10.6

locate(POINT p, const list<edge>& loc_start)

POINT_SET : 18.2

locate(POINT p, edge loc_start = NULL)

POINT_SET : 18.2

locate(POINT q)

POINT_LOCATOR : 18.3

LOCATE_IN_TRIANGULATION(const GRAPH<point,int>& G, point p, edge start = 0) : 17.24

LOCATE_IN_TRIANGULATION(const GRAPH<point,segment>& G, point p, edge start = 0) : 17.24

LOCATE_IN_TRIANGULATION(const graph& G, const node_array<point>& pos, point p, edge start = 0) : 17.24

locate_point(point p)

subdivision<I> : 18.7

locate_pred(const K& k)

sortseq<K,I> : 10.6

locate_succ(const K& k)

sortseq<K,I> : 10.6

log(const integer& a) : 8.1

log2_abs(const integer& a) : 8.1

longest_common_subsequence()

alignment : 7.5

longest_common_substring()

alignment : 7.5

lookup(const K1& x, const K2& y)

d2_dictionary<K1,K2,I> : 18.1

lookup(const K& k)

dictionary<K,I> : 10.1

sortseq<K,I> : 10.6

lookup(const rat_segment& s)

rat_segment_set<I> : 18.6

lookup(const segment& s)

segment_set<I> : 18.5

lookup(double x, double y)

interval_set<I> : 18.4

lookup(POINT p, const list<edge>& loc_start)

POINT_SET : 18.2

lookup(POINT p, edge loc_start = NULL)

POINT_SET : 18.2

low()

array<E> : 9.1

real : 8.4

low1()

array2<E> : 9.2

low2()

array2<E> : 9.2

lower_bound()

b_priority_queue<I> : 11.2

interval : 8.5

LOWER_CONVEX_HULL(const list<point>& L) : 17.24

lower_left()

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

lower_right()

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

lstyle_item(string s, line_style& x, const char* hlp=0)

window : 20.2

lstyle_item(string s, line_style& x, const window_handler& obj, const char* hlp=0)

window : 20.2

lstyle_item(string s, line_style& x, void(*F)(int), const char* hlp=0)

window : 20.2

lwidth_item(string s, int& x, const char* hlp=0)

window : 20.2

lwidth_item(string s, int& x, const window_handler& obj, const char* hlp=0)

window : 20.2

lwidth_item(string s, int& x, void(*F)(int), const char* hlp=0)

window : 20.2

MAC_is_valid()

OMACCoder< BlkCipher > : 13.5

Make_Acyclic(graph& G) : 14.23

Make_Biconnected(graph& G) : 14.23

Make_Biconnected(graph& G, list<edge>& L) : 14.23

make_bidirected()

graph : 14.1

Make_Bidirected(graph& G) : 14.23

Make_Bidirected(graph& G, list<edge>& L) : 14.23

make_bidirected(list<edge>& R)

graph : 14.1

make_block()

partition : 9.12

make_block(const E& x)

Partition<E> : 9.13

Make_Connected(graph& G) : 14.23

Make_Connected(graph& G, list<edge>& L) : 14.23

make_directed()

graph : 14.1

make_invalid()

AdjIt : 16.7

EdgeIt : 16.3

FaceCirc : 16.8

FaceIt : 16.4

InAdjIt : 16.6

NodeIt : 16.2

OutAdjIt : 16.5

make_map()

graph : 14.1

make_map(list<edge>& R)

graph : 14.1

make_menu_bar()

window : 20.2

make_planar_map()

graph : 14.1

make_rep(node v)

node_partition : 14.19

Make_Simple(graph& G) : 14.23

MAKE_TRANSITIVELY_CLOSED(graph& G) : 15.1

MAKE_TRANSITIVELY_REDUCED(graph& G) : 15.1

make_undirected()

graph : 14.1

make_weakly_simple()

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

make_weakly_simple(bool with_neg_parts = true, bool strict = false)

GEN_POLYGON : 17.7

POLYGON : 17.6

make_weakly_simple(const POLYGON& Q, bool with_neg_parts = true, bool strict = false)

GEN_POLYGON : 17.7

make_weakly_simple(const r_circle_polygon& Q)

r_circle_gen_polygon : 17.30

Manual Page : 4.2

map2<I1,I2,E> : 10.5

map<I,E> : 10.4

markov_chain : 14.24

matrix : 8.11

max()

d_int_set : 9.11

int_set : 9.10

list<E> : 9.7

max(const leda_cmp_base<E>& cmp)

list<E> : 9.7

MAX_CARD_BIPARTITE_MATCHING(graph& G) : 15.6

MAX_CARD_BIPARTITE_MATCHING(graph& G, const list<node>& A, const list<node>& B) : 15.6

MAX_CARD_BIPARTITE_MATCHING(graph& G, const list<node>& A, const list<node>& B, node_array<bool>& NC) : 15.6

MAX_CARD_BIPARTITE_MATCHING(graph& G, node_array<bool>& NC) : 15.6

MAX_CARD_MATCHING(const graph& G, int heur = 0) : 15.8

MAX_CARD_MATCHING(const graph& G, node_array<int>& OSC, int heur = 0) : 15.8

max_flow : 15.3

max_flow_gen_AMO(GRAPH<int,int>& G, node& s, node& t, int n) : 15.3

max_flow_gen_CG1(GRAPH<int,int>& G, node& s, node& t, int n) : 15.3

max_flow_gen_CG2(GRAPH<int,int>& G, node& s, node& t, int n) : 15.3

max_flow_gen_rand(GRAPH<int,int>& G, node& s, node& t, int n, int m) : 15.3

MAX_FLOW_SCALE_CAPS(const graph& G, node s, edge_array<double>& cap) : 15.3

max_item()

sortseq<K,I> : 10.6

max_key1()

d2_dictionary<K1,K2,I> : 18.1

max_key2()

d2_dictionary<K1,K2,I> : 18.1

max_size()

leda_allocator<T> : 6.10

maximal_planar_graph(graph& G, int n) : 14.22

maximal_planar_map(graph& G, int n) : 14.22

mc_matching : 15.8

mcb_matching : 15.6

MD5SumCoder : 12.17

measure

timer : 6.16

member(const E& x)

set<E> : 9.9

member(edge x)

edge_set : 14.17

member(int x)

d_int_set : 9.11

int_set : 9.10

member(node v)

node_list : 14.18

node_pq<P> : 14.20

member(node x)

node_set : 14.16

memory_streambuf : 12.26

menu : 20.4

menu_bar_height()

window : 20.2

merge(list<E>& L1)

list<E> : 9.7

merge(sortseq<K,I,seq_impl>& S1)

sortseq<K,I> : 10.6

merge_nodes(edge e1, node v2)

graph : 14.1

merge_nodes(node v1, node v2)

graph : 14.1

merge_sort()

list<E> : 9.7

merge_sort(int (*cmp)(const E& , const E& ))

list<E> : 9.7

message(const char* msg)

GraphWin : 20.6

message(string msg)

GeoWin : 20.8

message(string s)

window : 20.2

middle()

r_circle_segment : 17.28

midpoint(const d3_point& a, const d3_point& b) : 19.1

midpoint(const d3_rat_point& a, const d3_rat_point& b) : 19.8

midpoint(const point& a, const point& b) : 17.1

midpoint(const rat_point& a, const rat_point& b) : 17.10

midpoint(const real_point& a, const real_point& b) : 17.17

min()

d_int_set : 9.11

int_set : 9.10

list<E> : 9.7

min(const leda_cmp_base<E>& cmp)

list<E> : 9.7

MIN_AREA_ANNULUS(const list<point>& L, point& center, point& ipoint, point& opoint, line& l1) : 17.24

min_cost_flow : 15.4

MIN_COST_FLOW(const graph& G, const edge_array<int>& cap, const edge_array<int>& cost, const node_array<int>& supply, edge_array<int>& flow) : 15.4

MIN_COST_FLOW(const graph& G, const edge_array<int>& lcap, const edge_array<int>& ucap, const edge_array<int>& cost, const node_array<int>& supply, edge_array<int>& flow) : 15.4

MIN_COST_MAX_FLOW(const graph& G, node s, node t, const edge_array<int>& cap, const edge_array<int>& cost, edge_array<int>& flow) : 15.4

min_cut : 15.5

MIN_CUT(const graph& G, const edge_array<int>& weight) : 15.5

MIN_CUT(const graph& G, const edge_array<int>& weight, list<node>& C, bool use_heuristic = true) : 15.5

min_item()

sortseq<K,I> : 10.6

min_key1()

d2_dictionary<K1,K2,I> : 18.1

min_key2()

d2_dictionary<K1,K2,I> : 18.1

min_span : 15.11

MIN_SPANNING_TREE(const graph& G, const edge_array<int>& cost) : 15.11

MIN_SPANNING_TREE(const graph& G, const leda_cmp_base<edge>& cmp) : 15.11

MIN_SPANNING_TREE(const graph& G, int (*cmp)(const edge& , const edge& )) : 15.11

MIN_SPANNING_TREE(const list<point>& L, GRAPH<point,int>& T) : 17.24

MIN_WIDTH_ANNULUS(const list<point>& L, point& center, point& ipoint, point& opoint, line& l1, line& l2) : 17.24

minimize_function(double (*f)(double), double& xmin, double tol = 1.0e-10) : 8.17.1

MINIMUM_RATIO_CYCLE(graph& G, const edge_array<int>& c, const edge_array<int>& p, list<edge>& C_start) : 15.2

minimum_spanning_tree()

POINT_SET : 18.2

MINKOWSKI_DIFF(const gen_polygon& P, const polygon& R) : 17.24

MINKOWSKI_DIFF(const gen_polygon& P, const polygon& R, void (*conv_partition)(const gen_polygon& p, const polygon& r, list<polygon>& lp, list<polygon>& lr), gen_polygon (*conv_unite)(const list<gen_polygon>& )) : 17.24

MINKOWSKI_DIFF(const polygon& P, const polygon& R) : 17.24

MINKOWSKI_DIFF(const polygon& P, const polygon& R, void (*conv_partition)(const gen_polygon& p, const polygon& r, list<polygon>& lp, list<polygon>& lr), gen_polygon (*conv_unite)(const list<gen_polygon>& )) : 17.24

MINKOWSKI_SUM(const gen_polygon& P, const polygon& R) : 17.24

MINKOWSKI_SUM(const gen_polygon& P, const polygon& R, void (*conv_partition)(const gen_polygon& p, const polygon& r, list<polygon>& lp, list<polygon>& lr), gen_polygon (*conv_unite)(const list<gen_polygon>& )) : 17.24

MINKOWSKI_SUM(const polygon& P, const polygon& R) : 17.24

MINKOWSKI_SUM(const polygon& P, const polygon& R, void (*conv_partition)(const gen_polygon& p, const polygon& r, list<polygon>& lp, list<polygon>& lr), gen_polygon (*conv_unite)(const list<gen_polygon>& )) : 17.24

misc : 6.15

months_until(const date& D2)

date : 6.21

morphism

graph_morphism_algorithm< graph_t > : 15.16

morphism_list

graph_morphism_algorithm< graph_t > : 15.16

morris_pratt()

string_matching : 7.2

move()

d3_window : 20.9

move_edge(edge e, edge e1, edge e2, int d1=leda::behind, int d2=leda::behind)

graph : 14.1

move_edge(edge e, edge e1, node w, int d=leda::behind)

graph : 14.1

move_edge(edge e, node v, edge e2, int d=leda::behind)

graph : 14.1

move_edge(edge e, node v, node w)

graph : 14.1

move_file(string src, string dest) : 6.12

move_to_back(list_item it)

list<E> : 9.7

move_to_front(list_item it)

list<E> : 9.7

move_to_rear(list_item it)

list<E> : 9.7

msg_clear()

GeoWin : 20.8

msg_close()

GeoWin : 20.8

msg_open(string msg)

GeoWin : 20.8

MTF2Coder : 12.11

MTFCoder : 12.10

mul(const residual& a, const residual& b)

residual : 8.8

mul(double a, double b, double p)

residual : 8.7

MULMULEY_SEGMENTS(const list<segment>& S, GRAPH<point,segment>& G, bool embed=false) : 17.24

mw_matching : 15.9

MWA_SCALE_WEIGHTS(const graph& G, edge_array<double>& c) : 15.7

mwb_matching : 15.7

MWBM_SCALE_WEIGHTS(const graph& G, edge_array<double>& c) : 15.7

my_sortseq(seq_item it)

sortseq<K,I> : 10.6

n_gon(int n, CIRCLE C, double epsilon) : 17.6

nearest_neighbor(node w)

POINT_SET : 18.2

nearest_neighbor(POINT p)

POINT_SET : 18.2

nearest_neighbors(node w, int k)

POINT_SET : 18.2

nearest_neighbors(POINT p, int k)

POINT_SET : 18.2

negate()

rational : 8.2

negate(const residual& a)

residual : 8.8

negate(double a, double p)

residual : 8.7

Nesting_Tree(const gen_polygon& P, GRAPH<polygon, int>& T) : 17.24

new_edge(edge e, node w, const etype& x, int dir=leda::behind)

GRAPH<vtype,e...> : 14.2

new_edge(edge e, node w, int dir=leda::behind)

graph : 14.1

new_edge(edge e1, edge e2)

planar_map : 14.6

new_edge(edge e1, edge e2, const etype& x, int d1=leda::behind, int d2=leda::behind)

GRAPH<vtype,e...> : 14.2

new_edge(edge e1, edge e2, const ftype& y)

PLANAR_MAP<vtype,e...> : 14.7

new_edge(edge e1, edge e2, int d1=leda::behind, int d2=leda::behind)

graph : 14.1

new_edge(node v, edge e, const etype& x, int dir=leda::behind)

GRAPH<vtype,e...> : 14.2

new_edge(node v, edge e, int dir=leda::behind)

graph : 14.1

new_edge(node v, edge e, node w, const etype& x, int d=leda::behind)

GRAPH<vtype,e...> : 14.2

new_edge(node v, edge e, node w, int d=leda::behind)

graph : 14.1

new_edge(node v, edge e1, node w, edge e2, const etype& x, int d1=leda::behind, int d2=leda::behind)

GRAPH<vtype,e...> : 14.2

new_edge(node v, edge e1, node w, edge e2, int d1=leda::behind, int d2=leda::behind)

graph : 14.1

new_edge(node v, node w)

graph : 14.1

GraphWin : 20.6

static_graph : 14.3.7

new_edge(node v, node w, const etype& x)

GRAPH<vtype,e...> : 14.2

new_edge(node v, node w, const list<point>& P)

GraphWin : 20.6

new_edge(node v, node w, edge e, int d=leda::behind)

graph : 14.1

new_map_edge(edge e1, edge e2)

graph : 14.1

new_node()

graph : 14.1

static_graph : 14.3.7

new_node(const list<edge>& el)

planar_map : 14.6

new_node(const point& p)

GraphWin : 20.6

new_node(const vtype& x)

GRAPH<vtype,e...> : 14.2

new_node(face f)

planar_map : 14.6

new_node(face f, const vtype& x)

PLANAR_MAP<vtype,e...> : 14.7

new_node(list<edge>& el, const vtype& x)

PLANAR_MAP<vtype,e...> : 14.7

new_node(node u, const vtype& x, int dir)

GRAPH<vtype,e...> : 14.2

new_node(node u, int dir)

graph : 14.1

new_scenegroup(string name)

GeoWin : 20.8

new_scenegroup(string name, const list<geo_scene>& LS)

GeoWin : 20.8

next()

GIT_BFS<OutAdjI...> : 16.17

GIT_DFS<OutAdjI...> : 16.18

GIT_DIJKSTRA<OutAdjI...> : 16.21

GIT_SCC<Out,In,...> : 16.20

GIT_TOPOSORT<OutAdjI...> : 16.19

next_face_edge(edge e)

graph : 14.1

next_unseen()

GIT_DFS<OutAdjI...> : 16.18

node

graph_morphism_algorithm< graph_t > : 15.16

static_graph : 14.3.7

node_array<E> : 14.8

node_array_da<T> : 16.13

node_attribute_da<T> : 16.16

node_compat

graph_morphism_algorithm< graph_t > : 15.16

node_data()

GRAPH<vtype,e...> : 14.2

node_list : 14.18

node_map2<E> : 14.15

node_map<E> : 14.11

node_matrix<E> : 14.14

node_member_da<Str,T> : 16.15

node_morphism

graph_morphism_algorithm< graph_t > : 15.16

node_partition : 14.19

node_pq<P> : 14.20

node_set : 14.16

node_value_type

GRAPH<vtype,e...> : 14.2

NodeIt : 16.2

norm()

real_vector : 8.15

TRANSFORM : 17.25

vector : 8.10

normal()

d3_plane : 19.5

d3_rat_plane : 19.12

normal_project(const d3_point& q)

d3_plane : 19.5

normal_project(const d3_rat_point& q)

d3_rat_plane : 19.12

normalize()

GEN_POLYGON : 17.7

POLYGON : 17.6

r_circle_gen_polygon : 17.30

r_circle_point : 17.27

r_circle_polygon : 17.29

r_circle_segment : 17.28

rat_circle : 17.14

rat_line : 17.13

rat_point : 17.10

rat_ray : 17.12

rat_rectangle : 17.16

rat_segment : 17.11

rat_triangle : 17.15

rational : 8.2

number_of_blocks()

node_partition : 14.19

partition : 9.12

Partition<E> : 9.13

number_of_edges()

graph : 14.1

number_of_faces()

graph : 14.1

number_of_nodes()

graph : 14.1

number_of_steps()

dynamic_markov_chain : 14.25

markov_chain : 14.24

number_of_visits(node v)

dynamic_markov_chain : 14.25

markov_chain : 14.24

numerator()

rational : 8.2

numerical_analysis : 8.17

ObserverNodeIt<Obs,Iter> : 16.11

OMACCoder< BlkCipher > : 13.5

on_boundary(const POINT& p)

GEN_POLYGON : 17.7

POLYGON : 17.6

triangle : 17.8

on_boundary(const r_circle_point& p)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

on_boundary(const rat_point& p)

rat_triangle : 17.15

on_boundary(const real_point& p)

real_triangle : 17.22

on_circle(const point& a, const point& b, const point& c, const point& d) : 17.1

on_circle(const rat_point& a, const rat_point& b, const rat_point& c, const rat_point& d) : 17.10

on_circle(const real_point& a, const real_point& b, const real_point& c, const real_point& d) : 17.17

on_sphere(const d3_point& a, const d3_point& b, const d3_point& c, const d3_point& d, const d3_point& e) : 19.1

on_sphere(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c, const d3_rat_point& d, const d3_rat_point& e) : 19.8

open()

GraphWin : 20.6

open(const char* file_name = 0, ios::openmode mode = ios::in)

decoding_ifstream<Coder> : 12.22

open(const char* file_name = 0, ios::openmode mode = ios::openmode(ios::out : ios::trunc))
encoding_ofstream<Coder>

open(int x = window::center, int y = window::center)

panel : 20.3

open(int x, int y)

GraphWin : 20.6

open(window& W, int x, int y)

menu : 20.4

open(window& W, int x=window::center, int y=window::center)

panel : 20.3

open_file(string fname) : 6.12

open_file(string fname, string suffix) : 6.12

open_panel(panel& P)

GeoWin : 20.8

GraphWin : 20.6

operator>> : see User defined parameter types

operator<< : see User defined parameter types

opposite(edge e, node v)

graph : 14.1

static_graph : 14.3.7

opposite(node v, edge e)

graph : 14.1

optimal_mismatch()

string_matching : 7.2

orientation()

circle : 17.5

GEN_POLYGON : 17.7

POLYGON : 17.6

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

r_circle_segment : 17.28

rat_circle : 17.14

rat_triangle : 17.15

real_circle : 17.21

real_triangle : 17.22

triangle : 17.8

orientation(const d3_plane& p, const d3_point& q) : 19.5

orientation(const d3_point& a, const d3_point& b, const d3_point& c, const d3_point& d) : 19.1

orientation(const d3_rat_plane& p, const d3_rat_point& q) : 19.12

orientation(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c, const d3_rat_point& d) : 19.8

orientation(const line& l, const point& p) : 17.4

orientation(const point& a, const point& b, const point& c) : 17.1

orientation(const point& p)

line : 17.4

segment : 17.2

orientation(const point& q, const point& r)

point : 17.1

orientation(const rat_line& l, const rat_point& p) : 17.13

orientation(const rat_point& a, const rat_point& b, const rat_point& c) : 17.10

orientation(const rat_point& p)

rat_line : 17.13

rat_segment : 17.11

orientation(const rat_point& q, const rat_point& r)

rat_point : 17.10

orientation(const rat_ray& r, const rat_point& p) : 17.12

orientation(const rat_segment& s, const rat_point& p) : 17.11

orientation(const ray& r, const point& p) : 17.3

orientation(const real_line& l, const real_point& p) : 17.20

orientation(const real_point& a, const real_point& b, const real_point& c) : 17.17

orientation(const real_point& p)

real_line : 17.20

real_segment : 17.18

orientation(const real_point& q, const real_point& r)

real_point : 17.17

orientation(const real_ray& r, const real_point& p) : 17.19

orientation(const real_segment& s, const real_point& p) : 17.18

orientation(const segment& s, const point& p) : 17.2

orientation(edge e, POINT p)

POINT_SET : 18.2

orientation_xy(const d3_point& a, const d3_point& b, const d3_point& c) : 19.1

orientation_xy(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c) : 19.8

orientation_xz(const d3_point& a, const d3_point& b, const d3_point& c) : 19.1

orientation_xz(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c) : 19.8

orientation_yz(const d3_point& a, const d3_point& b, const d3_point& c) : 19.1

orientation_yz(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c) : 19.8

ORTHO_DRAW(const graph& G0, node_array<double>& xpos, node_array<double>& ypos, node_array<double>& xrad, node_array<double>& yrad, edge_array<list<double> >& xbends, edge_array<list<double> >& ybends, edge_array<double>& xsanch, edge_array<double>& ysanch, edge_array<double>& xtanch, edge_array<double>& ytanch) : 15.14

ORTHO_EMBEDDING(const graph& G, const node_array<bool>& crossing, const edge_array<int>& maxbends, node_array<int>& xcoord, node_array<int>& ycoord, edge_array<list<int> >& xbends, edge_array<list<int> >& ybends) : 15.14

ORTHO_EMBEDDING(const graph& G, node_array<int>& xpos, node_array<int>& ypos, edge_array<list<int> >& xbends, edge_array<list<int> >& ybends) : 15.14

ostream : 6

out_avail()

memory_streambuf : 12.26

out_count()

memory_streambuf : 12.26

out_current()

GIT_SCC<Out,In,...> : 16.20

out_edges(node v)

graph : 14.1

OutAdjIt : 16.5

outcircle(const rat_point& a, const rat_point& b, const rat_point& c, const rat_point& d) : 17.10

outdeg(node v)

graph : 14.1

static_graph : 14.3.7 | 14.3.7 | 14.3.7

outer_face()

subdivision<I> : 18.7

outside(const d3_point& p)

d3_sphere : 19.6

outside(const d3_rat_point& p)

d3_rat_sphere : 19.13

outside(const point& p)

circle : 17.5

GEN_POLYGON : 17.7

POLYGON : 17.6

rectangle : 17.9

triangle : 17.8

outside(const r_circle_point& p)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

outside(const rat_point& p)

rat_circle : 17.14

rat_rectangle : 17.16

rat_triangle : 17.15

outside(const real_point& p)

real_circle : 17.21

real_rectangle : 17.23

real_triangle : 17.22

outside_circle(const point& a, const point& b, const point& c, const point& d) : 17.1

outside_circle(const real_point& a, const real_point& b, const real_point& c, const real_point& d) : 17.17

outside_sphere(const d3_point& a, const d3_point& b, const d3_point& c, const d3_point& d, const d3_point& e) : 19.1

outside_sphere(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c, const d3_rat_point& d, const d3_rat_point& e) : 19.8

overlaps(const r_circle_segment& cs2)

r_circle_segment : 17.28

overlaps(const rat_segment& t)

rat_segment : 17.11

p_bisector(const rat_point& p, const rat_point& q) : 17.13

p_queue<P,I> : 11.1

panel : 20.3

parallel(const d3_plane& Q)

d3_plane : 19.5

parallel(const d3_rat_plane& Q)

d3_rat_plane : 19.12

parallel(const real_segment& s1, const real_segment& s2) : 17.18

parallel(const segment& s1, const segment& s2) : 17.2

parse(const char* filename)

gml_graph : 14.26

parse(istream& ins)

gml_graph : 14.26

parse_string(string s)

gml_graph : 14.26

partition : 9.12

Partition<E> : 9.13

permute()

array<E> : 9.1

list<E> : 9.7

permute(int low, int high)

array<E> : 9.1

permute(list_item* I)

list<E> : 9.7

permute_edges()

graph : 14.1

perpendicular(const point& p)

line : 17.4

segment : 17.2

perpendicular(const rat_point& p)

rat_line : 17.13

rat_segment : 17.11

perpendicular(const real_point& p)

real_line : 17.20

real_segment : 17.18

place_into_box(double x0, double y0, double x1, double y1)

GraphWin : 20.6

place_into_win()

GraphWin : 20.6

PLANAR(graph& , bool embed=false) : 15.13

PLANAR(graph& G, list<edge>& el, bool embed=false) : 15.13

planar_map : 14.6

PLANAR_MAP<vtype,e...> : 14.7

plane_graph_alg : 15.13

plot_xy(double x0, double x1, win_draw_func F, color c=window::fgcol)

window : 20.2

plot_yx(double y0, double y1, win_draw_func F, color c=window::fgcol)

window : 20.2

point : 17.1

point generators : 17.26

point1()

circle : 17.5

d3_line : 19.4

d3_plane : 19.5

d3_rat_line : 19.10

d3_rat_plane : 19.12

d3_rat_ray : 19.9

d3_rat_simplex : 19.14

d3_rat_sphere : 19.13

d3_ray : 19.2

d3_simplex : 19.7

d3_sphere : 19.6

line : 17.4

rat_circle : 17.14

rat_line : 17.13

rat_ray : 17.12

rat_triangle : 17.15

ray : 17.3

real_circle : 17.21

real_line : 17.20

real_ray : 17.19

real_triangle : 17.22

triangle : 17.8

point2()

circle : 17.5

d3_line : 19.4

d3_plane : 19.5

d3_rat_line : 19.10

d3_rat_plane : 19.12

d3_rat_ray : 19.9

d3_rat_simplex : 19.14

d3_rat_sphere : 19.13

d3_ray : 19.2

d3_simplex : 19.7

d3_sphere : 19.6

line : 17.4

rat_circle : 17.14

rat_line : 17.13

rat_ray : 17.12

rat_triangle : 17.15

ray : 17.3

real_circle : 17.21

real_line : 17.20

real_ray : 17.19

real_triangle : 17.22

triangle : 17.8

point3()

circle : 17.5

d3_plane : 19.5

d3_rat_plane : 19.12

d3_rat_simplex : 19.14

d3_rat_sphere : 19.13

d3_simplex : 19.7

d3_sphere : 19.6

rat_circle : 17.14

rat_triangle : 17.15

real_circle : 17.21

real_triangle : 17.22

triangle : 17.8

point4()

d3_rat_simplex : 19.14

d3_rat_sphere : 19.13

d3_simplex : 19.7

d3_sphere : 19.6

POINT_LOCATOR : 18.3

point_on_circle(double alpha, double epsilon)

rat_circle : 17.14

point_on_circle(double alpha, double=0)

circle : 17.5

point_on_positive_side(const d3_point& a, const d3_point& b, const d3_point& c) : 19.1

point_on_positive_side(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c) : 19.8

POINT_SET : 18.2

point_type

circle : 17.5

d3_rat_simplex : 19.14

d3_simplex : 19.7

GEN_POLYGON : 17.7

line : 17.4

point : 17.1

POLYGON : 17.6

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

rat_circle : 17.14

rat_line : 17.13

rat_point : 17.10

rat_ray : 17.12

rat_segment : 17.11

rat_triangle : 17.15

ray : 17.3

real_circle : 17.21

real_line : 17.20

real_point : 17.17

real_ray : 17.19

real_segment : 17.18

real_triangle : 17.22

segment : 17.2

triangle : 17.8

points()

POINT_SET : 18.2

points_on_segment(SEGMENT s, int n, list<POINT>& L) : 17.26

polar_to_cartesian()

d3_point : 19.1

POLYGON : 17.6

polygon_type

GEN_POLYGON : 17.7

r_circle_gen_polygon : 17.30

polygons()

GEN_POLYGON : 17.7

r_circle_gen_polygon : 17.30

Polynomial

real : 8.4

pop()

b_queue<E> : 9.6

b_stack<E> : 9.5

list<E> : 9.7 | 9.7

node_list : 14.18

queue<E> : 9.4

slist<E> : 9.8

stack<E> : 9.3

pop_back()

b_queue<E> : 9.6

list<E> : 9.7

node_list : 14.18

pop_front()

b_queue<E> : 9.6

list<E> : 9.7

pos(const string& s1)

string : 6.1

pos(node v)

POINT_SET : 18.2

pos(string s1, int i)

string : 6.1

pos_source(edge e)

POINT_SET : 18.2

pos_target(edge e)

POINT_SET : 18.2

position(node v)

subdivision<I> : 18.7

possible_zero()

real : 8.4

pow(const rational& q, int n) : 8.2

pow(const rational& q, integer a) : 8.2

powi(const real& x, int n) : 8.4

PPMIICoder : 12.3

pred(const K& k)

sortseq<K,I> : 10.6

pred(list_item it)

list<E> : 9.7

pred(node v)

node_list : 14.18

pred(seq_item x)

sortseq<K,I> : 10.6

pred_edge(edge e)

graph : 14.1

pred_face(face f)

graph : 14.1

pred_face_edge(edge e)

graph : 14.1

pred_node(node v)

graph : 14.1

prep_graph

graph_morphism_algorithm< graph_t > : 15.16

prepare_graph(const graph_t& g, const node_compat& node_comp = DEFAULT_NODE_CMP, const edge_compat& edge_comp = DEFAULT_EDGE_CMP)

graph_morphism_algorithm< graph_t > : 15.16

print()

matrix : 8.11

real_matrix : 8.16

real_vector : 8.15

vector : 8.10

print(char space = ' ')

array<E> : 9.1

list<E> : 9.7

print(ostream& O = cout)

graph : 14.1

print(ostream& O)

matrix : 8.11

real_matrix : 8.16

real_vector : 8.15

vector : 8.10

print(ostream& O, char space = ' ')

array<E> : 9.1

list<E> : 9.7

print(ostream& out, string s, char c=' ')

sortseq<K,I> : 10.6

print(string header, char space = ' ')

list<E> : 9.7

print(string s, char c=' ')

sortseq<K,I> : 10.6

print(string s, char space = ' ')

array<E> : 9.1

print(string s, ostream& O = cout)

graph : 14.1

print_edge(edge e, ostream& O = cout)

graph : 14.1

print_face(face f)

graph : 14.1

print_node(node v, ostream& O = cout)

graph : 14.1

print_separation_bounds()

real : 8.4

print_statistics() : 6.15

prio(b_pq_item x)

b_priority_queue<I> : 11.2

prio(node v)

node_pq<P> : 14.20

prio(pq_item it)

p_queue<P,I> : 11.1

prio_type

p_queue<P,I> : 11.1

project(const d3_point& p, const d3_point& q, const d3_point& v)

d3_segment : 19.3

project(const d3_point& p, const d3_point& q, const d3_point& v, d3_line& m)

d3_line : 19.4

project(const d3_point& p, const d3_point& q, const d3_point& v, d3_ray& m)

d3_ray : 19.2

project(const d3_rat_point& p, const d3_rat_point& q, const d3_rat_point& v)

d3_rat_segment : 19.11

project(const d3_rat_point& p, const d3_rat_point& q, const d3_rat_point& v, d3_rat_line& m)

d3_rat_line : 19.10

project(const d3_rat_point& p, const d3_rat_point& q, const d3_rat_point& v, d3_rat_ray& m)

d3_rat_ray : 19.9

project_xy()

d3_point : 19.1

d3_rat_point : 19.8

d3_rat_segment : 19.11

d3_segment : 19.3

project_xy(line& m)

d3_line : 19.4

project_xy(rat_line& m)

d3_rat_line : 19.10

project_xy(rat_ray& m)

d3_rat_ray : 19.9

project_xy(ray& m)

d3_ray : 19.2

project_xz()

d3_point : 19.1

d3_rat_point : 19.8

d3_rat_segment : 19.11

d3_segment : 19.3

project_xz(line& m)

d3_line : 19.4

project_xz(rat_line& m)

d3_rat_line : 19.10

project_xz(rat_ray& m)

d3_rat_ray : 19.9

project_xz(ray& m)

d3_ray : 19.2

project_yz()

d3_point : 19.1

d3_rat_point : 19.8

d3_rat_segment : 19.11

d3_segment : 19.3

project_yz(line& m)

d3_line : 19.4

project_yz(rat_line& m)

d3_rat_line : 19.10

project_yz(rat_ray& m)

d3_rat_ray : 19.9

project_yz(ray& m)

d3_ray : 19.2

ps_file : 20.5

pstyle_item(string s, point_style& x, const char* hlp=0)

window : 20.2

pstyle_item(string s, point_style& x, const window_handler& obj, const char* hlp=0)

window : 20.2

pstyle_item(string s, point_style& x, void(*F)(int), const char* hlp=0)

window : 20.2

push(const E& x)

b_queue<E> : 9.6

b_stack<E> : 9.5

list<E> : 9.7

queue<E> : 9.4

slist<E> : 9.8

stack<E> : 9.3

push(node v)

node_list : 14.18

push_back(const E& x)

b_queue<E> : 9.6

list<E> : 9.7

push_front(const E& x)

b_queue<E> : 9.6

list<E> : 9.7

put_back_event() : 20.2

put_bitmap(double x, double y, char* bm, color c=window::fgcol)

window : 20.2

put_pixrect(char* pr)

window : 20.2

put_pixrect(double x, double y, char* pr)

window : 20.2

put_pixrect(double x, double y, char* pr, int x0, int y0, int w, int h)

window : 20.2

put_pixrect(point p, char* pr)

window : 20.2

queue<E> : 9.4

quick_search()

string_matching : 7.2

r_circle_gen_polygon : 17.30

r_circle_point : 17.27

r_circle_polygon : 17.29

r_circle_segment : 17.28

radical_axis(const circle& C1, const circle& C2, line& rad_axis) : 17.5

radical_axis(const rat_circle& C1, const rat_circle& C2, rat_line& rad_axis) : 17.14

radical_axis(const real_circle& C1, const real_circle& C2, real_line& rad_axis) : 17.21

radius()

circle : 17.5

d3_sphere : 19.6

real_circle : 17.21

raita()

string_matching : 7.2

random(int n)

integer : 8.1

random_bigraph(graph& G, int a, int b, int m, list<node>& A, list<node>& B, int k = 1) : 14.22

random_d3_rat_point_in_ball(int R) : 19.8

random_d3_rat_point_in_cube(int maxc) : 19.8

random_d3_rat_point_in_disc(int R) : 19.8

random_d3_rat_point_in_square(int maxc) : 19.8

random_d3_rat_point_in_unit_ball(int D = 16383) : 19.8

random_d3_rat_point_in_unit_cube(int D = 16383) : 19.8

random_d3_rat_point_on_circle(int R) : 19.8

random_d3_rat_point_on_paraboloid(int maxc) : 19.8

random_d3_rat_point_on_sphere(int R) : 19.8

random_d3_rat_point_on_unit_circle(int D = 16383) : 19.8

random_d3_rat_point_on_unit_sphere(int D = 16383) : 19.8

random_d3_rat_points_in_ball(int n, int R, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_in_cube(int n, int maxc, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_in_disc(int n, int R, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_in_square(int n, int maxc, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_in_unit_ball(int n, int D, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_in_unit_ball(int n, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_in_unit_cube(int n, int D, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_in_unit_cube(int n, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_on_circle(int m, int R, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_on_paraboloid(int n, int maxc, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_on_segment(int n, int maxc, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_on_sphere(int m, int R, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_on_unit_circle(int m, int D, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_on_unit_circle(int m, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_on_unit_sphere(int m, int D, list<d3_rat_point>& L) : 19.8

random_d3_rat_points_on_unit_sphere(int m, list<d3_rat_point>& L) : 19.8

random_graph(graph& G, int n, double p) : 14.22

random_graph(graph& G, int n, int m) : 14.22

random_graph(graph& G, int n, int m, bool no_anti_parallel_edges, bool loopfree, bool no_parallel_edges) : 14.22

random_graph_noncompact(graph& G, int n, int m) : 14.22

random_planar_graph(graph& G, int n) : 14.22

random_planar_graph(graph& G, int n, int m) : 14.22

random_planar_graph(graph& G, node_array<double>& xcoord, node_array<double>& ycoord, int n) : 14.22

random_planar_graph(graph& G, node_array<double>& xcoord, node_array<double>& ycoord, int n, int m) : 14.22

random_planar_map(graph& G, int n, int m) : 14.22

random_planar_map(graph& G, node_array<double>& xcoord, node_array<double>& ycoord, int n, int m) : 14.22

random_point_in_ball(POINT& p, int R) : 17.26

random_point_in_cube(POINT& p, int maxc) : 17.26

random_point_in_disc(POINT& p, int R) : 17.26

random_point_in_square(POINT& p, int maxc) : 17.26

random_point_in_unit_ball(POINT& p, int D = (1<<30) - 1) : 17.26

random_point_in_unit_cube(POINT& p, int D = (1<<30) - 1) : 17.26

random_point_in_unit_disc(POINT& p, int D = (1<<30) - 1) : 17.26

random_point_in_unit_square(POINT& p, int D = (1<<30) - 1) : 17.26

random_point_near_circle(POINT& p, int R) : 17.26

random_point_near_sphere(POINT& p, int R) : 17.26

random_point_near_unit_circle(POINT& p, int D = (1<<30) - 1) : 17.26

random_point_near_unit_sphere(POINT& p, int D = (1<<30) - 1) : 17.26

random_point_on_circle(POINT& p, int R, int C = 1000000) : 17.26

random_point_on_paraboloid(POINT& p, int maxc) : 17.26

random_point_on_segment(POINT& p, SEGMENT s) : 17.26

random_point_on_sphere(POINT& p, int R) : 17.26

random_point_on_unit_circle(POINT& p, int C = 1000000) : 17.26

random_point_on_unit_sphere(POINT& p, int D = (1<<30) - 1) : 17.26

random_points_in_ball(int n, int R, list<POINT>& L) : 17.26

random_points_in_cube(int n, int maxc, list<POINT>& L) : 17.26

random_points_in_disc(int n, int R, list<POINT>& L) : 17.26

random_points_in_square(int n, int maxc, list<POINT>& L) : 17.26

random_points_in_unit_ball(int n, int D, list<POINT>& L) : 17.26

random_points_in_unit_ball(int n, list<POINT>& L) : 17.26

random_points_in_unit_cube(int n, int D, list<POINT>& L) : 17.26

random_points_in_unit_cube(int n, list<POINT>& L) : 17.26

random_points_in_unit_disc(int n, int D, list<POINT>& L) : 17.26

random_points_in_unit_disc(int n, list<POINT>& L) : 17.26

random_points_in_unit_square(int n, int D, list<POINT>& L) : 17.26

random_points_in_unit_square(int n, list<POINT>& L) : 17.26

random_points_near_circle(int n, int R, list<POINT>& L) : 17.26

random_points_near_sphere(int n, int R, list<POINT>& L) : 17.26

random_points_near_unit_circle(int n, int D, list<POINT>& L) : 17.26

random_points_near_unit_circle(int n, list<POINT>& L) : 17.26

random_points_near_unit_sphere(int n, int D, list<POINT>& L) : 17.26

random_points_near_unit_sphere(int n, list<POINT>& L) : 17.26

random_points_on_circle(int n, int R, list<POINT>& L, int C = 1000000) : 17.26

random_points_on_diagonal(int n, int maxc, list<POINT>& L) : 17.26

random_points_on_paraboloid(int n, int maxc, list<POINT>& L) : 17.26

random_points_on_segment(SEGMENT s, int n, list<POINT>& L) : 17.26

random_points_on_sphere(int n, int R, list<POINT>& L) : 17.26

random_points_on_unit_circle(int n, list<POINT>& L, int C = 1000000) : 17.26

random_points_on_unit_sphere(int n, int D, list<POINT>& L) : 17.26

random_points_on_unit_sphere(int n, list<POINT>& L) : 17.26

random_simple_graph(graph& G, int n, int m) : 14.22

random_simple_loopfree_graph(graph& G, int n, int m) : 14.22

random_simple_undirected_graph(graph& G, int n, int m) : 14.22

random_source : 6.6

random_sp_graph(graph& G, int n, int m) : 14.22

random_variate : 6.7

range_search(const CIRCLE& C)

POINT_SET : 18.2

range_search(const K1& x0, const K1& x1, const K2& y0, const K2& y1)

d2_dictionary<K1,K2,I> : 18.1

range_search(const POINT& a, const POINT& b)

POINT_SET : 18.2

range_search(const POINT& a, const POINT& b, const POINT& c)

POINT_SET : 18.2

range_search(node v, const POINT& p)

POINT_SET : 18.2

range_search_parallelogram(const POINT& a, const POINT& b, const POINT& c)

POINT_SET : 18.2

rank(const E& x)

list<E> : 9.7

rank(const integer_matrix& M) : 8.13

rat_circle : 17.14

rat_line : 17.13

rat_point : 17.10

rat_ray : 17.12

rat_rectangle : 17.16

rat_segment : 17.11

rat_segment_set<I> : 18.6

rat_triangle : 17.15

rat_vector : 8.14

rational : 8.2

ray : 17.3

read()

array<E> : 9.1

matrix : 8.11

real_matrix : 8.16

real_vector : 8.15

vector : 8.10

read(char delim = ' ')

string : 6.1

read(char delim = '')

list<E> : 9.7

read(const string& filename, gen_polygon& P)

wkb_io : 17.31

read(geo_scene sc, istream& is)

GeoWin : 20.8

read(istream& I = cin)

graph : 14.1

read(istream& I)

array<E> : 9.1

list<E> : 9.7

matrix : 8.11

real_matrix : 8.16

real_vector : 8.15

vector : 8.10

read(istream& I, char delim = ' ')

string : 6.1

read(istream& I, char delim)

list<E> : 9.7

read(string fname)

GRAPH<vtype,e...> : 14.2

read(string prompt, char delim = '')

list<E> : 9.7

read(string s)

array<E> : 9.1

graph : 14.1

read_char(string s) : 6.15

read_defaults(string fname)

GraphWin : 20.6

read_event()

window : 20.2

read_event(int& val, double& x, double& y)

window : 20.2

read_event(int& val, double& x, double& y, unsigned long& t)

window : 20.2

read_event(int& val, double& x, double& y, unsigned long& t, int timeout)

window : 20.2

read_file()

string : 6.1

read_file(istream& I)

string : 6.1

read_gml(istream& I = cin)

graph : 14.1

read_gml(istream& in)

GraphWin : 20.6

read_gml(string fname, bool ask_override=false)

GraphWin : 20.6

read_gml(string s)

graph : 14.1

read_gml_string(string s)

GraphWin : 20.6

read_gw(istream& in)

GraphWin : 20.6

read_gw(string fname)

GraphWin : 20.6

read_int(string p)

window : 20.2

read_int(string s) : 6.15

read_line()

string : 6.1

read_line(istream& I)

string : 6.1

read_mouse()

d3_window : 20.9

window : 20.2

read_mouse(double& x, double& y)

window : 20.2

read_mouse(double& x0, double& y0, int timeout1, int timeout2, bool& double_click, bool& drag)

window : 20.2

read_mouse(point& p)

window : 20.2

read_mouse(point& p, int timeout1, int timeout2, bool& double_click, bool& drag)

window : 20.2

read_mouse(window*& w, double& x, double& y) : 20.2

read_mouse_arc(const point& p, const point& q, point& r)

window : 20.2

read_mouse_arc(double x0, double y0, double x1, double y1, double& x, double& y)

window : 20.2

read_mouse_circle(const point& p, point& q)

window : 20.2

read_mouse_circle(double x0, double y0, double& x, double& y)

window : 20.2

read_mouse_line(const point& p, point& q)

window : 20.2

read_mouse_line(double x0, double y0, double& x, double& y)

window : 20.2

read_mouse_ray(const point& p, point& q)

window : 20.2

read_mouse_ray(double x0, double y0, double& x, double& y)

window : 20.2

read_mouse_rect(const point& p, point& q)

window : 20.2

read_mouse_rect(double x0, double y0, double& x, double& y)

window : 20.2

read_mouse_seg(const point& p, point& q)

window : 20.2

read_mouse_seg(double x0, double y0, double& x, double& y)

window : 20.2

read_panel(string h, int n, string* S)

window : 20.2

read_passphrase(const string& prompt, uint16 min_length = 6)

CryptKey : 13.2

read_polygon()

window : 20.2

read_real(string p)

window : 20.2

read_real(string s) : 6.15

read_string(string p)

window : 20.2

read_string(string s) : 6.15

read_vpanel(string h, int n, string* S)

window : 20.2

real : 8.4

real_circle : 17.21

real_line : 17.20

real_matrix : 8.16

real_middle()

r_circle_segment : 17.28

real_point : 17.17

real_ray : 17.19

real_rectangle : 17.23

real_roots(const int_Polynomial& iP, list<real>& roots, algorithm_type algorithm = isolating_algorithm, bool is_squarefree = true) : 8.4

real_roots(const Polynomial& P, growing_array<real>& roots, algorithm_type algorithm, bool is_squarefree) : 8.4

real_roots(const Polynomial& P, list<real>& roots, algorithm_type algorithm, bool is_squarefree) : 8.4

real_segment : 17.18

real_time() : 6.15

real_time(float& T) : 6.15

real_triangle : 17.22

real_vector : 8.15

receive_bytes(char* buf, size_t buf_sz)

leda_socket : 6.13

receive_bytes(size_t& num)

leda_socket : 6.13

receive_file(string fname)

leda_socket : 6.13

receive_int(int& x)

leda_socket : 6.13

receive_string(string& s)

leda_socket : 6.13

rectangle : 17.9

redraw()

GeoWin : 20.8

GraphWin : 20.6

window : 20.2

redraw_panel()

window : 20.2

redraw_panel(panel_item it)

window : 20.2

reduce(double a, double p)

residual : 8.7

reduce_of_positive(double a, double p)

residual : 8.7

reflect(const d3_plane& Q)

d3_plane : 19.5

reflect(const d3_point& p)

d3_line : 19.4

d3_ray : 19.2

d3_segment : 19.3

d3_simplex : 19.7

reflect(const d3_point& p, const d3_point& q, const d3_point& v)

d3_line : 19.4

d3_ray : 19.2

d3_segment : 19.3

d3_simplex : 19.7

reflect(const d3_point& q)

d3_plane : 19.5

d3_point : 19.1

reflect(const d3_point& q, const d3_point& r, const d3_point& s)

d3_point : 19.1

reflect(const d3_rat_plane& Q)

d3_rat_plane : 19.12

reflect(const d3_rat_point& p)

d3_rat_line : 19.10

d3_rat_ray : 19.9

d3_rat_segment : 19.11

d3_rat_simplex : 19.14

reflect(const d3_rat_point& p, const d3_rat_point& q, const d3_rat_point& r)

d3_rat_point : 19.8

reflect(const d3_rat_point& p, const d3_rat_point& q, const d3_rat_point& v)

d3_rat_line : 19.10

d3_rat_ray : 19.9

d3_rat_segment : 19.11

d3_rat_simplex : 19.14

reflect(const d3_rat_point& q)

d3_rat_plane : 19.12

d3_rat_point : 19.8

reflect(const point& p)

circle : 17.5

GEN_POLYGON : 17.7

POLYGON : 17.6

ray : 17.3

rectangle : 17.9

segment : 17.2

triangle : 17.8

reflect(const point& p, const point& q)

circle : 17.5

GEN_POLYGON : 17.7

line : 17.4

POLYGON : 17.6

ray : 17.3

segment : 17.2

triangle : 17.8

reflect(const point& q)

point : 17.1

reflect(const point& q, const point& r)

point : 17.1

reflect(const rat_point& p)

r_circle_gen_polygon : 17.30

r_circle_point : 17.27

r_circle_polygon : 17.29

r_circle_segment : 17.28

rat_circle : 17.14

rat_line : 17.13

rat_ray : 17.12

rat_rectangle : 17.16

rat_segment : 17.11

rat_triangle : 17.15

reflect(const rat_point& p, const rat_point& q)

r_circle_gen_polygon : 17.30

r_circle_point : 17.27

r_circle_polygon : 17.29

r_circle_segment : 17.28

rat_circle : 17.14

rat_line : 17.13

rat_point : 17.10

rat_ray : 17.12

rat_segment : 17.11

rat_triangle : 17.15

reflect(const rat_point& q)

rat_point : 17.10

reflect(const real_point& p)

real_circle : 17.21

real_ray : 17.19

real_rectangle : 17.23

real_segment : 17.18

real_triangle : 17.22

reflect(const real_point& p, const real_point& q)

real_circle : 17.21

real_line : 17.20

real_ray : 17.19

real_segment : 17.18

real_triangle : 17.22

reflect(const real_point& q)

real_point : 17.17

reflect(const real_point& q, const real_point& r)

real_point : 17.17

reflect_point(const d3_point& q)

d3_plane : 19.5

reflect_point(const d3_rat_point& q)

d3_rat_plane : 19.12

reflection(const POINT& q) : 17.25

reflection(const POINT& q, const POINT& r) : 17.25

reg_n_gon(int n, CIRCLE C, double epsilon) : 17.6

region_of(const POINT& p)

GEN_POLYGON : 17.7

POLYGON : 17.6

rectangle : 17.9

triangle : 17.8

region_of(const r_circle_point& p)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

region_of(const rat_point& p)

rat_rectangle : 17.16

rat_triangle : 17.15

region_of(const real_point& p)

real_rectangle : 17.23

real_triangle : 17.22

region_of_sphere(const d3_point& a, const d3_point& b, const d3_point& c, const d3_point& d, const d3_point& x) : 19.1

region_of_sphere(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c, const d3_rat_point& d, const d3_rat_point& x) : 19.8

regional_decomposition()

GEN_POLYGON : 17.7

register_window(window& win, bool (*ev_fcn)(window* w, int event, int but, double x, double y))

GeoWin : 20.8

reinit_seed()

random_source : 6.6

rel_freq_of_visit(node v)

dynamic_markov_chain : 14.25

markov_chain : 14.24

relative_neighborhood_graph()

POINT_SET : 18.2

remove(const E& x)

list<E> : 9.7

remove_bends()

GraphWin : 20.6

remove_bends(edge e)

GraphWin : 20.6

remove_texts()

GeoWin : 20.8

remove_texts(geo_scene sc)

GeoWin : 20.8

remove_trailing_directory_delimiter(string& dir) : 6.12

remove_user_layer_objects()

GeoWin : 20.8

replace(const string& s1, const string& s2, int i=1)

string : 6.1

replace(int i, const string& s1)

string : 6.1

replace(int i, int j, const string& s1)

string : 6.1

replace_all(const string& s1, const string& s2)

string : 6.1

report_on_desctruction(bool do_report = true)

counter : 6.17

timer : 6.16

required_primetable_size(int b)

residual : 8.8

reset()

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

AdjIt : 16.7

AutoDecoder : 12.24

counter : 6.17

CryptAutoDecoder : 13.6

DictCoder : 12.5

EdgeIt : 16.3

FaceIt : 16.4

GraphWin : 20.6

HuffmanCoder : 12.6

InAdjIt : 16.6

memory_streambuf : 12.26

MTF2Coder : 12.11

MTFCoder : 12.10

NodeIt : 16.2

OutAdjIt : 16.5

RLE0Coder : 12.12

timer : 6.16

reset(bool keep_block_size = true)

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

reset(bool keep_key = true)

CBCCoder< BlkCipher > : 13.4

reset(bool keep_mode = true)

RLECoder : 12.8

reset(bool keep_parameters = true)

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

DeflateCoder : 12.4

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

reset(bool keep_thresholds = true)

A0Coder : 12.1

reset_actions()

GeoWin : 20.8

GraphWin : 20.6

reset_acyclic()

GIT_TOPOSORT<OutAdjI...> : 16.19

reset_clipping()

window : 20.2

reset_defaults()

GraphWin : 20.6

reset_edge_anchors()

GraphWin : 20.6

reset_edges(long mask=E_ALL)

GraphWin : 20.6

reset_end()

AdjIt : 16.7

EdgeIt : 16.3

FaceIt : 16.4

InAdjIt : 16.6

NodeIt : 16.2

OutAdjIt : 16.5

reset_frame_label()

window : 20.2

reset_nodes(long mask=N_ALL)

GraphWin : 20.6

reset_num_calls()

graph_morphism_algorithm< graph_t > : 15.16

reset_path()

gml_graph : 14.26

reset_window()

GeoWin : 20.8

residual : 8.6 | 8.7 | 8.8

resize(int low, int high)

array<E> : 9.1

resize(int n)

array<E> : 9.1

restart()

timer : 6.16

restore_all_attributes()

GraphWin : 20.6

restore_all_edges()

graph : 14.1

restore_all_nodes()

graph : 14.1

restore_edge(edge e)

graph : 14.1

restore_edge_attributes()

GraphWin : 20.6

restore_edges(const list<edge>& el)

graph : 14.1

restore_node(node v)

graph : 14.1

restore_node_attributes()

GraphWin : 20.6

rev_all_edges()

graph : 14.1

rev_edge(edge e)

graph : 14.1

reversal()

rat_segment : 17.11

reversal(edge e)

graph : 14.1

reverse()

circle : 17.5

d3_line : 19.4

d3_rat_line : 19.10

d3_rat_ray : 19.9

d3_rat_segment : 19.11

d3_ray : 19.2

d3_segment : 19.3

line : 17.4

list<E> : 9.7

r_circle_segment : 17.28

rat_circle : 17.14

rat_line : 17.13

rat_ray : 17.12

rat_segment : 17.11

rat_triangle : 17.15

ray : 17.3

real_circle : 17.21

real_line : 17.20

real_ray : 17.19

real_segment : 17.18

real_triangle : 17.22

segment : 17.2

triangle : 17.8

reverse(edge e)

graph : 14.1

reverse(list_item it1, list_item it2)

list<E> : 9.7

reverse_colussi()

string_matching : 7.2

reverse_factor()

string_matching : 7.2

reverse_items()

list<E> : 9.7

reverse_items(list_item it1, list_item it2)

list<E> : 9.7

reverse_items(seq_item a, seq_item b)

sortseq<K,I> : 10.6

right(is_item it)

interval_set<I> : 18.4

right_tangent(const point& p)

circle : 17.5

right_tangent(const real_point& p)

real_circle : 17.21

right_turn(const point& a, const point& b, const point& c) : 17.1

right_turn(const rat_point& a, const rat_point& b, const rat_point& c) : 17.10

right_turn(const real_point& a, const real_point& b, const real_point& c) : 17.17

RLE0Coder : 12.12

RLECoder : 12.8

root(const real& x, int d) : 8.4

rotate(const point& p, double alpha)

GEN_POLYGON : 17.7

POLYGON : 17.6

rotate(const point& q, double a)

circle : 17.5

line : 17.4

point : 17.1

ray : 17.3

segment : 17.2

triangle : 17.8

rotate(double a)

circle : 17.5

line : 17.4

point : 17.1

ray : 17.3

vector : 8.10

rotate(double alpha)

GEN_POLYGON : 17.7

POLYGON : 17.6

segment : 17.2

triangle : 17.8

rotate90(const point& p, int i=1)

rectangle : 17.9

rotate90(const point& q, int i=1)

circle : 17.5

GEN_POLYGON : 17.7

line : 17.4

point : 17.1

POLYGON : 17.6

ray : 17.3

segment : 17.2

triangle : 17.8

rotate90(const rat_point& p, int i=1)

rat_rectangle : 17.16

rotate90(const rat_point& q, int i = 1)

rat_point : 17.10

rotate90(const rat_point& q, int i=1)

r_circle_gen_polygon : 17.30

r_circle_point : 17.27

r_circle_polygon : 17.29

r_circle_segment : 17.28

rat_circle : 17.14

rat_line : 17.13

rat_ray : 17.12

rat_segment : 17.11

rat_triangle : 17.15

rotate90(const real_point& p, int i=1)

real_rectangle : 17.23

rotate90(const real_point& q, int i=1)

real_circle : 17.21

real_line : 17.20

real_point : 17.17

real_ray : 17.19

real_segment : 17.18

real_triangle : 17.22

rotate90(int i = 1)

rat_point : 17.10

rotate90(int i=1)

point : 17.1

rat_rectangle : 17.16

rat_segment : 17.11

rat_triangle : 17.15

rat_vector : 8.14

real_point : 17.17

real_rectangle : 17.23

real_segment : 17.18

real_triangle : 17.22

real_vector : 8.15

rectangle : 17.9

segment : 17.2

triangle : 17.8

vector : 8.10

rotate_around_axis(int a, double phi)

d3_point : 19.1

rotate_around_vector(const vector& u, double phi)

d3_point : 19.1

rotation(const POINT& q, double alpha, double eps) : 17.25

rotation90(const POINT& q) : 17.25

round(const rational& q) : 8.2

round(int prec = 0)

r_circle_gen_polygon : 17.30

r_circle_point : 17.27

r_circle_polygon : 17.29

r_circle_segment : 17.28

row(int i)

integer_matrix : 8.13

matrix : 8.11

real_matrix : 8.16

run()

distance : 7.4

same_block(node v, node w)

node_partition : 14.19

same_block(partition_item p, partition_item q)

partition : 9.12

Partition<E> : 9.13

save_all_attributes()

GraphWin : 20.6

save_defaults(string fname)

GraphWin : 20.6

save_edge_attributes()

GraphWin : 20.6

save_gml(ostream& out)

GraphWin : 20.6

save_gml(string fname, bool ask_override=false)

GraphWin : 20.6

save_gw(ostream& out)

GraphWin : 20.6

save_gw(string fname, bool ask_overwrite=false)

GraphWin : 20.6

save_latex(string fname, bool ask_override=false)

GraphWin : 20.6

save_layout(ostream& ostr)

GraphWin : 20.6

save_layout(string fname, bool ask_override=false)

GraphWin : 20.6

save_node_attributes()

GraphWin : 20.6

save_ps(string fname, bool ask_override=false)

GraphWin : 20.6

save_svg(string fname, bool ask_override=false)

GraphWin : 20.6

save_wmf(string fname, bool ask_override=false)

GraphWin : 20.6

scale()

window : 20.2

score_matrix : 7.3

screenshot(string fname, bool full_color=true)

window : 20.2

search(const E& x)

list<E> : 9.7

second()

four_tuple<A,B,C,D> : 6.20

three_tuple<A,B,C> : 6.19

two_tuple<A,B> : 6.18

second_type

four_tuple<A,B,C,D> : 6.20

three_tuple<A,B,C> : 6.19

two_tuple<A,B> : 6.18

secure_socket_streambuf : 13.7

seekg(streamoff off, ios::seekdir dir)

decoding_ifstream<Coder> : 12.22

seekg(streampos pos)

decoding_ifstream<Coder> : 12.22

seekp(streamoff off, ios::seekdir dir)

encoding_ofstream<Coder> : 12.21

seekp(streampos pos)

encoding_ofstream<Coder> : 12.21

seg()

d3_line : 19.4

d3_rat_line : 19.10

d3_rat_ray : 19.9

d3_ray : 19.2

line : 17.4

rat_line : 17.13

real_line : 17.20

seg(edge e)

POINT_SET : 18.2

segment : 17.2

SEGMENT_INTERSECTION(const list<segment>& S, GRAPH<point,segment>& G, bool embed=false) : 17.24

SEGMENT_INTERSECTION(const list<segment>& S, list<point>& P) : 17.24

SEGMENT_INTERSECTION(const list<segment>& S, void (*report)(const segment& , const segment& )) : 17.24

SEGMENT_INTERSECTION(const list<segment>& S1, const list<segment>& S2, GRAPH<point,segment>& G, bool embed=false) : 17.24

segment_set<I> : 18.5

segment_type

GEN_POLYGON : 17.7

POLYGON : 17.6

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

segments()

POLYGON : 17.6

r_circle_polygon : 17.29

select(edge e)

GraphWin : 20.6

select(node v)

GraphWin : 20.6

select_all_edges()

GraphWin : 20.6

select_all_nodes()

GraphWin : 20.6

send_bytes(char* buf, size_t num)

leda_socket : 6.13

send_file(string fname)

leda_socket : 6.13

send_file(string fname, int buf_sz)

leda_socket : 6.13

send_int(int x)

leda_socket : 6.13

send_string(string msg)

leda_socket : 6.13

sends_acknowledge()

secure_socket_streambuf : 13.7

socket_streambuf : 6.14

sep_bfmss()

real : 8.4

sep_degree_measure()

real : 8.4

sep_li_yap()

real : 8.4

separation_bound()

real : 8.4

separator()

menu : 20.4

set(int x, const E& e)

array<E> : 9.1

set(node_array_da<T>& da, const Iter& it, T val) : 16.13

set(node_attribute_da<T>& ma, const Iter& it, T val) : 16.16

set(node_member_da<Str,T>& ma, const Iter& it, T val) : 16.15

set<E> : 9.9

set_action(long mask, geo_action f=0)

GeoWin : 20.8

set_action(long mask, gw_action func)

GraphWin : 20.6

set_activate_handler(geo_scene sc, void (*f)(geo_scene))

GeoWin : 20.8

set_active_line_width(geo_scene sc, int w)

GeoWin : 20.8

set_active_line_width(geo_scenegroup gs, int w)

GeoWin : 20.8

set_all_visible(bool v)

GeoWin : 20.8

set_animation_steps(int s)

GraphWin : 20.6

set_arrow(edge e, bool ar)

d3_window : 20.9

set_bg_color(color c)

GraphWin : 20.6

window : 20.2

set_bg_color(const color& c)

GeoWin : 20.8

set_bg_pixmap(char* pr)

window : 20.2

set_bg_pixmap(char* pr, double xorig=0, double yorig=0)

GraphWin : 20.6

set_bg_pixmap(string pix_name)

GeoWin : 20.8

set_bg_redraw(const window_handler& obj)

window : 20.2

set_bg_redraw(void (*f)(window*, double, double, double, double))

GraphWin : 20.6

set_bg_redraw(void (*F)(window*, double, double, double, double)=0)

window : 20.2

set_bg_xpm(const char** xpm_data)

GraphWin : 20.6

set_bitmap(geo_scene sc, unsigned char* bitmap)

GeoWin : 20.8

set_bitmap_colors(int c0, int c1)

window : 20.2

set_block_size(uint32 block_size)

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

set_blue(int b)

color : 20.1

set_buffer(char* buf, streamsize buf_sz, bool own_buf = false, bool wipe_buf = false)

memory_streambuf : 12.26

set_button_height(int h)

GeoWin : 20.8

set_button_label(int but, string s)

window : 20.2

set_button_pixrects(int but, char *pr1, char* pr2)

window : 20.2

set_button_space(int s)

window : 20.2

set_button_width(int w)

GeoWin : 20.8

set_checksums_in_stream_flag(bool sums_in_stream, uint32 blocksize = 0)

checksummer_base : 12.13

set_client_data(geo_scene sc, void* p, int i=0)

GeoWin : 20.8

set_client_data(void* p, int i=0)

window : 20.2

set_clip_ellipse(double x0, double y0, double r1, double r2)

window : 20.2

set_clip_rectangle(double x0, double y0, double x1, double y1)

window : 20.2

set_coder1(Coder1* c1, bool own_coder = false)

CoderPipe2<Coder1,...> : 12.23

set_coder2(Coder2* c2, bool own_coder = false)

CoderPipe2<Coder1,...> : 12.23

set_color(color c)

window : 20.2

set_color(edge e, color c)

d3_window : 20.9

set_color(geo_scene sc, color c)

GeoWin : 20.8

set_color(geo_scenegroup gs, color c)

GeoWin : 20.8

set_color(node v, color c)

d3_window : 20.9

set_compression_level(int level)

DeflateCoder : 12.4

set_cursor(int cursor_id = -1)

GeoWin : 20.8

window : 20.2

set_cyclic_colors(geo_scene sc, bool b)

GeoWin : 20.8

set_d3_elimination(bool b)

GeoWin : 20.8

set_d3_fcn(geo_scene sc, void (*f)(geo_scene gs, d3_window& W, GRAPH<d3_point,int>& H))

GeoWin : 20.8

set_d3_show_edges(bool b)

GeoWin : 20.8

set_d3_solid(bool b)

GeoWin : 20.8

set_date(const string date_str, bool swallow = true)

date : 6.21

set_date(int d, month m, int y)

date : 6.21

set_day(int d)

date : 6.21

set_dec_buffer_size(uint32 buffer_size)

DeflateCoder : 12.4

set_default_menu(long mask)

GraphWin : 20.6

set_default_value(const E& x)

d_array<I,E> : 10.2

h_array<I,E> : 10.3

map<I,E> : 10.4

set_del_edge_handler(bool (*f)(GraphWin& , edge))

GraphWin : 20.6

set_del_edge_handler(void (*f)(GraphWin& )=NULL)

GraphWin : 20.6

set_del_node_handler(bool (*f)(GraphWin& , node))

GraphWin : 20.6

set_del_node_handler(void (*f)(GraphWin& )=NULL)

GraphWin : 20.6

set_description(geo_scene sc, string desc)

GeoWin : 20.8

set_directory(string new_dir) : 6.12

set_done_handler(bool (*f)(const GeoWin& gw))

GeoWin : 20.8

set_dow_names(const char* names[])

date : 6.21

set_draw_edges(bool b)

d3_window : 20.9

set_draw_user_layer_fcn(void (*fcn)(GeoWin*))

GeoWin : 20.8

set_edge_border(bool b)

GraphWin : 20.6

set_edge_color(color c)

d3_window : 20.9

set_edge_distance(int d)

GraphWin : 20.6

set_edge_index_format(string s)

GraphWin : 20.6

set_edge_label_font(gw_font_type t, int sz)

GraphWin : 20.6

set_edge_label_font(string fn)

GraphWin : 20.6

set_edge_param(param_type x, bool apply=true)

GraphWin : 20.6

set_edge_position(edge e, edge p)

graph : 14.1

set_edge_slider_handler(void (*f)(GraphWin& , edge, double)=NULL, int sl=0)

GraphWin : 20.6

set_edit_loop_handler(bool (*f)(const GeoWin& gw))

GeoWin : 20.8

set_edit_mode(geo_scene sc, int emode)

GeoWin : 20.8

set_elim(bool b)

d3_window : 20.9

set_enc_buffer_size(uint32 buffer_size)

DeflateCoder : 12.4

set_end_edge_slider_handler(void (*f)(GraphWin& , edge, double)=NULL, int sl=0)

GraphWin : 20.6

set_end_move_node_handler(void (*f)(GraphWin& , node))

GraphWin : 20.6

set_error_handler(void (*err_handler)(int, const char*)) : 6.11

set_error_handler(void (*f)(leda_socket& , string))

leda_socket : 6.13

set_fast_compression_mode()

RLECoder : 12.8

set_fill_color(color c)

window : 20.2

set_fill_color(geo_scene sc, color c)

GeoWin : 20.8

set_fill_color(geo_scenegroup gs, color c)

GeoWin : 20.8

set_flush(bool b)

GraphWin : 20.6

window : 20.2

set_frame_label(const char* label)

GeoWin : 20.8

GraphWin : 20.6

set_frame_label(string s)

window : 20.2

set_function(int but, void (*F)(int))

window : 20.2

set_gen_edges(int m)

GraphWin : 20.6

set_gen_nodes(int n)

GraphWin : 20.6

set_graph(graph& G)

GraphWin : 20.6

set_green(int g)

color : 20.1

set_grid_dist(double d)

window : 20.2

set_grid_dist(double g)

GeoWin : 20.8

set_grid_dist(int d)

GraphWin : 20.6

set_grid_mode(int d)

window : 20.2

set_grid_size(int n)

GraphWin : 20.6

set_grid_style(grid_style g)

GeoWin : 20.8

set_grid_style(grid_style s)

GraphWin : 20.6

window : 20.2

set_handle_defining_points(geo_scene sc, geowin_defining_points gdp)

GeoWin : 20.8

set_high_compression_mode()

RLECoder : 12.8

set_host(const char* host)

leda_socket : 6.13

set_icon_label(string s)

window : 20.2

set_icon_pixrect(char* pr)

window : 20.2

set_incremental_update_limit(geo_scene sc, int l)

GeoWin : 20.8

set_incremental_update_state(geo_scene sc, bool us)

GeoWin : 20.8

set_init_graph_handler(bool (*f)(GraphWin& ))

GraphWin : 20.6

set_init_graph_handler(void (*f)(GraphWin& )=NULL)

GraphWin : 20.6

set_initialization_vector(const byte* iv)

CBCCoder< BlkCipher > : 13.4

set_input_format(format f)

date : 6.21

set_input_format(string f)

date : 6.21

set_input_precision(sz_t p)

bigfloat : 8.3

set_item_height(int h)

window : 20.2

set_item_width(int w)

window : 20.2

set_key(const CryptKey& key)

CBCCoder< BlkCipher > : 13.4

CryptAutoDecoder : 13.6

OMACCoder< BlkCipher > : 13.5

set_keys_in_file(const char* file_name)

CryptAutoDecoder : 13.6

set_keys_in_stream(streambuf* key_stream)

CryptAutoDecoder : 13.6

set_label(geo_scene sc, string label)

GeoWin : 20.8

set_language(language l)

date : 6.21

set_layout()

GraphWin : 20.6

set_layout(const node_array<double>& x, const node_array<double>& y)

GraphWin : 20.6

set_layout(const node_array<point>& pos)

GraphWin : 20.6

set_layout(const node_array<point>& pos, const edge_array<list<point> >& bends, bool reset_anchors=true)

GraphWin : 20.6

set_layout(const node_array<point>& pos, const node_array<double>& r1, const node_array<double>& r2, const edge_array<list<point> >& bends, const edge_array<point>& sanch, const edge_array<point>& tanch)

GraphWin : 20.6

set_limit(size_t limit)

leda_socket : 6.13

set_line_style(geo_scene sc, line_style l)

GeoWin : 20.8

set_line_style(geo_scenegroup gs, line_style l)

GeoWin : 20.8

set_line_style(line_style s)

window : 20.2

set_line_width(geo_scene sc, int w)

GeoWin : 20.8

set_line_width(geo_scenegroup gs, int w)

GeoWin : 20.8

set_line_width(int pix)

window : 20.2

set_MAC_in_stream_flag(bool mac_in_stream)

OMACCoder< BlkCipher > : 13.5

set_maximal_bit_length(int b, bool with_check=do_overflow_check)

residual : 8.8

set_memory_level(int level)

DeflateCoder : 12.4

set_menu(panel_item it, const list<string>& L, int sz=0)

window : 20.2

set_menu_add_fcn(void (*mfcn)(window& W))

GeoWin : 20.8

set_message(string msg)

d3_window : 20.9

set_midpoint(VOLATILE_I double num, VOLATILE_I double error)

interval : 8.5

set_mode(drawing_mode m)

window : 20.2

set_model_memory_bound(uint16 max_mem)

PPMIICoder : 12.3

set_model_order(byte order)

PPMIICoder : 12.3

set_model_restoration_method(mr_method method)

PPMIICoder : 12.3

set_month(month m)

date : 6.21

set_month_names(const char* names[])

date : 6.21

set_move_node_handler(void (*f)(GraphWin& , node)=NULL)

GraphWin : 20.6

set_name(const string& name)

counter : 6.17

timer : 6.16

set_name(geo_scene sc, string nm)

GeoWin : 20.8

set_new_edge_handler(bool (*f)(GraphWin& , node, node))

GraphWin : 20.6

set_new_edge_handler(void (*f)(GraphWin& , edge)=NULL)

GraphWin : 20.6

set_new_node_handler(bool (*f)(GraphWin& , const point& ))

GraphWin : 20.6

set_new_node_handler(void (*f)(GraphWin& , node)=NULL)

GraphWin : 20.6

set_node_color(color c)

d3_window : 20.9

set_node_index_format(string s)

GraphWin : 20.6

set_node_label_font(gw_font_type t, int sz)

GraphWin : 20.6

set_node_label_font(string fn)

GraphWin : 20.6

set_node_param(param_type x, bool apply=true)

GraphWin : 20.6

set_node_position(node v, node p)

graph : 14.1

set_node_width(int pix)

window : 20.2

set_object(int but, const window_handler& obj)

window : 20.2

set_output_format(format f)

date : 6.21

set_output_format(string f)

date : 6.21

set_output_mode(output_modes o_mode)

bigfloat : 8.3

set_output_precision(sz_t d)

bigfloat : 8.3

set_panel_bg_color(color c)

window : 20.2

set_param(edge e, param_type x)

GraphWin : 20.6

set_param(list<edge>& L, param_type x)

GraphWin : 20.6

set_param(list<node>& L, param_type x)

GraphWin : 20.6

set_param(node v, param_type x)

GraphWin : 20.6

set_pin_point(point p)

GeoWin : 20.8

set_pixrect(char* pr)

window : 20.2

set_point_style(geo_scene sc, point_style p)

GeoWin : 20.8

set_point_style(geo_scenegroup gs, point_style p)

GeoWin : 20.8

set_port(int port)

leda_socket : 6.13

set_position(const node_array<double>& x, const node_array<double>& y)

GraphWin : 20.6

set_position(const node_array<point>& pos)

GraphWin : 20.6

set_position(node v, double x, double y, double z)

d3_window : 20.9

set_postscript_user_layer_fcn(void (*fcn)(GeoWin*, ps_file& ))

GeoWin : 20.8

set_precision(int p)

random_source : 6.6

set_precision(int prec)

window : 20.2

set_precision(sz_t p)

bigfloat : 8.3

set_qlength(int len)

leda_socket : 6.13

set_quit_handler(bool (*f)(const GeoWin& gw))

GeoWin : 20.8

set_range(int low, int high)

random_source : 6.6

set_range(VOLATILE_I double x, VOLATILE_I double y)

interval : 8.5

set_receive_handler(void (*f)(leda_socket& , size_t, size_t))

leda_socket : 6.13

set_red(int r)

color : 20.1

set_redraw(const window_handler& obj)

window : 20.2

set_redraw(void (*F)(window*))

window : 20.2

set_redraw(void (*F)(window*, double, double, double, double)=0)

window : 20.2

set_redraw2(const window_handler& obj)

window : 20.2

set_reset_threshold(uint32 t)

A0Coder : 12.1

set_reversal(edge e, edge r)

graph : 14.1

set_rgb(int r, int g, int b)

color : 20.1

set_rounding_mode(rounding_modes m)

bigfloat : 8.3

set_scale_threshold(uint32 t)

A0Coder : 12.1

set_seed(int s)

random_source : 6.6

set_selection_color(geo_scene sc, color c)

GeoWin : 20.8

set_selection_color(geo_scenegroup gs, color c)

GeoWin : 20.8

set_selection_fill_color(geo_scene sc, color c)

GeoWin : 20.8

set_selection_line_style(geo_scene sc, line_style l)

GeoWin : 20.8

set_selection_line_width(geo_scene sc, int w)

GeoWin : 20.8

set_send_handler(void (*f)(leda_socket& , size_t, size_t))

leda_socket : 6.13

set_show_algorithms_menu(bool v)

GeoWin : 20.8

set_show_coord_handler(void (*F)(window*, double, double))

window : 20.2

set_show_coord_object(const window_handler& obj)

window : 20.2

set_show_coordinates(bool b)

window : 20.2

set_show_edit_menu(bool v)

GeoWin : 20.8

set_show_file_menu(bool v)

GeoWin : 20.8

set_show_grid(bool sh)

GeoWin : 20.8

set_show_help_menu(bool v)

GeoWin : 20.8

set_show_menu(bool v)

GeoWin : 20.8

set_show_options_menu(bool v)

GeoWin : 20.8

set_show_orientation(bool orient)

window : 20.2

set_show_orientation(geo_scene sc, bool o)

GeoWin : 20.8

set_show_position(bool sp)

GeoWin : 20.8

set_show_scenes_menu(bool v)

GeoWin : 20.8

set_show_status(bool b)

GeoWin : 20.8

GraphWin : 20.6

set_show_window_menu(bool v)

GeoWin : 20.8

set_size(streamsize n)

memory_streambuf : 12.26

set_solid(bool b)

d3_window : 20.9

set_src_file(const char* file_name)

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

AutoDecoder : 12.24

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

CryptAutoDecoder : 13.6

DeflateCoder : 12.4

DictCoder : 12.5

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

set_src_stream(streambuf* src_stream, bool own_stream = false)

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

AutoDecoder : 12.24

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

CryptAutoDecoder : 13.6

DeflateCoder : 12.4

DictCoder : 12.5

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

set_start_edge_slider_handler(void (*f)(GraphWin& , edge, double)=NULL, int sl=0)

GraphWin : 20.6

set_start_move_node_handler(bool (*f)(GraphWin& , node)=NULL)

GraphWin : 20.6

set_state(int stat)

window : 20.2

set_strategy(int strategy)

DeflateCoder : 12.4

set_text(panel_item it, string s)

window : 20.2

set_text_color(geo_scene sc, color c)

GeoWin : 20.8

set_text_color(geo_scenegroup gs, color c)

GeoWin : 20.8

set_text_mode(text_mode m)

window : 20.2

set_tgt_file(const char* file_name)

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

AutoDecoder : 12.24

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

CryptAutoDecoder : 13.6

DeflateCoder : 12.4

DictCoder : 12.5

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

set_tgt_stream(streambuf* tgt_stream, bool own_Stream = false)

A0Coder : 12.1

A0sCoder : 12.2

AdaptiveHuffmanCoder : 12.7

AutoDecoder : 12.24

BlockCoder<Coder> : 12.25

BWTCoder : 12.9

CBCCoder< BlkCipher > : 13.4

checksummer_base : 12.13

CoderPipe2<Coder1,...> : 12.23

CryptAutoDecoder : 13.6

DeflateCoder : 12.4

DictCoder : 12.5

HuffmanCoder : 12.6

MTF2Coder : 12.11

MTFCoder : 12.10

OMACCoder< BlkCipher > : 13.5

PPMIICoder : 12.3

RLE0Coder : 12.12

RLECoder : 12.8

set_timeout(int sec)

leda_socket : 6.13

set_to_current_date()

date : 6.21

set_tooltip(int i, double x0, double y0, double x1, double y1, string txt)

window : 20.2

set_user_layer_color(const color& c)

GeoWin : 20.8

set_user_layer_line_width(int lw)

GeoWin : 20.8

set_value(const unsigned long val)

counter : 6.17

set_visible(geo_scene sc, bool v)

GeoWin : 20.8

set_visible(geo_scenegroup gs, bool v)

GeoWin : 20.8

set_weight(edge e, int g)

dynamic_markov_chain : 14.25

set_weight(int i, int g)

dynamic_random_variate : 6.8

set_window(int but, window* M)

window : 20.2

set_window(window& W)

GraphWin : 20.6

set_window_delete_handler(void (*F)(window*))

window : 20.2

set_window_delete_object(const window_handler& obj)

window : 20.2

set_window_size(int log2_of_sz)

DeflateCoder : 12.4

set_x_rotation(bool b)

d3_window : 20.9

set_y_rotation(bool b)

d3_window : 20.9

set_year(int y)

date : 6.21

set_z_order(geo_scene sc, int n)

GeoWin : 20.8

set_zoom_factor(double f)

GraphWin : 20.6

set_zoom_labels(bool b)

GraphWin : 20.6

set_zoom_objects(bool b)

GraphWin : 20.6

setAlgorithm(alg A)

distance : 7.4

string_matching : 7.2

setAlgorithm(int A)

distance : 7.4

string_matching : 7.2

setDNA()

alphabet : 7.1

setFinished()

alphabet : 7.1

setFirstString(const string& str)

distance : 7.4

setGapIncPenalty(int incpen)

score_matrix : 7.3

setGapIncPenalty(int x)

alignment : 7.5

setGapPenalty(int pen)

score_matrix : 7.3

setGapPenalty(int pen, int incpen)

score_matrix : 7.3

setGapPenalty(int x)

alignment : 7.5

setPattern(const string& str)

string_matching : 7.2

setScore(char a, char b, int sc)

score_matrix : 7.3

setScoreMatch(int sc)

score_matrix : 7.3

setScoreMismatch(int sc)

score_matrix : 7.3

setSecondString(const string& str)

distance : 7.4

setStandard()

alphabet : 7.1

setString(const string& str)

string_matching : 7.2

setStringA(const string& x)

alignment : 7.5

setStringB(const string& x)

alignment : 7.5

setStrings(const string& str1, const string& str2)

string_matching : 7.2

SHACoder : 12.18

shift_key_down()

window : 20.2

shift_or()

string_matching : 7.2

shortest_path : 15.2

side_of(const d3_point& q)

d3_plane : 19.5

side_of(const d3_rat_point& q)

d3_rat_plane : 19.12

side_of(const point& p)

circle : 17.5

GEN_POLYGON : 17.7

line : 17.4

POLYGON : 17.6

triangle : 17.8

side_of(const r_circle_point& p)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

side_of(const rat_point& p)

rat_circle : 17.14

rat_line : 17.13

rat_triangle : 17.15

side_of(const real_point& p)

real_circle : 17.21

real_line : 17.20

real_triangle : 17.22

side_of_circle(const point& a, const point& b, const point& c, const point& d) : 17.1

side_of_circle(const rat_point& a, const rat_point& b, const rat_point& c, const rat_point& d) : 17.10

side_of_circle(const real_point& a, const real_point& b, const real_point& c, const real_point& d) : 17.17

side_of_halfspace(const point& a, const point& b, const point& c) : 17.1

side_of_halfspace(const rat_point& a, const rat_point& b, const rat_point& c) : 17.10

side_of_halfspace(const real_point& a, const real_point& b, const real_point& c) : 17.17

side_of_sphere(const d3_point& a, const d3_point& b, const d3_point& c, const d3_point& d, const d3_point& x) : 19.1

side_of_sphere(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c, const d3_rat_point& d, const d3_rat_point& e) : 19.8

sign()

integer : 8.1

interval : 8.5

real : 8.4

residual : 8.8

sign(const bigfloat& x) : 8.3

Sign(const floatf& f) : 8.9

sign(const integer& a) : 8.1

sign(const integer& q)

real : 8.4

sign(const rational& q) : 8.2

sign_is_known()

interval : 8.5

sign_of_determinant(const integer_matrix& M) : 8.13

simple_parts()

POLYGON : 17.6

simplify()

TRANSFORM : 17.25

simplify(const integer& a)

rational : 8.2

size()

array<E> : 9.1

b_priority_queue<I> : 11.2

b_queue<E> : 9.6

b_stack<E> : 9.5

d2_dictionary<K1,K2,I> : 18.1

d_array<I,E> : 10.2

d_int_set : 9.11

dictionary<K,I> : 10.1

edge_set : 14.17

GEN_POLYGON : 17.7

h_array<I,E> : 10.3

interval_set<I> : 18.4

list<E> : 9.7

node_pq<P> : 14.20

node_set : 14.16

p_queue<P,I> : 11.1

POLYGON : 17.6

queue<E> : 9.4

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

rat_segment_set<I> : 18.6

segment_set<I> : 18.5

set<E> : 9.9

slist<E> : 9.8

sortseq<K,I> : 10.6

stack<E> : 9.3

size(face f)

graph : 14.1

size(node v)

node_partition : 14.19

size(partition_item p)

partition : 9.12

Partition<E> : 9.13

size_of_file(string fname) : 6.12

size_type

string : 6.1

sleep(double sec) : 6.15

slist<E> : 9.8

slope()

line : 17.4

rat_line : 17.13

rat_segment : 17.11

ray : 17.3

real_line : 17.20

real_ray : 17.19

real_segment : 17.18

segment : 17.2

small_rational_between(const rational& p, const rational& q) : 8.2

small_rational_between(const real& x, const real& y) : 8.4

small_rational_near(const rational& p, rational eps) : 8.2

small_rational_near(const real& x, double eps) : 8.4

SMALLEST_ENCLOSING_CIRCLE(const list<point>& L) : 17.24

smith()

string_matching : 7.2

socket_streambuf : 6.14

solve(const real_vector& b)

real_matrix : 8.16

solve(const vector& b)

matrix : 8.11

sort()

array<E> : 9.1

list<E> : 9.7

sort(int (*cmp)(const E& , const E& ))

array<E> : 9.1

list<E> : 9.7

sort(int (*cmp)(const E& , const E& ), int low, int high)

array<E> : 9.1

sort(int low, int high)

array<E> : 9.1

sort_edges()

GRAPH<vtype,e...> : 14.2

sort_edges(const edge_array<T>& A)

graph : 14.1

sort_edges(const list<edge>& el)

GRAPH<vtype,e...> : 14.2

SORT_EDGES(graph& G, const edge_array<int>& dx, const edge_array<int>& dy) : 15.13

SORT_EDGES(graph& G, const node_array<int>& x, const node_array<int>& y) : 15.13

sort_edges(int (*cmp)(const edge& , const edge& ))

graph : 14.1

sort_nodes()

GRAPH<vtype,e...> : 14.2

sort_nodes(const list<node>& vl)

GRAPH<vtype,e...> : 14.2

sort_nodes(const node_array<T>& A)

graph : 14.1

sort_nodes(int (*cmp)(const node& , const node& ))

graph : 14.1

sortseq<K,I> : 10.6

source()

d3_rat_ray : 19.9

d3_rat_segment : 19.11

d3_ray : 19.2

d3_segment : 19.3

r_circle_segment : 17.28

rat_ray : 17.12

ray : 17.3

real_ray : 17.19

source(edge e) : 14.1

graph : 14.1

static_graph : 14.3.7

SP_EMBEDDING(graph& G, node_array<double>& x_coord, node_array<double>& y_coord, node_array<double>& x_radius, node_array<double>& y_radius, edge_array<list<double> >& x_bends, edge_array<list<double> >& y_bends, edge_array<double>& x_sanch, edge_array<double>& y_sanch, edge_array<double>& x_tanch, edge_array<double>& y_tanch) : 15.14

SPANNING_TREE(const graph& G) : 15.11

SPANNING_TREE1(graph& G) : 15.11

split(const list<node>& L)

node_partition : 14.19

split(const list<partition_item>& L)

partition : 9.12

Partition<E> : 9.13

split(list_item it, list<E>& L1, list<E>& L2)

list<E> : 9.7

split(list_item it, list<E>& L1, list<E>& L2, int dir)

list<E> : 9.7

split(seq_item it, sortseq<K,I,seq_impl>& S1, sortseq<K,I,seq_impl>& S2, int dir=leda::behind)

sortseq<K,I> : 10.6

split_edge(edge e)

planar_map : 14.6

split_edge(edge e, const vtype& x)

PLANAR_MAP<vtype,e...> : 14.7

split_edge(edge e, edge& e1, edge& e2)

graph : 14.1

split_face(edge e1, edge e2)

graph : 14.1

split_into_weakly_simple_parts()

r_circle_polygon : 17.29

split_into_weakly_simple_parts(bool strict = false)

POLYGON : 17.6

split_map_edge(edge e)

graph : 14.1

SPRING_EMBEDDING(const graph& G, const list<node>& fixed, node_array<double>& xpos, node_array<double>& ypos, double xleft, double xright, double ybottom, double ytop, int iterations=250) : 15.14

SPRING_EMBEDDING(const graph& G, node_array<double>& xpos, node_array<double>& ypos, double xleft, double xright, double ybottom, double ytop, int iterations=250) : 15.14

sputEOF()

secure_socket_streambuf : 13.7

socket_streambuf : 6.14

sqr(const integer& a) : 8.1

sqr(const rational& q) : 8.2

sqr(const real& x) : 8.4

sqr(const residual& a) : 8.8

sqr_dist()

rat_segment : 17.11

sqr_dist(const d3_point& p)

d3_line : 19.4

sqr_dist(const d3_point& q)

d3_plane : 19.5

d3_point : 19.1

sqr_dist(const d3_rat_point& p)

d3_rat_line : 19.10

sqr_dist(const d3_rat_point& q)

d3_rat_plane : 19.12

d3_rat_point : 19.8

sqr_dist(const point& p)

circle : 17.5

GEN_POLYGON : 17.7

POLYGON : 17.6

segment : 17.2

sqr_dist(const point& q)

line : 17.4

point : 17.1

sqr_dist(const rat_point& p)

rat_segment : 17.11

sqr_dist(const rat_point& q)

rat_line : 17.13

rat_point : 17.10

sqr_dist(const real_point& p)

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

r_circle_segment : 17.28

real_circle : 17.21

real_segment : 17.18

sqr_dist(const real_point& q)

real_line : 17.20

real_point : 17.17

sqr_length()

d3_rat_segment : 19.11

d3_segment : 19.3

rat_segment : 17.11

rat_vector : 8.14

real_segment : 17.18

real_vector : 8.15

segment : 17.2

vector : 8.10

sqr_radius()

circle : 17.5

d3_rat_sphere : 19.13

d3_sphere : 19.6

rat_circle : 17.14

real_circle : 17.21

sqrt(const integer& a) : 8.1

sqrt(const real& x) : 8.4

sqrt_d(const bigfloat& x, sz_t p, int d) : 8.3

ST_NUMBERING(const graph& G, node_array<int>& stnum, list<node>& stlist, edge e_st = nil) : 15.13

stable_matching : 15.10

StableMatching(const graph& G, const list<node>& A, const list<node>& B, list<edge>& M) : 15.10

stack<E> : 9.3

start()

rat_segment : 17.11

real_segment : 17.18

segment : 17.2

timer : 6.16

start_buffering()

window : 20.2

start_construction(int n, int m)

static_graph : 14.3.7

start_timer(int msec, const window_handler& obj)

window : 20.2

start_timer(int msec, void (*F)(window*))

window : 20.2

starts_with(const string& s1)

string : 6.1

state()

GIT_SCC<Out,In,...> : 16.20

static_graph : 14.3

step(int T = 1)

dynamic_markov_chain : 14.25

markov_chain : 14.24

STL : see iteration

STLNodeIt<DataAcc...> : 16.12

stop()

timer : 6.16

stop_buffering()

window : 20.2

stop_buffering(char*& prect)

window : 20.2

stop_timer()

window : 20.2

str()

string_ostream : 6.5

STRAIGHT_LINE_EMBED_MAP(graph& G, node_array<int>& xcoord, node_array<int>& ycoord) : 15.14

STRAIGHT_LINE_EMBEDDING(graph& G, node_array<int>& xc, node_array<int>& yc) : 15.14

string : 6.1

string_istream : 6.4

string_item(string s, string& x, const char* hlp=0)

window : 20.2

string_item(string s, string& x, const list<string>& L, const char* hlp=0)

window : 20.2

string_item(string s, string& x, const list<string>& L, const window_handler& obj, const char* hlp=0)

window : 20.2

string_item(string s, string& x, const list<string>& L, int sz, const char* hlp=0)

window : 20.2

string_item(string s, string& x, const list<string>& L, int sz, const window_handler& obj, const char* hlp=0)

window : 20.2

string_item(string s, string& x, const list<string>& L, int sz, void (*F)(char*), const char* hlp=0)

window : 20.2

string_item(string s, string& x, const window_handler& obj, const char* hlp=0)

window : 20.2

string_item(string s, string& x, void (*F)(char*), const char* hlp=0)

window : 20.2

string_matching : 7.2

string_ostream : 6.5

STRONG_COMPONENTS(const graph& G, node_array<int>& compnum) : 15.1

sub(const residual& a, const residual& b)

residual : 8.8

sub(double a, double b, double p)

residual : 8.7

subdivision<I> : 18.7

substring(int i)

string : 6.1

substring(int i, int j)

string : 6.1

succ(const K& k)

sortseq<K,I> : 10.6

succ(item it)

slist<E> : 9.8

succ(list_item it)

list<E> : 9.7

succ(node v)

node_list : 14.18

succ(seq_item it)

sortseq<K,I> : 10.6

succ_edge(edge e)

graph : 14.1

succ_face(face f)

graph : 14.1

succ_face_edge(edge e)

graph : 14.1

succ_node(node v)

graph : 14.1

supporting_circle()

r_circle_point : 17.27

supporting_line()

r_circle_point : 17.27

r_circle_segment : 17.28

supporting_line(edge e)

POINT_SET : 18.2

surface()

d3_sphere : 19.6

swap(int i, int j)

array<E> : 9.1

swap(list<E>& L1)

list<E> : 9.7

SWEEP_SEGMENTS(const list<r_circle_segment>& L, GRAPH<r_circle_point,r_circle_segment>& G, bool embed = true) : 17.28

SWEEP_SEGMENTS(const list<segment>& S, GRAPH<point,segment>& G, bool embed=false, bool use_optimization = true) : 17.24

sym_diff(const GEN_POLYGON& Q)

GEN_POLYGON : 17.7

sym_diff(const r_circle_gen_polygon& Q)

r_circle_gen_polygon : 17.30

sym_diff_approximate(const r_circle_gen_polygon& Q, double dist = 1e-2)

r_circle_gen_polygon : 17.30

symdiff(const d_int_set& T)

d_int_set : 9.11

symdiff(const int_set& T)

int_set : 9.10

symdiff(const set<E,set_impl>& T)

set<E> : 9.9

T_matrix()

TRANSFORM : 17.25

tail()

list<E> : 9.7

node_list : 14.18

slist<E> : 9.8

tail(int i)

string : 6.1

tangent_at(const r_circle_point& p)

r_circle_segment : 17.28

target()

d3_rat_segment : 19.11

d3_segment : 19.3

r_circle_segment : 17.28

target(edge e) : 14.1

graph : 14.1

static_graph : 14.3.7 | 14.3.7

tellg()

decoding_ifstream<Coder> : 12.22

tellp()

encoding_ofstream<Coder> : 12.21

test_bigraph(graph& G, list<node>& A, list<node>& B) : 14.22

test_graph(graph& G) : 14.22

text_box(double x0, double x1, double y, string s, bool draw=true)

window : 20.2

text_box(string s)

window : 20.2

text_item(string s)

window : 20.2

third()

four_tuple<A,B,C,D> : 6.20

three_tuple<A,B,C> : 6.19

third_type

four_tuple<A,B,C,D> : 6.20

three_tuple<A,B,C> : 6.19

three_tuple<A,B,C> : 6.19

time_of_file(string fname) : 6.12

timer : 6.16

tmp_dir_name() : 6.12

tmp_file_name() : 6.12

to_bigfloat()

real : 8.4

to_d3_simplex()

d3_rat_simplex : 19.14

to_double()

bigfloat : 8.3

integer : 8.1

interval : 8.5

real : 8.4

residual : 8.8

to_double(bool& is_double)

bigfloat : 8.3

integer : 8.1

to_double(const integer& a) : 8.1

to_double(double& abs_err, rounding_modes m = TO_NEAREST)

bigfloat : 8.3

to_double(double& error)

real : 8.4

to_double(rounding_modes m)

bigfloat : 8.3

to_float() : 8.2

d3_rat_line : 19.10

d3_rat_plane : 19.12

d3_rat_point : 19.8

d3_rat_segment : 19.11

d3_rat_sphere : 19.13

GEN_POLYGON : 17.7

integer : 8.1

POLYGON : 17.6

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

rat_circle : 17.14

rat_line : 17.13

rat_point : 17.10

rat_ray : 17.12

rat_rectangle : 17.16

rat_segment : 17.11

rat_vector : 8.14

real_vector : 8.15

residual : 8.8

to_hex_string()

CryptByteString : 13.1

to_integer()

residual : 8.8

to_integer(const bigfloat& x, rounding_modes rmode, bool& is_exact) : 8.3

to_integer(rounding_modes rmode = TO_NEAREST, bool& is_exact=bigfloat::dbool) : 8.3

to_line()

circle : 17.5

rat_circle : 17.14

real_circle : 17.21

to_long()

integer : 8.1

residual : 8.8

to_r_circle_polygon()

r_circle_gen_polygon : 17.30

to_rat_circle()

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

to_rat_gen_polygon()

r_circle_gen_polygon : 17.30

to_rat_point()

r_circle_point : 17.27

to_rat_polygon()

r_circle_polygon : 17.29

to_rat_segment()

r_circle_segment : 17.28

to_rational()

bigfloat : 8.3

real : 8.4

to_rational(int prec = -1)

GEN_POLYGON : 17.7

POLYGON : 17.6

to_string()

CryptByteString : 13.1

integer : 8.1

rational : 8.2

residual : 8.8

to_string(sz_t dec_prec=global_output_prec)

bigfloat : 8.3

to_vector()

d3_line : 19.4

d3_point : 19.1

d3_rat_line : 19.10

d3_rat_point : 19.8

d3_rat_ray : 19.9

d3_rat_segment : 19.11

d3_ray : 19.2

d3_segment : 19.3

point : 17.1

rat_point : 17.10

rat_segment : 17.11

real_segment : 17.18

segment : 17.2

top()

b_queue<E> : 9.6

b_stack<E> : 9.5

queue<E> : 9.4

stack<E> : 9.3

TOPSORT(const graph& G, list<node>& L) : 15.1

TOPSORT(const graph& G, node_array<int>& ord) : 15.1

TOPSORT1(graph& G) : 15.1

trans()

matrix : 8.11

real_matrix : 8.16

TRANSFORM : 17.25

transform_layout(node_array<double>& xpos, node_array<double>& ypos, edge_array<list<double> >& xbends, edge_array<list<double> >& ybends, double dx, double dy, double fx, double fy)

GraphWin : 20.6

transform_layout(node_array<double>& xpos, node_array<double>& ypos, node_array<double>& xrad, node_array<double>& yrad, edge_array<list<double> >& xbends, edge_array<list<double> >& ybends, double dx, double dy, double fx, double fy)

GraphWin : 20.6

TRANSITIVE_CLOSURE(const graph& G) : 15.1

TRANSITIVE_REDUCTION(const graph& G) : 15.1

translate(const integer& dx, const integer& dy, const integer& dw)

rat_segment : 17.11

translate(const rat_vector& v)

d3_rat_plane : 19.12

d3_rat_point : 19.8

d3_rat_ray : 19.9

d3_rat_segment : 19.11

d3_rat_simplex : 19.14

d3_rat_sphere : 19.13

r_circle_gen_polygon : 17.30

r_circle_point : 17.27

r_circle_polygon : 17.29

r_circle_segment : 17.28

rat_circle : 17.14

rat_line : 17.13

rat_point : 17.10

rat_ray : 17.12

rat_rectangle : 17.16

rat_segment : 17.11

rat_triangle : 17.15

translate(const rational& dx, const rational& dy)

rat_circle : 17.14

rat_line : 17.13

rat_point : 17.10

rat_ray : 17.12

rat_segment : 17.11

translate(const rational& dx, const rational& dy, const rational& dz)

d3_rat_plane : 19.12

d3_rat_point : 19.8

translate(const rational& r1, const rational& r2, const rational& r3)

d3_rat_sphere : 19.13

translate(const real_vector& v)

real_circle : 17.21

real_line : 17.20

real_point : 17.17

real_ray : 17.19

real_rectangle : 17.23

real_segment : 17.18

real_triangle : 17.22

translate(const vector& v)

circle : 17.5

d3_line : 19.4

d3_plane : 19.5

d3_point : 19.1

d3_ray : 19.2

d3_segment : 19.3

d3_simplex : 19.7

d3_sphere : 19.6

GEN_POLYGON : 17.7

line : 17.4

point : 17.1

POLYGON : 17.6

ray : 17.3

rectangle : 17.9

segment : 17.2

triangle : 17.8

translate(double dx, double dy)

circle : 17.5

line : 17.4

point : 17.1

ray : 17.3

real_point : 17.17

rectangle : 17.9

segment : 17.2

triangle : 17.8

translate(double dx, double dy, double dz)

d3_line : 19.4

d3_plane : 19.5

d3_point : 19.1

d3_ray : 19.2

d3_segment : 19.3

d3_simplex : 19.7

d3_sphere : 19.6

translate(INT_TYPE dx, INT_TYPE dy, INT_TYPE dw)

GEN_POLYGON : 17.7

POLYGON : 17.6

translate(integer dx, integer dy, integer dw)

rat_circle : 17.14

rat_line : 17.13

rat_point : 17.10

rat_ray : 17.12

translate(integer dx, integer dy, integer dz, integer dw)

d3_rat_line : 19.10

d3_rat_plane : 19.12

d3_rat_point : 19.8

d3_rat_segment : 19.11

d3_rat_simplex : 19.14

translate(RAT_TYPE dx, RAT_TYPE dy)

GEN_POLYGON : 17.7

POLYGON : 17.6

translate(rat_vector v)

d3_rat_line : 19.10

translate(rational dx, rational dy)

r_circle_gen_polygon : 17.30

r_circle_point : 17.27

r_circle_polygon : 17.29

r_circle_segment : 17.28

rat_rectangle : 17.16

rat_triangle : 17.15

translate(rational dx, rational dy, rational dz)

d3_rat_ray : 19.9

d3_rat_segment : 19.11

d3_rat_simplex : 19.14

translate(real dx, real dy)

real_circle : 17.21

real_line : 17.20

real_point : 17.17

real_ray : 17.19

real_rectangle : 17.23

real_segment : 17.18

real_triangle : 17.22

translate_by_angle(double a, double d)

circle : 17.5

line : 17.4

ray : 17.3

translate_by_angle(double alpha, double d)

GEN_POLYGON : 17.7

point : 17.1

POLYGON : 17.6

segment : 17.2

translation(const INT_TYPE& dx, const INT_TYPE& dy, const INT_TYPE& dw) : 17.25

translation(const RAT_TYPE& dx, const RAT_TYPE& dy) : 17.25

translation(const VECTOR& v) : 17.25

transpose(const integer_matrix& M) : 8.13

triangle : 17.8

TRIANGLE_COMPONENTS(const gen_polygon& GP) : 17.24

triangulate()

planar_map : 14.6

triangulate_map()

graph : 14.1

triangulate_planar_map()

graph : 14.1

TRIANGULATE_PLANAR_MAP(graph& G) : 15.13

TRIANGULATE_PLANE_MAP(GRAPH<point,segment>& G) : 17.24

TRIANGULATE_POINTS(const list<point>& L, GRAPH<point,int>& T) : 17.24

TRIANGULATE_POLYGON(const gen_polygon& GP, GRAPH<point,segment>& G, list<edge>& inner_edges, list<edge>& outer_edges, list<edge>& boundary_edges, list<edge>& hole_edges) : 17.24

TRIANGULATE_POLYGON(const polygon& P, GRAPH<point,segment>& G, list<edge>& inner_edges, list<edge>& outer_edges, list<edge>& boundary_edges) : 17.24

TRIANGULATE_SEGMENTS(const list<segment>& L, GRAPH<point,segment>& G) : 17.24

triangulated_planar_graph(graph& G, int n) : 14.22

triangulated_planar_graph(graph& G, list<node>& outer_face, node_array<double>& xcoord, node_array<double>& ycoord, int n) : 14.22

triangulated_planar_graph(graph& G, node_array<double>& xcoord, node_array<double>& ycoord, int n) : 14.22

triangulation_graph(graph& G, int n) : 14.22

triangulation_graph(graph& G, list<node>& outer_face, node_array<double>& xcoord, node_array<double>& ycoord, int n) : 14.22

triangulation_graph(graph& G, node_array<double>& xcoord, node_array<double>& ycoord, int n) : 14.22

triangulation_map(graph& G, int n) : 14.22

triangulation_map(graph& G, list<node>& outer_face, node_array<double>& xcoord, node_array<double>& ycoord, int n) : 14.22

triangulation_map(graph& G, node_array<double>& xcoord, node_array<double>& ycoord, int n) : 14.22

trivial()

GEN_POLYGON : 17.7

trunc(const rational& q) : 8.2

truncate(double x, int k = 10) : 6.15

truncate(streamsize n)

memory_streambuf : 12.26

tuned_boyer_moore()

string_matching : 7.2

turbo_boyer_moore()

string_matching : 7.2

turbo_reverse_factor()

string_matching : 7.2

TUTTE_EMBEDDING(const graph& G, const list<node>& fixed_nodes, node_array<double>& xpos, node_array<double>& ypos) : 15.14

two_tuple<A,B> : 6.18

ugraph : 14.4

UGRAPH<vtype,e...> : 14.5

undefine(const I& i)

d_array<I,E> : 10.2

h_array<I,E> : 10.3

undefine(const K& k)

dictionary<K,I> : 10.1

undo_clear()

GraphWin : 20.6

union_blocks(node v, node w)

node_partition : 14.19

union_blocks(partition_item p, partition_item q)

partition : 9.12

Partition<E> : 9.13

unique()

array<E> : 9.1

list<E> : 9.7

unique(int (*cmp)(const E& , const E& ))

list<E> : 9.7

unit(int i, int d=2)

rat_vector : 8.14

unite(const GEN_POLYGON& Q)

GEN_POLYGON : 17.7

unite(const list<r_circle_gen_polygon>& L)

r_circle_gen_polygon : 17.30

unite(const r_circle_gen_polygon& Q)

r_circle_gen_polygon : 17.30

unite_approximate(const list<r_circle_gen_polygon>& L, double dist = 1e-2)

r_circle_gen_polygon : 17.30

unite_approximate(const r_circle_gen_polygon& Q, double dist = 1e-2)

r_circle_gen_polygon : 17.30

unsaved_changes()

GraphWin : 20.6

unzoom()

GraphWin : 20.6

update(leda::edge e)

AdjIt : 16.7

EdgeIt : 16.3

FaceCirc : 16.8

InAdjIt : 16.6

OutAdjIt : 16.5

update(leda::face n)

FaceIt : 16.4

update(leda::node n)

AdjIt : 16.7

InAdjIt : 16.6

NodeIt : 16.2

OutAdjIt : 16.5

update(leda::node n, leda::edge e)

AdjIt : 16.7

InAdjIt : 16.6

OutAdjIt : 16.5

update_graph()

GraphWin : 20.6

upper_bound()

b_priority_queue<I> : 11.2

interval : 8.5

UPPER_CONVEX_HULL(const list<point>& L) : 17.24

upper_left()

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

upper_right()

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

use_edge_data(const graph_t& G, E x)

edge_array<E> : 14.9

edge_map<E> : 14.12

use_face_data(const graph_t& G, E x)

face_array<E> : 14.10

use_node_data(const graph_t& G)

node_array<E> : 14.8

use_node_data(const graph_t& G, E x)

node_array<E> : 14.8

node_map<E> : 14.11

used_time() : 6.15

used_time(float& T) : 6.15

used_words()

integer : 8.1

User defined parameter types

compare(...) : 4.3

copy constructor : 4.3

default constructor : 4.3

Hash(...) : 4.3

operator>> : 4.3

operator<< : 4.3

uses_compression()

secure_socket_streambuf : 13.7

valid()

AdjIt : 16.7

EdgeIt : 16.3

FaceCirc : 16.8

FaceIt : 16.4

InAdjIt : 16.6

NodeIt : 16.2

OutAdjIt : 16.5

value_type

array<E> : 9.1

list<E> : 9.7

queue<E> : 9.4

slist<E> : 9.8

vector : 8.10

verify_determinant(const integer_matrix& M, integer D, integer_matrix& L, integer_matrix& U, array<int> q, integer_vector& c) : 8.13

version()

GeoWin : 20.8

vertices()

GEN_POLYGON : 17.7

POLYGON : 17.6

r_circle_gen_polygon : 17.30

r_circle_polygon : 17.29

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

VISIBILITY_REPRESENTATION(graph& G, node_array<double>& x_pos, node_array<double>& y_pos, node_array<double>& x_rad, node_array<double>& y_rad, edge_array<double>& x_sanch, edge_array<double>& y_sanch, edge_array<double>& x_tanch, edge_array<double>& y_tanch) : 15.14

vol()

d3_rat_simplex : 19.14

d3_simplex : 19.7

volume()

d3_sphere : 19.6

volume(const d3_point& a, const d3_point& b, const d3_point& c, const d3_point& d) : 19.1

volume(const d3_rat_point& a, const d3_rat_point& b, const d3_rat_point& c, const d3_rat_point& d) : 19.8

VORONOI(const list<point>& L, GRAPH<circle,point>& VD) : 17.24

W()

d3_rat_point : 19.8

rat_point : 17.10

rat_vector : 8.14

W1()

rat_segment : 17.11

W2()

rat_segment : 17.11

wait()

GraphWin : 20.6

wait(const char* msg)

GraphWin : 20.6

wait(double sec) : 6.15

wait(float sec, const char* msg=")

GraphWin : 20.6

wait(string s)

leda_socket : 6.13

waits_for_acknowledge()

secure_socket_streambuf : 13.7

socket_streambuf : 6.14

WD()

d3_rat_point : 19.8

rat_point : 17.10

WD1()

rat_segment : 17.11

WD2()

rat_segment : 17.11

wedge_contains(const real_point& p)

r_circle_segment : 17.28

which_intersection()

r_circle_point : 17.27

width()

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

window : 20.2

WIDTH(const list<point>& L, line& l1, line& l2) : 17.24

will_report_on_desctruction()

counter : 6.17

timer : 6.16

win_init(double xmin, double xmax, double ymin)

GraphWin : 20.6

window : 20.2

wipe_buffer()

memory_streambuf : 12.26

wipe_memory(void* mem, uint32 sz)

CryptByteString : 13.1

wkb_io : 17.31

write(const string& filename, const gen_polygon& P)

wkb_io : 17.31

write(geo_scene sc, ostream& os)

GeoWin : 20.8

write(ostream& O = cout)

graph : 14.1

write(string fname)

GRAPH<vtype,e...> : 14.2

write(string s)

graph : 14.1

write_active_scene(ostream& os)

GeoWin : 20.8

write_gml(ostream& O = cout, void (*node_cb)(ostream& , const graph*, const node)=0, void (*edge_cb)(ostream& , const graph*, const edge)=0)

graph : 14.1

write_gml(string s, void (*node_cb)(ostream& , const graph*, const node)=0, void (*edge_cb)(ostream& , const graph*, const edge)=0)

graph : 14.1

X()

d3_rat_point : 19.8

rat_point : 17.10

rat_vector : 8.14

X1()

rat_segment : 17.11

X2()

rat_segment : 17.11

x_proj(double y)

line : 17.4

segment : 17.2

x_proj(rational y)

rat_line : 17.13

rat_segment : 17.11

x_proj(real y)

real_line : 17.20

real_segment : 17.18

xcoord()

d3_point : 19.1

d3_rat_point : 19.8

point : 17.1

rat_point : 17.10

rat_vector : 8.14

real_point : 17.17

real_vector : 8.15

vector : 8.10

xcoord1()

d3_rat_segment : 19.11

d3_segment : 19.3

rat_segment : 17.11

real_segment : 17.18

segment : 17.2

xcoord1D()

rat_segment : 17.11

xcoord2()

d3_rat_segment : 19.11

d3_segment : 19.3

rat_segment : 17.11

real_segment : 17.18

segment : 17.2

xcoord2D()

rat_segment : 17.11

xcoordD()

d3_rat_point : 19.8

rat_point : 17.10

XD()

d3_rat_point : 19.8

rat_point : 17.10

XD1()

rat_segment : 17.11

XD2()

rat_segment : 17.11

xdist(const d3_point& q)

d3_point : 19.1

xdist(const d3_rat_point& q)

d3_rat_point : 19.8

xdist(const point& q)

point : 17.1

xdist(const rat_point& q)

rat_point : 17.10

xdist(const real_point& q)

real_point : 17.17

xmax()

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

window : 20.2

xmin()

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

window : 20.2

xpos()

window : 20.2

Y()

d3_rat_point : 19.8

rat_point : 17.10

rat_vector : 8.14

Y1()

rat_segment : 17.11

Y2()

rat_segment : 17.11

y_abs()

line : 17.4

rat_line : 17.13

rat_segment : 17.11

real_line : 17.20

real_segment : 17.18

segment : 17.2

y_proj(double x)

line : 17.4

segment : 17.2

y_proj(rational x)

rat_line : 17.13

rat_segment : 17.11

y_proj(real x)

real_line : 17.20

real_segment : 17.18

ycoord()

d3_point : 19.1

d3_rat_point : 19.8

point : 17.1

rat_point : 17.10

rat_vector : 8.14

real_point : 17.17

real_vector : 8.15

vector : 8.10

ycoord1()

d3_rat_segment : 19.11

d3_segment : 19.3

rat_segment : 17.11

real_segment : 17.18

segment : 17.2

ycoord1D()

rat_segment : 17.11

ycoord2()

d3_rat_segment : 19.11

d3_segment : 19.3

rat_segment : 17.11

real_segment : 17.18

segment : 17.2

ycoord2D()

rat_segment : 17.11

ycoordD()

d3_rat_point : 19.8

rat_point : 17.10

YD()

d3_rat_point : 19.8

rat_point : 17.10

YD1()

rat_segment : 17.11

YD2()

rat_segment : 17.11

ydist(const d3_point& q)

d3_point : 19.1

ydist(const d3_rat_point& q)

d3_rat_point : 19.8

ydist(const point& q)

point : 17.1

ydist(const rat_point& q)

rat_point : 17.10

ydist(const real_point& q)

real_point : 17.17

years_until(const date& D2)

date : 6.21

Yes(string s) : 6.15

ymax()

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

window : 20.2

ymin()

rat_rectangle : 17.16

real_rectangle : 17.23

rectangle : 17.9

window : 20.2

ypos()

window : 20.2

Z()

d3_rat_point : 19.8

rat_vector : 8.14

zcoord()

d3_point : 19.1

d3_rat_point : 19.8

rat_vector : 8.14

real_vector : 8.15

vector : 8.10

zcoord1()

d3_rat_segment : 19.11

d3_segment : 19.3

zcoord2()

d3_rat_segment : 19.11

d3_segment : 19.3

zcoordD()

d3_rat_point : 19.8

ZD()

d3_rat_point : 19.8

zdist(const d3_point& q)

d3_point : 19.1

zdist(const d3_rat_point& q)

d3_rat_point : 19.8

zero(int d=2)

rat_vector : 8.14

zero_of_function(double (*f)(double), double l, double r, double tol = 1.0e-10) : 8.17.4

zhu_takaoka()

string_matching : 7.2

zoom(double f)

GraphWin : 20.6

zoom_area(double x0, double y0, double x1, double y1)

GraphWin : 20.6

zoom_down()

GeoWin : 20.8

zoom_graph()

GraphWin : 20.6

zoom_up()

GeoWin : 20.8