home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / changes next >
Encoding:
Text File  |  1992-05-08  |  26.7 KB  |  849 lines

  1. +==============================================================================+
  2. |                                           |
  3. |                           VERSION 2.1.1                        |
  4. |                                                                              |
  5. +==============================================================================+
  6.  
  7.  
  8.  
  9. --------------------------------------------------------------------------------
  10. vector/matrix
  11. --------------------------------------------------------------------------------
  12.  
  13. 1. Assignment (=) and  comparison (==/!=) operators now can be applied to
  14.    vectors/matrices with different dimensions.
  15.  
  16. 2. The default initialization for arrays of vectors/matrices is the
  17.    vector/matrix of dimension 0.
  18.  
  19. 3. Problems with vector/matrix typ parameters fixed.
  20.  
  21.  
  22.  
  23. --------------------------------------------------------------------------------
  24. graphics
  25. --------------------------------------------------------------------------------
  26.  
  27.  
  28. graph_edit(window W, GRAPH(point,int) G, bool directed = true);
  29.  
  30.         Graph editor, edges are represented by arrows if directed = true
  31.         and by segments if directed = false
  32.         (declaration in <LEDA/graph_edit.h>)
  33.  
  34.         see example program "prog/graphics/matching.c" for details.
  35.  
  36.  
  37. --------------------------------------------------------------------------------
  38. string
  39. --------------------------------------------------------------------------------
  40.  
  41.  
  42. string(const char*, ...)               new printf/form - like constructor
  43.                                        e.g.  s = string("x = %5.2f",x);
  44.  
  45.  
  46. --------------------------------------------------------------------------------
  47. graph algorithms
  48. --------------------------------------------------------------------------------
  49.  
  50.  
  51. list(edge) MAX_CARD_MATCHING(graph G) 
  52.  
  53.                               Maximum cardinality matching for general graphs,
  54.                               implemented by Edmond's Algorithm, returns list
  55.                               of matched edges.
  56.                               (source in  "src/graph_alg/_mc_matching.c")
  57.                 
  58.                               (worst-case running time  O(n*m) )
  59.                 
  60.  
  61.  
  62.  
  63. +==============================================================================+
  64. |                                           |
  65. |                           VERSION 2.1.0                        |
  66. |                                                                              |
  67. +==============================================================================+
  68.  
  69.  
  70. --------------------------------------------------------------------------------
  71.         !!!!!!!!!!!!  CHANGES IN HEADER FILES  !!!!!!!!!!!!!!!!!!
  72. --------------------------------------------------------------------------------
  73.  
  74. I. <LEDA/graph.h> 
  75.  
  76.  
  77. Header file <LEDA/graph.h> has been split into  
  78.  
  79.  
  80. <LEDA/graph.h>            : graph, GRAPH, node_array, edge_array
  81.  
  82. <LEDA/ugraph.h>           : ugraph, UGRAPH
  83.  
  84. <LEDA/planar_map.h>       : planar_map, PLANAR_MAP
  85.  
  86. <LEDA/graph_alg.h>        : graph algorithms + predefined node/edge array types
  87.  
  88.                             node_array(int)   edge_array(int)
  89.                             node_array(edge)  edge_array(edge)
  90.                             node_array(bool)  edge_array(bool);
  91.                             node_array(real)  edge_array(real)
  92.                             node_matrix(bool)
  93.                             node_matrix(int)
  94.                             node_matrix(real)
  95.  
  96. <LEDA/node_set.h>         : node_set
  97.  
  98. <LEDA/edge_set.h>         : edge_set
  99.  
  100. <LEDA/node_partition.h>   : node_partition
  101.  
  102. <LEDA/node_pq.h>          : node_pq
  103.  
  104. --------------------------------------------------------------------------------
  105.  
  106.  
  107. II. <LEDA/plane.h> 
  108.  
  109.  
  110. Header file <LEDA/plane.h> has been split into  
  111.  
  112. <LEDA/plane.h>      : basic geometric objects (point,segment, ...) and 
  113.                       predefined types list(point), list(segment), ...
  114.  
  115. <LEDA/plane_alg.h>  : plane algorithms, predefined type GRAPH(point,point)
  116.  
  117.  
  118. --------------------------------------------------------------------------------
  119.  
  120.  
  121. --------------------------------------------------------------------------------
  122. data type "string"
  123. --------------------------------------------------------------------------------
  124.  
  125. int       s.pos (string s_1, int i ) 
  126.  
  127.                       returns the first position of s_1 in s right of  
  128.                       position i (-1 if no such position exists)  
  129.  
  130.  
  131. string    s.insert (string s_1, int i ) 
  132.  
  133.                       returns s(0,i-1) + s_1 + s(i+1,s.length())  
  134.                       Precondition:0 <= i <= s.length()-1  
  135.  
  136.  
  137. string    s.replace (string s_1, string s_2, int i=1 ) 
  138.  
  139.                       returns the string created from s by replacing  
  140.                       the i-th occurence of s_1 in s by s_2  
  141.  
  142.  
  143. string    s.replace_all (string s_1, string s_2 ) 
  144.  
  145.                       returns the string created from s by replacing  
  146.                       all occurences of s_1 in s by s_2  
  147.  
  148.  
  149. string    s.replace (int i, int j, string s_1 ) 
  150.  
  151.                       returns the string created from s by replacing  
  152.                       s(i,j) by s_1  
  153.  
  154.  
  155. string    s.replace (int i, string s_1 ) 
  156.  
  157.                       returns the string created from s by replacing  
  158.                       s[i] by s_1  
  159.  
  160.  
  161. string    s.del (string s_1, int i=1 ) 
  162.  
  163.                       returns s.replace(s_1,"",i)  
  164.  
  165.  
  166. string    s.del_all (string s_1 ) 
  167.  
  168.                       returns s.replace_all(s_1,"")  
  169.  
  170.  
  171. string    s.del (int i, int j ) 
  172.  
  173.                       returns s.replace(i,j,"")  
  174.  
  175.  
  176. string    s.del (int i ) 
  177.  
  178.                       returns s.replace(i,"")  
  179.  
  180.  
  181. void      s.read (istream I, char delim = ' ' ) 
  182.  
  183.                       reads characters from input stream I into s  
  184.                       until the first occurence of character delim  
  185.  
  186.  
  187. void      s.read (char delim = ' ' ) 
  188.  
  189.                       read(cin,delim)  
  190.  
  191.  
  192. void      s.readline (istream I ) 
  193.  
  194.                       read(I,'\n')  
  195.  
  196.  
  197. void      s.readline () 
  198.  
  199.                       readline(cin)  
  200.  
  201.  
  202.  
  203. --------------------------------------------------------------------------------
  204. matrix
  205. --------------------------------------------------------------------------------
  206.  
  207. Operations   matrix matrix::inv()                O(n^3)
  208.              vector matrix::solve(vector)        O(n^2)
  209.              double matrix::det()                O(n^2)
  210.  
  211. are now implemented by Gaussian eliminiation.
  212.  
  213.  
  214. matrix M.solve(matrix A)    solves  M*x_i = b_i simultaneously for all 
  215.                             columns b_i of A, returns matrix (x_0,...,x_n-1)
  216.                             Preconditions: a) M is quadratic 
  217.                                            b) A.dim2() = M.dim1()
  218.  
  219.  
  220. --------------------------------------------------------------------------------
  221. list
  222. --------------------------------------------------------------------------------
  223.  
  224. list_item  L[int i]        returns i-th item (nil if i<0 or i>L.length()-1)
  225.                            cost: O(i)
  226.  
  227.  
  228.  
  229. --------------------------------------------------------------------------------
  230. sortseq
  231. --------------------------------------------------------------------------------
  232.  
  233. void      S.split (seq_item it, sortseq& S_1, sortseq& S_2 ) 
  234.  
  235.                       splits S at item it into sequences S_1 and S_2  
  236.                       and makes S empty. More precisely, if  
  237.                       S = x_1,...,x_k-1,it,x_k+1,...,x_n then  
  238.                       S1 = x_1,...,x_k-1,it and S2 = x_k+1,...,x_n  
  239.                       Precondition: it is an item in S.  
  240.  
  241. sortseq&  S.conc (sortseq& S_1 ) 
  242.  
  243.                       appends S_1 to S, makes S_1 empty, and returns S.
  244.                       Precondition: S.key(S.max()) <= S_1.key(S_1.min()).  
  245.  
  246.  
  247.  
  248.  
  249.  
  250.  
  251. --------------------------------------------------------------------------------
  252. graph  G
  253. --------------------------------------------------------------------------------
  254.  
  255. void      G.sort_nodes (node_array(T) A ) 
  256.  
  257.                       the nodes of G are sorted according to the  
  258.                       entries of node_array A (cf. section 5.7)  
  259.                       Precondition: T must be linearly ordered  
  260.  
  261. void      G.sort_edges (edge_array(T) A ) 
  262.  
  263.                       the edges of G are sorted according to the  
  264.                       entries of edge_array A (cf. section 5.7)  
  265.                       Precondition: T must be linearly ordered  
  266.  
  267.  
  268.  
  269. pretty printing:
  270.  
  271. void      G.print(string s, ostream O)
  272. void      G.print(string s)
  273. void      G.print(ostream O)
  274. void      G.print()
  275.  
  276. void      G.print_node(node v, ostream O = cout)
  277. void      G.print_edge(edge e, ostream O = cout)
  278.  
  279.  
  280.  
  281.  
  282. --------------------------------------------------------------------------------
  283. GRAPH(vtype,etype)  G
  284. --------------------------------------------------------------------------------
  285.  
  286. void      G.sort_nodes () 
  287.  
  288.                       the nodes of G are sorted according to their  
  289.                       informations. Precondition: vtype is linearly  
  290.                       ordered.  
  291.  
  292. void      G.sort_edges () 
  293.  
  294.                       the edges of G are sorted according to their  
  295.                       informations. Precondition: etype is linearly  
  296.                       ordered.  
  297.  
  298. --------------------------------------------------------------------------------
  299. node/edge_array
  300. --------------------------------------------------------------------------------
  301.  
  302. Creation of a node array (edge array)::
  303.  
  304. a) ...
  305. b) ...
  306. c) ...
  307.  
  308. d) node/edge_array(E)  A(graph G, int n, E x)    array for n nodes/edges of G
  309.                                                  Precondition: n >= |V| (|E|)
  310.  
  311.  
  312.  
  313.  
  314.  
  315.  
  316.  
  317.  
  318.  
  319.  
  320. +==============================================================================+
  321. |                                           |
  322. |                           VERSION 2.0.1                       |
  323. |                                                                              |
  324. +==============================================================================+
  325.  
  326.  
  327. --------------------------------------------------------------------------------
  328. GENERAL
  329. --------------------------------------------------------------------------------
  330.  
  331. forall_items(x,...)    can be used for all kinds of items
  332.  
  333.  
  334. Read and Write functions for user defined I/O (cf. User Manual, section 1.5)
  335. must have an additional stream argument: 
  336.  
  337.                    Read(T&, istream&)
  338.  
  339.                    defines an input function for reading objects of type T 
  340.                    from an input stream.
  341.  
  342.                    Write(T&,ostream&)
  343.  
  344.                    defines an output function for printing objects of type T 
  345.                    to an output stream.
  346.  
  347. --------------------------------------------------------------------------------
  348. string (section 2.3)
  349. --------------------------------------------------------------------------------
  350.  
  351.  
  352. string  s.tail(int i)       returns the last  i characters of s
  353.  
  354. string  s.head(int i)       returns the first i characters of s
  355.  
  356.  
  357. --------------------------------------------------------------------------------
  358. array (section 3.1)
  359. --------------------------------------------------------------------------------
  360.  
  361.  
  362. void     A.sort (int (*cmp)(E&, E&), int l, int h ) 
  363.  
  364.                       applies the sorting operation to the sub-array  
  365.                       [l..h].  
  366.  
  367. void     A.read (istream I ) 
  368.  
  369.                       reads b-a+1 objects of type E from the input  
  370.                       stream I into the array A using the overloaded  
  371.                       Read function (section 1.5)  
  372.  
  373. void     A.read () 
  374.  
  375.                       Calls A.read(cin) to read A from  
  376.                       the standard input stream cin.  
  377.  
  378. void     A.read (string s ) 
  379.  
  380.                       As above, but uses string s as a prompt.  
  381.  
  382. void     A.print (ostream O, char space = ' ' ) 
  383.  
  384.                       Prints the contents of array A to the output  
  385.                       stream O using the overload Print function  
  386.                       (section 1.5) to print each element. The elements  
  387.                       are separated by the space character space.  
  388.  
  389. void     A.print (char space = ' ' ) 
  390.  
  391.                       Calls A.print(cout, space) to print A on  
  392.                       the standard output stream cout.  
  393.  
  394. void     A.print (string s, char space = ' ' ) 
  395.  
  396.                       As above, but uses string s as a header.  
  397.  
  398.  
  399.  
  400.  
  401. --------------------------------------------------------------------------------
  402. list  (section 3.7)
  403. --------------------------------------------------------------------------------
  404.  
  405.  
  406. void     L.read (istream I, char delim = '\n' ) 
  407.  
  408.                       reads a sequence of objects of type E terminated  
  409.                       by the delimiter delim from the input stream I  
  410.                       using the overloaded Read function (section 1.5)  
  411.                       L is made a list of appropriate length and the  
  412.                       sequence is stored in L.  
  413.  
  414. void     L.read (char delim = '\n' ) 
  415.  
  416.                       Calls L.read(cin, delim) to read L from  
  417.                       the standard input stream cin.  
  418.  
  419. void     L.read (string s, char delim = '\n' ) 
  420.  
  421.                       As above, but uses string s as a prompt.  
  422.  
  423. void     L.print (ostream O, char space = ' ' ) 
  424.  
  425.                       Prints the contents of list L to the output  
  426.                       stream O using the overload Print function  
  427.                       (section 1.5) to print each element. The elements  
  428.                       are separated by the space character space.  
  429.  
  430. void     L.print (char space = ' ' ) 
  431.  
  432.                       Calls L.print(cout, space) to print L on  
  433.                       the standard output stream cout.  
  434.  
  435. void     L.print (string s, char space = ' ' ) 
  436.  
  437.                       As above, but uses string s as a header.  
  438.  
  439.  
  440.  
  441. void     L.write (string fname ) 
  442.  
  443.                       writes G to the file with name fname. The  
  444.                       overloaded functions Print(vtype,ostream)  
  445.                       and Print(etype,ostream) (cf. section 1.6)  
  446.                       are used to write the node and edge entries  
  447.                       of G respectively.  
  448.  
  449. void     L.read (string fname ) 
  450.  
  451.                       reads G from the file with name fname. The  
  452.                       overloaded functions Read(vtype,istream)  
  453.                       and Read(etype,istream) (cf. section 1.6)  
  454.                       are used to read the node and edge entries  
  455.                       of G respectively.  
  456.  
  457. --------------------------------------------------------------------------------
  458. priority_queue  (section 4.1)
  459. --------------------------------------------------------------------------------
  460.  
  461. Operation del_min has been overloaded
  462.  
  463. K    del_min()
  464.  
  465. void del_min(K& k, I& i)
  466.  
  467.                       removes an item x with minimal information
  468.                       assigns key(x) to k and inf(x) to i.
  469.  
  470.  
  471. --------------------------------------------------------------------------------
  472. sortseq  (section 4.6)
  473. --------------------------------------------------------------------------------
  474.  
  475. Operations "succ" and "pred" have been overloaded:
  476.  
  477. seq_item  S.succ(seq_item x)
  478. seq_item  S.succ(K k)
  479. seq_item  S.pred(seq_item x)
  480. seq_item  S.pred(K k)
  481.  
  482.  
  483.  
  484. NEW DATA TYPE:
  485. --------------------------------------------------------------------------------
  486. 4.7 Persistent Dictionaries (p_dictionary)
  487. --------------------------------------------------------------------------------
  488.  
  489.  
  490. 1. DEFINITION
  491.  
  492. The difference between dictionaries (cf. section~4.3) and persistent 
  493. dictionaries lies in the fact that update operations performed 
  494. on a persistent dictionary D do not change D but create and return a 
  495. new dictionary D'. For example, D.del(k) returns the dictionary D' 
  496. containing all items it of D with key(it) != k. 
  497.  
  498. An instance D of the data type p_dictionary is a set of items (type 
  499. p_dic_item). Every item in D contains a key from a linearly ordered 
  500. data type K, called the key type of D, and an information from a data 
  501. type I, called the information type  of D. The number of items in D 
  502. is called the size of D. A dictionary of size zero is called empty. 
  503. We use <k,i> to denote an item with key k and information 
  504. i (i is said to be the information associated with key k).  For each 
  505. k in K there is at most one item <k,i> in D.
  506.  
  507.  
  508.  
  509. 2. DECLARATION
  510.  
  511. declare2(p_dictionary,K,I)
  512.  
  513. introduces a new data type with name p_dictionary(K,I) consisting of all 
  514. persistent dictionaries with key type K and information type I.
  515. precond K is linearly ordered.
  516.  
  517.  
  518.  
  519. 3. CREATION
  520.  
  521. p_dictionary(K,I) D ;
  522.  
  523. creates an instance D of type p_dictionary(K,I) and initializes D to an 
  524. empty persistent dictionary. 
  525.  
  526.  
  527.  
  528. 4. OPERATIONS
  529.  
  530. K         D.key (dic_item it ) 
  531.  
  532.                       returns the key of item it.  
  533.                       Precondition: it in D.  
  534.  
  535. I         D.inf (dic_item it ) 
  536.  
  537.                       returns the information of item it.  
  538.                       Precondition: it in D.  
  539.  
  540. dic_item  D.lookup (K k ) 
  541.  
  542.                       returns the item with key k (nil if  
  543.                       no such item exists in D).  
  544.  
  545. I         D.access (K k ) 
  546.  
  547.                       returns the information associated with key k  
  548.                       Precondition: there is an item with  
  549.                       key k in D.  
  550.  
  551. p_dictionary(K,I) D.del (K k ) 
  552.  
  553.                       returns { x in D | key(x) != k }.  
  554.  
  555. p_dictionary(K,I) D.del_item (dic_item it ) 
  556.  
  557.                       returns { x in D | x != it }.  
  558.  
  559. p_dictionary(K,I) D.insert (K k, I i ) 
  560.  
  561.                       returns D.del(k) cup {<k,i>}.  
  562.  
  563. p_dictionary(K,I) D.change_inf (dic_item it, I i ) 
  564.  
  565.                       Let k = key(it), returns D.del_item(it) cup  
  566.                       {<k,i>}. Precondition: it in D.  
  567.  
  568. p_dictionary(K,I) D.clear () 
  569.  
  570.                       returns an empty persistent dictionary.  
  571.  
  572. bool      D.empty () 
  573.  
  574.                       returns true if D is empty, false otherwise.  
  575.  
  576. int       D.size () 
  577.  
  578.                       returns the size of D.  
  579.  
  580.  
  581.  
  582. 5. ITERATION
  583.  
  584. forall_items(i,D) 
  585. { ``the items of D are successively assigned to i '' }
  586.  
  587.  
  588.  
  589. 6. IMPLEMENTATION
  590.  
  591. Persistent Dictionaries are implemented by leaf oriented 
  592. persistent red black trees (cf. [DSST89]).
  593. Operations insert, lookup, del_item, del take time O(log n), key, inf, 
  594. empty, size, change_inf and clear take time O(1). The space requirement 
  595. is O(n). Here n is the number of all created persistent dictionaries (= number 
  596. of all performed update operations). 
  597.  
  598.  
  599. --------------------------------------------------------------------------------
  600. GRAPH    (section 5.4)
  601. --------------------------------------------------------------------------------
  602.  
  603.  
  604. void      G.write (string fname ) 
  605.  
  606.                       writes G to the file with name fname. The  
  607.                       overloaded functions Print(vtype,ostream)  
  608.                       and Print(etype,ostream) (cf. section 1.6)  
  609.                       are used to write the node and edge entries  
  610.                       of G respectively.  
  611.  
  612. int       G.read (string fname ) 
  613.  
  614.                       reads G from the file with name fname. The  
  615.                       overloaded functions Read(vtype,istream)  
  616.                       and Read(etype,istream) (cf. section 1.6)  
  617.                       are used to read the node and edge entries  
  618.                       of G respectively. Returns error code
  619.                       1  if file fname does not exist
  620.                       2  if graph is not of type GRAPH(vtype,etype)
  621.                       3  if file fname does not contain a graph
  622.                       0  otherwise.
  623.  
  624.  
  625.  
  626.  
  627. --------------------------------------------------------------------------------
  628. PLANE  (section 6.1.6)
  629. --------------------------------------------------------------------------------
  630.  
  631.  
  632.  
  633. Function VORONOI  (cf. section 6.1.6) has a new interface:
  634.  
  635.  
  636. void VORONOI(list(point), double R, GRAPH(point,point) )
  637.  
  638.         VORONOI takes as input a list of points  sites and a real number 
  639.         R. It computes a directed graph G representing the planar subdivision
  640.         defined by the Voronoi-diagram of sites where all ``infinite" edges have
  641.         length R. For each node v G.inf(v) is the corresponding Voronoi 
  642.         vertex (point) and for each edge e  G.inf(e) is the site (point) 
  643.         whose Voronoi region is bounded by e. 
  644.  
  645.  
  646.  
  647.  
  648. --------------------------------------------------------------------------------
  649. point_set  (section 6.3)
  650. --------------------------------------------------------------------------------
  651.  
  652. list(ps_item) S.convex_hull () 
  653.  
  654.                       returns the list of items containing  
  655.                       all points of the convex hull of  
  656.                       in clockwise order.  
  657.  
  658.  
  659.  
  660.  
  661.  
  662.  
  663. --------------------------------------------------------------------------------
  664. graphic windows  (section 6.7)
  665. --------------------------------------------------------------------------------
  666.  
  667. Data type gwindow no longer exists, it is replaced by data type window
  668.  
  669. The data type window provides an interface for the input and 
  670. output of basic two-dimensinal geometric objects (cf. section 5.1) 
  671. using the X11 (xview) or SunView window system.
  672. There are two object code libraries (libWs.a, libWx.a) containing 
  673. implementations for different environments. Application programs using data 
  674. type window have to be linked with one of these libraries (cf. section~1.6):
  675.  
  676.  
  677. a) For the SunView window system:
  678.  
  679.    CC prog.c -lWs -lP -lG -lL -lm  -lsuntool -lsunwindow -lpixrect
  680.  
  681.  
  682. b) For the X11 (open windows) window system:
  683.  
  684.    CC prog.c -lWx -lP -lG -lL -lm  -lxview -lolgx -lX11 
  685.  
  686.  
  687.  
  688. --------------------------------------------------------------------------------
  689. Creation of a graphic window
  690. --------------------------------------------------------------------------------
  691.  
  692.  
  693. a) window W(int xpix, int ypix, int xpos, int ypos);
  694.  
  695. b) window W(int xpix, int ypix);
  696.  
  697. c) window W();
  698.  
  699. Variant a) creates a window W of physical size xpix times ypix pixels 
  700. with its upper left corner at position (xpos,ypos) on the screen,
  701. variant b) places W into the upper right corner of the screen, and
  702. variant c) creates a 850 times 850 pixel window positioned into the
  703. upper right corner.
  704.  
  705. All three variants initialize the coordinates of W to x0 = 0,
  706. x1 = 100 and y0 = 0. The init operation (see  below) can later 
  707. be used to change the window coordinates and scaling.
  708.  
  709.  
  710.  
  711. --------------------------------------------------------------------------------
  712. Additional operations
  713. --------------------------------------------------------------------------------
  714.  
  715.  
  716. int       W.read_panel (string h, int n, string* S ) 
  717.  
  718.                       displays a panel with header h and an array S[n]  
  719.                       of n string buttons, returns the index of the selected  
  720.                       button.  
  721.  
  722. int       W.read_vpanel (string h, int n, string* S ) 
  723.  
  724.                       read_panel with vertical button layout
  725.  
  726.  
  727. int       W.read_int (string p ) 
  728.  
  729.                       displays a panel with prompt p for integer input,  
  730.                       returns the input  
  731.  
  732.  
  733. real      W.read_real (string p ) 
  734.  
  735.                       displays a panel with prompt p for real input  
  736.                       returns the input  
  737.  
  738.  
  739. string    W.read_string (string p ) 
  740.  
  741.                       displays a panel with prompt p for string input,  
  742.                       returns the input  
  743.  
  744.  
  745.         
  746. string    W.read_string (string p, list(string) menu)
  747.  
  748.                       as above, adds an additional menu button which
  749.                       can be used to select a string from menu.
  750.      
  751. string    W.read_string (string p, string label, list(string) menu)
  752.                       as above, the menu button is labelled with label.
  753.  
  754.  
  755.  
  756.  
  757. --------------------------------------------------------------------------------
  758. PANELS
  759. --------------------------------------------------------------------------------
  760.  
  761.  
  762. Creation:
  763. --------
  764.  
  765. panel P(string header);
  766.  
  767. panel P;
  768.  
  769.  
  770. Operations:
  771. ----------
  772.  
  773. void P.text_item(string s)
  774.  
  775. void P.bool_item(string label, bool& x)
  776.  
  777. void P.real_item(string label, real& x)
  778.  
  779. void P.color_item(string label, color& x)
  780.  
  781. void P.int_item(string label, int& x)
  782. void P.int_item(string label, int& x, int min, int max)              // slider
  783. void P.int_item(string label, int& x, int low, int high, int step)   // choice
  784.  
  785. void P.string_item(string label, string& x)
  786. void P.string_item(string label,string& x,list(string) L)  // menu
  787.  
  788. void P.choice_item(string label, int& x, list(string) L)
  789. void P.choice_item(string label, int& x, int l, string* L)
  790. void P.choice_item(string label, int& x, string, ... )
  791.  
  792. void P.button(string label)
  793.  
  794. void P.new_button_line()
  795. void P.new_button_line(list(string) buttons)
  796.  
  797.  
  798. int  P.open()
  799. int  P.open(list(string)& buttons)
  800.  
  801.  
  802. --------------------------------------------------------------------------------
  803. 7. Miscellaneous
  804. --------------------------------------------------------------------------------
  805.  
  806. --------------------------------------------------------------------------------
  807. Command input streams (cmd_istream)
  808. --------------------------------------------------------------------------------
  809.  
  810. An instance I of the data type cmd_istream is an C++ istream
  811. connected to the output of a shell command cmd, i.e., all input operations 
  812. or operators applied to I read from the standard output of command cmd. 
  813.  
  814. 1. Creation of a command input stream 
  815.  
  816. cmd_istream   in(string cmd);
  817.  
  818. creates an instance in of type cmd_istream connected to the output of command cmd.
  819.  
  820. 2. Operations
  821.  
  822. All operations and operators (>>) defined for C++ istreams can
  823. be applied to command input streams as well.
  824.  
  825.  
  826.  
  827.  
  828. --------------------------------------------------------------------------------
  829. Command output streams (cmd_ostream)
  830. --------------------------------------------------------------------------------
  831.  
  832. An instance O of the data type cmd_ostream is an C++ ostream
  833. connected to the input of a shell command cmd, i.e., all output operations 
  834. or operators applied to O write into the standard input of command cmd. 
  835.  
  836. 1. Creation of a command output stream} 
  837.  
  838. cmd_ostream   out(string cmd);
  839.  
  840. creates an instance out of type cmd_ostream connected to the input of 
  841. command cmd. 
  842.  
  843. 2. Operations 
  844.  
  845. All operations and operators (<<) defined for C++ ostreams can
  846. be applied to command output streams as well.
  847.  
  848.  
  849.