ROL
ROL_SandiaRules.hpp
Go to the documentation of this file.
1 // @HEADER
2 // ************************************************************************
3 //
4 // Rapid Optimization Library (ROL) Package
5 // Copyright (2014) Sandia Corporation
6 //
7 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact lead developers:
38 // Drew Kouri (dpkouri@sandia.gov) and
39 // Denis Ridzal (dridzal@sandia.gov)
40 //
41 // ************************************************************************
42 // @HEADER
43 
44 
45 #ifndef ROL_SANDIARULES_HPP
46 #define ROL_SANDIARULES_HPP
47 
48 # include <cstdlib>
49 # include <iomanip>
50 # include <iostream>
51 # include <cmath>
52 # include <ctime>
53 # include <fstream>
54 # include <string>
55 
56 namespace ROL {
57 
58 class SandiaRules {
59 public:
60 
61  SandiaRules(void) {};
62 
63  void binary_vector_next ( int n, int bvec[] );
64 
65  void ccn_compute ( int n, double x[], double w[] );
66  void ccn_compute_np ( int n, int np, double p[], double x[], double w[] );
67  void ccn_compute_points ( int n, double x[] );
68  void ccn_compute_points_np ( int n, int np, double p[], double x[] );
69  void ccn_compute_weights ( int n, double w[] );
70  void ccn_compute_weights_np ( int n, int np, double p[], double w[] );
71 
72  void chebyshev1_compute ( int order, double x[], double w[] );
73  void chebyshev1_compute_np ( int order, int np, double p[], double x[], double w[] );
74  void chebyshev1_compute_points ( int order, double x[] );
75  void chebyshev1_compute_points_np ( int order, int np, double p[], double x[] );
76  void chebyshev1_compute_weights ( int order, double w[] );
77  void chebyshev1_compute_weights_np ( int order, int np, double p[], double w[] );
78  double chebyshev1_integral ( int expon );
79 
80  void chebyshev2_compute ( int order, double x[], double w[] );
81  void chebyshev2_compute_np ( int order, int np, double p[], double x[], double w[] );
82  void chebyshev2_compute_points ( int order, double x[] );
83  void chebyshev2_compute_points_np ( int order, int np, double p[], double x[] );
84  void chebyshev2_compute_weights ( int order, double w[] );
85  void chebyshev2_compute_weights_np ( int order, int np, double p[], double w[] );
86  double chebyshev2_integral ( int expon );
87 
88  void clenshaw_curtis_compute ( int order, double x[], double w[] );
89  void clenshaw_curtis_compute_np ( int order, int np, double p[], double x[], double w[] );
90  void clenshaw_curtis_compute_points ( int order, double x[] );
91  void clenshaw_curtis_compute_points_np ( int order, int np, double p[], double x[] );
92  void clenshaw_curtis_compute_weights ( int order, double w[] );
93  void clenshaw_curtis_compute_weights_np ( int order, int np, double p[], double w[] );
94 
95  void comp_next ( int n, int k, int a[], bool *more, int *h, int *t );
96 
97  double cpu_time ( );
98 
99  void dif_deriv ( int nd, double xd[], double yd[], int *ndp, double xdp[],
100  double ydp[] );
101  void dif_shift_x ( int nd, double xd[], double yd[], double xv );
102  void dif_shift_zero ( int nd, double xd[], double yd[] );
103  void dif_to_r8poly ( int nd, double xd[], double yd[], double c[] );
104 
105  void fejer2_compute ( int order, double x[], double w[] );
106  void fejer2_compute_np ( int order, int np, double p[], double x[], double w[] );
107  void fejer2_compute_points ( int order, double x[] );
108  void fejer2_compute_points_np ( int order, int np, double p[], double x[] );
109  void fejer2_compute_weights ( int order, double w[] );
110  void fejer2_compute_weights_np ( int order, int np, double p[], double w[] );
111 
112  void gegenbauer_compute ( int order, double alpha, double x[], double w[] );
113  void gegenbauer_compute_np ( int order, int np, double p[], double x[], double w[] );
114  void gegenbauer_compute_points ( int order, double alpha, double x[] );
115  void gegenbauer_compute_points_np ( int order, int np, double p[], double x[] );
116  void gegenbauer_compute_weights ( int order, double alpha, double w[] );
117  void gegenbauer_compute_weights_np ( int order, int np, double p[], double w[] );
118  double gegenbauer_integral ( int expon, double alpha );
119  void gegenbauer_recur ( double *p2, double *dp2, double *p1, double x,
120  int order, double alpha, double c[] );
121  void gegenbauer_root ( double *x, int order, double alpha, double *dp2,
122  double *p1, double c[] );
123 
124  void gen_hermite_compute ( int order, double alpha, double x[], double w[] );
125  void gen_hermite_compute_np ( int order, int np, double p[], double x[], double w[] );
126  void gen_hermite_compute_points ( int order, double alpha, double x[] );
127  void gen_hermite_compute_points_np ( int order, int np, double p[], double x[] );
128  void gen_hermite_compute_weights ( int order, double alpha, double w[] );
129  void gen_hermite_compute_weights_np ( int order, int np, double p[], double w[] );
130  void gen_hermite_dr_compute ( int order, double alpha, double x[], double w[] );
131  double gen_hermite_integral ( int expon, double alpha );
132 
133  void gen_laguerre_compute ( int order, double alpha, double x[], double w[] );
134  void gen_laguerre_compute_np ( int order, int np, double p[], double x[], double w[] );
135  void gen_laguerre_compute_points ( int order, double alpha, double x[] );
136  void gen_laguerre_compute_points_np ( int order, int np, double p[], double x[] );
137  void gen_laguerre_compute_weights ( int order, double alpha, double w[] );
138  void gen_laguerre_compute_weights_np ( int order, int np, double p[], double w[] );
139  double gen_laguerre_integral ( int expon, double alpha );
140  void gen_laguerre_ss_compute ( int order, double alpha, double x[], double w[] );
141  void gen_laguerre_ss_recur ( double *p2, double *dp2, double *p1, double x,
142  int order, double alpha, double b[], double c[] );
143  void gen_laguerre_ss_root ( double *x, int order, double alpha, double *dp2,
144  double *p1, double b[], double c[] );
145 
146  void hc_compute_weights_from_points ( int nhalf, double x[], double w[] );
147 
148  void hcc_compute ( int n, double x[], double w[] );
149  void hcc_compute_np ( int n, int np, double p[], double x[], double w[] );
150  void hcc_compute_points ( int n, double x[] );
151  void hcc_compute_points_np ( int n, int np, double p[], double x[] );
152  void hcc_compute_weights ( int n, double w[] );
153  void hcc_compute_weights_np ( int n, int np, double p[], double w[] );
154 
155  void hce_compute ( int n, double x[], double w[] );
156  void hce_compute_np ( int n, int np, double p[], double x[], double w[] );
157  void hce_compute_points ( int n, double x[] );
158  void hce_compute_points_np ( int n, int np, double p[], double x[] );
159  void hce_compute_weights ( int n, double w[] );
160  void hce_compute_weights_np ( int n, int np, double p[], double w[] );
161 
162  void hermite_compute ( int order, double x[], double w[] );
163  void hermite_compute_np ( int order, int np, double p[], double x[], double w[] );
164  void hermite_compute_points ( int order, double x[] );
165  void hermite_compute_points_np ( int order, int np, double p[], double x[] );
166  void hermite_compute_weights ( int order, double w[] );
167  void hermite_compute_weights_np ( int order, int np, double p[], double w[] );
168 
169  void hermite_genz_keister_lookup ( int n, double x[], double w[] );
170  void hermite_genz_keister_lookup_points ( int n, double x[] );
171  void hermite_genz_keister_lookup_points_np ( int n, int np, double p[],
172  double x[] );
173  void hermite_genz_keister_lookup_weights ( int n, double w[] );
174  void hermite_genz_keister_lookup_weights_np ( int n, int np, double p[],
175  double w[] );
176 
177  void hermite_gk18_lookup_points ( int n, double x[] );
178  void hermite_gk22_lookup_points ( int n, double x[] );
179  void hermite_gk24_lookup_points ( int n, double x[] );
180 
181  double hermite_integral ( int n );
182 
183  void hermite_interpolant ( int n, double x[], double y[], double yp[],
184  double xd[], double yd[], double xdp[], double ydp[] );
185  void hermite_interpolant_rule ( int n, double a, double b, double x[], double w[] );
186  void hermite_interpolant_value ( int nd, double xd[], double yd[], double xdp[],
187  double ydp[], int nv, double xv[], double yv[], double yvp[] );
188 
189  void hermite_lookup ( int n, double x[], double w[] );
190  void hermite_lookup_points ( int n, double x[] );
191  void hermite_lookup_weights ( int n, double w[] );
192  void hermite_ss_compute ( int order, double x[], double w[] );
193  void hermite_ss_recur ( double *p2, double *dp2, double *p1, double x,
194  int order );
195  void hermite_ss_root ( double *x, int order, double *dp2, double *p1 );
196 
197  int i4_choose ( int n, int k );
198  int i4_log_2 ( int i );
199  int i4_max ( int i1, int i2 );
200  int i4_min ( int i1, int i2 );
201  int i4_power ( int i, int j );
202 
203  void i4mat_copy ( int m, int n, int a1[], int a2[] );
204  int *i4mat_copy_new ( int m, int n, int a1[] );
205  void i4mat_transpose_print ( int m, int n, int a[], std::string title );
206  void i4mat_transpose_print_some ( int m, int n, int a[], int ilo, int jlo,
207  int ihi, int jhi, std::string title );
208  void i4mat_write ( std::string output_filename, int m, int n, int table[] );
209 
210  int *i4vec_add_new ( int n, int a[], int b[] );
211  bool i4vec_any_lt ( int n, int a[], int b[] );
212  void i4vec_copy ( int n, int a1[], int a2[] );
213  int *i4vec_copy_new ( int n, int a1[] );
214  void i4vec_min_mv ( int m, int n, int u[], int v[], int w[] );
215  void i4vec_print ( int n, int a[], std::string title );
216  int i4vec_product ( int n, int a[] );
217  int i4vec_sum ( int n, int a[] );
218  void i4vec_zero ( int n, int a[] );
219  int *i4vec_zero_new ( int n );
220 
221  void imtqlx ( int n, double d[], double e[], double z[] );
222 
223  void jacobi_compute ( int order, double alpha, double beta, double x[],
224  double w[] );
225  void jacobi_compute_np ( int order, int np, double p[], double x[], double w[] );
226  void jacobi_compute_points ( int order, double alpha, double beta,
227  double x[] );
228  void jacobi_compute_points_np ( int order, int np, double p[], double x[] );
229  void jacobi_compute_weights ( int order, double alpha, double beta,
230  double w[] );
231  void jacobi_compute_weights_np ( int order, int np, double p[], double w[] );
232  double jacobi_integral ( int expon, double alpha, double beta );
233  void jacobi_ss_compute ( int order, double alpha, double beta, double x[],
234  double w[] );
235  void jacobi_ss_recur ( double *p2, double *dp2, double *p1, double x, int order,
236  double alpha, double beta, double b[], double c[] );
237  void jacobi_ss_root ( double *x, int order, double alpha, double beta,
238  double *dp2, double *p1, double b[], double c[] );
239 
240  void laguerre_compute ( int n, double x[], double w[] );
241  void laguerre_compute_np ( int order, int np, double p[], double x[], double w[] );
242  void laguerre_compute_points ( int order, double x[] );
243  void laguerre_compute_points_np ( int order, int np, double p[], double x[] );
244  void laguerre_compute_weights ( int order, double w[] );
245  void laguerre_compute_weights_np ( int order, int np, double p[], double w[] );
246  double laguerre_integral ( int expon );
247  void laguerre_lookup ( int n, double x[], double w[] );
248  void laguerre_lookup_points ( int n, double x[] );
249  void laguerre_lookup_weights ( int n, double w[] );
250  void laguerre_ss_compute ( int order, double x[], double w[] );
251  void laguerre_ss_recur ( double *p2, double *dp2, double *p1, double x,
252  int order, double b[], double c[] );
253  void laguerre_ss_root ( double *x, int order, double *dp2, double *p1,
254  double b[], double c[] );
255 
256  void legendre_compute ( int n, double x[], double w[] );
257  void legendre_compute_np ( int order, int np, double p[], double x[], double w[] );
258  void legendre_compute_points ( int order, double x[] );
259  void legendre_compute_points_np ( int order, int np, double p[], double x[] );
260  void legendre_compute_weights ( int order, double w[] );
261  void legendre_compute_weights_np ( int order, int np, double p[], double w[] );
262  void legendre_dr_compute ( int order, double x[], double w[] );
263  double legendre_integral ( int expon );
264  void legendre_lookup ( int n, double x[], double w[] );
265  void legendre_lookup_points ( int n, double x[] );
266  void legendre_lookup_weights ( int n, double w[] );
267  double *legendre_zeros ( int order );
268 
269  void level_growth_to_order ( int dim_num, int level[], int rule[], int growth[],
270  int order[] );
271  void level_to_order_default ( int dim_num, int level[], int rule[],
272  int order[] );
273  void level_to_order_exponential ( int dim_num, int level[], int rule[],
274  int order[] );
275  void level_to_order_exponential_slow ( int dim_num, int level[], int rule[],
276  int order[] );
277  void level_to_order_linear ( int dim_num, int level[], int rule[],
278  int order[] );
279  int level_to_order_exp_cc ( int level, int growth );
280  int level_to_order_exp_f2 ( int level, int growth );
281  int level_to_order_exp_gauss ( int level, int growth );
282  int level_to_order_exp_gp ( int level, int growth );
283  int level_to_order_exp_hgk ( int level, int growth );
284  int level_to_order_linear_nn ( int level, int growth );
285  int level_to_order_linear_wn ( int level, int growth );
286 
287 
288  void nc_compute ( int n, double x_min, double x_max, double x[], double w[] );
289  double *nc_compute_new ( int n, double x_min, double x_max, double x[] );
290 
291  void ncc_compute_points ( int n, double x[] );
292  void ncc_compute_weights ( int n, double w[] );
293 
294  void nco_compute_points ( int n, double x[] );
295  void nco_compute_weights ( int n, double w[] );
296 
297  void ncoh_compute_points ( int n, double x[] );
298  void ncoh_compute_weights ( int n, double w[] );
299 
300  void patterson_lookup ( int n, double x[], double w[] );
301  void patterson_lookup_points ( int n, double x[] );
302  void patterson_lookup_points_np ( int n, int np, double p[], double x[] );
303  void patterson_lookup_weights ( int n, double w[] );
304  void patterson_lookup_weights_np ( int n, int np, double p[], double w[] );
305 
306  int point_radial_tol_unique_count ( int m, int n, double a[], double tol,
307  int *seed );
308  void point_radial_tol_unique_count_inc1 ( int m, int n1, double a1[],
309  double tol, int *seed, double z[], double r1[], int indx1[], bool unique1[],
310  int *unique_num1 );
311  void point_radial_tol_unique_count_inc2 ( int m, int n1, double a1[], int n2,
312  double a2[], double tol, double z[], double r1[], int indx1[], bool unique1[],
313  int *unique_num2 );
314  int point_radial_tol_unique_index ( int m, int n, double a[], double tol,
315  int *seed, int undx[], int xdnu[] );
316  void point_radial_tol_unique_index_inc1 ( int m, int n1, double a1[],
317  double tol, int *seed, double z[], double r1[], int indx1[], bool unique1[],
318  int *unique_num1, int undx1[], int xdnu1[] );
319  void point_radial_tol_unique_index_inc2 ( int m, int n1, double a1[], int n2,
320  double a2[], double tol, double z[], double r1[], int indx1[], bool unique1[],
321  int unique_num1, int undx1[], int xdnu1[], double r2[],
322  int indx2[], bool unique2[], int *unique_num2, int undx2[], int xdnu2[] );
323  void point_radial_tol_unique_index_inc3 ( int m, int n1, double a1[],
324  double r1[], int indx1[], bool unique1[], int unique_num1, int undx1[],
325  int xdnu1[], int n2, double a2[], double r2[], int indx2[], bool unique2[],
326  int unique_num2, int undx2[], int xdnu2[], int *n3, double a3[], double r3[],
327  int indx3[], bool unique3[], int *unique_num3, int undx3[], int xdnu3[] );
328 
329  void point_unique_index ( int m, int n, double a[], int unique_num, int undx[],
330  int xdnu[] );
331 
332  void product_mixed_weight ( int dim_num, int order_1d[], int order_nd,
333  int rule[], double alpha[], double beta[], double weight_nd[] );
334 
335  double r8_abs ( double x );
336  double r8_ceiling ( double x );
337  double r8_choose ( int n, int k );
338  double r8_epsilon ( );
339  double r8_factorial ( int n );
340  double r8_factorial2 ( int n );
341  double r8_floor ( double x );
342  double r8_gamma ( double x );
343  double r8_huge ( );
344  double r8_hyper_2f1 ( double a, double b, double c, double x );
345  double r8_max ( double x, double y );
346  double r8_min ( double x, double y );
347  double r8_mop ( int i );
348  double r8_psi ( double xx );
349  double r8_sign ( double x );
350 
351  int r8col_compare ( int m, int n, double a[], int i, int j );
352  void r8col_sort_heap_a ( int m, int n, double a[] );
353  int *r8col_sort_heap_index_a ( int m, int n, double a[] );
354  int r8col_sorted_unique_count ( int m, int n, double a[], double tol );
355  void r8col_swap ( int m, int n, double a[], int j1, int j2 );
356  void r8col_tol_undex ( int x_dim, int x_num, double x_val[], int x_unique_num,
357  double tol, int undx[], int xdnu[] );
358  int r8col_tol_unique_count ( int m, int n, double a[], double tol );
359  void r8col_undex ( int x_dim, int x_num, double x_val[], int x_unique_num,
360  double tol, int undx[], int xdnu[] );
361  void r8col_unique_index ( int m, int n, double a[], double tol,
362  int unique_index[] );
363 
364  void r8mat_transpose_print ( int m, int n, double a[], std::string title );
365  void r8mat_transpose_print_some ( int m, int n, double a[], int ilo, int jlo,
366  int ihi, int jhi, std::string title );
367  void r8mat_write ( std::string output_filename, int m, int n, double table[] );
368 
369  double r8poly_ant_val ( int n, double poly_cof[], double xval );
370 
371  double *r8vec_chebyshev_new ( int n, double a_first, double a_last );
372  int r8vec_compare ( int n, double a[], double b[] );
373  void r8vec_copy ( int n, double a1[], double a2[] );
374  double *r8vec_copy_new ( int n, double a1[] );
375  double r8vec_diff_norm_li ( int n, double a[], double b[] );
376  void r8vec_direct_product2 ( int factor_index, int factor_order,
377  double factor_value[], int factor_num, int point_num, double w[] );
378  double r8vec_dot_product ( int n, double a1[], double a2[] );
379  double r8vec_i4vec_dot_product ( int n, double r8vec[], int i4vec[] );
380  void r8vec_index_sorted_range ( int n, double r[], int indx[], double r_lo,
381  double r_hi, int *i_lo, int *i_hi );
382  void r8vec_indexed_heap_d ( int n, double a[], int indx[] );
383  int r8vec_indexed_heap_d_extract ( int *n, double a[], int indx[] );
384  void r8vec_indexed_heap_d_insert ( int *n, double a[], int indx[],
385  int indx_insert );
386  int r8vec_indexed_heap_d_max ( int n, double a[], int indx[] );
387  double *r8vec_legendre_new ( int n, double a_first, double a_last );
388  double *r8vec_linspace_new ( int n, double a_first, double a_last );
389  double r8vec_min ( int n, double r8vec[] );
390  double r8vec_min_pos ( int n, double a[] );
391  void r8vec_print ( int n, double a[], std::string title );
392  void r8vec_scale ( double s, int n, double a[] );
393  void r8vec_sort_heap_index_a ( int n, double a[], int indx[] );
394  int *r8vec_sort_heap_index_a_new ( int n, double a[] );
395  void r8vec_stutter ( int n, double a[], int m, double am[] );
396  double r8vec_sum ( int n, double a[] );
397  void r8vec_uniform_01 ( int n, int *seed, double r[] );
398  double *r8vec_uniform_01_new ( int n, int *seed );
399  void r8vec_zero ( int n, double a[] );
400 
401  void sort_heap_external ( int n, int *indx, int *i, int *j, int isgn );
402 
403  void timestamp ( );
404 
405  void vec_colex_next3 ( int dim_num, int base[], int a[], bool *more );
406 }; // class SandiaRules
407 
408 } // namespace ROL
409 
410 #include "ROL_SandiaRulesDef.hpp"
411 #endif
void r8vec_direct_product2(int factor_index, int factor_order, double factor_value[], int factor_num, int point_num, double w[])
void level_growth_to_order(int dim_num, int level[], int rule[], int growth[], int order[])
void legendre_compute_points_np(int order, int np, double p[], double x[])
bool i4vec_any_lt(int n, int a[], int b[])
void i4mat_transpose_print(int m, int n, int a[], std::string title)
void nco_compute_weights(int n, double w[])
void hermite_compute_np(int order, int np, double p[], double x[], double w[])
void legendre_compute_np(int order, int np, double p[], double x[], double w[])
void r8vec_indexed_heap_d_insert(int *n, double a[], int indx[], int indx_insert)
void binary_vector_next(int n, int bvec[])
void point_radial_tol_unique_index_inc1(int m, int n1, double a1[], double tol, int *seed, double z[], double r1[], int indx1[], bool unique1[], int *unique_num1, int undx1[], int xdnu1[])
void patterson_lookup_weights(int n, double w[])
void chebyshev2_compute_np(int order, int np, double p[], double x[], double w[])
void fejer2_compute(int order, double x[], double w[])
void gegenbauer_compute_np(int order, int np, double p[], double x[], double w[])
void laguerre_compute_points(int order, double x[])
double legendre_integral(int expon)
void gen_hermite_dr_compute(int order, double alpha, double x[], double w[])
void hce_compute_np(int n, int np, double p[], double x[], double w[])
double gegenbauer_integral(int expon, double alpha)
double gen_laguerre_integral(int expon, double alpha)
void gen_laguerre_compute_points(int order, double alpha, double x[])
void laguerre_lookup(int n, double x[], double w[])
void gen_hermite_compute_weights(int order, double alpha, double w[])
void hcc_compute_points(int n, double x[])
void r8vec_print(int n, double a[], std::string title)
void hermite_gk18_lookup_points(int n, double x[])
void ccn_compute_np(int n, int np, double p[], double x[], double w[])
double r8_sign(double x)
void hermite_lookup(int n, double x[], double w[])
void level_to_order_default(int dim_num, int level[], int rule[], int order[])
double r8vec_sum(int n, double a[])
void hermite_lookup_points(int n, double x[])
void chebyshev1_compute_points(int order, double x[])
void r8col_swap(int m, int n, double a[], int j1, int j2)
void sort_heap_external(int n, int *indx, int *i, int *j, int isgn)
double r8_gamma(double x)
double r8_min(double x, double y)
void jacobi_compute_points(int order, double alpha, double beta, double x[])
void laguerre_lookup_weights(int n, double w[])
void hce_compute_points(int n, double x[])
void r8col_unique_index(int m, int n, double a[], double tol, int unique_index[])
void jacobi_compute_weights(int order, double alpha, double beta, double w[])
void level_to_order_exponential(int dim_num, int level[], int rule[], int order[])
void chebyshev1_compute_np(int order, int np, double p[], double x[], double w[])
void gen_laguerre_compute(int order, double alpha, double x[], double w[])
double laguerre_integral(int expon)
void hce_compute_points_np(int n, int np, double p[], double x[])
void hermite_compute_points(int order, double x[])
double * nc_compute_new(int n, double x_min, double x_max, double x[])
void hermite_gk22_lookup_points(int n, double x[])
void gen_hermite_compute(int order, double alpha, double x[], double w[])
int r8col_tol_unique_count(int m, int n, double a[], double tol)
void fejer2_compute_weights(int order, double w[])
void ncoh_compute_points(int n, double x[])
void r8vec_index_sorted_range(int n, double r[], int indx[], double r_lo, double r_hi, int *i_lo, int *i_hi)
void ccn_compute(int n, double x[], double w[])
int * i4vec_copy_new(int n, int a1[])
void hcc_compute(int n, double x[], double w[])
void gegenbauer_root(double *x, int order, double alpha, double *dp2, double *p1, double c[])
void legendre_dr_compute(int order, double x[], double w[])
int r8vec_compare(int n, double a[], double b[])
void legendre_lookup(int n, double x[], double w[])
void r8vec_sort_heap_index_a(int n, double a[], int indx[])
void gegenbauer_recur(double *p2, double *dp2, double *p1, double x, int order, double alpha, double c[])
void legendre_compute_weights(int order, double w[])
double * r8vec_chebyshev_new(int n, double a_first, double a_last)
double gen_hermite_integral(int expon, double alpha)
void gegenbauer_compute_points(int order, double alpha, double x[])
void hermite_interpolant(int n, double x[], double y[], double yp[], double xd[], double yd[], double xdp[], double ydp[])
int i4vec_product(int n, int a[])
void hermite_compute_points_np(int order, int np, double p[], double x[])
int i4_power(int i, int j)
void i4vec_zero(int n, int a[])
void dif_shift_x(int nd, double xd[], double yd[], double xv)
void laguerre_lookup_points(int n, double x[])
void clenshaw_curtis_compute_points_np(int order, int np, double p[], double x[])
void gegenbauer_compute_weights(int order, double alpha, double w[])
void hermite_compute_weights_np(int order, int np, double p[], double w[])
void gen_laguerre_compute_points_np(int order, int np, double p[], double x[])
void patterson_lookup_points(int n, double x[])
void level_to_order_linear(int dim_num, int level[], int rule[], int order[])
int level_to_order_exp_hgk(int level, int growth)
void i4vec_copy(int n, int a1[], int a2[])
void laguerre_compute_weights(int order, double w[])
void hcc_compute_points_np(int n, int np, double p[], double x[])
void dif_shift_zero(int nd, double xd[], double yd[])
void gen_laguerre_compute_weights(int order, double alpha, double w[])
void legendre_lookup_weights(int n, double w[])
void fejer2_compute_points_np(int order, int np, double p[], double x[])
void gen_hermite_compute_points(int order, double alpha, double x[])
double r8_hyper_2f1(double a, double b, double c, double x)
void fejer2_compute_weights_np(int order, int np, double p[], double w[])
int point_radial_tol_unique_index(int m, int n, double a[], double tol, int *seed, int undx[], int xdnu[])
void level_to_order_exponential_slow(int dim_num, int level[], int rule[], int order[])
void clenshaw_curtis_compute_weights(int order, double w[])
double r8_psi(double xx)
void clenshaw_curtis_compute(int order, double x[], double w[])
void ccn_compute_points_np(int n, int np, double p[], double x[])
void fejer2_compute_np(int order, int np, double p[], double x[], double w[])
void point_radial_tol_unique_count_inc1(int m, int n1, double a1[], double tol, int *seed, double z[], double r1[], int indx1[], bool unique1[], int *unique_num1)
void gen_hermite_compute_np(int order, int np, double p[], double x[], double w[])
double jacobi_integral(int expon, double alpha, double beta)
void laguerre_compute_points_np(int order, int np, double p[], double x[])
void laguerre_ss_compute(int order, double x[], double w[])
void laguerre_compute_np(int order, int np, double p[], double x[], double w[])
void i4mat_copy(int m, int n, int a1[], int a2[])
void vec_colex_next3(int dim_num, int base[], int a[], bool *more)
void r8col_undex(int x_dim, int x_num, double x_val[], int x_unique_num, double tol, int undx[], int xdnu[])
double * legendre_zeros(int order)
void gen_laguerre_ss_recur(double *p2, double *dp2, double *p1, double x, int order, double alpha, double b[], double c[])
void point_radial_tol_unique_index_inc3(int m, int n1, double a1[], double r1[], int indx1[], bool unique1[], int unique_num1, int undx1[], int xdnu1[], int n2, double a2[], double r2[], int indx2[], bool unique2[], int unique_num2, int undx2[], int xdnu2[], int *n3, double a3[], double r3[], int indx3[], bool unique3[], int *unique_num3, int undx3[], int xdnu3[])
void ncoh_compute_weights(int n, double w[])
void patterson_lookup(int n, double x[], double w[])
void clenshaw_curtis_compute_weights_np(int order, int np, double p[], double w[])
void ccn_compute_points(int n, double x[])
void gen_hermite_compute_points_np(int order, int np, double p[], double x[])
void gen_laguerre_ss_root(double *x, int order, double alpha, double *dp2, double *p1, double b[], double c[])
void hc_compute_weights_from_points(int nhalf, double x[], double w[])
double * r8vec_uniform_01_new(int n, int *seed)
void hce_compute_weights(int n, double w[])
void imtqlx(int n, double d[], double e[], double z[])
double r8vec_min_pos(int n, double a[])
void hermite_genz_keister_lookup(int n, double x[], double w[])
void hce_compute_weights_np(int n, int np, double p[], double w[])
void hermite_gk24_lookup_points(int n, double x[])
void i4mat_write(std::string output_filename, int m, int n, int table[])
int * i4vec_add_new(int n, int a[], int b[])
void laguerre_compute(int n, double x[], double w[])
void chebyshev2_compute_weights_np(int order, int np, double p[], double w[])
void r8mat_transpose_print_some(int m, int n, double a[], int ilo, int jlo, int ihi, int jhi, std::string title)
void laguerre_compute_weights_np(int order, int np, double p[], double w[])
int level_to_order_linear_nn(int level, int growth)
void jacobi_ss_compute(int order, double alpha, double beta, double x[], double w[])
void gen_laguerre_compute_np(int order, int np, double p[], double x[], double w[])
void hermite_ss_root(double *x, int order, double *dp2, double *p1)
void jacobi_compute(int order, double alpha, double beta, double x[], double w[])
void i4vec_print(int n, int a[], std::string title)
void hce_compute(int n, double x[], double w[])
void hermite_interpolant_rule(int n, double a, double b, double x[], double w[])
void hcc_compute_weights(int n, double w[])
void jacobi_ss_recur(double *p2, double *dp2, double *p1, double x, int order, double alpha, double beta, double b[], double c[])
void nc_compute(int n, double x_min, double x_max, double x[], double w[])
int * i4mat_copy_new(int m, int n, int a1[])
int i4vec_sum(int n, int a[])
void jacobi_compute_points_np(int order, int np, double p[], double x[])
void ccn_compute_weights_np(int n, int np, double p[], double w[])
void chebyshev1_compute_weights(int order, double w[])
int level_to_order_exp_f2(int level, int growth)
int level_to_order_linear_wn(int level, int growth)
void r8vec_zero(int n, double a[])
void legendre_compute_weights_np(int order, int np, double p[], double w[])
void chebyshev1_compute(int order, double x[], double w[])
double r8_abs(double x)
void nco_compute_points(int n, double x[])
void hcc_compute_weights_np(int n, int np, double p[], double w[])
void chebyshev1_compute_weights_np(int order, int np, double p[], double w[])
void hermite_genz_keister_lookup_points(int n, double x[])
void r8col_tol_undex(int x_dim, int x_num, double x_val[], int x_unique_num, double tol, int undx[], int xdnu[])
double r8_choose(int n, int k)
void chebyshev2_compute_points_np(int order, int np, double p[], double x[])
void legendre_lookup_points(int n, double x[])
int r8vec_indexed_heap_d_extract(int *n, double a[], int indx[])
void ncc_compute_weights(int n, double w[])
double * r8vec_legendre_new(int n, double a_first, double a_last)
void r8mat_write(std::string output_filename, int m, int n, double table[])
void r8vec_stutter(int n, double a[], int m, double am[])
void chebyshev2_compute_weights(int order, double w[])
int * r8vec_sort_heap_index_a_new(int n, double a[])
void hermite_genz_keister_lookup_points_np(int n, int np, double p[], double x[])
double hermite_integral(int n)
void laguerre_ss_root(double *x, int order, double *dp2, double *p1, double b[], double c[])
void point_unique_index(int m, int n, double a[], int unique_num, int undx[], int xdnu[])
int level_to_order_exp_gauss(int level, int growth)
int i4_min(int i1, int i2)
void hermite_ss_recur(double *p2, double *dp2, double *p1, double x, int order)
void jacobi_compute_np(int order, int np, double p[], double x[], double w[])
double r8vec_diff_norm_li(int n, double a[], double b[])
int point_radial_tol_unique_count(int m, int n, double a[], double tol, int *seed)
void jacobi_compute_weights_np(int order, int np, double p[], double w[])
void dif_deriv(int nd, double xd[], double yd[], int *ndp, double xdp[], double ydp[])
void hermite_genz_keister_lookup_weights(int n, double w[])
int r8col_compare(int m, int n, double a[], int i, int j)
void hermite_lookup_weights(int n, double w[])
void point_radial_tol_unique_count_inc2(int m, int n1, double a1[], int n2, double a2[], double tol, double z[], double r1[], int indx1[], bool unique1[], int *unique_num2)
int r8col_sorted_unique_count(int m, int n, double a[], double tol)
int level_to_order_exp_gp(int level, int growth)
int i4_max(int i1, int i2)
void laguerre_ss_recur(double *p2, double *dp2, double *p1, double x, int order, double b[], double c[])
void hermite_genz_keister_lookup_weights_np(int n, int np, double p[], double w[])
double r8vec_i4vec_dot_product(int n, double r8vec[], int i4vec[])
void r8vec_copy(int n, double a1[], double a2[])
void patterson_lookup_points_np(int n, int np, double p[], double x[])
void fejer2_compute_points(int order, double x[])
void patterson_lookup_weights_np(int n, int np, double p[], double w[])
int r8vec_indexed_heap_d_max(int n, double a[], int indx[])
int * r8col_sort_heap_index_a(int m, int n, double a[])
double chebyshev1_integral(int expon)
void gegenbauer_compute(int order, double alpha, double x[], double w[])
void clenshaw_curtis_compute_points(int order, double x[])
void legendre_compute_points(int order, double x[])
void r8col_sort_heap_a(int m, int n, double a[])
double * r8vec_linspace_new(int n, double a_first, double a_last)
double r8vec_min(int n, double r8vec[])
void hermite_compute_weights(int order, double w[])
void hermite_ss_compute(int order, double x[], double w[])
void ncc_compute_points(int n, double x[])
void chebyshev2_compute(int order, double x[], double w[])
void legendre_compute(int n, double x[], double w[])
double * r8vec_copy_new(int n, double a1[])
void i4mat_transpose_print_some(int m, int n, int a[], int ilo, int jlo, int ihi, int jhi, std::string title)
void r8vec_indexed_heap_d(int n, double a[], int indx[])
void chebyshev1_compute_points_np(int order, int np, double p[], double x[])
void hcc_compute_np(int n, int np, double p[], double x[], double w[])
void product_mixed_weight(int dim_num, int order_1d[], int order_nd, int rule[], double alpha[], double beta[], double weight_nd[])
double r8_ceiling(double x)
double r8_max(double x, double y)
double r8vec_dot_product(int n, double a1[], double a2[])
int level_to_order_exp_cc(int level, int growth)
void dif_to_r8poly(int nd, double xd[], double yd[], double c[])
void ccn_compute_weights(int n, double w[])
void hermite_compute(int order, double x[], double w[])
void gegenbauer_compute_points_np(int order, int np, double p[], double x[])
void gen_laguerre_ss_compute(int order, double alpha, double x[], double w[])
void comp_next(int n, int k, int a[], bool *more, int *h, int *t)
void r8vec_scale(double s, int n, double a[])
void i4vec_min_mv(int m, int n, int u[], int v[], int w[])
void r8mat_transpose_print(int m, int n, double a[], std::string title)
double r8poly_ant_val(int n, double poly_cof[], double xval)
void jacobi_ss_root(double *x, int order, double alpha, double beta, double *dp2, double *p1, double b[], double c[])
void gen_laguerre_compute_weights_np(int order, int np, double p[], double w[])
void r8vec_uniform_01(int n, int *seed, double r[])
void point_radial_tol_unique_index_inc2(int m, int n1, double a1[], int n2, double a2[], double tol, double z[], double r1[], int indx1[], bool unique1[], int unique_num1, int undx1[], int xdnu1[], double r2[], int indx2[], bool unique2[], int *unique_num2, int undx2[], int xdnu2[])
void hermite_interpolant_value(int nd, double xd[], double yd[], double xdp[], double ydp[], int nv, double xv[], double yv[], double yvp[])
void clenshaw_curtis_compute_np(int order, int np, double p[], double x[], double w[])
void gen_hermite_compute_weights_np(int order, int np, double p[], double w[])
double chebyshev2_integral(int expon)
void gegenbauer_compute_weights_np(int order, int np, double p[], double w[])
int i4_choose(int n, int k)
double r8_floor(double x)
void chebyshev2_compute_points(int order, double x[])