diff options
| author | Andre Vieira <andre.simoesdiasvieira@arm.com> | 2018-06-22 14:59:21 +0000 |
|---|---|---|
| committer | Andre Vieira <andre.simoesdiasvieira@arm.com> | 2018-06-22 14:59:21 +0000 |
| commit | 80bb895d235d82f30bb097050acc82470b53cf52 (patch) | |
| tree | d887d893f39d16e4990a853d3398dfc48433430f | |
| parent | 701c5838e5f5999de48c3b2c9f2e10b453a78f88 (diff) | |
| parent | 8483773478af7ea732b52a98e325a07608777ebe (diff) | |
Merge from gcc-7-branch.ARM/embedded-7-branch-2018q2ARM/embedded-7-branch
git-svn-id: https://gcc.gnu.org/svn/gcc/branches/ARM/embedded-7-branch@261903 138bc75d-0d04-0410-961f-82ee72b054a4
224 files changed, 14431 insertions, 13743 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 220d222986c..37d23da6c5e 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,281 @@ +2018-06-22 Andre Vieira <andre.simoesdiasvieira@arm.com> + + Backport from mainline + 2018-06-05 Andre Vieira <andre.simoesdiasvieira@arm.com> + + * config/arm/arm_cmse.h (cmse_nsfptr_create): Change typeof to + __typeof__. + (cmse_check_pointed_object): Likewise. + +2018-06-22 Andre Vieira <andre.simoesdiasvieira@arm.com> + + Backport from mainline + 2018-05-17 Jerome Lambourg <lambourg@adacore.com> + + * config/arm/arm_cmse.h (cmse_nsfptr_create, cmse_is_nsfptr): Remove + #include <stdint.h>. Replace intptr_t with __INTPTR_TYPE__. + +2018-06-21 Sebastian Huber <sebastian.huber@embedded-brains.de> + + Backport from mainline + 2018-06-15 Sebastian Huber <sebastian.huber@embedded-brains.de> + + * config.gcc (riscv*-*-elf* | riscv*-*-rtems*): Use custom + multilibs for *-*-rtems*. + * config/riscv/t-rtems: New file. + +2018-06-19 Max Filippov <jcmvbkbc@gmail.com> + + Backport from mainline + 2018-06-19 Max Filippov <jcmvbkbc@gmail.com> + + * config/xtensa/xtensa.md (UNSPEC_FRAME_BLOCKAGE): New unspec + constant. + (allocate_stack, frame_blockage, *frame_blockage): New patterns. + +2018-06-19 Eric Botcazou <ebotcazou@adacore.com> + + * gimplify.c (gimplify_init_constructor): Really never clear for an + incomplete constructor if CONSTRUCTOR_NO_CLEARING is set. + +2018-06-18 Martin Sebor <msebor@redhat.com> + + PR middle-end/82063 + * calls.c (alloc_max_size): Correct a logic error/typo. + Treat excessive arguments as infinite. Warn for invalid arguments. + * doc/invoke.texi (-Walloc-size-larger-than): Update. + +2018-06-14 Sebastian Huber <sebastian.huber@embedded-brains.de> + + Backport from mainline + 2018-06-14 Sebastian Huber <sebastian.huber@embedded-brains.de> + + * config/rtems.h (STDINT_LONG32): Define. + +2018-06-11 Peter Bergner <bergner@vnet.ibm.com> + + Backport from mainline + 2018-06-08 Peter Bergner <bergner@vnet.ibm.com> + + PR target/85755 + * config/rs6000/rs6000.c (mem_operand_gpr): Enable PRE_INC and PRE_DEC + addresses. + +2018-06-07 Peter Bergner <bergner@vnet.ibm.com> + + Backport from mainline + 2018-06-06 Peter Bergner <bergner@vnet.ibm.com> + + PR target/63177 + * /config/rs6000/rs6000.h (ASM_CPU_SPEC): Add support for -mpower9. + Don't handle -mcpu=power8 if -mpower9-vector is also used. + +2018-06-07 Richard Biener <rguenther@suse.de> + + Backport from mainline + 2018-05-04 Richard Biener <rguenther@suse.de> + + PR middle-end/85588 + * fold-const.c (negate_expr_p): Restrict negation of operand + zero of a division to when we know that can happen without + overflow. + (fold_negate_expr_1): Likewise. + + 2018-05-02 Richard Biener <rguenther@suse.de> + + PR middle-end/85567 + * gimplify.c (gimplify_save_expr): When in SSA form allow + SAVE_EXPRs to compute to SSA vars. + + 2018-05-02 Richard Biener <rguenther@suse.de> + + PR tree-optimization/85597 + * tree-vect-stmts.c (vectorizable_operation): For ternary SLP + do not use split vect_get_vec_defs call but call vect_get_slp_defs + directly. + +2018-06-05 Andreas Krebbel <krebbel@linux.ibm.com> + + Backport from mainline + 2018-06-05 Andreas Krebbel <krebbel@linux.ibm.com> + + * config/s390/s390-builtin-types.def: Add void function type. + * config/s390/s390-builtins.def: Use the function type for the + tbeginc builtin. + +2018-06-01 Bill Schmidt <wschmidt@linux.ibm.com> + + PR tree-optimization/85712 + Backport from mainline: + 2018-05-23 Bill Schmidt <wschmidt@linux.ibm.com> + + PR tree-optimization/85712 + * gimple-ssa-strength-reduction.c (struct slsr_cand_d): Add + first_interp field. + (alloc_cand_and_find_basis): Initialize first_interp field. + (slsr_process_mul): Modify first_interp field. + (slsr_process_add): Likewise. + (slsr_process_cast): Modify first_interp field for each new + interpretation. + (slsr_process_copy): Likewise. + (dump_candidate): Dump first_interp field. + (replace_mult_candidate): Process all interpretations, not just + subsequent ones. + (replace_rhs_if_not_dup): Likewise. + (replace_one_candidate): Likewise. + + Backport from mainline: + 2018-05-25 Bill Schmidt <wschmidt@linux.ibm.com> + + PR tree-optimization/85712 + * gimple-ssa-strength-reduction.c (replace_one_candidate): Skip if + this candidate has already been replaced in-situ by a copy. + +2018-05-24 Uros Bizjak <ubizjak@gmail.com> + + * config/i386/sse.md (cvtusi2<ssescalarmodesuffix>64<round_name>): + Add {q} suffix to insn mnemonic. + +2018-05-24 Uros Bizjak <ubizjak@gmail.com> + + PR target/85903 + * config/i386/sse.md (movdi_to_sse): Do not generate pseudo + when memory input operand is handled. + +2018-05-21 Pat Haugen <pthaugen@us.ibm.com> + + Backport from mainline + 2018-05-17 Pat Haugen <pthaugen@us.ibm.com> + Segher Boessenkool <segher@kernel.crashing.org> + + PR target/85698 + * config/rs6000/rs6000.c (rs6000_output_move_128bit): Check + dest operand. + +2018-05-17 Martin Jambor <mjambor@suse.cz> + + Backport from mainline + 2018-05-11 Martin Jambor <mjambor@suse.cz> + + PR ipa/85655 + * ipa-cp.c (intersect_with_plats): Check that the lattice contains + single const. + +2018-05-01 Tom de Vries <tom@codesourcery.com> + + backport from trunk: + 2018-04-16 Cesar Philippidis <cesar@codesourcery.com> + Tom de Vries <tom@codesourcery.com> + + PR middle-end/84955 + * omp-expand.c (expand_oacc_for): Add dummy false branch for + tiled basic blocks without omp continue statements. + +2018-04-26 Richard Biener <rguenther@suse.de> + + Backport from mainline + 2018-04-09 Richard Biener <rguenther@suse.de> + + PR tree-optimization/85284 + * tree-ssa-loop-niter.c (number_of_iterations_exit_assumptions): + Only use the niter constraining form of simple_iv when the exit + is always executed. + + 2018-04-06 Richard Biener <rguenther@suse.de> + + PR middle-end/85244 + * tree-dfa.c (get_ref_base_and_extent): Reset seen_variable_array_ref + after seeing a component reference with an adjacent field. Treat + refs to arrays at struct end of external decls similar to + refs to unconstrained commons. + + 2018-04-04 Richard Biener <rguenther@suse.de> + + PR tree-optimization/85168 + * tree-ssa-sccvn.c (vn_reference_maybe_forwprop_address): Avoid + propagating abnormals. + +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-04-17 Martin Liska <mliska@suse.cz> + + PR lto/85405 + * ipa-devirt.c (odr_types_equivalent_p): Remove trailing + in message, remote space in between '_G' and '('. + +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-04-17 Jan Hubicka <jh@suse.cz> + + PR lto/85405 + * ipa-devirt.c (odr_types_equivalent_p): Handle bit fields. + +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-03-28 Jakub Jelinek <jakub@redhat.com> + Martin Liska <mliska@suse.cz> + + PR sanitizer/85081 + * gimplify.c (asan_poison_variable): Don't do the check for + gimplify_omp_ctxp here. + (gimplify_decl_expr): Do it here. + (gimplify_target_expr): Likewise. + +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-03-21 Martin Liska <mliska@suse.cz> + + PR ipa/84963 + * ipa-icf.c (sem_item_optimizer::fixup_points_to_sets): Remove + not intended return statement. + +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-03-13 Martin Liska <mliska@suse.cz> + + PR ipa/84658. + * (sem_item_optimizer::sem_item_optimizer): Initialize new + vector. + (sem_item_optimizer::~sem_item_optimizer): Release it. + (sem_item_optimizer::merge_classes): Register variable aliases. + (sem_item_optimizer::fixup_pt_set): New function. + (sem_item_optimizer::fixup_points_to_sets): Likewise. + * ipa-icf.h: Declare new variables and functions. + +2018-04-23 Aaron Sawdey <acsawdey@linux.ibm.com> + + Backport from mainline + 2018-04-16 Aaron Sawdey <acsawdey@linux.ibm.com> + + PR target/83660 + * config/rs6000/rs6000-c.c (altivec_resolve_overloaded_builtin): Mark + vec_extract expression as having side effects to make sure it gets + a cleanup point. + +2018-04-23 Eric Botcazou <ebotcazou@adacore.com> + + PR middle-end/85496 + * expr.c (store_field): In the bitfield case, if the value comes from + a function call and is returned in registers by means of a PARALLEL, + do not change the mode of the temporary unless BLKmode and VOIDmode. + +2018-04-20 Peter Bergner <bergner@vnet.ibm.com> + + Backport from mainline + 2018-03-09 Peter Bergner <bergner@vnet.ibm.com> + + PR target/83969 + * config/rs6000/rs6000.c (rs6000_offsettable_memref_p): New prototype. + Add strict argument and use it. + (rs6000_split_multireg_move): Update for new strict argument. + (mem_operand_gpr): Disallow all non-offsettable addresses. + * config/rs6000/rs6000.md (*movdi_internal64): Use YZ constraint. + 2018-04-18 Thomas Preud'homme <thomas.preudhomme@arm.com> Backport from mainline diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 4a263217f2d..29a22e10baa 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20180418 +20180622 diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index da154469753..cda6b623efb 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,60 @@ +2018-06-12 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/ada-tree.h (TYPE_RETURN_BY_DIRECT_REF_P): Change from + using TYPE_LANG_FLAG_4 to using TYPE_LANG_FLAG_0. + (TYPE_ALIGN_OK): Move around. + (TYPE_PADDING_FOR_COMPONENT): Remove superfluous parentheses. + * gcc-interface/decl.c (change_qualified_type): Move to... + (gnat_to_gnu_entity): Adjust comment. + * gcc-interface/gigi.h (change_qualified_type): ...here; make inline. + (ceil_pow2): Use ceil_log2. + * gcc-interface/utils.c (finish_subprog_decl): Add couple of comments + and do not set TREE_SIDE_EFFECTS. + (handle_noreturn_attribute): Use change_qualified_type. + +2018-06-12 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/decl.c (gnat_to_gnu_entity) <E_Constant>: Do not get + the expression of a dispatch table that is not being defined. + <E_Record_Subtype>: Remove obsolete kludge. + +2018-06-12 Eric Botcazou <ebotcazou@adacore.com> + + Backpor from mainline + 2018-06-02 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/decl.c (gnat_to_gnu_entity) <E_Constant>: If this is + not a definition, retrieve the expression only if it's a compile-time + known value if we are just annotating types. + + * gcc-interface/utils.c (convert): Do not try to upcast properly for a + conversion between tagged types in type_annotate_only mode. + +2018-06-12 Eric Botcazou <ebotcazou@adacore.com> + + Backport from mainline + 2018-06-11 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/decl.c (gnat_to_gnu_entity) <E_Array_Type>: Reuse the + existing fields of a dummy fat pointer type, if any. Clear the + TYPE_DECL_SUPPRESS_DEBUG on the fat pointer type after completing it. + +2018-06-02 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/ada-tree.h (TYPE_PADDING_FOR_COMPONENT): New macro. + * gcc-interface/decl.c (gnat_to_gnu_component_type): Cache the padding + type built for an aliased component with variable size. + +2018-06-02 Eric Botcazou <ebotcazou@adacore.com> + + Backport from mainline + 2018-05-31 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/trans.c (Call_to_gnu): If this is a function call and + there is no target, also create a temporary for the return value for + an allocator if the type is an unconstrained record type with default + discriminant. + 2018-04-12 Sebastian Huber <sebastian.huber@embedded-brains.de> Backport from mainline diff --git a/gcc/ada/gcc-interface/ada-tree.h b/gcc/ada/gcc-interface/ada-tree.h index a3d38b1b22e..852e2a5138b 100644 --- a/gcc/ada/gcc-interface/ada-tree.h +++ b/gcc/ada/gcc-interface/ada-tree.h @@ -6,7 +6,7 @@ * * * C Header File * * * - * Copyright (C) 1992-2016, Free Software Foundation, Inc. * + * Copyright (C) 1992-2018, Free Software Foundation, Inc. * * * * GNAT is free software; you can redistribute it and/or modify it under * * terms of the GNU General Public License as published by the Free Soft- * @@ -83,6 +83,12 @@ do { \ ((TREE_CODE (NODE) == INTEGER_TYPE || TREE_CODE (NODE) == ARRAY_TYPE) \ && TYPE_PACKED_ARRAY_TYPE_P (NODE)) +/* For FUNCTION_TYPEs, nonzero if the function returns by direct reference, + i.e. the callee returns a pointer to a memory location it has allocated + and the caller only needs to dereference the pointer. */ +#define TYPE_RETURN_BY_DIRECT_REF_P(NODE) \ + TYPE_LANG_FLAG_0 (FUNCTION_TYPE_CHECK (NODE)) + /* For INTEGER_TYPE, nonzero if this is a modular type with a modulus that is not equal to two to the power of its mode's size. */ #define TYPE_MODULAR_P(NODE) TYPE_LANG_FLAG_1 (INTEGER_TYPE_CHECK (NODE)) @@ -152,12 +158,6 @@ do { \ #define TYPE_CONVENTION_FORTRAN_P(NODE) \ TYPE_LANG_FLAG_4 (ARRAY_TYPE_CHECK (NODE)) -/* For FUNCTION_TYPEs, nonzero if the function returns by direct reference, - i.e. the callee returns a pointer to a memory location it has allocated - and the caller only needs to dereference the pointer. */ -#define TYPE_RETURN_BY_DIRECT_REF_P(NODE) \ - TYPE_LANG_FLAG_4 (FUNCTION_TYPE_CHECK (NODE)) - /* For RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE, nonzero if this is a dummy type, made to correspond to a private or incomplete type. */ #define TYPE_DUMMY_P(NODE) \ @@ -186,6 +186,9 @@ do { \ /* True for a dummy type if TYPE appears in a profile. */ #define TYPE_DUMMY_IN_PROFILE_P(NODE) TYPE_LANG_FLAG_6 (NODE) +/* True if objects of this type are guaranteed to be properly aligned. */ +#define TYPE_ALIGN_OK(NODE) TYPE_LANG_FLAG_7 (NODE) + /* True for types that implement a packed array and for original packed array types. */ #define TYPE_IMPL_PACKED_ARRAY_P(NODE) \ @@ -199,9 +202,6 @@ do { \ alignment value the type ought to have. */ #define TYPE_MAX_ALIGN(NODE) (TYPE_PRECISION (RECORD_OR_UNION_CHECK (NODE))) -/* True if objects of tagged types are guaranteed to be properly aligned. */ -#define TYPE_ALIGN_OK(NODE) TYPE_LANG_FLAG_7 (NODE) - /* For an UNCONSTRAINED_ARRAY_TYPE, this is the record containing both the template and the object. @@ -232,6 +232,11 @@ do { \ refer to the routine gnat_to_gnu_entity. */ #define TYPE_CI_CO_LIST(NODE) TYPE_LANG_SLOT_1 (FUNCTION_TYPE_CHECK (NODE)) +/* For an ARRAY_TYPE with variable size, this is the padding type built for + the array type when it is itself the component type of another array. */ +#define TYPE_PADDING_FOR_COMPONENT(NODE) \ + TYPE_LANG_SLOT_1 (ARRAY_TYPE_CHECK (NODE)) + /* For a VECTOR_TYPE, this is the representative array type. */ #define TYPE_REPRESENTATIVE_ARRAY(NODE) \ TYPE_LANG_SLOT_1 (VECTOR_TYPE_CHECK (NODE)) diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c index e226f256b47..d2316afc8f1 100644 --- a/gcc/ada/gcc-interface/decl.c +++ b/gcc/ada/gcc-interface/decl.c @@ -206,7 +206,6 @@ static tree gnat_to_gnu_component_type (Entity_Id, bool, bool); static tree gnat_to_gnu_subprog_type (Entity_Id, bool, bool, tree *); static tree gnat_to_gnu_field (Entity_Id, tree, int, bool, bool); static tree gnu_ext_name_for_subprog (Entity_Id, tree); -static tree change_qualified_type (tree, int); static void set_nonaliased_component_on_array_type (tree); static void set_reverse_storage_order_on_array_type (tree); static bool same_discriminant_p (Entity_Id, Entity_Id); @@ -592,17 +591,22 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) /* If we have a constant that we are not defining, get the expression it was defined to represent. This is necessary to avoid generating dumb elaboration code in simple cases, but we may throw it away later if it - is not a constant. But do not retrieve it if it is an allocator since - the designated type might still be dummy at this point. */ + is not a constant. But do not do it for dispatch tables because they + are only referenced indirectly and we need to have a consistent view + of the exported and of the imported declarations of the tables from + external units for them to be properly merged in LTO mode. Moreover + simply do not retrieve the expression it if it is an allocator since + the designated type might still be dummy at this point. Note that we + invoke gnat_to_gnu_external and not gnat_to_gnu because the expression + may contain N_Expression_With_Actions nodes and thus declarations of + objects from other units that we need to discard. */ if (!definition && !No_Initialization (Declaration_Node (gnat_entity)) - && Present (Expression (Declaration_Node (gnat_entity))) - && Nkind (Expression (Declaration_Node (gnat_entity))) - != N_Allocator) - /* The expression may contain N_Expression_With_Actions nodes and - thus object declarations from other units. Discard them. */ - gnu_expr - = gnat_to_gnu_external (Expression (Declaration_Node (gnat_entity))); + && !Is_Dispatch_Table_Entity (gnat_entity) + && Present (gnat_temp = Expression (Declaration_Node (gnat_entity))) + && Nkind (gnat_temp) != N_Allocator + && (!type_annotate_only || Compile_Time_Known_Value (gnat_temp))) + gnu_expr = gnat_to_gnu_external (gnat_temp); /* ... fall through ... */ @@ -2063,11 +2067,16 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) { gnu_fat_type = TYPE_MAIN_VARIANT (TYPE_POINTER_TO (gnu_type)); TYPE_NAME (gnu_fat_type) = NULL_TREE; - /* Save the contents of the dummy type for update_pointer_to. */ - TYPE_POINTER_TO (gnu_type) = copy_type (gnu_fat_type); gnu_ptr_template = - TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (gnu_fat_type))); + TREE_TYPE (DECL_CHAIN (TYPE_FIELDS (gnu_fat_type))); gnu_template_type = TREE_TYPE (gnu_ptr_template); + + /* Save the contents of the dummy type for update_pointer_to. */ + TYPE_POINTER_TO (gnu_type) = copy_type (gnu_fat_type); + TYPE_FIELDS (TYPE_POINTER_TO (gnu_type)) + = copy_node (TYPE_FIELDS (gnu_fat_type)); + DECL_CHAIN (TYPE_FIELDS (TYPE_POINTER_TO (gnu_type))) + = copy_node (DECL_CHAIN (TYPE_FIELDS (gnu_fat_type))); } else { @@ -2088,29 +2097,39 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) /* Build the fat pointer type. Use a "void *" object instead of a pointer to the array type since we don't have the array type - yet (it will reference the fat pointer via the bounds). */ - tem - = create_field_decl (get_identifier ("P_ARRAY"), ptr_type_node, - gnu_fat_type, NULL_TREE, NULL_TREE, 0, 0); - DECL_CHAIN (tem) - = create_field_decl (get_identifier ("P_BOUNDS"), gnu_ptr_template, - gnu_fat_type, NULL_TREE, NULL_TREE, 0, 0); - + yet (it will reference the fat pointer via the bounds). Note + that we reuse the existing fields of a dummy type because for: + + type Arr is array (Positive range <>) of Element_Type; + type Array_Ref is access Arr; + Var : Array_Ref := Null; + + in a declarative part, Arr will be frozen only after Var, which + means that the fields used in the CONSTRUCTOR built for Null are + those of the dummy type, which in turn means that COMPONENT_REFs + of Var may be built with these fields. Now if COMPONENT_REFs of + Var are also built later with the fields of the final type, the + aliasing machinery may consider that the accesses are distinct + if the FIELD_DECLs are distinct as objects. */ if (COMPLETE_TYPE_P (gnu_fat_type)) { - /* We are going to lay it out again so reset the alias set. */ - alias_set_type alias_set = TYPE_ALIAS_SET (gnu_fat_type); - TYPE_ALIAS_SET (gnu_fat_type) = -1; - finish_fat_pointer_type (gnu_fat_type, tem); - TYPE_ALIAS_SET (gnu_fat_type) = alias_set; + tem = TYPE_FIELDS (gnu_fat_type); + TREE_TYPE (tem) = ptr_type_node; + TREE_TYPE (DECL_CHAIN (tem)) = gnu_ptr_template; + TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (gnu_fat_type)) = 0; for (t = gnu_fat_type; t; t = TYPE_NEXT_VARIANT (t)) - { - TYPE_FIELDS (t) = tem; - SET_TYPE_UNCONSTRAINED_ARRAY (t, gnu_type); - } + SET_TYPE_UNCONSTRAINED_ARRAY (t, gnu_type); } else { + tem + = create_field_decl (get_identifier ("P_ARRAY"), + ptr_type_node, gnu_fat_type, + NULL_TREE, NULL_TREE, 0, 0); + DECL_CHAIN (tem) + = create_field_decl (get_identifier ("P_BOUNDS"), + gnu_ptr_template, gnu_fat_type, + NULL_TREE, NULL_TREE, 0, 0); finish_fat_pointer_type (gnu_fat_type, tem); SET_TYPE_UNCONSTRAINED_ARRAY (gnu_fat_type, gnu_type); } @@ -3389,20 +3408,6 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) break; } - /* If this is a record subtype associated with a dispatch table, - strip the suffix. This is necessary to make sure 2 different - subtypes associated with the imported and exported views of a - dispatch table are properly merged in LTO mode. */ - if (Is_Dispatch_Table_Entity (gnat_entity)) - { - char *p; - Get_Encoded_Name (gnat_entity); - p = strchr (Name_Buffer, '_'); - gcc_assert (p); - strcpy (p+2, "dtS"); - gnu_entity_name = get_identifier (Name_Buffer); - } - /* When the subtype has discriminants and these discriminants affect the initial shape it has inherited, factor them in. But for an Unchecked_Union (it must be an Itype), just return the type. @@ -4681,7 +4686,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) /* If this is not an unconstrained array type, set some flags. */ if (TREE_CODE (gnu_type) != UNCONSTRAINED_ARRAY_TYPE) { - /* Tell the middle-end that objects of tagged types are guaranteed to + /* Record the property that objects of tagged types are guaranteed to be properly aligned. This is necessary because conversions to the class-wide type are translated into conversions to the root type, which can be less aligned than some of its derived types. */ @@ -5272,17 +5277,6 @@ gnat_to_gnu_component_type (Entity_Id gnat_array, bool definition, Is_Bit_Packed_Array (gnat_array) ? TYPE_DECL : VAR_DECL, true, Has_Component_Size_Clause (gnat_array)); - /* If the array has aliased components and the component size can be zero, - force at least unit size to ensure that the components have distinct - addresses. */ - if (!gnu_comp_size - && Has_Aliased_Components (gnat_array) - && (integer_zerop (TYPE_SIZE (gnu_type)) - || (TREE_CODE (gnu_type) == ARRAY_TYPE - && !TREE_CONSTANT (TYPE_SIZE (gnu_type))))) - gnu_comp_size - = size_binop (MAX_EXPR, TYPE_SIZE (gnu_type), bitsize_unit_node); - /* If the component type is a RECORD_TYPE that has a self-referential size, then use the maximum size for the component size. */ if (!gnu_comp_size @@ -5290,6 +5284,13 @@ gnat_to_gnu_component_type (Entity_Id gnat_array, bool definition, && CONTAINS_PLACEHOLDER_P (TYPE_SIZE (gnu_type))) gnu_comp_size = max_size (TYPE_SIZE (gnu_type), true); + /* If the array has aliased components and the component size is zero, force + the unit size to ensure that the components have distinct addresses. */ + if (!gnu_comp_size + && Has_Aliased_Components (gnat_array) + && integer_zerop (TYPE_SIZE (gnu_type))) + gnu_comp_size = bitsize_unit_node; + /* Honor the component size. This is not needed for bit-packed arrays. */ if (gnu_comp_size && !Is_Bit_Packed_Array (gnat_array)) { @@ -5312,6 +5313,30 @@ gnat_to_gnu_component_type (Entity_Id gnat_array, bool definition, gnat_array); } + /* This is a very special case where the array has aliased components and the + component size might be zero at run time. As explained above, we force at + least the unit size but we don't want to build a distinct padding type for + each invocation (they are not canonicalized if they have variable size) so + we cache this special padding type as TYPE_PADDING_FOR_COMPONENT. */ + else if (Has_Aliased_Components (gnat_array) + && TREE_CODE (gnu_type) == ARRAY_TYPE + && !TREE_CONSTANT (TYPE_SIZE (gnu_type))) + { + if (TYPE_PADDING_FOR_COMPONENT (gnu_type)) + gnu_type = TYPE_PADDING_FOR_COMPONENT (gnu_type); + else + { + gnu_comp_size + = size_binop (MAX_EXPR, TYPE_SIZE (gnu_type), bitsize_unit_node); + TYPE_PADDING_FOR_COMPONENT (gnu_type) + = maybe_pad_type (gnu_type, gnu_comp_size, 0, gnat_array, + true, false, definition, true); + gnu_type = TYPE_PADDING_FOR_COMPONENT (gnu_type); + create_type_decl (TYPE_NAME (gnu_type), gnu_type, true, debug_info_p, + gnat_array); + } + } + /* If the component type is a padded type made for a non-bit-packed array of scalars with reverse storage order, we need to propagate the reverse storage order to the padding type since it is the innermost enclosing @@ -6276,19 +6301,6 @@ gnu_ext_name_for_subprog (Entity_Id gnat_subprog, tree gnu_entity_name) return gnu_ext_name; } -/* Like build_qualified_type, but TYPE_QUALS is added to the existing - qualifiers on TYPE. */ - -static tree -change_qualified_type (tree type, int type_quals) -{ - /* Qualifiers must be put on the associated array type. */ - if (TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE) - return type; - - return build_qualified_type (type, TYPE_QUALS (type) | type_quals); -} - /* Set TYPE_NONALIASED_COMPONENT on an array type built by means of build_nonshared_array_type. */ diff --git a/gcc/ada/gcc-interface/gigi.h b/gcc/ada/gcc-interface/gigi.h index 1d87b5be44e..2b33c13302c 100644 --- a/gcc/ada/gcc-interface/gigi.h +++ b/gcc/ada/gcc-interface/gigi.h @@ -1074,7 +1074,7 @@ maybe_vector_array (tree exp) static inline unsigned HOST_WIDE_INT ceil_pow2 (unsigned HOST_WIDE_INT x) { - return (unsigned HOST_WIDE_INT) 1 << (floor_log2 (x - 1) + 1); + return (unsigned HOST_WIDE_INT) 1 << ceil_log2 (x); } /* Return true if EXP, a CALL_EXPR, is an atomic load. */ @@ -1171,3 +1171,16 @@ maybe_debug_type (tree type) return type; } + +/* Like build_qualified_type, but TYPE_QUALS is added to the existing + qualifiers on TYPE. */ + +static inline tree +change_qualified_type (tree type, int type_quals) +{ + /* Qualifiers must be put on the associated array type. */ + if (TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE) + return type; + + return build_qualified_type (type, TYPE_QUALS (type) | type_quals); +} diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c index eaad084959c..47c8a286220 100644 --- a/gcc/ada/gcc-interface/trans.c +++ b/gcc/ada/gcc-interface/trans.c @@ -4326,12 +4326,15 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, because we need to preserve the return value before copying back the parameters. - 2. There is no target and the call is made for neither an object nor a + 2. There is no target and the call is made for neither an object, nor a renaming declaration, nor a return statement, nor an allocator, and the return type has variable size because in this case the gimplifier - cannot create the temporary, or more generally is simply an aggregate - type, because the gimplifier would then create the temporary in the - outermost scope instead of locally. + cannot create the temporary, or more generally is an aggregate type, + because the gimplifier would create the temporary in the outermost + scope instead of locally. But there is an exception for an allocator + of an unconstrained record type with default discriminant because we + allocate the actual size in this case, unlike the other 3 cases, so + we need a temporary to fetch the discriminant and we create it here. 3. There is a target and it is a slice or an array with fixed size, and the return type has variable size, because the gimplifier @@ -4350,8 +4353,9 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, && Nkind (Parent (gnat_node)) != N_Object_Declaration && Nkind (Parent (gnat_node)) != N_Object_Renaming_Declaration && Nkind (Parent (gnat_node)) != N_Simple_Return_Statement - && !(Nkind (Parent (gnat_node)) == N_Qualified_Expression - && Nkind (Parent (Parent (gnat_node))) == N_Allocator) + && (!(Nkind (Parent (gnat_node)) == N_Qualified_Expression + && Nkind (Parent (Parent (gnat_node))) == N_Allocator) + || type_is_padding_self_referential (gnu_result_type)) && AGGREGATE_TYPE_P (gnu_result_type) && !TYPE_IS_FAT_POINTER_P (gnu_result_type)) || (gnu_target diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c index f362946e63a..cb2c4d22a41 100644 --- a/gcc/ada/gcc-interface/utils.c +++ b/gcc/ada/gcc-interface/utils.c @@ -3255,8 +3255,11 @@ finish_subprog_decl (tree decl, tree asm_name, tree type) DECL_BY_REFERENCE (result_decl) = TREE_ADDRESSABLE (type); DECL_RESULT (decl) = result_decl; + /* Propagate the "const" property. */ TREE_READONLY (decl) = TYPE_READONLY (type); - TREE_SIDE_EFFECTS (decl) = TREE_THIS_VOLATILE (decl) = TYPE_VOLATILE (type); + + /* Propagate the "noreturn" property. */ + TREE_THIS_VOLATILE (decl) = TYPE_VOLATILE (type); if (asm_name) { @@ -4543,9 +4546,12 @@ convert (tree type, tree expr) etype))) return build1 (VIEW_CONVERT_EXPR, type, expr); - /* If we are converting between tagged types, try to upcast properly. */ + /* If we are converting between tagged types, try to upcast properly. + But don't do it if we are just annotating types since tagged types + aren't fully laid out in this mode. */ else if (ecode == RECORD_TYPE && code == RECORD_TYPE - && TYPE_ALIGN_OK (etype) && TYPE_ALIGN_OK (type)) + && TYPE_ALIGN_OK (etype) && TYPE_ALIGN_OK (type) + && !type_annotate_only) { tree child_etype = etype; do { @@ -6113,8 +6119,7 @@ handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args), && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) TREE_TYPE (*node) = build_pointer_type - (build_type_variant (TREE_TYPE (type), - TYPE_READONLY (TREE_TYPE (type)), 1)); + (change_qualified_type (TREE_TYPE (type), TYPE_QUAL_VOLATILE)); else { warning (OPT_Wattributes, "%qs attribute ignored", diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index 7a83a0a9062..962f62844a3 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,17 @@ +2018-04-26 Richard Biener <rguenther@suse.de> + + Backport from mainline + 2018-03-16 Richard Biener <rguenther@suse.de> + + PR c/84873 + * c-gimplify.c (c_gimplify_expr): Revert previous change. Instead + unshare the possibly folded expression. + + 2018-03-15 Richard Biener <rguenther@suse.de> + + PR c/84873 + * c-gimplify.c (c_gimplify_expr): Do not fold expressions. + 2018-03-03 Jakub Jelinek <jakub@redhat.com> Backported from mainline diff --git a/gcc/c-family/c-gimplify.c b/gcc/c-family/c-gimplify.c index 57edb41af0f..deecb1a3e4a 100644 --- a/gcc/c-family/c-gimplify.c +++ b/gcc/c-family/c-gimplify.c @@ -244,7 +244,9 @@ c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED, unsigned_type_node) && !types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (*op1_p)), integer_type_node)) - *op1_p = convert (unsigned_type_node, *op1_p); + /* Make sure to unshare the result, tree sharing is invalid + during gimplification. */ + *op1_p = unshare_expr (convert (unsigned_type_node, *op1_p)); break; } diff --git a/gcc/calls.c b/gcc/calls.c index b183be63dd4..31663f4f67b 100644 --- a/gcc/calls.c +++ b/gcc/calls.c @@ -1196,65 +1196,79 @@ static GTY(()) tree alloc_object_size_limit; static tree alloc_max_size (void) { - if (!alloc_object_size_limit) - { - alloc_object_size_limit = TYPE_MAX_VALUE (ssizetype); + if (alloc_object_size_limit) + return alloc_object_size_limit; - if (warn_alloc_size_limit) - { - char *end = NULL; - errno = 0; - unsigned HOST_WIDE_INT unit = 1; - unsigned HOST_WIDE_INT limit - = strtoull (warn_alloc_size_limit, &end, 10); + alloc_object_size_limit = TYPE_MAX_VALUE (ssizetype); - if (!errno) - { - if (end && *end) - { - /* Numeric option arguments are at most INT_MAX. Make it - possible to specify a larger value by accepting common - suffixes. */ - if (!strcmp (end, "kB")) - unit = 1000; - else if (!strcasecmp (end, "KiB") || strcmp (end, "KB")) - unit = 1024; - else if (!strcmp (end, "MB")) - unit = HOST_WIDE_INT_UC (1000) * 1000; - else if (!strcasecmp (end, "MiB")) - unit = HOST_WIDE_INT_UC (1024) * 1024; - else if (!strcasecmp (end, "GB")) - unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000; - else if (!strcasecmp (end, "GiB")) - unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024; - else if (!strcasecmp (end, "TB")) - unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000; - else if (!strcasecmp (end, "TiB")) - unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024; - else if (!strcasecmp (end, "PB")) - unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000; - else if (!strcasecmp (end, "PiB")) - unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024; - else if (!strcasecmp (end, "EB")) - unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000 - * 1000; - else if (!strcasecmp (end, "EiB")) - unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024 - * 1024; - else - unit = 0; - } + if (!warn_alloc_size_limit) + return alloc_object_size_limit; - if (unit) - { - wide_int w = wi::uhwi (limit, HOST_BITS_PER_WIDE_INT + 64); - w *= unit; - if (wi::ltu_p (w, alloc_object_size_limit)) - alloc_object_size_limit = wide_int_to_tree (ssizetype, w); - } - } + const char *optname = "-Walloc-size-larger-than="; + + char *end = NULL; + errno = 0; + unsigned HOST_WIDE_INT unit = 1; + unsigned HOST_WIDE_INT limit + = strtoull (warn_alloc_size_limit, &end, 10); + + /* If the value is too large to be represented use the maximum + representable value that strtoull sets limit to (setting + errno to ERANGE). */ + + if (end && *end) + { + /* Numeric option arguments are at most INT_MAX. Make it + possible to specify a larger value by accepting common + suffixes. */ + if (!strcmp (end, "kB")) + unit = 1000; + else if (!strcasecmp (end, "KiB") || !strcmp (end, "KB")) + unit = 1024; + else if (!strcmp (end, "MB")) + unit = HOST_WIDE_INT_UC (1000) * 1000; + else if (!strcasecmp (end, "MiB")) + unit = HOST_WIDE_INT_UC (1024) * 1024; + else if (!strcasecmp (end, "GB")) + unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000; + else if (!strcasecmp (end, "GiB")) + unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024; + else if (!strcasecmp (end, "TB")) + unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000; + else if (!strcasecmp (end, "TiB")) + unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024; + else if (!strcasecmp (end, "PB")) + unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000; + else if (!strcasecmp (end, "PiB")) + unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024; + else if (!strcasecmp (end, "EB")) + unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000 + * 1000; + else if (!strcasecmp (end, "EiB")) + unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024 + * 1024; + else + { + /* This could mean an unknown suffix or a bad prefix, like + "+-1". */ + warning_at (UNKNOWN_LOCATION, 0, + "invalid argument %qs to %qs", + warn_alloc_size_limit, optname); + /* Ignore the limit extracted by strtoull. */ + unit = 0; } } + + if (unit) + { + widest_int w = wi::mul (limit, unit); + if (w < wi::to_widest (alloc_object_size_limit)) + alloc_object_size_limit + = wide_int_to_tree (ptrdiff_type_node, w); + else + alloc_object_size_limit = build_all_ones_cst (size_type_node); + } + return alloc_object_size_limit; } diff --git a/gcc/config.gcc b/gcc/config.gcc index b54345dcda5..3e41aa5b764 100644 --- a/gcc/config.gcc +++ b/gcc/config.gcc @@ -2046,10 +2046,17 @@ riscv*-*-linux*) ;; riscv*-*-elf* | riscv*-*-rtems*) tm_file="elfos.h newlib-stdint.h ${tm_file} riscv/elf.h" - case "x${enable_multilib}" in - xno) ;; - xyes) tmake_file="${tmake_file} riscv/t-elf-multilib" ;; - *) echo "Unknown value for enable_multilib"; exit 1 + case ${target} in + *-*-rtems*) + tm_file="${tm_file} rtems.h riscv/rtems.h" + tmake_file="${tmake_file} riscv/t-rtems" + ;; + *) + case "x${enable_multilib}" in + xno) ;; + xyes) tmake_file="${tmake_file} riscv/t-elf-multilib" ;; + *) echo "Unknown value for enable_multilib"; exit 1 + esac esac tmake_file="${tmake_file} riscv/t-riscv" gnu_ld=yes @@ -2057,11 +2064,6 @@ riscv*-*-elf* | riscv*-*-rtems*) # Force .init_array support. The configure script cannot always # automatically detect that GAS supports it, yet we require it. gcc_cv_initfini_array=yes - case ${target} in - riscv*-*-rtems*) - tm_file="${tm_file} rtems.h riscv/rtems.h" - ;; - esac ;; mips*-*-netbsd*) # NetBSD/mips, either endian. target_cpu_default="MASK_ABICALLS" diff --git a/gcc/config/arm/arm_cmse.h b/gcc/config/arm/arm_cmse.h index 8fde2736a2a..427647fb981 100644 --- a/gcc/config/arm/arm_cmse.h +++ b/gcc/config/arm/arm_cmse.h @@ -35,7 +35,6 @@ extern "C" { #if __ARM_FEATURE_CMSE & 1 #include <stddef.h> -#include <stdint.h> #ifdef __ARM_BIG_ENDIAN @@ -174,9 +173,9 @@ cmse_nonsecure_caller (void) #define CMSE_MPU_NONSECURE 16 #define CMSE_NONSECURE 18 -#define cmse_nsfptr_create(p) ((typeof ((p))) ((intptr_t) (p) & ~1)) +#define cmse_nsfptr_create(p) ((__typeof__ ((p))) ((__INTPTR_TYPE__) (p) & ~1)) -#define cmse_is_nsfptr(p) (!((intptr_t) (p) & 1)) +#define cmse_is_nsfptr(p) (!((__INTPTR_TYPE__) (p) & 1)) #endif /* __ARM_FEATURE_CMSE & 2 */ @@ -188,7 +187,7 @@ __extension__ void * cmse_check_address_range (void *, size_t, int); #define cmse_check_pointed_object(p, f) \ - ((typeof ((p))) cmse_check_address_range ((p), sizeof (*(p)), (f))) + ((__typeof__ ((p))) cmse_check_address_range ((p), sizeof (*(p)), (f))) #endif /* __ARM_FEATURE_CMSE & 1 */ diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md index 1cd6efb300e..0ed1ac053c5 100644 --- a/gcc/config/i386/sse.md +++ b/gcc/config/i386/sse.md @@ -1134,11 +1134,8 @@ operands[2])); } else if (memory_operand (operands[1], DImode)) - { - rtx tmp = gen_reg_rtx (V2DImode); - emit_insn (gen_vec_concatv2di (tmp, operands[1], const0_rtx)); - emit_move_insn (operands[0], gen_lowpart (V4SImode, tmp)); - } + emit_insn (gen_vec_concatv2di (gen_lowpart (V2DImode, operands[0]), + operands[1], const0_rtx)); else gcc_unreachable (); DONE; @@ -4398,7 +4395,7 @@ (match_operand:VF_128 1 "register_operand" "v") (const_int 1)))] "TARGET_AVX512F && TARGET_64BIT" - "vcvtusi2<ssescalarmodesuffix>\t{%2, <round_op3>%1, %0|%0, %1<round_op3>, %2}" + "vcvtusi2<ssescalarmodesuffix>{q}\t{%2, <round_op3>%1, %0|%0, %1<round_op3>, %2}" [(set_attr "type" "sseicvt") (set_attr "prefix" "evex") (set_attr "mode" "<ssescalarmode>")]) diff --git a/gcc/config/riscv/t-rtems b/gcc/config/riscv/t-rtems new file mode 100644 index 00000000000..41f5927fc87 --- /dev/null +++ b/gcc/config/riscv/t-rtems @@ -0,0 +1,25 @@ +MULTILIB_OPTIONS = +MULTILIB_DIRNAMES = + +MULTILIB_OPTIONS += march=rv32i/march=rv32im/march=rv32imafd/march=rv32iac/march=rv32imac/march=rv32imafc/march=rv64imafd/march=rv64imac/march=rv64imafdc +MULTILIB_DIRNAMES += rv32i rv32im rv32imafd rv32iac rv32imac rv32imafc rv64imafd rv64imac rv64imafdc + +MULTILIB_OPTIONS += mabi=ilp32/mabi=ilp32f/mabi=ilp32d/mabi=lp64/mabi=lp64d +MULTILIB_DIRNAMES += ilp32 ilp32f ilp32d lp64 lp64d + +MULTILIB_OPTIONS += mcmodel=medany +MULTILIB_DIRNAMES += medany + +MULTILIB_REQUIRED = +MULTILIB_REQUIRED += march=rv32i/mabi=ilp32 +MULTILIB_REQUIRED += march=rv32im/mabi=ilp32 +MULTILIB_REQUIRED += march=rv32imafd/mabi=ilp32d +MULTILIB_REQUIRED += march=rv32iac/mabi=ilp32 +MULTILIB_REQUIRED += march=rv32imac/mabi=ilp32 +MULTILIB_REQUIRED += march=rv32imafc/mabi=ilp32f +MULTILIB_REQUIRED += march=rv64imafd/mabi=lp64d +MULTILIB_REQUIRED += march=rv64imafd/mabi=lp64d/mcmodel=medany +MULTILIB_REQUIRED += march=rv64imac/mabi=lp64 +MULTILIB_REQUIRED += march=rv64imac/mabi=lp64/mcmodel=medany +MULTILIB_REQUIRED += march=rv64imafdc/mabi=lp64d +MULTILIB_REQUIRED += march=rv64imafdc/mabi=lp64d/mcmodel=medany diff --git a/gcc/config/rs6000/rs6000-c.c b/gcc/config/rs6000/rs6000-c.c index c6fd52439eb..24904d1bd74 100644 --- a/gcc/config/rs6000/rs6000-c.c +++ b/gcc/config/rs6000/rs6000-c.c @@ -6075,6 +6075,15 @@ altivec_resolve_overloaded_builtin (location_t loc, tree fndecl, stmt = build_binary_op (loc, PLUS_EXPR, stmt, arg2, 1); stmt = build_indirect_ref (loc, stmt, RO_NULL); + /* PR83660: We mark this as having side effects so that + downstream in fold_build_cleanup_point_expr () it will get a + CLEANUP_POINT_EXPR. If it does not we can run into an ICE + later in gimplify_cleanup_point_expr (). Potentially this + causes missed optimization because the actually is no side + effect. */ + if (c_dialect_cxx ()) + TREE_SIDE_EFFECTS (stmt) = 1; + return stmt; } diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c index edddff7aeca..01ae6ad8787 100644 --- a/gcc/config/rs6000/rs6000.c +++ b/gcc/config/rs6000/rs6000.c @@ -1372,6 +1372,7 @@ static rtx rs6000_debug_legitimize_reload_address (rtx, machine_mode, int, int, int, int *); static bool rs6000_mode_dependent_address (const_rtx); static bool rs6000_debug_mode_dependent_address (const_rtx); +static bool rs6000_offsettable_memref_p (rtx, machine_mode, bool); static enum reg_class rs6000_secondary_reload_class (enum reg_class, machine_mode, rtx); static enum reg_class rs6000_debug_secondary_reload_class (enum reg_class, @@ -8564,10 +8565,15 @@ mem_operand_gpr (rtx op, machine_mode mode) int extra; rtx addr = XEXP (op, 0); - /* Don't allow altivec type addresses like (mem (and (plus ...))). - See PR target/84279. */ + /* PR85755: Allow PRE_INC and PRE_DEC addresses. */ + if (TARGET_UPDATE + && (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC) + && mode_supports_pre_incdec_p (mode) + && legitimate_indirect_address_p (XEXP (addr, 0), false)) + return true; - if (GET_CODE (addr) == AND) + /* Don't allow non-offsettable addresses. See PRs 83969 and 84279. */ + if (!rs6000_offsettable_memref_p (op, mode, false)) return false; op = address_offset (addr); @@ -10340,7 +10346,7 @@ rs6000_find_base_term (rtx op) in 32-bit mode, that the recog predicate rejects. */ static bool -rs6000_offsettable_memref_p (rtx op, machine_mode reg_mode) +rs6000_offsettable_memref_p (rtx op, machine_mode reg_mode, bool strict) { bool worst_case; @@ -10348,7 +10354,7 @@ rs6000_offsettable_memref_p (rtx op, machine_mode reg_mode) return false; /* First mimic offsettable_memref_p. */ - if (offsettable_address_p (true, GET_MODE (op), XEXP (op, 0))) + if (offsettable_address_p (strict, GET_MODE (op), XEXP (op, 0))) return true; /* offsettable_address_p invokes rs6000_mode_dependent_address, but @@ -10362,7 +10368,7 @@ rs6000_offsettable_memref_p (rtx op, machine_mode reg_mode) worst_case = ((TARGET_POWERPC64 && GET_MODE_CLASS (reg_mode) == MODE_INT) || GET_MODE_SIZE (reg_mode) == 4); return rs6000_legitimate_offset_address_p (GET_MODE (op), XEXP (op, 0), - true, worst_case); + strict, worst_case); } /* Determine the reassociation width to be used in reassociate_bb. @@ -23281,7 +23287,7 @@ rs6000_output_move_128bit (rtx operands[]) } else if (TARGET_ALTIVEC && src_vmx_p - && altivec_indexed_or_indirect_operand (src, mode)) + && altivec_indexed_or_indirect_operand (dest, mode)) return "stvx %1,%y0"; else if (TARGET_VSX && src_vsx_p) @@ -26559,7 +26565,7 @@ rs6000_split_multireg_move (rtx dst, rtx src) emit_insn (gen_add3_insn (breg, breg, delta_rtx)); src = replace_equiv_address (src, breg); } - else if (! rs6000_offsettable_memref_p (src, reg_mode)) + else if (! rs6000_offsettable_memref_p (src, reg_mode, true)) { if (GET_CODE (XEXP (src, 0)) == PRE_MODIFY) { @@ -26626,7 +26632,7 @@ rs6000_split_multireg_move (rtx dst, rtx src) emit_insn (gen_add3_insn (breg, breg, delta_rtx)); dst = replace_equiv_address (dst, breg); } - else if (!rs6000_offsettable_memref_p (dst, reg_mode) + else if (!rs6000_offsettable_memref_p (dst, reg_mode, true) && GET_CODE (XEXP (dst, 0)) != LO_SUM) { if (GET_CODE (XEXP (dst, 0)) == PRE_MODIFY) @@ -26665,7 +26671,7 @@ rs6000_split_multireg_move (rtx dst, rtx src) } } else if (GET_CODE (XEXP (dst, 0)) != LO_SUM) - gcc_assert (rs6000_offsettable_memref_p (dst, reg_mode)); + gcc_assert (rs6000_offsettable_memref_p (dst, reg_mode, true)); } for (i = 0; i < nregs; i++) diff --git a/gcc/config/rs6000/rs6000.h b/gcc/config/rs6000/rs6000.h index 76c44ef31b3..ba234fda718 100644 --- a/gcc/config/rs6000/rs6000.h +++ b/gcc/config/rs6000/rs6000.h @@ -110,7 +110,8 @@ /* Common ASM definitions used by ASM_SPEC among the various targets for handling -mcpu=xxx switches. There is a parallel list in driver-rs6000.c to provide the default assembler options if the user uses -mcpu=native, so if - you make changes here, make them also there. */ + you make changes here, make them also there. PR63177: Do not pass -mpower8 + to the assembler if -mpower9-vector was also used. */ #define ASM_CPU_SPEC \ "%{!mcpu*: \ %{mpowerpc64*: -mppc64} \ @@ -124,7 +125,7 @@ %{mcpu=power6: %(asm_cpu_power6) -maltivec} \ %{mcpu=power6x: %(asm_cpu_power6) -maltivec} \ %{mcpu=power7: %(asm_cpu_power7)} \ -%{mcpu=power8: %(asm_cpu_power8)} \ +%{mcpu=power8: %{!mpower9-vector: %(asm_cpu_power8)}} \ %{mcpu=power9: %(asm_cpu_power9)} \ %{mcpu=a2: -ma2} \ %{mcpu=powerpc: -mppc} \ @@ -173,6 +174,7 @@ %{maltivec: -maltivec} \ %{mvsx: -mvsx %{!maltivec: -maltivec} %{!mcpu*: %(asm_cpu_power7)}} \ %{mpower8-vector|mcrypto|mdirect-move|mhtm: %{!mcpu*: %(asm_cpu_power8)}} \ +%{mpower9-vector: %{!mcpu*|mcpu=power8: %(asm_cpu_power9)}} \ -many" #define CPP_DEFAULT_SPEC "" diff --git a/gcc/config/rs6000/rs6000.md b/gcc/config/rs6000/rs6000.md index 40eda587137..ca7c04e275a 100644 --- a/gcc/config/rs6000/rs6000.md +++ b/gcc/config/rs6000/rs6000.md @@ -8640,14 +8640,14 @@ ;; FPR->GPR GPR->FPR VSX->GPR GPR->VSX (define_insn "*movdi_internal64" [(set (match_operand:DI 0 "nonimmediate_operand" - "=Y, r, r, r, r, r, + "=YZ, r, r, r, r, r, ^m, ^d, ^d, ^wY, $Z, $wb, $wv, ^wi, *wo, *wo, *wv, *wi, *wi, *wv, *wv, r, *h, *h, ?*r, ?*wg, ?*r, ?*wj") (match_operand:DI 1 "input_operand" - "r, Y, r, I, L, nF, + "r, YZ, r, I, L, nF, d, m, d, wb, wv, wY, Z, wi, Oj, wM, OjwM, Oj, wM, wS, wB, *h, r, 0, diff --git a/gcc/config/rtems.h b/gcc/config/rtems.h index 439199d4cbb..35026efa2c7 100644 --- a/gcc/config/rtems.h +++ b/gcc/config/rtems.h @@ -48,3 +48,7 @@ -latomic -lc -lgcc --end-group %{!qnolinkcmds: -T linkcmds%s}}}" #define TARGET_POSIX_IO + +/* Prefer int for int32_t (see stdint-newlib.h). */ +#undef STDINT_LONG32 +#define STDINT_LONG32 (INT_TYPE_SIZE != 32 && LONG_TYPE_SIZE == 32) diff --git a/gcc/config/s390/s390-builtin-types.def b/gcc/config/s390/s390-builtin-types.def index b7f33030eb9..915b050b2fb 100644 --- a/gcc/config/s390/s390-builtin-types.def +++ b/gcc/config/s390/s390-builtin-types.def @@ -124,6 +124,7 @@ DEF_OPAQUE_VECTOR_TYPE (BT_OUV4SI, BT_UINT, 4) DEF_OPAQUE_VECTOR_TYPE (BT_BV4SI, BT_BINT, 4) DEF_FN_TYPE_0 (BT_FN_INT, BT_INT) DEF_FN_TYPE_0 (BT_FN_UINT, BT_UINT) +DEF_FN_TYPE_0 (BT_FN_VOID, BT_VOID) DEF_FN_TYPE_1 (BT_FN_INT_INT, BT_INT, BT_INT) DEF_FN_TYPE_1 (BT_FN_INT_VOIDPTR, BT_INT, BT_VOIDPTR) DEF_FN_TYPE_1 (BT_FN_OV4SI_INT, BT_OV4SI, BT_INT) diff --git a/gcc/config/s390/s390-builtins.def b/gcc/config/s390/s390-builtins.def index 9046cb08f94..c2f278dc9c3 100644 --- a/gcc/config/s390/s390-builtins.def +++ b/gcc/config/s390/s390-builtins.def @@ -294,7 +294,7 @@ flags: Flags applying to all its variants should be mentioned in the OB_DEF line instead. */ -B_DEF (tbeginc, tbeginc, 0, B_HTM, 0, BT_FN_INT) +B_DEF (tbeginc, tbeginc, 0, B_HTM, 0, BT_FN_VOID) B_DEF (tbegin, tbegin, returns_twice_attr, B_HTM, 0, BT_FN_INT_VOIDPTR) B_DEF (tbegin_nofloat, tbegin_nofloat, returns_twice_attr, B_HTM, 0, BT_FN_INT_VOIDPTR) B_DEF (tbegin_retry, tbegin_retry, returns_twice_attr, B_HTM, 0, BT_FN_INT_VOIDPTR_INT) diff --git a/gcc/config/xtensa/xtensa.md b/gcc/config/xtensa/xtensa.md index d5596e25d82..0eba10b742c 100644 --- a/gcc/config/xtensa/xtensa.md +++ b/gcc/config/xtensa/xtensa.md @@ -38,6 +38,7 @@ (UNSPEC_MEMW 11) (UNSPEC_LSETUP_START 12) (UNSPEC_LSETUP_END 13) + (UNSPEC_FRAME_BLOCKAGE 14) (UNSPECV_SET_FP 1) (UNSPECV_ENTRY 2) @@ -1676,6 +1677,32 @@ ;; Miscellaneous instructions. +;; In windowed ABI stack pointer adjustment must happen before any access +;; to the space allocated on stack is allowed, otherwise register spill +;; area may be clobbered. That's what frame blockage is supposed to enforce. + +(define_expand "allocate_stack" + [(set (match_operand 0 "nonimmed_operand") + (minus (reg A1_REG) (match_operand 1 "add_operand"))) + (set (reg A1_REG) + (minus (reg A1_REG) (match_dup 1)))] + "TARGET_WINDOWED_ABI" +{ + if (CONST_INT_P (operands[1])) + { + rtx neg_op0 = GEN_INT (-INTVAL (operands[1])); + emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, neg_op0)); + } + else + { + emit_insn (gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, + operands[1])); + } + emit_move_insn (operands[0], virtual_stack_dynamic_rtx); + emit_insn (gen_frame_blockage ()); + DONE; +}) + (define_expand "prologue" [(const_int 0)] "" @@ -1767,6 +1794,25 @@ [(set_attr "length" "0") (set_attr "type" "nop")]) +;; Do not schedule instructions accessing memory before this point. + +(define_expand "frame_blockage" + [(set (match_dup 0) + (unspec:BLK [(match_dup 1)] UNSPEC_FRAME_BLOCKAGE))] + "" +{ + operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode)); + MEM_VOLATILE_P (operands[0]) = 1; + operands[1] = stack_pointer_rtx; +}) + +(define_insn "*frame_blockage" + [(set (match_operand:BLK 0 "" "") + (unspec:BLK [(match_operand:SI 1 "" "")] UNSPEC_FRAME_BLOCKAGE))] + "" + "" + [(set_attr "length" "0")]) + (define_insn "trap" [(trap_if (const_int 1) (const_int 0))] "" diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 87633e9343c..2d06819d455 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,52 @@ +2018-06-12 Jason Merrill <jason@redhat.com> + + PR c++/85815 - reference to member of enclosing template. + * parser.c (cp_parser_postfix_dot_deref_expression): Check + currently_open_class. + + PR c++/86060 - ICE on range for with -std=c++98. + * parser.c (cp_parser_init_statement): Don't clobber *decl after + pedwarn. + +2018-05-07 Jason Merrill <jason@redhat.com> + + PR c++/85646 - lambda visibility. + * decl2.c (determine_visibility): Don't mess with template arguments + from the containing scope. + (vague_linkage_p): Check DECL_ABSTRACT_P before looking at a 'tor + thunk. + +2018-04-23 Ville Voutilainen <ville.voutilainen@gmail.com> + + Backport from mainline + 2018-04-05 Ville Voutilainen <ville.voutilainen@gmail.com> + + Implement P0969 + * decl.c (find_decomp_class_base): Check accessibility instead + of declared access, adjust diagnostic. + +2018-04-23 Jakub Jelinek <jakub@redhat.com> + Jason Merrill <jason@redhat.com> + + PR c++/85470 - wrong error with static data member. + * decl.c (check_initializer): Check DECL_INITIALIZED_IN_CLASS_P. + * typeck2.c (store_init_value): Likewise. + +2018-04-23 Ville Voutilainen <ville.voutilainen@gmail.com> + + Backport from mainline + 2018-04-05 Ville Voutilainen <ville.voutilainen@gmail.com> + + Implement P0961 + * decl.c (get_tuple_decomp_init): Check the templatedness + of a member get. + +2018-04-19 Jonathan Wakely <jwakely@redhat.com> + + PR c++/85464 - missing location for -Wignored-qualifiers diagnostic + * decl.c (grokdeclarator): If declspecs->locations[ds_type_spec] + is UNKNOWN_LOCATION fall back to input_location. + 2018-04-09 Jason Merrill <jason@redhat.com> PR c++/85279 - dump_expr doesn't understand decltype. diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 5c519146043..836506ef7be 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -6400,7 +6400,9 @@ check_initializer (tree decl, tree init, int flags, vec<tree, va_gc> **cleanups) } if (init_code - && (DECL_IN_AGGR_P (decl) && !DECL_VAR_DECLARED_INLINE_P (decl))) + && (DECL_IN_AGGR_P (decl) + && DECL_INITIALIZED_IN_CLASS_P (decl) + && !DECL_VAR_DECLARED_INLINE_P (decl))) { static int explained = 0; @@ -7228,9 +7230,9 @@ find_decomp_class_base (location_t loc, tree type, tree ret) inform (DECL_SOURCE_LOCATION (field), "declared here"); return error_mark_node; } - else if (TREE_PRIVATE (field) || TREE_PROTECTED (field)) + else if (!accessible_p (type, field, true)) { - error_at (loc, "cannot decompose non-public member %qD of %qT", + error_at (loc, "cannot decompose inaccessible member %qD of %qT", field, type); inform (DECL_SOURCE_LOCATION (field), TREE_PRIVATE (field) @@ -7338,7 +7340,29 @@ get_tuple_decomp_init (tree decl, unsigned i) tree fns = lookup_qualified_name (TREE_TYPE (e), get_id, /*type*/false, /*complain*/false); - if (fns != error_mark_node) + bool use_member_get = false; + + /* To use a member get, member lookup must find at least one + declaration that is a function template + whose first template parameter is a non-type parameter. */ + for (tree iter = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns; + iter; + iter = OVL_NEXT (iter)) + { + tree fn = OVL_CURRENT (iter); + if (TREE_CODE (fn) == TEMPLATE_DECL) + { + tree tparms = DECL_TEMPLATE_PARMS (fn); + tree parm = TREE_VEC_ELT (INNERMOST_TEMPLATE_PARMS (tparms), 0); + if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL) + { + use_member_get = true; + break; + } + } + } + + if (use_member_get) { fns = lookup_template_function (fns, targs); return build_new_method_call (e, fns, /*args*/NULL, @@ -10105,6 +10129,8 @@ grokdeclarator (const cp_declarator *declarator, declspecs->locations); if (typespec_loc == UNKNOWN_LOCATION) typespec_loc = declspecs->locations[ds_type_spec]; + if (typespec_loc == UNKNOWN_LOCATION) + typespec_loc = input_location; /* Look inside a declarator for the name being declared and get it as a string, for an error message. */ diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 982f35f558f..7ad6a108224 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -1829,10 +1829,13 @@ vague_linkage_p (tree decl) { if (!TREE_PUBLIC (decl)) { - /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor - variants, check one of the "clones" for the real linkage. */ + /* maybe_thunk_body clears TREE_PUBLIC and DECL_ABSTRACT_P on the + maybe-in-charge 'tor variants; in that case we need to check one of + the "clones" for the real linkage. But only in that case; before + maybe_clone_body we haven't yet copied the linkage to the clones. */ if ((DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl) || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)) + && !DECL_ABSTRACT_P (decl) && DECL_CHAIN (decl) && DECL_CLONED_FUNCTION (DECL_CHAIN (decl))) return vague_linkage_p (DECL_CHAIN (decl)); @@ -2310,11 +2313,8 @@ determine_visibility (tree decl) } /* Local classes in templates have CLASSTYPE_USE_TEMPLATE set, - but have no TEMPLATE_INFO. Their containing template - function does, and the local class could be constrained - by that. */ - if (template_decl) - template_decl = fn; + but have no TEMPLATE_INFO, so don't try to check it. */ + template_decl = NULL_TREE; } else if (VAR_P (decl) && DECL_TINFO_P (decl) && flag_visibility_ms_compat) diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 9a65d945232..6d9b712e243 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -7364,9 +7364,7 @@ cp_parser_postfix_dot_deref_expression (cp_parser *parser, if (postfix_expression != current_class_ref && scope != error_mark_node && !(processing_template_decl - && current_class_type - && (same_type_ignoring_top_level_qualifiers_p - (scope, current_class_type)))) + && currently_open_class (scope))) { scope = complete_type (scope); if (!COMPLETE_TYPE_P (scope) @@ -12103,12 +12101,9 @@ cp_parser_init_statement (cp_parser* parser, tree *decl) cp_lexer_consume_token (parser->lexer); is_range_for = true; if (cxx_dialect < cxx11) - { - pedwarn (cp_lexer_peek_token (parser->lexer)->location, 0, - "range-based %<for%> loops only available with " - "-std=c++11 or -std=gnu++11"); - *decl = error_mark_node; - } + pedwarn (cp_lexer_peek_token (parser->lexer)->location, 0, + "range-based %<for%> loops only available with " + "-std=c++11 or -std=gnu++11"); } else /* The ';' is not consumed yet because we told diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c index 1f0eb454754..764fbca832d 100644 --- a/gcc/cp/typeck2.c +++ b/gcc/cp/typeck2.c @@ -817,9 +817,12 @@ store_init_value (tree decl, tree init, vec<tree, va_gc>** cleanups, int flags) bool const_init; value = instantiate_non_dependent_expr (value); if (DECL_DECLARED_CONSTEXPR_P (decl) - || (DECL_IN_AGGR_P (decl) && !DECL_VAR_DECLARED_INLINE_P (decl))) + || (DECL_IN_AGGR_P (decl) + && DECL_INITIALIZED_IN_CLASS_P (decl) + && !DECL_VAR_DECLARED_INLINE_P (decl))) { - /* Diagnose a non-constant initializer for constexpr. */ + /* Diagnose a non-constant initializer for constexpr variable or + non-inline in-class-initialized static data member. */ if (processing_template_decl && !require_potential_constant_expression (value)) value = error_mark_node; diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 9abf7783313..109be3bd7a5 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -5171,6 +5171,9 @@ precision would exceed @code{SIZE_MAX / 2}. The option argument @var{n} may end in one of the standard suffixes designating a multiple of bytes such as @code{kB} and @code{KiB} for kilobyte and kibibyte, respectively, @code{MB} and @code{MiB} for megabyte and mebibyte, and so on. +@option{-Walloc-size-larger-than=}@var{PTRDIFF_MAX} is enabled by default. +Warnings controlled by the option can be disabled by specifying @var{n} +of @var{SIZE_MAX} or more. @xref{Function Attributes}. @item -Walloca diff --git a/gcc/expr.c b/gcc/expr.c index d87e24f0634..9fe4ec91c1c 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -6893,8 +6893,9 @@ store_field (rtx target, HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos, if (GET_CODE (temp) == PARALLEL) { HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp)); - machine_mode temp_mode - = smallest_mode_for_size (size * BITS_PER_UNIT, MODE_INT); + machine_mode temp_mode = GET_MODE (temp); + if (temp_mode == BLKmode || temp_mode == VOIDmode) + temp_mode = smallest_mode_for_size (size * BITS_PER_UNIT, MODE_INT); rtx temp_target = gen_reg_rtx (temp_mode); emit_group_store (temp_target, temp, TREE_TYPE (exp), size); temp = temp_target; diff --git a/gcc/fold-const.c b/gcc/fold-const.c index 0781f4212b7..8e1b0623763 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -473,12 +473,15 @@ negate_expr_p (tree t) case EXACT_DIV_EXPR: if (TYPE_UNSIGNED (type)) break; - if (negate_expr_p (TREE_OPERAND (t, 0))) + /* In general we can't negate A in A / B, because if A is INT_MIN and + B is not 1 we change the sign of the result. */ + if (TREE_CODE (TREE_OPERAND (t, 0)) == INTEGER_CST + && negate_expr_p (TREE_OPERAND (t, 0))) return true; /* In general we can't negate B in A / B, because if A is INT_MIN and B is 1, we may turn this into INT_MIN / -1 which is undefined and actually traps on some architectures. */ - if (! INTEGRAL_TYPE_P (TREE_TYPE (t)) + if (! ANY_INTEGRAL_TYPE_P (TREE_TYPE (t)) || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t)) || (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST && ! integer_onep (TREE_OPERAND (t, 1)))) @@ -652,14 +655,17 @@ fold_negate_expr_1 (location_t loc, tree t) case EXACT_DIV_EXPR: if (TYPE_UNSIGNED (type)) break; - if (negate_expr_p (TREE_OPERAND (t, 0))) + /* In general we can't negate A in A / B, because if A is INT_MIN and + B is not 1 we change the sign of the result. */ + if (TREE_CODE (TREE_OPERAND (t, 0)) == INTEGER_CST + && negate_expr_p (TREE_OPERAND (t, 0))) return fold_build2_loc (loc, TREE_CODE (t), type, negate_expr (TREE_OPERAND (t, 0)), TREE_OPERAND (t, 1)); /* In general we can't negate B in A / B, because if A is INT_MIN and B is 1, we may turn this into INT_MIN / -1 which is undefined and actually traps on some architectures. */ - if ((! INTEGRAL_TYPE_P (TREE_TYPE (t)) + if ((! ANY_INTEGRAL_TYPE_P (TREE_TYPE (t)) || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t)) || (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST && ! integer_onep (TREE_OPERAND (t, 1)))) diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 9554295e6d0..6541331e05e 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,211 @@ +2018-06-13 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/86110 + * array.c (gfc_resolve_character_array_constructor): Avoid NULL + pointer dereference. + +2018-06-12 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/44491 + * expr.c (gfc_check_assign): Select non-NULL locus. + +2018-06-09 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/38351 + * resolve.c (resolve_operator): Provide better error message for + derived type entity used in an binary intrinsic numeric operator. + +2018-06-09 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/63514 + * symbol.c (gfc_add_volatile): Enforce F2008:C1282 and F2018:C1588. + +2018-06-09 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/78278 + * data.c (gfc_assign_data_value): Re-arrange code to allow for + an error for double initialization of CHARACTER entities. + +2018-06-09 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/86059 + * array.c (match_array_cons_element): NULL() cannot be in an + array constructor. + +2018-06-09 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85138 + PR fortran/85996 + PR fortran/86051 + * decl.c (gfc_match_char_spec): Use private namespace in attempt to + reduce a charlen to a constant. + +2018-06-07 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/86045 + Backport from trunk. + * simplify.c (gfc_simplify_mod): Re-arrange code to test whether + 'P' is zero and issue an error if it is. + +2018-06-07 Thomas Koenig <tkoenig@gcc.gnu.org> + + PR fortran/85641 + Backport from trunk. + * frontend-passes.c (is_fe_temp): Add prototype. + (realloc_string_callback): Early return for frontend-generated + temporary. + +2018-06-04 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85981 + * resolve.c (resolve_allocate_deallocate): Check errmsg is default + character kind. + +2018-05-25 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85543 + Backport from trunk + * resolve.c (update_current_proc_array_outer_dependency): Avoid NULL + pointer dereference. + +2018-05-25 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85779 + Backport from trunk + * decl.c (gfc_match_derived_decl): Fix NULL point dereference. + +2018-05-25 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85780 + Backport from trunk + * resolve.c (resolve_fl_procedure): Avoid NULL dereference. + +2018-05-25 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85895 + Backport from trunk + * resolve.c (resolve_sync): Resolve expression before checking for + an error. + +2018-05-20 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/80657 + Backport from trunk + * resolve.c (flag_fn_result_spec): Use the 'sym' argument to + test for self refs to the function result in the character len + expression. If a self reference is found, emit an error and + return true. + (resolve_fntype): Use the function symbol in the calls to the + above. + +2018-05-20 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/82275 + Backport from trunk + * match.c (gfc_match_type_spec): Go through the array ref and + decrement 'rank' for every dimension that is an element. + +2018-05-19 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/82923 + PR fortran/66694 + PR fortran/82617 + Backport from trunk + * trans-array.c (gfc_alloc_allocatable_for_assignment): Set the + charlen backend_decl of the rhs expr to ss->info->string_length + so that the value in the current scope is used. + +2018-05-16 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/83149 + Backport from trunk + * trans-decl.c (gfc_finish_var_decl): Test sym->ns->proc_name + before accessing its components. + * trans-types.c (gfc_sym_type): If a character result has null + backend_decl, try the procedure symbol.. + +2018-16-05 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/83898 + Backport from trunk + * trans-stmt.c (trans_associate_var): Do not set cst_array_ctor + for characters. + +2018-05-16 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/84546 + Backport from trunk + * trans-array.c (structure_alloc_comps): Make sure that the + vptr is copied and that the unlimited polymorphic _len is used + to compute the size to be allocated. + (build_array_ref): Set the 'unlimited' argument false in the + call to gfc_get_class_array_ref. + * trans-expr.c (gfc_get_class_array_ref): If unlimited, use the + unlimited polymorphic _len for the offset to the element. + (gfc_copy_class_to_class): Set the new 'unlimited' argument. + * trans.h : Add the boolean 'unlimited' to the prototype. + +2018-05-12 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85542 + Backport from trunk + * expr.c (check_inquiry): Avoid NULL pointer dereference. + +2018-05-12 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/68846 + PR fortran/70864 + Backport from trunk + * resolve.c (get_temp_from_expr): The temporary must not have + dummy or intent attributes. + +2018-05-11 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/70870 + Backport from trunk + * data.c (gfc_assign_data_value): Check that a data object does + not also have default initialization. + +2018-05-11 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85521 + Backport from trunk + * array.c (gfc_resolve_character_array_constructor): Substrings + with upper bound smaller than lower bound are zero length strings. + +2018-05-11 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85687 + Backport from trunk + * check.c (gfc_check_rank): Check that the argument is a data object. + +2018-05-06 Andre Vehreschild <vehre@gcc.gnu.org> + + PR fortran/85507 + Backport from trunk. + * dependency.c (gfc_dep_resolver): Revert looking at coarray dimension + introduced by r259385. + * trans-intrinsic.c (conv_caf_send): Always report a dependency for + same variables in coarray assignments. + +2018-04-28 Andre Vehreschild <vehre@gcc.gnu.org> + + PR fortran/81773 + PR fortran/83606 + Backport from trunk. + * dependency.c (gfc_dep_resolver): Coarray indexes are to be ignored + during dependency computation. They define no data dependency. + * trans-array.c (conv_array_index_offset): The stride can not be set + here, prevent fail. + * trans-intrinsic.c (conv_caf_send): Add creation of temporary array + for caf_get's result and copying to the array with vectorial + indexing. + +2018-04-24 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85520 + * decl.c (gfc_match_char_spec): Check for negative length and set to 0. + 2018-03-28 Thomas Koenig <tkoenig@gcc.gnu.org> PR fortran/85084 diff --git a/gcc/fortran/array.c b/gcc/fortran/array.c index ec0c26656ff..17b3c7d44e8 100644 --- a/gcc/fortran/array.c +++ b/gcc/fortran/array.c @@ -1079,6 +1079,15 @@ match_array_cons_element (gfc_constructor_base *result) if (m != MATCH_YES) return m; + if (expr->expr_type == EXPR_FUNCTION + && expr->ts.type == BT_UNKNOWN + && strcmp(expr->symtree->name, "null") == 0) + { + gfc_error ("NULL() at %C cannot appear in an array constructor"); + gfc_free_expr (expr); + return MATCH_ERROR; + } + gfc_constructor_append_expr (result, expr, &gfc_current_locus); return MATCH_YES; } @@ -1998,7 +2007,9 @@ got_charlen: gfc_ref *ref; for (ref = p->expr->ref; ref; ref = ref->next) if (ref->type == REF_SUBSTRING + && ref->u.ss.start && ref->u.ss.start->expr_type == EXPR_CONSTANT + && ref->u.ss.end && ref->u.ss.end->expr_type == EXPR_CONSTANT) break; @@ -2021,7 +2032,8 @@ got_charlen: else return true; - gcc_assert (current_length != -1); + if (current_length < 0) + current_length = 0; if (found_length == -1) found_length = current_length; diff --git a/gcc/fortran/check.c b/gcc/fortran/check.c index 6e62d409e7b..f5e0ab5f5b8 100644 --- a/gcc/fortran/check.c +++ b/gcc/fortran/check.c @@ -3764,8 +3764,11 @@ gfc_check_rank (gfc_expr *a) ? a->value.function.esym->result->attr.pointer : a->symtree->n.sym->result->attr.pointer; - if (a->expr_type == EXPR_OP || a->expr_type == EXPR_NULL - || a->expr_type == EXPR_COMPCALL|| a->expr_type == EXPR_PPC + if (a->expr_type == EXPR_OP + || a->expr_type == EXPR_NULL + || a->expr_type == EXPR_COMPCALL + || a->expr_type == EXPR_PPC + || a->ts.type == BT_PROCEDURE || !is_variable) { gfc_error ("The argument of the RANK intrinsic at %L must be a data " diff --git a/gcc/fortran/data.c b/gcc/fortran/data.c index 184e53d480f..5d1d38042f4 100644 --- a/gcc/fortran/data.c +++ b/gcc/fortran/data.c @@ -481,6 +481,21 @@ gfc_assign_data_value (gfc_expr *lvalue, gfc_expr *rvalue, mpz_t index, mpz_clear (offset); gcc_assert (repeat == NULL); + /* Overwriting an existing initializer is non-standard but usually only + provokes a warning from other compilers. */ + if (init != NULL && init->where.lb && rvalue->where.lb) + { + /* Order in which the expressions arrive here depends on whether + they are from data statements or F95 style declarations. + Therefore, check which is the most recent. */ + expr = (LOCATION_LINE (init->where.lb->location) + > LOCATION_LINE (rvalue->where.lb->location)) + ? init : rvalue; + if (gfc_notify_std (GFC_STD_GNU, "re-initialization of %qs at %L", + symbol->name, &expr->where) == false) + return false; + } + if (ref || last_ts->type == BT_CHARACTER) { /* An initializer has to be constant. */ @@ -492,20 +507,13 @@ gfc_assign_data_value (gfc_expr *lvalue, gfc_expr *rvalue, mpz_t index, } else { - /* Overwriting an existing initializer is non-standard but usually only - provokes a warning from other compilers. */ - if (init != NULL) + if (lvalue->ts.type == BT_DERIVED + && gfc_has_default_initializer (lvalue->ts.u.derived)) { - /* Order in which the expressions arrive here depends on whether - they are from data statements or F95 style declarations. - Therefore, check which is the most recent. */ - expr = (LOCATION_LINE (init->where.lb->location) - > LOCATION_LINE (rvalue->where.lb->location)) - ? init : rvalue; - if (gfc_notify_std (GFC_STD_GNU, - "re-initialization of %qs at %L", - symbol->name, &expr->where) == false) - return false; + gfc_error ("Nonpointer object %qs with default initialization " + "shall not appear in a DATA statement at %L", + symbol->name, &lvalue->where); + return false; } expr = gfc_copy_expr (rvalue); diff --git a/gcc/fortran/decl.c b/gcc/fortran/decl.c index ac5e462a524..e73f2d76f45 100644 --- a/gcc/fortran/decl.c +++ b/gcc/fortran/decl.c @@ -2998,22 +2998,36 @@ done: cl->length = gfc_get_int_expr (gfc_default_integer_kind, NULL, 1); else { - /* If gfortran ends up here, then the len may be reducible to a - constant. Try to do that here. If it does not reduce, simply - assign len to the charlen. */ + /* If gfortran ends up here, then len may be reducible to a constant. + Try to do that here. If it does not reduce, simply assign len to + charlen. A complication occurs with user-defined generic functions, + which are not resolved. Use a private namespace to deal with + generic functions. */ + if (len && len->expr_type != EXPR_CONSTANT) { + gfc_namespace *old_ns; gfc_expr *e; + + old_ns = gfc_current_ns; + gfc_current_ns = gfc_get_namespace (NULL, 0); + e = gfc_copy_expr (len); gfc_reduce_init_expr (e); if (e->expr_type == EXPR_CONSTANT) - gfc_replace_expr (len, e); + { + gfc_replace_expr (len, e); + if (mpz_cmp_si (len->value.integer, 0) < 0) + mpz_set_ui (len->value.integer, 0); + } else gfc_free_expr (e); - cl->length = len; + + gfc_free_namespace (gfc_current_ns); + gfc_current_ns = old_ns; } - else - cl->length = len; + + cl->length = len; } ts->u.cl = cl; @@ -9031,8 +9045,12 @@ gfc_match_derived_decl (void) if (!gensym->attr.generic && gensym->ts.type != BT_UNKNOWN) { - gfc_error ("Derived type name %qs at %C already has a basic type " - "of %s", gensym->name, gfc_typename (&gensym->ts)); + if (gensym->ts.u.derived) + gfc_error ("Derived type name %qs at %C already has a basic type " + "of %s", gensym->name, gfc_typename (&gensym->ts)); + else + gfc_error ("Derived type name %qs at %C already has a basic type", + gensym->name); return MATCH_ERROR; } diff --git a/gcc/fortran/expr.c b/gcc/fortran/expr.c index f302ef70b86..0d553c0bea2 100644 --- a/gcc/fortran/expr.c +++ b/gcc/fortran/expr.c @@ -2315,7 +2315,7 @@ check_inquiry (gfc_expr *e, int not_restricted) /* Assumed character length will not reduce to a constant expression with LEN, as required by the standard. */ - if (i == 5 && not_restricted + if (i == 5 && not_restricted && ap->expr->symtree && ap->expr->symtree->n.sym->ts.type == BT_CHARACTER && (ap->expr->symtree->n.sym->ts.u.cl->length == NULL || ap->expr->symtree->n.sym->ts.deferred)) @@ -3288,6 +3288,8 @@ gfc_check_assign (gfc_expr *lvalue, gfc_expr *rvalue, int conform, /* Only DATA Statements come here. */ if (!conform) { + locus *where; + /* Numeric can be converted to any other numeric. And Hollerith can be converted to any other type. */ if ((gfc_numeric_ts (&lvalue->ts) && gfc_numeric_ts (&rvalue->ts)) @@ -3297,8 +3299,9 @@ gfc_check_assign (gfc_expr *lvalue, gfc_expr *rvalue, int conform, if (lvalue->ts.type == BT_LOGICAL && rvalue->ts.type == BT_LOGICAL) return true; + where = lvalue->where.lb ? &lvalue->where : &rvalue->where; gfc_error ("Incompatible types in DATA statement at %L; attempted " - "conversion of %s to %s", &lvalue->where, + "conversion of %s to %s", where, gfc_typename (&rvalue->ts), gfc_typename (&lvalue->ts)); return false; diff --git a/gcc/fortran/frontend-passes.c b/gcc/fortran/frontend-passes.c index d7b4f23fe89..ef1d8f97434 100644 --- a/gcc/fortran/frontend-passes.c +++ b/gcc/fortran/frontend-passes.c @@ -48,6 +48,8 @@ static gfc_code * create_do_loop (gfc_expr *, gfc_expr *, gfc_expr *, locus *, gfc_namespace *, char *vname=NULL); +static bool is_fe_temp (gfc_expr *e); + #ifdef CHECKING_P static void check_locus (gfc_namespace *); #endif @@ -231,6 +233,9 @@ realloc_string_callback (gfc_code **c, int *walk_subtrees ATTRIBUTE_UNUSED, || !expr1->ts.deferred) return 0; + if (is_fe_temp (expr1)) + return 0; + expr2 = gfc_discard_nops (co->expr2); if (expr2->expr_type == EXPR_VARIABLE) diff --git a/gcc/fortran/match.c b/gcc/fortran/match.c index 682f7b021b0..89fb43dc048 100644 --- a/gcc/fortran/match.c +++ b/gcc/fortran/match.c @@ -2063,7 +2063,7 @@ gfc_match_type_spec (gfc_typespec *ts) or list item in a type-list of an OpenMP reduction clause. Need to differentiate REAL([KIND]=scalar-int-initialization-expr) from REAL(A,[KIND]) and REAL(KIND,A). Logically, when this code was - written the use of LOGICAL as a type-spec or intrinsic subprogram + written the use of LOGICAL as a type-spec or intrinsic subprogram was overlooked. */ m = gfc_match (" %n", name); @@ -5714,6 +5714,7 @@ copy_ts_from_selector_to_associate (gfc_expr *associate, gfc_expr *selector) { gfc_ref *ref; gfc_symbol *assoc_sym; + int rank = 0; assoc_sym = associate->symtree->n.sym; @@ -5750,14 +5751,28 @@ copy_ts_from_selector_to_associate (gfc_expr *associate, gfc_expr *selector) selector->rank = ref->u.ar.dimen; else selector->rank = 0; + + rank = selector->rank; } - if (selector->rank) + if (rank) { - assoc_sym->attr.dimension = 1; - assoc_sym->as = gfc_get_array_spec (); - assoc_sym->as->rank = selector->rank; - assoc_sym->as->type = AS_DEFERRED; + for (int i = 0; i < ref->u.ar.dimen + ref->u.ar.codimen; i++) + if (ref->u.ar.dimen_type[i] == DIMEN_ELEMENT + || (ref->u.ar.dimen_type[i] == DIMEN_UNKNOWN + && ref->u.ar.end[i] == NULL + && ref->u.ar.stride[i] == NULL)) + rank--; + + if (rank) + { + assoc_sym->attr.dimension = 1; + assoc_sym->as = gfc_get_array_spec (); + assoc_sym->as->rank = rank; + assoc_sym->as->type = AS_DEFERRED; + } + else + assoc_sym->as = NULL; } else assoc_sym->as = NULL; diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c index 4baa0e036fc..d5e74823c71 100644 --- a/gcc/fortran/resolve.c +++ b/gcc/fortran/resolve.c @@ -2906,8 +2906,8 @@ update_current_proc_array_outer_dependency (gfc_symbol *sym) /* If SYM has references to outer arrays, so has the procedure calling SYM. If SYM is a procedure pointer, we can assume the worst. */ - if (sym->attr.array_outer_dependency - || sym->attr.proc_pointer) + if ((sym->attr.array_outer_dependency || sym->attr.proc_pointer) + && gfc_current_ns->proc_name) gfc_current_ns->proc_name->attr.array_outer_dependency = 1; } @@ -3685,7 +3685,13 @@ resolve_operator (gfc_expr *e) break; } - sprintf (msg, + if (op1->ts.type == BT_DERIVED || op2->ts.type == BT_DERIVED) + sprintf (msg, + _("Unexpected derived-type entities in binary intrinsic " + "numeric operator %%<%s%%> at %%L"), + gfc_op2string (e->value.op.op)); + else + sprintf (msg, _("Operands of binary numeric operator %%<%s%%> at %%L are %s/%s"), gfc_op2string (e->value.op.op), gfc_typename (&op1->ts), gfc_typename (&op2->ts)); @@ -7554,12 +7560,17 @@ resolve_allocate_deallocate (gfc_code *code, const char *fcn) gfc_check_vardef_context (errmsg, false, false, false, _("ERRMSG variable")); + /* F18:R928 alloc-opt is ERRMSG = errmsg-variable + F18:R930 errmsg-variable is scalar-default-char-variable + F18:R906 default-char-variable is variable + F18:C906 default-char-variable shall be default character. */ if ((errmsg->ts.type != BT_CHARACTER && !(errmsg->ref && (errmsg->ref->type == REF_ARRAY || errmsg->ref->type == REF_COMPONENT))) - || errmsg->rank > 0 ) - gfc_error ("Errmsg-variable at %L must be a scalar CHARACTER " + || errmsg->rank > 0 + || errmsg->ts.kind != gfc_default_character_kind) + gfc_error ("ERRMSG variable at %L shall be a scalar default CHARACTER " "variable", &errmsg->where); for (p = code->ext.alloc.list; p; p = p->next) @@ -9299,6 +9310,7 @@ resolve_sync (gfc_code *code) } /* Check STAT. */ + gfc_resolve_expr (code->expr2); if (code->expr2 && (code->expr2->ts.type != BT_INTEGER || code->expr2->rank != 0 || code->expr2->expr_type != EXPR_VARIABLE)) @@ -9306,6 +9318,7 @@ resolve_sync (gfc_code *code) &code->expr2->where); /* Check ERRMSG. */ + gfc_resolve_expr (code->expr3); if (code->expr3 && (code->expr3->ts.type != BT_CHARACTER || code->expr3->rank != 0 || code->expr3->expr_type != EXPR_VARIABLE)) @@ -10276,6 +10289,8 @@ get_temp_from_expr (gfc_expr *e, gfc_namespace *ns) tmp->n.sym->attr.function = 0; tmp->n.sym->attr.result = 0; tmp->n.sym->attr.flavor = FL_VARIABLE; + tmp->n.sym->attr.dummy = 0; + tmp->n.sym->attr.intent = INTENT_UNKNOWN; if (as) { @@ -12266,7 +12281,7 @@ resolve_fl_procedure (gfc_symbol *sym, int mp_flag) while (curr_arg != NULL) { /* Skip implicitly typed dummy args here. */ - if (curr_arg->sym->attr.implicit_type == 0) + if (curr_arg->sym && curr_arg->sym->attr.implicit_type == 0) if (!gfc_verify_c_interop_param (curr_arg->sym)) /* If something is found to fail, record the fact so we can mark the symbol for the procedure as not being @@ -15868,7 +15883,7 @@ resolve_equivalence (gfc_equiv *eq) static bool flag_fn_result_spec (gfc_expr *expr, - gfc_symbol *sym ATTRIBUTE_UNUSED, + gfc_symbol *sym, int *f ATTRIBUTE_UNUSED) { gfc_namespace *ns; @@ -15881,6 +15896,13 @@ flag_fn_result_spec (gfc_expr *expr, if (!ns->parent) break; + if (sym == s) + { + gfc_error ("Self reference in character length expression " + "for %qs at %L", sym->name, &expr->where); + return true; + } + if (!s->fn_result_spec && s->attr.flavor == FL_PARAMETER) { @@ -15963,7 +15985,7 @@ resolve_fntype (gfc_namespace *ns) } if (sym->ts.type == BT_CHARACTER) - gfc_traverse_expr (sym->ts.u.cl->length, NULL, flag_fn_result_spec, 0); + gfc_traverse_expr (sym->ts.u.cl->length, sym, flag_fn_result_spec, 0); } diff --git a/gcc/fortran/simplify.c b/gcc/fortran/simplify.c index e34deada3fc..6cfa2283336 100644 --- a/gcc/fortran/simplify.c +++ b/gcc/fortran/simplify.c @@ -4642,43 +4642,48 @@ gfc_simplify_mod (gfc_expr *a, gfc_expr *p) gfc_expr *result; int kind; - if (a->expr_type != EXPR_CONSTANT || p->expr_type != EXPR_CONSTANT) + /* First check p. */ + if (p->expr_type != EXPR_CONSTANT) return NULL; - kind = a->ts.kind > p->ts.kind ? a->ts.kind : p->ts.kind; - result = gfc_get_constant_expr (a->ts.type, kind, &a->where); - - switch (a->ts.type) + /* p shall not be 0. */ + switch (p->ts.type) { case BT_INTEGER: if (mpz_cmp_ui (p->value.integer, 0) == 0) { - /* Result is processor-dependent. */ - gfc_error ("Second argument MOD at %L is zero", &a->where); - gfc_free_expr (result); + gfc_error ("Argument %qs of MOD at %L shall not be zero", + "P", &p->where); return &gfc_bad_expr; } - mpz_tdiv_r (result->value.integer, a->value.integer, p->value.integer); break; - case BT_REAL: if (mpfr_cmp_ui (p->value.real, 0) == 0) { - /* Result is processor-dependent. */ - gfc_error ("Second argument of MOD at %L is zero", &p->where); - gfc_free_expr (result); + gfc_error ("Argument %qs of MOD at %L shall not be zero", + "P", &p->where); return &gfc_bad_expr; } - - gfc_set_model_kind (kind); - mpfr_fmod (result->value.real, a->value.real, p->value.real, - GFC_RND_MODE); break; - default: gfc_internal_error ("gfc_simplify_mod(): Bad arguments"); } + if (a->expr_type != EXPR_CONSTANT) + return NULL; + + kind = a->ts.kind > p->ts.kind ? a->ts.kind : p->ts.kind; + result = gfc_get_constant_expr (a->ts.type, kind, &a->where); + + if (a->ts.type == BT_INTEGER) + mpz_tdiv_r (result->value.integer, a->value.integer, p->value.integer); + else + { + gfc_set_model_kind (kind); + mpfr_fmod (result->value.real, a->value.real, p->value.real, + GFC_RND_MODE); + } + return range_check (result, "MOD"); } diff --git a/gcc/fortran/symbol.c b/gcc/fortran/symbol.c index ec43e635bf3..6917b22dff2 100644 --- a/gcc/fortran/symbol.c +++ b/gcc/fortran/symbol.c @@ -1259,6 +1259,20 @@ gfc_add_volatile (symbol_attribute *attr, const char *name, locus *where) where)) return false; + /* F2008: C1282 A designator of a variable with the VOLATILE attribute + shall not appear in a pure subprogram. + + F2018: C1588 A local variable of a pure subprogram, or of a BLOCK + construct within a pure subprogram, shall not have the SAVE or + VOLATILE attribute. */ + if (gfc_pure (NULL)) + { + gfc_error ("VOLATILE attribute at %L cannot be specified in a " + "PURE procedure", where); + return false; + } + + attr->volatile_ = 1; attr->volatile_ns = gfc_current_ns; return check_conflict (attr, name, where); diff --git a/gcc/fortran/trans-array.c b/gcc/fortran/trans-array.c index 10790dce6b3..6be9c70a678 100644 --- a/gcc/fortran/trans-array.c +++ b/gcc/fortran/trans-array.c @@ -3073,7 +3073,7 @@ conv_array_index_offset (gfc_se * se, gfc_ss * ss, int dim, int i, } /* Multiply by the stride. */ - if (!integer_onep (stride)) + if (stride != NULL && !integer_onep (stride)) index = fold_build2_loc (input_location, MULT_EXPR, gfc_array_index_type, index, stride); @@ -3338,7 +3338,10 @@ build_array_ref (tree desc, tree offset, tree decl, tree vptr) { type = gfc_get_element_type (type); tmp = TREE_OPERAND (cdecl, 0); - tmp = gfc_get_class_array_ref (offset, tmp, NULL_TREE); + /* Note that the fourth argument in this call has been set false. + should any character dynamic types come this way, the 'len' + field of the unlimited object will not be used. */ + tmp = gfc_get_class_array_ref (offset, tmp, NULL_TREE, false); tmp = fold_convert (build_pointer_type (type), tmp); tmp = build_fold_indirect_ref_loc (input_location, tmp); return tmp; @@ -8650,6 +8653,31 @@ structure_alloc_comps (gfc_symbol * der_type, tree decl, gfc_init_block (&tmpblock); + gfc_add_modify (&tmpblock, gfc_class_vptr_get (dcmp), + gfc_class_vptr_get (comp)); + + /* Copy the unlimited '_len' field. If it is greater than zero + (ie. a character(_len)), multiply it by size and use this + for the malloc call. */ + if (UNLIMITED_POLY (c)) + { + tree ctmp; + gfc_add_modify (&tmpblock, gfc_class_len_get (dcmp), + gfc_class_len_get (comp)); + + size = gfc_evaluate_now (size, &tmpblock); + tmp = gfc_class_len_get (comp); + ctmp = fold_build2_loc (input_location, MULT_EXPR, + size_type_node, size, + fold_convert (size_type_node, tmp)); + tmp = fold_build2_loc (input_location, GT_EXPR, + logical_type_node, tmp, + build_zero_cst (TREE_TYPE (tmp))); + size = fold_build3_loc (input_location, COND_EXPR, + size_type_node, tmp, ctmp, size); + size = gfc_evaluate_now (size, &tmpblock); + } + /* Coarray component have to have the same allocation status and shape/type-parameter/effective-type on the LHS and RHS of an intrinsic assignment. Hence, we did not deallocated them - and @@ -9104,6 +9132,12 @@ gfc_alloc_allocatable_for_assignment (gfc_loopinfo *loop, if (expr2 && rss == gfc_ss_terminator) return NULL_TREE; + /* Ensure that the string length from the current scope is used. */ + if (expr2->ts.type == BT_CHARACTER + && expr2->expr_type == EXPR_FUNCTION + && !expr2->value.function.isym) + expr2->ts.u.cl->backend_decl = rss->info->string_length; + gfc_start_block (&fblock); /* Since the lhs is allocatable, this must be a descriptor type. diff --git a/gcc/fortran/trans-decl.c b/gcc/fortran/trans-decl.c index 796fd6da008..1e2be2f2d0e 100644 --- a/gcc/fortran/trans-decl.c +++ b/gcc/fortran/trans-decl.c @@ -603,10 +603,12 @@ gfc_finish_var_decl (tree decl, gfc_symbol * sym) function scope. */ if (current_function_decl != NULL_TREE) { - if (sym->ns->proc_name->backend_decl == current_function_decl - || sym->result == sym) + if (sym->ns->proc_name + && (sym->ns->proc_name->backend_decl == current_function_decl + || sym->result == sym)) gfc_add_decl_to_function (decl); - else if (sym->ns->proc_name->attr.flavor == FL_LABEL) + else if (sym->ns->proc_name + && sym->ns->proc_name->attr.flavor == FL_LABEL) /* This is a BLOCK construct. */ add_decl_as_local (decl); else @@ -698,7 +700,8 @@ gfc_finish_var_decl (tree decl, gfc_symbol * sym) } /* Keep variables larger than max-stack-var-size off stack. */ - if (!sym->ns->proc_name->attr.recursive && !sym->attr.automatic + if (!(sym->ns->proc_name && sym->ns->proc_name->attr.recursive) + && !sym->attr.automatic && INTEGER_CST_P (DECL_SIZE_UNIT (decl)) && !gfc_can_put_var_on_stack (DECL_SIZE_UNIT (decl)) /* Put variable length auto array pointers always into stack. */ diff --git a/gcc/fortran/trans-expr.c b/gcc/fortran/trans-expr.c index 49486c5328a..e1205e36b97 100644 --- a/gcc/fortran/trans-expr.c +++ b/gcc/fortran/trans-expr.c @@ -1156,15 +1156,32 @@ gfc_conv_class_to_class (gfc_se *parmse, gfc_expr *e, gfc_typespec class_ts, of the referenced element. */ tree -gfc_get_class_array_ref (tree index, tree class_decl, tree data_comp) +gfc_get_class_array_ref (tree index, tree class_decl, tree data_comp, + bool unlimited) { - tree data = data_comp != NULL_TREE ? data_comp : - gfc_class_data_get (class_decl); - tree size = gfc_class_vtab_size_get (class_decl); - tree offset = fold_build2_loc (input_location, MULT_EXPR, - gfc_array_index_type, - index, size); - tree ptr; + tree data, size, tmp, ctmp, offset, ptr; + + data = data_comp != NULL_TREE ? data_comp : + gfc_class_data_get (class_decl); + size = gfc_class_vtab_size_get (class_decl); + + if (unlimited) + { + tmp = fold_convert (gfc_array_index_type, + gfc_class_len_get (class_decl)); + ctmp = fold_build2_loc (input_location, MULT_EXPR, + gfc_array_index_type, size, tmp); + tmp = fold_build2_loc (input_location, GT_EXPR, + logical_type_node, tmp, + build_zero_cst (TREE_TYPE (tmp))); + size = fold_build3_loc (input_location, COND_EXPR, + gfc_array_index_type, tmp, ctmp, size); + } + + offset = fold_build2_loc (input_location, MULT_EXPR, + gfc_array_index_type, + index, size); + data = gfc_conv_descriptor_data_get (data); ptr = fold_convert (pvoid_type_node, data); ptr = fold_build_pointer_plus_loc (input_location, ptr, offset); @@ -1266,14 +1283,15 @@ gfc_copy_class_to_class (tree from, tree to, tree nelems, bool unlimited) if (is_from_desc) { - from_ref = gfc_get_class_array_ref (index, from, from_data); + from_ref = gfc_get_class_array_ref (index, from, from_data, + unlimited); vec_safe_push (args, from_ref); } else vec_safe_push (args, from_data); if (is_to_class) - to_ref = gfc_get_class_array_ref (index, to, to_data); + to_ref = gfc_get_class_array_ref (index, to, to_data, unlimited); else { tmp = gfc_conv_array_data (to); diff --git a/gcc/fortran/trans-intrinsic.c b/gcc/fortran/trans-intrinsic.c index 05a1a7aa346..18cae832c64 100644 --- a/gcc/fortran/trans-intrinsic.c +++ b/gcc/fortran/trans-intrinsic.c @@ -1860,7 +1860,7 @@ conv_caf_send (gfc_code *code) { lhs_expr = code->ext.actual->expr; rhs_expr = code->ext.actual->next->expr; - may_require_tmp = gfc_check_dependency (lhs_expr, rhs_expr, false) == 0 + may_require_tmp = gfc_check_dependency (lhs_expr, rhs_expr, true) == 0 ? boolean_false_node : boolean_true_node; gfc_init_block (&block); @@ -1906,34 +1906,124 @@ conv_caf_send (gfc_code *code) { } else { - /* If has_vector, pass descriptor for whole array and the - vector bounds separately. */ - gfc_array_ref *ar, ar2; - bool has_vector = false; + bool has_vector = gfc_has_vector_subscript (lhs_expr); - if (gfc_is_coindexed (lhs_expr) && gfc_has_vector_subscript (lhs_expr)) + if (gfc_is_coindexed (lhs_expr) || !has_vector) { - has_vector = true; - ar = gfc_find_array_ref (lhs_expr); - ar2 = *ar; - memset (ar, '\0', sizeof (*ar)); - ar->as = ar2.as; - ar->type = AR_FULL; + /* If has_vector, pass descriptor for whole array and the + vector bounds separately. */ + gfc_array_ref *ar, ar2; + bool has_tmp_lhs_array = false; + if (has_vector) + { + has_tmp_lhs_array = true; + ar = gfc_find_array_ref (lhs_expr); + ar2 = *ar; + memset (ar, '\0', sizeof (*ar)); + ar->as = ar2.as; + ar->type = AR_FULL; + } + lhs_se.want_pointer = 1; + gfc_conv_expr_descriptor (&lhs_se, lhs_expr); + /* Using gfc_conv_expr_descriptor, we only get the descriptor, but + that has the wrong type if component references are done. */ + lhs_type = gfc_typenode_for_spec (&lhs_expr->ts); + tmp = build_fold_indirect_ref_loc (input_location, lhs_se.expr); + gfc_add_modify (&lhs_se.pre, gfc_conv_descriptor_dtype (tmp), + gfc_get_dtype_rank_type (has_vector ? ar2.dimen + : lhs_expr->rank, + lhs_type)); + if (has_tmp_lhs_array) + { + vec = conv_caf_vector_subscript (&block, lhs_se.expr, &ar2); + *ar = ar2; + } } - lhs_se.want_pointer = 1; - gfc_conv_expr_descriptor (&lhs_se, lhs_expr); - /* Using gfc_conv_expr_descriptor, we only get the descriptor, but that - has the wrong type if component references are done. */ - lhs_type = gfc_typenode_for_spec (&lhs_expr->ts); - tmp = build_fold_indirect_ref_loc (input_location, lhs_se.expr); - gfc_add_modify (&lhs_se.pre, gfc_conv_descriptor_dtype (tmp), - gfc_get_dtype_rank_type (has_vector ? ar2.dimen - : lhs_expr->rank, - lhs_type)); - if (has_vector) + else { - vec = conv_caf_vector_subscript (&block, lhs_se.expr, &ar2); - *ar = ar2; + /* Special casing for arr1 ([...]) = arr2[...], i.e. caf_get to + indexed array expression. This is rewritten to: + + tmp_array = arr2[...] + arr1 ([...]) = tmp_array + + because using the standard gfc_conv_expr (lhs_expr) did the + assignment with lhs and rhs exchanged. */ + + gfc_ss *lss_for_tmparray, *lss_real; + gfc_loopinfo loop; + gfc_se se; + stmtblock_t body; + tree tmparr_desc, src; + tree index = gfc_index_zero_node; + tree stride = gfc_index_zero_node; + int n; + + /* Walk both sides of the assignment, once to get the shape of the + temporary array to create right. */ + lss_for_tmparray = gfc_walk_expr (lhs_expr); + /* And a second time to be able to create an assignment of the + temporary to the lhs_expr. gfc_trans_create_temp_array replaces + the tree in the descriptor with the one for the temporary + array. */ + lss_real = gfc_walk_expr (lhs_expr); + gfc_init_loopinfo (&loop); + gfc_add_ss_to_loop (&loop, lss_for_tmparray); + gfc_add_ss_to_loop (&loop, lss_real); + gfc_conv_ss_startstride (&loop); + gfc_conv_loop_setup (&loop, &lhs_expr->where); + lhs_type = gfc_typenode_for_spec (&lhs_expr->ts); + gfc_trans_create_temp_array (&lhs_se.pre, &lhs_se.post, + lss_for_tmparray, lhs_type, NULL_TREE, + false, true, false, + &lhs_expr->where); + tmparr_desc = lss_for_tmparray->info->data.array.descriptor; + gfc_start_scalarized_body (&loop, &body); + gfc_init_se (&se, NULL); + gfc_copy_loopinfo_to_se (&se, &loop); + se.ss = lss_real; + gfc_conv_expr (&se, lhs_expr); + gfc_add_block_to_block (&body, &se.pre); + + /* Walk over all indexes of the loop. */ + for (n = loop.dimen - 1; n > 0; --n) + { + tmp = loop.loopvar[n]; + tmp = fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, tmp, loop.from[n]); + tmp = fold_build2_loc (input_location, PLUS_EXPR, + gfc_array_index_type, tmp, index); + + stride = fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, + loop.to[n - 1], loop.from[n - 1]); + stride = fold_build2_loc (input_location, PLUS_EXPR, + gfc_array_index_type, + stride, gfc_index_one_node); + + index = fold_build2_loc (input_location, MULT_EXPR, + gfc_array_index_type, tmp, stride); + } + + index = fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, + index, loop.from[0]); + + index = fold_build2_loc (input_location, PLUS_EXPR, + gfc_array_index_type, + loop.loopvar[0], index); + + src = build_fold_indirect_ref (gfc_conv_array_data (tmparr_desc)); + src = gfc_build_array_ref (src, index, NULL); + /* Now create the assignment of lhs_expr = tmp_array. */ + gfc_add_modify (&body, se.expr, src); + gfc_add_block_to_block (&body, &se.post); + lhs_se.expr = gfc_build_addr_expr (NULL_TREE, tmparr_desc); + gfc_trans_scalarizing_loops (&loop, &body); + gfc_add_block_to_block (&loop.pre, &loop.post); + gfc_add_expr_to_block (&lhs_se.post, gfc_finish_block (&loop.pre)); + gfc_free_ss (lss_for_tmparray); + gfc_free_ss (lss_real); } } diff --git a/gcc/fortran/trans-stmt.c b/gcc/fortran/trans-stmt.c index 79ec6c2e13b..ac90c97e544 100644 --- a/gcc/fortran/trans-stmt.c +++ b/gcc/fortran/trans-stmt.c @@ -1566,7 +1566,8 @@ trans_associate_var (gfc_symbol *sym, gfc_wrapped_block *block) desc = sym->backend_decl; cst_array_ctor = e->expr_type == EXPR_ARRAY - && gfc_constant_array_constructor_p (e->value.constructor); + && gfc_constant_array_constructor_p (e->value.constructor) + && e->ts.type != BT_CHARACTER; /* If association is to an expression, evaluate it and create temporary. Otherwise, get descriptor of target for pointer assignment. */ diff --git a/gcc/fortran/trans-types.c b/gcc/fortran/trans-types.c index 724c0fa979f..9a96ae7b69d 100644 --- a/gcc/fortran/trans-types.c +++ b/gcc/fortran/trans-types.c @@ -2168,6 +2168,14 @@ gfc_sym_type (gfc_symbol * sym) if (sym->backend_decl && !sym->attr.function) return TREE_TYPE (sym->backend_decl); + if (sym->attr.result + && sym->ts.type == BT_CHARACTER + && sym->ts.u.cl->backend_decl == NULL_TREE + && sym->ns->proc_name + && sym->ns->proc_name->ts.u.cl + && sym->ns->proc_name->ts.u.cl->backend_decl != NULL_TREE) + sym->ts.u.cl->backend_decl = sym->ns->proc_name->ts.u.cl->backend_decl; + if (sym->ts.type == BT_CHARACTER && ((sym->attr.function && sym->attr.is_bind_c) || (sym->attr.result diff --git a/gcc/fortran/trans.h b/gcc/fortran/trans.h index d02f3470eeb..4fcc389a53b 100644 --- a/gcc/fortran/trans.h +++ b/gcc/fortran/trans.h @@ -431,7 +431,7 @@ tree gfc_vptr_deallocate_get (tree); void gfc_reset_vptr (stmtblock_t *, gfc_expr *); void gfc_reset_len (stmtblock_t *, gfc_expr *); tree gfc_get_vptr_from_expr (tree); -tree gfc_get_class_array_ref (tree, tree, tree); +tree gfc_get_class_array_ref (tree, tree, tree, bool); tree gfc_copy_class_to_class (tree, tree, tree, bool); bool gfc_add_finalizer_call (stmtblock_t *, gfc_expr *); bool gfc_add_comp_finalizer_call (stmtblock_t *, tree, gfc_component *, bool); diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c index 2b68c2b1b0a..3e19c4b603e 100644 --- a/gcc/gimple-ssa-strength-reduction.c +++ b/gcc/gimple-ssa-strength-reduction.c @@ -266,6 +266,10 @@ struct slsr_cand_d of a statement. */ cand_idx next_interp; + /* Index of the first candidate record in a chain for the same + statement. */ + cand_idx first_interp; + /* Index of the basis statement S0, if any, in the candidate vector. */ cand_idx basis; @@ -643,6 +647,7 @@ alloc_cand_and_find_basis (enum cand_kind kind, gimple *gs, tree base, c->kind = kind; c->cand_num = cand_vec.length () + 1; c->next_interp = 0; + c->first_interp = c->cand_num; c->dependent = 0; c->sibling = 0; c->def_phi = kind == CAND_MULT ? find_phi_def (base) : 0; @@ -1213,6 +1218,7 @@ slsr_process_mul (gimple *gs, tree rhs1, tree rhs2, bool speed) is the stride and RHS2 is the base expression. */ c2 = create_mul_ssa_cand (gs, rhs2, rhs1, speed); c->next_interp = c2->cand_num; + c2->first_interp = c->cand_num; } else { @@ -1450,7 +1456,10 @@ slsr_process_add (gimple *gs, tree rhs1, tree rhs2, bool speed) { c2 = create_add_ssa_cand (gs, rhs2, rhs1, false, speed); if (c) - c->next_interp = c2->cand_num; + { + c->next_interp = c2->cand_num; + c2->first_interp = c->cand_num; + } else add_cand_for_stmt (gs, c2); } @@ -1573,6 +1582,8 @@ slsr_process_cast (gimple *gs, tree rhs1, bool speed) if (base_cand && base_cand->kind != CAND_PHI) { + slsr_cand_t first_cand = NULL; + while (base_cand) { /* Propagate all data from the base candidate except the type, @@ -1587,6 +1598,12 @@ slsr_process_cast (gimple *gs, tree rhs1, bool speed) base_cand->index, base_cand->stride, ctype, base_cand->stride_type, savings); + if (!first_cand) + first_cand = c; + + if (first_cand != c) + c->first_interp = first_cand->cand_num; + if (base_cand->next_interp) base_cand = lookup_cand (base_cand->next_interp); else @@ -1609,6 +1626,7 @@ slsr_process_cast (gimple *gs, tree rhs1, bool speed) c2 = alloc_cand_and_find_basis (CAND_MULT, gs, rhs1, 0, integer_one_node, ctype, sizetype, 0); c->next_interp = c2->cand_num; + c2->first_interp = c->cand_num; } /* Add the first (or only) interpretation to the statement-candidate @@ -1633,6 +1651,8 @@ slsr_process_copy (gimple *gs, tree rhs1, bool speed) if (base_cand && base_cand->kind != CAND_PHI) { + slsr_cand_t first_cand = NULL; + while (base_cand) { /* Propagate all data from the base candidate. */ @@ -1645,6 +1665,12 @@ slsr_process_copy (gimple *gs, tree rhs1, bool speed) base_cand->index, base_cand->stride, base_cand->cand_type, base_cand->stride_type, savings); + if (!first_cand) + first_cand = c; + + if (first_cand != c) + c->first_interp = first_cand->cand_num; + if (base_cand->next_interp) base_cand = lookup_cand (base_cand->next_interp); else @@ -1669,6 +1695,7 @@ slsr_process_copy (gimple *gs, tree rhs1, bool speed) integer_one_node, TREE_TYPE (rhs1), sizetype, 0); c->next_interp = c2->cand_num; + c2->first_interp = c->cand_num; } /* Add the first (or only) interpretation to the statement-candidate @@ -1839,8 +1866,9 @@ dump_candidate (slsr_cand_t c) print_generic_expr (dump_file, c->cand_type, 0); fprintf (dump_file, "\n basis: %d dependent: %d sibling: %d\n", c->basis, c->dependent, c->sibling); - fprintf (dump_file, " next-interp: %d dead-savings: %d\n", - c->next_interp, c->dead_savings); + fprintf (dump_file, + " next-interp: %d first-interp: %d dead-savings: %d\n", + c->next_interp, c->first_interp, c->dead_savings); if (c->def_phi) fprintf (dump_file, " phi: %d\n", c->def_phi); fputs ("\n", dump_file); @@ -2098,14 +2126,13 @@ replace_mult_candidate (slsr_cand_t c, tree basis_name, widest_int bump) tree lhs = gimple_assign_lhs (c->cand_stmt); gassign *copy_stmt = gimple_build_assign (lhs, basis_name); gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt); - slsr_cand_t cc = c; + slsr_cand_t cc = lookup_cand (c->first_interp); gimple_set_location (copy_stmt, gimple_location (c->cand_stmt)); gsi_replace (&gsi, copy_stmt, false); - c->cand_stmt = copy_stmt; - while (cc->next_interp) + while (cc) { - cc = lookup_cand (cc->next_interp); cc->cand_stmt = copy_stmt; + cc = cc->next_interp ? lookup_cand (cc->next_interp) : NULL; } if (dump_file && (dump_flags & TDF_DETAILS)) stmt_to_print = copy_stmt; @@ -2132,15 +2159,14 @@ replace_mult_candidate (slsr_cand_t c, tree basis_name, widest_int bump) else { gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt); - slsr_cand_t cc = c; + slsr_cand_t cc = lookup_cand (c->first_interp); gimple_assign_set_rhs_with_ops (&gsi, code, basis_name, bump_tree); update_stmt (gsi_stmt (gsi)); - c->cand_stmt = gsi_stmt (gsi); - while (cc->next_interp) + while (cc) { - cc = lookup_cand (cc->next_interp); cc->cand_stmt = gsi_stmt (gsi); + cc = cc->next_interp ? lookup_cand (cc->next_interp) : NULL; } if (dump_file && (dump_flags & TDF_DETAILS)) stmt_to_print = gsi_stmt (gsi); @@ -3426,14 +3452,13 @@ replace_rhs_if_not_dup (enum tree_code new_code, tree new_rhs1, tree new_rhs2, || !operand_equal_p (new_rhs2, old_rhs1, 0)))) { gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt); - slsr_cand_t cc = c; + slsr_cand_t cc = lookup_cand (c->first_interp); gimple_assign_set_rhs_with_ops (&gsi, new_code, new_rhs1, new_rhs2); update_stmt (gsi_stmt (gsi)); - c->cand_stmt = gsi_stmt (gsi); - while (cc->next_interp) + while (cc) { - cc = lookup_cand (cc->next_interp); cc->cand_stmt = gsi_stmt (gsi); + cc = cc->next_interp ? lookup_cand (cc->next_interp) : NULL; } if (dump_file && (dump_flags & TDF_DETAILS)) @@ -3466,6 +3491,11 @@ replace_one_candidate (slsr_cand_t c, unsigned i, tree basis_name) orig_rhs2 = gimple_assign_rhs2 (c->cand_stmt); cand_incr = cand_increment (c); + /* If orig_rhs2 is NULL, we have already replaced this in situ with + a copy statement under another interpretation. */ + if (!orig_rhs2) + return; + if (dump_file && (dump_flags & TDF_DETAILS)) { fputs ("Replacing: ", dump_file); @@ -3538,14 +3568,13 @@ replace_one_candidate (slsr_cand_t c, unsigned i, tree basis_name) || !operand_equal_p (rhs2, orig_rhs2, 0)) { gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt); - slsr_cand_t cc = c; + slsr_cand_t cc = lookup_cand (c->first_interp); gimple_assign_set_rhs_with_ops (&gsi, MINUS_EXPR, basis_name, rhs2); update_stmt (gsi_stmt (gsi)); - c->cand_stmt = gsi_stmt (gsi); - while (cc->next_interp) + while (cc) { - cc = lookup_cand (cc->next_interp); cc->cand_stmt = gsi_stmt (gsi); + cc = cc->next_interp ? lookup_cand (cc->next_interp) : NULL; } if (dump_file && (dump_flags & TDF_DETAILS)) @@ -3565,14 +3594,13 @@ replace_one_candidate (slsr_cand_t c, unsigned i, tree basis_name) { gassign *copy_stmt = gimple_build_assign (lhs, basis_name); gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt); - slsr_cand_t cc = c; + slsr_cand_t cc = lookup_cand (c->first_interp); gimple_set_location (copy_stmt, gimple_location (c->cand_stmt)); gsi_replace (&gsi, copy_stmt, false); - c->cand_stmt = copy_stmt; - while (cc->next_interp) + while (cc) { - cc = lookup_cand (cc->next_interp); cc->cand_stmt = copy_stmt; + cc = cc->next_interp ? lookup_cand (cc->next_interp) : NULL; } if (dump_file && (dump_flags & TDF_DETAILS)) @@ -3582,14 +3610,13 @@ replace_one_candidate (slsr_cand_t c, unsigned i, tree basis_name) { gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt); gassign *cast_stmt = gimple_build_assign (lhs, NOP_EXPR, basis_name); - slsr_cand_t cc = c; + slsr_cand_t cc = lookup_cand (c->first_interp); gimple_set_location (cast_stmt, gimple_location (c->cand_stmt)); gsi_replace (&gsi, cast_stmt, false); - c->cand_stmt = cast_stmt; - while (cc->next_interp) + while (cc) { - cc = lookup_cand (cc->next_interp); cc->cand_stmt = cast_stmt; + cc = cc->next_interp ? lookup_cand (cc->next_interp) : NULL; } if (dump_file && (dump_flags & TDF_DETAILS)) diff --git a/gcc/gimplify.c b/gcc/gimplify.c index 5264a4f3d40..2a7951f16b3 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -1125,10 +1125,6 @@ static void asan_poison_variable (tree decl, bool poison, gimple_stmt_iterator *it, bool before) { - /* When within an OMP context, do not emit ASAN_MARK internal fns. */ - if (gimplify_omp_ctxp) - return; - tree unit_size = DECL_SIZE_UNIT (decl); tree base = build_fold_addr_expr (decl); @@ -1640,7 +1636,8 @@ gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p) && TREE_ADDRESSABLE (decl) && !TREE_STATIC (decl) && !DECL_HAS_VALUE_EXPR_P (decl) - && dbg_cnt (asan_use_after_scope)) + && dbg_cnt (asan_use_after_scope) + && !gimplify_omp_ctxp) { asan_poisoned_variables->add (decl); asan_poison_variable (decl, false, seq_p); @@ -4684,7 +4681,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, objects. Initializers for such objects must explicitly set every field that needs to be set. */ cleared = false; - else if (!complete_p && !CONSTRUCTOR_NO_CLEARING (ctor)) + else if (!complete_p) /* If the constructor isn't complete, clear the whole object beforehand, unless CONSTRUCTOR_NO_CLEARING is set on it. @@ -4693,7 +4690,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, we'd need to *find* the elements that are not present, and that requires trickery to avoid quadratic compile-time behavior in large cases or excessive memory use in small cases. */ - cleared = true; + cleared = !CONSTRUCTOR_NO_CLEARING (ctor); else if (num_ctor_elements - num_nonzero_elements > CLEAR_RATIO (optimize_function_for_speed_p (cfun)) && num_nonzero_elements < num_ctor_elements / 4) @@ -5776,8 +5773,11 @@ gimplify_save_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) } else /* The temporary may not be an SSA name as later abnormal and EH - control flow may invalidate use/def domination. */ - val = get_initialized_tmp_var (val, pre_p, post_p, false); + control flow may invalidate use/def domination. When in SSA + form then assume there are no such issues and SAVE_EXPRs only + appear via GENERIC foldings. */ + val = get_initialized_tmp_var (val, pre_p, post_p, + gimple_in_ssa_p (cfun)); TREE_OPERAND (*expr_p, 0) = val; SAVE_EXPR_RESOLVED_P (*expr_p) = 1; @@ -6458,7 +6458,8 @@ gimplify_target_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) clobber = build2 (MODIFY_EXPR, TREE_TYPE (temp), temp, clobber); gimple_push_cleanup (temp, clobber, false, pre_p, true); } - if (asan_poisoned_variables && dbg_cnt (asan_use_after_scope)) + if (asan_poisoned_variables && dbg_cnt (asan_use_after_scope) + && !gimplify_omp_ctxp) { tree asan_cleanup = build_asan_poison_call_expr (temp); if (asan_cleanup) diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c index f5dcfc0341b..3902d3a8a00 100644 --- a/gcc/ipa-cp.c +++ b/gcc/ipa-cp.c @@ -4027,7 +4027,9 @@ intersect_with_plats (struct ipcp_param_lattices *plats, if (aglat->offset - offset == item->offset) { gcc_checking_assert (item->value); - if (values_equal_for_ipcp_p (item->value, aglat->values->value)) + if (aglat->is_single_const () + && values_equal_for_ipcp_p (item->value, + aglat->values->value)) found = true; break; } diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c index 0d214170c24..c1b7aa3bea6 100644 --- a/gcc/ipa-devirt.c +++ b/gcc/ipa-devirt.c @@ -1577,8 +1577,15 @@ odr_types_equivalent_p (tree t1, tree t2, bool warn, bool *warned, "in another translation unit")); return false; } - gcc_assert (DECL_NONADDRESSABLE_P (f1) - == DECL_NONADDRESSABLE_P (f2)); + if (DECL_BIT_FIELD (f1) != DECL_BIT_FIELD (f2)) + { + warn_odr (t1, t2, f1, f2, warn, warned, + G_("one field is bitfield while other is not")); + return false; + } + else + gcc_assert (DECL_NONADDRESSABLE_P (f1) + == DECL_NONADDRESSABLE_P (f2)); } /* If one aggregate has more fields than the other, they diff --git a/gcc/ipa-icf.c b/gcc/ipa-icf.c index 95fad30e83a..c8ca9566cb7 100644 --- a/gcc/ipa-icf.c +++ b/gcc/ipa-icf.c @@ -2132,23 +2132,6 @@ sem_variable::get_hash (void) return m_hash; } -/* Set all points-to UIDs of aliases pointing to node N as UID. */ - -static void -set_alias_uids (symtab_node *n, int uid) -{ - ipa_ref *ref; - FOR_EACH_ALIAS (n, ref) - { - if (dump_file) - fprintf (dump_file, " Setting points-to UID of [%s] as %d\n", - xstrdup_for_dump (ref->referring->asm_name ()), uid); - - SET_DECL_PT_UID (ref->referring->decl, uid); - set_alias_uids (ref->referring, uid); - } -} - /* Merges instance with an ALIAS_ITEM, where alias, thunk or redirection can be applied. */ @@ -2275,7 +2258,6 @@ sem_variable::merge (sem_item *alias_item) if (dump_file) fprintf (dump_file, "Unified; Variable alias has been created.\n"); - set_alias_uids (original, DECL_UID (original->decl)); return true; } } @@ -2295,7 +2277,7 @@ unsigned int sem_item_optimizer::class_id = 0; sem_item_optimizer::sem_item_optimizer () : worklist (0), m_classes (0), m_classes_count (0), m_cgraph_node_hooks (NULL), - m_varpool_node_hooks (NULL) + m_varpool_node_hooks (NULL), m_merged_variables () { m_items.create (0); bitmap_obstack_initialize (&m_bmstack); @@ -2320,6 +2302,7 @@ sem_item_optimizer::~sem_item_optimizer () m_items.release (); bitmap_obstack_release (&m_bmstack); + m_merged_variables.release (); } /* Write IPA ICF summary for symbols. */ @@ -3571,13 +3554,103 @@ sem_item_optimizer::merge_classes (unsigned int prev_class_count) } if (dbg_cnt (merged_ipa_icf)) - merged_p |= source->merge (alias); + { + bool merged = source->merge (alias); + merged_p |= merged; + + if (merged && alias->type == VAR) + { + symtab_pair p = symtab_pair (source->node, alias->node); + m_merged_variables.safe_push (p); + } + } } } + if (!m_merged_variables.is_empty ()) + fixup_points_to_sets (); + return merged_p; } +/* Fixup points to set PT. */ + +void +sem_item_optimizer::fixup_pt_set (struct pt_solution *pt) +{ + if (pt->vars == NULL) + return; + + unsigned i; + symtab_pair *item; + FOR_EACH_VEC_ELT (m_merged_variables, i, item) + if (bitmap_bit_p (pt->vars, DECL_UID (item->second->decl))) + bitmap_set_bit (pt->vars, DECL_UID (item->first->decl)); +} + +/* Set all points-to UIDs of aliases pointing to node N as UID. */ + +static void +set_alias_uids (symtab_node *n, int uid) +{ + ipa_ref *ref; + FOR_EACH_ALIAS (n, ref) + { + if (dump_file) + fprintf (dump_file, " Setting points-to UID of [%s] as %d\n", + xstrdup_for_dump (ref->referring->asm_name ()), uid); + + SET_DECL_PT_UID (ref->referring->decl, uid); + set_alias_uids (ref->referring, uid); + } +} + +/* Fixup points to analysis info. */ + +void +sem_item_optimizer::fixup_points_to_sets (void) +{ + /* TODO: remove in GCC 9 and trigger PTA re-creation after IPA passes. */ + cgraph_node *cnode; + + FOR_EACH_DEFINED_FUNCTION (cnode) + { + tree name; + unsigned i; + function *fn = DECL_STRUCT_FUNCTION (cnode->decl); + if (!gimple_in_ssa_p (fn)) + continue; + + FOR_EACH_SSA_NAME (i, name, fn) + if (POINTER_TYPE_P (TREE_TYPE (name)) + && SSA_NAME_PTR_INFO (name)) + fixup_pt_set (&SSA_NAME_PTR_INFO (name)->pt); + fixup_pt_set (&fn->gimple_df->escaped); + + /* The above get's us to 99% I guess, at least catching the + address compares. Below also gets us aliasing correct + but as said we're giving leeway to the situation with + readonly vars anyway, so ... */ + basic_block bb; + FOR_EACH_BB_FN (bb, fn) + for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi); + gsi_next (&gsi)) + { + gcall *call = dyn_cast<gcall *> (gsi_stmt (gsi)); + if (call) + { + fixup_pt_set (gimple_call_use_set (call)); + fixup_pt_set (gimple_call_clobber_set (call)); + } + } + } + + unsigned i; + symtab_pair *item; + FOR_EACH_VEC_ELT (m_merged_variables, i, item) + set_alias_uids (item->first, DECL_UID (item->first->decl)); +} + /* Dump function prints all class members to a FILE with an INDENT. */ void diff --git a/gcc/ipa-icf.h b/gcc/ipa-icf.h index c57224c1517..2101747bfd6 100644 --- a/gcc/ipa-icf.h +++ b/gcc/ipa-icf.h @@ -141,6 +141,8 @@ public: unsigned int index; }; +typedef std::pair<symtab_node *, symtab_node *> symtab_pair; + /* Semantic item is a base class that encapsulates all shared functionality for both semantic function and variable items. */ class sem_item @@ -563,6 +565,12 @@ private: processed. */ bool merge_classes (unsigned int prev_class_count); + /* Fixup points to analysis info. */ + void fixup_points_to_sets (void); + + /* Fixup points to set PT. */ + void fixup_pt_set (struct pt_solution *pt); + /* Adds a newly created congruence class CLS to worklist. */ void worklist_push (congruence_class *cls); @@ -632,6 +640,10 @@ private: /* Bitmap stack. */ bitmap_obstack m_bmstack; + + /* Vector of merged variables. Needed for fixup of points-to-analysis + info. */ + vec <symtab_pair> m_merged_variables; }; // class sem_item_optimizer } // ipa_icf namespace diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog index 1ebbb907ec1..17431acfe90 100644 --- a/gcc/lto/ChangeLog +++ b/gcc/lto/ChangeLog @@ -1,3 +1,29 @@ +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-04-19 Martin Liska <mliska@suse.cz> + + * lto-symtab.c (lto_symtab_resolve_symbols): Do not bail out + for multiple PREVAILING_DEF_IRONLY for common symbols. + +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-04-10 Martin Liska <mliska@suse.cz> + + PR lto/85248 + * lto-symtab.c (lto_symtab_merge_p): Do not check for + TREE_VALUES of error attributes. + +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-04-10 Richard Biener <rguenther@suse.de> + Martin Liska <mliska@suse.cz> + + PR lto/85248 + * lto-symtab.c (lto_symtab_merge_p): Handle noreturn attribute. + 2018-03-06 Martin Liska <mliska@suse.cz> Backport from mainline diff --git a/gcc/lto/lto-symtab.c b/gcc/lto/lto-symtab.c index 10c3fbe49f3..01cc0b7602e 100644 --- a/gcc/lto/lto-symtab.c +++ b/gcc/lto/lto-symtab.c @@ -465,9 +465,14 @@ lto_symtab_resolve_symbols (symtab_node *first) /* If the chain is already resolved there is nothing else to do. */ if (prevailing) { - /* Assert it's the only one. */ + /* Assert it's the only one. + GCC should silence multiple PREVAILING_DEF_IRONLY defs error + on COMMON symbols since it isn't error. + See: https://sourceware.org/bugzilla/show_bug.cgi?id=23079. */ for (e = prevailing->next_sharing_asm_name; e; e = e->next_sharing_asm_name) if (lto_symtab_symbol_p (e) + && !DECL_COMMON (prevailing->decl) + && !DECL_COMMON (e->decl) && (e->resolution == LDPR_PREVAILING_DEF_IRONLY || e->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP || e->resolution == LDPR_PREVAILING_DEF)) @@ -571,6 +576,9 @@ lto_symtab_merge_p (tree prevailing, tree decl) return false; } } + + /* FIXME: after MPX is removed, use flags_from_decl_or_type + function instead. PR lto/85248. */ if (DECL_ATTRIBUTES (prevailing) != DECL_ATTRIBUTES (decl)) { tree prev_attr = lookup_attribute ("error", DECL_ATTRIBUTES (prevailing)); @@ -598,6 +606,16 @@ lto_symtab_merge_p (tree prevailing, tree decl) "warning attribute mismatch\n"); return false; } + + prev_attr = lookup_attribute ("noreturn", DECL_ATTRIBUTES (prevailing)); + attr = lookup_attribute ("noreturn", DECL_ATTRIBUTES (decl)); + if ((prev_attr == NULL) != (attr == NULL)) + { + if (symtab->dump_file) + fprintf (symtab->dump_file, "Not merging decls; " + "noreturn attribute mismatch\n"); + return false; + } } return true; } diff --git a/gcc/omp-expand.c b/gcc/omp-expand.c index a1e668d99d2..549a5db000a 100644 --- a/gcc/omp-expand.c +++ b/gcc/omp-expand.c @@ -5628,6 +5628,14 @@ expand_oacc_for (struct omp_region *region, struct omp_for_data *fd) split->flags ^= EDGE_FALLTHRU | EDGE_TRUE_VALUE; + /* Add a dummy exit for the tiled block when cont_bb is missing. */ + if (cont_bb == NULL) + { + edge e = make_edge (body_bb, exit_bb, EDGE_FALSE_VALUE); + e->probability = PROB_EVEN; + split->probability = PROB_EVEN; + } + /* Initialize the user's loop vars. */ gsi = gsi_start_bb (elem_body_bb); expand_oacc_collapse_vars (fd, true, &gsi, counts, e_offset); diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 248c5d57fdc..c0cc3694262 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,383 @@ +2018-06-22 Andre Vieira <andre.simoesdiasvieira@arm.com> + + Backport from mainline + 2018-06-05 Andre Vieira <andre.simoesdiasvieira@arm.com> + + * gcc.target/arm/cmse/cmse-1c99.c: New test. + +2018-06-19 Eric Botcazou <ebotcazou@adacore.com> + + * gnat.dg/aggr24.adb: New test. + * gnat.dg/aggr24_pkg.ad[sb]: New helper. + +2018-06-18 Martin Sebor <msebor@redhat.com> + + PR middle-end/82063 + * gcc.dg/Walloc-size-larger-than-1.c: New test. + * gcc.dg/Walloc-size-larger-than-10.c: New test. + * gcc.dg/Walloc-size-larger-than-11.c: New test. + * gcc.dg/Walloc-size-larger-than-12.c: New test. + * gcc.dg/Walloc-size-larger-than-13.c: New test. + * gcc.dg/Walloc-size-larger-than-14.c: New test. + * gcc.dg/Walloc-size-larger-than-15.c: New test. + * gcc.dg/Walloc-size-larger-than-16.c: New test. + * gcc.dg/Walloc-size-larger-than-2.c: New test. + * gcc.dg/Walloc-size-larger-than-3.c: New test. + * gcc.dg/Walloc-size-larger-than-4.c: New test. + * gcc.dg/Walloc-size-larger-than-5.c: New test. + * gcc.dg/Walloc-size-larger-than-6.c: New test. + * gcc.dg/Walloc-size-larger-than-7.c: New test. + * gcc.dg/Walloc-size-larger-than-8.c: New test. + * gcc.dg/Walloc-size-larger-than-9.c: New test. + * gcc.dg/Walloc-size-larger-than.c: New test. + +2018-06-13 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/86110 + * gfortran.dg/pr86110.f90: New test. + +2018-06-12 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/44491 + * gfortran.dg/pr44491.f90: New testcase + +2018-06-11 Peter Bergner <bergner@vnet.ibm.com> + + Backport from mainline + 2018-06-08 Peter Bergner <bergner@vnet.ibm.com> + + PR target/85755 + * gcc.target/powerpc/pr85755.c: New test. + +2018-06-09 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/38351 + * gfortran.dg/pr38351.f90: New test. + * gfortran.dg/typebound_operator_4.f03: Adjust for new error message. + +2018-06-09 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/63514 + * gfortran.dg/pr63514.f90: New test. + +2018-06-09 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/78278 + * gfortran.dg/data_bounds_1.f90: Add -std=gnu option. + * gfortran.dg/data_char_1.f90: Ditto. + * gfortran.dg/pr78571.f90: Ditto. + * gfortran.dg/pr78278.f90: New test. + +2018-06-09 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/86059 + * gfortran.dg/associate_30.f90: Remove code tested ... + * gfortran.dg/pr67803.f90: Ditto. + * gfortran.dg/pr67805.f90: Ditto. + * gfortran.dg/pr86059.f90: ... here. New test. + +2018-06-09 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85138 + PR fortran/85996 + PR fortran/86051 + * gfortran.dg/pr85138_1.f90: New test. + * gfortran.dg/pr85138_2.f90: Ditto. + * gfortran.dg/pr85996.f90: Ditto. + +2018-06-07 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/86045 + Backport from trunk. + * gfortran.dg/pr86045.f90: New test. + +2018-06-07 Thomas Koenig <tkoenig@gcc.gnu.org> + + PR fortran/85641 + Backport from trunk. + * gfortran.dg/realloc_on_assign_30.f90: New test. + +2018-06-07 Richard Biener <rguenther@suse.de> + + Backport from mainline + 2018-05-04 Richard Biener <rguenther@suse.de> + + PR middle-end/85588 + * gcc.dg/torture/pr85588.c: New testcase. + * gcc.dg/torture/pr57656.c: Use dg-additional-options. + + 2018-05-02 Richard Biener <rguenther@suse.de> + + PR middle-end/85567 + * gcc.dg/torture/pr85567.c: New testcase. + + 2018-05-02 Richard Biener <rguenther@suse.de> + + PR tree-optimization/85597 + * gcc.dg/vect/pr85597.c: New testcase. + +2018-06-05 Andreas Krebbel <krebbel@linux.ibm.com> + + Backport from mainline + 2018-06-05 Andreas Krebbel <krebbel@linux.ibm.com> + + * gcc.target/s390/htm-builtins-compile-4.c: New test. + +2018-06-04 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85981 + * gfortran.dg/allocate_alloc_opt_14.f90: New test. + * gfortran.dg/allocate_alloc_opt_1.f90: Update error string. + * gfortran.dg/allocate_stat_2.f90: Ditto. + * gfortran.dg/deallocate_alloc_opt_1.f90: Ditto. + +2018-06-02 Eric Botcazou <ebotcazou@adacore.com> + + * gnat.dg/specs/opt3.ads: New test. + * gnat.dg/specs/opt3_pkg.ads: New helper. + +2018-06-02 Eric Botcazou <ebotcazou@adacore.com> + + * gnat.dg/discr53.ad[sb]: New test. + * gnat.dg/discr53_pkg.ads: New helper. + +2018-05-25 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85543 + Backport from trunk + * gfortran.dg/pr85543.f90: New test. + +2018-05-25 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85779 + Backport from trunk + * gfortran.dg/pr85779_1.f90: New test. + * gfortran.dg/pr85779_2.f90: Ditto. + * gfortran.dg/pr85779_3.f90: Ditto. + +2018-05-25 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85780 + Backport from trunk + * gfortran.dg/pr85780.f90: New test. + +2018-05-25 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85895 + Backport from trunk + * gfortran.dg/coarray_3.f90: Fix invalid testcase. + * gfortran.dg/pr85895.f90: New test. + +2018-05-24 Uros Bizjak <ubizjak@gmail.com> + + * gcc.target/i386/avx512f-vcvtusi2sd64-1.c: Update scan string. + * gcc.target/i386/avx512f-vcvtusi2ss64-1.c: Ditto. + +2018-05-21 Pat Haugen <pthaugen@us.ibm.com> + + Backport from mainline: + 2018-05-17 Pat Haugen <pthaugen@us.ibm.com> + + PR target/85698 + * gcc.target/powerpc/pr85698.c: New test. + +2018-05-20 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/80657 + Backport from trunk + * gfortran.dg/char_result_18.f90: New test. + +2018-05-20 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/82275 + Backport from trunk + * gfortran.dg/select_type_42.f90: New test. + +2018-05-19 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/82923 + Backport from trunk + * gfortran.dg/allocate_assumed_charlen_4.f90: New test. Note + that the patch fixes PR66694 & PR82617, although the testcases + are not explicitly included. + +2017-05-17 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/82814 + Backport from trunk + * gfortran.dg/submodule_31.f08: New test. + +2018-05-16 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/83149 + Backport from trunk + * gfortran.dg/pr83149_1.f90: New test. + * gfortran.dg/pr83149.f90: Additional source for previous. + * gfortran.dg/pr83149_b.f90: New test. + * gfortran.dg/pr83149_a.f90: Additional source for previous. + +2018-16-05 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/83898 + Backport from trunk + * gfortran.dg/associate_33.f03 : New test. + +2018-05-16 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/84546 + Backport from trunk + * gfortran.dg/unlimited_polymorphic_29.f90 : New test. + +2018-05-12 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85542 + Backport from trunk + * gfortran.dg/pr85542.f90: New test. + +2018-05-12 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/68846 + Backport from trunk + * gfortran.dg/temporary_3.f90 : New test. + + PR fortran/70864 + Backport from trunk + * gfortran.dg/temporary_2.f90 : New test. + +2018-05-11 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/70870 + Backport from trunk + * gfortran.dg/pr70870_1.f90: New test. + +2018-05-11 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85521 + Backport from trunk + * gfortran.dg/pr85521_1.f90: New test. + * gfortran.dg/pr85521_2.f90: New test. + +2018-05-11 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85687 + Backport from trunk + * gfortran.dg/pr85687.f90: new test. + +2018-05-06 Andre Vehreschild <vehre@gcc.gnu.org> + + PR fortran/85507 + Backport from trunk. + * gfortran.dg/coarray_dependency_1.f90: New test. + * gfortran.dg/coarray_lib_comm_1.f90: Fix counting caf-expressions. + +2018-05-01 Kyrylo Tkachov <kyrylo.tkachov@arm.com> + + Backport from trunk + 2018-04-27 Kyrylo Tkachov <kyrylo.tkachov@arm.com> + + PR target/82518 + * lib/target-supports.exp (check_effective_target_vect_load_lanes): + Use check_effective_target_arm_little_endian. + +2018-04-28 Andre Vehreschild <vehre@gcc.gnu.org> + + PR fortran/81773 + PR fortran/83606 + Backport from trunk. + * gfortran.dg/coarray/get_to_indexed_array_1.f90: New test. + * gfortran.dg/coarray/get_to_indirect_array.f90: New test. + +2018-04-26 Richard Biener <rguenther@suse.de> + + Backport from mainline + 2018-04-09 Richard Biener <rguenther@suse.de> + + PR tree-optimization/85284 + * gcc.dg/torture/pr85284.c: New testcase. + + 2018-04-06 Richard Biener <rguenther@suse.de> + + PR middle-end/85244 + * gcc.dg/torture/pr85244-1.c: New testcase. + * gcc.dg/torture/pr85244-2.c: Likewise. + + 2018-04-04 Richard Biener <rguenther@suse.de> + + PR tree-optimization/85168 + * gcc.dg/torture/pr85168.c: New testcase. + + 2018-03-15 Richard Biener <rguenther@suse.de> + + PR c/84873 + * c-c++-common/pr84873.c: New testcase. + +2018-04-24 Steven G. Kargl <kargl@gcc.gnu.org> + + PR fortran/85520 + * gfortran.dg/pr85520.f90: New test. + +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-04-10 Jakub Jelinek <jakub@redhat.com> + + PR lto/85248 + * gcc.dg/lto/pr85248_0.c: New test. + * gcc.dg/lto/pr85248_1.c: New test. + +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-03-28 Jakub Jelinek <jakub@redhat.com> + Martin Liska <mliska@suse.cz> + + PR sanitizer/85081 + * g++.dg/asan/pr85081.C: New test. + +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-03-21 Martin Liska <mliska@suse.cz> + + PR ipa/84963 + * gfortran.dg/goacc/pr84963.f90: New test. + +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-03-13 Martin Liska <mliska@suse.cz> + + PR ipa/84658. + * g++.dg/ipa/pr84658.C: New test. + +2018-04-23 Aaron Sawdey <acsawdey@linux.ibm.com> + + Backport from mainline + 2018-04-16 Aaron Sawdey <acsawdey@linux.ibm.com> + + PR target/83660 + * gcc.target/powerpc/pr83660.C: New test. + +2018-04-23 Eric Botcazou <ebotcazou@adacore.com> + + * g++.dg/torture/pr85496.C: New test. + +2018-04-20 Peter Bergner <bergner@vnet.ibm.com> + + PR target/85436 + * go.dg/pr85436.go: New test. + + Backport from mainline + 2018-03-09 Peter Bergner <bergner@vnet.ibm.com> + + PR target/83969 + * gcc.target/powerpc/pr83969.c: New test. + +2018-04-19 Jonathan Wakely <jwakely@redhat.com> + + PR c++/85464 - missing location for -Wignored-qualifiers diagnostic + * g++.dg/diagnostic/pr85464.C: New. + 2018-04-18 Thomas Preud'homme <thomas.preudhomme@arm.com> Backport from mainline diff --git a/gcc/testsuite/c-c++-common/pr84873.c b/gcc/testsuite/c-c++-common/pr84873.c new file mode 100644 index 00000000000..5eb8a8df81d --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr84873.c @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-frounding-math" } */ + +int +i1 (int w3, int n9) +{ + return w3 >> ((long int)(1 + 0.1) + -!n9); +} diff --git a/gcc/testsuite/g++.dg/asan/pr85081.C b/gcc/testsuite/g++.dg/asan/pr85081.C new file mode 100644 index 00000000000..d7dec311450 --- /dev/null +++ b/gcc/testsuite/g++.dg/asan/pr85081.C @@ -0,0 +1,20 @@ +/* PR sanitizer/85081 */ +/* { dg-do run } */ +/* { dg-options "-fopenmp-simd" } */ +/* { dg-require-effective-target fopenmp } */ + +inline const int& max(const int& a, const int& b) +{ + return a < b ? b : a; +} + +int main() +{ + #pragma omp simd + for ( int i = 0; i < 20; ++i ) + { + const int j = max(i, 1); + } + + return 0; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/extern_template-4.C b/gcc/testsuite/g++.dg/cpp0x/extern_template-4.C new file mode 100644 index 00000000000..9f0c7d720ab --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/extern_template-4.C @@ -0,0 +1,23 @@ +// PR c++/85470 +// { dg-do compile { target c++11 } } + +template <class T> +struct StaticObject +{ + static T& create() + { + static T t; + return t; + } + + static T & instance; +}; + +template <class T> T & StaticObject<T>::instance = StaticObject<T>::create(); + +extern template class StaticObject<int>; + +void test() +{ + StaticObject<int>::instance; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-dependent1.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-dependent1.C new file mode 100644 index 00000000000..6fd2bb379bf --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-dependent1.C @@ -0,0 +1,19 @@ +// PR c++/85815 +// { dg-do compile { target c++11 } } + +template<class T> +class A { + static A* INSTANCE; + void foobar(); + void moo() {} +}; + +template<class T> +A<T>* A<T>::INSTANCE = nullptr; + +template<class T> +void A<T>::foobar() { + auto x = []() { + INSTANCE->moo(); + }; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/range-for35.C b/gcc/testsuite/g++.dg/cpp0x/range-for35.C new file mode 100644 index 00000000000..c77a5af5a44 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/range-for35.C @@ -0,0 +1,8 @@ +// PR c++/86060 +// { dg-options -Wpedantic } + +template <typename T> void foo(T (&a)[8]) { + for (int i : a) // { dg-warning "range-based" "" { target c++98_only } } + i; +} +void fn1() { foo<int>; } diff --git a/gcc/testsuite/g++.dg/cpp0x/range-for9.C b/gcc/testsuite/g++.dg/cpp0x/range-for9.C index 6a50ec36c14..eaa5b406880 100644 --- a/gcc/testsuite/g++.dg/cpp0x/range-for9.C +++ b/gcc/testsuite/g++.dg/cpp0x/range-for9.C @@ -5,6 +5,6 @@ void test() { int a[] = {0,1,2}; - for (int x : a) // { dg-error "range-based 'for'" } + for (int x : a) // { dg-error "range-based 'for'|forming reference" } ; } diff --git a/gcc/testsuite/g++.dg/cpp1z/decomp10.C b/gcc/testsuite/g++.dg/cpp1z/decomp10.C index f27cbfbc0d9..95d8bf6364e 100644 --- a/gcc/testsuite/g++.dg/cpp1z/decomp10.C +++ b/gcc/testsuite/g++.dg/cpp1z/decomp10.C @@ -20,7 +20,7 @@ void f3() { auto [ x ] = a3; } // { dg-error "get" } struct A3a { int i,j; int get(); } a3a; template<> struct std::tuple_size<A3a> { enum { value = 1 }; }; -void f3a() { auto [ x ] = a3a; } // { dg-error "get<0>" } +void f3a() { auto [ x ] = a3a; } // { dg-error "get" } struct A3b { int i,j; } a3b; int get(A3b&&); diff --git a/gcc/testsuite/g++.dg/cpp1z/decomp37.C b/gcc/testsuite/g++.dg/cpp1z/decomp37.C new file mode 100644 index 00000000000..dc47908cddf --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/decomp37.C @@ -0,0 +1,62 @@ +// { dg-additional-options -std=c++17 } +// { dg-do compile } + +#include <memory> +#include <tuple> +#include <string> + +struct X : private std::shared_ptr<int> +{ + std::string fun_payload; +}; + +template<int N> std::string& get(X& x) +{ + if constexpr(N==0) return x.fun_payload; +} + +namespace std { + template<> class tuple_size<X> : public std::integral_constant<int, 1> {}; + template<> class tuple_element<0, X> {public: using type = std::string;}; +} + +struct X2 : private std::shared_ptr<int> +{ + int fun_payload; + template <class T> void get(); +}; + +template<int N> int& get(X2& x) +{ + if constexpr(N==0) return x.fun_payload; +} + +namespace std { + template<> class tuple_size<X2> : public std::integral_constant<int, 1> {}; + template<> class tuple_element<0, X2> {public: using type = int;}; +} + +class X3 +{ + double fun_payload; +public: + template <int N> double& get() + { + if constexpr(N==0) return fun_payload; + } +}; + +namespace std { + template<> class tuple_size<X3> : public std::integral_constant<int, 1> {}; + template<> class tuple_element<0, X3> {public: using type = double;}; +} + +int main() +{ + X x; + auto& [b1] = x; + X2 x2; + auto& [b2] = x2; + X3 x3; + auto& [b3] = x3; +} diff --git a/gcc/testsuite/g++.dg/cpp1z/decomp38.C b/gcc/testsuite/g++.dg/cpp1z/decomp38.C new file mode 100644 index 00000000000..fc69c02e4d3 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/decomp38.C @@ -0,0 +1,48 @@ +// { dg-additional-options -std=c++17 } +// { dg-do compile } + +class X +{ + int a, b; + void f() + { + auto[x,y] = *this; + } +}; + +class X2 +{ + int a, b; + void f(X2& other) + { + auto[x,y] = other; + } +}; + +struct X3 +{ + friend void foo(); +private: + int a; +}; + +void foo() +{ + X3 x; + auto [a] = x; +} + +struct X4 +{ + int a; +}; + +struct X5 : private X4 +{ + friend void foo2(); +}; + +void foo2() { + X5 x; + auto [a] = x; +} diff --git a/gcc/testsuite/g++.dg/cpp1z/decomp4.C b/gcc/testsuite/g++.dg/cpp1z/decomp4.C index bc85263e986..30068592553 100644 --- a/gcc/testsuite/g++.dg/cpp1z/decomp4.C +++ b/gcc/testsuite/g++.dg/cpp1z/decomp4.C @@ -18,10 +18,10 @@ test (A &a, B &b, C &c, D &d, E &e, F &f, G &g, H &h, I &i) // { dg-warning "decomposition declaration only available with -std=c..1z or -std=gnu..1z" "" { target c++14_down } .-1 } auto [ k ] { b }; // { dg-error "cannot decompose class type 'B' because it has an anonymous union member" } // { dg-warning "decomposition declaration only available with -std=c..1z or -std=gnu..1z" "" { target c++14_down } .-1 } - auto [ l, l2 ] = c; // { dg-error "cannot decompose non-public member 'C::b' of 'C'" } + auto [ l, l2 ] = c; // { dg-error "cannot decompose inaccessible member 'C::b' of 'C'" } // { dg-warning "decomposition declaration only available with -std=c..1z or -std=gnu..1z" "" { target c++14_down } .-1 } auto [ m ] = d; // { dg-warning "decomposition declaration only available with -std=c..1z or -std=gnu..1z" "" { target c++14_down } } - auto [ n ] { e }; // { dg-error "cannot decompose non-public member 'E::a' of 'E'" } + auto [ n ] { e }; // { dg-error "cannot decompose inaccessible member 'E::a' of 'E'" } // { dg-warning "decomposition declaration only available with -std=c..1z or -std=gnu..1z" "" { target c++14_down } .-1 } auto [ o ] { f }; // { dg-warning "decomposition declaration only available with -std=c..1z or -std=gnu..1z" "" { target c++14_down } } auto & [ p ] { g }; // { dg-error "cannot decompose class type 'G': both it and its base class 'F' have non-static data members" } diff --git a/gcc/testsuite/g++.dg/diagnostic/pr85464.C b/gcc/testsuite/g++.dg/diagnostic/pr85464.C new file mode 100644 index 00000000000..ee8b65185e5 --- /dev/null +++ b/gcc/testsuite/g++.dg/diagnostic/pr85464.C @@ -0,0 +1,5 @@ +// { dg-options "-Wignored-qualifiers" } +struct Test { + operator int const(); // { dg-warning "type qualifiers ignored" } + operator int const() const; // { dg-warning "type qualifiers ignored" } +}; diff --git a/gcc/testsuite/g++.dg/ext/visibility/lambda1.C b/gcc/testsuite/g++.dg/ext/visibility/lambda1.C new file mode 100644 index 00000000000..359f8e4af5a --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/visibility/lambda1.C @@ -0,0 +1,14 @@ +// PR c++/85646 +// { dg-do compile { target c++11 } } +// { dg-additional-options -fvisibility=hidden } + +template<typename T> +void foo() { + struct inner { + inner() { + (void)([this] { }); + } + }; +} + +int main() { foo<int>(); } diff --git a/gcc/testsuite/g++.dg/ipa/pr84658.C b/gcc/testsuite/g++.dg/ipa/pr84658.C new file mode 100644 index 00000000000..6846e1832bd --- /dev/null +++ b/gcc/testsuite/g++.dg/ipa/pr84658.C @@ -0,0 +1,30 @@ +/* PR ipa/84658 */ +/* { dg-do run } */ +/* { dg-options "-O2 -fmerge-all-constants -std=c++11" } */ + +const int kTestCasesFoo[] = { 0, 1, 2, 3, 4, 5, 8, 15, 16, 17, 512, 1020, 1021, 1022, 1023, 1024 }; +const int kTestCasesBar[] = { 0, 1, 2, 3, 4, 5, 8, 15, 16, 17, 512, 1020, 1021, 1022, 1023, 1024 }; + +void Foo() { + __builtin_printf("foo:"); + for (int count : kTestCasesFoo) { + __builtin_printf("%d,", count); + } + __builtin_printf(";\n"); +} + +void Bar() { + __builtin_printf("bar:"); + for (int count : kTestCasesBar) { + __builtin_printf("%d,", count); + } + __builtin_printf(";\n"); +} + +int main() { + Foo(); + Bar(); +} + +/* { dg-output "foo:0,1,2,3,4,5,8,15,16,17,512,1020,1021,1022,1023,1024,;(\n|\n\r|\r)*" } */ +/* { dg-output "bar:0,1,2,3,4,5,8,15,16,17,512,1020,1021,1022,1023,1024,;(\n|\n\r|\r)*" } */ diff --git a/gcc/testsuite/g++.dg/torture/pr85496.C b/gcc/testsuite/g++.dg/torture/pr85496.C new file mode 100644 index 00000000000..3f504a37791 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr85496.C @@ -0,0 +1,18 @@ +// PR middle-end/85496 +// Reported by Marek Polacek <mpolacek@gcc.gnu.org> + +template <typename> class complex; +template <typename _Tp> complex<_Tp> operator*(complex<_Tp>, complex<_Tp>); +template <> struct complex<float> { _Complex float _M_value; }; +class A { + complex<float> _f0, _f1; + +public: + complex<float> &m_fn1() { return _f1; } +}; +complex<float> a; +void cos() { + A b; + complex<float> c; + b.m_fn1() = c * a; +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-1.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-1.c new file mode 100644 index 00000000000..2e0b76554f9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-1.c @@ -0,0 +1,19 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile } + { dg-options "-O -Walloc-size-larger-than=1KB -ftrack-macro-expansion=0" } */ + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + unsigned n = 0; + T (__builtin_malloc (n)); + + n = 1024; /* 1 kibibyte (KB or KiB) */ + T (__builtin_malloc (n)); + + n = 1025; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1025. exceeds maximum object size 1024" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-10.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-10.c new file mode 100644 index 00000000000..559309d5531 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-10.c @@ -0,0 +1,27 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile { target lp64 } } + { dg-options "-O -Walloc-size-larger-than=1PiB -ftrack-macro-expansion=0" } */ + +typedef __SIZE_TYPE__ size_t; + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + size_t n = 0; + T (__builtin_malloc (n)); + + n = (size_t)1024 * 1024 * 1024 * 1024 * 1024; /* 1 pebibyte (PiB) */ + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1125899906842625. exceeds maximum object size 1125899906842624" } */ + + n = __PTRDIFF_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ + + n = __SIZE_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-11.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-11.c new file mode 100644 index 00000000000..41e523c6958 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-11.c @@ -0,0 +1,27 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile { target lp64 } } + { dg-options "-O -Walloc-size-larger-than=1PB -ftrack-macro-expansion=0" } */ + +typedef __SIZE_TYPE__ size_t; + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + size_t n = 0; + T (__builtin_malloc (n)); + + n = (size_t)1000 * 1000 * 1000 * 1000 * 1000; /* 1 petabyte (PB) */ + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1000000000000001. exceeds maximum object size 1000000000000000" } */ + + n = __PTRDIFF_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ + + n = __SIZE_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-12.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-12.c new file mode 100644 index 00000000000..24269a8a102 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-12.c @@ -0,0 +1,27 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile { target lp64 } } + { dg-options "-O -Walloc-size-larger-than=1EiB -ftrack-macro-expansion=0" } */ + +typedef __SIZE_TYPE__ size_t; + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + size_t n = 0; + T (__builtin_malloc (n)); + + n = (size_t)1024 * 1024 * 1024 * 1024 * 1024 * 1024; /* 1 exbibyte (EiB) */ + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1152921504606846977. exceeds maximum object size 1152921504606846976" } */ + + n = __PTRDIFF_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ + + n = __SIZE_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-13.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-13.c new file mode 100644 index 00000000000..b96e3892bd8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-13.c @@ -0,0 +1,27 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile { target lp64 } } + { dg-options "-O -Walloc-size-larger-than=1EB -ftrack-macro-expansion=0" } */ + +typedef __SIZE_TYPE__ size_t; + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + size_t n = 0; + T (__builtin_malloc (n)); + + n = (size_t)1000 * 1000 * 1000 * 1000 * 1000 * 1000; /* 1 exabyte (EB) */ + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1000000000000000001. exceeds maximum object size 1000000000000000000" } */ + + n = __PTRDIFF_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ + + n = __SIZE_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-14.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-14.c new file mode 100644 index 00000000000..e632e2236a3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-14.c @@ -0,0 +1,30 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile } + { dg-options "-O -Walloc-size-larger-than=123456789123456789123456789123456789 -ftrack-macro-expansion=0" } */ + +typedef __SIZE_TYPE__ size_t; + +void sink (void*); + +#define T(x) sink (x) + +/* Verify that an exceedingly large -Walloc-size-larger-than argument + with no suffix is accepted and treated as infinite. */ + +void f (void) +{ + size_t n = 0; + T (__builtin_malloc (n)); + + n = __PTRDIFF_MAX__; + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); + + n = __SIZE_MAX__ - 1; + T (__builtin_malloc (n)); + + n = __SIZE_MAX__; + T (__builtin_malloc (n)); +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-15.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-15.c new file mode 100644 index 00000000000..b699cc09c22 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-15.c @@ -0,0 +1,30 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile } + { dg-options "-O -Walloc-size-larger-than=123456789123456789123456789123456789gb -ftrack-macro-expansion=0" } */ + +typedef __SIZE_TYPE__ size_t; + +void sink (void*); + +#define T(x) sink (x) + +/* Verify that an exceeingly large -Walloc-size-larger-than argument + with a valid suffic is accepted and treated as infinite. */ + +void f (void) +{ + size_t n = 0; + T (__builtin_malloc (n)); + + n = __PTRDIFF_MAX__; + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); + + n = __SIZE_MAX__ - 1; + T (__builtin_malloc (n)); + + n = __SIZE_MAX__; + T (__builtin_malloc (n)); +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-16.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-16.c new file mode 100644 index 00000000000..837b69a36d8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-16.c @@ -0,0 +1,32 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile } + { dg-options "-O -Walloc-size-larger-than=1zb -ftrack-macro-expansion=0" } */ + +typedef __SIZE_TYPE__ size_t; + +void sink (void*); + +#define T(x) sink (x) + +/* Verify that an invalid -Walloc-size-larger-than argument is diagnosed + and rejected without changing the default setting of PTRDIFF_MAX. */ + +void f (void) +{ + size_t n = 0; + T (__builtin_malloc (n)); + + n = __PTRDIFF_MAX__; + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ + + n = __SIZE_MAX__ - 1; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ + + n = __SIZE_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ +} + +/* { dg-warning "invalid argument .1zb. to .-Walloc-size-larger-than=." "" { target *-*-* } 0 } */ diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-2.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-2.c new file mode 100644 index 00000000000..1ded37b0b5c --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-2.c @@ -0,0 +1,20 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile } + { dg-options "-O -Walloc-size-larger-than=1KiB -ftrack-macro-expansion=0" } +*/ + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + unsigned n = 0; + T (__builtin_malloc (n)); + + n = 1024; /* 1 kibibyte (KB or KiB) */ + T (__builtin_malloc (n)); + + n = 1025; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1025. exceeds maximum object size 1024" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-3.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-3.c new file mode 100644 index 00000000000..500ddbf7c74 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-3.c @@ -0,0 +1,19 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile } + { dg-options "-O -Walloc-size-larger-than=1kB -ftrack-macro-expansion=0" } */ + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + unsigned n = 0; + T (__builtin_malloc (n)); + + n = 1000; /* 1 kilobyte (kB, not to be confused with KB or KiB) */ + T (__builtin_malloc (n)); + + n = 1001; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1001. exceeds maximum object size 1000" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-4.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-4.c new file mode 100644 index 00000000000..e4fde5a8eb9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-4.c @@ -0,0 +1,19 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile } + { dg-options "-O -Walloc-size-larger-than=1MiB -ftrack-macro-expansion=0" } */ + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + unsigned n = 0; + T (__builtin_malloc (n)); + + n = 1024 * 1024; /* 1 mebibyte (MiB) */ + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1048577. exceeds maximum object size 1048576" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-5.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-5.c new file mode 100644 index 00000000000..bfea259e0ad --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-5.c @@ -0,0 +1,25 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile } + { dg-options "-O -Walloc-size-larger-than=1MB -ftrack-macro-expansion=0" } */ + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + __SIZE_TYPE__ n = 0; + T (__builtin_malloc (n)); + + n = 1000 * 1000; /* 1 megabyte (MB) */ + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1000001. exceeds maximum object size 1000000" } */ + + n = __PTRDIFF_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size 1000000" } */ + + n = __SIZE_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size 1000000" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-6.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-6.c new file mode 100644 index 00000000000..1eb83a5f613 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-6.c @@ -0,0 +1,25 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile } + { dg-options "-O -Walloc-size-larger-than=1GiB -ftrack-macro-expansion=0" } */ + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + __SIZE_TYPE__ n = 0; + T (__builtin_malloc (n)); + + n = 1024 * 1024 * 1024; /* 1 gigibyte (GiB) */ + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1073741825. exceeds maximum object size 1073741824" } */ + + n = __PTRDIFF_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ + + n = __SIZE_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-7.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-7.c new file mode 100644 index 00000000000..5188203337d --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-7.c @@ -0,0 +1,25 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile } + { dg-options "-O -Walloc-size-larger-than=1GB -ftrack-macro-expansion=0" } */ + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + __SIZE_TYPE__ n = 0; + T (__builtin_malloc (n)); + + n = 1000 * 1000 * 1000; /* 1 gigabyte (GB) */ + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1000000001. exceeds maximum object size 1000000000" } */ + + n = __PTRDIFF_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ + + n = __SIZE_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-8.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-8.c new file mode 100644 index 00000000000..4f84a027d79 --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-8.c @@ -0,0 +1,27 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile { target lp64 } } + { dg-options "-O -Walloc-size-larger-than=1TiB -ftrack-macro-expansion=0" } */ + +typedef __SIZE_TYPE__ size_t; + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + size_t n = 0; + T (__builtin_malloc (n)); + + n = (size_t)1024 * 1024 * 1024 * 1024; /* 1 tebibyte (TiB) */ + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1099511627777. exceeds maximum object size 1099511627776" } */ + + n = __PTRDIFF_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ + + n = __SIZE_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than-9.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-9.c new file mode 100644 index 00000000000..f3927f1456e --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than-9.c @@ -0,0 +1,27 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile { target lp64 } } + { dg-options "-O -Walloc-size-larger-than=1TB -ftrack-macro-expansion=0" } */ + +typedef __SIZE_TYPE__ size_t; + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + size_t n = 0; + T (__builtin_malloc (n)); + + n = (size_t)1000 * 1000 * 1000 * 1000; /* 1 terabyte (TB) */ + T (__builtin_malloc (n)); + + n += 1; + T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1000000000001. exceeds maximum object size 1000000000000" } */ + + n = __PTRDIFF_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ + + n = __SIZE_MAX__; + T (__builtin_malloc (n)); /* { dg-warning "exceeds maximum object size" } */ +} diff --git a/gcc/testsuite/gcc.dg/Walloc-size-larger-than.c b/gcc/testsuite/gcc.dg/Walloc-size-larger-than.c new file mode 100644 index 00000000000..8096ff1d3dd --- /dev/null +++ b/gcc/testsuite/gcc.dg/Walloc-size-larger-than.c @@ -0,0 +1,13 @@ +/* PR middle-end/82063 - issues with arguments enabled by -Wall + { dg-do compile } + { dg-options "-Walloc-size-larger-than=0 -ftrack-macro-expansion=0" } */ + +void sink (void*); + +#define T(x) sink (x) + +void f (void) +{ + T (__builtin_malloc (0)); + T (__builtin_malloc (1)); /* { dg-warning "argument 1 value .1. exceeds maximum object size 0" } */ +} diff --git a/gcc/testsuite/gcc.dg/lto/pr85248_0.c b/gcc/testsuite/gcc.dg/lto/pr85248_0.c new file mode 100644 index 00000000000..df61ac976a5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/lto/pr85248_0.c @@ -0,0 +1,45 @@ +/* PR lto/85248 */ +/* { dg-lto-do run } */ +/* { dg-lto-options { { -flto -O2 } } } */ + +extern void test_alias (int s, int e) __asm__ (__USER_LABEL_PREFIX__ "test"); +extern void test_noreturn (int s, int e) __asm__ (__USER_LABEL_PREFIX__ "test") + __attribute__ ((__noreturn__)); + +extern inline __attribute__ ((__always_inline__, __gnu_inline__)) void +test (int s, int e) +{ + if (__builtin_constant_p (s) && s != 0) + test_noreturn (s, e); + else + test_alias (s, e); +} + +int +foo (void) +{ + static volatile int a; + return a; +} + +static void +bar (void) +{ + test (0, 1); + __builtin_exit (0); +} + +static void +baz () +{ + test (1, 0); +} + +int +main () +{ + if (foo ()) + baz (); + bar (); + __builtin_abort (); +} diff --git a/gcc/testsuite/gcc.dg/lto/pr85248_1.c b/gcc/testsuite/gcc.dg/lto/pr85248_1.c new file mode 100644 index 00000000000..5ce257181fb --- /dev/null +++ b/gcc/testsuite/gcc.dg/lto/pr85248_1.c @@ -0,0 +1,9 @@ +/* { dg-options "-fno-lto" } */ + +void +test (int s, int e) +{ + asm volatile ("" : "+g" (s), "+g" (e) : : "memory"); + if (s) + __builtin_abort (); +} diff --git a/gcc/testsuite/gcc.dg/torture/pr57656.c b/gcc/testsuite/gcc.dg/torture/pr57656.c index 4f3645e4693..02490140105 100644 --- a/gcc/testsuite/gcc.dg/torture/pr57656.c +++ b/gcc/testsuite/gcc.dg/torture/pr57656.c @@ -1,5 +1,5 @@ /* { dg-do run } */ -/* { dg-options "-fstrict-overflow" } */ +/* { dg-additional-options "-fstrict-overflow" } */ int main (void) { diff --git a/gcc/testsuite/gcc.dg/torture/pr85168.c b/gcc/testsuite/gcc.dg/torture/pr85168.c new file mode 100644 index 00000000000..cc5e6648c7e --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr85168.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target indirect_jumps } */ + +typedef struct { + struct { + char a; + } b; +} c; + +int d, f; +c *e; + +extern void i(void); +extern void sejtmp () __attribute__((returns_twice)); + +void g(void) +{ + c *h = e; + if (f) + { + i(); + h--; + if (d) + if (h->b.a) + i(); + } + if (h->b.a) + sejtmp(); + e = h; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr85244-1.c b/gcc/testsuite/gcc.dg/torture/pr85244-1.c new file mode 100644 index 00000000000..44716aa9e04 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr85244-1.c @@ -0,0 +1,19 @@ +/* { dg-do run } */ +/* { dg-additional-sources "pr85244-2.c" } */ + +struct s { + long a; + int b; + int tab[]; +}; + +extern const struct s val; +extern int idx; +extern void abort (void); + +int main() +{ + if (val.tab[0] != 42 || val.tab[1] != 1337 || val.tab[idx] != 1337) + abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr85244-2.c b/gcc/testsuite/gcc.dg/torture/pr85244-2.c new file mode 100644 index 00000000000..d57cb712420 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr85244-2.c @@ -0,0 +1,8 @@ +struct s { + long a; + int b; + int tab[]; +}; + +int idx = 1; +const struct s val = { 0, 0, { 42, 1337 } }; diff --git a/gcc/testsuite/gcc.dg/torture/pr85284.c b/gcc/testsuite/gcc.dg/torture/pr85284.c new file mode 100644 index 00000000000..80e2c5b247b --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr85284.c @@ -0,0 +1,20 @@ +/* { dg-do run } */ + +static int p[48], v; + +int +main () +{ + p[32] = 1; + for (int i = 48; i--;) + { + if (!p[i]) + continue; + if ((i & 7) > 2) + break; + v = i & 1; + } + if (v != 0) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr85567.c b/gcc/testsuite/gcc.dg/torture/pr85567.c new file mode 100644 index 00000000000..f20c69f4201 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr85567.c @@ -0,0 +1,16 @@ +/* { dg-do compile } */ + +extern void sincos(double x, double *sinx, double *cosx); + +void apply(void (*f)(double, double *, double *), + double x, double *sinx, double *cosx) +{ + f(x, sinx, cosx); + return; +} + +void apply_sincos(double x, double *sinx, double *cosx) +{ + apply(sincos, x, sinx, cosx); + return; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr85588.c b/gcc/testsuite/gcc.dg/torture/pr85588.c new file mode 100644 index 00000000000..5d95c96bc35 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr85588.c @@ -0,0 +1,4 @@ +/* { dg-do run } */ +/* { dg-additional-options "-fwrapv" } */ + +#include "pr57656.c" diff --git a/gcc/testsuite/gcc.dg/vect/pr85597.c b/gcc/testsuite/gcc.dg/vect/pr85597.c new file mode 100644 index 00000000000..cf615f9c464 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/pr85597.c @@ -0,0 +1,26 @@ +/* { dg-do compile } */ +/* { dg-options "-O3" } */ +/* { dg-additional-options "-mfma" { target { x86_64-*-* i?86-*-* } } } */ + +extern double fma (double, double, double); + +static inline void +bar (int i, double *D, double *S) +{ + while (i-- > 0) + { + D[0] = fma (1, S[0], D[0]); + D[1] = fma (1, S[1], D[1]); + D[2] = fma (1, S[2], D[2]); + D[3] = fma (1, S[3], D[3]); + D += 4; + S += 4; + } +} + +void +foo (double *d, double *s) +{ + bar (10, d, s); +} + diff --git a/gcc/testsuite/gcc.target/arm/cmse/cmse-1c99.c b/gcc/testsuite/gcc.target/arm/cmse/cmse-1c99.c new file mode 100644 index 00000000000..0f99dd341b7 --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/cmse/cmse-1c99.c @@ -0,0 +1,4 @@ +/* { dg-do compile } */ +/* { dg-options "-Os -mcmse -std=c99" } */ +/* This is a copy of cmse-1.c to test arm_mve.h ISO C compatibility. */ +#include "cmse-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-vcvtusi2sd64-1.c b/gcc/testsuite/gcc.target/i386/avx512f-vcvtusi2sd64-1.c index 8675450f0c4..66476c3013f 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-vcvtusi2sd64-1.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-vcvtusi2sd64-1.c @@ -1,7 +1,7 @@ /* { dg-do compile { target { ! ia32 } } } */ /* { dg-options "-mavx512f -O2" } */ -/* { dg-final { scan-assembler-times "vcvtusi2sd\[ \\t\]+\[^\{\n\]*%xmm\[0-9\]+(?:\n|\[ \\t\]+#)" 1 } } */ -/* { dg-final { scan-assembler-times "vcvtusi2sd\[ \\t\]+\[^%\n\]*%r\[^\{\n\]*\{ru-sae\}\[^\{\n\]*%xmm\[0-9\]+(?:\n|\[ \\t\]+#)" 1 } } */ +/* { dg-final { scan-assembler-times "vcvtusi2sdq\[ \\t\]+\[^\{\n\]*%xmm\[0-9\]+(?:\n|\[ \\t\]+#)" 1 } } */ +/* { dg-final { scan-assembler-times "vcvtusi2sdq\[ \\t\]+\[^%\n\]*%r\[^\{\n\]*\{ru-sae\}\[^\{\n\]*%xmm\[0-9\]+(?:\n|\[ \\t\]+#)" 1 } } */ #include <immintrin.h> diff --git a/gcc/testsuite/gcc.target/i386/avx512f-vcvtusi2ss64-1.c b/gcc/testsuite/gcc.target/i386/avx512f-vcvtusi2ss64-1.c index 38ecf39ad65..f4dae536873 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-vcvtusi2ss64-1.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-vcvtusi2ss64-1.c @@ -1,7 +1,7 @@ /* { dg-do compile { target { ! ia32 } } } */ /* { dg-options "-mavx512f -O2" } */ -/* { dg-final { scan-assembler-times "vcvtusi2ss\[ \\t\]+\[^\{\n\]*%xmm\[0-9\]+(?:\n|\[ \\t\]+#)" 1 } } */ -/* { dg-final { scan-assembler-times "vcvtusi2ss\[ \\t\]+\[^%\n\]*%r\[^\{\n\]*\{rz-sae\}\[^\{\n\]*%xmm\[0-9\]+(?:\n|\[ \\t\]+#)" 1 } } */ +/* { dg-final { scan-assembler-times "vcvtusi2ssq\[ \\t\]+\[^\{\n\]*%xmm\[0-9\]+(?:\n|\[ \\t\]+#)" 1 } } */ +/* { dg-final { scan-assembler-times "vcvtusi2ssq\[ \\t\]+\[^%\n\]*%r\[^\{\n\]*\{rz-sae\}\[^\{\n\]*%xmm\[0-9\]+(?:\n|\[ \\t\]+#)" 1 } } */ #include <immintrin.h> diff --git a/gcc/testsuite/gcc.target/powerpc/pr83660.C b/gcc/testsuite/gcc.target/powerpc/pr83660.C new file mode 100644 index 00000000000..60adcdacb4b --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr83660.C @@ -0,0 +1,14 @@ +/* PR target/83660 */ +/* { dg-do compile } */ +/* { dg-options "-mcpu=power7" } */ + +#include <altivec.h> + +typedef __vector unsigned int uvec32_t __attribute__((__aligned__(16))); + +unsigned get_word(uvec32_t v) +{ + return ({const unsigned _B1 = 32; + vec_extract((uvec32_t)v, 2);}); +} + diff --git a/gcc/testsuite/gcc.target/powerpc/pr83969.c b/gcc/testsuite/gcc.target/powerpc/pr83969.c new file mode 100644 index 00000000000..fe61594be16 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr83969.c @@ -0,0 +1,14 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=G5" } } */ +/* { dg-options "-O1 -mcpu=G5 -fno-split-wide-types -ftree-loop-vectorize" } */ + +long long int +n7 (int po, long long int r4) +{ + while (po < 1) + { + r4 |= 1; + ++po; + } + return r4; +} diff --git a/gcc/testsuite/gcc.target/powerpc/pr85698.c b/gcc/testsuite/gcc.target/powerpc/pr85698.c new file mode 100644 index 00000000000..294a5665b32 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr85698.c @@ -0,0 +1,79 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vsx_hw } */ +/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power7" } } */ +/* { dg-options "-O3 -mcpu=power7" } */ + +/* PR85698: Incorrect code generated on LE due to use of stxvw4x. */ + +typedef unsigned char uint8_t; +typedef short int16_t; +extern void abort (void); +extern int memcmp(const void *, const void *, __SIZE_TYPE__); + +uint8_t expected[128] = +{14, 0, 4, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 28, 35, 33, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 66, 63, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 97, 96, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127}; + +static uint8_t x264_clip_uint8( int x ) +{ + return x&(~255) ? (-x)>>31 : x; +} +void add4x4_idct( uint8_t *p_dst, int16_t dct[16]) +{ + int16_t d[16]; + int16_t tmp[16]; + int i, y, x; + for( i = 0; i < 4; i++ ) + { + int s02 = dct[0*4+i] + dct[2*4+i]; + int d02 = dct[0*4+i] - dct[2*4+i]; + int s13 = dct[1*4+i] + (dct[3*4+i]>>1); + int d13 = (dct[1*4+i]>>1) - dct[3*4+i]; + tmp[i*4+0] = s02 + s13; + tmp[i*4+1] = d02 + d13; + tmp[i*4+2] = d02 - d13; + tmp[i*4+3] = s02 - s13; + } + for( i = 0; i < 4; i++ ) + { + int s02 = tmp[0*4+i] + tmp[2*4+i]; + int d02 = tmp[0*4+i] - tmp[2*4+i]; + int s13 = tmp[1*4+i] + (tmp[3*4+i]>>1); + int d13 = (tmp[1*4+i]>>1) - tmp[3*4+i]; + d[0*4+i] = ( s02 + s13 + 32 ) >> 6; + d[1*4+i] = ( d02 + d13 + 32 ) >> 6; + d[2*4+i] = ( d02 - d13 + 32 ) >> 6; + d[3*4+i] = ( s02 - s13 + 32 ) >> 6; + } + for( y = 0; y < 4; y++ ) + { + for( x = 0; x < 4; x++ ) + p_dst[x] = x264_clip_uint8( p_dst[x] + d[y*4+x] ); + p_dst += 32; + } +} + +int main() +{ + uint8_t dst[128]; + int16_t dct[16]; + int i; + + for (i = 0; i < 16; i++) + dct[i] = i*10 + i; + for (i = 0; i < 128; i++) + dst[i] = i; + + add4x4_idct(dst, dct); + + if (memcmp (dst, expected, 128)) + abort(); + + return 0; +} + diff --git a/gcc/testsuite/gcc.target/powerpc/pr85755.c b/gcc/testsuite/gcc.target/powerpc/pr85755.c new file mode 100644 index 00000000000..2d8741d639e --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr85755.c @@ -0,0 +1,22 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-options "-O1" } */ + +void +preinc (long *q, long n) +{ + long i; + for (i = 0; i < n; i++) + q[i] = i; +} + +void +predec (long *q, long n) +{ + long i; + for (i = n; i >= 0; i--) + q[i] = i; +} + +/* { dg-final { scan-assembler-times {\mstwu\M} 2 { target ilp32 } } } */ +/* { dg-final { scan-assembler-times {\mstdu\M} 2 { target lp64 } } } */ +/* { dg-final { scan-assembler-not {\mstfdu\M} } } */ diff --git a/gcc/testsuite/gcc.target/s390/htm-builtins-compile-4.c b/gcc/testsuite/gcc.target/s390/htm-builtins-compile-4.c new file mode 100644 index 00000000000..c3866bde4a4 --- /dev/null +++ b/gcc/testsuite/gcc.target/s390/htm-builtins-compile-4.c @@ -0,0 +1,10 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=zEC12 -mzarch" } */ + +/* A bug in the builtin definition made__builtin_tbeginc to have an + integer return argument. */ +void +must_not_compile1 (void) +{ + int rc = __builtin_tbeginc (); /* { dg-error "void value not ignored as it ought to be" } */ +} diff --git a/gcc/testsuite/gfortran.dg/allocate_alloc_opt_1.f90 b/gcc/testsuite/gfortran.dg/allocate_alloc_opt_1.f90 index 95571fdfe12..12005a6cc16 100644 --- a/gcc/testsuite/gfortran.dg/allocate_alloc_opt_1.f90 +++ b/gcc/testsuite/gfortran.dg/allocate_alloc_opt_1.f90 @@ -22,7 +22,7 @@ program a allocate(i(2))) ! { dg-error "Syntax error in ALLOCATE" } allocate(i(2), errmsg=err, errmsg=err) ! { dg-error "Redundant ERRMSG" } allocate(i(2), errmsg=err) ! { dg-warning "useless without a STAT" } - allocate(i(2), stat=j, errmsg=x) ! { dg-error "must be a scalar CHARACTER" } + allocate(i(2), stat=j, errmsg=x) ! { dg-error "shall be a scalar default CHARACTER" } allocate(err) ! { dg-error "neither a data pointer nor an allocatable" } diff --git a/gcc/testsuite/gfortran.dg/allocate_alloc_opt_14.f90 b/gcc/testsuite/gfortran.dg/allocate_alloc_opt_14.f90 new file mode 100644 index 00000000000..6de43a7597f --- /dev/null +++ b/gcc/testsuite/gfortran.dg/allocate_alloc_opt_14.f90 @@ -0,0 +1,8 @@ +! { dg-do compile } +program p + integer, allocatable :: arr(:) + integer :: stat + character(len=128, kind=4) :: errmsg = ' ' + allocate (arr(3), stat=stat, errmsg=errmsg) ! { dg-error "shall be a scalar default CHARACTER" } + print *, allocated(arr), stat, trim(errmsg) +end diff --git a/gcc/testsuite/gfortran.dg/allocate_assumed_charlen_4.f90 b/gcc/testsuite/gfortran.dg/allocate_assumed_charlen_4.f90 new file mode 100644 index 00000000000..1a5539a642b --- /dev/null +++ b/gcc/testsuite/gfortran.dg/allocate_assumed_charlen_4.f90 @@ -0,0 +1,39 @@ +! { dg-do run } +! +! Test the fix for PR82923, in which an ICE occurred because the +! character length from 'getchars' scope was being used in the +! automatic allocation of 'mine'. +! +! Contributed by "Werner Blokbuster" <werner.blokbuster@gmail.com> +! +module m + implicit none +contains + function getchars(my_len,my_size) + integer, intent(in) :: my_len, my_size + character(my_len) :: getchars(my_size) + getchars = 'A-' + end function getchars + + function getchars2(my_len) + integer, intent(in) :: my_len + character(my_len) :: getchars2 + getchars2 = 'B--' + end function getchars2 +end module m + +program testca + use m, only: getchars, getchars2 + implicit none + character(:), allocatable :: mine(:) + character(:), allocatable :: mine2 + integer :: i + + ! ICE occured at this line: + mine = getchars(2,4) + if (any (mine .ne. [('A-', i = 1, 4)])) stop 1 + + ! The scalar version was fine and this will keep it so: + mine2 = getchars2(3) + if (mine2 .ne. 'B--') stop 2 +end program testca diff --git a/gcc/testsuite/gfortran.dg/allocate_stat_2.f90 b/gcc/testsuite/gfortran.dg/allocate_stat_2.f90 index 7cf6d659ea2..a28a2536046 100644 --- a/gcc/testsuite/gfortran.dg/allocate_stat_2.f90 +++ b/gcc/testsuite/gfortran.dg/allocate_stat_2.f90 @@ -5,6 +5,6 @@ program main character(len=30), dimension(2) :: er integer, dimension (:), allocatable :: a allocate (a (16), stat = ier) ! { dg-error "must be a scalar INTEGER" } - allocate (a (14), stat=ier(1),errmsg=er) ! { dg-error "must be a scalar CHARACTER" } + allocate (a (14), stat=ier(1),errmsg=er) ! { dg-error "shall be a scalar default CHARACTER" } end diff --git a/gcc/testsuite/gfortran.dg/associate_30.f90 b/gcc/testsuite/gfortran.dg/associate_30.f90 index ad15d8bf576..ecc9ad06a56 100644 --- a/gcc/testsuite/gfortran.dg/associate_30.f90 +++ b/gcc/testsuite/gfortran.dg/associate_30.f90 @@ -8,8 +8,3 @@ associate (x => null()) ! { dg-error "cannot be NULL()" } end associate end subroutine - - subroutine s2 - associate (x => [null()]) ! { dg-error "has no type" } - end associate - end subroutine diff --git a/gcc/testsuite/gfortran.dg/associate_33.f03 b/gcc/testsuite/gfortran.dg/associate_33.f03 new file mode 100644 index 00000000000..1f87b22e8e4 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/associate_33.f03 @@ -0,0 +1,11 @@ +! { dg-do run } +! +! Test the fix for PR83898.f90 +! +! Contributed by G Steinmetz <gscfq@t-online.de> +! +program p + associate (x => ['1','2']) + if (any (x .ne. ['1','2'])) call abort + end associate +end diff --git a/gcc/testsuite/gfortran.dg/char_result_18.f90 b/gcc/testsuite/gfortran.dg/char_result_18.f90 new file mode 100644 index 00000000000..f47c88ad4b3 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/char_result_18.f90 @@ -0,0 +1,10 @@ +! { dg-do compile } +! +! Tests the fix for PR80657. +! +! Contributed by Vittorio Zecca <zeccav@gmail.com> +! +function f(x) +implicit character(len(f)) (x) ! { dg-error "Self reference in character length" } +character(len(x)) f +end diff --git a/gcc/testsuite/gfortran.dg/coarray/get_to_indexed_array_1.f90 b/gcc/testsuite/gfortran.dg/coarray/get_to_indexed_array_1.f90 new file mode 100644 index 00000000000..04714711707 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray/get_to_indexed_array_1.f90 @@ -0,0 +1,32 @@ +! { dg-do run } + +! Test that index vector on lhs of caf-expression works correctly. + +program pr81773 + + integer, parameter :: ndim = 5 + integer :: i + integer :: vec(ndim) = -1 + integer :: res(ndim)[*] = [ (i, i=1, ndim) ] + type T + integer :: padding + integer :: dest(ndim) + integer :: src(ndim) + end type + + type(T) :: dest + type(T), allocatable :: caf[:] + + vec([ndim, 3, 1]) = res(1:3)[1] + if (any (vec /= [ 3, -1, 2, -1, 1])) stop 1 + + dest = T(42, [ ( -1, i = 1, ndim ) ], [ ( i - 2, i = ndim, 1, -1) ] ) + dest%dest([ 4,3,2 ]) = res(3:5)[1] + if (any (dest%dest /= [-1, 5, 4, 3, -1])) stop 2 + + vec(:) = -1 + allocate(caf[*], source = T(42, [ ( -1, i = 1, ndim ) ], [ ( i - 2, i = ndim, 1, -1) ] )) + vec([ 5,3,2 ]) = caf[1]%src(2:4) + if (any (vec /= [ -1, 0, 1, -1, 2])) stop 3 +end + diff --git a/gcc/testsuite/gfortran.dg/coarray/get_to_indirect_array.f90 b/gcc/testsuite/gfortran.dg/coarray/get_to_indirect_array.f90 new file mode 100644 index 00000000000..efb78353637 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray/get_to_indirect_array.f90 @@ -0,0 +1,28 @@ +! { dg-do run } +! +! Test that pr81773/fortran is fixed. + +program get_to_indexed_array + + integer, parameter :: ndim = 5 + integer :: i + integer :: vec(1:ndim) = 0 + integer :: indx(1:2) = [3, 2] + integer :: mat(1:ndim, 1:ndim) = 0 + integer :: res(1:ndim)[*]=[ (i, i=1, ndim) ] + + ! No sync needed, because this test always is running on single image + vec([ndim , 1]) = res(1:2)[1] + if (vec(1) /= res(2) .or. vec(ndim) /= res(1)) then + print *,"vec: ", vec, " on image: ", this_image() + stop 1 + end if + + mat(2:3,[indx(:)]) = reshape(res(1:4)[1], [2, 2]) + if (any(mat(2:3, 3:2:-1) /= reshape(res(1:4), [2,2]))) then + print *, "mat: ", mat, " on image: ", this_image() + stop 2 + end if +end + +! vim:ts=2:sts=2:sw=2: diff --git a/gcc/testsuite/gfortran.dg/coarray_3.f90 b/gcc/testsuite/gfortran.dg/coarray_3.f90 index aba4eb1bc84..d152ce1b2bd 100644 --- a/gcc/testsuite/gfortran.dg/coarray_3.f90 +++ b/gcc/testsuite/gfortran.dg/coarray_3.f90 @@ -13,7 +13,7 @@ end critical fkl ! { dg-error "Expecting END PROGRAM" } sync all (stat=1) ! { dg-error "Syntax error in SYNC ALL" } sync all ( stat = n,stat=k) ! { dg-error "Redundant STAT" } -sync memory (errmsg=str) +sync memory (errmsg=str) ! { dg-error "must be a scalar CHARACTER variable" } sync memory (errmsg=n) ! { dg-error "must be a scalar CHARACTER variable" } sync images (*, stat=1.0) ! { dg-error "Syntax error in SYNC IMAGES" } sync images (-1) ! { dg-error "must between 1 and num_images" } diff --git a/gcc/testsuite/gfortran.dg/coarray_dependency_1.f90 b/gcc/testsuite/gfortran.dg/coarray_dependency_1.f90 new file mode 100644 index 00000000000..dc4cbacba1e --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray_dependency_1.f90 @@ -0,0 +1,11 @@ +! { dg-do compile } +! { dg-options "-fcoarray=lib -lcaf_single" } +! +! Check that reffing x on both sides of a coarray send does not ICE. +! PR 85507 + +program check_dependency + integer :: x[*] + x[42] = x +end program check_dependency + diff --git a/gcc/testsuite/gfortran.dg/coarray_lib_comm_1.f90 b/gcc/testsuite/gfortran.dg/coarray_lib_comm_1.f90 index 8ad6b081a13..df3b9d439b1 100644 --- a/gcc/testsuite/gfortran.dg/coarray_lib_comm_1.f90 +++ b/gcc/testsuite/gfortran.dg/coarray_lib_comm_1.f90 @@ -38,9 +38,8 @@ B(1:5) = B(3:7) if (any (A-B /= 0)) call abort end -! { dg-final { scan-tree-dump-times "_gfortran_caf_get \\\(caf_token.0, \\\(integer\\\(kind=\[48\]\\\)\\\) parm.\[0-9\]+.data - \\\(integer\\\(kind=\[48\]\\\)\\\) a, 1, &parm.\[0-9\]+, 0B, &parm.\[0-9\]+, 4, 4, 0, 0B\\\);" 1 "original" } } -! { dg-final { scan-tree-dump-times "_gfortran_caf_get \\\(caf_token.0, \\\(integer\\\(kind=\[48\]\\\)\\\) parm.\[0-9\]+.data - \\\(integer\\\(kind=\[48\]\\\)\\\) a, 1, &parm.\[0-9\]+, 0B, &parm.\[0-9\]+, 4, 4, 1, 0B\\\);" 1 "original" } } +! { dg-final { scan-tree-dump-times "_gfortran_caf_get \\\(caf_token.0, \\\(integer\\\(kind=\[48\]\\\)\\\) parm.\[0-9\]+.data - \\\(integer\\\(kind=\[48\]\\\)\\\) a, 1, &parm.\[0-9\]+, 0B, &parm.\[0-9\]+, 4, 4, 1, 0B\\\);" 2 "original" } } ! { dg-final { scan-tree-dump-times "_gfortran_caf_get \\\(caf_token.0, \\\(integer\\\(kind=\[48\]\\\)\\\) parm.\[0-9\]+.data - \\\(integer\\\(kind=\[48\]\\\)\\\) a, 1, &parm.\[0-9\]+, 0B, &p, 4, 4, 1, 0B\\\);" 1 "original" } } ! { dg-final { scan-tree-dump-times "_gfortran_caf_get \\\(caf_token.1, \\\(integer\\\(kind=\[48\]\\\)\\\) parm.\[0-9\]+.data - \\\(integer\\\(kind=\[48\]\\\)\\\) b, 1, &parm.\[0-9\]+, 0B, &p, 4, 4, 0, 0B\\\);" 1 "original" } } -! { dg-final { scan-tree-dump-times "_gfortran_caf_sendget \\\(caf_token.0, \\\(integer\\\(kind=\[48\]\\\)\\\) parm.\[0-9\]+.data - \\\(integer\\\(kind=\[48\]\\\)\\\) a, 1, &parm.\[0-9\]+, 0B, caf_token.0, \\\(integer\\\(kind=\[48\]\\\)\\\) parm.\[0-9\]+.data - \\\(integer\\\(kind=\[48\]\\\)\\\) a, 1, &parm.\[0-9\]+, 0B, 4, 4, 0, 0B\\\);" 1 "original" } } +! { dg-final { scan-tree-dump-times "_gfortran_caf_sendget \\\(caf_token.0, \\\(integer\\\(kind=\[48\]\\\)\\\) parm.\[0-9\]+.data - \\\(integer\\\(kind=\[48\]\\\)\\\) a, 1, &parm.\[0-9\]+, 0B, caf_token.0, \\\(integer\\\(kind=\[48\]\\\)\\\) parm.\[0-9\]+.data - \\\(integer\\\(kind=\[48\]\\\)\\\) a, 1, &parm.\[0-9\]+, 0B, 4, 4, 1, 0B\\\);" 1 "original" } } diff --git a/gcc/testsuite/gfortran.dg/data_bounds_1.f90 b/gcc/testsuite/gfortran.dg/data_bounds_1.f90 index b20aa415b8a..24cdc7c9815 100644 --- a/gcc/testsuite/gfortran.dg/data_bounds_1.f90 +++ b/gcc/testsuite/gfortran.dg/data_bounds_1.f90 @@ -1,4 +1,5 @@ ! { dg-do compile } +! { dg-options "-std=gnu" } ! Checks the fix for PR32315, in which the bounds checks below were not being done. ! ! Contributed by Tobias Burnus <burnus@gcc.gnu.org> diff --git a/gcc/testsuite/gfortran.dg/data_char_1.f90 b/gcc/testsuite/gfortran.dg/data_char_1.f90 index 96db4fd30eb..24785b636fa 100644 --- a/gcc/testsuite/gfortran.dg/data_char_1.f90 +++ b/gcc/testsuite/gfortran.dg/data_char_1.f90 @@ -1,4 +1,5 @@ ! { dg-do run } +! { dg-options "-std=gnu" } ! Test character variables in data statements ! Also substrings of character variables. ! PR14976 PR16228 diff --git a/gcc/testsuite/gfortran.dg/deallocate_alloc_opt_1.f90 b/gcc/testsuite/gfortran.dg/deallocate_alloc_opt_1.f90 index 969ce257efe..58790ebfb58 100644 --- a/gcc/testsuite/gfortran.dg/deallocate_alloc_opt_1.f90 +++ b/gcc/testsuite/gfortran.dg/deallocate_alloc_opt_1.f90 @@ -22,7 +22,7 @@ program a deallocate(i)) ! { dg-error "Syntax error in DEALLOCATE" } deallocate(i, errmsg=err, errmsg=err) ! { dg-error "Redundant ERRMSG" } deallocate(i, errmsg=err) ! { dg-warning "useless without a STAT" } - deallocate(i, stat=j, errmsg=x) ! { dg-error "must be a scalar CHARACTER" } + deallocate(i, stat=j, errmsg=x) ! { dg-error "shall be a scalar default CHARACTER" } deallocate(err) ! { dg-error "nonprocedure pointer nor an allocatable" } diff --git a/gcc/testsuite/gfortran.dg/goacc/pr84963.f90 b/gcc/testsuite/gfortran.dg/goacc/pr84963.f90 new file mode 100644 index 00000000000..4548082bee3 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/goacc/pr84963.f90 @@ -0,0 +1,7 @@ +! PR ipa/84963 +! { dg-options "-O2" } + +program p + print *, sin([1.0, 2.0]) + print *, cos([1.0, 2.0]) +end diff --git a/gcc/testsuite/gfortran.dg/pr38351.f90 b/gcc/testsuite/gfortran.dg/pr38351.f90 new file mode 100644 index 00000000000..08e1724dc0a --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr38351.f90 @@ -0,0 +1,21 @@ +! { dg-do compile } +module m1 + type t1 + integer :: i + end type t1 + interface operator(+) + module procedure add + end interface + contains + type(t1) function add(a,b) + type(t1), intent(in) :: a,b + end function +end module m1 + +program foo + use m1 + type(t1), dimension(2,2) :: a = t1(1), b = t1(2) + type(t1) :: c=t1(1), d=t1(2) + c = c + d + a = a + b ! { dg-error "Unexpected derived-type entities" } +end program foo diff --git a/gcc/testsuite/gfortran.dg/pr44491.f90 b/gcc/testsuite/gfortran.dg/pr44491.f90 new file mode 100644 index 00000000000..406bb262f71 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr44491.f90 @@ -0,0 +1,5 @@ +! { dg-do compile } +! { dg-options "-std=gnu" } +! PR fortran/44491 + character*2 escape /z'1B'/ ! { dg-error "Incompatible types in DATA" } + end diff --git a/gcc/testsuite/gfortran.dg/pr63514.f90 b/gcc/testsuite/gfortran.dg/pr63514.f90 new file mode 100644 index 00000000000..389fb92608e --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr63514.f90 @@ -0,0 +1,41 @@ +! { dg-do compile } +! PR fortran/63514.f90 +program foo + + implicit none + + integer, volatile :: n + + n = 0 + + call bar + call bah + + contains + + subroutine bar + integer k + integer, volatile :: m + block + integer, save :: i + integer, volatile :: j + i = 42 + j = 2 * i + k = i + j + n + end block + end subroutine bar + + pure subroutine bah + integer k + integer, volatile :: m ! { dg-error "cannot be specified in a PURE" } + block + integer, save :: i ! { dg-error "cannot be specified in a PURE" } + integer, volatile :: j ! { dg-error "cannot be specified in a PURE" } + i = 42 ! { dg-error "has no IMPLICIT type" } + j = 2 * i ! { dg-error "has no IMPLICIT type" } + k = i + j + n + end block + m = k * m ! { dg-error "has no IMPLICIT type" } + end subroutine bah + +end program foo diff --git a/gcc/testsuite/gfortran.dg/pr67803.f90 b/gcc/testsuite/gfortran.dg/pr67803.f90 index 9a8ff309feb..55a1bbf5794 100644 --- a/gcc/testsuite/gfortran.dg/pr67803.f90 +++ b/gcc/testsuite/gfortran.dg/pr67803.f90 @@ -10,5 +10,4 @@ program p x = '0' // [character :: 1d1] ! { dg-error "Incompatible typespec for" } x = '0' // [character :: (0.,1.)] ! { dg-error "Incompatible typespec for" } x = '0' // [character :: .true.] ! { dg-error "Incompatible typespec for" } - x = '0' // [character :: null()] ! { dg-error "Incompatible typespec for" } end diff --git a/gcc/testsuite/gfortran.dg/pr67805.f90 b/gcc/testsuite/gfortran.dg/pr67805.f90 index 7371991717d..2aedde8977b 100644 --- a/gcc/testsuite/gfortran.dg/pr67805.f90 +++ b/gcc/testsuite/gfortran.dg/pr67805.f90 @@ -22,7 +22,6 @@ subroutine p s = [character([1.]) :: 'x', 'y'] ! { dg-error "INTEGER expression expected" } s = [character([1d1]) :: 'x', 'y'] ! { dg-error "INTEGER expression expected" } s = [character([(0.,1.)]) :: 'x', 'y'] ! { dg-error "INTEGER expression expected" } - s = [character([null()]) :: 'x', 'y'] ! { dg-error "INTEGER expression expected" } s = [character(null()) :: 'x', 'y'] ! { dg-error "INTEGER expression expected" } call foo(s) end subroutine p diff --git a/gcc/testsuite/gfortran.dg/pr70870_1.f90 b/gcc/testsuite/gfortran.dg/pr70870_1.f90 new file mode 100644 index 00000000000..0f9584a36db --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr70870_1.f90 @@ -0,0 +1,9 @@ +! { dg-do compile } +! PR fortran/70870 +! Contributed by Vittorio Zecca <zeccav at gmail dot com > + type t + integer :: g=0 ! default initialization + end type + type(t) :: v2 + data v2/t(2)/ ! { dg-error "default initialization shall not" } + end diff --git a/gcc/testsuite/gfortran.dg/pr78278.f90 b/gcc/testsuite/gfortran.dg/pr78278.f90 new file mode 100644 index 00000000000..fd50e3e1c18 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr78278.f90 @@ -0,0 +1,14 @@ +! { dg-do compile } +! { dg-options "-std=f95" } +! PR fortran/78278 +program p + character, pointer :: x => null() + data x /null()/ ! { dg-error "GNU Extension: re-initialization" } + print *, associated(x) +end + +subroutine foo + real :: x = 42 + data x /0/ ! { dg-error "GNU Extension: re-initialization" } + print *, x +end subroutine foo diff --git a/gcc/testsuite/gfortran.dg/pr83149.f90 b/gcc/testsuite/gfortran.dg/pr83149.f90 new file mode 100644 index 00000000000..fc0607e1369 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr83149.f90 @@ -0,0 +1,14 @@ +! Compiled with pr83149_1.f90 +! +module mod1 + integer :: ncells +end module + +module mod2 +contains + function get() result(array) + use mod1 + real array(ncells) + array = 1.0 + end function +end module diff --git a/gcc/testsuite/gfortran.dg/pr83149_1.f90 b/gcc/testsuite/gfortran.dg/pr83149_1.f90 new file mode 100644 index 00000000000..3a8f5d55d9b --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr83149_1.f90 @@ -0,0 +1,24 @@ +! Compiled with pr83149.f90 +! { dg-do run } +! { dg-options "-fno-whole-file" } +! { dg-compile-aux-modules "pr83149.f90" } +! { dg-additional-sources pr83149.f90 } +! +! Contributed by Neil Carlson <neil.n.carlson@gmail.com> +! +subroutine sub(s) + use mod2 + real :: s + s = sum(get()) +end + + use mod1 + real :: s + ncells = 2 + call sub (s) + if (int (s) .ne. ncells) stop 1 + ncells = 10 + call sub (s) + if (int (s) .ne. ncells) stop 2 +end + diff --git a/gcc/testsuite/gfortran.dg/pr83149_a.f90 b/gcc/testsuite/gfortran.dg/pr83149_a.f90 new file mode 100644 index 00000000000..3f15198bfe9 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr83149_a.f90 @@ -0,0 +1,11 @@ +! Compiled with pr83149_b.f90 +! +module mod + character(8) string +contains + function get_string() result(s) + character(len_trim(string)) s + s = string + end function +end module + diff --git a/gcc/testsuite/gfortran.dg/pr83149_b.f90 b/gcc/testsuite/gfortran.dg/pr83149_b.f90 new file mode 100644 index 00000000000..f67ffd95159 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr83149_b.f90 @@ -0,0 +1,16 @@ +! Compiled with pr83149_a.f90 +! { dg-do run } +! { dg-options "-fno-whole-file" } +! { dg-compile-aux-modules "pr83149_a.f90" } +! { dg-additional-sources pr83149_a.f90 } +! +! Contributed by Neil Carlson <neil.n.carlson@gmail.com> +! + use mod + string = 'fubar' + select case (get_string()) + case ('fubar') + case default + stop 1 + end select +end diff --git a/gcc/testsuite/gfortran.dg/pr85138_1.f90 b/gcc/testsuite/gfortran.dg/pr85138_1.f90 new file mode 100644 index 00000000000..a64d9ce9329 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85138_1.f90 @@ -0,0 +1,29 @@ +! { dg-do compile } +module fox_m_fsys_format + + interface len + module procedure str_real_sp_len, str_real_sp_fmt_len + end interface + +contains + + pure function str_real_sp_fmt_len(x, fmt) result(n) + real, intent(in) :: x + character(len=*), intent(in) :: fmt + if (.not.checkFmt(fmt)) then + endif + end function str_real_sp_fmt_len + pure function str_real_sp_len(x) result(n) + real, intent(in) :: x + n = len(x, "") + end function str_real_sp_len + pure function str_real_dp_matrix(xa) result(s) + real, intent(in) :: xa + character(len=len(xa)) :: s + end function str_real_dp_matrix + + pure function checkfmt(s) result(a) + logical a + character(len=*), intent(in) :: s + end function checkfmt +end module fox_m_fsys_format diff --git a/gcc/testsuite/gfortran.dg/pr85138_2.f90 b/gcc/testsuite/gfortran.dg/pr85138_2.f90 new file mode 100644 index 00000000000..942cc6684d8 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85138_2.f90 @@ -0,0 +1,32 @@ +! { dg-do compile } +module fox_m_fsys_format + interface len + module procedure str_real_dp_len, str_real_dp_fmt_len + end interface +contains + pure function str_real_dp_fmt_len(x, fmt) result(n) + real, intent(in) :: x + character(len=*), intent(in) :: fmt + if (.not.checkFmt(fmt)) then + endif + end function str_real_dp_fmt_len + pure function str_real_dp_len(x) result(n) + real, intent(in) :: x + end function str_real_dp_len + pure function str_real_dp_array_len(xa) result(n) + real, dimension(:), intent(in) :: xa + end function str_real_dp_array_len + pure function str_real_dp_array_fmt_len(xa, fmt) result(n) + real, dimension(:), intent(in) :: xa + character(len=*), intent(in) :: fmt + end function str_real_dp_array_fmt_len + pure function str_real_dp_fmt(x, fmt) result(s) + real, intent(in) :: x + character(len=*), intent(in) :: fmt + character(len=len(x, fmt)) :: s + end function str_real_dp_fmt + pure function checkFmt(fmt) result(good) + character(len=*), intent(in) :: fmt + logical :: good + end function checkFmt +end module fox_m_fsys_format diff --git a/gcc/testsuite/gfortran.dg/pr85520.f90 b/gcc/testsuite/gfortran.dg/pr85520.f90 new file mode 100644 index 00000000000..3e66a9020f8 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85520.f90 @@ -0,0 +1,7 @@ +! { dg-do run } +! PR fortran/85520 +! Original code from Gerhard Steinmetz <gscfq at t-online dot de> +program p + character(-huge(1)) :: c = ' ' + if (len(c) /= 0) stop 1 +end diff --git a/gcc/testsuite/gfortran.dg/pr85521_1.f90 b/gcc/testsuite/gfortran.dg/pr85521_1.f90 new file mode 100644 index 00000000000..57e4620fe0d --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85521_1.f90 @@ -0,0 +1,8 @@ +! { dg-do compile } +! PR fortran/85521 +program p + character(3) :: c = 'abc' + character(3) :: z(1) + z = [ c(:-1) ] + print *, z +end diff --git a/gcc/testsuite/gfortran.dg/pr85521_2.f90 b/gcc/testsuite/gfortran.dg/pr85521_2.f90 new file mode 100644 index 00000000000..737b61a11b9 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85521_2.f90 @@ -0,0 +1,8 @@ +! { dg-do compile } +! PR fortran/85521 +program p + character(3) :: c = 'abc' + character(3) :: z(1) + z = [ c(:-2) ] + print *, z +end diff --git a/gcc/testsuite/gfortran.dg/pr85542.f90 b/gcc/testsuite/gfortran.dg/pr85542.f90 new file mode 100644 index 00000000000..f61d2c9beb0 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85542.f90 @@ -0,0 +1,7 @@ +! { dg-do compile } +! PR fortran/85542 +function f(x) + character(*), intent(in) :: x + character((len((x)))) :: f + f = x +end diff --git a/gcc/testsuite/gfortran.dg/pr85543.f90 b/gcc/testsuite/gfortran.dg/pr85543.f90 new file mode 100644 index 00000000000..d3f83276a7f --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85543.f90 @@ -0,0 +1,8 @@ +! { dg-do compile } +! PR fortran/85543 +program p + procedure(), pointer :: z +contains + real(z()) function f() ! { dg-error "in initialization expression at" } + end +end diff --git a/gcc/testsuite/gfortran.dg/pr85687.f90 b/gcc/testsuite/gfortran.dg/pr85687.f90 new file mode 100644 index 00000000000..03bc2119364 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85687.f90 @@ -0,0 +1,8 @@ +! { dg-do compile } +! PR fortran/85687 +! Code original contributed by Gerhard Steinmetz gscfq at t-oline dot de +program p + type t + end type + print *, rank(t) ! { dg-error "must be a data object" } +end diff --git a/gcc/testsuite/gfortran.dg/pr85779_1.f90 b/gcc/testsuite/gfortran.dg/pr85779_1.f90 new file mode 100644 index 00000000000..186568ff124 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85779_1.f90 @@ -0,0 +1,6 @@ +! { dg-do compile } +! PR fortran/85779 +type(t) function f() ! { dg-error "is not accessible" } + type f ! { dg-error "already has a basic type" } + end type ! { dg-error "END FUNCTION statement" } +end diff --git a/gcc/testsuite/gfortran.dg/pr85779_2.f90 b/gcc/testsuite/gfortran.dg/pr85779_2.f90 new file mode 100644 index 00000000000..4cc3c62979c --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85779_2.f90 @@ -0,0 +1,7 @@ +! { dg-do compile } +! PR fortran/85779 +type(t) function f() result(z) ! { dg-error "is not accessible" } + type z ! { dg-error "already has a basic type" } + end type ! { dg-error "END FUNCTION statement" } +end + diff --git a/gcc/testsuite/gfortran.dg/pr85779_3.f90 b/gcc/testsuite/gfortran.dg/pr85779_3.f90 new file mode 100644 index 00000000000..fba1133b3ea --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85779_3.f90 @@ -0,0 +1,7 @@ +! { dg-do compile } +! PR fortran/85779 +class(t) function f() ! { dg-error "must be dummy, allocatable or pointer" } + type f ! { dg-error "already has a basic type" } + end type ! { dg-error "END FUNCTION statement" } +end + diff --git a/gcc/testsuite/gfortran.dg/pr85780.f90 b/gcc/testsuite/gfortran.dg/pr85780.f90 new file mode 100644 index 00000000000..ad6b27fc4db --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85780.f90 @@ -0,0 +1,5 @@ +! { dg-do compile } +! { dg-options "-std=legacy" } +! PR fortran/85780 +subroutine s(*) bind(c) +end diff --git a/gcc/testsuite/gfortran.dg/pr85895.f90 b/gcc/testsuite/gfortran.dg/pr85895.f90 new file mode 100644 index 00000000000..184266e5ec8 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85895.f90 @@ -0,0 +1,17 @@ +! { dg-do compile } +! { dg-options "-fcoarray=lib" } +! PR fortran/85895 +subroutine p + character(80) :: c(2) + sync memory (errmsg=c) ! { dg-error "scalar CHARACTER variable" } +end subroutine p + +subroutine q + character(80) :: c(2) + sync memory (errmsg=c(1:2)) ! { dg-error "scalar CHARACTER variable" } +end subroutine q + +subroutine r + character(80) :: c(2) + sync memory (errmsg=c(1)) +end subroutine r diff --git a/gcc/testsuite/gfortran.dg/pr85996.f90 b/gcc/testsuite/gfortran.dg/pr85996.f90 new file mode 100644 index 00000000000..e594d6771c8 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr85996.f90 @@ -0,0 +1,69 @@ +! { dg-do compile } +module strings + + type string + integer :: len = 0, size = 0 + character, pointer :: chars(:) => null() + end type string + + interface length + module procedure len_s + end interface + + interface char + module procedure s_to_c, s_to_slc + end interface + + interface uppercase + module procedure uppercase_c + end interface + + interface replace + module procedure replace_ccs + end interface + + contains + + elemental function len_s(s) + type(string), intent(in) :: s + integer :: len_s + end function len_s + + pure function s_to_c(s) + type(string),intent(in) :: s + character(length(s)) :: s_to_c + end function s_to_c + + pure function s_to_slc(s,long) + type(string),intent(in) :: s + integer, intent(in) :: long + character(long) :: s_to_slc + end function s_to_slc + + pure function lr_sc_s(s,start,ss) result(l) + type(string), intent(in) :: s + character(*), intent(in) :: ss + integer, intent(in) :: start + integer :: l + end function lr_sc_s + + pure function lr_ccc(s,tgt,ss,action) result(l) + character(*), intent(in) :: s,tgt,ss,action + integer :: l + select case(uppercase(action)) + case default + end select + end function lr_ccc + + function replace_ccs(s,tgt,ss) result(r) + character(*), intent(in) :: s,tgt + type(string), intent(in) :: ss + character(lr_ccc(s,tgt,char(ss),'first')) :: r + end function replace_ccs + + pure function uppercase_c(c) + character(*), intent(in) :: c + character(len(c)) :: uppercase_c + end function uppercase_c + +end module strings diff --git a/gcc/testsuite/gfortran.dg/pr86045.f90 b/gcc/testsuite/gfortran.dg/pr86045.f90 new file mode 100644 index 00000000000..685672f1dbd --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr86045.f90 @@ -0,0 +1,7 @@ +! { dg-do compile } +program p + logical :: a(2) = (mod([2,3],0) == 0) ! { dg-error "shall not be zero" } + integer :: b = count(mod([2,3],0) == 0) ! { dg-error "shall not be zero" } + integer :: c = all(mod([2,3],0) == 0) ! { dg-error "shall not be zero" } + integer :: d = any(mod([2,3],0) == 0) ! { dg-error "shall not be zero" } +end diff --git a/gcc/testsuite/gfortran.dg/pr86059.f90 b/gcc/testsuite/gfortran.dg/pr86059.f90 new file mode 100644 index 00000000000..e0caed102d7 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr86059.f90 @@ -0,0 +1,8 @@ +! { dg-do compile } +! PR fortran/86059 +program foo + integer :: i(2) = [ null(), 1 ] ! { dg-error "cannot appear in an array constructor" } + integer :: j(2) = [ (null(), n = 1, 2) ] ! { dg-error "cannot appear in an array constructor" } + integer k(2) + k = 42 + [1, null()] ! { dg-error "cannot appear in an array constructor" } +end program foo diff --git a/gcc/testsuite/gfortran.dg/pr86110.f90 b/gcc/testsuite/gfortran.dg/pr86110.f90 new file mode 100644 index 00000000000..890670f5854 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr86110.f90 @@ -0,0 +1,7 @@ +! { dg-do compile } +! PR fortran/86110 +program p + character(:), allocatable :: x, y + x = 'abc' + y = [x(:)] ! { dg-error "Incompatible ranks 0 and 1" } +end diff --git a/gcc/testsuite/gfortran.dg/realloc_on_assign_30.f90 b/gcc/testsuite/gfortran.dg/realloc_on_assign_30.f90 new file mode 100644 index 00000000000..4e7eb4ba220 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/realloc_on_assign_30.f90 @@ -0,0 +1,13 @@ +! { dg-do compile } +! PR 85641 - this used to ICE due do infinite recursion. +! Test case by Antony Lewis. +program tester +character(LEN=:), allocatable :: fields +integer j +character(LEN=4), parameter :: CMB_CL_Fields = 'TEBP' + +fields = '' +j=1 +fields = fields // CMB_CL_Fields(j:j) + +end program tester diff --git a/gcc/testsuite/gfortran.dg/select_type_42.f90 b/gcc/testsuite/gfortran.dg/select_type_42.f90 new file mode 100644 index 00000000000..ff73e6c7858 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/select_type_42.f90 @@ -0,0 +1,26 @@ +! { dg-do run } +! +! Tests the fix for PR82275. +! Associating a name with a reduced-dimension section of a +! multidimensional array precluded subsequent use of the name +! with the appropriately reduced dimensionality and instead +! required use of the (invalid) full set of original dimensions. +! +! Contributed by Damian Rouson <damian@sourceryinstitute.org> +! + type component + integer :: i + end type + type container + class(component), allocatable :: component_array(:,:) + end type + type(container) bag + type(component) section_copy + allocate(bag%component_array, source = reshape ([component(10), component (100)], [1,2])) + select type(associate_name=>bag%component_array(1,:)) + type is (component) + section_copy = associate_name(2) ! gfortran rejected valid +! section_copy = associate_name(1,1)! gfortran accepted invalid + end select + if (section_copy%i .ne. 100) stop 1 +end diff --git a/gcc/testsuite/gfortran.dg/submodule_31.f08 b/gcc/testsuite/gfortran.dg/submodule_31.f08 new file mode 100644 index 00000000000..72594d05df3 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/submodule_31.f08 @@ -0,0 +1,54 @@ +! { dg-do run } +! +! Test the fix for PR82814 in which an ICE occurred for the submodule allocation. +! +! Contributed by "Werner Blokbuster" <werner.blokbuster@gmail.com> +! +module u + + implicit none + + interface unique + module function uniq_char(input) result(uniq) + character(*), intent(in) :: input(:) + character(size(input)), allocatable :: uniq(:) + end function uniq_char + end interface unique + +contains + + module function uniq2(input) result(uniq) + character(*), intent(in) :: input(:) + character(size(input)), allocatable :: uniq(:) + allocate(uniq(1)) + uniq = 'A' + end function uniq2 + +end module u + + +submodule (u) z + + implicit none + +contains + + module function uniq_char(input) result(uniq) + character(*), intent(in) :: input(:) + character(size(input)), allocatable :: uniq(:) + allocate(uniq(1)) ! This used to ICE + uniq = 'A' + end function uniq_char + +end submodule z + + +program test_uniq + use u + implicit none + character(1), dimension(4) :: chr = ['1','2','1','2'] + + write(*,*) unique(chr) + write(*,*) uniq2(chr) + +end program test_uniq diff --git a/gcc/testsuite/gfortran.dg/temporary_2.f90 b/gcc/testsuite/gfortran.dg/temporary_2.f90 new file mode 100644 index 00000000000..0598ea54f28 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/temporary_2.f90 @@ -0,0 +1,39 @@ +! { dg-do compile } +! +! Tests the fix for PR70864 in which compiler generated temporaries received +! the attributes of a dummy argument. This is the original testcase. +! The simplified version by Gerhard Steinmetz is gratefully acknowledged. +! +! Contributed by Weiqun Zhang <weiqun.zhang@gmail.com> +! +module boxarray_module + implicit none + type :: BoxArray + integer :: i = 0 + contains + procedure :: boxarray_assign + generic :: assignment(=) => boxarray_assign + end type BoxArray +contains + subroutine boxarray_assign (dst, src) + class(BoxArray), intent(inout) :: dst + type (BoxArray), intent(in ) :: src + dst%i =src%i + end subroutine boxarray_assign +end module boxarray_module + +module multifab_module + use boxarray_module + implicit none + type, public :: MultiFab + type(BoxArray) :: ba + end type MultiFab +contains + subroutine multifab_swap(mf1, mf2) + type(MultiFab), intent(inout) :: mf1, mf2 + type(MultiFab) :: tmp + tmp = mf1 + mf1 = mf2 ! Generated an ICE in trans-decl.c. + mf2 = tmp + end subroutine multifab_swap +end module multifab_module diff --git a/gcc/testsuite/gfortran.dg/temporary_3.f90 b/gcc/testsuite/gfortran.dg/temporary_3.f90 new file mode 100644 index 00000000000..84b300a38d9 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/temporary_3.f90 @@ -0,0 +1,121 @@ +! { dg-do run } +! +! Tests the fix for PR68846 in which compiler generated temporaries were +! receiving the attributes of dummy arguments. This test is the original. +! The simplified versions by Gerhard Steinmetz are gratefully acknowledged. +! +! Contributed by Mirco Valentini <mirco.valentini@polimi.it> +! +MODULE grid + IMPLICIT NONE + PRIVATE + REAL(KIND=8), DIMENSION(100,100), TARGET :: WORKSPACE + TYPE, PUBLIC :: grid_t + REAL(KIND=8), DIMENSION(:,:), POINTER :: P => NULL () + END TYPE + PUBLIC :: INIT +CONTAINS + SUBROUTINE INIT (DAT) + IMPLICIT NONE + TYPE(grid_t), INTENT(INOUT) :: DAT + INTEGER :: I, J + DAT%P => WORKSPACE + DO I = 1, 100 + DO J = 1, 100 + DAT%P(I,J) = REAL ((I-1)*100+J-1) + END DO + ENDDO + END SUBROUTINE INIT +END MODULE grid + +MODULE subgrid + USE :: grid, ONLY: grid_t + IMPLICIT NONE + PRIVATE + TYPE, PUBLIC :: subgrid_t + INTEGER, DIMENSION(4) :: range + CLASS(grid_t), POINTER :: grd => NULL () + CONTAINS + PROCEDURE, PASS :: INIT => LVALUE_INIT + PROCEDURE, PASS :: JMP => LVALUE_JMP + END TYPE +CONTAINS + SUBROUTINE LVALUE_INIT (HOBJ, P, D) + IMPLICIT NONE + CLASS(subgrid_t), INTENT(INOUT) :: HOBJ + TYPE(grid_t), POINTER, INTENT(INOUT) :: P + INTEGER, DIMENSION(4), INTENT(IN) :: D + HOBJ%range = D + HOBJ%grd => P + END SUBROUTINE LVALUE_INIT + + FUNCTION LVALUE_JMP(HOBJ, I, J) RESULT(P) + IMPLICIT NONE + CLASS(subgrid_t), INTENT(INOUT) :: HOBJ + INTEGER, INTENT(IN) :: I, J + REAL(KIND=8), POINTER :: P + P => HOBJ%grd%P(HOBJ%range(1)+I-1, HOBJ%range(3)+J-1) + END FUNCTION LVALUE_JMP +END MODULE subgrid + +MODULE geom + IMPLICIT NONE +CONTAINS + SUBROUTINE fillgeom_03( subgrid, value ) + USE :: subgrid, ONLY: subgrid_t + IMPLICIT NONE + TYPE(subgrid_T), intent(inout) :: subgrid + REAL(kind=8), intent(in) :: value + INTEGER :: I, J + DO i = 1, 3 + DO J = 1, 4 + subgrid%jmp(i,j) = value ! Dummy argument '_F.DA0' with INTENT(IN) + ! in pointer association context or ICE + ! in trans_decl.c, depending on INTENT of + ! 'VALUE' + ENDDO + ENDDO + END SUBROUTINE fillgeom_03 +END MODULE geom + +PROGRAM test_lvalue + USE :: grid + USE :: subgrid + USE :: geom + IMPLICIT NONE + TYPE(grid_t), POINTER :: GRD => NULL() + TYPE(subgrid_t) :: STENCIL + REAL(KIND=8), POINTER :: real_tmp_ptr + REAL(KIND=8), DIMENSION(10,10), TARGET :: AA + REAL(KIND=8), DIMENSION(3,4) :: VAL + INTEGER :: I, J, chksum + integer, parameter :: r1 = 50 + integer, parameter :: r2 = 52 + integer, parameter :: r3 = 50 + integer, parameter :: r4 = 53 + DO I = 1, 3 + DO J = 1, 4 + VAL(I,J) = dble(I)*dble(J) + ENDDO + ENDDO + + ALLOCATE (GRD) + CALL INIT (GRD) + chksum = sum([([((i-1)*100 + j -1, j=1,100)], i = 1,100)]) + if (int(sum(grd%p)) .ne. chksum) stop 1 + + CALL STENCIL%INIT (GRD, [r1, r2, r3, r4]) + if (.not.associated (stencil%grd, grd)) stop 2 + if (int(sum(grd%p)) .ne. chksum) stop 3 + + CALL fillgeom_03(stencil, 42.0_8) + if (any (int (grd%p(r1:r2,r3:r4)) .ne. 42)) stop 4 + + chksum = chksum - sum([([((i - 1) * 100 + j -1, j=r3,r4)], i = r1,r2)]) & + + (r4 - r3 + 1) * (r2 - r1 +1) * 42 + if (int(sum(grd%p)) .ne. chksum) stop 5 + + deallocate (grd) +END PROGRAM test_lvalue + + diff --git a/gcc/testsuite/gfortran.dg/typebound_operator_4.f03 b/gcc/testsuite/gfortran.dg/typebound_operator_4.f03 index 836505bba3d..cd0e8f602ae 100644 --- a/gcc/testsuite/gfortran.dg/typebound_operator_4.f03 +++ b/gcc/testsuite/gfortran.dg/typebound_operator_4.f03 @@ -84,6 +84,6 @@ PROGRAM main TYPE(myint) :: x x = 0 ! { dg-error "Can't convert" } - x = x + 42 ! { dg-error "Operands of" } + x = x + 42 ! { dg-error "binary intrinsic numeric operator" } x = x .PLUS. 5 ! { dg-error "Unknown operator" } END PROGRAM main diff --git a/gcc/testsuite/gfortran.dg/unlimited_polymorphic_29.f90 b/gcc/testsuite/gfortran.dg/unlimited_polymorphic_29.f90 new file mode 100644 index 00000000000..d4ad39cda1e --- /dev/null +++ b/gcc/testsuite/gfortran.dg/unlimited_polymorphic_29.f90 @@ -0,0 +1,84 @@ +! { dg-do run } +! +! Test the fix for PR84546 in which the failing cases would +! have x%vec = ['foo','b ']. +! +! Contributed by Neil Carlson <neil.n.carlson@gmail.com> +! +module any_vector_type + + type :: any_vector + class(*), allocatable :: vec(:) + end type + + interface any_vector + procedure any_vector1 + end interface + +contains + + function any_vector1(vec) result(this) + class(*), intent(in) :: vec(:) + type(any_vector) :: this + allocate(this%vec, source=vec) + end function + +end module + +program main + + use any_vector_type + implicit none + + class(*), allocatable :: x + character(*), parameter :: vec(2) = ['foo','bar'] + integer :: vec1(3) = [7,8,9] + + call foo1 + call foo2 + call foo3 + call foo4 + +contains + + subroutine foo1 ! This always worked + allocate (any_vector :: x) + select type (x) + type is (any_vector) + x = any_vector(vec) + end select + call bar(1) + deallocate (x) + end + + subroutine foo2 ! Failure found during diagnosis + x = any_vector (vec) + call bar(2) + deallocate (x) + end + + subroutine foo3 ! Original failure + allocate (x, source = any_vector (vec)) + call bar(3) + deallocate (x) + end + + subroutine foo4 ! This always worked + allocate (x, source = any_vector (vec1)) + call bar(4) + deallocate (x) + end + + subroutine bar (stop_flag) + integer :: stop_flag + select type (x) + type is (any_vector) + select type (xvec => x%vec) + type is (character(*)) + if (any(xvec /= vec)) stop stop_flag + type is (integer) + if (any(xvec /= (vec1))) stop stop_flag + end select + end select + end +end program diff --git a/gcc/testsuite/gnat.dg/aggr24.adb b/gcc/testsuite/gnat.dg/aggr24.adb new file mode 100644 index 00000000000..b739c54fdc4 --- /dev/null +++ b/gcc/testsuite/gnat.dg/aggr24.adb @@ -0,0 +1,13 @@ +-- { dg-do run } + +with Aggr24_Pkg; use Aggr24_Pkg; + +procedure Aggr24 is + V : Rec; +begin + V.S := "Hello"; + Init (V); + if V.S /= "Hello" then + raise Program_Error; + end if; +end; diff --git a/gcc/testsuite/gnat.dg/aggr24_pkg.adb b/gcc/testsuite/gnat.dg/aggr24_pkg.adb new file mode 100644 index 00000000000..2ae3e79e322 --- /dev/null +++ b/gcc/testsuite/gnat.dg/aggr24_pkg.adb @@ -0,0 +1,15 @@ +package body Aggr24_Pkg is + + procedure Init (R : out Rec) is + begin + R := (I1 => 0, + I2 => 0, + I3 => 0, + I4 => 0, + I5 => 0, + I6 => 0, + I7 => 0, + S => <>); + end; + +end Aggr24_Pkg; diff --git a/gcc/testsuite/gnat.dg/aggr24_pkg.ads b/gcc/testsuite/gnat.dg/aggr24_pkg.ads new file mode 100644 index 00000000000..5918f5e8bd4 --- /dev/null +++ b/gcc/testsuite/gnat.dg/aggr24_pkg.ads @@ -0,0 +1,16 @@ +package Aggr24_Pkg is + + type Rec is record + I1 : Integer; + I2 : Integer; + I3 : Integer; + I4 : Integer; + I5 : Integer; + I6 : Integer; + I7 : Integer; + S : String (1 .. 5); + end record; + + procedure Init (R : out Rec); + +end Aggr24_Pkg; diff --git a/gcc/testsuite/gnat.dg/discr53.adb b/gcc/testsuite/gnat.dg/discr53.adb new file mode 100644 index 00000000000..2e362a7fd29 --- /dev/null +++ b/gcc/testsuite/gnat.dg/discr53.adb @@ -0,0 +1,19 @@ +-- { dg-do compile } + +package body Discr53 is + + function F return Rec is + Data : Rec; + begin + return Data; + end; + + type Ptr is access Rec; + + procedure Proc is + Local : Ptr; + begin + Local := new Rec'(F); + end; + +end Discr53; diff --git a/gcc/testsuite/gnat.dg/discr53.ads b/gcc/testsuite/gnat.dg/discr53.ads new file mode 100644 index 00000000000..3fa9f0f4845 --- /dev/null +++ b/gcc/testsuite/gnat.dg/discr53.ads @@ -0,0 +1,16 @@ +with Discr53_Pkg; + +package Discr53 is + + type Rec (D : Boolean := False) is record + case D is + when True => S : String (1 .. Discr53_Pkg.Max); + when False => null; + end case; + end record; + + function F return Rec; + + procedure Proc; + +end Discr53; diff --git a/gcc/testsuite/gnat.dg/discr53_pkg.ads b/gcc/testsuite/gnat.dg/discr53_pkg.ads new file mode 100644 index 00000000000..d36e1ba2a12 --- /dev/null +++ b/gcc/testsuite/gnat.dg/discr53_pkg.ads @@ -0,0 +1,5 @@ +package Discr53_Pkg is + + function Max return Natural; + +end Discr53_Pkg; diff --git a/gcc/testsuite/gnat.dg/specs/opt3.ads b/gcc/testsuite/gnat.dg/specs/opt3.ads new file mode 100644 index 00000000000..531cf59eae3 --- /dev/null +++ b/gcc/testsuite/gnat.dg/specs/opt3.ads @@ -0,0 +1,13 @@ +-- { dg-do compile } +-- { dg-options "-O3" } + +with Ada.Containers.Vectors; +with Opt3_Pkg; + +package Opt3 is + + type Arr is array (1 .. Opt3_Pkg.Max) of Integer; + + package Arr_Container is new Ada.Containers.Vectors (Natural, Arr); + +end Opt3; diff --git a/gcc/testsuite/gnat.dg/specs/opt3_pkg.ads b/gcc/testsuite/gnat.dg/specs/opt3_pkg.ads new file mode 100644 index 00000000000..4145ac4abaa --- /dev/null +++ b/gcc/testsuite/gnat.dg/specs/opt3_pkg.ads @@ -0,0 +1,7 @@ +-- { dg-excess-errors "no code generated" } + +package Opt3_Pkg is + + function Max return Natural; + +end Opt3_Pkg; diff --git a/gcc/testsuite/go.dg/pr85436.go b/gcc/testsuite/go.dg/pr85436.go new file mode 100644 index 00000000000..225c2734561 --- /dev/null +++ b/gcc/testsuite/go.dg/pr85436.go @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -mcpu=power9" { target { powerpc*-*-* } } } */ + +package main +import ( + "go/ast" + "go/parser" + "go/token" +) +type testFuncs struct { } +func (t *testFuncs) load(filename, pkg string, doImport, seen *bool) { + var testFileSet = token.NewFileSet() + f, err := parser.ParseFile(testFileSet, filename, nil, parser.ParseComments) + if err != nil { } + for _, d := range f.Decls { + n, ok := d.(*ast.FuncDecl) + if !ok { } + ptr := n.Type.Params.List[0].Type.(*ast.StarExpr) + if sel := ptr.X.(*ast.SelectorExpr); sel.Sel.Name == "M" { } + } +} diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index 5aa05b877a9..c2a593d5ac0 100644 --- a/gcc/testsuite/lib/target-supports.exp +++ b/gcc/testsuite/lib/target-supports.exp @@ -5942,7 +5942,7 @@ proc check_effective_target_vect_load_lanes { } { } else { set et_vect_load_lanes 0 # We don't support load_lanes correctly on big-endian arm. - if { ([istarget arm-*-*] && [check_effective_target_arm_neon_ok]) + if { ([check_effective_target_arm_little_endian] && [check_effective_target_arm_neon_ok]) || [istarget aarch64*-*-*] } { set et_vect_load_lanes 1 } diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c index 4e47be1dc05..645db9e1459 100644 --- a/gcc/tree-dfa.c +++ b/gcc/tree-dfa.c @@ -438,7 +438,7 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, referenced the last field of a struct or a union member then we have to adjust maxsize by the padding at the end of our field. */ - if (seen_variable_array_ref && maxsize != -1) + if (seen_variable_array_ref) { tree stype = TREE_TYPE (TREE_OPERAND (exp, 0)); tree next = DECL_CHAIN (field); @@ -454,7 +454,7 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, || ssize == NULL || TREE_CODE (ssize) != INTEGER_CST) maxsize = -1; - else + else if (maxsize != -1) { offset_int tem = (wi::to_offset (ssize) - wi::to_offset (fsize)); @@ -463,6 +463,11 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, maxsize += tem; } } + /* An component ref with an adjacent field up in the + structure hierarchy constrains the size of any variable + array ref lower in the access hierarchy. */ + else + seen_variable_array_ref = false; } } else @@ -617,7 +622,9 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, if (DECL_P (exp)) { - if (flag_unconstrained_commons && VAR_P (exp) && DECL_COMMON (exp)) + if (VAR_P (exp) + && ((flag_unconstrained_commons && DECL_COMMON (exp)) + || (DECL_EXTERNAL (exp) && seen_variable_array_ref))) { tree sz_tree = TYPE_SIZE (TREE_TYPE (exp)); /* If size is unknown, or we have read to the end, assume there diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c index 6b829cc4d79..3f51cb98788 100644 --- a/gcc/tree-ssa-loop-niter.c +++ b/gcc/tree-ssa-loop-niter.c @@ -2320,11 +2320,11 @@ number_of_iterations_exit_assumptions (struct loop *loop, edge exit, tree iv0_niters = NULL_TREE; if (!simple_iv_with_niters (loop, loop_containing_stmt (stmt), - op0, &iv0, &iv0_niters, false)) + op0, &iv0, safe ? &iv0_niters : NULL, false)) return false; tree iv1_niters = NULL_TREE; if (!simple_iv_with_niters (loop, loop_containing_stmt (stmt), - op1, &iv1, &iv1_niters, false)) + op1, &iv1, safe ? &iv1_niters : NULL, false)) return false; /* Give up on complicated case. */ if (iv0_niters && iv1_niters) diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c index 01e060b6690..0607b4bf083 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -1245,7 +1245,9 @@ vn_reference_maybe_forwprop_address (vec<vn_reference_op_s> *ops, return true; } if (!addr_base - || TREE_CODE (addr_base) != MEM_REF) + || TREE_CODE (addr_base) != MEM_REF + || (TREE_CODE (TREE_OPERAND (addr_base, 0)) == SSA_NAME + && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (addr_base, 0)))) return false; off += addr_offset; @@ -1258,6 +1260,7 @@ vn_reference_maybe_forwprop_address (vec<vn_reference_op_s> *ops, ptr = gimple_assign_rhs1 (def_stmt); ptroff = gimple_assign_rhs2 (def_stmt); if (TREE_CODE (ptr) != SSA_NAME + || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ptr) || TREE_CODE (ptroff) != INTEGER_CST) return false; diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c index b5601727c53..04237dbb9fe 100644 --- a/gcc/tree-vect-stmts.c +++ b/gcc/tree-vect-stmts.c @@ -5479,15 +5479,34 @@ vectorizable_operation (gimple *stmt, gimple_stmt_iterator *gsi, /* Handle uses. */ if (j == 0) { - if (op_type == binary_op || op_type == ternary_op) + if (op_type == binary_op) vect_get_vec_defs (op0, op1, stmt, &vec_oprnds0, &vec_oprnds1, slp_node, -1); + else if (op_type == ternary_op) + { + if (slp_node) + { + auto_vec<tree> ops(3); + ops.quick_push (op0); + ops.quick_push (op1); + ops.quick_push (op2); + auto_vec<vec<tree> > vec_defs(3); + vect_get_slp_defs (ops, slp_node, &vec_defs, -1); + vec_oprnds0 = vec_defs[0]; + vec_oprnds1 = vec_defs[1]; + vec_oprnds2 = vec_defs[2]; + } + else + { + vect_get_vec_defs (op0, op1, stmt, &vec_oprnds0, &vec_oprnds1, + NULL, -1); + vect_get_vec_defs (op2, NULL_TREE, stmt, &vec_oprnds2, NULL, + NULL, -1); + } + } else vect_get_vec_defs (op0, NULL_TREE, stmt, &vec_oprnds0, NULL, slp_node, -1); - if (op_type == ternary_op) - vect_get_vec_defs (op2, NULL_TREE, stmt, &vec_oprnds2, NULL, - slp_node, -1); } else { diff --git a/libgcc/ChangeLog b/libgcc/ChangeLog index 70e5bc3baa2..f26d2bbfcb8 100644 --- a/libgcc/ChangeLog +++ b/libgcc/ChangeLog @@ -1,3 +1,11 @@ +2018-06-22 Andre Vieira <andre.simoesdiasvieira@arm.com> + + Backport from mainline + 2018-05-17 Jerome Lambourg <lambourg@adacore.com> + + * config/arm/cmse.c (cmse_check_address_range): Replace + UINTPTR_MAX with __UINTPTR_MAX__ and uintptr_t with __UINTPTR_TYPE__. + 2018-04-02 H.J. Lu <hongjiu.lu@intel.com> Backport from mainline diff --git a/libgcc/config/arm/cmse.c b/libgcc/config/arm/cmse.c index 4ef7102064e..e284bae4293 100644 --- a/libgcc/config/arm/cmse.c +++ b/libgcc/config/arm/cmse.c @@ -36,7 +36,7 @@ cmse_check_address_range (void *p, size_t size, int flags) char *pb = (char *) p, *pe; /* Check if the range wraps around. */ - if (UINTPTR_MAX - (uintptr_t) p < size) + if (__UINTPTR_MAX__ - (__UINTPTR_TYPE__) p < size) return NULL; /* Check if an unknown flag is present. */ @@ -51,7 +51,8 @@ cmse_check_address_range (void *p, size_t size, int flags) /* Execute the right variant of the TT instructions. */ pe = pb + size - 1; - const int singleCheck = (((uintptr_t) pb ^ (uintptr_t) pe) < 32); + const int singleCheck + = (((__UINTPTR_TYPE__) pb ^ (__UINTPTR_TYPE__) pe) < 32); switch (flags & known_secure_level) { case 0: diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog index 798a50ea85b..958b65e73c3 100644 --- a/libgfortran/ChangeLog +++ b/libgfortran/ChangeLog @@ -1,3 +1,17 @@ +2018-06-09 Jerry DeLisle <jvdelisle@gcc.gnu.org> + + Backport from trunk. + PR libgfortran/86070 + * io/write_float.def (build_float_string): Initialize *len. + +2018-06-01 Jerry DeLisle <jvdelisle@gcc.gnu.org> + + Backport from trunk. + PR libgfortran/85840 + * io/write.c (write_float_0, write_real, write_real_g0, + write_complex): Use separate local variables for the float + string length. + 2018-02-18 Jerry DeLisle <jvdelisle@gcc.gnu.org> Backport from trunk diff --git a/libgfortran/io/write.c b/libgfortran/io/write.c index a7307a8f762..70af7703b7e 100644 --- a/libgfortran/io/write.c +++ b/libgfortran/io/write.c @@ -1483,7 +1483,7 @@ write_character (st_parameter_dt *dtp, const char *source, int kind, int length, /* Floating point helper functions. */ -#define BUF_STACK_SZ 256 +#define BUF_STACK_SZ 384 static int get_precision (st_parameter_dt *dtp, const fnode *f, const char *source, int kind) @@ -1584,7 +1584,7 @@ write_float_0 (st_parameter_dt *dtp, const fnode *f, const char *source, int kin char buf_stack[BUF_STACK_SZ]; char str_buf[BUF_STACK_SZ]; char *buffer, *result; - size_t buf_size, res_len; + size_t buf_size, res_len, flt_str_len; /* Precision for snprintf call. */ int precision = get_precision (dtp, f, source, kind); @@ -1595,8 +1595,8 @@ write_float_0 (st_parameter_dt *dtp, const fnode *f, const char *source, int kin buffer = select_buffer (dtp, f, precision, buf_stack, &buf_size, kind); get_float_string (dtp, f, source , kind, 0, buffer, - precision, buf_size, result, &res_len); - write_float_string (dtp, result, res_len); + precision, buf_size, result, &flt_str_len); + write_float_string (dtp, result, flt_str_len); if (buf_size > BUF_STACK_SZ) free (buffer); @@ -1699,7 +1699,7 @@ write_real (st_parameter_dt *dtp, const char *source, int kind) char buf_stack[BUF_STACK_SZ]; char str_buf[BUF_STACK_SZ]; char *buffer, *result; - size_t buf_size, res_len; + size_t buf_size, res_len, flt_str_len; int orig_scale = dtp->u.p.scale_factor; dtp->u.p.scale_factor = 1; set_fnode_default (dtp, &f, kind); @@ -1714,8 +1714,8 @@ write_real (st_parameter_dt *dtp, const char *source, int kind) buffer = select_buffer (dtp, &f, precision, buf_stack, &buf_size, kind); get_float_string (dtp, &f, source , kind, 1, buffer, - precision, buf_size, result, &res_len); - write_float_string (dtp, result, res_len); + precision, buf_size, result, &flt_str_len); + write_float_string (dtp, result, flt_str_len); dtp->u.p.scale_factor = orig_scale; if (buf_size > BUF_STACK_SZ) @@ -1734,7 +1734,7 @@ write_real_g0 (st_parameter_dt *dtp, const char *source, int kind, int d) char buf_stack[BUF_STACK_SZ]; char str_buf[BUF_STACK_SZ]; char *buffer, *result; - size_t buf_size, res_len; + size_t buf_size, res_len, flt_str_len; int comp_d; set_fnode_default (dtp, &f, kind); @@ -1758,8 +1758,8 @@ write_real_g0 (st_parameter_dt *dtp, const char *source, int kind, int d) buffer = select_buffer (dtp, &f, precision, buf_stack, &buf_size, kind); get_float_string (dtp, &f, source , kind, comp_d, buffer, - precision, buf_size, result, &res_len); - write_float_string (dtp, result, res_len); + precision, buf_size, result, &flt_str_len); + write_float_string (dtp, result, flt_str_len); dtp->u.p.g0_no_blanks = 0; if (buf_size > BUF_STACK_SZ) @@ -1784,7 +1784,7 @@ write_complex (st_parameter_dt *dtp, const char *source, int kind, size_t size) char str1_buf[BUF_STACK_SZ]; char str2_buf[BUF_STACK_SZ]; char *buffer, *result1, *result2; - size_t buf_size, res_len1, res_len2; + size_t buf_size, res_len1, res_len2, flt_str_len1, flt_str_len2; int width, lblanks, orig_scale = dtp->u.p.scale_factor; dtp->u.p.scale_factor = 1; @@ -1807,18 +1807,18 @@ write_complex (st_parameter_dt *dtp, const char *source, int kind, size_t size) buffer = select_buffer (dtp, &f, precision, buf_stack, &buf_size, kind); get_float_string (dtp, &f, source , kind, 0, buffer, - precision, buf_size, result1, &res_len1); + precision, buf_size, result1, &flt_str_len1); get_float_string (dtp, &f, source + size / 2 , kind, 0, buffer, - precision, buf_size, result2, &res_len2); + precision, buf_size, result2, &flt_str_len2); if (!dtp->u.p.namelist_mode) { - lblanks = width - res_len1 - res_len2 - 3; + lblanks = width - flt_str_len1 - flt_str_len2 - 3; write_x (dtp, lblanks, lblanks); } write_char (dtp, '('); - write_float_string (dtp, result1, res_len1); + write_float_string (dtp, result1, flt_str_len1); write_char (dtp, semi_comma); - write_float_string (dtp, result2, res_len2); + write_float_string (dtp, result2, flt_str_len2); write_char (dtp, ')'); dtp->u.p.scale_factor = orig_scale; diff --git a/libgfortran/io/write_float.def b/libgfortran/io/write_float.def index 7f0aa1d6143..b4971fd335e 100644 --- a/libgfortran/io/write_float.def +++ b/libgfortran/io/write_float.def @@ -135,6 +135,7 @@ build_float_string (st_parameter_dt *dtp, const fnode *f, char *buffer, w = f->u.real.w; d = f->u.real.d; p = dtp->u.p.scale_factor; + *len = 0; rchar = '5'; diff --git a/libgo/config.h.in b/libgo/config.h.in index a7b1d47ac9b..312da8b2837 100644 --- a/libgo/config.h.in +++ b/libgo/config.h.in @@ -340,9 +340,6 @@ /* Define to 1 if you have the `unshare' function. */ #undef HAVE_UNSHARE -/* Define to 1 if you have the <ustat.h> header file and it works. */ -#undef HAVE_USTAT_H - /* Define to 1 if you have the `utimensat' function. */ #undef HAVE_UTIMENSAT diff --git a/libgo/configure b/libgo/configure index 1d3d714fc05..94c42f67e82 100755 --- a/libgo/configure +++ b/libgo/configure @@ -14784,39 +14784,6 @@ fi done -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether <ustat.h> can be used" >&5 -$as_echo_n "checking whether <ustat.h> can be used... " >&6; } -if test "${libgo_cv_c_ustat_h+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - CFLAGS_hold=$CFLAGS -CFLAGS="$CFLAGS -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE $OSCFLAGS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -#include <sys/types.h> -#ifdef HAVE_LINUX_FILTER_H -#include <linux/filter.h> -#endif -#include <ustat.h> - -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - libgo_cv_c_ustat_h=yes -else - libgo_cv_c_ustat_h=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -CFLAGS=$CFLAGS_hold -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libgo_cv_c_ustat_h" >&5 -$as_echo "$libgo_cv_c_ustat_h" >&6; } -if test $libgo_cv_c_ustat_h = yes; then - -$as_echo "#define HAVE_USTAT_H 1" >>confdefs.h - -fi - if test "$ac_cv_header_sys_mman_h" = yes; then HAVE_SYS_MMAN_H_TRUE= HAVE_SYS_MMAN_H_FALSE='#' diff --git a/libgo/configure.ac b/libgo/configure.ac index 51b2c161846..0adbadf20d4 100644 --- a/libgo/configure.ac +++ b/libgo/configure.ac @@ -572,24 +572,6 @@ AC_CHECK_HEADERS([linux/filter.h linux/if_addr.h linux/if_ether.h linux/if_tun.h #endif ]) -AC_CACHE_CHECK([whether <ustat.h> can be used], -[libgo_cv_c_ustat_h], -[CFLAGS_hold=$CFLAGS -CFLAGS="$CFLAGS -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE $OSCFLAGS" -AC_COMPILE_IFELSE( -[AC_LANG_SOURCE([ -#include <sys/types.h> -#ifdef HAVE_LINUX_FILTER_H -#include <linux/filter.h> -#endif -#include <ustat.h> -])], [libgo_cv_c_ustat_h=yes], [libgo_cv_c_ustat_h=no]) -CFLAGS=$CFLAGS_hold]) -if test $libgo_cv_c_ustat_h = yes; then - AC_DEFINE(HAVE_USTAT_H, 1, - [Define to 1 if you have the <ustat.h> header file and it works.]) -fi - AM_CONDITIONAL(HAVE_SYS_MMAN_H, test "$ac_cv_header_sys_mman_h" = yes) AC_CHECK_FUNCS(strerror_r strsignal wait4 mincore setenv unsetenv dl_iterate_phdr) diff --git a/libgo/go/syscall/libcall_linux_ustat.go b/libgo/go/syscall/libcall_linux_ustat.go deleted file mode 100644 index 261f086f47e..00000000000 --- a/libgo/go/syscall/libcall_linux_ustat.go +++ /dev/null @@ -1,12 +0,0 @@ -// Copyright 2015 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// GNU/Linux library ustat call. -// This is not supported on some kernels, such as arm64. -// +build !arm64 - -package syscall - -//sys Ustat(dev int, ubuf *Ustat_t) (err error) -//ustat(dev _dev_t, ubuf *Ustat_t) _C_int diff --git a/libgo/mksysinfo.sh b/libgo/mksysinfo.sh index 61d39d7e2dd..2284928ae53 100755 --- a/libgo/mksysinfo.sh +++ b/libgo/mksysinfo.sh @@ -1107,20 +1107,6 @@ grep '^type _sysinfo ' gen-sysinfo.go | \ -e 's/mem_unit/Unit/' \ >> ${OUT} -# The ustat struct. -grep '^type _ustat ' gen-sysinfo.go | \ - sed -e 's/_ustat/Ustat_t/' \ - -e 's/f_tfree/Tfree/' \ - -e 's/f_tinode/Tinoe/' \ - -e 's/f_fname/Fname/' \ - -e 's/f_fpack/Fpack/' \ - >> ${OUT} -# Force it to be defined, as on some older GNU/Linux systems the -# header file fails when using with <linux/filter.h>. -if ! grep 'type _ustat ' gen-sysinfo.go >/dev/null 2>&1; then - echo 'type Ustat_t struct { Tfree int32; Tinoe uint64; Fname [5+1]int8; Fpack [5+1]int8; }' >> ${OUT} -fi - # The utimbuf struct. grep '^type _utimbuf ' gen-sysinfo.go | \ sed -e 's/_utimbuf/Utimbuf/' \ diff --git a/libgo/sysinfo.c b/libgo/sysinfo.c index a1afc7d119c..7ff721816f9 100644 --- a/libgo/sysinfo.c +++ b/libgo/sysinfo.c @@ -135,9 +135,6 @@ #if defined(HAVE_SYS_SYSINFO_H) #include <sys/sysinfo.h> #endif -#if defined(HAVE_USTAT_H) -#include <ustat.h> -#endif #if defined(HAVE_UTIME_H) #include <utime.h> #endif diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog index c3a640a0689..cc463532157 100644 --- a/libgomp/ChangeLog +++ b/libgomp/ChangeLog @@ -1,3 +1,13 @@ +2018-05-01 Tom de Vries <tom@codesourcery.com> + + backport from trunk: + 2018-04-16 Cesar Philippidis <cesar@codesourcery.com> + Tom de Vries <tom@codesourcery.com> + + PR middle-end/84955 + * testsuite/libgomp.oacc-c-c++-common/pr84955.c: New test. + * testsuite/libgomp.oacc-fortran/pr84955.f90: New test. + 2018-03-03 Jakub Jelinek <jakub@redhat.com> Backported from mainline diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/pr84955.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/pr84955.c new file mode 100644 index 00000000000..e528faad0c4 --- /dev/null +++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/pr84955.c @@ -0,0 +1,15 @@ +/* { dg-do compile } */ + +int +main (void) +{ + int i, j; + +#pragma acc parallel loop tile(2,3) + for (i = 1; i < 10; i++) + for (j = 1; j < 10; j++) + for (;;) + ; + + return i + j; +} diff --git a/libgomp/testsuite/libgomp.oacc-fortran/pr84955.f90 b/libgomp/testsuite/libgomp.oacc-fortran/pr84955.f90 new file mode 100644 index 00000000000..dc858653808 --- /dev/null +++ b/libgomp/testsuite/libgomp.oacc-fortran/pr84955.f90 @@ -0,0 +1,13 @@ +! { dg-do compile } + +subroutine s + integer :: i, j + !$acc parallel loop tile(2,3) + do i = 1, 10 + do j = 1, 10 + do + end do + end do + end do + !$acc end parallel loop +end subroutine s diff --git a/libsanitizer/ChangeLog b/libsanitizer/ChangeLog index 2c213f18e0c..3a1619045eb 100644 --- a/libsanitizer/ChangeLog +++ b/libsanitizer/ChangeLog @@ -1,3 +1,40 @@ +2018-06-07 Richard Biener <rguenther@suse.de> + + Backport from mainline + 2018-03-19 Jakub Jelinek <jakub@redhat.com> + + PR sanitizer/84761 + * sanitizer_common/sanitizer_linux_libcdep.cc (__GLIBC_PREREQ): + Define if not defined. + (DL_INTERNAL_FUNCTION): Don't define. + (InitTlsSize): For __i386__ if not compiled against glibc 2.27+ + determine at runtime whether to use regparm(3), stdcall calling + convention for older glibcs or normal calling convention for + newer glibcs for call to _dl_get_tls_static_info. + +2018-05-31 Matthias Klose <doko@ubuntu.com> + + PR sanitizer/86012 + * sanitizer_common/sanitizer_platform_limits_posix.cc: Define + SIZEOF_STRUCT_USTAT for 32bit sparc. + +2018-05-24 H.J. Lu <hongjiu.lu@intel.com> + + PR sanitizer/85835 + * sanitizer_common/sanitizer_platform_limits_posix.cc: Don't + include <sys/ustat.h> for Linux. + (SIZEOF_STRUCT_USTAT): New. + (struct_ustat_sz): Use SIZEOF_STRUCT_USTAT for Linux. + +2018-04-24 Martin Liska <mliska@suse.cz> + + Backport from mainline + 2018-04-18 Bill Seurer <seurer@linux.vnet.ibm.com> + + PR sanitizer/85389 + * asan/asan_allocator.h (kAllocatorSpace): For __powerpc64__ change + from 0xa0000000000ULL to ~(uptr)0. + 2018-01-25 Release Manager * GCC 7.3.0 released. diff --git a/libsanitizer/asan/asan_allocator.h b/libsanitizer/asan/asan_allocator.h index 7eeddadd547..dacfddd5ddf 100644 --- a/libsanitizer/asan/asan_allocator.h +++ b/libsanitizer/asan/asan_allocator.h @@ -115,7 +115,7 @@ struct AsanMapUnmapCallback { #if SANITIZER_CAN_USE_ALLOCATOR64 # if defined(__powerpc64__) -const uptr kAllocatorSpace = 0xa0000000000ULL; +const uptr kAllocatorSpace = ~(uptr)0; const uptr kAllocatorSize = 0x20000000000ULL; // 2T. typedef DefaultSizeClassMap SizeClassMap; # elif defined(__aarch64__) && SANITIZER_ANDROID diff --git a/libsanitizer/sanitizer_common/sanitizer_linux_libcdep.cc b/libsanitizer/sanitizer_common/sanitizer_linux_libcdep.cc index 63e70660cf3..dc342de6e10 100644 --- a/libsanitizer/sanitizer_common/sanitizer_linux_libcdep.cc +++ b/libsanitizer/sanitizer_common/sanitizer_linux_libcdep.cc @@ -153,28 +153,43 @@ bool SanitizerGetThreadName(char *name, int max_len) { #endif } +#ifndef __GLIBC_PREREQ +#define __GLIBC_PREREQ(x, y) 0 +#endif + #if !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO static uptr g_tls_size; -#ifdef __i386__ -# define DL_INTERNAL_FUNCTION __attribute__((regparm(3), stdcall)) -#else -# define DL_INTERNAL_FUNCTION -#endif - void InitTlsSize() { // all current supported platforms have 16 bytes stack alignment const size_t kStackAlign = 16; - typedef void (*get_tls_func)(size_t*, size_t*) DL_INTERNAL_FUNCTION; - get_tls_func get_tls; - void *get_tls_static_info_ptr = dlsym(RTLD_NEXT, "_dl_get_tls_static_info"); - CHECK_EQ(sizeof(get_tls), sizeof(get_tls_static_info_ptr)); - internal_memcpy(&get_tls, &get_tls_static_info_ptr, - sizeof(get_tls_static_info_ptr)); - CHECK_NE(get_tls, 0); size_t tls_size = 0; size_t tls_align = 0; - get_tls(&tls_size, &tls_align); + void *get_tls_static_info_ptr = dlsym(RTLD_NEXT, "_dl_get_tls_static_info"); +#if defined(__i386__) && !__GLIBC_PREREQ(2, 27) + /* On i?86, _dl_get_tls_static_info used to be internal_function, i.e. + __attribute__((regparm(3), stdcall)) before glibc 2.27 and is normal + function in 2.27 and later. */ + if (!dlvsym(RTLD_NEXT, "glob", "GLIBC_2.27")) { + typedef void (*get_tls_func)(size_t*, size_t*) + __attribute__((regparm(3), stdcall)); + get_tls_func get_tls; + CHECK_EQ(sizeof(get_tls), sizeof(get_tls_static_info_ptr)); + internal_memcpy(&get_tls, &get_tls_static_info_ptr, + sizeof(get_tls_static_info_ptr)); + CHECK_NE(get_tls, 0); + get_tls(&tls_size, &tls_align); + } else +#endif + { + typedef void (*get_tls_func)(size_t*, size_t*); + get_tls_func get_tls; + CHECK_EQ(sizeof(get_tls), sizeof(get_tls_static_info_ptr)); + internal_memcpy(&get_tls, &get_tls_static_info_ptr, + sizeof(get_tls_static_info_ptr)); + CHECK_NE(get_tls, 0); + get_tls(&tls_size, &tls_align); + } if (tls_align < kStackAlign) tls_align = kStackAlign; g_tls_size = RoundUpTo(tls_size, tls_align); diff --git a/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.cc b/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.cc index 31a5e697eae..97eae3fc7bc 100644 --- a/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.cc +++ b/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.cc @@ -154,7 +154,6 @@ typedef struct user_fpregs elf_fpregset_t; # include <sys/procfs.h> #endif #include <sys/user.h> -#include <sys/ustat.h> #include <linux/cyclades.h> #include <linux/if_eql.h> #include <linux/if_plip.h> @@ -247,7 +246,19 @@ namespace __sanitizer { #endif // SANITIZER_LINUX || SANITIZER_FREEBSD #if SANITIZER_LINUX && !SANITIZER_ANDROID - unsigned struct_ustat_sz = sizeof(struct ustat); + // Use pre-computed size of struct ustat to avoid <sys/ustat.h> which + // has been removed from glibc 2.28. +#if defined(__aarch64__) || defined(__s390x__) || defined (__mips64) \ + || defined(__powerpc64__) || defined(__arch64__) || defined(__sparcv9) \ + || defined(__x86_64__) +#define SIZEOF_STRUCT_USTAT 32 +#elif defined(__arm__) || defined(__i386__) || defined(__mips__) \ + || defined(__powerpc__) || defined(__s390__) || defined(__sparc__) +#define SIZEOF_STRUCT_USTAT 20 +#else +#error Unknown size of struct ustat +#endif + unsigned struct_ustat_sz = SIZEOF_STRUCT_USTAT; unsigned struct_rlimit64_sz = sizeof(struct rlimit64); unsigned struct_statvfs64_sz = sizeof(struct statvfs64); #endif // SANITIZER_LINUX && !SANITIZER_ANDROID diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 5f76ed34181..fc7f9764521 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,99 @@ +2018-06-21 Jonathan Wakely <jwakely@redhat.com> + + * config/abi/post/x86_64-linux-gnu/baseline_symbols.txt: Update. + +2018-06-19 Jonathan Wakely <jwakely@redhat.com> + + * include/std/utility: Remove unused <exception> header. + +2018-06-15 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/86169 + * include/bits/basic_string.h [!_GLIBCXX_USE_CXX11_ABI] + (basic_string::data()): Unshare string. + * testsuite/21_strings/basic_string/operations/data/char/86169.cc: + New. + +2018-06-15 Jonathan Wakely <jwakely@redhat.com> + + * include/bits/char_traits.h (__cpp_lib_constexpr_char_traits): Only + define for C++17 and above. + +2018-05-17 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/85812 + * libsupc++/cxxabi_init_exception.h (__cxa_free_exception): Declare. + * libsupc++/exception_ptr.h (make_exception_ptr) [__cpp_exceptions]: + Refactor to separate non-throwing and throwing implementations. + [__cpp_rtti && !_GLIBCXX_HAVE_CDTOR_CALLABI]: Deallocate the memory + if constructing the object throws. + +2018-05-14 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/67554 + * include/bits/valarray_array.h (_Array_copy_ctor<_Tp, true>) + (_Array_copier<_Tp, true>): Do not pass null pointers to memcpy. + + PR libstdc++/82966 + * include/bits/node_handle.h (_Node_handle_common::_M_swap): Use value + instead of type. + * testsuite/23_containers/set/modifiers/node_swap.cc: New. + +2018-05-10 Jonathan Wakely <jwakely@redhat.com> + + * doc/xml/faq.xml: Link to C++17 status. Add note to outdated answer. + * doc/xml/manual/debug_mode.xml: Add array and forward_list to list + of C++11 containers with Debug Mode support. + * doc/xml/manual/using.xml: Document Dual ABI for ios_base::failure. + * doc/html/*: Regenerate. + +2018-05-07 Edward Smith-Rowland <3dw4rd@verizon.net> + Jonathan Wakely <jwakely@redhat.com> + + Backport from mainline + 2018-05-07 Edward Smith-Rowland <3dw4rd@verizon.net> + + PR libstdc++/80506 + * include/bits/random.tcc (gamma_distribution::operator()): Fix magic + number used in loop condition. + (gamma_distribution::__generate_impl()): Ditto. + +2018-05-03 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/84769 + * include/std/variant (visit): Qualify std::get call. + + PR libstdc++/85632 use uintmax_t for arithmetic + * src/filesystem/ops.cc (experimental::filesystem::space): Perform + arithmetic in result type. + * testsuite/experimental/filesystem/operations/space.cc: New. + +2018-04-30 Edward Smith-Rowland <3dw4rd@verizon.net> + + PR libstdc++/pr66689 - comp_ellint_3 and ellint_3 return garbage values + * include/tr1/ell_integral.tcc: Correct the nu sign convention + in ellint_3 and comp_ellint_3. + * testsuite/tr1/5_numerical_facilities/special_functions/ + 06_comp_ellint_3/check_value.cc: Regen with correct values. + * testsuite/tr1/5_numerical_facilities/special_functions/ + 14_ellint_3/check_value.cc: Ditto. + * testsuite/special_functions/06_comp_ellint_3/check_value.cc: Ditto. + * testsuite/special_functions/13_ellint_3/check_value.cc: Ditto. + * testsuite/special_functions/06_comp_ellint_3/pr66689.cc: New. + * testsuite/special_functions/13_ellint_3/pr66689.cc: New. + * testsuite/tr1/5_numerical_facilities/special_functions/ + 06_comp_ellint_3/pr66689.cc: New. + * testsuite/tr1/5_numerical_facilities/special_functions/ + 14_ellint_3/pr66689.cc: New. + +2018-04-30 Edward Smith-Rowland <3dw4rd@verizon.net> + + PR libstdc++/68397 std::tr1::expint fails ... long double arguments. + * include/tr1/exp_integral.tcc: Increase iteration limits. + * testsuite/tr1/5_numerical_facilities/special_functions/15_expint/ + pr68397.cc: New test. + * testsuite/special_functions/14_expint/pr68397.cc: New test. + 2018-04-18 Jonathan Wakely <jwakely@redhat.com> Jakub Jelinek <jakub@redhat.com> diff --git a/libstdc++-v3/config/abi/post/x86_64-linux-gnu/baseline_symbols.txt b/libstdc++-v3/config/abi/post/x86_64-linux-gnu/baseline_symbols.txt index a31597e906f..06c61236f34 100644 --- a/libstdc++-v3/config/abi/post/x86_64-linux-gnu/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/x86_64-linux-gnu/baseline_symbols.txt @@ -4004,6 +4004,7 @@ OBJECT:0:GLIBCXX_3.4.20 OBJECT:0:GLIBCXX_3.4.21 OBJECT:0:GLIBCXX_3.4.22 OBJECT:0:GLIBCXX_3.4.23 +OBJECT:0:GLIBCXX_3.4.24 OBJECT:0:GLIBCXX_3.4.3 OBJECT:0:GLIBCXX_3.4.4 OBJECT:0:GLIBCXX_3.4.5 diff --git a/libstdc++-v3/doc/html/faq.html b/libstdc++-v3/doc/html/faq.html index f78d63cd61e..9e3924f8a60 100644 --- a/libstdc++-v3/doc/html/faq.html +++ b/libstdc++-v3/doc/html/faq.html @@ -534,14 +534,15 @@ except for some corner cases. Support for localization in <code class="classname">locale</code> may be incomplete on some non-GNU platforms. Also dependent on the underlying platform is support - for <span class="type">wchar_t</span> and <span class="type">long - long</span> specializations, and details of thread support. + for <span class="type">wchar_t</span> and <span class="type">long long</span> specializations, + and details of thread support. </p><p> Long answer: See the implementation status pages for <a class="link" href="manual/status.html#status.iso.1998" title="C++ 1998/2003">C++98</a>, - <a class="link" href="manual/status.html#status.iso.tr1" title="C++ TR1">TR1</a>, and - <a class="link" href="manual/status.html#status.iso.2011" title="C++ 2011">C++11</a>. - <a class="link" href="manual/status.html#status.iso.2014" title="C++ 2014">C++14</a>. + <a class="link" href="manual/status.html#status.iso.tr1" title="C++ TR1">TR1</a>, + <a class="link" href="manual/status.html#status.iso.2011" title="C++ 2011">C++11</a>, + <a class="link" href="manual/status.html#status.iso.2014" title="C++ 2014">C++14</a>, and + <a class="link" href="manual/status.html#status.iso.2017" title="C++ 2017">C++17</a>. </p></td></tr><tr class="question"><td align="left" valign="top"><a id="faq.standard_bugs"></a><a id="q-standard_bugs"></a><p><strong>5.2.</strong></p></td><td align="left" valign="top"><p> Bugs in the ISO C++ language or library specification </p></td></tr><tr class="answer"><td align="left" valign="top"><a id="a-standard_bugs"></a></td><td align="left" valign="top"><p> @@ -633,7 +634,7 @@ without other drawbacks, send us a patch. </p></td></tr><tr class="question"><td align="left" valign="top"><a id="faq.ambiguous_overloads"></a><a id="q-ambiguous_overloads"></a><p><strong>6.3.</strong></p></td><td align="left" valign="top"><p> Ambiguous overloads after including an old-style header - </p></td></tr><tr class="answer"><td align="left" valign="top"><a id="a-ambiguous_overloads"></a></td><td align="left" valign="top"><p> + </p></td></tr><tr class="answer"><td align="left" valign="top"><a id="a-ambiguous_overloads"></a></td><td align="left" valign="top"><div class="note" style="margin-left: 0.5in; margin-right: 0.5in;"><h3 class="title">Note</h3><p>This answer is old and probably no longer be relevant.</p></div><p> Another problem is the <code class="literal">rel_ops</code> namespace and the template comparison operator functions contained therein. If they become visible in the same namespace as other comparison functions diff --git a/libstdc++-v3/doc/html/manual/debug_mode_using.html b/libstdc++-v3/doc/html/manual/debug_mode_using.html index 99142903dfb..e4f7ea54d22 100644 --- a/libstdc++-v3/doc/html/manual/debug_mode_using.html +++ b/libstdc++-v3/doc/html/manual/debug_mode_using.html @@ -20,4 +20,4 @@ containers: </p><div class="table"><a id="table.debug_mode_containers"></a><p class="title"><strong>Table 17.1. Debugging Containers</strong></p><div class="table-contents"><table class="table" summary="Debugging Containers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Container</th><th align="left">Header</th><th align="left">Debug container</th><th align="left">Debug header</th></tr></thead><tbody><tr><td align="left"><code class="classname">std::bitset</code></td><td align="left"><code class="filename">bitset</code></td><td align="left"><code class="classname">__gnu_debug::bitset</code></td><td align="left"><code class="filename"><debug/bitset></code></td></tr><tr><td align="left"><code class="classname">std::deque</code></td><td align="left"><code class="filename">deque</code></td><td align="left"><code class="classname">__gnu_debug::deque</code></td><td align="left"><code class="filename"><debug/deque></code></td></tr><tr><td align="left"><code class="classname">std::list</code></td><td align="left"><code class="filename">list</code></td><td align="left"><code class="classname">__gnu_debug::list</code></td><td align="left"><code class="filename"><debug/list></code></td></tr><tr><td align="left"><code class="classname">std::map</code></td><td align="left"><code class="filename">map</code></td><td align="left"><code class="classname">__gnu_debug::map</code></td><td align="left"><code class="filename"><debug/map></code></td></tr><tr><td align="left"><code class="classname">std::multimap</code></td><td align="left"><code class="filename">map</code></td><td align="left"><code class="classname">__gnu_debug::multimap</code></td><td align="left"><code class="filename"><debug/map></code></td></tr><tr><td align="left"><code class="classname">std::multiset</code></td><td align="left"><code class="filename">set</code></td><td align="left"><code class="classname">__gnu_debug::multiset</code></td><td align="left"><code class="filename"><debug/set></code></td></tr><tr><td align="left"><code class="classname">std::set</code></td><td align="left"><code class="filename">set</code></td><td align="left"><code class="classname">__gnu_debug::set</code></td><td align="left"><code class="filename"><debug/set></code></td></tr><tr><td align="left"><code class="classname">std::string</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="classname">__gnu_debug::string</code></td><td align="left"><code class="filename"><debug/string></code></td></tr><tr><td align="left"><code class="classname">std::wstring</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="classname">__gnu_debug::wstring</code></td><td align="left"><code class="filename"><debug/string></code></td></tr><tr><td align="left"><code class="classname">std::basic_string</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="classname">__gnu_debug::basic_string</code></td><td align="left"><code class="filename"><debug/string></code></td></tr><tr><td align="left"><code class="classname">std::vector</code></td><td align="left"><code class="filename">vector</code></td><td align="left"><code class="classname">__gnu_debug::vector</code></td><td align="left"><code class="filename"><debug/vector></code></td></tr></tbody></table></div></div><br class="table-break" /><p>In addition, when compiling in C++11 mode, these additional containers have additional debug capability. -</p><div class="table"><a id="table.debug_mode_containers_cxx11"></a><p class="title"><strong>Table 17.2. Debugging Containers C++11</strong></p><div class="table-contents"><table class="table" summary="Debugging Containers C++11" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Container</th><th align="left">Header</th><th align="left">Debug container</th><th align="left">Debug header</th></tr></thead><tbody><tr><td align="left"><code class="classname">std::unordered_map</code></td><td align="left"><code class="filename">unordered_map</code></td><td align="left"><code class="classname">__gnu_debug::unordered_map</code></td><td align="left"><code class="filename"><debug/unordered_map></code></td></tr><tr><td align="left"><code class="classname">std::unordered_multimap</code></td><td align="left"><code class="filename">unordered_map</code></td><td align="left"><code class="classname">__gnu_debug::unordered_multimap</code></td><td align="left"><code class="filename"><debug/unordered_map></code></td></tr><tr><td align="left"><code class="classname">std::unordered_set</code></td><td align="left"><code class="filename">unordered_set</code></td><td align="left"><code class="classname">__gnu_debug::unordered_set</code></td><td align="left"><code class="filename"><debug/unordered_set></code></td></tr><tr><td align="left"><code class="classname">std::unordered_multiset</code></td><td align="left"><code class="filename">unordered_set</code></td><td align="left"><code class="classname">__gnu_debug::unordered_multiset</code></td><td align="left"><code class="filename"><debug/unordered_set></code></td></tr></tbody></table></div></div><br class="table-break" /></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="debug_mode_semantics.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="debug_mode.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="debug_mode_design.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Semantics </td><td width="20%" align="center"><a accesskey="h" href="../index.html">Home</a></td><td width="40%" align="right" valign="top"> Design</td></tr></table></div></body></html>
\ No newline at end of file +</p><div class="table"><a id="table.debug_mode_containers_cxx11"></a><p class="title"><strong>Table 17.2. Debugging Containers C++11</strong></p><div class="table-contents"><table class="table" summary="Debugging Containers C++11" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Container</th><th align="left">Header</th><th align="left">Debug container</th><th align="left">Debug header</th></tr></thead><tbody><tr><td align="left"><code class="classname">std::array</code></td><td align="left"><code class="filename">array</code></td><td align="left"><code class="classname">__gnu_debug::array</code></td><td align="left"><code class="filename"><debug/array></code></td></tr><tr><td align="left"><code class="classname">std::forward_list</code></td><td align="left"><code class="filename">forward_list</code></td><td align="left"><code class="classname">__gnu_debug::forward_list</code></td><td align="left"><code class="filename"><debug/forward_list></code></td></tr><tr><td align="left"><code class="classname">std::unordered_map</code></td><td align="left"><code class="filename">unordered_map</code></td><td align="left"><code class="classname">__gnu_debug::unordered_map</code></td><td align="left"><code class="filename"><debug/unordered_map></code></td></tr><tr><td align="left"><code class="classname">std::unordered_multimap</code></td><td align="left"><code class="filename">unordered_map</code></td><td align="left"><code class="classname">__gnu_debug::unordered_multimap</code></td><td align="left"><code class="filename"><debug/unordered_map></code></td></tr><tr><td align="left"><code class="classname">std::unordered_set</code></td><td align="left"><code class="filename">unordered_set</code></td><td align="left"><code class="classname">__gnu_debug::unordered_set</code></td><td align="left"><code class="filename"><debug/unordered_set></code></td></tr><tr><td align="left"><code class="classname">std::unordered_multiset</code></td><td align="left"><code class="filename">unordered_set</code></td><td align="left"><code class="classname">__gnu_debug::unordered_multiset</code></td><td align="left"><code class="filename"><debug/unordered_set></code></td></tr></tbody></table></div></div><br class="table-break" /></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="debug_mode_semantics.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="debug_mode.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="debug_mode_design.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Semantics </td><td width="20%" align="center"><a accesskey="h" href="../index.html">Home</a></td><td width="40%" align="right" valign="top"> Design</td></tr></table></div></body></html>
\ No newline at end of file diff --git a/libstdc++-v3/doc/html/manual/using_dual_abi.html b/libstdc++-v3/doc/html/manual/using_dual_abi.html index 4a62c0267be..916ac575f64 100644 --- a/libstdc++-v3/doc/html/manual/using_dual_abi.html +++ b/libstdc++-v3/doc/html/manual/using_dual_abi.html @@ -14,7 +14,7 @@ for the new implementations have different names the definitions for both versions can be present in the same library. </p><p> The <span class="symbol">_GLIBCXX_USE_CXX11_ABI</span> macro (see -<a class="xref" href="using_macros.html" title="Macros">Macros</a>) controls whether + <a class="xref" href="using_macros.html" title="Macros">Macros</a>) controls whether the declarations in the library headers use the old or new ABI. So the decision of which ABI to use can be made separately for each source file being compiled. @@ -43,10 +43,35 @@ facet that derives from one or other version of <code class="classname">time_get</code> is installed in the locale). </p><p> Although the standard exception types defined in - <code class="filename"><stdexcept></code> use strings, they + <code class="filename"><stdexcept></code> use strings, most are not defined twice, so that a <code class="classname">std::out_of_range</code> exception thrown in one file can always be caught by a suitable handler in another file, even if the two files are compiled with different ABIs. +</p><p> One exception type does change when using the new ABI, namely + <code class="classname">std::ios_base::failure</code>. + This is necessary because the 2011 standard changed its base class from + <code class="classname">std::exception</code> to + <code class="classname">std::system_error</code>, which causes its layout to change. + Exceptions due to iostream errors are thrown by a function inside + <code class="filename">libstdc++.so</code>, so whether the thrown + exception uses the old <code class="classname">std::ios_base::failure</code> type + or the new one depends on the ABI that was active when + <code class="filename">libstdc++.so</code> was built, + <span class="emphasis"><em>not</em></span> the ABI active in the user code that is using + iostreams. + This means that for a given build of GCC the type thrown is fixed. + In current releases the library throws a special type that can be caught + by handlers for either the old or new type, + but for GCC 7.1, 7.2 and 7.3 the library throws the new + <code class="classname">std::ios_base::failure</code> type, + and for GCC 5.x and 6.x the library throws the old type. + Catch handlers of type <code class="classname">std::ios_base::failure</code> + will only catch the exceptions if using a newer release, + or if the handler is compiled with the same ABI as the type thrown by + the library. + Handlers for <code class="classname">std::exception</code> will always catch + iostreams exceptions, because the old and new type both inherit from + <code class="classname">std::exception</code>. </p><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="manual.intro.using.abi.trouble"></a>Troubleshooting</h3></div></div></div><p> If you get linker errors about undefined references to symbols that involve types in the <code class="code">std::__cxx11</code> namespace or the tag <code class="code">[abi:cxx11]</code> then it probably indicates that you are trying to diff --git a/libstdc++-v3/doc/xml/faq.xml b/libstdc++-v3/doc/xml/faq.xml index 8041c1428e6..9f0c5c9e661 100644 --- a/libstdc++-v3/doc/xml/faq.xml +++ b/libstdc++-v3/doc/xml/faq.xml @@ -734,15 +734,16 @@ except for some corner cases. Support for localization in <classname>locale</classname> may be incomplete on some non-GNU platforms. Also dependent on the underlying platform is support - for <type>wchar_t</type> and <type>long - long</type> specializations, and details of thread support. + for <type>wchar_t</type> and <type>long long</type> specializations, + and details of thread support. </para> <para> Long answer: See the implementation status pages for <link linkend="status.iso.1998">C++98</link>, - <link linkend="status.iso.tr1">TR1</link>, and - <link linkend="status.iso.2011">C++11</link>. - <link linkend="status.iso.2014">C++14</link>. + <link linkend="status.iso.tr1">TR1</link>, + <link linkend="status.iso.2011">C++11</link>, + <link linkend="status.iso.2014">C++14</link>, and + <link linkend="status.iso.2017">C++17</link>. </para> </answer> </qandaentry> @@ -875,6 +876,9 @@ </para> </question> <answer xml:id="a-ambiguous_overloads"> + <note> + <para>This answer is old and probably no longer be relevant.</para> + </note> <para> Another problem is the <literal>rel_ops</literal> namespace and the template comparison operator functions contained therein. If they become diff --git a/libstdc++-v3/doc/xml/manual/debug_mode.xml b/libstdc++-v3/doc/xml/manual/debug_mode.xml index 65abf051674..1031171871d 100644 --- a/libstdc++-v3/doc/xml/manual/debug_mode.xml +++ b/libstdc++-v3/doc/xml/manual/debug_mode.xml @@ -285,7 +285,19 @@ containers have additional debug capability. </row> </thead> <tbody> - <row> + <row> + <entry><classname>std::array</classname></entry> + <entry><filename class="headerfile">array</filename></entry> + <entry><classname>__gnu_debug::array</classname></entry> + <entry><filename class="headerfile"><debug/array></filename></entry> + </row> + <row> + <entry><classname>std::forward_list</classname></entry> + <entry><filename class="headerfile">forward_list</filename></entry> + <entry><classname>__gnu_debug::forward_list</classname></entry> + <entry><filename class="headerfile"><debug/forward_list></filename></entry> + </row> + <row> <entry><classname>std::unordered_map</classname></entry> <entry><filename class="headerfile">unordered_map</filename></entry> <entry><classname>__gnu_debug::unordered_map</classname></entry> diff --git a/libstdc++-v3/doc/xml/manual/using.xml b/libstdc++-v3/doc/xml/manual/using.xml index 5c0e1b9f8c1..992e4ecea8d 100644 --- a/libstdc++-v3/doc/xml/manual/using.xml +++ b/libstdc++-v3/doc/xml/manual/using.xml @@ -1016,7 +1016,7 @@ g++ -Winvalid-pch -I. -include stdc++.h -H -g -O2 hello.cc -o test.exe </para> <para> The <symbol>_GLIBCXX_USE_CXX11_ABI</symbol> macro (see -<xref linkend="manual.intro.using.macros"/>) controls whether + <xref linkend="manual.intro.using.macros"/>) controls whether the declarations in the library headers use the old or new ABI. So the decision of which ABI to use can be made separately for each source file being compiled. @@ -1051,12 +1051,39 @@ g++ -Winvalid-pch -I. -include stdc++.h -H -g -O2 hello.cc -o test.exe </para> <para> Although the standard exception types defined in - <filename class="headerfile"><stdexcept></filename> use strings, they + <filename class="headerfile"><stdexcept></filename> use strings, most are not defined twice, so that a <classname>std::out_of_range</classname> exception thrown in one file can always be caught by a suitable handler in another file, even if the two files are compiled with different ABIs. </para> +<para> One exception type does change when using the new ABI, namely + <classname>std::ios_base::failure</classname>. + This is necessary because the 2011 standard changed its base class from + <classname>std::exception</classname> to + <classname>std::system_error</classname>, which causes its layout to change. + Exceptions due to iostream errors are thrown by a function inside + <filename class="libraryfile">libstdc++.so</filename>, so whether the thrown + exception uses the old <classname>std::ios_base::failure</classname> type + or the new one depends on the ABI that was active when + <filename class="libraryfile">libstdc++.so</filename> was built, + <emphasis>not</emphasis> the ABI active in the user code that is using + iostreams. + This means that for a given build of GCC the type thrown is fixed. + In current releases the library throws a special type that can be caught + by handlers for either the old or new type, + but for GCC 7.1, 7.2 and 7.3 the library throws the new + <classname>std::ios_base::failure</classname> type, + and for GCC 5.x and 6.x the library throws the old type. + Catch handlers of type <classname>std::ios_base::failure</classname> + will only catch the exceptions if using a newer release, + or if the handler is compiled with the same ABI as the type thrown by + the library. + Handlers for <classname>std::exception</classname> will always catch + iostreams exceptions, because the old and new type both inherit from + <classname>std::exception</classname>. +</para> + <section xml:id="manual.intro.using.abi.trouble" xreflabel="Dual ABI Troubleshooting"><info><title>Troubleshooting</title></info> <para> If you get linker errors about undefined references to symbols diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h index 7df39685ad3..674fe0963eb 100644 --- a/libstdc++-v3/include/bits/basic_string.h +++ b/libstdc++-v3/include/bits/basic_string.h @@ -5130,7 +5130,10 @@ _GLIBCXX_END_NAMESPACE_CXX11 */ _CharT* data() noexcept - { return _M_data(); } + { + _M_leak(); + return _M_data(); + } #endif /** diff --git a/libstdc++-v3/include/bits/char_traits.h b/libstdc++-v3/include/bits/char_traits.h index 3ecc30e46cb..791608ad3db 100644 --- a/libstdc++-v3/include/bits/char_traits.h +++ b/libstdc++-v3/include/bits/char_traits.h @@ -143,8 +143,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); } }; -#define __cpp_lib_constexpr_char_traits 201611 - template<typename _CharT> _GLIBCXX14_CONSTEXPR int char_traits<_CharT>:: @@ -217,6 +215,8 @@ namespace std _GLIBCXX_VISIBILITY(default) _GLIBCXX_BEGIN_NAMESPACE_VERSION #if __cplusplus > 201402 +#define __cpp_lib_constexpr_char_traits 201611 + /** * @brief Determine whether the characters of a NULL-terminated * string are known at compile time. diff --git a/libstdc++-v3/include/bits/node_handle.h b/libstdc++-v3/include/bits/node_handle.h index f75f7425f47..b4f732a36f0 100644 --- a/libstdc++-v3/include/bits/node_handle.h +++ b/libstdc++-v3/include/bits/node_handle.h @@ -105,7 +105,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { using std::swap; swap(_M_ptr, __nh._M_ptr); - if (_AllocTraits::propagate_on_container_swap + if (_AllocTraits::propagate_on_container_swap::value || !_M_alloc || !__nh._M_alloc) _M_alloc.swap(__nh._M_alloc); else diff --git a/libstdc++-v3/include/bits/random.tcc b/libstdc++-v3/include/bits/random.tcc index df05ebea6e9..c43d85551c3 100644 --- a/libstdc++-v3/include/bits/random.tcc +++ b/libstdc++-v3/include/bits/random.tcc @@ -2356,7 +2356,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __v = __v * __v * __v; __u = __aurng(); } - while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n + while (__u > result_type(1.0) - 0.0331 * __n * __n * __n * __n && (std::log(__u) > (0.5 * __n * __n + __a1 * (1.0 - __v + std::log(__v))))); @@ -2405,7 +2405,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __v = __v * __v * __v; __u = __aurng(); } - while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n + while (__u > result_type(1.0) - 0.0331 * __n * __n * __n * __n && (std::log(__u) > (0.5 * __n * __n + __a1 * (1.0 - __v + std::log(__v))))); @@ -2426,7 +2426,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __v = __v * __v * __v; __u = __aurng(); } - while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n + while (__u > result_type(1.0) - 0.0331 * __n * __n * __n * __n && (std::log(__u) > (0.5 * __n * __n + __a1 * (1.0 - __v + std::log(__v))))); diff --git a/libstdc++-v3/include/bits/valarray_array.h b/libstdc++-v3/include/bits/valarray_array.h index f169edd9728..bb32d7ac188 100644 --- a/libstdc++-v3/include/bits/valarray_array.h +++ b/libstdc++-v3/include/bits/valarray_array.h @@ -152,7 +152,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { inline static void _S_do_it(const _Tp* __b, const _Tp* __e, _Tp* __restrict__ __o) - { __builtin_memcpy(__o, __b, (__e - __b) * sizeof(_Tp)); } + { + if (__b) + __builtin_memcpy(__o, __b, (__e - __b) * sizeof(_Tp)); + } }; template<typename _Tp> @@ -258,7 +261,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { inline static void _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) - { __builtin_memcpy(__b, __a, __n * sizeof (_Tp)); } + { + if (__n != 0) + __builtin_memcpy(__b, __a, __n * sizeof (_Tp)); + } }; // Copy a plain array __a[<__n>] into a play array __b[<>] diff --git a/libstdc++-v3/include/std/utility b/libstdc++-v3/include/std/utility index 978acb747e9..847e5184c5b 100644 --- a/libstdc++-v3/include/std/utility +++ b/libstdc++-v3/include/std/utility @@ -75,10 +75,6 @@ #include <bits/move.h> #include <initializer_list> -#if __cplusplus > 201402L -#include <exception> -#endif - namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION diff --git a/libstdc++-v3/include/std/variant b/libstdc++-v3/include/std/variant index 0180eefd169..b31d774375d 100644 --- a/libstdc++-v3/include/std/variant +++ b/libstdc++-v3/include/std/variant @@ -1242,7 +1242,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using _Result_type = decltype(std::forward<_Visitor>(__visitor)( - get<0>(std::forward<_Variants>(__variants))...)); + std::get<0>(std::forward<_Variants>(__variants))...)); constexpr auto& __vtable = __detail::__variant::__gen_vtable< _Result_type, _Visitor&&, _Variants&&...>::_S_vtable; diff --git a/libstdc++-v3/include/tr1/ell_integral.tcc b/libstdc++-v3/include/tr1/ell_integral.tcc index 01f9313a256..99a6b9ce691 100644 --- a/libstdc++-v3/include/tr1/ell_integral.tcc +++ b/libstdc++-v3/include/tr1/ell_integral.tcc @@ -685,8 +685,8 @@ namespace tr1 const _Tp __kk = __k * __k; return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) - - __nu - * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) + __nu) + + __nu + * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu) / _Tp(3); } } @@ -735,9 +735,9 @@ namespace tr1 const _Tp __Pi = __s * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) - - __nu * __sss + + __nu * __sss * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1), - _Tp(1) + __nu * __ss) / _Tp(3); + _Tp(1) - __nu * __ss) / _Tp(3); if (__n == 0) return __Pi; diff --git a/libstdc++-v3/include/tr1/exp_integral.tcc b/libstdc++-v3/include/tr1/exp_integral.tcc index f33f234e6f6..8e6f55178e7 100644 --- a/libstdc++-v3/include/tr1/exp_integral.tcc +++ b/libstdc++-v3/include/tr1/exp_integral.tcc @@ -86,7 +86,7 @@ namespace tr1 _Tp __term = _Tp(1); _Tp __esum = _Tp(0); _Tp __osum = _Tp(0); - const unsigned int __max_iter = 100; + const unsigned int __max_iter = 1000; for (unsigned int __i = 1; __i < __max_iter; ++__i) { __term *= - __x / __i; @@ -156,7 +156,7 @@ namespace tr1 _Tp __expint_En_series(unsigned int __n, _Tp __x) { - const unsigned int __max_iter = 100; + const unsigned int __max_iter = 1000; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const int __nm1 = __n - 1; _Tp __ans = (__nm1 != 0 @@ -202,7 +202,7 @@ namespace tr1 _Tp __expint_En_cont_frac(unsigned int __n, _Tp __x) { - const unsigned int __max_iter = 100; + const unsigned int __max_iter = 1000; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __fp_min = std::numeric_limits<_Tp>::min(); const int __nm1 = __n - 1; diff --git a/libstdc++-v3/libsupc++/cxxabi_init_exception.h b/libstdc++-v3/libsupc++/cxxabi_init_exception.h index bf7b4bada81..2cf2c257ea8 100644 --- a/libstdc++-v3/libsupc++/cxxabi_init_exception.h +++ b/libstdc++-v3/libsupc++/cxxabi_init_exception.h @@ -62,6 +62,9 @@ namespace __cxxabiv1 void* __cxa_allocate_exception(size_t) _GLIBCXX_NOTHROW; + void + __cxa_free_exception(void*) _GLIBCXX_NOTHROW; + // Initialize exception (this is a GNU extension) __cxa_refcounted_exception* __cxa_init_primary_exception(void *object, std::type_info *tinfo, diff --git a/libstdc++-v3/libsupc++/exception_ptr.h b/libstdc++-v3/libsupc++/exception_ptr.h index 0ece81d8137..faae9b77cb3 100644 --- a/libstdc++-v3/libsupc++/exception_ptr.h +++ b/libstdc++-v3/libsupc++/exception_ptr.h @@ -178,25 +178,31 @@ namespace std exception_ptr make_exception_ptr(_Ex __ex) _GLIBCXX_USE_NOEXCEPT { -#if __cpp_exceptions +#if __cpp_exceptions && __cpp_rtti && !_GLIBCXX_HAVE_CDTOR_CALLABI + void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex)); + (void) __cxxabiv1::__cxa_init_primary_exception( + __e, const_cast<std::type_info*>(&typeid(__ex)), + __exception_ptr::__dest_thunk<_Ex>); try { -#if __cpp_rtti && !_GLIBCXX_HAVE_CDTOR_CALLABI - void *__e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex)); - (void)__cxxabiv1::__cxa_init_primary_exception( - __e, const_cast<std::type_info*>(&typeid(__ex)), - __exception_ptr::__dest_thunk<_Ex>); ::new (__e) _Ex(__ex); return exception_ptr(__e); -#else + } + catch(...) + { + __cxxabiv1::__cxa_free_exception(__e); + return current_exception(); + } +#elif __cpp_exceptions + try + { throw __ex; -#endif } catch(...) { return current_exception(); } -#else +#else // no RTTI and no exceptions return exception_ptr(); #endif } diff --git a/libstdc++-v3/src/filesystem/ops.cc b/libstdc++-v3/src/filesystem/ops.cc index 8de3511346e..12a87c57276 100644 --- a/libstdc++-v3/src/filesystem/ops.cc +++ b/libstdc++-v3/src/filesystem/ops.cc @@ -1391,10 +1391,11 @@ fs::space(const path& p, error_code& ec) noexcept ec.assign(errno, std::generic_category()); else { + uintmax_t fragment_size = f.f_frsize; info = space_info{ - f.f_blocks * f.f_frsize, - f.f_bfree * f.f_frsize, - f.f_bavail * f.f_frsize + f.f_blocks * fragment_size, + f.f_bfree * fragment_size, + f.f_bavail * fragment_size }; ec.clear(); } diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/operations/data/char/86169.cc b/libstdc++-v3/testsuite/21_strings/basic_string/operations/data/char/86169.cc new file mode 100644 index 00000000000..a8b0ff4aa3f --- /dev/null +++ b/libstdc++-v3/testsuite/21_strings/basic_string/operations/data/char/86169.cc @@ -0,0 +1,37 @@ +// Copyright (C) 2018 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// { dg-options "-std=gnu++17" } +// { dg-do run { target c++1z } } + +// PR libstdc++/86169 + +#ifndef _GLIBCXX_USE_CXX11_ABI +# define _GLIBCXX_USE_CXX11_ABI 0 +#endif + +#include <string> +#include <testsuite_hooks.h> + +int main() +{ + const std::string s0{"hello world"}; + std::string s1 {s0}; + char* p = s1.data(); + *p = ' '; + VERIFY(s0.compare("hello world") == 0); +} diff --git a/libstdc++-v3/testsuite/23_containers/set/modifiers/node_swap.cc b/libstdc++-v3/testsuite/23_containers/set/modifiers/node_swap.cc new file mode 100644 index 00000000000..32c7d496428 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/set/modifiers/node_swap.cc @@ -0,0 +1,48 @@ +// Copyright (C) 2018 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// { dg-options "-std=gnu++17" } +// { dg-do run { target c++1z } } + +#include <set> +#include <testsuite_hooks.h> + +void +test01() +{ + // PR libstdc++/82966 + std::set<int>::node_type n1, n2; + n1.swap(n2); + VERIFY( n1.empty() ); + VERIFY( n2.empty() ); +} + +void +test02() +{ + std::set<int> s{1, 2}; + std::set<int>::node_type n1 = s.extract(1), n2; + swap(n1, n2); + VERIFY( n1.empty() ); + VERIFY( !n2.empty() ); +} + +int main() +{ + test01(); + test02(); +} diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/space.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/space.cc new file mode 100644 index 00000000000..aa6a6aeaa60 --- /dev/null +++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/space.cc @@ -0,0 +1,57 @@ +// Copyright (C) 2017-2018 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// { dg-options "-DUSE_FILESYSTEM_TS -lstdc++fs" } +// { dg-do run { target c++11 } } +// { dg-require-filesystem-ts "" } + +// 30.10.14.3 Permissions [fs.op.space] + +#include <experimental/filesystem> +#include <testsuite_fs.h> +#include <testsuite_hooks.h> + +namespace fs = std::experimental::filesystem; + +void +test01() +{ + fs::space_info s = fs::space("/"); + std::error_code ec = make_error_code(std::errc::invalid_argument); + s = fs::space("/", ec); + VERIFY( !ec ); + + s = fs::space(__gnu_test::nonexistent_path(), ec); + VERIFY( ec ); + VERIFY( s.capacity == static_cast<uintmax_t>(-1) ); + VERIFY( s.free == static_cast<uintmax_t>(-1) ); + VERIFY( s.available == static_cast<uintmax_t>(-1) ); +} + +void +test02() +{ + fs::space_info s = fs::space("."); + VERIFY( s.capacity >= s.free ); +} + +int +main() +{ + test01(); + test02(); +} diff --git a/libstdc++-v3/testsuite/special_functions/06_comp_ellint_3/check_value.cc b/libstdc++-v3/testsuite/special_functions/06_comp_ellint_3/check_value.cc index 1a3dbac3d2d..60f6addf008 100644 --- a/libstdc++-v3/testsuite/special_functions/06_comp_ellint_3/check_value.cc +++ b/libstdc++-v3/testsuite/special_functions/06_comp_ellint_3/check_value.cc @@ -1,7 +1,7 @@ // { dg-do run { target c++11 } } // { dg-options "-D__STDCPP_WANT_MATH_SPEC_FUNCS__" } // -// Copyright (C) 2016-2017 Free Software Foundation, Inc. +// Copyright (C) 2016-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -37,387 +37,444 @@ #endif #include <specfun_testcase.h> - // Test data for k=-0.90000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 2.6751587294384150e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 5 +// max(|f - f_Boost| / |f_Boost|): 1.2838262090802751e-16 +// mean(f - f_Boost): 4.4408920985006264e-17 +// variance(f - f_Boost): 2.4347558803117648e-34 +// stddev(f - f_Boost): 1.5603704304785339e-17 const testcase_comp_ellint_3<double> data001[10] = { { 2.2805491384227703, -0.90000000000000002, 0.0000000000000000 }, - { 2.1537868513875287, -0.90000000000000002, 0.10000000000000001 }, - { 2.0443194576468890, -0.90000000000000002, 0.20000000000000001 }, - { 1.9486280260314426, -0.90000000000000002, 0.29999999999999999 }, - { 1.8641114227238349, -0.90000000000000002, 0.40000000000000002 }, - { 1.7888013241937861, -0.90000000000000002, 0.50000000000000000 }, - { 1.7211781128919523, -0.90000000000000002, 0.59999999999999998 }, - { 1.6600480747670940, -0.90000000000000002, 0.69999999999999996 }, - { 1.6044591960982202, -0.90000000000000002, 0.80000000000000004 }, - { 1.5536420236310946, -0.90000000000000002, 0.90000000000000002 }, + { 2.4295011187834885, -0.90000000000000002, 0.10000000000000001 }, + { 2.6076835743348412, -0.90000000000000002, 0.20000000000000001 }, + { 2.8256506968858512, -0.90000000000000002, 0.30000000000000004 }, + { 3.1000689868578619, -0.90000000000000002, 0.40000000000000002 }, + { 3.4591069002104677, -0.90000000000000002, 0.50000000000000000 }, + { 3.9549939883570229, -0.90000000000000002, 0.60000000000000009 }, + { 4.6985482312992435, -0.90000000000000002, 0.70000000000000007 }, + { 5.9820740813645710, -0.90000000000000002, 0.80000000000000004 }, + { 8.9942562031858699, -0.90000000000000002, 0.90000000000000002 }, }; const double toler001 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 1.5960830388244336e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.1949393471095187e-16 +// mean(f - f_Boost): 9.5479180117763459e-16 +// variance(f - f_Boost): 5.4782007307014711e-34 +// stddev(f - f_Boost): 2.3405556457178006e-17 const testcase_comp_ellint_3<double> data002[10] = { - { 1.9953027776647296, -0.80000000000000004, 0.0000000000000000 }, - { 1.8910755418379521, -0.80000000000000004, 0.10000000000000001 }, - { 1.8007226661734588, -0.80000000000000004, 0.20000000000000001 }, - { 1.7214611048717301, -0.80000000000000004, 0.29999999999999999 }, - { 1.6512267838651289, -0.80000000000000004, 0.40000000000000002 }, - { 1.5884528947755532, -0.80000000000000004, 0.50000000000000000 }, - { 1.5319262547427865, -0.80000000000000004, 0.59999999999999998 }, - { 1.4806912324625332, -0.80000000000000004, 0.69999999999999996 }, - { 1.4339837018309471, -0.80000000000000004, 0.80000000000000004 }, - { 1.3911845406776222, -0.80000000000000004, 0.90000000000000002 }, + { 1.9953027776647294, -0.80000000000000004, 0.0000000000000000 }, + { 2.1172616484005085, -0.80000000000000004, 0.10000000000000001 }, + { 2.2624789434186798, -0.80000000000000004, 0.20000000000000001 }, + { 2.4392042002725698, -0.80000000000000004, 0.30000000000000004 }, + { 2.6604037035529728, -0.80000000000000004, 0.40000000000000002 }, + { 2.9478781158239751, -0.80000000000000004, 0.50000000000000000 }, + { 3.3418121892288055, -0.80000000000000004, 0.60000000000000009 }, + { 3.9268876980046397, -0.80000000000000004, 0.70000000000000007 }, + { 4.9246422058196071, -0.80000000000000004, 0.80000000000000004 }, + { 7.2263259298637132, -0.80000000000000004, 0.90000000000000002 }, }; const double toler002 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3074070916136724e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 3 +// max(|f - f_Boost| / |f_Boost|): 1.9832236886714888e-16 +// mean(f - f_Boost): -1.5543122344752191e-16 +// variance(f - f_Boost): 2.9825759533819119e-33 +// stddev(f - f_Boost): 5.4612965066748680e-17 const testcase_comp_ellint_3<double> data003[10] = { - { 1.8456939983747236, -0.69999999999999996, 0.0000000000000000 }, - { 1.7528050171757608, -0.69999999999999996, 0.10000000000000001 }, - { 1.6721098780092145, -0.69999999999999996, 0.20000000000000001 }, - { 1.6011813647733213, -0.69999999999999996, 0.29999999999999999 }, - { 1.5382162002954762, -0.69999999999999996, 0.40000000000000002 }, - { 1.4818433192178544, -0.69999999999999996, 0.50000000000000000 }, - { 1.4309994736080540, -0.69999999999999996, 0.59999999999999998 }, - { 1.3848459188329196, -0.69999999999999996, 0.69999999999999996 }, - { 1.3427110650397531, -0.69999999999999996, 0.80000000000000004 }, - { 1.3040500499695913, -0.69999999999999996, 0.90000000000000002 }, + { 1.8456939983747234, -0.69999999999999996, 0.0000000000000000 }, + { 1.9541347343119564, -0.69999999999999996, 0.10000000000000001 }, + { 2.0829290325820202, -0.69999999999999996, 0.20000000000000001 }, + { 2.2392290510988535, -0.69999999999999996, 0.30000000000000004 }, + { 2.4342502915307880, -0.69999999999999996, 0.40000000000000002 }, + { 2.6868019968236996, -0.69999999999999996, 0.50000000000000000 }, + { 3.0314573496746742, -0.69999999999999996, 0.60000000000000009 }, + { 3.5408408771788564, -0.69999999999999996, 0.70000000000000007 }, + { 4.4042405729076961, -0.69999999999999996, 0.80000000000000004 }, + { 6.3796094177887754, -0.69999999999999996, 0.90000000000000002 }, }; const double toler003 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1891472451898755e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 2 +// max(|f - f_Boost| / |f_Boost|): 2.2547200163366559e-16 +// mean(f - f_Boost): -1.9984014443252818e-16 +// variance(f - f_Boost): 4.9303806576313241e-33 +// stddev(f - f_Boost): 7.0216669371534022e-17 const testcase_comp_ellint_3<double> data004[10] = { { 1.7507538029157526, -0.59999999999999998, 0.0000000000000000 }, - { 1.6648615773343014, -0.59999999999999998, 0.10000000000000001 }, - { 1.5901418016279374, -0.59999999999999998, 0.20000000000000001 }, - { 1.5243814243493585, -0.59999999999999998, 0.29999999999999999 }, - { 1.4659345278069984, -0.59999999999999998, 0.40000000000000002 }, - { 1.4135484285693078, -0.59999999999999998, 0.50000000000000000 }, - { 1.3662507535812816, -0.59999999999999998, 0.59999999999999998 }, - { 1.3232737468822813, -0.59999999999999998, 0.69999999999999996 }, - { 1.2840021261752192, -0.59999999999999998, 0.80000000000000004 }, - { 1.2479362973851875, -0.59999999999999998, 0.90000000000000002 }, + { 1.8508766487100685, -0.59999999999999998, 0.10000000000000001 }, + { 1.9695980282802217, -0.59999999999999998, 0.20000000000000001 }, + { 2.1134154405060599, -0.59999999999999998, 0.30000000000000004 }, + { 2.2925036420985130, -0.59999999999999998, 0.40000000000000002 }, + { 2.5239007084492711, -0.59999999999999998, 0.50000000000000000 }, + { 2.8388723099514972, -0.59999999999999998, 0.60000000000000009 }, + { 3.3029735898397159, -0.59999999999999998, 0.70000000000000007 }, + { 4.0867036409261832, -0.59999999999999998, 0.80000000000000004 }, + { 5.8709993116265604, -0.59999999999999998, 0.90000000000000002 }, }; const double toler004 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 1.7857620325589816e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 3 +// max(|f - f_Boost| / |f_Boost|): 2.1900131385114407e-16 +// mean(f - f_Boost): 2.4424906541753446e-16 +// variance(f - f_Boost): 7.3651365379430888e-33 +// stddev(f - f_Boost): 8.5820373676319358e-17 const testcase_comp_ellint_3<double> data005[10] = { - { 1.6857503548125963, -0.50000000000000000, 0.0000000000000000 }, - { 1.6045524936084892, -0.50000000000000000, 0.10000000000000001 }, - { 1.5338490483665983, -0.50000000000000000, 0.20000000000000001 }, - { 1.4715681939859637, -0.50000000000000000, 0.29999999999999999 }, - { 1.4161679518465340, -0.50000000000000000, 0.40000000000000002 }, - { 1.3664739530045971, -0.50000000000000000, 0.50000000000000000 }, - { 1.3215740290190876, -0.50000000000000000, 0.59999999999999998 }, - { 1.2807475181182502, -0.50000000000000000, 0.69999999999999996 }, - { 1.2434165408189539, -0.50000000000000000, 0.80000000000000004 }, - { 1.2091116095504744, -0.50000000000000000, 0.90000000000000002 }, + { 1.6857503548125961, -0.50000000000000000, 0.0000000000000000 }, + { 1.7803034946545482, -0.50000000000000000, 0.10000000000000001 }, + { 1.8922947612264021, -0.50000000000000000, 0.20000000000000001 }, + { 2.0277924458111314, -0.50000000000000000, 0.30000000000000004 }, + { 2.1962905366178065, -0.50000000000000000, 0.40000000000000002 }, + { 2.4136715042011945, -0.50000000000000000, 0.50000000000000000 }, + { 2.7090491861753558, -0.50000000000000000, 0.60000000000000009 }, + { 3.1433945297859229, -0.50000000000000000, 0.70000000000000007 }, + { 3.8750701888108070, -0.50000000000000000, 0.80000000000000004 }, + { 5.5355132096026463, -0.50000000000000000, 0.90000000000000002 }, }; const double toler005 = 2.5000000000000020e-13; -// Test data for k=-0.40000000000000002. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.1925080711125793e-16 +// Test data for k=-0.39999999999999991. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.1718164615986397e-16 +// mean(f - f_Boost): 6.2172489379008762e-16 +// variance(f - f_Boost): 1.6458949750907531e-31 +// stddev(f - f_Boost): 4.0569631192441877e-16 const testcase_comp_ellint_3<double> data006[10] = { - { 1.6399998658645112, -0.40000000000000002, 0.0000000000000000 }, - { 1.5620566886683604, -0.40000000000000002, 0.10000000000000001 }, - { 1.4941414344266770, -0.40000000000000002, 0.20000000000000001 }, - { 1.4342789859950078, -0.40000000000000002, 0.29999999999999999 }, - { 1.3809986210732901, -0.40000000000000002, 0.40000000000000002 }, - { 1.3331797176377398, -0.40000000000000002, 0.50000000000000000 }, - { 1.2899514672527024, -0.40000000000000002, 0.59999999999999998 }, - { 1.2506255923253344, -0.40000000000000002, 0.69999999999999996 }, - { 1.2146499565727209, -0.40000000000000002, 0.80000000000000004 }, - { 1.1815758115929846, -0.40000000000000002, 0.90000000000000002 }, + { 1.6399998658645112, -0.39999999999999991, 0.0000000000000000 }, + { 1.7306968836847190, -0.39999999999999991, 0.10000000000000001 }, + { 1.8380358826317627, -0.39999999999999991, 0.20000000000000001 }, + { 1.9677924132520139, -0.39999999999999991, 0.30000000000000004 }, + { 2.1289968719280026, -0.39999999999999991, 0.40000000000000002 }, + { 2.3367461373176512, -0.39999999999999991, 0.50000000000000000 }, + { 2.6186940209850191, -0.39999999999999991, 0.60000000000000009 }, + { 3.0327078743873246, -0.39999999999999991, 0.70000000000000007 }, + { 3.7289548002199902, -0.39999999999999991, 0.80000000000000004 }, + { 5.3055535102872513, -0.39999999999999991, 0.90000000000000002 }, }; const double toler006 = 2.5000000000000020e-13; -// Test data for k=-0.30000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8209844149902043e-16 +// Test data for k=-0.29999999999999993. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.9274792319434433e-16 +// mean(f - f_Boost): 6.2172489379008762e-16 +// variance(f - f_Boost): 8.7651211691223537e-33 +// stddev(f - f_Boost): 9.3622225828712025e-17 const testcase_comp_ellint_3<double> data007[10] = { - { 1.6080486199305128, -0.30000000000000004, 0.0000000000000000 }, - { 1.5323534693557528, -0.30000000000000004, 0.10000000000000001 }, - { 1.4663658145259877, -0.30000000000000004, 0.20000000000000001 }, - { 1.4081767433479091, -0.30000000000000004, 0.29999999999999999 }, - { 1.3563643538969763, -0.30000000000000004, 0.40000000000000002 }, - { 1.3098448759814962, -0.30000000000000004, 0.50000000000000000 }, - { 1.2677758800420669, -0.30000000000000004, 0.59999999999999998 }, - { 1.2294913236274982, -0.30000000000000004, 0.69999999999999996 }, - { 1.1944567571590048, -0.30000000000000004, 0.80000000000000004 }, - { 1.1622376896064914, -0.30000000000000004, 0.90000000000000002 }, + { 1.6080486199305128, -0.29999999999999993, 0.0000000000000000 }, + { 1.6960848815118226, -0.29999999999999993, 0.10000000000000001 }, + { 1.8002173372290500, -0.29999999999999993, 0.20000000000000001 }, + { 1.9260216862473254, -0.29999999999999993, 0.30000000000000004 }, + { 2.0822121773175533, -0.29999999999999993, 0.40000000000000002 }, + { 2.2833505881933971, -0.29999999999999993, 0.50000000000000000 }, + { 2.5560975528589065, -0.29999999999999993, 0.60000000000000009 }, + { 2.9562123549913877, -0.29999999999999993, 0.70000000000000007 }, + { 3.6283050484567170, -0.29999999999999993, 0.80000000000000004 }, + { 5.1479514944016795, -0.29999999999999993, 0.90000000000000002 }, }; const double toler007 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8637687241174905e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.9753938705764407e-16 +// mean(f - f_Boost): 3.1086244689504381e-16 +// variance(f - f_Boost): 4.1147374377268827e-32 +// stddev(f - f_Boost): 2.0284815596220939e-16 const testcase_comp_ellint_3<double> data008[10] = { - { 1.5868678474541660, -0.19999999999999996, 0.0000000000000000 }, - { 1.5126513474261087, -0.19999999999999996, 0.10000000000000001 }, - { 1.4479323932249564, -0.19999999999999996, 0.20000000000000001 }, - { 1.3908453514752477, -0.19999999999999996, 0.29999999999999999 }, - { 1.3400002519661005, -0.19999999999999996, 0.40000000000000002 }, - { 1.2943374404397372, -0.19999999999999996, 0.50000000000000000 }, - { 1.2530330675914556, -0.19999999999999996, 0.59999999999999998 }, - { 1.2154356555075863, -0.19999999999999996, 0.69999999999999996 }, - { 1.1810223448909909, -0.19999999999999996, 0.80000000000000004 }, - { 1.1493679916141861, -0.19999999999999996, 0.90000000000000002 }, + { 1.5868678474541662, -0.19999999999999996, 0.0000000000000000 }, + { 1.6731552050562593, -0.19999999999999996, 0.10000000000000001 }, + { 1.7751816279738935, -0.19999999999999996, 0.20000000000000001 }, + { 1.8983924169967101, -0.19999999999999996, 0.30000000000000004 }, + { 2.0512956926676806, -0.19999999999999996, 0.40000000000000002 }, + { 2.2481046259421302, -0.19999999999999996, 0.50000000000000000 }, + { 2.5148333891629315, -0.19999999999999996, 0.60000000000000009 }, + { 2.9058704854500967, -0.19999999999999996, 0.70000000000000007 }, + { 3.5622166386422633, -0.19999999999999996, 0.80000000000000004 }, + { 5.0448269356200370, -0.19999999999999996, 0.90000000000000002 }, }; const double toler008 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8887517676790089e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 5 +// max(|f - f_Boost| / |f_Boost|): 1.9932308021417639e-16 +// mean(f - f_Boost): 0.0000000000000000 +// variance(f - f_Boost): 6.8368087769470551e-64 +// stddev(f - f_Boost): 2.6147291976315738e-32 const testcase_comp_ellint_3<double> data009[10] = { - { 1.5747455615173562, -0.099999999999999978, 0.0000000000000000 }, - { 1.5013711111199950, -0.099999999999999978, 0.10000000000000001 }, - { 1.4373749386463430, -0.099999999999999978, 0.20000000000000001 }, - { 1.3809159606704959, -0.099999999999999978, 0.29999999999999999 }, - { 1.3306223265207477, -0.099999999999999978, 0.40000000000000002 }, - { 1.2854480708580160, -0.099999999999999978, 0.50000000000000000 }, - { 1.2445798942989255, -0.099999999999999978, 0.59999999999999998 }, - { 1.2073745911083185, -0.099999999999999978, 0.69999999999999996 }, - { 1.1733158866987732, -0.099999999999999978, 0.80000000000000004 }, - { 1.1419839485283374, -0.099999999999999978, 0.90000000000000002 }, + { 1.5747455615173560, -0.099999999999999978, 0.0000000000000000 }, + { 1.6600374067558428, -0.099999999999999978, 0.10000000000000001 }, + { 1.7608656115083421, -0.099999999999999978, 0.20000000000000001 }, + { 1.8826015946315438, -0.099999999999999978, 0.30000000000000004 }, + { 2.0336367403076760, -0.099999999999999978, 0.40000000000000002 }, + { 2.2279868912966849, -0.099999999999999978, 0.50000000000000000 }, + { 2.4913004919173827, -0.099999999999999978, 0.60000000000000009 }, + { 2.8771910188009744, -0.099999999999999978, 0.70000000000000007 }, + { 3.5246199613295617, -0.099999999999999978, 0.80000000000000004 }, + { 4.9862890417305508, -0.099999999999999978, 0.90000000000000002 }, }; const double toler009 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 1.6725702444488137e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 2.1899085000907084e-16 +// mean(f - f_Boost): -2.2204460492503131e-16 +// variance(f - f_Boost): 5.4782007307014711e-32 +// stddev(f - f_Boost): 2.3405556457178008e-16 const testcase_comp_ellint_3<double> data010[10] = { { 1.5707963267948966, 0.0000000000000000, 0.0000000000000000 }, - { 1.4976955329233277, 0.0000000000000000, 0.10000000000000001 }, - { 1.4339343023863691, 0.0000000000000000, 0.20000000000000001 }, - { 1.3776795151134889, 0.0000000000000000, 0.29999999999999999 }, - { 1.3275651989026320, 0.0000000000000000, 0.40000000000000002 }, - { 1.2825498301618641, 0.0000000000000000, 0.50000000000000000 }, - { 1.2418235332245127, 0.0000000000000000, 0.59999999999999998 }, - { 1.2047457872617382, 0.0000000000000000, 0.69999999999999996 }, - { 1.1708024551734544, 0.0000000000000000, 0.80000000000000004 }, - { 1.1395754288497419, 0.0000000000000000, 0.90000000000000002 }, + { 1.6557647109660170, 0.0000000000000000, 0.10000000000000001 }, + { 1.7562036827601817, 0.0000000000000000, 0.20000000000000001 }, + { 1.8774607092226381, 0.0000000000000000, 0.30000000000000004 }, + { 2.0278893379868062, 0.0000000000000000, 0.40000000000000002 }, + { 2.2214414690791831, 0.0000000000000000, 0.50000000000000000 }, + { 2.4836470664490258, 0.0000000000000000, 0.60000000000000009 }, + { 2.8678686047727386, 0.0000000000000000, 0.70000000000000007 }, + { 3.5124073655203634, 0.0000000000000000, 0.80000000000000004 }, + { 4.9672941328980516, 0.0000000000000000, 0.90000000000000002 }, }; const double toler010 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8887517676790089e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 5 +// max(|f - f_Boost| / |f_Boost|): 1.9932308021417639e-16 +// mean(f - f_Boost): -2.2204460492503132e-17 +// variance(f - f_Boost): 6.0868897007794120e-35 +// stddev(f - f_Boost): 7.8018521523926693e-18 const testcase_comp_ellint_3<double> data011[10] = { - { 1.5747455615173562, 0.10000000000000009, 0.0000000000000000 }, - { 1.5013711111199950, 0.10000000000000009, 0.10000000000000001 }, - { 1.4373749386463430, 0.10000000000000009, 0.20000000000000001 }, - { 1.3809159606704959, 0.10000000000000009, 0.29999999999999999 }, - { 1.3306223265207477, 0.10000000000000009, 0.40000000000000002 }, - { 1.2854480708580160, 0.10000000000000009, 0.50000000000000000 }, - { 1.2445798942989255, 0.10000000000000009, 0.59999999999999998 }, - { 1.2073745911083185, 0.10000000000000009, 0.69999999999999996 }, - { 1.1733158866987732, 0.10000000000000009, 0.80000000000000004 }, - { 1.1419839485283374, 0.10000000000000009, 0.90000000000000002 }, + { 1.5747455615173560, 0.10000000000000009, 0.0000000000000000 }, + { 1.6600374067558428, 0.10000000000000009, 0.10000000000000001 }, + { 1.7608656115083421, 0.10000000000000009, 0.20000000000000001 }, + { 1.8826015946315440, 0.10000000000000009, 0.30000000000000004 }, + { 2.0336367403076760, 0.10000000000000009, 0.40000000000000002 }, + { 2.2279868912966849, 0.10000000000000009, 0.50000000000000000 }, + { 2.4913004919173827, 0.10000000000000009, 0.60000000000000009 }, + { 2.8771910188009744, 0.10000000000000009, 0.70000000000000007 }, + { 3.5246199613295617, 0.10000000000000009, 0.80000000000000004 }, + { 4.9862890417305508, 0.10000000000000009, 0.90000000000000002 }, }; const double toler011 = 2.5000000000000020e-13; -// Test data for k=0.19999999999999996. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8637687241174905e-16 +// Test data for k=0.20000000000000018. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.9753938705764407e-16 +// mean(f - f_Boost): 3.1086244689504381e-16 +// variance(f - f_Boost): 4.1147374377268827e-32 +// stddev(f - f_Boost): 2.0284815596220939e-16 const testcase_comp_ellint_3<double> data012[10] = { - { 1.5868678474541660, 0.19999999999999996, 0.0000000000000000 }, - { 1.5126513474261087, 0.19999999999999996, 0.10000000000000001 }, - { 1.4479323932249564, 0.19999999999999996, 0.20000000000000001 }, - { 1.3908453514752477, 0.19999999999999996, 0.29999999999999999 }, - { 1.3400002519661005, 0.19999999999999996, 0.40000000000000002 }, - { 1.2943374404397372, 0.19999999999999996, 0.50000000000000000 }, - { 1.2530330675914556, 0.19999999999999996, 0.59999999999999998 }, - { 1.2154356555075863, 0.19999999999999996, 0.69999999999999996 }, - { 1.1810223448909909, 0.19999999999999996, 0.80000000000000004 }, - { 1.1493679916141861, 0.19999999999999996, 0.90000000000000002 }, + { 1.5868678474541662, 0.20000000000000018, 0.0000000000000000 }, + { 1.6731552050562593, 0.20000000000000018, 0.10000000000000001 }, + { 1.7751816279738935, 0.20000000000000018, 0.20000000000000001 }, + { 1.8983924169967101, 0.20000000000000018, 0.30000000000000004 }, + { 2.0512956926676806, 0.20000000000000018, 0.40000000000000002 }, + { 2.2481046259421302, 0.20000000000000018, 0.50000000000000000 }, + { 2.5148333891629315, 0.20000000000000018, 0.60000000000000009 }, + { 2.9058704854500967, 0.20000000000000018, 0.70000000000000007 }, + { 3.5622166386422633, 0.20000000000000018, 0.80000000000000004 }, + { 5.0448269356200370, 0.20000000000000018, 0.90000000000000002 }, }; const double toler012 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8209844149902043e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.4585997630846713e-16 +// mean(f - f_Boost): 5.1070259132757197e-16 +// variance(f - f_Boost): 1.7591111235252501e-32 +// stddev(f - f_Boost): 1.3263148659067538e-16 const testcase_comp_ellint_3<double> data013[10] = { { 1.6080486199305128, 0.30000000000000004, 0.0000000000000000 }, - { 1.5323534693557528, 0.30000000000000004, 0.10000000000000001 }, - { 1.4663658145259877, 0.30000000000000004, 0.20000000000000001 }, - { 1.4081767433479091, 0.30000000000000004, 0.29999999999999999 }, - { 1.3563643538969763, 0.30000000000000004, 0.40000000000000002 }, - { 1.3098448759814962, 0.30000000000000004, 0.50000000000000000 }, - { 1.2677758800420669, 0.30000000000000004, 0.59999999999999998 }, - { 1.2294913236274982, 0.30000000000000004, 0.69999999999999996 }, - { 1.1944567571590048, 0.30000000000000004, 0.80000000000000004 }, - { 1.1622376896064914, 0.30000000000000004, 0.90000000000000002 }, + { 1.6960848815118228, 0.30000000000000004, 0.10000000000000001 }, + { 1.8002173372290500, 0.30000000000000004, 0.20000000000000001 }, + { 1.9260216862473254, 0.30000000000000004, 0.30000000000000004 }, + { 2.0822121773175533, 0.30000000000000004, 0.40000000000000002 }, + { 2.2833505881933975, 0.30000000000000004, 0.50000000000000000 }, + { 2.5560975528589065, 0.30000000000000004, 0.60000000000000009 }, + { 2.9562123549913877, 0.30000000000000004, 0.70000000000000007 }, + { 3.6283050484567174, 0.30000000000000004, 0.80000000000000004 }, + { 5.1479514944016795, 0.30000000000000004, 0.90000000000000002 }, }; const double toler013 = 2.5000000000000020e-13; -// Test data for k=0.39999999999999991. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.1925080711125793e-16 +// Test data for k=0.40000000000000013. +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.7696531428672557e-16 +// mean(f - f_Boost): 1.1990408665951691e-15 +// variance(f - f_Boost): 2.6514491536595121e-31 +// stddev(f - f_Boost): 5.1492224205791612e-16 const testcase_comp_ellint_3<double> data014[10] = { - { 1.6399998658645112, 0.39999999999999991, 0.0000000000000000 }, - { 1.5620566886683604, 0.39999999999999991, 0.10000000000000001 }, - { 1.4941414344266770, 0.39999999999999991, 0.20000000000000001 }, - { 1.4342789859950078, 0.39999999999999991, 0.29999999999999999 }, - { 1.3809986210732901, 0.39999999999999991, 0.40000000000000002 }, - { 1.3331797176377398, 0.39999999999999991, 0.50000000000000000 }, - { 1.2899514672527024, 0.39999999999999991, 0.59999999999999998 }, - { 1.2506255923253344, 0.39999999999999991, 0.69999999999999996 }, - { 1.2146499565727209, 0.39999999999999991, 0.80000000000000004 }, - { 1.1815758115929846, 0.39999999999999991, 0.90000000000000002 }, + { 1.6399998658645112, 0.40000000000000013, 0.0000000000000000 }, + { 1.7306968836847190, 0.40000000000000013, 0.10000000000000001 }, + { 1.8380358826317629, 0.40000000000000013, 0.20000000000000001 }, + { 1.9677924132520141, 0.40000000000000013, 0.30000000000000004 }, + { 2.1289968719280030, 0.40000000000000013, 0.40000000000000002 }, + { 2.3367461373176512, 0.40000000000000013, 0.50000000000000000 }, + { 2.6186940209850196, 0.40000000000000013, 0.60000000000000009 }, + { 3.0327078743873246, 0.40000000000000013, 0.70000000000000007 }, + { 3.7289548002199906, 0.40000000000000013, 0.80000000000000004 }, + { 5.3055535102872522, 0.40000000000000013, 0.90000000000000002 }, }; const double toler014 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 1.7857620325589816e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 3 +// max(|f - f_Boost| / |f_Boost|): 2.1900131385114407e-16 +// mean(f - f_Boost): 2.4424906541753446e-16 +// variance(f - f_Boost): 7.3651365379430888e-33 +// stddev(f - f_Boost): 8.5820373676319358e-17 const testcase_comp_ellint_3<double> data015[10] = { - { 1.6857503548125963, 0.50000000000000000, 0.0000000000000000 }, - { 1.6045524936084892, 0.50000000000000000, 0.10000000000000001 }, - { 1.5338490483665983, 0.50000000000000000, 0.20000000000000001 }, - { 1.4715681939859637, 0.50000000000000000, 0.29999999999999999 }, - { 1.4161679518465340, 0.50000000000000000, 0.40000000000000002 }, - { 1.3664739530045971, 0.50000000000000000, 0.50000000000000000 }, - { 1.3215740290190876, 0.50000000000000000, 0.59999999999999998 }, - { 1.2807475181182502, 0.50000000000000000, 0.69999999999999996 }, - { 1.2434165408189539, 0.50000000000000000, 0.80000000000000004 }, - { 1.2091116095504744, 0.50000000000000000, 0.90000000000000002 }, + { 1.6857503548125961, 0.50000000000000000, 0.0000000000000000 }, + { 1.7803034946545482, 0.50000000000000000, 0.10000000000000001 }, + { 1.8922947612264021, 0.50000000000000000, 0.20000000000000001 }, + { 2.0277924458111314, 0.50000000000000000, 0.30000000000000004 }, + { 2.1962905366178065, 0.50000000000000000, 0.40000000000000002 }, + { 2.4136715042011945, 0.50000000000000000, 0.50000000000000000 }, + { 2.7090491861753558, 0.50000000000000000, 0.60000000000000009 }, + { 3.1433945297859229, 0.50000000000000000, 0.70000000000000007 }, + { 3.8750701888108070, 0.50000000000000000, 0.80000000000000004 }, + { 5.5355132096026463, 0.50000000000000000, 0.90000000000000002 }, }; const double toler015 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 4.7124937590522226e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 2 +// max(|f - f_Boost| / |f_Boost|): 2.2547200163366559e-16 +// mean(f - f_Boost): -2.2204460492503131e-16 +// variance(f - f_Boost): 6.0868897007794117e-33 +// stddev(f - f_Boost): 7.8018521523926690e-17 const testcase_comp_ellint_3<double> data016[10] = { { 1.7507538029157526, 0.60000000000000009, 0.0000000000000000 }, - { 1.6648615773343014, 0.60000000000000009, 0.10000000000000001 }, - { 1.5901418016279374, 0.60000000000000009, 0.20000000000000001 }, - { 1.5243814243493585, 0.60000000000000009, 0.29999999999999999 }, - { 1.4659345278069984, 0.60000000000000009, 0.40000000000000002 }, - { 1.4135484285693078, 0.60000000000000009, 0.50000000000000000 }, - { 1.3662507535812816, 0.60000000000000009, 0.59999999999999998 }, - { 1.3232737468822813, 0.60000000000000009, 0.69999999999999996 }, - { 1.2840021261752192, 0.60000000000000009, 0.80000000000000004 }, - { 1.2479362973851873, 0.60000000000000009, 0.90000000000000002 }, + { 1.8508766487100687, 0.60000000000000009, 0.10000000000000001 }, + { 1.9695980282802217, 0.60000000000000009, 0.20000000000000001 }, + { 2.1134154405060599, 0.60000000000000009, 0.30000000000000004 }, + { 2.2925036420985130, 0.60000000000000009, 0.40000000000000002 }, + { 2.5239007084492711, 0.60000000000000009, 0.50000000000000000 }, + { 2.8388723099514976, 0.60000000000000009, 0.60000000000000009 }, + { 3.3029735898397159, 0.60000000000000009, 0.70000000000000007 }, + { 4.0867036409261832, 0.60000000000000009, 0.80000000000000004 }, + { 5.8709993116265613, 0.60000000000000009, 0.90000000000000002 }, }; const double toler016 = 2.5000000000000020e-13; -// Test data for k=0.69999999999999996. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3074070916136724e-16 +// Test data for k=0.70000000000000018. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 2.9298727220933567e-16 +// mean(f - f_Boost): 4.8849813083506892e-16 +// variance(f - f_Boost): 2.0476296953421943e-31 +// stddev(f - f_Boost): 4.5250742483877478e-16 const testcase_comp_ellint_3<double> data017[10] = { - { 1.8456939983747236, 0.69999999999999996, 0.0000000000000000 }, - { 1.7528050171757608, 0.69999999999999996, 0.10000000000000001 }, - { 1.6721098780092145, 0.69999999999999996, 0.20000000000000001 }, - { 1.6011813647733213, 0.69999999999999996, 0.29999999999999999 }, - { 1.5382162002954762, 0.69999999999999996, 0.40000000000000002 }, - { 1.4818433192178544, 0.69999999999999996, 0.50000000000000000 }, - { 1.4309994736080540, 0.69999999999999996, 0.59999999999999998 }, - { 1.3848459188329196, 0.69999999999999996, 0.69999999999999996 }, - { 1.3427110650397531, 0.69999999999999996, 0.80000000000000004 }, - { 1.3040500499695913, 0.69999999999999996, 0.90000000000000002 }, + { 1.8456939983747238, 0.70000000000000018, 0.0000000000000000 }, + { 1.9541347343119566, 0.70000000000000018, 0.10000000000000001 }, + { 2.0829290325820207, 0.70000000000000018, 0.20000000000000001 }, + { 2.2392290510988540, 0.70000000000000018, 0.30000000000000004 }, + { 2.4342502915307880, 0.70000000000000018, 0.40000000000000002 }, + { 2.6868019968237000, 0.70000000000000018, 0.50000000000000000 }, + { 3.0314573496746746, 0.70000000000000018, 0.60000000000000009 }, + { 3.5408408771788569, 0.70000000000000018, 0.70000000000000007 }, + { 4.4042405729076970, 0.70000000000000018, 0.80000000000000004 }, + { 6.3796094177887763, 0.70000000000000018, 0.90000000000000002 }, }; const double toler017 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 1.5960830388244336e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.1949393471095187e-16 +// mean(f - f_Boost): 9.5479180117763459e-16 +// variance(f - f_Boost): 5.4782007307014711e-34 +// stddev(f - f_Boost): 2.3405556457178006e-17 const testcase_comp_ellint_3<double> data018[10] = { - { 1.9953027776647296, 0.80000000000000004, 0.0000000000000000 }, - { 1.8910755418379521, 0.80000000000000004, 0.10000000000000001 }, - { 1.8007226661734588, 0.80000000000000004, 0.20000000000000001 }, - { 1.7214611048717301, 0.80000000000000004, 0.29999999999999999 }, - { 1.6512267838651289, 0.80000000000000004, 0.40000000000000002 }, - { 1.5884528947755532, 0.80000000000000004, 0.50000000000000000 }, - { 1.5319262547427865, 0.80000000000000004, 0.59999999999999998 }, - { 1.4806912324625332, 0.80000000000000004, 0.69999999999999996 }, - { 1.4339837018309471, 0.80000000000000004, 0.80000000000000004 }, - { 1.3911845406776222, 0.80000000000000004, 0.90000000000000002 }, + { 1.9953027776647294, 0.80000000000000004, 0.0000000000000000 }, + { 2.1172616484005085, 0.80000000000000004, 0.10000000000000001 }, + { 2.2624789434186798, 0.80000000000000004, 0.20000000000000001 }, + { 2.4392042002725698, 0.80000000000000004, 0.30000000000000004 }, + { 2.6604037035529728, 0.80000000000000004, 0.40000000000000002 }, + { 2.9478781158239751, 0.80000000000000004, 0.50000000000000000 }, + { 3.3418121892288055, 0.80000000000000004, 0.60000000000000009 }, + { 3.9268876980046397, 0.80000000000000004, 0.70000000000000007 }, + { 4.9246422058196071, 0.80000000000000004, 0.80000000000000004 }, + { 7.2263259298637132, 0.80000000000000004, 0.90000000000000002 }, }; const double toler018 = 2.5000000000000020e-13; -// Test data for k=0.89999999999999991. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 2.6751587294384150e-16 +// Test data for k=0.90000000000000013. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 3 +// max(|f - f_Boost| / |f_Boost|): 1.5716352001310461e-16 +// mean(f - f_Boost): 4.4408920985006264e-17 +// variance(f - f_Boost): 2.4347558803117648e-34 +// stddev(f - f_Boost): 1.5603704304785339e-17 const testcase_comp_ellint_3<double> data019[10] = { - { 2.2805491384227703, 0.89999999999999991, 0.0000000000000000 }, - { 2.1537868513875287, 0.89999999999999991, 0.10000000000000001 }, - { 2.0443194576468895, 0.89999999999999991, 0.20000000000000001 }, - { 1.9486280260314426, 0.89999999999999991, 0.29999999999999999 }, - { 1.8641114227238351, 0.89999999999999991, 0.40000000000000002 }, - { 1.7888013241937863, 0.89999999999999991, 0.50000000000000000 }, - { 1.7211781128919525, 0.89999999999999991, 0.59999999999999998 }, - { 1.6600480747670940, 0.89999999999999991, 0.69999999999999996 }, - { 1.6044591960982202, 0.89999999999999991, 0.80000000000000004 }, - { 1.5536420236310948, 0.89999999999999991, 0.90000000000000002 }, + { 2.2805491384227707, 0.90000000000000013, 0.0000000000000000 }, + { 2.4295011187834890, 0.90000000000000013, 0.10000000000000001 }, + { 2.6076835743348421, 0.90000000000000013, 0.20000000000000001 }, + { 2.8256506968858521, 0.90000000000000013, 0.30000000000000004 }, + { 3.1000689868578628, 0.90000000000000013, 0.40000000000000002 }, + { 3.4591069002104686, 0.90000000000000013, 0.50000000000000000 }, + { 3.9549939883570242, 0.90000000000000013, 0.60000000000000009 }, + { 4.6985482312992453, 0.90000000000000013, 0.70000000000000007 }, + { 5.9820740813645727, 0.90000000000000013, 0.80000000000000004 }, + { 8.9942562031858735, 0.90000000000000013, 0.90000000000000002 }, }; const double toler019 = 2.5000000000000020e-13; -template<typename Tp, unsigned int Num> +template<typename Ret, unsigned int Num> void - test(const testcase_comp_ellint_3<Tp> (&data)[Num], Tp toler) + test(const testcase_comp_ellint_3<Ret> (&data)[Num], Ret toler) { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); + bool test __attribute__((unused)) = true; + const Ret eps = std::numeric_limits<Ret>::epsilon(); + Ret max_abs_diff = -Ret(1); + Ret max_abs_frac = -Ret(1); unsigned int num_datum = Num; for (unsigned int i = 0; i < num_datum; ++i) { - const Tp f = std::comp_ellint_3(data[i].k, data[i].nu); - const Tp f0 = data[i].f0; - const Tp diff = f - f0; + const Ret f = std::comp_ellint_3(data[i].k, data[i].nu); + const Ret f0 = data[i].f0; + const Ret diff = f - f0; if (std::abs(diff) > max_abs_diff) max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) + if (std::abs(f0) > Ret(10) * eps + && std::abs(f) > Ret(10) * eps) { - const Tp frac = diff / f0; + const Ret frac = diff / f0; if (std::abs(frac) > max_abs_frac) max_abs_frac = std::abs(frac); } diff --git a/libstdc++-v3/testsuite/special_functions/06_comp_ellint_3/pr66689.cc b/libstdc++-v3/testsuite/special_functions/06_comp_ellint_3/pr66689.cc new file mode 100644 index 00000000000..c500f20dfd7 --- /dev/null +++ b/libstdc++-v3/testsuite/special_functions/06_comp_ellint_3/pr66689.cc @@ -0,0 +1,24 @@ +// { dg-do run { target c++11 } } +// { dg-require-c-std "" } +// { dg-options "-D__STDCPP_WANT_MATH_SPEC_FUNCS__" } +// { dg-add-options ieee } + +#include <cmath> +#include <testsuite_hooks.h> + +void +test01() +{ + double Pi1 = std::comp_ellint_3(0.75, 0.0); + VERIFY(std::abs(Pi1 - 1.91099) < 0.00001); + + double Pi2 = std::comp_ellint_3(0.75, 0.5); + VERIFY(std::abs(Pi2 - 2.80011) < 0.00001); +} + +int +main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/special_functions/13_ellint_3/check_value.cc b/libstdc++-v3/testsuite/special_functions/13_ellint_3/check_value.cc index 8a7202fdb2c..7a948e0f56c 100644 --- a/libstdc++-v3/testsuite/special_functions/13_ellint_3/check_value.cc +++ b/libstdc++-v3/testsuite/special_functions/13_ellint_3/check_value.cc @@ -1,7 +1,7 @@ // { dg-do run { target c++11 } } // { dg-options "-D__STDCPP_WANT_MATH_SPEC_FUNCS__" } // -// Copyright (C) 2016-2017 Free Software Foundation, Inc. +// Copyright (C) 2016-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -37,30 +37,32 @@ #endif #include <specfun_testcase.h> - // Test data for k=-0.90000000000000002, nu=0.0000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 2.9686139313362077e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 5.7842011620951154e-16 +// mean(f - f_Boost): 5.8286708792820721e-17 +// variance(f - f_Boost): 4.1942474344433133e-34 +// stddev(f - f_Boost): 2.0479861900030756e-17 const testcase_ellint_3<double> data001[10] = { { 0.0000000000000000, -0.90000000000000002, 0.0000000000000000, 0.0000000000000000 }, - { 0.17525427376115024, -0.90000000000000002, 0.0000000000000000, + { 0.17525427376115027, -0.90000000000000002, 0.0000000000000000, 0.17453292519943295 }, { 0.35492464591297446, -0.90000000000000002, 0.0000000000000000, 0.34906585039886590 }, - { 0.54388221416157112, -0.90000000000000002, 0.0000000000000000, + { 0.54388221416157123, -0.90000000000000002, 0.0000000000000000, 0.52359877559829882 }, - { 0.74797400423532490, -0.90000000000000002, 0.0000000000000000, + { 0.74797400423532512, -0.90000000000000002, 0.0000000000000000, 0.69813170079773179 }, - { 0.97463898451966458, -0.90000000000000002, 0.0000000000000000, + { 0.97463898451966446, -0.90000000000000002, 0.0000000000000000, 0.87266462599716477 }, - { 1.2334463254523440, -0.90000000000000002, 0.0000000000000000, + { 1.2334463254523438, -0.90000000000000002, 0.0000000000000000, 1.0471975511965976 }, { 1.5355247765594913, -0.90000000000000002, 0.0000000000000000, 1.2217304763960306 }, - { 1.8882928567775121, -0.90000000000000002, 0.0000000000000000, + { 1.8882928567775126, -0.90000000000000002, 0.0000000000000000, 1.3962634015954636 }, { 2.2805491384227703, -0.90000000000000002, 0.0000000000000000, 1.5707963267948966 }, @@ -68,269 +70,299 @@ data001[10] = const double toler001 = 2.5000000000000020e-13; // Test data for k=-0.90000000000000002, nu=0.10000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.0141810743801079e-16 +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.1500594295134815e-16 +// mean(f - f_Boost): 1.0269562977782698e-16 +// variance(f - f_Boost): 1.4388836606733082e-32 +// stddev(f - f_Boost): 1.1995347684303728e-16 const testcase_ellint_3<double> data002[10] = { { 0.0000000000000000, -0.90000000000000002, 0.10000000000000001, 0.0000000000000000 }, - { 0.17507714233254656, -0.90000000000000002, 0.10000000000000001, + { 0.17543204932716244, -0.90000000000000002, 0.10000000000000001, 0.17453292519943295 }, - { 0.35350932904326521, -0.90000000000000002, 0.10000000000000001, + { 0.35636022898551184, -0.90000000000000002, 0.10000000000000001, 0.34906585039886590 }, - { 0.53911129989870976, -0.90000000000000002, 0.10000000000000001, + { 0.54880278898382584, -0.90000000000000002, 0.10000000000000001, 0.52359877559829882 }, - { 0.73666644254508395, -0.90000000000000002, 0.10000000000000001, + { 0.75988834774529268, -0.90000000000000002, 0.10000000000000001, 0.69813170079773179 }, - { 0.95250736612100195, -0.90000000000000002, 0.10000000000000001, + { 0.99853303003568117, -0.90000000000000002, 0.10000000000000001, 0.87266462599716477 }, - { 1.1950199550905594, -0.90000000000000002, 0.10000000000000001, + { 1.2759958823999022, -0.90000000000000002, 0.10000000000000001, 1.0471975511965976 }, - { 1.4741687286340850, -0.90000000000000002, 0.10000000000000001, + { 1.6051187364639401, -0.90000000000000002, 0.10000000000000001, 1.2217304763960306 }, - { 1.7968678183506057, -0.90000000000000002, 0.10000000000000001, + { 1.9941406879519472, -0.90000000000000002, 0.10000000000000001, 1.3962634015954636 }, - { 2.1537868513875287, -0.90000000000000002, 0.10000000000000001, + { 2.4295011187834881, -0.90000000000000002, 0.10000000000000001, 1.5707963267948966 }, }; const double toler002 = 2.5000000000000020e-13; // Test data for k=-0.90000000000000002, nu=0.20000000000000001. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.0588292817405780e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 5.2711357908578066e-16 +// mean(f - f_Boost): 8.0491169285323847e-17 +// variance(f - f_Boost): 7.9985534974304465e-34 +// stddev(f - f_Boost): 2.8281714052423424e-17 const testcase_ellint_3<double> data003[10] = { { 0.0000000000000000, -0.90000000000000002, 0.20000000000000001, 0.0000000000000000 }, - { 0.17490065089140927, -0.90000000000000002, 0.20000000000000001, + { 0.17561047321968409, -0.90000000000000002, 0.20000000000000001, 0.17453292519943295 }, - { 0.35211377590661436, -0.90000000000000002, 0.20000000000000001, + { 0.35781659944356109, -0.90000000000000002, 0.20000000000000001, 0.34906585039886590 }, - { 0.53448220334204100, -0.90000000000000002, 0.20000000000000001, + { 0.55388150905215283, -0.90000000000000002, 0.20000000000000001, 0.52359877559829882 }, - { 0.72591368943179579, -0.90000000000000002, 0.20000000000000001, + { 0.77246874123251441, -0.90000000000000002, 0.20000000000000001, 0.69813170079773179 }, - { 0.93192539780038763, -0.90000000000000002, 0.20000000000000001, + { 1.0244466254771925, -0.90000000000000002, 0.20000000000000001, 0.87266462599716477 }, - { 1.1600809679692683, -0.90000000000000002, 0.20000000000000001, + { 1.3234824077640801, -0.90000000000000002, 0.20000000000000001, 1.0471975511965976 }, - { 1.4195407225882510, -0.90000000000000002, 0.20000000000000001, + { 1.6849848968804237, -0.90000000000000002, 0.20000000000000001, 1.2217304763960306 }, - { 1.7168966476424525, -0.90000000000000002, 0.20000000000000001, + { 2.1185749045502273, -0.90000000000000002, 0.20000000000000001, 1.3962634015954636 }, - { 2.0443194576468890, -0.90000000000000002, 0.20000000000000001, + { 2.6076835743348412, -0.90000000000000002, 0.20000000000000001, 1.5707963267948966 }, }; const double toler003 = 2.5000000000000020e-13; -// Test data for k=-0.90000000000000002, nu=0.29999999999999999. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.2403611223075570e-16 +// Test data for k=-0.90000000000000002, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.9955372494296814e-16 +// mean(f - f_Boost): 5.8286708792820721e-17 +// variance(f - f_Boost): 4.1942474344433133e-34 +// stddev(f - f_Boost): 2.0479861900030756e-17 const testcase_ellint_3<double> data004[10] = { - { 0.0000000000000000, -0.90000000000000002, 0.29999999999999999, + { 0.0000000000000000, -0.90000000000000002, 0.30000000000000004, 0.0000000000000000 }, - { 0.17472479532647531, -0.90000000000000002, 0.29999999999999999, + { 0.17578954966746221, -0.90000000000000002, 0.30000000000000004, 0.17453292519943295 }, - { 0.35073750187374114, -0.90000000000000002, 0.29999999999999999, + { 0.35929429810867447, -0.90000000000000002, 0.30000000000000004, 0.34906585039886590 }, - { 0.52998766129466957, -0.90000000000000002, 0.29999999999999999, + { 0.55912757154240811, -0.90000000000000002, 0.30000000000000004, 0.52359877559829882 }, - { 0.71566993548699553, -0.90000000000000002, 0.29999999999999999, + { 0.78578314722025389, -0.90000000000000002, 0.30000000000000004, 0.69813170079773179 }, - { 0.91271517762560195, -0.90000000000000002, 0.29999999999999999, + { 1.0526941001131365, -0.90000000000000002, 0.30000000000000004, 0.87266462599716477 }, - { 1.1281241199843370, -0.90000000000000002, 0.29999999999999999, + { 1.3769682234538601, -0.90000000000000002, 0.30000000000000004, 1.0471975511965976 }, - { 1.3704929576917451, -0.90000000000000002, 0.29999999999999999, + { 1.7779437432911238, -0.90000000000000002, 0.30000000000000004, 1.2217304763960306 }, - { 1.6461981511487713, -0.90000000000000002, 0.29999999999999999, + { 2.2676509341813631, -0.90000000000000002, 0.30000000000000004, 1.3962634015954636 }, - { 1.9486280260314426, -0.90000000000000002, 0.29999999999999999, + { 2.8256506968858512, -0.90000000000000002, 0.30000000000000004, 1.5707963267948966 }, }; const double toler004 = 2.5000000000000020e-13; // Test data for k=-0.90000000000000002, nu=0.40000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3487482375512111e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.7042235432234642e-16 +// mean(f - f_Boost): 2.0261570199409106e-16 +// variance(f - f_Boost): 5.8024227149195491e-32 +// stddev(f - f_Boost): 2.4088218520512364e-16 const testcase_ellint_3<double> data005[10] = { { 0.0000000000000000, -0.90000000000000002, 0.40000000000000002, 0.0000000000000000 }, - { 0.17454957156468837, -0.90000000000000002, 0.40000000000000002, + { 0.17596928293938452, -0.90000000000000002, 0.40000000000000002, 0.17453292519943295 }, - { 0.34938003933330430, -0.90000000000000002, 0.40000000000000002, + { 0.36079388642472821, -0.90000000000000002, 0.40000000000000002, 0.34906585039886590 }, - { 0.52562093533067433, -0.90000000000000002, 0.40000000000000002, + { 0.56455096667115612, -0.90000000000000002, 0.40000000000000002, 0.52359877559829882 }, - { 0.70589461324915670, -0.90000000000000002, 0.40000000000000002, + { 0.79990996997869435, -0.90000000000000002, 0.40000000000000002, 0.69813170079773179 }, - { 0.89472658511942849, -0.90000000000000002, 0.40000000000000002, + { 1.0836647913872215, -0.90000000000000002, 0.40000000000000002, 0.87266462599716477 }, - { 1.0987419542323440, -0.90000000000000002, 0.40000000000000002, + { 1.4378726836091849, -0.90000000000000002, 0.40000000000000002, 1.0471975511965976 }, - { 1.3261349565496303, -0.90000000000000002, 0.40000000000000002, + { 1.8880446720682853, -0.90000000000000002, 0.40000000000000002, 1.2217304763960306 }, - { 1.5831293909853765, -0.90000000000000002, 0.40000000000000002, + { 2.4505848932025227, -0.90000000000000002, 0.40000000000000002, 1.3962634015954636 }, - { 1.8641114227238349, -0.90000000000000002, 0.40000000000000002, + { 3.1000689868578615, -0.90000000000000002, 0.40000000000000002, 1.5707963267948966 }, }; const double toler005 = 2.5000000000000020e-13; // Test data for k=-0.90000000000000002, nu=0.50000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.4538944656036724e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 3.8944086593755267e-16 +// mean(f - f_Boost): 6.9388939039072284e-17 +// variance(f - f_Boost): 1.7333369499485123e-32 +// stddev(f - f_Boost): 1.3165625507162629e-16 const testcase_ellint_3<double> data006[10] = { { 0.0000000000000000, -0.90000000000000002, 0.50000000000000000, 0.0000000000000000 }, - { 0.17437497557073334, -0.90000000000000002, 0.50000000000000000, + { 0.17614967734498183, -0.90000000000000002, 0.50000000000000000, 0.17453292519943295 }, - { 0.34804093691586013, -0.90000000000000002, 0.50000000000000000, + { 0.36231594750319435, -0.90000000000000002, 0.50000000000000000, 0.34906585039886590 }, - { 0.52137576320372891, -0.90000000000000002, 0.50000000000000000, + { 0.57016256984349567, -0.90000000000000002, 0.50000000000000000, 0.52359877559829882 }, - { 0.69655163996912262, -0.90000000000000002, 0.50000000000000000, + { 0.81494025918293422, -0.90000000000000002, 0.50000000000000000, 0.69813170079773179 }, - { 0.87783188683054236, -0.90000000000000002, 0.50000000000000000, + { 1.1178482279283477, -0.90000000000000002, 0.50000000000000000, 0.87266462599716477 }, - { 1.0716015959755185, -0.90000000000000002, 0.50000000000000000, + { 1.5081455873012106, -0.90000000000000002, 0.50000000000000000, 1.0471975511965976 }, - { 1.2857636916026749, -0.90000000000000002, 0.50000000000000000, + { 2.0213599730863998, -0.90000000000000002, 0.50000000000000000, 1.2217304763960306 }, - { 1.5264263913252363, -0.90000000000000002, 0.50000000000000000, + { 2.6822467012926827, -0.90000000000000002, 0.50000000000000000, 1.3962634015954636 }, - { 1.7888013241937861, -0.90000000000000002, 0.50000000000000000, + { 3.4591069002104677, -0.90000000000000002, 0.50000000000000000, 1.5707963267948966 }, }; const double toler006 = 2.5000000000000020e-13; -// Test data for k=-0.90000000000000002, nu=0.59999999999999998. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.5560830683344639e-16 +// Test data for k=-0.90000000000000002, nu=0.60000000000000009. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.0602096790645418e-16 +// mean(f - f_Boost): 1.0269562977782698e-16 +// variance(f - f_Boost): 1.4388836606733082e-32 +// stddev(f - f_Boost): 1.1995347684303728e-16 const testcase_ellint_3<double> data007[10] = { - { 0.0000000000000000, -0.90000000000000002, 0.59999999999999998, + { 0.0000000000000000, -0.90000000000000002, 0.60000000000000009, 0.0000000000000000 }, - { 0.17420100334657812, -0.90000000000000002, 0.59999999999999998, + { 0.17633073723493825, -0.90000000000000002, 0.60000000000000009, 0.17453292519943295 }, - { 0.34671975876122157, -0.90000000000000002, 0.59999999999999998, + { 0.36386108723492810, -0.90000000000000002, 0.60000000000000009, 0.34906585039886590 }, - { 0.51724631570707946, -0.90000000000000002, 0.59999999999999998, + { 0.57597424744716241, -0.90000000000000002, 0.60000000000000009, 0.52359877559829882 }, - { 0.68760879113743023, -0.90000000000000002, 0.59999999999999998, + { 0.83098051948501150, -0.90000000000000002, 0.60000000000000009, 0.69813170079773179 }, - { 0.86192157779698364, -0.90000000000000002, 0.59999999999999998, + { 1.1558706545698916, -0.90000000000000002, 0.60000000000000009, 0.87266462599716477 }, - { 1.0464279696166354, -0.90000000000000002, 0.59999999999999998, + { 1.5905576379415669, -0.90000000000000002, 0.60000000000000009, 1.0471975511965976 }, - { 1.2488156247094007, -0.90000000000000002, 0.59999999999999998, + { 2.1875186010215080, -0.90000000000000002, 0.60000000000000009, 1.2217304763960306 }, - { 1.4750988777188472, -0.90000000000000002, 0.59999999999999998, + { 2.9885767771316849, -0.90000000000000002, 0.60000000000000009, 1.3962634015954636 }, - { 1.7211781128919523, -0.90000000000000002, 0.59999999999999998, + { 3.9549939883570224, -0.90000000000000002, 0.60000000000000009, 1.5707963267948966 }, }; const double toler007 = 2.5000000000000020e-13; -// Test data for k=-0.90000000000000002, nu=0.69999999999999996. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 5.4833366769839281e-16 +// Test data for k=-0.90000000000000002, nu=0.70000000000000007. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 5.1938610791060186e-16 +// mean(f - f_Boost): 3.0253577421035517e-16 +// variance(f - f_Boost): 4.2342877557562532e-32 +// stddev(f - f_Boost): 2.0577385051935665e-16 const testcase_ellint_3<double> data008[10] = { - { 0.0000000000000000, -0.90000000000000002, 0.69999999999999996, + { 0.0000000000000000, -0.90000000000000002, 0.70000000000000007, 0.0000000000000000 }, - { 0.17402765093102207, -0.90000000000000002, 0.69999999999999996, + { 0.17651246700160939, -0.90000000000000002, 0.70000000000000007, 0.17453292519943295 }, - { 0.34541608382635131, -0.90000000000000002, 0.69999999999999996, + { 0.36542993547358982, -0.90000000000000002, 0.70000000000000007, 0.34906585039886590 }, - { 0.51322715827061682, -0.90000000000000002, 0.69999999999999996, + { 0.58199897877674867, -0.90000000000000002, 0.70000000000000007, 0.52359877559829882 }, - { 0.67903717872440272, -0.90000000000000002, 0.69999999999999996, + { 0.84815633587352857, -0.90000000000000002, 0.70000000000000007, 0.69813170079773179 }, - { 0.84690113601682671, -0.90000000000000002, 0.69999999999999996, + { 1.1985495623872375, -0.90000000000000002, 0.70000000000000007, 0.87266462599716477 }, - { 1.0229914311548418, -0.90000000000000002, 0.69999999999999996, + { 1.6892158134027688, -0.90000000000000002, 0.70000000000000007, 1.0471975511965976 }, - { 1.2148329639709381, -0.90000000000000002, 0.69999999999999996, + { 2.4029722191094236, -0.90000000000000002, 0.70000000000000007, 1.2217304763960306 }, - { 1.4283586501307803, -0.90000000000000002, 0.69999999999999996, + { 3.4201084941340052, -0.90000000000000002, 0.70000000000000007, 1.3962634015954636 }, - { 1.6600480747670940, -0.90000000000000002, 0.69999999999999996, + { 4.6985482312992435, -0.90000000000000002, 0.70000000000000007, 1.5707963267948966 }, }; const double toler008 = 2.5000000000000020e-13; // Test data for k=-0.90000000000000002, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.7525301941362493e-16 +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 6.5091520146032660e-16 +// mean(f - f_Boost): 2.8310687127941490e-16 +// variance(f - f_Boost): 9.8950000698295322e-33 +// stddev(f - f_Boost): 9.9473614943006532e-17 const testcase_ellint_3<double> data009[10] = { { 0.0000000000000000, -0.90000000000000002, 0.80000000000000004, 0.0000000000000000 }, - { 0.17385491439925146, -0.90000000000000002, 0.80000000000000004, + { 0.17669487107954862, -0.90000000000000002, 0.80000000000000004, 0.17453292519943295 }, - { 0.34412950523113928, -0.90000000000000002, 0.80000000000000004, + { 0.36702314729628421, -0.90000000000000002, 0.80000000000000004, 0.34906585039886590 }, - { 0.50931321668729590, -0.90000000000000002, 0.80000000000000004, + { 0.58825099711365492, -0.90000000000000002, 0.80000000000000004, 0.52359877559829882 }, - { 0.67081081392296327, -0.90000000000000002, 0.80000000000000004, + { 0.86661711422209031, -0.90000000000000002, 0.80000000000000004, 0.69813170079773179 }, - { 0.83268846097293259, -0.90000000000000002, 0.80000000000000004, + { 1.2469779109884802, -0.90000000000000002, 0.80000000000000004, 0.87266462599716477 }, - { 1.0010985015814027, -0.90000000000000002, 0.80000000000000004, + { 1.8105469760531578, -0.90000000000000002, 0.80000000000000004, 1.0471975511965976 }, - { 1.1834394045489680, -0.90000000000000002, 0.80000000000000004, + { 2.6989505165893752, -0.90000000000000002, 0.80000000000000004, 1.2217304763960306 }, - { 1.3855695891683186, -0.90000000000000002, 0.80000000000000004, + { 4.0935213267757424, -0.90000000000000002, 0.80000000000000004, 1.3962634015954636 }, - { 1.6044591960982202, -0.90000000000000002, 0.80000000000000004, + { 5.9820740813645710, -0.90000000000000002, 0.80000000000000004, 1.5707963267948966 }, }; const double toler009 = 2.5000000000000020e-13; // Test data for k=-0.90000000000000002, nu=0.90000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8471853989694167e-16 +// max(|f - f_Boost|): 4.4408920985006262e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 8.2628580104449673e-16 +// mean(f - f_Boost): 8.5764728652293339e-16 +// variance(f - f_Boost): 8.9671393318321280e-31 +// stddev(f - f_Boost): 9.4694980499666013e-16 const testcase_ellint_3<double> data010[10] = { { 0.0000000000000000, -0.90000000000000002, 0.90000000000000002, 0.0000000000000000 }, - { 0.17368278986240135, -0.90000000000000002, 0.90000000000000002, + { 0.17687795394604169, -0.90000000000000002, 0.90000000000000002, 0.17453292519943295 }, - { 0.34285962963961397, -0.90000000000000002, 0.90000000000000002, + { 0.36864140434751286, -0.90000000000000002, 0.90000000000000002, 0.34906585039886590 }, - { 0.50549974644993312, -0.90000000000000002, 0.90000000000000002, + { 0.59474595366817051, -0.90000000000000002, 0.90000000000000002, 0.52359877559829882 }, - { 0.66290623857720876, -0.90000000000000002, 0.90000000000000002, + { 0.88654237226056665, -0.90000000000000002, 0.90000000000000002, 0.69813170079773179 }, - { 0.81921183128847175, -0.90000000000000002, 0.90000000000000002, + { 1.3026595810616726, -0.90000000000000002, 0.90000000000000002, 0.87266462599716477 }, - { 0.98058481956066390, -0.90000000000000002, 0.90000000000000002, + { 1.9653635459278078, -0.90000000000000002, 0.90000000000000002, 1.0471975511965976 }, - { 1.1543223520473569, -0.90000000000000002, 0.90000000000000002, + { 3.1451407527189463, -0.90000000000000002, 0.90000000000000002, 1.2217304763960306 }, - { 1.3462119782292938, -0.90000000000000002, 0.90000000000000002, + { 5.3745230680316114, -0.90000000000000002, 0.90000000000000002, 1.3962634015954636 }, - { 1.5536420236310946, -0.90000000000000002, 0.90000000000000002, + { 8.9942562031858682, -0.90000000000000002, 0.90000000000000002, 1.5707963267948966 }, }; const double toler010 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.0000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1175183168766718e-16 +// max(|f - f_Boost|): 1.5543122344752192e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.7898565163847540e-16 +// mean(f - f_Boost): 2.3869795029440865e-16 +// variance(f - f_Boost): 2.1368406725192426e-31 +// stddev(f - f_Boost): 4.6225974002926564e-16 const testcase_ellint_3<double> data011[10] = { @@ -338,289 +370,319 @@ data011[10] = 0.0000000000000000 }, { 0.17510154241338899, -0.80000000000000004, 0.0000000000000000, 0.17453292519943295 }, - { 0.35365068839779390, -0.80000000000000004, 0.0000000000000000, + { 0.35365068839779396, -0.80000000000000004, 0.0000000000000000, 0.34906585039886590 }, { 0.53926804409084550, -0.80000000000000004, 0.0000000000000000, 0.52359877559829882 }, - { 0.73587926028070361, -0.80000000000000004, 0.0000000000000000, + { 0.73587926028070372, -0.80000000000000004, 0.0000000000000000, 0.69813170079773179 }, { 0.94770942970071170, -0.80000000000000004, 0.0000000000000000, 0.87266462599716477 }, { 1.1789022995388236, -0.80000000000000004, 0.0000000000000000, 1.0471975511965976 }, - { 1.4323027881876009, -0.80000000000000004, 0.0000000000000000, + { 1.4323027881876012, -0.80000000000000004, 0.0000000000000000, 1.2217304763960306 }, - { 1.7069629739121674, -0.80000000000000004, 0.0000000000000000, + { 1.7069629739121677, -0.80000000000000004, 0.0000000000000000, 1.3962634015954636 }, - { 1.9953027776647296, -0.80000000000000004, 0.0000000000000000, + { 1.9953027776647294, -0.80000000000000004, 0.0000000000000000, 1.5707963267948966 }, }; const double toler011 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.10000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1537164503193145e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 8.3898786942190374e-16 +// mean(f - f_Boost): 2.3869795029440865e-16 +// variance(f - f_Boost): 2.9190059990693968e-31 +// stddev(f - f_Boost): 5.4027826155319237e-16 const testcase_ellint_3<double> data012[10] = { { 0.0000000000000000, -0.80000000000000004, 0.10000000000000001, 0.0000000000000000 }, - { 0.17492468824017163, -0.80000000000000004, 0.10000000000000001, + { 0.17527903952342144, -0.80000000000000004, 0.10000000000000001, 0.17453292519943295 }, - { 0.35224443521476911, -0.80000000000000004, 0.10000000000000001, + { 0.35507705313548549, -0.80000000000000004, 0.10000000000000001, 0.34906585039886590 }, - { 0.53456851853226950, -0.80000000000000004, 0.10000000000000001, + { 0.54411455987643553, -0.80000000000000004, 0.10000000000000001, 0.52359877559829882 }, - { 0.72488875602364922, -0.80000000000000004, 0.10000000000000001, + { 0.74745625666804383, -0.80000000000000004, 0.10000000000000001, 0.69813170079773179 }, - { 0.92661354274638952, -0.80000000000000004, 0.10000000000000001, + { 0.97046953684238557, -0.80000000000000004, 0.10000000000000001, 0.87266462599716477 }, - { 1.1432651144499075, -0.80000000000000004, 0.10000000000000001, + { 1.2183080025184605, -0.80000000000000004, 0.10000000000000001, 1.0471975511965976 }, - { 1.3774479927211429, -0.80000000000000004, 0.10000000000000001, + { 1.4943711151994405, -0.80000000000000004, 0.10000000000000001, 1.2217304763960306 }, - { 1.6287092337196041, -0.80000000000000004, 0.10000000000000001, + { 1.7972401309544201, -0.80000000000000004, 0.10000000000000001, 1.3962634015954636 }, - { 1.8910755418379521, -0.80000000000000004, 0.10000000000000001, + { 2.1172616484005085, -0.80000000000000004, 0.10000000000000001, 1.5707963267948966 }, }; const double toler012 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.20000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1894552974436829e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.8513740186068518e-16 +// mean(f - f_Boost): 2.8310687127941490e-16 +// variance(f - f_Boost): 2.7528339102381189e-31 +// stddev(f - f_Boost): 5.2467455724840699e-16 const testcase_ellint_3<double> data013[10] = { { 0.0000000000000000, -0.80000000000000004, 0.20000000000000001, 0.0000000000000000 }, - { 0.17474847286224940, -0.80000000000000004, 0.20000000000000001, + { 0.17545718375086419, -0.80000000000000004, 0.20000000000000001, 0.17453292519943295 }, - { 0.35085779529084682, -0.80000000000000004, 0.20000000000000001, + { 0.35652404627248163, -0.80000000000000004, 0.20000000000000001, 0.34906585039886590 }, - { 0.53000829263059146, -0.80000000000000004, 0.20000000000000001, + { 0.54911638512920913, -0.80000000000000004, 0.20000000000000001, 0.52359877559829882 }, - { 0.71443466027453384, -0.80000000000000004, 0.20000000000000001, + { 0.75967684282131176, -0.80000000000000004, 0.20000000000000001, 0.69813170079773179 }, - { 0.90698196872715420, -0.80000000000000004, 0.20000000000000001, + { 0.99513526893543769, -0.80000000000000004, 0.20000000000000001, 0.87266462599716477 }, - { 1.1108198200558579, -0.80000000000000004, 0.20000000000000001, + { 1.2622192109995993, -0.80000000000000004, 0.20000000000000001, 1.0471975511965976 }, - { 1.3284988909963957, -0.80000000000000004, 0.20000000000000001, + { 1.5654106676347741, -0.80000000000000004, 0.20000000000000001, 1.2217304763960306 }, - { 1.5600369318140328, -0.80000000000000004, 0.20000000000000001, + { 1.9029531718534984, -0.80000000000000004, 0.20000000000000001, 1.3962634015954636 }, - { 1.8007226661734588, -0.80000000000000004, 0.20000000000000001, + { 2.2624789434186798, -0.80000000000000004, 0.20000000000000001, 1.5707963267948966 }, }; const double toler013 = 2.5000000000000020e-13; -// Test data for k=-0.80000000000000004, nu=0.29999999999999999. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2247517409029886e-16 +// Test data for k=-0.80000000000000004, nu=0.30000000000000004. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.2825261583337354e-16 +// mean(f - f_Boost): 2.6367796834847468e-16 +// variance(f - f_Boost): 2.8249350208968825e-31 +// stddev(f - f_Boost): 5.3150117788175054e-16 const testcase_ellint_3<double> data014[10] = { - { 0.0000000000000000, -0.80000000000000004, 0.29999999999999999, + { 0.0000000000000000, -0.80000000000000004, 0.30000000000000004, 0.0000000000000000 }, - { 0.17457289217669889, -0.80000000000000004, 0.29999999999999999, + { 0.17563597931587369, -0.80000000000000004, 0.30000000000000004, 0.17453292519943295 }, - { 0.34949028801501258, -0.80000000000000004, 0.29999999999999999, + { 0.35799220412005128, -0.80000000000000004, 0.30000000000000004, 0.34906585039886590 }, - { 0.52558024362769307, -0.80000000000000004, 0.29999999999999999, + { 0.55428253691111318, -0.80000000000000004, 0.30000000000000004, 0.52359877559829882 }, - { 0.70447281740094891, -0.80000000000000004, 0.29999999999999999, + { 0.77260647376977365, -0.80000000000000004, 0.30000000000000004, 0.69813170079773179 }, - { 0.88864745641528986, -0.80000000000000004, 0.29999999999999999, + { 1.0220015271210958, -0.80000000000000004, 0.30000000000000004, 0.87266462599716477 }, - { 1.0811075819341462, -0.80000000000000004, 0.29999999999999999, + { 1.3115965312302671, -0.80000000000000004, 0.30000000000000004, 1.0471975511965976 }, - { 1.2844589654082377, -0.80000000000000004, 0.29999999999999999, + { 1.6478518468813512, -0.80000000000000004, 0.30000000000000004, 1.2217304763960306 }, - { 1.4991461361277847, -0.80000000000000004, 0.29999999999999999, + { 2.0290458414203481, -0.80000000000000004, 0.30000000000000004, 1.3962634015954636 }, - { 1.7214611048717301, -0.80000000000000004, 0.29999999999999999, + { 2.4392042002725693, -0.80000000000000004, 0.30000000000000004, 1.5707963267948966 }, }; const double toler014 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.40000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2596216594752862e-16 +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 8.3462748389836647e-16 +// mean(f - f_Boost): 3.3861802251067273e-16 +// variance(f - f_Boost): 4.3719465706454422e-31 +// stddev(f - f_Boost): 6.6120696991527871e-16 const testcase_ellint_3<double> data015[10] = { { 0.0000000000000000, -0.80000000000000004, 0.40000000000000002, 0.0000000000000000 }, - { 0.17439794211872175, -0.80000000000000004, 0.40000000000000002, + { 0.17581543047866136, -0.80000000000000004, 0.40000000000000002, 0.17453292519943295 }, - { 0.34814144964568972, -0.80000000000000004, 0.40000000000000002, + { 0.35948208343061633, -0.80000000000000004, 0.40000000000000002, 0.34906585039886590 }, - { 0.52127776285273064, -0.80000000000000004, 0.40000000000000002, + { 0.55962280893702021, -0.80000000000000004, 0.40000000000000002, 0.52359877559829882 }, - { 0.69496411438966588, -0.80000000000000004, 0.40000000000000002, + { 0.78632063889234116, -0.80000000000000004, 0.40000000000000002, 0.69813170079773179 }, - { 0.87146878427509589, -0.80000000000000004, 0.40000000000000002, + { 1.0514333069550323, -0.80000000000000004, 0.40000000000000002, 0.87266462599716477 }, - { 1.0537579024937762, -0.80000000000000004, 0.40000000000000002, + { 1.3677213138838757, -0.80000000000000004, 0.40000000000000002, 1.0471975511965976 }, - { 1.2445534387922637, -0.80000000000000004, 0.40000000000000002, + { 1.7451736773665165, -0.80000000000000004, 0.40000000000000002, 1.2217304763960306 }, - { 1.4446769766361993, -0.80000000000000004, 0.40000000000000002, + { 2.1830100424586831, -0.80000000000000004, 0.40000000000000002, 1.3962634015954636 }, - { 1.6512267838651289, -0.80000000000000004, 0.40000000000000002, + { 2.6604037035529724, -0.80000000000000004, 0.40000000000000002, 1.5707963267948966 }, }; const double toler015 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.50000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2940800093915668e-16 +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.0388243828581744e-16 +// mean(f - f_Boost): 3.8580250105724191e-16 +// variance(f - f_Boost): 6.4106456575047741e-31 +// stddev(f - f_Boost): 8.0066507713929764e-16 const testcase_ellint_3<double> data016[10] = { { 0.0000000000000000, -0.80000000000000004, 0.50000000000000000, 0.0000000000000000 }, - { 0.17422361866118044, -0.80000000000000004, 0.50000000000000000, + { 0.17599554153999472, -0.80000000000000004, 0.50000000000000000, 0.17453292519943295 }, - { 0.34681083254170475, -0.80000000000000004, 0.50000000000000000, + { 0.36099426243351540, -0.80000000000000004, 0.50000000000000000, 0.34906585039886590 }, - { 0.51709470815494440, -0.80000000000000004, 0.50000000000000000, + { 0.56514786174780673, -0.80000000000000004, 0.50000000000000000, 0.52359877559829882 }, - { 0.68587375344080237, -0.80000000000000004, 0.50000000000000000, + { 0.80090697622371010, -0.80000000000000004, 0.50000000000000000, 0.69813170079773179 }, - { 0.85532571852810624, -0.80000000000000004, 0.50000000000000000, + { 1.0838891627679339, -0.80000000000000004, 0.50000000000000000, 0.87266462599716477 }, - { 1.0284677391874903, -0.80000000000000004, 0.50000000000000000, + { 1.4323506654466280, -0.80000000000000004, 0.50000000000000000, 1.0471975511965976 }, - { 1.2081693942686225, -0.80000000000000004, 0.50000000000000000, + { 1.8625761085390575, -0.80000000000000004, 0.50000000000000000, 1.2217304763960306 }, - { 1.3955803006426311, -0.80000000000000004, 0.50000000000000000, + { 2.3768757305654766, -0.80000000000000004, 0.50000000000000000, 1.3962634015954636 }, - { 1.5884528947755532, -0.80000000000000004, 0.50000000000000000, + { 2.9478781158239746, -0.80000000000000004, 0.50000000000000000, 1.5707963267948966 }, }; const double toler016 = 2.5000000000000020e-13; -// Test data for k=-0.80000000000000004, nu=0.59999999999999998. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.3281408974056389e-16 +// Test data for k=-0.80000000000000004, nu=0.60000000000000009. +// max(|f - f_Boost|): 3.5527136788005009e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.0631099169042069e-15 +// mean(f - f_Boost): 4.8294701571194306e-16 +// variance(f - f_Boost): 1.1633910328160319e-30 +// stddev(f - f_Boost): 1.0786060600682865e-15 const testcase_ellint_3<double> data017[10] = { - { 0.0000000000000000, -0.80000000000000004, 0.59999999999999998, + { 0.0000000000000000, -0.80000000000000004, 0.60000000000000009, 0.0000000000000000 }, - { 0.17404991781414089, -0.80000000000000004, 0.59999999999999998, + { 0.17617631684170665, -0.80000000000000004, 0.60000000000000009, 0.17453292519943295 }, - { 0.34549800443625167, -0.80000000000000004, 0.59999999999999998, + { 0.36252934193666231, -0.80000000000000004, 0.60000000000000009, 0.34906585039886590 }, - { 0.51302536167001545, -0.80000000000000004, 0.59999999999999998, + { 0.57086932622945163, -0.80000000000000004, 0.60000000000000009, 0.52359877559829882 }, - { 0.67717065003912236, -0.80000000000000004, 0.59999999999999998, + { 0.81646796740150973, -0.80000000000000004, 0.60000000000000009, 0.69813170079773179 }, - { 0.84011512421134416, -0.80000000000000004, 0.59999999999999998, + { 1.1199552158519064, -0.80000000000000004, 0.60000000000000009, 0.87266462599716477 }, - { 1.0049863847088740, -0.80000000000000004, 0.59999999999999998, + { 1.5079766673336394, -0.80000000000000004, 0.60000000000000009, 1.0471975511965976 }, - { 1.1748145941898920, -0.80000000000000004, 0.59999999999999998, + { 2.0082747447038165, -0.80000000000000004, 0.60000000000000009, 1.2217304763960306 }, - { 1.3510319699755071, -0.80000000000000004, 0.59999999999999998, + { 2.6315146066775523, -0.80000000000000004, 0.60000000000000009, 1.3962634015954636 }, - { 1.5319262547427865, -0.80000000000000004, 0.59999999999999998, + { 3.3418121892288051, -0.80000000000000004, 0.60000000000000009, 1.5707963267948966 }, }; const double toler017 = 2.5000000000000020e-13; -// Test data for k=-0.80000000000000004, nu=0.69999999999999996. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 4.3618176466061808e-16 +// Test data for k=-0.80000000000000004, nu=0.70000000000000007. +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.6544679145741375e-16 +// mean(f - f_Boost): 3.2751579226442120e-16 +// variance(f - f_Boost): 4.4236851331020672e-31 +// stddev(f - f_Boost): 6.6510789599147505e-16 const testcase_ellint_3<double> data018[10] = { - { 0.0000000000000000, -0.80000000000000004, 0.69999999999999996, + { 0.0000000000000000, -0.80000000000000004, 0.70000000000000007, 0.0000000000000000 }, - { 0.17387683562442199, -0.80000000000000004, 0.69999999999999996, + { 0.17635776076721221, -0.80000000000000004, 0.70000000000000007, 0.17453292519943295 }, - { 0.34420254775101611, -0.80000000000000004, 0.69999999999999996, + { 0.36408794649916976, -0.80000000000000004, 0.70000000000000007, 0.34906585039886590 }, - { 0.50906439222143673, -0.80000000000000004, 0.69999999999999996, + { 0.57679992290624138, -0.80000000000000004, 0.70000000000000007, 0.52359877559829882 }, - { 0.66882693152688422, -0.80000000000000004, 0.69999999999999996, + { 0.83312441418142813, -0.80000000000000004, 0.70000000000000007, 0.69813170079773179 }, - { 0.82574792844091316, -0.80000000000000004, 0.69999999999999996, + { 1.1603958891464856, -0.80000000000000004, 0.70000000000000007, 0.87266462599716477 }, - { 0.98310431309490931, -0.80000000000000004, 0.69999999999999996, + { 1.5982855143796213, -0.80000000000000004, 0.70000000000000007, 1.0471975511965976 }, - { 1.1440884535113258, -0.80000000000000004, 0.69999999999999996, + { 2.1962484408371821, -0.80000000000000004, 0.70000000000000007, 1.2217304763960306 }, - { 1.3103743938952537, -0.80000000000000004, 0.69999999999999996, + { 2.9873281786111869, -0.80000000000000004, 0.70000000000000007, 1.3962634015954636 }, - { 1.4806912324625332, -0.80000000000000004, 0.69999999999999996, + { 3.9268876980046397, -0.80000000000000004, 0.70000000000000007, 1.5707963267948966 }, }; const double toler018 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.3951228558314112e-16 +// max(|f - f_Boost|): 4.4408920985006262e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.0176949165011079e-16 +// mean(f - f_Boost): 7.0499162063697436e-16 +// variance(f - f_Boost): 1.7230805408026989e-30 +// stddev(f - f_Boost): 1.3126616246400665e-15 const testcase_ellint_3<double> data019[10] = { { 0.0000000000000000, -0.80000000000000004, 0.80000000000000004, 0.0000000000000000 }, - { 0.17370436817515203, -0.80000000000000004, 0.80000000000000004, + { 0.17653987774203392, -0.80000000000000004, 0.80000000000000004, 0.17453292519943295 }, - { 0.34292405894783395, -0.80000000000000004, 0.80000000000000004, + { 0.36567072568046877, -0.80000000000000004, 0.80000000000000004, 0.34906585039886590 }, - { 0.50520682176250076, -0.80000000000000004, 0.80000000000000004, + { 0.58295359996558616, -0.80000000000000004, 0.80000000000000004, 0.52359877559829882 }, - { 0.66081751679736178, -0.80000000000000004, 0.80000000000000004, + { 0.85101998309176108, -0.80000000000000004, 0.80000000000000004, 0.69813170079773179 }, - { 0.81214672249355102, -0.80000000000000004, 0.80000000000000004, + { 1.2062322059736537, -0.80000000000000004, 0.80000000000000004, 0.87266462599716477 }, - { 0.96264481387685552, -0.80000000000000004, 0.80000000000000004, + { 1.7090321420917429, -0.80000000000000004, 0.80000000000000004, 1.0471975511965976 }, - { 1.1156611352656258, -0.80000000000000004, 0.80000000000000004, + { 2.4529058049405066, -0.80000000000000004, 0.80000000000000004, 1.2217304763960306 }, - { 1.2730756225143889, -0.80000000000000004, 0.80000000000000004, + { 3.5368893360106948, -0.80000000000000004, 0.80000000000000004, 1.3962634015954636 }, - { 1.4339837018309471, -0.80000000000000004, 0.80000000000000004, + { 4.9246422058196062, -0.80000000000000004, 0.80000000000000004, 1.5707963267948966 }, }; const double toler019 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.90000000000000002. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 4.4280684534289690e-16 +// max(|f - f_Boost|): 4.4408920985006262e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.7782721357365268e-16 +// mean(f - f_Boost): 8.9928064994637676e-16 +// variance(f - f_Boost): 1.5485199571025344e-30 +// stddev(f - f_Boost): 1.2443954183066307e-15 const testcase_ellint_3<double> data020[10] = { { 0.0000000000000000, -0.80000000000000004, 0.90000000000000002, 0.0000000000000000 }, - { 0.17353251158533151, -0.80000000000000004, 0.90000000000000002, + { 0.17672267223433513, -0.80000000000000004, 0.90000000000000002, 0.17453292519943295 }, - { 0.34166214791545768, -0.80000000000000004, 0.90000000000000002, + { 0.36727835537196063, -0.80000000000000004, 0.90000000000000002, 0.34906585039886590 }, - { 0.50144799535130569, -0.80000000000000004, 0.90000000000000002, + { 0.58934569363716649, -0.80000000000000004, 0.90000000000000002, 0.52359877559829882 }, - { 0.65311976193814425, -0.80000000000000004, 0.90000000000000002, + { 0.87032723471138851, -0.80000000000000004, 0.90000000000000002, 0.69813170079773179 }, - { 0.79924384892320866, -0.80000000000000004, 0.90000000000000002, + { 1.2588676111323349, -0.80000000000000004, 0.90000000000000002, 0.87266462599716477 }, - { 0.94345762353365603, -0.80000000000000004, 0.90000000000000002, + { 1.8498731900660019, -0.80000000000000004, 0.90000000000000002, 1.0471975511965976 }, - { 1.0892582069219161, -0.80000000000000004, 0.90000000000000002, + { 2.8368381299300420, -0.80000000000000004, 0.90000000000000002, 1.2217304763960306 }, - { 1.2387000876610268, -0.80000000000000004, 0.90000000000000002, + { 4.5674844191654058, -0.80000000000000004, 0.90000000000000002, 1.3962634015954636 }, - { 1.3911845406776222, -0.80000000000000004, 0.90000000000000002, + { 7.2263259298637115, -0.80000000000000004, 0.90000000000000002, 1.5707963267948966 }, }; const double toler020 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.0000000000000000. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 3.5930208052157665e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 5.5425633303580569e-16 +// mean(f - f_Boost): 7.7715611723760953e-17 +// variance(f - f_Boost): 7.4564398834547797e-34 +// stddev(f - f_Boost): 2.7306482533374340e-17 const testcase_ellint_3<double> data021[10] = { @@ -628,289 +690,319 @@ data021[10] = 0.0000000000000000 }, { 0.17496737466916723, -0.69999999999999996, 0.0000000000000000, 0.17453292519943295 }, - { 0.35254687535677925, -0.69999999999999996, 0.0000000000000000, + { 0.35254687535677931, -0.69999999999999996, 0.0000000000000000, 0.34906585039886590 }, - { 0.53536740275997119, -0.69999999999999996, 0.0000000000000000, + { 0.53536740275997130, -0.69999999999999996, 0.0000000000000000, 0.52359877559829882 }, { 0.72603797651684454, -0.69999999999999996, 0.0000000000000000, 0.69813170079773179 }, - { 0.92698296348313458, -0.69999999999999996, 0.0000000000000000, + { 0.92698296348313447, -0.69999999999999996, 0.0000000000000000, 0.87266462599716477 }, { 1.1400447527693316, -0.69999999999999996, 0.0000000000000000, 1.0471975511965976 }, - { 1.3657668117194073, -0.69999999999999996, 0.0000000000000000, + { 1.3657668117194071, -0.69999999999999996, 0.0000000000000000, 1.2217304763960306 }, - { 1.6024686895959159, -0.69999999999999996, 0.0000000000000000, + { 1.6024686895959162, -0.69999999999999996, 0.0000000000000000, 1.3962634015954636 }, - { 1.8456939983747236, -0.69999999999999996, 0.0000000000000000, + { 1.8456939983747234, -0.69999999999999996, 0.0000000000000000, 1.5707963267948966 }, }; const double toler021 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.10000000000000001. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 3.6735282577377367e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 5.2736371663370261e-16 +// mean(f - f_Boost): 8.8817841970012528e-17 +// variance(f - f_Boost): 9.7390235212470591e-34 +// stddev(f - f_Boost): 3.1207408609570677e-17 const testcase_ellint_3<double> data022[10] = { { 0.0000000000000000, -0.69999999999999996, 0.10000000000000001, 0.0000000000000000 }, - { 0.17479076384884684, -0.69999999999999996, 0.10000000000000001, + { 0.17514462737300920, -0.69999999999999996, 0.10000000000000001, 0.17453292519943295 }, - { 0.35114844900396364, -0.69999999999999996, 0.10000000000000001, + { 0.35396527997470451, -0.69999999999999996, 0.10000000000000001, 0.34906585039886590 }, - { 0.53072776947527001, -0.69999999999999996, 0.10000000000000001, + { 0.54015179589433981, -0.69999999999999996, 0.10000000000000001, 0.52359877559829882 }, - { 0.71530198262386235, -0.69999999999999996, 0.10000000000000001, + { 0.73734430854477728, -0.69999999999999996, 0.10000000000000001, 0.69813170079773179 }, - { 0.90666760677828306, -0.69999999999999996, 0.10000000000000001, + { 0.94888950796697047, -0.69999999999999996, 0.10000000000000001, 0.87266462599716477 }, - { 1.1063366517438080, -0.69999999999999996, 0.10000000000000001, + { 1.1772807959736322, -0.69999999999999996, 0.10000000000000001, 1.0471975511965976 }, - { 1.3149477243092149, -0.69999999999999996, 0.10000000000000001, + { 1.4231796401075831, -0.69999999999999996, 0.10000000000000001, 1.2217304763960306 }, - { 1.5314886725038925, -0.69999999999999996, 0.10000000000000001, + { 1.6841856799887469, -0.69999999999999996, 0.10000000000000001, 1.3962634015954636 }, - { 1.7528050171757608, -0.69999999999999996, 0.10000000000000001, + { 1.9541347343119562, -0.69999999999999996, 0.10000000000000001, 1.5707963267948966 }, }; const double toler022 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.20000000000000001. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 3.7517969287516802e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.9907249355047774e-16 +// mean(f - f_Boost): 3.3306690738754695e-17 +// variance(f - f_Boost): 1.3695501826753678e-34 +// stddev(f - f_Boost): 1.1702778228589003e-17 const testcase_ellint_3<double> data023[10] = { { 0.0000000000000000, -0.69999999999999996, 0.20000000000000001, 0.0000000000000000 }, - { 0.17461479077791475, -0.69999999999999996, 0.20000000000000001, + { 0.17532252613350796, -0.69999999999999996, 0.20000000000000001, 0.17453292519943295 }, - { 0.34976950621407538, -0.69999999999999996, 0.20000000000000001, + { 0.35540417596807522, -0.69999999999999996, 0.20000000000000001, 0.34906585039886590 }, - { 0.52622533231350177, -0.69999999999999996, 0.20000000000000001, + { 0.54508913033361928, -0.69999999999999996, 0.20000000000000001, 0.52359877559829882 }, - { 0.70508774017895215, -0.69999999999999996, 0.20000000000000001, + { 0.74927635777718415, -0.69999999999999996, 0.20000000000000001, 0.69813170079773179 }, - { 0.88775302531730294, -0.69999999999999996, 0.20000000000000001, + { 0.97261706337936338, -0.69999999999999996, 0.20000000000000001, 0.87266462599716477 }, - { 1.0756195476149006, -0.69999999999999996, 0.20000000000000001, + { 1.2187303976209327, -0.69999999999999996, 0.20000000000000001, 1.0471975511965976 }, - { 1.2695349716654374, -0.69999999999999996, 0.20000000000000001, + { 1.4887796709222487, -0.69999999999999996, 0.20000000000000001, 1.2217304763960306 }, - { 1.4690814617070540, -0.69999999999999996, 0.20000000000000001, + { 1.7796581281839212, -0.69999999999999996, 0.20000000000000001, 1.3962634015954636 }, - { 1.6721098780092145, -0.69999999999999996, 0.20000000000000001, + { 2.0829290325820202, -0.69999999999999996, 0.20000000000000001, 1.5707963267948966 }, }; const double toler023 = 2.5000000000000020e-13; -// Test data for k=-0.69999999999999996, nu=0.29999999999999999. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8280039841080712e-16 +// Test data for k=-0.69999999999999996, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.6912897610535316e-16 +// mean(f - f_Boost): 1.6653345369377347e-17 +// variance(f - f_Boost): 2.6207864467918357e-32 +// stddev(f - f_Boost): 1.6188843216214787e-16 const testcase_ellint_3<double> data024[10] = { - { 0.0000000000000000, -0.69999999999999996, 0.29999999999999999, + { 0.0000000000000000, -0.69999999999999996, 0.30000000000000004, 0.0000000000000000 }, - { 0.17443945136076175, -0.69999999999999996, 0.29999999999999999, + { 0.17550107516328570, -0.69999999999999996, 0.30000000000000004, 0.17453292519943295 }, - { 0.34840956983535287, -0.69999999999999996, 0.29999999999999999, + { 0.35686409576571959, -0.69999999999999996, 0.30000000000000004, 0.34906585039886590 }, - { 0.52185308551329168, -0.69999999999999996, 0.29999999999999999, + { 0.55018827316513352, -0.69999999999999996, 0.30000000000000004, 0.52359877559829882 }, - { 0.69535240431168255, -0.69999999999999996, 0.29999999999999999, + { 0.76189759494390275, -0.69999999999999996, 0.30000000000000004, 0.69813170079773179 }, - { 0.87007983473964923, -0.69999999999999996, 0.29999999999999999, + { 0.99844623430885615, -0.69999999999999996, 0.30000000000000004, 0.87266462599716477 }, - { 1.0474657975577066, -0.69999999999999996, 0.29999999999999999, + { 1.2652862989039833, -0.69999999999999996, 0.30000000000000004, 1.0471975511965976 }, - { 1.2286225419931891, -0.69999999999999996, 0.29999999999999999, + { 1.5647666808691361, -0.69999999999999996, 0.30000000000000004, 1.2217304763960306 }, - { 1.4136490671013271, -0.69999999999999996, 0.29999999999999999, + { 1.8932499694938163, -0.69999999999999996, 0.30000000000000004, 1.3962634015954636 }, - { 1.6011813647733213, -0.69999999999999996, 0.29999999999999999, + { 2.2392290510988535, -0.69999999999999996, 0.30000000000000004, 1.5707963267948966 }, }; const double toler024 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.40000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.3472957053482092e-16 +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 6.5578567644745380e-16 +// mean(f - f_Boost): 1.4710455076283324e-16 +// variance(f - f_Boost): 2.6715739327327140e-33 +// stddev(f - f_Boost): 5.1687270509601433e-17 const testcase_ellint_3<double> data025[10] = { { 0.0000000000000000, -0.69999999999999996, 0.40000000000000002, 0.0000000000000000 }, - { 0.17426474153983229, -0.69999999999999996, 0.40000000000000002, + { 0.17568027871494424, -0.69999999999999996, 0.40000000000000002, 0.17453292519943295 }, - { 0.34706817945773732, -0.69999999999999996, 0.40000000000000002, + { 0.35834559208180261, -0.69999999999999996, 0.40000000000000002, 0.34906585039886590 }, - { 0.51760452851738148, -0.69999999999999996, 0.40000000000000002, + { 0.55545885451190613, -0.69999999999999996, 0.40000000000000002, 0.52359877559829882 }, - { 0.68605801534722755, -0.69999999999999996, 0.40000000000000002, + { 0.77528120402568101, -0.69999999999999996, 0.40000000000000002, 0.69813170079773179 }, - { 0.85351339387296532, -0.69999999999999996, 0.40000000000000002, + { 1.0267241287600319, -0.69999999999999996, 0.40000000000000002, 0.87266462599716477 }, - { 1.0215297967969539, -0.69999999999999996, 0.40000000000000002, + { 1.3181380338980246, -0.69999999999999996, 0.40000000000000002, 1.0471975511965976 }, - { 1.1915051074460530, -0.69999999999999996, 0.40000000000000002, + { 1.6542840785132085, -0.69999999999999996, 0.40000000000000002, 1.2217304763960306 }, - { 1.3639821911744707, -0.69999999999999996, 0.40000000000000002, + { 2.0315595131131818, -0.69999999999999996, 0.40000000000000002, 1.3962634015954636 }, - { 1.5382162002954762, -0.69999999999999996, 0.40000000000000002, + { 2.4342502915307875, -0.69999999999999996, 0.40000000000000002, 1.5707963267948966 }, }; const double toler025 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.50000000000000000. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 3.9748346743390620e-16 +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 6.0416041815443256e-16 +// mean(f - f_Boost): 1.9151347174783951e-16 +// variance(f - f_Boost): 7.8758646268991113e-33 +// stddev(f - f_Boost): 8.8746068233466605e-17 const testcase_ellint_3<double> data026[10] = { { 0.0000000000000000, -0.69999999999999996, 0.50000000000000000, 0.0000000000000000 }, - { 0.17409065729516096, -0.69999999999999996, 0.50000000000000000, + { 0.17586014108156545, -0.69999999999999996, 0.50000000000000000, 0.17453292519943295 }, - { 0.34574489064986091, -0.69999999999999996, 0.50000000000000000, + { 0.35984923894341653, -0.69999999999999996, 0.50000000000000000, 0.34906585039886590 }, - { 0.51347361925579782, -0.69999999999999996, 0.50000000000000000, + { 0.56091135606739995, -0.69999999999999996, 0.50000000000000000, 0.52359877559829882 }, - { 0.67717079489579279, -0.69999999999999996, 0.50000000000000000, + { 0.78951212635197054, -0.69999999999999996, 0.50000000000000000, 0.69813170079773179 }, - { 0.83793902055292280, -0.69999999999999996, 0.50000000000000000, + { 1.0578865732938729, -0.69999999999999996, 0.50000000000000000, 0.87266462599716477 }, - { 0.99752863545289705, -0.69999999999999996, 0.50000000000000000, + { 1.3789149005151722, -0.69999999999999996, 0.50000000000000000, 1.0471975511965976 }, - { 1.1576240080401501, -0.69999999999999996, 0.50000000000000000, + { 1.7620212286086225, -0.69999999999999996, 0.50000000000000000, 1.2217304763960306 }, - { 1.3191464023923762, -0.69999999999999996, 0.50000000000000000, + { 2.2051554347435585, -0.69999999999999996, 0.50000000000000000, 1.3962634015954636 }, - { 1.4818433192178544, -0.69999999999999996, 0.50000000000000000, + { 2.6868019968236991, -0.69999999999999996, 0.50000000000000000, 1.5707963267948966 }, }; const double toler026 = 2.5000000000000020e-13; -// Test data for k=-0.69999999999999996, nu=0.59999999999999998. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 4.0457157538295173e-16 +// Test data for k=-0.69999999999999996, nu=0.60000000000000009. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.6515644573247170e-16 +// mean(f - f_Boost): 9.9920072216264091e-17 +// variance(f - f_Boost): 1.2325951644078310e-33 +// stddev(f - f_Boost): 3.5108334685767011e-17 const testcase_ellint_3<double> data027[10] = { - { 0.0000000000000000, -0.69999999999999996, 0.59999999999999998, + { 0.0000000000000000, -0.69999999999999996, 0.60000000000000009, 0.0000000000000000 }, - { 0.17391719464391614, -0.69999999999999996, 0.59999999999999998, + { 0.17604066659721918, -0.69999999999999996, 0.60000000000000009, 0.17453292519943295 }, - { 0.34443927423869031, -0.69999999999999996, 0.59999999999999998, + { 0.36137563278353424, -0.69999999999999996, 0.60000000000000009, 0.34906585039886590 }, - { 0.50945473266486063, -0.69999999999999996, 0.59999999999999998, + { 0.56655721272747606, -0.69999999999999996, 0.60000000000000009, 0.52359877559829882 }, - { 0.66866056326513812, -0.69999999999999996, 0.59999999999999998, + { 0.80468966552978305, -0.69999999999999996, 0.60000000000000009, 0.69813170079773179 }, - { 0.82325830002337352, -0.69999999999999996, 0.59999999999999998, + { 1.0924902943683852, -0.69999999999999996, 0.60000000000000009, 0.87266462599716477 }, - { 0.97522808245669368, -0.69999999999999996, 0.59999999999999998, + { 1.4499247992499797, -0.69999999999999996, 0.60000000000000009, 1.0471975511965976 }, - { 1.1265300613705285, -0.69999999999999996, 0.59999999999999998, + { 1.8953714382113815, -0.69999999999999996, 0.60000000000000009, 1.2217304763960306 }, - { 1.2784066076152001, -0.69999999999999996, 0.59999999999999998, + { 2.4323229949248670, -0.69999999999999996, 0.60000000000000009, 1.3962634015954636 }, - { 1.4309994736080540, -0.69999999999999996, 0.59999999999999998, + { 3.0314573496746742, -0.69999999999999996, 0.60000000000000009, 1.5707963267948966 }, }; const double toler027 = 2.5000000000000020e-13; -// Test data for k=-0.69999999999999996, nu=0.69999999999999996. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 5.4867405596732161e-16 +// Test data for k=-0.69999999999999996, nu=0.70000000000000007. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.8475278552871384e-16 +// mean(f - f_Boost): 9.9920072216264091e-17 +// variance(f - f_Boost): 1.2325951644078310e-33 +// stddev(f - f_Boost): 3.5108334685767011e-17 const testcase_ellint_3<double> data028[10] = { - { 0.0000000000000000, -0.69999999999999996, 0.69999999999999996, + { 0.0000000000000000, -0.69999999999999996, 0.70000000000000007, 0.0000000000000000 }, - { 0.17374434963995031, -0.69999999999999996, 0.69999999999999996, + { 0.17622185963747933, -0.69999999999999996, 0.70000000000000007, 0.17453292519943295 }, - { 0.34315091562900674, -0.69999999999999996, 0.69999999999999996, + { 0.36292539360435261, -0.69999999999999996, 0.70000000000000007, 0.34906585039886590 }, - { 0.50554262375653347, -0.69999999999999996, 0.69999999999999996, + { 0.57240892970150015, -0.69999999999999996, 0.70000000000000007, 0.52359877559829882 }, - { 0.66050025406305801, -0.69999999999999996, 0.69999999999999996, + { 0.82093084713182629, -0.69999999999999996, 0.70000000000000007, 0.69813170079773179 }, - { 0.80938620118847404, -0.69999999999999996, 0.69999999999999996, + { 1.1312609022179871, -0.69999999999999996, 0.70000000000000007, 0.87266462599716477 }, - { 0.95443223855852144, -0.69999999999999996, 0.69999999999999996, + { 1.5345768067715795, -0.69999999999999996, 0.70000000000000007, 1.0471975511965976 }, - { 1.0978573207128304, -0.69999999999999996, 0.69999999999999996, + { 2.0668847445934420, -0.69999999999999996, 0.70000000000000007, 1.2217304763960306 }, - { 1.2411754575007123, -0.69999999999999996, 0.69999999999999996, + { 2.7483444537551240, -0.69999999999999996, 0.70000000000000007, 1.3962634015954636 }, - { 1.3848459188329196, -0.69999999999999996, 0.69999999999999996, + { 3.5408408771788560, -0.69999999999999996, 0.70000000000000007, 1.5707963267948966 }, }; const double toler028 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1829502028913879e-16 +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 6.8664526853112274e-16 +// mean(f - f_Boost): 1.6930901125533636e-16 +// variance(f - f_Boost): 3.5389557150937801e-33 +// stddev(f - f_Boost): 5.9489122661994095e-17 const testcase_ellint_3<double> data029[10] = { { 0.0000000000000000, -0.69999999999999996, 0.80000000000000004, 0.0000000000000000 }, - { 0.17357211837335740, -0.69999999999999996, 0.80000000000000004, + { 0.17640372461994805, -0.69999999999999996, 0.80000000000000004, 0.17453292519943295 }, - { 0.34187941416012108, -0.69999999999999996, 0.80000000000000004, + { 0.36449916621651091, -0.69999999999999996, 0.80000000000000004, 0.34906585039886590 }, - { 0.50173239465478259, -0.69999999999999996, 0.80000000000000004, + { 0.57848021800372573, -0.69999999999999996, 0.80000000000000004, 0.52359877559829882 }, - { 0.65266550725988315, -0.69999999999999996, 0.80000000000000004, + { 0.83837480968392586, -0.69999999999999996, 0.80000000000000004, 0.69813170079773179 }, - { 0.79624879865249298, -0.69999999999999996, 0.80000000000000004, + { 1.1751669030061143, -0.69999999999999996, 0.80000000000000004, 0.87266462599716477 }, - { 0.93497577043296920, -0.69999999999999996, 0.80000000000000004, + { 1.6381851899173601, -0.69999999999999996, 0.80000000000000004, 1.0471975511965976 }, - { 1.0713041566930750, -0.69999999999999996, 0.80000000000000004, + { 2.3002065924302197, -0.69999999999999996, 0.80000000000000004, 1.2217304763960306 }, - { 1.2069772023255654, -0.69999999999999996, 0.80000000000000004, + { 3.2337600665337862, -0.69999999999999996, 0.80000000000000004, 1.3962634015954636 }, - { 1.3427110650397531, -0.69999999999999996, 0.80000000000000004, + { 4.4042405729076961, -0.69999999999999996, 0.80000000000000004, 1.5707963267948966 }, }; const double toler029 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.90000000000000002. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2494869624129105e-16 +// max(|f - f_Boost|): 3.5527136788005009e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 8.5869439826269878e-16 +// mean(f - f_Boost): 6.7723604502134545e-16 +// variance(f - f_Boost): 4.8757508225668289e-31 +// stddev(f - f_Boost): 6.9826576763914390e-16 const testcase_ellint_3<double> data030[10] = { { 0.0000000000000000, -0.69999999999999996, 0.90000000000000002, 0.0000000000000000 }, - { 0.17340049697003637, -0.69999999999999996, 0.90000000000000002, + { 0.17658626600478800, -0.69999999999999996, 0.90000000000000002, 0.17453292519943295 }, - { 0.34062438249741556, -0.69999999999999996, 0.90000000000000002, + { 0.36609762156017206, -0.69999999999999996, 0.90000000000000002, 0.34906585039886590 }, - { 0.49801946510076867, -0.69999999999999996, 0.90000000000000002, + { 0.58478615187842409, -0.69999999999999996, 0.90000000000000002, 0.52359877559829882 }, - { 0.64513432604750476, -0.69999999999999996, 0.90000000000000002, + { 0.85718862878291846, -0.69999999999999996, 0.90000000000000002, 0.69813170079773179 }, - { 0.78378145487573758, -0.69999999999999996, 0.90000000000000002, + { 1.2255385617397643, -0.69999999999999996, 0.90000000000000002, 0.87266462599716477 }, - { 0.91671799500854623, -0.69999999999999996, 0.90000000000000002, + { 1.7696521899992939, -0.69999999999999996, 0.90000000000000002, 1.0471975511965976 }, - { 1.0466193579463123, -0.69999999999999996, 0.90000000000000002, + { 2.6476314987883502, -0.69999999999999996, 0.90000000000000002, 1.2217304763960306 }, - { 1.1754218079199146, -0.69999999999999996, 0.90000000000000002, + { 4.1373434902898083, -0.69999999999999996, 0.90000000000000002, 1.3962634015954636 }, - { 1.3040500499695913, -0.69999999999999996, 0.90000000000000002, + { 6.3796094177887746, -0.69999999999999996, 0.90000000000000002, 1.5707963267948966 }, }; const double toler030 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.0000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 2.8964816695821429e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.3664899092028927e-16 +// mean(f - f_Boost): 5.2735593669694933e-17 +// variance(f - f_Boost): 3.4333862218458872e-34 +// stddev(f - f_Boost): 1.8529398861932589e-17 const testcase_ellint_3<double> data031[10] = { @@ -918,289 +1010,319 @@ data031[10] = 0.0000000000000000 }, { 0.17485154362988359, -0.59999999999999998, 0.0000000000000000, 0.17453292519943295 }, - { 0.35160509865544326, -0.59999999999999998, 0.0000000000000000, + { 0.35160509865544320, -0.59999999999999998, 0.0000000000000000, 0.34906585039886590 }, { 0.53210652578446138, -0.59999999999999998, 0.0000000000000000, 0.52359877559829882 }, { 0.71805304664485659, -0.59999999999999998, 0.0000000000000000, 0.69813170079773179 }, - { 0.91082759030195970, -0.59999999999999998, 0.0000000000000000, + { 0.91082759030195981, -0.59999999999999998, 0.0000000000000000, 0.87266462599716477 }, { 1.1112333229323361, -0.59999999999999998, 0.0000000000000000, 1.0471975511965976 }, { 1.3191461190365270, -0.59999999999999998, 0.0000000000000000, 1.2217304763960306 }, - { 1.5332022105084773, -0.59999999999999998, 0.0000000000000000, + { 1.5332022105084779, -0.59999999999999998, 0.0000000000000000, 1.3962634015954636 }, - { 1.7507538029157526, -0.59999999999999998, 0.0000000000000000, + { 1.7507538029157523, -0.59999999999999998, 0.0000000000000000, 1.5707963267948966 }, }; const double toler031 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.10000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 2.6674242225057385e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.2335247010355137e-16 +// mean(f - f_Boost): 8.6042284408449634e-17 +// variance(f - f_Boost): 2.2835347143080263e-33 +// stddev(f - f_Boost): 4.7786344433405099e-17 const testcase_ellint_3<double> data032[10] = { { 0.0000000000000000, -0.59999999999999998, 0.10000000000000001, 0.0000000000000000 }, - { 0.17467514275022011, -0.59999999999999998, 0.10000000000000001, + { 0.17502858548476194, -0.59999999999999998, 0.10000000000000001, 0.17453292519943295 }, - { 0.35021333086258255, -0.59999999999999998, 0.10000000000000001, + { 0.35301673150537388, -0.59999999999999998, 0.10000000000000001, 0.34906585039886590 }, - { 0.52751664092962691, -0.59999999999999998, 0.10000000000000001, + { 0.53683932476326812, -0.59999999999999998, 0.10000000000000001, 0.52359877559829882 }, - { 0.70752126971957874, -0.59999999999999998, 0.10000000000000001, + { 0.72914228589586771, -0.59999999999999998, 0.10000000000000001, 0.69813170079773179 }, - { 0.89111058756112871, -0.59999999999999998, 0.10000000000000001, + { 0.93208036718354692, -0.59999999999999998, 0.10000000000000001, 0.87266462599716477 }, - { 1.0789241202877768, -0.59999999999999998, 0.10000000000000001, + { 1.1468984688863377, -0.59999999999999998, 0.10000000000000001, 1.0471975511965976 }, - { 1.2710800210399946, -0.59999999999999998, 0.10000000000000001, + { 1.3733904977062528, -0.59999999999999998, 0.10000000000000001, 1.2217304763960306 }, - { 1.4669060574440276, -0.59999999999999998, 0.10000000000000001, + { 1.6094225663372157, -0.59999999999999998, 0.10000000000000001, 1.3962634015954636 }, - { 1.6648615773343014, -0.59999999999999998, 0.10000000000000001, + { 1.8508766487100685, -0.59999999999999998, 0.10000000000000001, 1.5707963267948966 }, }; const double toler032 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.20000000000000001. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1891472451898755e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.0940560416437693e-16 +// mean(f - f_Boost): 4.1633363423443370e-17 +// variance(f - f_Boost): 8.5834655546147173e-33 +// stddev(f - f_Boost): 9.2646994309662939e-17 const testcase_ellint_3<double> data033[10] = { { 0.0000000000000000, -0.59999999999999998, 0.20000000000000001, 0.0000000000000000 }, - { 0.17449937871800650, -0.59999999999999998, 0.20000000000000001, + { 0.17520627248155893, -0.59999999999999998, 0.20000000000000001, 0.17453292519943295 }, - { 0.34884093647346553, -0.59999999999999998, 0.20000000000000001, + { 0.35444873935437748, -0.59999999999999998, 0.20000000000000001, 0.34906585039886590 }, - { 0.52306221119844087, -0.59999999999999998, 0.20000000000000001, + { 0.54172310557682524, -0.59999999999999998, 0.20000000000000001, 0.52359877559829882 }, - { 0.69749955678982223, -0.59999999999999998, 0.20000000000000001, + { 0.74084300280734672, -0.59999999999999998, 0.20000000000000001, 0.69813170079773179 }, - { 0.87274610682416853, -0.59999999999999998, 0.20000000000000001, + { 0.95509001527006121, -0.59999999999999998, 0.20000000000000001, 0.87266462599716477 }, - { 1.0494620540750792, -0.59999999999999998, 0.20000000000000001, + { 1.1865688084431796, -0.59999999999999998, 0.20000000000000001, 1.0471975511965976 }, - { 1.2280847305507339, -0.59999999999999998, 0.20000000000000001, + { 1.4352978868932598, -0.59999999999999998, 0.20000000000000001, 1.2217304763960306 }, - { 1.4085436279696886, -0.59999999999999998, 0.20000000000000001, + { 1.6983400371331816, -0.59999999999999998, 0.20000000000000001, 1.3962634015954636 }, - { 1.5901418016279374, -0.59999999999999998, 0.20000000000000001, + { 1.9695980282802215, -0.59999999999999998, 0.20000000000000001, 1.5707963267948966 }, }; const double toler033 = 2.5000000000000020e-13; -// Test data for k=-0.59999999999999998, nu=0.29999999999999999. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 2.9132420715478757e-16 +// Test data for k=-0.59999999999999998, nu=0.30000000000000004. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.9470074709717020e-16 +// mean(f - f_Boost): 7.4940054162198071e-17 +// variance(f - f_Boost): 1.6823592487044846e-32 +// stddev(f - f_Boost): 1.2970579203352812e-16 const testcase_ellint_3<double> data034[10] = { - { 0.0000000000000000, -0.59999999999999998, 0.29999999999999999, + { 0.0000000000000000, -0.59999999999999998, 0.30000000000000004, 0.0000000000000000 }, - { 0.17432424744393932, -0.59999999999999998, 0.29999999999999999, + { 0.17538460882640122, -0.59999999999999998, 0.30000000000000004, 0.17453292519943295 }, - { 0.34748744127146447, -0.59999999999999998, 0.29999999999999999, + { 0.35590165133735557, -0.59999999999999998, 0.30000000000000004, 0.34906585039886590 }, - { 0.51873632743924825, -0.59999999999999998, 0.29999999999999999, + { 0.54676661152254535, -0.59999999999999998, 0.30000000000000004, 0.52359877559829882 }, - { 0.68794610396313116, -0.59999999999999998, 0.29999999999999999, + { 0.75321709418305305, -0.59999999999999998, 0.30000000000000004, 0.69813170079773179 }, - { 0.85558070175468726, -0.59999999999999998, 0.29999999999999999, + { 0.98012637808992920, -0.59999999999999998, 0.30000000000000004, 0.87266462599716477 }, - { 1.0224416343605653, -0.59999999999999998, 0.29999999999999999, + { 1.2310891277158875, -0.59999999999999998, 0.30000000000000004, 1.0471975511965976 }, - { 1.1893144457936788, -0.59999999999999998, 0.29999999999999999, + { 1.5069157924585623, -0.59999999999999998, 0.30000000000000004, 1.2217304763960306 }, - { 1.3566435377982575, -0.59999999999999998, 0.29999999999999999, + { 1.8039583598337940, -0.59999999999999998, 0.30000000000000004, 1.3962634015954636 }, - { 1.5243814243493585, -0.59999999999999998, 0.29999999999999999, + { 2.1134154405060599, -0.59999999999999998, 0.30000000000000004, 1.5707963267948966 }, }; const double toler034 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.40000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3897581541285558e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.7909659715991921e-16 +// mean(f - f_Boost): -2.7755575615628915e-18 +// variance(f - f_Boost): 2.4044165394594425e-32 +// stddev(f - f_Boost): 1.5506181152880429e-16 const testcase_ellint_3<double> data035[10] = { { 0.0000000000000000, -0.59999999999999998, 0.40000000000000002, 0.0000000000000000 }, - { 0.17414974487670717, -0.59999999999999998, 0.40000000000000002, + { 0.17556359876533037, -0.59999999999999998, 0.40000000000000002, 0.17453292519943295 }, - { 0.34615238767335027, -0.59999999999999998, 0.40000000000000002, + { 0.35737601674244679, -0.59999999999999998, 0.40000000000000002, 0.34906585039886590 }, - { 0.51453257838108557, -0.59999999999999998, 0.40000000000000002, + { 0.55197933771320218, -0.59999999999999998, 0.40000000000000002, 0.52359877559829882 }, - { 0.67882386787534399, -0.59999999999999998, 0.40000000000000002, + { 0.76633591620002894, -0.59999999999999998, 0.40000000000000002, 0.69813170079773179 }, - { 0.83948470233173578, -0.59999999999999998, 0.40000000000000002, + { 1.0075231136019616, -0.59999999999999998, 0.40000000000000002, 0.87266462599716477 }, - { 0.99753496200073977, -0.59999999999999998, 0.40000000000000002, + { 1.2815842073813450, -0.59999999999999998, 0.40000000000000002, 1.0471975511965976 }, - { 1.1541101404388487, -0.59999999999999998, 0.40000000000000002, + { 1.5911666941449827, -0.59999999999999998, 0.40000000000000002, 1.2217304763960306 }, - { 1.3100911323398814, -0.59999999999999998, 0.40000000000000002, + { 1.9323227566025762, -0.59999999999999998, 0.40000000000000002, 1.3962634015954636 }, - { 1.4659345278069984, -0.59999999999999998, 0.40000000000000002, + { 2.2925036420985130, -0.59999999999999998, 0.40000000000000002, 1.5707963267948966 }, }; const double toler035 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.50000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.5022138270566200e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.6240126899196213e-16 +// mean(f - f_Boost): 9.1593399531575410e-17 +// variance(f - f_Boost): 1.0357223256482469e-33 +// stddev(f - f_Boost): 3.2182640128619758e-17 const testcase_ellint_3<double> data036[10] = { { 0.0000000000000000, -0.59999999999999998, 0.50000000000000000, 0.0000000000000000 }, - { 0.17397586700252807, -0.59999999999999998, 0.50000000000000000, + { 0.17574324658480217, -0.59999999999999998, 0.50000000000000000, 0.17453292519943295 }, - { 0.34483533397138516, -0.59999999999999998, 0.50000000000000000, + { 0.35887240603169313, -0.59999999999999998, 0.50000000000000000, 0.34906585039886590 }, - { 0.51044500461706477, -0.59999999999999998, 0.50000000000000000, + { 0.55737161826345261, -0.59999999999999998, 0.50000000000000000, 0.52359877559829882 }, - { 0.67009988034712664, -0.59999999999999998, 0.50000000000000000, + { 0.78028227313077458, -0.59999999999999998, 0.50000000000000000, 0.69813170079773179 }, - { 0.82434762375735193, -0.59999999999999998, 0.50000000000000000, + { 1.0376989776486290, -0.59999999999999998, 0.50000000000000000, 0.87266462599716477 }, - { 0.97447346702798998, -0.59999999999999998, 0.50000000000000000, + { 1.3395933991042925, -0.59999999999999998, 0.50000000000000000, 1.0471975511965976 }, - { 1.1219494000522143, -0.59999999999999998, 0.50000000000000000, + { 1.6924049626591782, -0.59999999999999998, 0.50000000000000000, 1.2217304763960306 }, - { 1.2680242605954484, -0.59999999999999998, 0.50000000000000000, + { 2.0931011856518920, -0.59999999999999998, 0.50000000000000000, 1.3962634015954636 }, - { 1.4135484285693078, -0.59999999999999998, 0.50000000000000000, + { 2.5239007084492706, -0.59999999999999998, 0.50000000000000000, 1.5707963267948966 }, }; const double toler036 = 2.5000000000000020e-13; -// Test data for k=-0.59999999999999998, nu=0.59999999999999998. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.2504224329684343e-16 +// Test data for k=-0.59999999999999998, nu=0.60000000000000009. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.6651378277398083e-16 +// mean(f - f_Boost): 1.1934897514720432e-16 +// variance(f - f_Boost): 1.7585404776158019e-33 +// stddev(f - f_Boost): 4.1934955319110598e-17 const testcase_ellint_3<double> data037[10] = { - { 0.0000000000000000, -0.59999999999999998, 0.59999999999999998, + { 0.0000000000000000, -0.59999999999999998, 0.60000000000000009, 0.0000000000000000 }, - { 0.17380260984469353, -0.59999999999999998, 0.59999999999999998, + { 0.17592355661219386, -0.59999999999999998, 0.60000000000000009, 0.17453292519943295 }, - { 0.34353585361777839, -0.59999999999999998, 0.59999999999999998, + { 0.36039141192661606, -0.59999999999999998, 0.60000000000000009, 0.34906585039886590 }, - { 0.50646805774321380, -0.59999999999999998, 0.59999999999999998, + { 0.56295472636903854, -0.59999999999999998, 0.60000000000000009, 0.52359877559829882 }, - { 0.66174468108625506, -0.59999999999999998, 0.59999999999999998, + { 0.79515295130165986, -0.59999999999999998, 0.60000000000000009, 0.69813170079773179 }, - { 0.81007462280278408, -0.59999999999999998, 0.59999999999999998, + { 1.0711886441942242, -0.59999999999999998, 0.60000000000000009, 0.87266462599716477 }, - { 0.95303466945718729, -0.59999999999999998, 0.59999999999999998, + { 1.4072952835139891, -0.59999999999999998, 0.60000000000000009, 1.0471975511965976 }, - { 1.0924118588677505, -0.59999999999999998, 0.59999999999999998, + { 1.8174863977376825, -0.59999999999999998, 0.60000000000000009, 1.2217304763960306 }, - { 1.2297640574847937, -0.59999999999999998, 0.59999999999999998, + { 2.3029921578542232, -0.59999999999999998, 0.60000000000000009, 1.3962634015954636 }, - { 1.3662507535812816, -0.59999999999999998, 0.59999999999999998, + { 2.8388723099514972, -0.59999999999999998, 0.60000000000000009, 1.5707963267948966 }, }; const double toler037 = 2.5000000000000020e-13; -// Test data for k=-0.59999999999999998, nu=0.69999999999999996. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3559889697529752e-16 +// Test data for k=-0.59999999999999998, nu=0.70000000000000007. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.2451074234797436e-16 +// mean(f - f_Boost): 5.2735593669694933e-17 +// variance(f - f_Boost): 3.4333862218458872e-34 +// stddev(f - f_Boost): 1.8529398861932589e-17 const testcase_ellint_3<double> data038[10] = { - { 0.0000000000000000, -0.59999999999999998, 0.69999999999999996, + { 0.0000000000000000, -0.59999999999999998, 0.70000000000000007, 0.0000000000000000 }, - { 0.17362996946312007, -0.59999999999999998, 0.69999999999999996, + { 0.17610453321631936, -0.59999999999999998, 0.70000000000000007, 0.17453292519943295 }, - { 0.34225353454870588, -0.59999999999999998, 0.69999999999999996, + { 0.36193365056369764, -0.59999999999999998, 0.70000000000000007, 0.34906585039886590 }, - { 0.50259656397799524, -0.59999999999999998, 0.69999999999999996, + { 0.56874098962268527, -0.59999999999999998, 0.70000000000000007, 0.52359877559829882 }, - { 0.65373184496628933, -0.59999999999999998, 0.69999999999999996, + { 0.81106198671477181, -0.59999999999999998, 0.70000000000000007, 0.69813170079773179 }, - { 0.79658372884056439, -0.59999999999999998, 0.69999999999999996, + { 1.1086886419010082, -0.59999999999999998, 0.70000000000000007, 0.87266462599716477 }, - { 0.93303240100245421, -0.59999999999999998, 0.69999999999999996, + { 1.4879048567239257, -0.59999999999999998, 0.70000000000000007, 1.0471975511965976 }, - { 1.0651547944716557, -0.59999999999999998, 0.69999999999999996, + { 1.9780310073615923, -0.59999999999999998, 0.70000000000000007, 1.2217304763960306 }, - { 1.1947676204853441, -0.59999999999999998, 0.69999999999999996, + { 2.5941545586772712, -0.59999999999999998, 0.70000000000000007, 1.3962634015954636 }, - { 1.3232737468822813, -0.59999999999999998, 0.69999999999999996, + { 3.3029735898397155, -0.59999999999999998, 0.70000000000000007, 1.5707963267948966 }, }; const double toler038 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.80000000000000004. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 5.1879494682720725e-16 +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.3826960061025914e-16 +// mean(f - f_Boost): 2.7478019859472625e-16 +// variance(f - f_Boost): 4.6451528105588637e-32 +// stddev(f - f_Boost): 2.1552616570984749e-16 const testcase_ellint_3<double> data039[10] = { { 0.0000000000000000, -0.59999999999999998, 0.80000000000000004, 0.0000000000000000 }, - { 0.17345794195390685, -0.59999999999999998, 0.80000000000000004, + { 0.17628618080795252, -0.59999999999999998, 0.80000000000000004, 0.17453292519943295 }, - { 0.34098797854531027, -0.59999999999999998, 0.80000000000000004, + { 0.36349976272521012, -0.59999999999999998, 0.80000000000000004, 0.34906585039886590 }, - { 0.49882569168826213, -0.59999999999999998, 0.80000000000000004, + { 0.57474392342151914, -0.59999999999999998, 0.80000000000000004, 0.52359877559829882 }, - { 0.64603758566475511, -0.59999999999999998, 0.80000000000000004, + { 0.82814493499158159, -0.59999999999999998, 0.80000000000000004, 0.69813170079773179 }, - { 0.78380365594769730, -0.59999999999999998, 0.80000000000000004, + { 1.1511281795998280, -0.59999999999999998, 0.80000000000000004, 0.87266462599716477 }, - { 0.91430946255611190, -0.59999999999999998, 0.80000000000000004, + { 1.5864286332503075, -0.59999999999999998, 0.80000000000000004, 1.0471975511965976 }, - { 1.0398955217270607, -0.59999999999999998, 0.80000000000000004, + { 2.1958944866494527, -0.59999999999999998, 0.80000000000000004, 1.2217304763960306 }, - { 1.1625948314277679, -0.59999999999999998, 0.80000000000000004, + { 3.0398358172574604, -0.59999999999999998, 0.80000000000000004, 1.3962634015954636 }, - { 1.2840021261752192, -0.59999999999999998, 0.80000000000000004, + { 4.0867036409261832, -0.59999999999999998, 0.80000000000000004, 1.5707963267948966 }, }; const double toler039 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.90000000000000002. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.4768329326726447e-16 +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 5.7440178400898422e-16 +// mean(f - f_Boost): 5.0792703376600914e-16 +// variance(f - f_Boost): 1.9863137923719990e-31 +// stddev(f - f_Boost): 4.4568080420543122e-16 const testcase_ellint_3<double> data040[10] = { { 0.0000000000000000, -0.59999999999999998, 0.90000000000000002, 0.0000000000000000 }, - { 0.17328652344890030, -0.59999999999999998, 0.90000000000000002, + { 0.17646850384035848, -0.59999999999999998, 0.90000000000000002, 0.17453292519943295 }, - { 0.33973880062929018, -0.59999999999999998, 0.90000000000000002, + { 0.36509041515134105, -0.59999999999999998, 0.90000000000000002, 0.34906585039886590 }, - { 0.49515092233122743, -0.59999999999999998, 0.90000000000000002, + { 0.58097838596260631, -0.59999999999999998, 0.90000000000000002, 0.52359877559829882 }, - { 0.63864042139737043, -0.59999999999999998, 0.90000000000000002, + { 0.84656453396163722, -0.59999999999999998, 0.90000000000000002, 0.69813170079773179 }, - { 0.77167205646538850, -0.59999999999999998, 0.90000000000000002, + { 1.1997828426963724, -0.59999999999999998, 0.90000000000000002, 0.87266462599716477 }, - { 0.89673202848034383, -0.59999999999999998, 0.90000000000000002, + { 1.7112436789225605, -0.59999999999999998, 0.90000000000000002, 1.0471975511965976 }, - { 1.0163984492661304, -0.59999999999999998, 0.90000000000000002, + { 2.5193168553672312, -0.59999999999999998, 0.90000000000000002, 1.2217304763960306 }, - { 1.1328845785162431, -0.59999999999999998, 0.90000000000000002, + { 3.8656670488606686, -0.59999999999999998, 0.90000000000000002, 1.3962634015954636 }, - { 1.2479362973851875, -0.59999999999999998, 0.90000000000000002, + { 5.8709993116265595, -0.59999999999999998, 0.90000000000000002, 1.5707963267948966 }, }; const double toler040 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.0000000000000000. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.1201497220602069e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.4551389361831220e-16 +// mean(f - f_Boost): -1.3877787807814457e-17 +// variance(f - f_Boost): 2.5893058141206173e-32 +// stddev(f - f_Boost): 1.6091320064309879e-16 const testcase_ellint_3<double> data041[10] = { @@ -1208,1469 +1330,1619 @@ data041[10] = 0.0000000000000000 }, { 0.17475385514035785, -0.50000000000000000, 0.0000000000000000, 0.17453292519943295 }, - { 0.35081868470101585, -0.50000000000000000, 0.0000000000000000, + { 0.35081868470101579, -0.50000000000000000, 0.0000000000000000, 0.34906585039886590 }, { 0.52942862705190574, -0.50000000000000000, 0.0000000000000000, 0.52359877559829882 }, - { 0.71164727562630314, -0.50000000000000000, 0.0000000000000000, + { 0.71164727562630326, -0.50000000000000000, 0.0000000000000000, 0.69813170079773179 }, { 0.89824523594227768, -0.50000000000000000, 0.0000000000000000, 0.87266462599716477 }, - { 1.0895506700518851, -0.50000000000000000, 0.0000000000000000, + { 1.0895506700518853, -0.50000000000000000, 0.0000000000000000, 1.0471975511965976 }, - { 1.2853005857432931, -0.50000000000000000, 0.0000000000000000, + { 1.2853005857432933, -0.50000000000000000, 0.0000000000000000, 1.2217304763960306 }, - { 1.4845545520549484, -0.50000000000000000, 0.0000000000000000, + { 1.4845545520549488, -0.50000000000000000, 0.0000000000000000, 1.3962634015954636 }, - { 1.6857503548125963, -0.50000000000000000, 0.0000000000000000, + { 1.6857503548125961, -0.50000000000000000, 0.0000000000000000, 1.5707963267948966 }, }; const double toler041 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.10000000000000001. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.1662857256911530e-16 +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.7416868347177582e-16 +// mean(f - f_Boost): 2.7755575615628915e-18 +// variance(f - f_Boost): 5.4326441655972001e-32 +// stddev(f - f_Boost): 2.3308033305273100e-16 const testcase_ellint_3<double> data042[10] = { { 0.0000000000000000, -0.50000000000000000, 0.10000000000000001, 0.0000000000000000 }, - { 0.17457763120814676, -0.50000000000000000, 0.10000000000000001, + { 0.17493071928248824, -0.50000000000000000, 0.10000000000000001, 0.17453292519943295 }, - { 0.34943246340849154, -0.50000000000000000, 0.10000000000000001, + { 0.35222467688034798, -0.50000000000000000, 0.10000000000000001, 0.34906585039886590 }, - { 0.52487937869610790, -0.50000000000000000, 0.10000000000000001, + { 0.53411928652008112, -0.50000000000000000, 0.10000000000000001, 0.52359877559829882 }, - { 0.70127785096388384, -0.50000000000000000, 0.10000000000000001, + { 0.72256398117177589, -0.50000000000000000, 0.10000000000000001, 0.69813170079773179 }, - { 0.87898815988624479, -0.50000000000000000, 0.10000000000000001, + { 0.91899583232771009, -0.50000000000000000, 0.10000000000000001, 0.87266462599716477 }, - { 1.0582764576094172, -0.50000000000000000, 0.10000000000000001, + { 1.1240549163055360, -0.50000000000000000, 0.10000000000000001, 1.0471975511965976 }, - { 1.2391936844060205, -0.50000000000000000, 0.10000000000000001, + { 1.3372938086286021, -0.50000000000000000, 0.10000000000000001, 1.2217304763960306 }, - { 1.4214793542995841, -0.50000000000000000, 0.10000000000000001, + { 1.5570024469132429, -0.50000000000000000, 0.10000000000000001, 1.3962634015954636 }, - { 1.6045524936084892, -0.50000000000000000, 0.10000000000000001, + { 1.7803034946545480, -0.50000000000000000, 0.10000000000000001, 1.5707963267948966 }, }; const double toler042 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.20000000000000001. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.2114786773102175e-16 +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.1198767993730867e-16 +// mean(f - f_Boost): 2.7755575615628914e-17 +// variance(f - f_Boost): 5.0311947683004831e-32 +// stddev(f - f_Boost): 2.2430324938128922e-16 const testcase_ellint_3<double> data043[10] = { { 0.0000000000000000, -0.50000000000000000, 0.20000000000000001, 0.0000000000000000 }, - { 0.17440204336345433, -0.50000000000000000, 0.20000000000000001, + { 0.17510822779582402, -0.50000000000000000, 0.20000000000000001, 0.17453292519943295 }, - { 0.34806552388338824, -0.50000000000000000, 0.20000000000000001, + { 0.35365094725531487, -0.50000000000000000, 0.20000000000000001, 0.34906585039886590 }, - { 0.52046416757129810, -0.50000000000000000, 0.20000000000000001, + { 0.53895933237328697, -0.50000000000000000, 0.20000000000000001, 0.52359877559829882 }, - { 0.69140924550993865, -0.50000000000000000, 0.20000000000000001, + { 0.73408090840070794, -0.50000000000000000, 0.20000000000000001, 0.69813170079773179 }, - { 0.86104678636125520, -0.50000000000000000, 0.20000000000000001, + { 0.94145442818535396, -0.50000000000000000, 0.20000000000000001, 0.87266462599716477 }, - { 1.0297439459053981, -0.50000000000000000, 0.20000000000000001, + { 1.1624120186296487, -0.50000000000000000, 0.20000000000000001, 1.0471975511965976 }, - { 1.1979214112912033, -0.50000000000000000, 0.20000000000000001, + { 1.3965823372867114, -0.50000000000000000, 0.20000000000000001, 1.2217304763960306 }, - { 1.3659033858648930, -0.50000000000000000, 0.20000000000000001, + { 1.6414308440430099, -0.50000000000000000, 0.20000000000000001, 1.3962634015954636 }, - { 1.5338490483665983, -0.50000000000000000, 0.20000000000000001, + { 1.8922947612264018, -0.50000000000000000, 0.20000000000000001, 1.5707963267948966 }, }; const double toler043 = 2.5000000000000020e-13; -// Test data for k=-0.50000000000000000, nu=0.29999999999999999. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.2557837230041312e-16 +// Test data for k=-0.50000000000000000, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.3800262770228813e-16 +// mean(f - f_Boost): 5.8286708792820721e-17 +// variance(f - f_Boost): 8.5027191584278157e-32 +// stddev(f - f_Boost): 2.9159422419567599e-16 const testcase_ellint_3<double> data044[10] = { - { 0.0000000000000000, -0.50000000000000000, 0.29999999999999999, + { 0.0000000000000000, -0.50000000000000000, 0.30000000000000004, 0.0000000000000000 }, - { 0.17422708752228896, -0.50000000000000000, 0.29999999999999999, + { 0.17528638488102041, -0.50000000000000000, 0.30000000000000004, 0.17453292519943295 }, - { 0.34671739434855858, -0.50000000000000000, 0.29999999999999999, + { 0.35509802222332720, -0.50000000000000000, 0.30000000000000004, 0.34906585039886590 }, - { 0.51617616305641878, -0.50000000000000000, 0.29999999999999999, + { 0.54395740731866193, -0.50000000000000000, 0.30000000000000004, 0.52359877559829882 }, - { 0.68200047612545167, -0.50000000000000000, 0.29999999999999999, + { 0.74625871438752667, -0.50000000000000000, 0.30000000000000004, 0.69813170079773179 }, - { 0.84427217869498372, -0.50000000000000000, 0.29999999999999999, + { 0.96588271186092023, -0.50000000000000000, 0.30000000000000004, 0.87266462599716477 }, - { 1.0035637821389782, -0.50000000000000000, 0.29999999999999999, + { 1.2054319584357329, -0.50000000000000000, 0.30000000000000004, 1.0471975511965976 }, - { 1.1606800483933111, -0.50000000000000000, 0.29999999999999999, + { 1.4651077994832871, -0.50000000000000000, 0.30000000000000004, 1.2217304763960306 }, - { 1.3164407134643459, -0.50000000000000000, 0.29999999999999999, + { 1.7416018368052644, -0.50000000000000000, 0.30000000000000004, 1.3962634015954636 }, - { 1.4715681939859637, -0.50000000000000000, 0.29999999999999999, + { 2.0277924458111314, -0.50000000000000000, 0.30000000000000004, 1.5707963267948966 }, }; const double toler044 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.40000000000000002. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.2992508582900068e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.0439932918341581e-16 +// mean(f - f_Boost): 3.0531133177191807e-17 +// variance(f - f_Boost): 9.0809736800018602e-32 +// stddev(f - f_Boost): 3.0134653938616686e-16 const testcase_ellint_3<double> data045[10] = { { 0.0000000000000000, -0.50000000000000000, 0.40000000000000002, 0.0000000000000000 }, - { 0.17405275963859917, -0.50000000000000000, 0.40000000000000002, + { 0.17546519477859268, -0.50000000000000000, 0.40000000000000002, 0.17453292519943295 }, - { 0.34538761957029329, -0.50000000000000000, 0.40000000000000002, + { 0.35656644822531680, -0.50000000000000000, 0.40000000000000002, 0.34906585039886590 }, - { 0.51200902646603907, -0.50000000000000000, 0.40000000000000002, + { 0.54912289677411319, -0.50000000000000000, 0.40000000000000002, 0.52359877559829882 }, - { 0.67301522212868792, -0.50000000000000000, 0.40000000000000002, + { 0.75916731611690047, -0.50000000000000000, 0.40000000000000002, 0.69813170079773179 }, - { 0.82853844466313320, -0.50000000000000000, 0.40000000000000002, + { 0.99260415631328214, -0.50000000000000000, 0.40000000000000002, 0.87266462599716477 }, - { 0.97942097862681488, -0.50000000000000000, 0.40000000000000002, + { 1.2541925856918670, -0.50000000000000000, 0.40000000000000002, 1.0471975511965976 }, - { 1.1268429801220614, -0.50000000000000000, 0.40000000000000002, + { 1.5456393705347609, -0.50000000000000000, 0.40000000000000002, 1.2217304763960306 }, - { 1.2720406704533922, -0.50000000000000000, 0.40000000000000002, + { 1.8631904972952076, -0.50000000000000000, 0.40000000000000002, 1.3962634015954636 }, - { 1.4161679518465340, -0.50000000000000000, 0.40000000000000002, + { 2.1962905366178065, -0.50000000000000000, 0.40000000000000002, 1.5707963267948966 }, }; const double toler045 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.50000000000000000. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3419255755184137e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.6797816859260978e-16 +// mean(f - f_Boost): 9.4368957093138303e-17 +// variance(f - f_Boost): 7.7794254682023874e-32 +// stddev(f - f_Boost): 2.7891621444803792e-16 const testcase_ellint_3<double> data046[10] = { { 0.0000000000000000, -0.50000000000000000, 0.50000000000000000, 0.0000000000000000 }, - { 0.17387905570381157, -0.50000000000000000, 0.50000000000000000, + { 0.17564466176941509, -0.50000000000000000, 0.50000000000000000, 0.17453292519943295 }, - { 0.34407576010465207, -0.50000000000000000, 0.50000000000000000, + { 0.35805679276065394, -0.50000000000000000, 0.50000000000000000, 0.34906585039886590 }, - { 0.50795686560160824, -0.50000000000000000, 0.50000000000000000, + { 0.55446601496200032, -0.50000000000000000, 0.50000000000000000, 0.52359877559829882 }, - { 0.66442115453330164, -0.50000000000000000, 0.50000000000000000, + { 0.77288783578259013, -0.50000000000000000, 0.50000000000000000, 0.69813170079773179 }, - { 0.81373829119355345, -0.50000000000000000, 0.50000000000000000, + { 1.0220246013918972, -0.50000000000000000, 0.50000000000000000, 0.87266462599716477 }, - { 0.95705743313235825, -0.50000000000000000, 0.50000000000000000, + { 1.3101681612463965, -0.50000000000000000, 0.50000000000000000, 1.0471975511965976 }, - { 1.0959131991362554, -0.50000000000000000, 0.50000000000000000, + { 1.6422994881851025, -0.50000000000000000, 0.50000000000000000, 1.2217304763960306 }, - { 1.2318900529754597, -0.50000000000000000, 0.50000000000000000, + { 2.0152636030998816, -0.50000000000000000, 0.50000000000000000, 1.3962634015954636 }, - { 1.3664739530045971, -0.50000000000000000, 0.50000000000000000, + { 2.4136715042011945, -0.50000000000000000, 0.50000000000000000, 1.5707963267948966 }, }; const double toler046 = 2.5000000000000020e-13; -// Test data for k=-0.50000000000000000, nu=0.59999999999999998. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3838494104749599e-16 +// Test data for k=-0.50000000000000000, nu=0.60000000000000009. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.9178421578645735e-16 +// mean(f - f_Boost): 1.3322676295501878e-16 +// variance(f - f_Boost): 1.7749370367472766e-31 +// stddev(f - f_Boost): 4.2130001622920411e-16 const testcase_ellint_3<double> data047[10] = { - { 0.0000000000000000, -0.50000000000000000, 0.59999999999999998, + { 0.0000000000000000, -0.50000000000000000, 0.60000000000000009, 0.0000000000000000 }, - { 0.17370597174637581, -0.50000000000000000, 0.59999999999999998, + { 0.17582479017522740, -0.50000000000000000, 0.60000000000000009, 0.17453292519943295 }, - { 0.34278139158591414, -0.50000000000000000, 0.59999999999999998, + { 0.35956964546660036, -0.50000000000000000, 0.60000000000000009, 0.34906585039886590 }, - { 0.50401419439302708, -0.50000000000000000, 0.59999999999999998, + { 0.55999790372984193, -0.50000000000000000, 0.60000000000000009, 0.52359877559829882 }, - { 0.65618938076167210, -0.50000000000000000, 0.59999999999999998, + { 0.78751507911209895, -0.50000000000000000, 0.60000000000000009, 0.69813170079773179 }, - { 0.79977959248855424, -0.50000000000000000, 0.59999999999999998, + { 1.0546620505035220, -0.50000000000000000, 0.60000000000000009, 0.87266462599716477 }, - { 0.93625925190753545, -0.50000000000000000, 0.59999999999999998, + { 1.3754438357425935, -0.50000000000000000, 0.60000000000000009, 1.0471975511965976 }, - { 1.0674905658379708, -0.50000000000000000, 0.59999999999999998, + { 1.7615727400820127, -0.50000000000000000, 0.60000000000000009, 1.2217304763960306 }, - { 1.1953481298023050, -0.50000000000000000, 0.59999999999999998, + { 2.2134638067565242, -0.50000000000000000, 0.60000000000000009, 1.3962634015954636 }, - { 1.3215740290190876, -0.50000000000000000, 0.59999999999999998, + { 2.7090491861753558, -0.50000000000000000, 0.60000000000000009, 1.5707963267948966 }, }; const double toler047 = 2.5000000000000020e-13; -// Test data for k=-0.50000000000000000, nu=0.69999999999999996. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.4250604066951477e-16 +// Test data for k=-0.50000000000000000, nu=0.70000000000000007. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.0745105182189226e-16 +// mean(f - f_Boost): 4.1633363423443370e-17 +// variance(f - f_Boost): 1.9996383743576116e-32 +// stddev(f - f_Boost): 1.4140857026211713e-16 const testcase_ellint_3<double> data048[10] = { - { 0.0000000000000000, -0.50000000000000000, 0.69999999999999996, + { 0.0000000000000000, -0.50000000000000000, 0.70000000000000007, 0.0000000000000000 }, - { 0.17353350383131641, -0.50000000000000000, 0.69999999999999996, + { 0.17600558435914915, -0.50000000000000000, 0.70000000000000007, 0.17453292519943295 }, - { 0.34150410405436771, -0.50000000000000000, 0.69999999999999996, + { 0.36110561926726259, -0.50000000000000000, 0.70000000000000007, 0.34906585039886590 }, - { 0.50017589696443487, -0.50000000000000000, 0.69999999999999996, + { 0.56573074641137111, -0.50000000000000000, 0.70000000000000007, 0.52359877559829882 }, - { 0.64829398188419951, -0.50000000000000000, 0.69999999999999996, + { 0.80316073084237205, -0.50000000000000000, 0.70000000000000007, 0.69813170079773179 }, - { 0.78658270782402073, -0.50000000000000000, 0.69999999999999996, + { 1.0911910688131461, -0.50000000000000000, 0.70000000000000007, 0.87266462599716477 }, - { 0.91684738336675053, -0.50000000000000000, 0.69999999999999996, + { 1.4530946406380640, -0.50000000000000000, 0.70000000000000007, 1.0471975511965976 }, - { 1.0412486789555935, -0.50000000000000000, 0.69999999999999996, + { 1.9144386536785372, -0.50000000000000000, 0.70000000000000007, 1.2217304763960306 }, - { 1.1619021847612001, -0.50000000000000000, 0.69999999999999996, + { 2.4878788958234970, -0.50000000000000000, 0.70000000000000007, 1.3962634015954636 }, - { 1.2807475181182502, -0.50000000000000000, 0.69999999999999996, + { 3.1433945297859225, -0.50000000000000000, 0.70000000000000007, 1.5707963267948966 }, }; const double toler048 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.5715240651179632e-16 +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.4380477375534667e-16 +// mean(f - f_Boost): 2.3037127760972000e-16 +// variance(f - f_Boost): 1.4989821857033475e-31 +// stddev(f - f_Boost): 3.8716691306248618e-16 const testcase_ellint_3<double> data049[10] = { { 0.0000000000000000, -0.50000000000000000, 0.80000000000000004, 0.0000000000000000 }, - { 0.17336164805979126, -0.50000000000000000, 0.80000000000000004, + { 0.17618704872620228, -0.50000000000000000, 0.80000000000000004, 0.17453292519943295 }, - { 0.34024350132086773, -0.50000000000000000, 0.80000000000000004, + { 0.36266535159745827, -0.50000000000000000, 0.80000000000000004, 0.34906585039886590 }, - { 0.49643719555734073, -0.50000000000000000, 0.80000000000000004, + { 0.57167789954529158, -0.50000000000000000, 0.80000000000000004, 0.52359877559829882 }, - { 0.64071162456976150, -0.50000000000000000, 0.80000000000000004, + { 0.81995752984315018, -0.50000000000000000, 0.80000000000000004, 0.69813170079773179 }, - { 0.77407836177211908, -0.50000000000000000, 0.80000000000000004, + { 1.1325112162158122, -0.50000000000000000, 0.80000000000000004, 0.87266462599716477 }, - { 0.89867058251905652, -0.50000000000000000, 0.80000000000000004, + { 1.5479055930718042, -0.50000000000000000, 0.80000000000000004, 1.0471975511965976 }, - { 1.0169181822134910, -0.50000000000000000, 0.80000000000000004, + { 2.1215243941010486, -0.50000000000000000, 0.80000000000000004, 1.2217304763960306 }, - { 1.1311363312779448, -0.50000000000000000, 0.80000000000000004, + { 2.9069405767650132, -0.50000000000000000, 0.80000000000000004, 1.3962634015954636 }, - { 1.2434165408189539, -0.50000000000000000, 0.80000000000000004, + { 3.8750701888108066, -0.50000000000000000, 0.80000000000000004, 1.5707963267948966 }, }; const double toler049 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.90000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.4664649039489274e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.6192315188521289e-16 +// mean(f - f_Boost): 3.5249581031848718e-16 +// variance(f - f_Boost): 2.5029385557256515e-31 +// stddev(f - f_Boost): 5.0029376927217987e-16 const testcase_ellint_3<double> data050[10] = { { 0.0000000000000000, -0.50000000000000000, 0.90000000000000002, 0.0000000000000000 }, - { 0.17319040056865681, -0.50000000000000000, 0.90000000000000002, + { 0.17636918772384180, -0.50000000000000000, 0.90000000000000002, 0.17453292519943295 }, - { 0.33899920036578557, -0.50000000000000000, 0.90000000000000002, + { 0.36424950570740700, -0.50000000000000000, 0.90000000000000002, 0.34906585039886590 }, - { 0.49279362182695174, -0.50000000000000000, 0.90000000000000002, + { 0.57785404590231426, -0.50000000000000000, 0.90000000000000002, 0.52359877559829882 }, - { 0.63342123379746151, -0.50000000000000000, 0.90000000000000002, + { 0.83806480521716531, -0.50000000000000000, 0.90000000000000002, 0.69813170079773179 }, - { 0.76220595179550321, -0.50000000000000000, 0.90000000000000002, + { 1.1798568683069752, -0.50000000000000000, 0.90000000000000002, 0.87266462599716477 }, - { 0.88160004743532294, -0.50000000000000000, 0.90000000000000002, + { 1.6678766243739607, -0.50000000000000000, 0.90000000000000002, 1.0471975511965976 }, - { 0.99427448642310123, -0.50000000000000000, 0.90000000000000002, + { 2.4282976450693483, -0.50000000000000000, 0.90000000000000002, 1.2217304763960306 }, - { 1.1027091512470095, -0.50000000000000000, 0.90000000000000002, + { 3.6810787666126656, -0.50000000000000000, 0.90000000000000002, 1.3962634015954636 }, - { 1.2091116095504744, -0.50000000000000000, 0.90000000000000002, + { 5.5355132096026454, -0.50000000000000000, 0.90000000000000002, 1.5707963267948966 }, }; const double toler050 = 2.5000000000000020e-13; -// Test data for k=-0.40000000000000002, nu=0.0000000000000000. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 4.0617918857203532e-16 +// Test data for k=-0.39999999999999991, nu=0.0000000000000000. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.1423314994346225e-16 +// mean(f - f_Boost): 1.9428902930940238e-17 +// variance(f - f_Boost): 2.2263750157116445e-32 +// stddev(f - f_Boost): 1.4921042241450980e-16 const testcase_ellint_3<double> data051[10] = { - { 0.0000000000000000, -0.40000000000000002, 0.0000000000000000, + { 0.0000000000000000, -0.39999999999999991, 0.0000000000000000, 0.0000000000000000 }, - { 0.17467414669441528, -0.40000000000000002, 0.0000000000000000, + { 0.17467414669441528, -0.39999999999999991, 0.0000000000000000, 0.17453292519943295 }, - { 0.35018222772483443, -0.40000000000000002, 0.0000000000000000, + { 0.35018222772483443, -0.39999999999999991, 0.0000000000000000, 0.34906585039886590 }, - { 0.52729015917508737, -0.40000000000000002, 0.0000000000000000, + { 0.52729015917508748, -0.39999999999999991, 0.0000000000000000, 0.52359877559829882 }, - { 0.70662374407341244, -0.40000000000000002, 0.0000000000000000, + { 0.70662374407341244, -0.39999999999999991, 0.0000000000000000, 0.69813170079773179 }, - { 0.88859210497602170, -0.40000000000000002, 0.0000000000000000, + { 0.88859210497602159, -0.39999999999999991, 0.0000000000000000, 0.87266462599716477 }, - { 1.0733136290471379, -0.40000000000000002, 0.0000000000000000, + { 1.0733136290471381, -0.39999999999999991, 0.0000000000000000, 1.0471975511965976 }, - { 1.2605612170157061, -0.40000000000000002, 0.0000000000000000, + { 1.2605612170157066, -0.39999999999999991, 0.0000000000000000, 1.2217304763960306 }, - { 1.4497513956433439, -0.40000000000000002, 0.0000000000000000, + { 1.4497513956433439, -0.39999999999999991, 0.0000000000000000, 1.3962634015954636 }, - { 1.6399998658645112, -0.40000000000000002, 0.0000000000000000, + { 1.6399998658645112, -0.39999999999999991, 0.0000000000000000, 1.5707963267948966 }, }; const double toler051 = 2.5000000000000020e-13; -// Test data for k=-0.40000000000000002, nu=0.10000000000000001. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2644663257577874e-16 +// Test data for k=-0.39999999999999991, nu=0.10000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.8489340395463703e-16 +// mean(f - f_Boost): 6.3837823915946496e-17 +// variance(f - f_Boost): 4.4785242050000272e-32 +// stddev(f - f_Boost): 2.1162523963365114e-16 const testcase_ellint_3<double> data052[10] = { - { 0.0000000000000000, -0.40000000000000002, 0.10000000000000001, + { 0.0000000000000000, -0.39999999999999991, 0.10000000000000001, 0.0000000000000000 }, - { 0.17449806706684670, -0.40000000000000002, 0.10000000000000001, + { 0.17485086590796767, -0.39999999999999991, 0.10000000000000001, 0.17453292519943295 }, - { 0.34880048623856075, -0.40000000000000002, 0.10000000000000001, + { 0.35158366412506992, -0.39999999999999991, 0.10000000000000001, 0.34906585039886590 }, - { 0.52277322065757392, -0.40000000000000002, 0.10000000000000001, + { 0.53194731675711726, -0.39999999999999991, 0.10000000000000001, 0.52359877559829882 }, - { 0.69638072056918365, -0.40000000000000002, 0.10000000000000001, + { 0.71740615528010931, -0.39999999999999991, 0.10000000000000001, 0.69813170079773179 }, - { 0.86968426619831540, -0.40000000000000002, 0.10000000000000001, + { 0.90896157773487030, -0.39999999999999991, 0.10000000000000001, 0.87266462599716477 }, - { 1.0428044206578095, -0.40000000000000002, 0.10000000000000001, + { 1.1069605483834348, -0.39999999999999991, 0.10000000000000001, 1.0471975511965976 }, - { 1.2158651158274378, -0.40000000000000002, 0.10000000000000001, + { 1.3109353428823001, -0.39999999999999991, 0.10000000000000001, 1.2217304763960306 }, - { 1.3889447129893324, -0.40000000000000002, 0.10000000000000001, + { 1.5195460789903448, -0.39999999999999991, 0.10000000000000001, 1.3962634015954636 }, - { 1.5620566886683604, -0.40000000000000002, 0.10000000000000001, + { 1.7306968836847187, -0.39999999999999991, 0.10000000000000001, 1.5707963267948966 }, }; const double toler052 = 2.5000000000000020e-13; -// Test data for k=-0.40000000000000002, nu=0.20000000000000001. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 4.4583049464169287e-16 +// Test data for k=-0.39999999999999991, nu=0.20000000000000001. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.0467985583872730e-16 +// mean(f - f_Boost): 8.6042284408449634e-17 +// variance(f - f_Boost): 1.5826864298542218e-32 +// stddev(f - f_Boost): 1.2580486595733180e-16 const testcase_ellint_3<double> data053[10] = { - { 0.0000000000000000, -0.40000000000000002, 0.20000000000000001, + { 0.0000000000000000, -0.39999999999999991, 0.20000000000000001, 0.0000000000000000 }, - { 0.17432262290723397, -0.40000000000000002, 0.20000000000000001, + { 0.17502822886437389, -0.39999999999999991, 0.20000000000000001, 0.17453292519943295 }, - { 0.34743795258968596, -0.40000000000000002, 0.20000000000000001, + { 0.35300530062530805, -0.39999999999999991, 0.20000000000000001, 0.34906585039886590 }, - { 0.51838919472805101, -0.40000000000000002, 0.20000000000000001, + { 0.53675259548210896, -0.39999999999999991, 0.20000000000000001, 0.52359877559829882 }, - { 0.68663134739057907, -0.40000000000000002, 0.20000000000000001, + { 0.72878006428676934, -0.39999999999999991, 0.20000000000000001, 0.69813170079773179 }, - { 0.85206432981833979, -0.40000000000000002, 0.20000000000000001, + { 0.93100219010583563, -0.39999999999999991, 0.20000000000000001, 0.87266462599716477 }, - { 1.0149595349004430, -0.40000000000000002, 0.20000000000000001, + { 1.1443487271187609, -0.39999999999999991, 0.20000000000000001, 1.0471975511965976 }, - { 1.1758349405464676, -0.40000000000000002, 0.20000000000000001, + { 1.3683427764108813, -0.39999999999999991, 0.20000000000000001, 1.2217304763960306 }, - { 1.3353337673882637, -0.40000000000000002, 0.20000000000000001, + { 1.6008221459300933, -0.39999999999999991, 0.20000000000000001, 1.3962634015954636 }, - { 1.4941414344266770, -0.40000000000000002, 0.20000000000000001, + { 1.8380358826317627, -0.39999999999999991, 0.20000000000000001, 1.5707963267948966 }, }; const double toler053 = 2.5000000000000020e-13; -// Test data for k=-0.40000000000000002, nu=0.29999999999999999. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.1925080711125793e-16 +// Test data for k=-0.39999999999999991, nu=0.30000000000000004. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 2.9973414591826100e-16 +// mean(f - f_Boost): 8.6042284408449634e-17 +// variance(f - f_Boost): 1.5826864298542218e-32 +// stddev(f - f_Boost): 1.2580486595733180e-16 const testcase_ellint_3<double> data054[10] = { - { 0.0000000000000000, -0.40000000000000002, 0.29999999999999999, + { 0.0000000000000000, -0.39999999999999991, 0.30000000000000004, 0.0000000000000000 }, - { 0.17414781013591540, -0.40000000000000002, 0.29999999999999999, + { 0.17520623975982899, -0.39999999999999991, 0.30000000000000004, 0.17453292519943295 }, - { 0.34609415696777285, -0.40000000000000002, 0.29999999999999999, + { 0.35444766141612105, -0.39999999999999991, 0.30000000000000004, 0.34906585039886590 }, - { 0.51413131295862535, -0.40000000000000002, 0.29999999999999999, + { 0.54171455841536009, -0.39999999999999991, 0.30000000000000004, 0.52359877559829882 }, - { 0.67733527622935630, -0.40000000000000002, 0.29999999999999999, + { 0.74080517001084012, -0.39999999999999991, 0.30000000000000004, 0.69813170079773179 }, - { 0.83558675182733266, -0.40000000000000002, 0.29999999999999999, + { 0.95496950509296563, -0.39999999999999991, 0.30000000000000004, 0.87266462599716477 }, - { 0.98940140808865906, -0.40000000000000002, 0.29999999999999999, + { 1.1862627879844718, -0.39999999999999991, 0.30000000000000004, 1.0471975511965976 }, - { 1.1396968797728058, -0.40000000000000002, 0.29999999999999999, + { 1.4346501803799458, -0.39999999999999991, 0.30000000000000004, 1.2217304763960306 }, - { 1.2875920037865090, -0.40000000000000002, 0.29999999999999999, + { 1.6971744798077697, -0.39999999999999991, 0.30000000000000004, 1.3962634015954636 }, - { 1.4342789859950078, -0.40000000000000002, 0.29999999999999999, + { 1.9677924132520139, -0.39999999999999991, 0.30000000000000004, 1.5707963267948966 }, }; const double toler054 = 2.5000000000000020e-13; -// Test data for k=-0.40000000000000002, nu=0.40000000000000002. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 4.8235661108581362e-16 +// Test data for k=-0.39999999999999991, nu=0.40000000000000002. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.2577246923979600e-16 +// mean(f - f_Boost): 1.8596235662471373e-16 +// variance(f - f_Boost): 1.6222417021441306e-31 +// stddev(f - f_Boost): 4.0277061736727151e-16 const testcase_ellint_3<double> data055[10] = { - { 0.0000000000000000, -0.40000000000000002, 0.40000000000000002, + { 0.0000000000000000, -0.39999999999999991, 0.40000000000000002, 0.0000000000000000 }, - { 0.17397362471112707, -0.40000000000000002, 0.40000000000000002, + { 0.17538490283034375, -0.39999999999999991, 0.40000000000000002, 0.17453292519943295 }, - { 0.34476864603333196, -0.40000000000000002, 0.40000000000000002, + { 0.35591129064319948, -0.39999999999999991, 0.40000000000000002, 0.34906585039886590 }, - { 0.50999329415379346, -0.40000000000000002, 0.40000000000000002, + { 0.54684250413264535, -0.39999999999999991, 0.40000000000000002, 0.52359877559829882 }, - { 0.66845674551396006, -0.40000000000000002, 0.40000000000000002, + { 0.75355027742668290, -0.39999999999999991, 0.40000000000000002, 0.69813170079773179 }, - { 0.82012848346231748, -0.40000000000000002, 0.40000000000000002, + { 0.98117935026780634, -0.39999999999999991, 0.40000000000000002, 0.87266462599716477 }, - { 0.96582449258349057, -0.40000000000000002, 0.40000000000000002, + { 1.2337464222030734, -0.39999999999999991, 0.40000000000000002, 1.0471975511965976 }, - { 1.1068473749476286, -0.40000000000000002, 0.40000000000000002, + { 1.5125183419289221, -0.39999999999999991, 0.40000000000000002, 1.2217304763960306 }, - { 1.2447132729159989, -0.40000000000000002, 0.40000000000000002, + { 1.8140224451130311, -0.39999999999999991, 0.40000000000000002, 1.3962634015954636 }, - { 1.3809986210732901, -0.40000000000000002, 0.40000000000000002, + { 2.1289968719280026, -0.39999999999999991, 0.40000000000000002, 1.5707963267948966 }, }; const double toler055 = 2.5000000000000020e-13; -// Test data for k=-0.40000000000000002, nu=0.50000000000000000. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 4.9965792755639576e-16 +// Test data for k=-0.39999999999999991, nu=0.50000000000000000. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.8009196014748294e-16 +// mean(f - f_Boost): 1.6375789613221060e-16 +// variance(f - f_Boost): 6.4788283329186610e-32 +// stddev(f - f_Boost): 2.5453542647181080e-16 const testcase_ellint_3<double> data056[10] = { - { 0.0000000000000000, -0.40000000000000002, 0.50000000000000000, + { 0.0000000000000000, -0.39999999999999991, 0.50000000000000000, 0.0000000000000000 }, - { 0.17380006262854136, -0.40000000000000002, 0.50000000000000000, + { 0.17556422235224273, -0.39999999999999991, 0.50000000000000000, 0.17453292519943295 }, - { 0.34346098216756610, -0.40000000000000002, 0.50000000000000000, + { 0.35739675341763921, -0.39999999999999991, 0.50000000000000000, 0.34906585039886590 }, - { 0.50596929935059420, -0.40000000000000002, 0.50000000000000000, + { 0.55214655195037188, -0.39999999999999991, 0.50000000000000000, 0.52359877559829882 }, - { 0.65996392089131251, -0.40000000000000002, 0.50000000000000000, + { 0.76709520942047438, -0.39999999999999991, 0.50000000000000000, 0.69813170079773179 }, - { 0.80558463511364786, -0.40000000000000002, 0.50000000000000000, + { 1.0100278761577499, -0.39999999999999991, 0.50000000000000000, 0.87266462599716477 }, - { 0.94397834522857704, -0.40000000000000002, 0.50000000000000000, + { 1.2882265661384342, -0.39999999999999991, 0.50000000000000000, 1.0471975511965976 }, - { 1.0768075114108115, -0.40000000000000002, 0.50000000000000000, + { 1.6059059780051874, -0.39999999999999991, 0.50000000000000000, 1.2217304763960306 }, - { 1.2059184624251333, -0.40000000000000002, 0.50000000000000000, + { 1.9600182740224081, -0.39999999999999991, 0.50000000000000000, 1.3962634015954636 }, - { 1.3331797176377398, -0.40000000000000002, 0.50000000000000000, + { 2.3367461373176508, -0.39999999999999991, 0.50000000000000000, 1.5707963267948966 }, }; const double toler056 = 2.5000000000000020e-13; -// Test data for k=-0.40000000000000002, nu=0.59999999999999998. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 5.1640223038298069e-16 +// Test data for k=-0.39999999999999991, nu=0.60000000000000009. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 2.8411408870840790e-16 +// mean(f - f_Boost): 9.7144514654701197e-17 +// variance(f - f_Boost): 1.4860570558543486e-32 +// stddev(f - f_Boost): 1.2190393988113545e-16 const testcase_ellint_3<double> data057[10] = { - { 0.0000000000000000, -0.40000000000000002, 0.59999999999999998, + { 0.0000000000000000, -0.39999999999999991, 0.60000000000000009, 0.0000000000000000 }, - { 0.17362711992081245, -0.40000000000000002, 0.59999999999999998, + { 0.17574420264267029, -0.39999999999999991, 0.60000000000000009, 0.17453292519943295 }, - { 0.34217074276403953, -0.40000000000000002, 0.59999999999999998, + { 0.35890463689046265, -0.39999999999999991, 0.60000000000000009, 0.34906585039886590 }, - { 0.50205389185761606, -0.40000000000000002, 0.59999999999999998, + { 0.55763773975194486, -0.39999999999999991, 0.60000000000000009, 0.52359877559829882 }, - { 0.65182834920372734, -0.40000000000000002, 0.59999999999999998, + { 0.78153324227761267, -0.39999999999999991, 0.60000000000000009, 0.69813170079773179 }, - { 0.79186512820565136, -0.40000000000000002, 0.59999999999999998, + { 1.0420205885765887, -0.39999999999999991, 0.60000000000000009, 0.87266462599716477 }, - { 0.92365535916287134, -0.40000000000000002, 0.59999999999999998, + { 1.3517205230381770, -0.39999999999999991, 0.60000000000000009, 1.0471975511965976 }, - { 1.0491915663957907, -0.40000000000000002, 0.59999999999999998, + { 1.7210360970313896, -0.39999999999999991, 0.60000000000000009, 1.2217304763960306 }, - { 1.1705934291745106, -0.40000000000000002, 0.59999999999999998, + { 2.1500780510169242, -0.39999999999999991, 0.60000000000000009, 1.3962634015954636 }, - { 1.2899514672527024, -0.40000000000000002, 0.59999999999999998, + { 2.6186940209850191, -0.39999999999999991, 0.60000000000000009, 1.5707963267948966 }, }; const double toler057 = 2.5000000000000020e-13; -// Test data for k=-0.40000000000000002, nu=0.69999999999999996. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 5.3264047918332349e-16 +// Test data for k=-0.39999999999999991, nu=0.70000000000000007. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.1553900340611668e-16 +// mean(f - f_Boost): 1.1657341758564144e-16 +// variance(f - f_Boost): 1.3242789405258207e-32 +// stddev(f - f_Boost): 1.1507731924779187e-16 const testcase_ellint_3<double> data058[10] = { - { 0.0000000000000000, -0.40000000000000002, 0.69999999999999996, + { 0.0000000000000000, -0.39999999999999991, 0.70000000000000007, 0.0000000000000000 }, - { 0.17345479265712868, -0.40000000000000002, 0.69999999999999996, + { 0.17592484806010436, -0.39999999999999991, 0.70000000000000007, 0.17453292519943295 }, - { 0.34089751955950354, -0.40000000000000002, 0.69999999999999996, + { 0.36043555139631439, -0.39999999999999991, 0.70000000000000007, 0.34906585039886590 }, - { 0.49824200167361332, -0.40000000000000002, 0.69999999999999996, + { 0.56332813669944881, -0.39999999999999991, 0.70000000000000007, 0.52359877559829882 }, - { 0.64402450341199402, -0.40000000000000002, 0.69999999999999996, + { 0.79697424562157548, -0.39999999999999991, 0.70000000000000007, 0.69813170079773179 }, - { 0.77889207804122873, -0.40000000000000002, 0.69999999999999996, + { 1.0778155987523672, -0.39999999999999991, 0.70000000000000007, 0.87266462599716477 }, - { 0.90468169720957992, -0.40000000000000002, 0.69999999999999996, + { 1.4272018169896268, -0.39999999999999991, 0.70000000000000007, 1.0471975511965976 }, - { 1.0236847823692916, -0.40000000000000002, 0.69999999999999996, + { 1.8684377907453380, -0.39999999999999991, 0.70000000000000007, 1.2217304763960306 }, - { 1.1382465247425166, -0.40000000000000002, 0.69999999999999996, + { 2.4128677409207469, -0.39999999999999991, 0.70000000000000007, 1.3962634015954636 }, - { 1.2506255923253344, -0.40000000000000002, 0.69999999999999996, + { 3.0327078743873241, -0.39999999999999991, 0.70000000000000007, 1.5707963267948966 }, }; const double toler058 = 2.5000000000000020e-13; -// Test data for k=-0.40000000000000002, nu=0.80000000000000004. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 6.6611561645571024e-16 +// Test data for k=-0.39999999999999991, nu=0.80000000000000004. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.5727642219519274e-16 +// mean(f - f_Boost): 2.1926904736346843e-16 +// variance(f - f_Boost): 1.5293405480859847e-31 +// stddev(f - f_Boost): 3.9106783913868252e-16 const testcase_ellint_3<double> data059[10] = { - { 0.0000000000000000, -0.40000000000000002, 0.80000000000000004, + { 0.0000000000000000, -0.39999999999999991, 0.80000000000000004, 0.0000000000000000 }, - { 0.17328307694277154, -0.40000000000000002, 0.80000000000000004, + { 0.17610616300487833, -0.39999999999999991, 0.80000000000000004, 0.17453292519943295 }, - { 0.33964091800132007, -0.40000000000000002, 0.80000000000000004, + { 0.36199013167171978, -0.39999999999999991, 0.80000000000000004, 0.34906585039886590 }, - { 0.49452889372467440, -0.40000000000000002, 0.80000000000000004, + { 0.56923097361842423, -0.39999999999999991, 0.80000000000000004, 0.52359877559829882 }, - { 0.63652940095937316, -0.40000000000000002, 0.80000000000000004, + { 0.81354878456624347, -0.39999999999999991, 0.80000000000000004, 0.69813170079773179 }, - { 0.76659772511159097, -0.40000000000000002, 0.80000000000000004, + { 1.1182902719261825, -0.39999999999999991, 0.80000000000000004, 0.87266462599716477 }, - { 0.88691047977338111, -0.40000000000000002, 0.80000000000000004, + { 1.5192950589409022, -0.39999999999999991, 0.80000000000000004, 1.0471975511965976 }, - { 1.0000273200611638, -0.40000000000000002, 0.80000000000000004, + { 2.0678761710223981, -0.39999999999999991, 0.80000000000000004, 1.2217304763960306 }, - { 1.1084787902188009, -0.40000000000000002, 0.80000000000000004, + { 2.8135222249879783, -0.39999999999999991, 0.80000000000000004, 1.3962634015954636 }, - { 1.2146499565727209, -0.40000000000000002, 0.80000000000000004, + { 3.7289548002199902, -0.39999999999999991, 0.80000000000000004, 1.5707963267948966 }, }; const double toler059 = 2.5000000000000020e-13; -// Test data for k=-0.40000000000000002, nu=0.90000000000000002. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 5.6376730823308004e-16 +// Test data for k=-0.39999999999999991, nu=0.90000000000000002. +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.0221626338023938e-16 +// mean(f - f_Boost): 4.1910919179599658e-16 +// variance(f - f_Boost): 6.2246150910247033e-31 +// stddev(f - f_Boost): 7.8896229891070860e-16 const testcase_ellint_3<double> data060[10] = { - { 0.0000000000000000, -0.40000000000000002, 0.90000000000000002, + { 0.0000000000000000, -0.39999999999999991, 0.90000000000000002, 0.0000000000000000 }, - { 0.17311196891868127, -0.40000000000000002, 0.90000000000000002, + { 0.17628815191971123, -0.39999999999999991, 0.90000000000000002, 0.17453292519943295 }, - { 0.33840055664911906, -0.40000000000000002, 0.90000000000000002, + { 0.36356903815378772, -0.39999999999999991, 0.90000000000000002, 0.34906585039886590 }, - { 0.49091013944075329, -0.40000000000000002, 0.90000000000000002, + { 0.57536079447000310, -0.39999999999999991, 0.90000000000000002, 0.52359877559829882 }, - { 0.62932228186809580, -0.40000000000000002, 0.90000000000000002, + { 0.83141355850172571, -0.39999999999999991, 0.90000000000000002, 0.69813170079773179 }, - { 0.75492278323019801, -0.40000000000000002, 0.90000000000000002, + { 1.1646481598721361, -0.39999999999999991, 0.90000000000000002, 0.87266462599716477 }, - { 0.87021659043854294, -0.40000000000000002, 0.90000000000000002, + { 1.6357275034001995, -0.39999999999999991, 0.90000000000000002, 1.0471975511965976 }, - { 0.97800245228239246, -0.40000000000000002, 0.90000000000000002, + { 2.3628787566572398, -0.39999999999999991, 0.90000000000000002, 1.2217304763960306 }, - { 1.0809625773173697, -0.40000000000000002, 0.90000000000000002, + { 3.5521010369134958, -0.39999999999999991, 0.90000000000000002, 1.3962634015954636 }, - { 1.1815758115929846, -0.40000000000000002, 0.90000000000000002, + { 5.3055535102872513, -0.39999999999999991, 0.90000000000000002, 1.5707963267948966 }, }; const double toler060 = 2.5000000000000020e-13; -// Test data for k=-0.30000000000000004, nu=0.0000000000000000. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.3361874537309281e-16 +// Test data for k=-0.29999999999999993, nu=0.0000000000000000. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.2241249691539529e-16 +// mean(f - f_Boost): 4.9960036108132046e-17 +// variance(f - f_Boost): 4.6872855002064458e-32 +// stddev(f - f_Boost): 2.1650139722889657e-16 const testcase_ellint_3<double> data061[10] = { - { 0.0000000000000000, -0.30000000000000004, 0.0000000000000000, + { 0.0000000000000000, -0.29999999999999993, 0.0000000000000000, 0.0000000000000000 }, - { 0.17461228653000099, -0.30000000000000004, 0.0000000000000000, + { 0.17461228653000099, -0.29999999999999993, 0.0000000000000000, 0.17453292519943295 }, - { 0.34969146102798415, -0.30000000000000004, 0.0000000000000000, + { 0.34969146102798421, -0.29999999999999993, 0.0000000000000000, 0.34906585039886590 }, - { 0.52565822873726320, -0.30000000000000004, 0.0000000000000000, + { 0.52565822873726309, -0.29999999999999993, 0.0000000000000000, 0.52359877559829882 }, - { 0.70284226512408532, -0.30000000000000004, 0.0000000000000000, + { 0.70284226512408543, -0.29999999999999993, 0.0000000000000000, 0.69813170079773179 }, - { 0.88144139195111182, -0.30000000000000004, 0.0000000000000000, + { 0.88144139195111171, -0.29999999999999993, 0.0000000000000000, 0.87266462599716477 }, - { 1.0614897067260520, -0.30000000000000004, 0.0000000000000000, + { 1.0614897067260520, -0.29999999999999993, 0.0000000000000000, 1.0471975511965976 }, - { 1.2428416824174218, -0.30000000000000004, 0.0000000000000000, + { 1.2428416824174220, -0.29999999999999993, 0.0000000000000000, 1.2217304763960306 }, - { 1.4251795877015927, -0.30000000000000004, 0.0000000000000000, + { 1.4251795877015929, -0.29999999999999993, 0.0000000000000000, 1.3962634015954636 }, - { 1.6080486199305128, -0.30000000000000004, 0.0000000000000000, + { 1.6080486199305126, -0.29999999999999993, 0.0000000000000000, 1.5707963267948966 }, }; const double toler061 = 2.5000000000000020e-13; -// Test data for k=-0.30000000000000004, nu=0.10000000000000001. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.3908043711907203e-16 +// Test data for k=-0.29999999999999993, nu=0.10000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.1872304407982844e-16 +// mean(f - f_Boost): 9.4368957093138303e-17 +// variance(f - f_Boost): 4.0359883022230488e-32 +// stddev(f - f_Boost): 2.0089769292411121e-16 const testcase_ellint_3<double> data062[10] = { - { 0.0000000000000000, -0.30000000000000004, 0.10000000000000001, + { 0.0000000000000000, -0.29999999999999993, 0.10000000000000001, 0.0000000000000000 }, - { 0.17443631884814376, -0.30000000000000004, 0.10000000000000001, + { 0.17478889331392972, -0.29999999999999993, 0.10000000000000001, 0.17453292519943295 }, - { 0.34831316835124926, -0.30000000000000004, 0.10000000000000001, + { 0.35108939018329183, -0.29999999999999993, 0.10000000000000001, 0.34906585039886590 }, - { 0.52116586276523857, -0.30000000000000004, 0.10000000000000001, + { 0.53028990896115835, -0.29999999999999993, 0.10000000000000001, 0.52359877559829882 }, - { 0.69269385837910036, -0.30000000000000004, 0.10000000000000001, + { 0.71352417052371409, -0.29999999999999993, 0.10000000000000001, 0.69813170079773179 }, - { 0.86279023163070856, -0.30000000000000004, 0.10000000000000001, + { 0.90153086032405894, -0.29999999999999993, 0.10000000000000001, 0.87266462599716477 }, - { 1.0315321461438263, -0.30000000000000004, 0.10000000000000001, + { 1.0945187977283313, -0.29999999999999993, 0.10000000000000001, 1.0471975511965976 }, - { 1.1991449111869024, -0.30000000000000004, 0.10000000000000001, + { 1.2920699268385680, -0.29999999999999993, 0.10000000000000001, 1.2217304763960306 }, - { 1.3659561780923213, -0.30000000000000004, 0.10000000000000001, + { 1.4931243665896394, -0.29999999999999993, 0.10000000000000001, 1.3962634015954636 }, - { 1.5323534693557528, -0.30000000000000004, 0.10000000000000001, + { 1.6960848815118226, -0.29999999999999993, 0.10000000000000001, 1.5707963267948966 }, }; const double toler062 = 2.5000000000000020e-13; -// Test data for k=-0.30000000000000004, nu=0.20000000000000001. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.4447238179454079e-16 +// Test data for k=-0.29999999999999993, nu=0.20000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.2247497610332889e-16 +// mean(f - f_Boost): 1.1102230246251565e-16 +// variance(f - f_Boost): 3.8043060629871325e-32 +// stddev(f - f_Boost): 1.9504630380981672e-16 const testcase_ellint_3<double> data063[10] = { - { 0.0000000000000000, -0.30000000000000004, 0.20000000000000001, + { 0.0000000000000000, -0.29999999999999993, 0.20000000000000001, 0.0000000000000000 }, - { 0.17426098615372088, -0.30000000000000004, 0.20000000000000001, + { 0.17496614335337535, -0.29999999999999993, 0.20000000000000001, 0.17453292519943295 }, - { 0.34695402664689923, -0.30000000000000004, 0.20000000000000001, + { 0.35250745937139372, -0.29999999999999993, 0.20000000000000001, 0.34906585039886590 }, - { 0.51680555567038933, -0.30000000000000004, 0.20000000000000001, + { 0.53506875002836884, -0.29999999999999993, 0.20000000000000001, 0.52359877559829882 }, - { 0.68303375225260210, -0.30000000000000004, 0.20000000000000001, + { 0.72479106622248191, -0.29999999999999993, 0.20000000000000001, 0.69813170079773179 }, - { 0.84540662891295026, -0.30000000000000004, 0.20000000000000001, + { 0.92326451535891607, -0.29999999999999993, 0.20000000000000001, 0.87266462599716477 }, - { 1.0041834051646927, -0.30000000000000004, 0.20000000000000001, + { 1.1312092060698349, -0.29999999999999993, 0.20000000000000001, 1.0471975511965976 }, - { 1.1599952702345711, -0.30000000000000004, 0.20000000000000001, + { 1.3481473154592321, -0.29999999999999993, 0.20000000000000001, 1.2217304763960306 }, - { 1.3137179520499165, -0.30000000000000004, 0.20000000000000001, + { 1.5722049569662748, -0.29999999999999993, 0.20000000000000001, 1.3962634015954636 }, - { 1.4663658145259877, -0.30000000000000004, 0.20000000000000001, + { 1.8002173372290498, -0.29999999999999993, 0.20000000000000001, 1.5707963267948966 }, }; const double toler063 = 2.5000000000000020e-13; -// Test data for k=-0.30000000000000004, nu=0.29999999999999999. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.4979715256503266e-16 +// Test data for k=-0.29999999999999993, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.1678685180047551e-16 +// mean(f - f_Boost): 1.0547118733938987e-16 +// variance(f - f_Boost): 7.5633408838247182e-32 +// stddev(f - f_Boost): 2.7501528837184157e-16 const testcase_ellint_3<double> data064[10] = { - { 0.0000000000000000, -0.30000000000000004, 0.29999999999999999, + { 0.0000000000000000, -0.29999999999999993, 0.30000000000000004, 0.0000000000000000 }, - { 0.17408628437042842, -0.30000000000000004, 0.29999999999999999, + { 0.17514404084107435, -0.29999999999999993, 0.30000000000000004, 0.17453292519943295 }, - { 0.34561356761638401, -0.30000000000000004, 0.29999999999999999, + { 0.35394619108645647, -0.29999999999999993, 0.30000000000000004, 0.34906585039886590 }, - { 0.51257058617875850, -0.30000000000000004, 0.29999999999999999, + { 0.54000325463372689, -0.29999999999999993, 0.30000000000000004, 0.52359877559829882 }, - { 0.67382207124602878, -0.30000000000000004, 0.29999999999999999, + { 0.73670193794067651, -0.29999999999999993, 0.30000000000000004, 0.69813170079773179 }, - { 0.82914751587825131, -0.30000000000000004, 0.29999999999999999, + { 0.94689345491722177, -0.29999999999999993, 0.30000000000000004, 0.87266462599716477 }, - { 0.97907434814374938, -0.30000000000000004, 0.29999999999999999, + { 1.1723274608389140, -0.29999999999999993, 0.30000000000000004, 1.0471975511965976 }, - { 1.1246399297351584, -0.30000000000000004, 0.29999999999999999, + { 1.4128880552936287, -0.29999999999999993, 0.30000000000000004, 1.2217304763960306 }, - { 1.2671793970398149, -0.30000000000000004, 0.29999999999999999, + { 1.6659010047449661, -0.29999999999999993, 0.30000000000000004, 1.3962634015954636 }, - { 1.4081767433479091, -0.30000000000000004, 0.29999999999999999, + { 1.9260216862473254, -0.29999999999999993, 0.30000000000000004, 1.5707963267948966 }, }; const double toler064 = 2.5000000000000020e-13; -// Test data for k=-0.30000000000000004, nu=0.40000000000000002. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.5505716921759864e-16 +// Test data for k=-0.29999999999999993, nu=0.40000000000000002. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.3983279132797385e-16 +// mean(f - f_Boost): 1.1657341758564144e-16 +// variance(f - f_Boost): 1.8245832308692586e-31 +// stddev(f - f_Boost): 4.2715140534349863e-16 const testcase_ellint_3<double> data065[10] = { - { 0.0000000000000000, -0.30000000000000004, 0.40000000000000002, + { 0.0000000000000000, -0.29999999999999993, 0.40000000000000002, 0.0000000000000000 }, - { 0.17391220945982727, -0.30000000000000004, 0.40000000000000002, + { 0.17532259000954434, -0.29999999999999993, 0.40000000000000002, 0.17453292519943295 }, - { 0.34429133937639689, -0.30000000000000004, 0.40000000000000002, + { 0.35540612770983693, -0.29999999999999993, 0.40000000000000002, 0.34906585039886590 }, - { 0.50845471668581632, -0.30000000000000004, 0.40000000000000002, + { 0.54510265552938919, -0.29999999999999993, 0.40000000000000002, 0.52359877559829882 }, - { 0.66502347027873854, -0.30000000000000004, 0.40000000000000002, + { 0.74932476310965057, -0.29999999999999993, 0.40000000000000002, 0.69813170079773179 }, - { 0.81389191978012254, -0.30000000000000004, 0.40000000000000002, + { 0.97272793583093109, -0.29999999999999993, 0.40000000000000002, 0.87266462599716477 }, - { 0.95590618002140570, -0.30000000000000004, 0.40000000000000002, + { 1.2188928987074241, -0.29999999999999993, 0.40000000000000002, 1.0471975511965976 }, - { 1.0924915195213121, -0.30000000000000004, 0.40000000000000002, + { 1.4888771674085941, -0.29999999999999993, 0.40000000000000002, 1.2217304763960306 }, - { 1.2253651604038061, -0.30000000000000004, 0.40000000000000002, + { 1.7794558498219191, -0.29999999999999993, 0.40000000000000002, 1.3962634015954636 }, - { 1.3563643538969763, -0.30000000000000004, 0.40000000000000002, + { 2.0822121773175528, -0.29999999999999993, 0.40000000000000002, 1.5707963267948966 }, }; const double toler065 = 2.5000000000000020e-13; -// Test data for k=-0.30000000000000004, nu=0.50000000000000000. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.7807908859023716e-16 +// Test data for k=-0.29999999999999993, nu=0.50000000000000000. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.0516138451673425e-16 +// mean(f - f_Boost): 4.7184478546569152e-17 +// variance(f - f_Boost): 1.9448563670505968e-32 +// stddev(f - f_Boost): 1.3945810722401896e-16 const testcase_ellint_3<double> data066[10] = { - { 0.0000000000000000, -0.30000000000000004, 0.50000000000000000, + { 0.0000000000000000, -0.29999999999999993, 0.50000000000000000, 0.0000000000000000 }, - { 0.17373875742088232, -0.30000000000000004, 0.50000000000000000, + { 0.17550179513158179, -0.29999999999999993, 0.50000000000000000, 0.17453292519943295 }, - { 0.34298690571124157, -0.30000000000000004, 0.50000000000000000, + { 0.35688783251681200, -0.29999999999999993, 0.50000000000000000, 0.34906585039886590 }, - { 0.50445214859646936, -0.30000000000000004, 0.50000000000000000, + { 0.55037700010142798, -0.29999999999999993, 0.50000000000000000, 0.52359877559829882 }, - { 0.65660648352418516, -0.30000000000000004, 0.50000000000000000, + { 0.76273839789895992, -0.29999999999999993, 0.50000000000000000, 0.69813170079773179 }, - { 0.79953670639287289, -0.30000000000000004, 0.50000000000000000, + { 1.0011570518830419, -0.29999999999999993, 0.50000000000000000, 0.87266462599716477 }, - { 0.93443393926588536, -0.30000000000000004, 0.50000000000000000, + { 1.2722987414055109, -0.29999999999999993, 0.50000000000000000, 1.0471975511965976 }, - { 1.0630838369016911, -0.30000000000000004, 0.50000000000000000, + { 1.5799590511080066, -0.29999999999999993, 0.50000000000000000, 1.2217304763960306 }, - { 1.1875197325653029, -0.30000000000000004, 0.50000000000000000, + { 1.9212367220124293, -0.29999999999999993, 0.50000000000000000, 1.3962634015954636 }, - { 1.3098448759814962, -0.30000000000000004, 0.50000000000000000, + { 2.2833505881933971, -0.29999999999999993, 0.50000000000000000, 1.5707963267948966 }, }; const double toler066 = 2.5000000000000020e-13; -// Test data for k=-0.30000000000000004, nu=0.59999999999999998. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 7.0057999499931649e-16 +// Test data for k=-0.29999999999999993, nu=0.60000000000000009. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.2121157428443725e-16 +// mean(f - f_Boost): 1.9428902930940239e-16 +// variance(f - f_Boost): 1.5987596229703424e-31 +// stddev(f - f_Boost): 3.9984492281012430e-16 const testcase_ellint_3<double> data067[10] = { - { 0.0000000000000000, -0.30000000000000004, 0.59999999999999998, + { 0.0000000000000000, -0.29999999999999993, 0.60000000000000009, 0.0000000000000000 }, - { 0.17356592428950823, -0.30000000000000004, 0.59999999999999998, + { 0.17568166052076745, -0.29999999999999993, 0.60000000000000009, 0.17453292519943295 }, - { 0.34169984536697379, -0.30000000000000004, 0.59999999999999998, + { 0.35839189074731181, -0.29999999999999993, 0.60000000000000009, 0.34906585039886590 }, - { 0.50055748266498457, -0.30000000000000004, 0.59999999999999998, + { 0.55583724744367558, -0.29999999999999993, 0.60000000000000009, 0.52359877559829882 }, - { 0.64854298527106768, -0.30000000000000004, 0.59999999999999998, + { 0.77703498090888223, -0.29999999999999993, 0.60000000000000009, 0.69813170079773179 }, - { 0.78599329284207431, -0.30000000000000004, 0.59999999999999998, + { 1.0326772113675962, -0.29999999999999993, 0.60000000000000009, 0.87266462599716477 }, - { 0.91445452089128199, -0.30000000000000004, 0.59999999999999998, + { 1.3345139983717369, -0.29999999999999993, 0.60000000000000009, 1.0471975511965976 }, - { 1.0360412952290587, -0.30000000000000004, 0.59999999999999998, + { 1.6921742922838403, -0.29999999999999993, 0.60000000000000009, 1.2217304763960306 }, - { 1.1530473919778641, -0.30000000000000004, 0.59999999999999998, + { 2.1056608968472186, -0.29999999999999993, 0.60000000000000009, 1.3962634015954636 }, - { 1.2677758800420669, -0.30000000000000004, 0.59999999999999998, + { 2.5560975528589061, -0.29999999999999993, 0.60000000000000009, 1.5707963267948966 }, }; const double toler067 = 2.5000000000000020e-13; -// Test data for k=-0.30000000000000004, nu=0.69999999999999996. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 7.2239502844122443e-16 +// Test data for k=-0.29999999999999993, nu=0.70000000000000007. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.0088945789059381e-16 +// mean(f - f_Boost): 1.6653345369377348e-16 +// variance(f - f_Boost): 3.1994213989721786e-31 +// stddev(f - f_Boost): 5.6563428104846852e-16 const testcase_ellint_3<double> data068[10] = { - { 0.0000000000000000, -0.30000000000000004, 0.69999999999999996, + { 0.0000000000000000, -0.29999999999999993, 0.70000000000000007, 0.0000000000000000 }, - { 0.17339370613812224, -0.30000000000000004, 0.69999999999999996, + { 0.17586219053197988, -0.29999999999999993, 0.70000000000000007, 0.17453292519943295 }, - { 0.34042975138455933, -0.30000000000000004, 0.69999999999999996, + { 0.35991891074557669, -0.29999999999999993, 0.70000000000000007, 0.34906585039886590 }, - { 0.49676568368075985, -0.30000000000000004, 0.69999999999999996, + { 0.56149538019961731, -0.29999999999999993, 0.70000000000000007, 0.52359877559829882 }, - { 0.64080774055753720, -0.30000000000000004, 0.69999999999999996, + { 0.79232303189667685, -0.29999999999999993, 0.70000000000000007, 0.69813170079773179 }, - { 0.77318507779667278, -0.30000000000000004, 0.69999999999999996, + { 1.0679345542878826, -0.29999999999999993, 0.70000000000000007, 0.87266462599716477 }, - { 0.89579782346548609, -0.30000000000000004, 0.69999999999999996, + { 1.4084400085913955, -0.29999999999999993, 0.70000000000000007, 1.0471975511965976 }, - { 1.0110573286052202, -0.30000000000000004, 0.69999999999999996, + { 1.8357382859296454, -0.29999999999999993, 0.70000000000000007, 1.2217304763960306 }, - { 1.1214710972949635, -0.30000000000000004, 0.69999999999999996, + { 2.3604197996171519, -0.29999999999999993, 0.70000000000000007, 1.3962634015954636 }, - { 1.2294913236274982, -0.30000000000000004, 0.69999999999999996, + { 2.9562123549913872, -0.29999999999999993, 0.70000000000000007, 1.5707963267948966 }, }; const double toler068 = 2.5000000000000020e-13; -// Test data for k=-0.30000000000000004, nu=0.80000000000000004. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 7.4358357000101250e-16 +// Test data for k=-0.29999999999999993, nu=0.80000000000000004. +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.1197887707781618e-16 +// mean(f - f_Boost): 3.4416913763379854e-16 +// variance(f - f_Boost): 4.3461914185990199e-31 +// stddev(f - f_Boost): 6.5925650687718054e-16 const testcase_ellint_3<double> data069[10] = { - { 0.0000000000000000, -0.30000000000000004, 0.80000000000000004, + { 0.0000000000000000, -0.29999999999999993, 0.80000000000000004, 0.0000000000000000 }, - { 0.17322209907520358, -0.30000000000000004, 0.80000000000000004, + { 0.17604338956191670, -0.29999999999999993, 0.80000000000000004, 0.17453292519943295 }, - { 0.33917623046949996, -0.30000000000000004, 0.80000000000000004, + { 0.36146952517410791, -0.29999999999999993, 0.80000000000000004, 0.34906585039886590 }, - { 0.49307204894329176, -0.30000000000000004, 0.80000000000000004, + { 0.56736453393774644, -0.29999999999999993, 0.80000000000000004, 0.52359877559829882 }, - { 0.63337802830291734, -0.30000000000000004, 0.80000000000000004, + { 0.80873149979001091, -0.29999999999999993, 0.80000000000000004, 0.69813170079773179 }, - { 0.76104540997689407, -0.30000000000000004, 0.80000000000000004, + { 1.1077903069860620, -0.29999999999999993, 0.80000000000000004, 0.87266462599716477 }, - { 0.87832009635450714, -0.30000000000000004, 0.80000000000000004, + { 1.4985874311132998, -0.29999999999999993, 0.80000000000000004, 1.0471975511965976 }, - { 0.98787879723171790, -0.30000000000000004, 0.80000000000000004, + { 2.0298167266724954, -0.29999999999999993, 0.80000000000000004, 1.2217304763960306 }, - { 1.0924036340069339, -0.30000000000000004, 0.80000000000000004, + { 2.7483929054985432, -0.29999999999999993, 0.80000000000000004, 1.3962634015954636 }, - { 1.1944567571590048, -0.30000000000000004, 0.80000000000000004, + { 3.6283050484567170, -0.29999999999999993, 0.80000000000000004, 1.5707963267948966 }, }; const double toler069 = 2.5000000000000020e-13; -// Test data for k=-0.30000000000000004, nu=0.90000000000000002. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 7.6419688299804087e-16 +// Test data for k=-0.29999999999999993, nu=0.90000000000000002. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 5.1301806687926828e-16 +// mean(f - f_Boost): 4.1633363423443370e-16 +// variance(f - f_Boost): 2.2835347143080263e-31 +// stddev(f - f_Boost): 4.7786344433405093e-16 const testcase_ellint_3<double> data070[10] = { - { 0.0000000000000000, -0.30000000000000004, 0.90000000000000002, + { 0.0000000000000000, -0.29999999999999993, 0.90000000000000002, 0.0000000000000000 }, - { 0.17305109924485945, -0.30000000000000004, 0.90000000000000002, + { 0.17622526204962433, -0.29999999999999993, 0.90000000000000002, 0.17453292519943295 }, - { 0.33793890239556984, -0.30000000000000004, 0.90000000000000002, + { 0.36304439230777141, -0.29999999999999993, 0.90000000000000002, 0.34906585039886590 }, - { 0.48947218005089738, -0.30000000000000004, 0.90000000000000002, + { 0.57345914744719195, -0.29999999999999993, 0.90000000000000002, 0.52359877559829882 }, - { 0.62623332340775151, -0.30000000000000004, 0.90000000000000002, + { 0.82641512928845162, -0.29999999999999993, 0.90000000000000002, 0.69813170079773179 }, - { 0.74951596581511148, -0.30000000000000004, 0.90000000000000002, + { 1.1534256210757743, -0.29999999999999993, 0.90000000000000002, 0.87266462599716477 }, - { 0.86189886597755994, -0.30000000000000004, 0.90000000000000002, + { 1.6124900353411677, -0.29999999999999993, 0.90000000000000002, 1.0471975511965976 }, - { 0.96629451153092005, -0.30000000000000004, 0.90000000000000002, + { 2.3165905514845089, -0.29999999999999993, 0.90000000000000002, 1.2217304763960306 }, - { 1.0655269133492682, -0.30000000000000004, 0.90000000000000002, + { 3.4625619526539824, -0.29999999999999993, 0.90000000000000002, 1.3962634015954636 }, - { 1.1622376896064914, -0.30000000000000004, 0.90000000000000002, + { 5.1479514944016787, -0.29999999999999993, 0.90000000000000002, 1.5707963267948966 }, }; const double toler070 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.0000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2156475739151676e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 4.2156475739151676e-16 +// mean(f - f_Boost): -5.2735593669694933e-17 +// variance(f - f_Boost): 3.0473442641042680e-32 +// stddev(f - f_Boost): 1.7456644190978597e-16 const testcase_ellint_3<double> data071[10] = { { 0.0000000000000000, -0.19999999999999996, 0.0000000000000000, 0.0000000000000000 }, - { 0.17456817290292809, -0.19999999999999996, 0.0000000000000000, + { 0.17456817290292806, -0.19999999999999996, 0.0000000000000000, 0.17453292519943295 }, - { 0.34934315932086801, -0.19999999999999996, 0.0000000000000000, + { 0.34934315932086796, -0.19999999999999996, 0.0000000000000000, 0.34906585039886590 }, { 0.52450880529443988, -0.19999999999999996, 0.0000000000000000, 0.52359877559829882 }, - { 0.70020491009844876, -0.19999999999999996, 0.0000000000000000, + { 0.70020491009844887, -0.19999999999999996, 0.0000000000000000, 0.69813170079773179 }, - { 0.87651006649967955, -0.19999999999999996, 0.0000000000000000, + { 0.87651006649967977, -0.19999999999999996, 0.0000000000000000, 0.87266462599716477 }, { 1.0534305870298994, -0.19999999999999996, 0.0000000000000000, 1.0471975511965976 }, - { 1.2308975521670784, -0.19999999999999996, 0.0000000000000000, + { 1.2308975521670789, -0.19999999999999996, 0.0000000000000000, 1.2217304763960306 }, { 1.4087733584990738, -0.19999999999999996, 0.0000000000000000, 1.3962634015954636 }, - { 1.5868678474541660, -0.19999999999999996, 0.0000000000000000, + { 1.5868678474541662, -0.19999999999999996, 0.0000000000000000, 1.5707963267948966 }, }; const double toler071 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.10000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.3374593253183472e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 4.0890622182605400e-16 +// mean(f - f_Boost): -3.8857805861880476e-17 +// variance(f - f_Boost): 2.8794792590749608e-32 +// stddev(f - f_Boost): 1.6969028431454054e-16 const testcase_ellint_3<double> data072[10] = { { 0.0000000000000000, -0.19999999999999996, 0.10000000000000001, 0.0000000000000000 }, - { 0.17439228502691748, -0.19999999999999996, 0.10000000000000001, + { 0.17474469953608965, -0.19999999999999996, 0.10000000000000001, 0.17453292519943295 }, - { 0.34796731137565740, -0.19999999999999996, 0.10000000000000001, + { 0.35073860234984255, -0.19999999999999996, 0.10000000000000001, 0.34906585039886590 }, - { 0.52003370294544848, -0.19999999999999996, 0.10000000000000001, + { 0.52912258712951521, -0.19999999999999996, 0.10000000000000001, 0.52359877559829882 }, - { 0.69012222258631462, -0.19999999999999996, 0.10000000000000001, + { 0.71081701558898069, -0.19999999999999996, 0.10000000000000001, 0.69813170079773179 }, - { 0.85803491465566772, -0.19999999999999996, 0.10000000000000001, + { 0.89640758521169384, -0.19999999999999996, 0.10000000000000001, 0.87266462599716477 }, - { 1.0238463961099364, -0.19999999999999996, 0.10000000000000001, + { 1.0860417038089853, -0.19999999999999996, 0.10000000000000001, 1.0471975511965976 }, - { 1.1878691059202153, -0.19999999999999996, 0.10000000000000001, + { 1.2793599255528623, -0.19999999999999996, 0.10000000000000001, 1.2217304763960306 }, - { 1.3505985031831940, -0.19999999999999996, 0.10000000000000001, + { 1.4754938544089076, -0.19999999999999996, 0.10000000000000001, 1.3962634015954636 }, - { 1.5126513474261087, -0.19999999999999996, 0.10000000000000001, + { 1.6731552050562593, -0.19999999999999996, 0.10000000000000001, 1.5707963267948966 }, }; const double toler072 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.20000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.4549984059502760e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 3.9570963716579749e-16 +// mean(f - f_Boost): -5.8286708792820721e-17 +// variance(f - f_Boost): 3.1158217732380362e-32 +// stddev(f - f_Boost): 1.7651690494788412e-16 const testcase_ellint_3<double> data073[10] = { { 0.0000000000000000, -0.19999999999999996, 0.20000000000000001, 0.0000000000000000 }, - { 0.17421703179583747, -0.19999999999999996, 0.20000000000000001, + { 0.17492186907740698, -0.19999999999999996, 0.20000000000000001, 0.17453292519943295 }, - { 0.34661057411998791, -0.19999999999999996, 0.20000000000000001, + { 0.35215414286134267, -0.19999999999999996, 0.20000000000000001, 0.34906585039886590 }, - { 0.51569006052647393, -0.19999999999999996, 0.20000000000000001, + { 0.53388285615182440, -0.19999999999999996, 0.20000000000000001, 0.52359877559829882 }, - { 0.68052412821107244, -0.19999999999999996, 0.20000000000000001, + { 0.72200960282688265, -0.19999999999999996, 0.20000000000000001, 0.69813170079773179 }, - { 0.84081341263313825, -0.19999999999999996, 0.20000000000000001, + { 0.91793087614428526, -0.19999999999999996, 0.20000000000000001, 0.87266462599716477 }, - { 0.99683359988842890, -0.19999999999999996, 0.20000000000000001, + { 1.1222602841587976, -0.19999999999999996, 0.20000000000000001, 1.0471975511965976 }, - { 1.1493086715118852, -0.19999999999999996, 0.20000000000000001, + { 1.3345489407496247, -0.19999999999999996, 0.20000000000000001, 1.2217304763960306 }, - { 1.2992699693957541, -0.19999999999999996, 0.20000000000000001, + { 1.5531225705475502, -0.19999999999999996, 0.20000000000000001, 1.3962634015954636 }, - { 1.4479323932249564, -0.19999999999999996, 0.20000000000000001, + { 1.7751816279738935, -0.19999999999999996, 0.20000000000000001, 1.5707963267948966 }, }; const double toler073 = 2.5000000000000020e-13; -// Test data for k=-0.19999999999999996, nu=0.29999999999999999. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 5.3140668101543467e-16 +// Test data for k=-0.19999999999999996, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.6785817924053817e-16 +// mean(f - f_Boost): -1.1102230246251566e-17 +// variance(f - f_Boost): 9.9840208317034302e-32 +// stddev(f - f_Boost): 3.1597501217190311e-16 const testcase_ellint_3<double> data074[10] = { - { 0.0000000000000000, -0.19999999999999996, 0.29999999999999999, + { 0.0000000000000000, -0.19999999999999996, 0.30000000000000004, 0.0000000000000000 }, - { 0.17404240913577704, -0.19999999999999996, 0.29999999999999999, + { 0.17509968571715159, -0.19999999999999996, 0.30000000000000004, 0.17453292519943295 }, - { 0.34527248032587193, -0.19999999999999996, 0.29999999999999999, + { 0.35359030214835629, -0.19999999999999996, 0.30000000000000004, 0.34906585039886590 }, - { 0.51147118981668416, -0.19999999999999996, 0.29999999999999999, + { 0.53879807274537084, -0.19999999999999996, 0.30000000000000004, 0.52359877559829882 }, - { 0.67137107867777601, -0.19999999999999996, 0.29999999999999999, + { 0.73384116418059731, -0.19999999999999996, 0.30000000000000004, 0.69813170079773179 }, - { 0.82470418188668893, -0.19999999999999996, 0.29999999999999999, + { 0.94132799329524031, -0.19999999999999996, 0.30000000000000004, 0.87266462599716477 }, - { 0.97202873223594299, -0.19999999999999996, 0.29999999999999999, + { 1.1628407021801439, -0.19999999999999996, 0.30000000000000004, 1.0471975511965976 }, - { 1.1144773569375266, -0.19999999999999996, 0.29999999999999999, + { 1.3982440216739438, -0.19999999999999996, 0.30000000000000004, 1.2217304763960306 }, - { 1.2535292433701000, -0.19999999999999996, 0.29999999999999999, + { 1.6450634983653640, -0.19999999999999996, 0.30000000000000004, 1.3962634015954636 }, - { 1.3908453514752477, -0.19999999999999996, 0.29999999999999999, + { 1.8983924169967099, -0.19999999999999996, 0.30000000000000004, 1.5707963267948966 }, }; const double toler074 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.40000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.6788709752760483e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.3298410018355870e-16 +// mean(f - f_Boost): 1.3877787807814457e-17 +// variance(f - f_Boost): 9.4370567274974557e-32 +// stddev(f - f_Boost): 3.0719792850046133e-16 const testcase_ellint_3<double> data075[10] = { { 0.0000000000000000, -0.19999999999999996, 0.40000000000000002, 0.0000000000000000 }, - { 0.17386841301066674, -0.19999999999999996, 0.40000000000000002, + { 0.17527815368535152, -0.19999999999999996, 0.40000000000000002, 0.17453292519943295 }, - { 0.34395257914113253, -0.19999999999999996, 0.40000000000000002, + { 0.35504762134297801, -0.19999999999999996, 0.40000000000000002, 0.34906585039886590 }, - { 0.50737088376869466, -0.19999999999999996, 0.40000000000000002, + { 0.54387742353211344, -0.19999999999999996, 0.40000000000000002, 0.52359877559829882 }, - { 0.66262801717277631, -0.19999999999999996, 0.40000000000000002, + { 0.74637910471804259, -0.19999999999999996, 0.40000000000000002, 0.69813170079773179 }, - { 0.80958766645079094, -0.19999999999999996, 0.40000000000000002, + { 0.96690539714174639, -0.19999999999999996, 0.40000000000000002, 0.87266462599716477 }, - { 0.94913754236162040, -0.19999999999999996, 0.40000000000000002, + { 1.2087859420184757, -0.19999999999999996, 0.40000000000000002, 1.0471975511965976 }, - { 1.0827985514222997, -0.19999999999999996, 0.40000000000000002, + { 1.4729799844168852, -0.19999999999999996, 0.40000000000000002, 1.2217304763960306 }, - { 1.2124212429050478, -0.19999999999999996, 0.40000000000000002, + { 1.7564445064596661, -0.19999999999999996, 0.40000000000000002, 1.3962634015954636 }, - { 1.3400002519661005, -0.19999999999999996, 0.40000000000000002, + { 2.0512956926676802, -0.19999999999999996, 0.40000000000000002, 1.5707963267948966 }, }; const double toler075 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.50000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.7788201301356829e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.3841806057292116e-16 +// mean(f - f_Boost): 8.0491169285323847e-17 +// variance(f - f_Boost): 8.0538110429953348e-32 +// stddev(f - f_Boost): 2.8379237204328335e-16 const testcase_ellint_3<double> data076[10] = { { 0.0000000000000000, -0.19999999999999996, 0.50000000000000000, 0.0000000000000000 }, - { 0.17369503942181799, -0.19999999999999996, 0.50000000000000000, + { 0.17545727725228877, -0.19999999999999996, 0.50000000000000000, 0.17453292519943295 }, - { 0.34265043534362660, -0.19999999999999996, 0.50000000000000000, + { 0.35652666242062175, -0.19999999999999996, 0.50000000000000000, 0.34906585039886590 }, - { 0.50338337208655415, -0.19999999999999996, 0.50000000000000000, + { 0.54913090549102406, -0.19999999999999996, 0.50000000000000000, 0.52359877559829882 }, - { 0.65426373297163609, -0.19999999999999996, 0.50000000000000000, + { 0.75970161209211551, -0.19999999999999996, 0.50000000000000000, 0.69813170079773179 }, - { 0.79536193036145808, -0.19999999999999996, 0.50000000000000000, + { 0.99504737401590326, -0.19999999999999996, 0.50000000000000000, 0.87266462599716477 }, - { 0.92791875910061605, -0.19999999999999996, 0.50000000000000000, + { 1.2614666007124373, -0.19999999999999996, 0.50000000000000000, 1.0471975511965976 }, - { 1.0538145052725829, -0.19999999999999996, 0.50000000000000000, + { 1.5625255355205496, -0.19999999999999996, 0.50000000000000000, 1.2217304763960306 }, - { 1.1752060022875899, -0.19999999999999996, 0.50000000000000000, + { 1.8954460255613343, -0.19999999999999996, 0.50000000000000000, 1.3962634015954636 }, - { 1.2943374404397372, -0.19999999999999996, 0.50000000000000000, + { 2.2481046259421302, -0.19999999999999996, 0.50000000000000000, 1.5707963267948966 }, }; const double toler076 = 2.5000000000000020e-13; -// Test data for k=-0.19999999999999996, nu=0.59999999999999998. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.8899223779598256e-16 +// Test data for k=-0.19999999999999996, nu=0.60000000000000009. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.5317584994994743e-16 +// mean(f - f_Boost): -1.3877787807814457e-17 +// variance(f - f_Boost): 1.0045745697575397e-31 +// stddev(f - f_Boost): 3.1695024369095219e-16 const testcase_ellint_3<double> data077[10] = { - { 0.0000000000000000, -0.19999999999999996, 0.59999999999999998, + { 0.0000000000000000, -0.19999999999999996, 0.60000000000000009, 0.0000000000000000 }, - { 0.17352228440746925, -0.19999999999999996, 0.59999999999999998, + { 0.17563706072900442, -0.19999999999999996, 0.60000000000000009, 0.17453292519943295 }, - { 0.34136562863713626, -0.19999999999999996, 0.59999999999999998, + { 0.35802800926807238, -0.19999999999999996, 0.60000000000000009, 0.34906585039886590 }, - { 0.49950328177638481, -0.19999999999999996, 0.59999999999999998, + { 0.55456942250515051, -0.19999999999999996, 0.60000000000000009, 0.52359877559829882 }, - { 0.64625032705690799, -0.19999999999999996, 0.59999999999999998, + { 0.77390003828438203, -0.19999999999999996, 0.60000000000000009, 0.69813170079773179 }, - { 0.78193941198403083, -0.19999999999999996, 0.59999999999999998, + { 1.0262441366366397, -0.19999999999999996, 0.60000000000000009, 0.87266462599716477 }, - { 0.90817230934317128, -0.19999999999999996, 0.59999999999999998, + { 1.3228192988439669, -0.19999999999999996, 0.60000000000000009, 1.0471975511965976 }, - { 1.0271563751276462, -0.19999999999999996, 0.59999999999999998, + { 1.6728005754680795, -0.19999999999999996, 0.60000000000000009, 1.2217304763960306 }, - { 1.1412999379040518, -0.19999999999999996, 0.59999999999999998, + { 2.0761587107468511, -0.19999999999999996, 0.60000000000000009, 1.3962634015954636 }, - { 1.2530330675914556, -0.19999999999999996, 0.59999999999999998, + { 2.5148333891629315, -0.19999999999999996, 0.60000000000000009, 1.5707963267948966 }, }; const double toler077 = 2.5000000000000020e-13; -// Test data for k=-0.19999999999999996, nu=0.69999999999999996. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 5.9999318361775115e-16 +// Test data for k=-0.19999999999999996, nu=0.70000000000000007. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.1818454249546518e-16 +// mean(f - f_Boost): 3.6082248300317589e-17 +// variance(f - f_Boost): 8.9638010532618564e-32 +// stddev(f - f_Boost): 2.9939607634806868e-16 const testcase_ellint_3<double> data078[10] = { - { 0.0000000000000000, -0.19999999999999996, 0.69999999999999996, + { 0.0000000000000000, -0.19999999999999996, 0.70000000000000007, 0.0000000000000000 }, - { 0.17335014404233895, -0.19999999999999996, 0.69999999999999996, + { 0.17581750846781172, -0.19999999999999996, 0.70000000000000007, 0.17453292519943295 }, - { 0.34009775298617811, -0.19999999999999996, 0.69999999999999996, + { 0.35955226882028513, -0.19999999999999996, 0.70000000000000007, 0.34906585039886590 }, - { 0.49572560201923810, -0.19999999999999996, 0.69999999999999996, + { 0.56020489659466499, -0.19999999999999996, 0.70000000000000007, 0.52359877559829882 }, - { 0.63856276669886503, -0.19999999999999996, 0.69999999999999996, + { 0.78908196988531487, -0.19999999999999996, 0.70000000000000007, 0.69813170079773179 }, - { 0.76924438644867565, -0.19999999999999996, 0.69999999999999996, + { 1.0611336754143517, -0.19999999999999996, 0.70000000000000007, 0.87266462599716477 }, - { 0.88973060843856466, -0.19999999999999996, 0.69999999999999996, + { 1.3956969951058884, -0.19999999999999996, 0.70000000000000007, 1.0471975511965976 }, - { 1.0025230471636377, -0.19999999999999996, 0.69999999999999996, + { 1.8138131612209609, -0.19999999999999996, 0.70000000000000007, 1.2217304763960306 }, - { 1.1102356376093103, -0.19999999999999996, 0.69999999999999996, + { 2.3256365528879561, -0.19999999999999996, 0.70000000000000007, 1.3962634015954636 }, - { 1.2154356555075863, -0.19999999999999996, 0.69999999999999996, + { 2.9058704854500963, -0.19999999999999996, 0.70000000000000007, 1.5707963267948966 }, }; const double toler078 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 5.0901276230707249e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.9866614515542431e-16 +// mean(f - f_Boost): 1.8318679906315082e-16 +// variance(f - f_Boost): 3.1335688610218711e-31 +// stddev(f - f_Boost): 5.5978289193417400e-16 const testcase_ellint_3<double> data079[10] = { { 0.0000000000000000, -0.19999999999999996, 0.80000000000000004, 0.0000000000000000 }, - { 0.17317861443718538, -0.19999999999999996, 0.80000000000000004, + { 0.17599862486281712, -0.19999999999999996, 0.80000000000000004, 0.17453292519943295 }, - { 0.33884641598718701, -0.19999999999999996, 0.80000000000000004, + { 0.36110007227128776, -0.19999999999999996, 0.80000000000000004, 0.34906585039886590 }, - { 0.49204565281259494, -0.19999999999999996, 0.80000000000000004, + { 0.56605039658567224, -0.19999999999999996, 0.80000000000000004, 0.52359877559829882 }, - { 0.63117851188220320, -0.19999999999999996, 0.80000000000000004, + { 0.80537523874517691, -0.19999999999999996, 0.80000000000000004, 0.69813170079773179 }, - { 0.75721095949544170, -0.19999999999999996, 0.80000000000000004, + { 1.1005662342414086, -0.19999999999999996, 0.80000000000000004, 0.87266462599716477 }, - { 0.87245201443919118, -0.19999999999999996, 0.80000000000000004, + { 1.4845340298105778, -0.19999999999999996, 0.80000000000000004, 1.0471975511965976 }, - { 0.97966584238831089, -0.19999999999999996, 0.80000000000000004, + { 2.0043332244969392, -0.19999999999999996, 0.80000000000000004, 1.2217304763960306 }, - { 1.0816336325174360, -0.19999999999999996, 0.80000000000000004, + { 2.7052856676744761, -0.19999999999999996, 0.80000000000000004, 1.3962634015954636 }, - { 1.1810223448909909, -0.19999999999999996, 0.80000000000000004, + { 3.5622166386422629, -0.19999999999999996, 0.80000000000000004, 1.5707963267948966 }, }; const double toler079 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.90000000000000002. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 6.4833128442756722e-16 +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.2817178727913890e-16 +// mean(f - f_Boost): 3.4694469519536142e-16 +// variance(f - f_Boost): 6.6311432369155086e-31 +// stddev(f - f_Boost): 8.1431831840598485e-16 const testcase_ellint_3<double> data080[10] = { { 0.0000000000000000, -0.19999999999999996, 0.90000000000000002, 0.0000000000000000 }, - { 0.17300769173837277, -0.19999999999999996, 0.90000000000000002, + { 0.17618041435044951, -0.19999999999999996, 0.90000000000000002, 0.17453292519943295 }, - { 0.33761123827372508, -0.19999999999999996, 0.90000000000000002, + { 0.36267207636502929, -0.19999999999999996, 0.90000000000000002, 0.34906585039886590 }, - { 0.48845905690769426, -0.19999999999999996, 0.90000000000000002, + { 0.57212028758237743, -0.19999999999999996, 0.90000000000000002, 0.52359877559829882 }, - { 0.62407720017324952, -0.19999999999999996, 0.90000000000000002, + { 0.82293323876704483, -0.19999999999999996, 0.90000000000000002, 0.69813170079773179 }, - { 0.74578146525124289, -0.19999999999999996, 0.90000000000000002, + { 1.1457077279880385, -0.19999999999999996, 0.90000000000000002, 0.87266462599716477 }, - { 0.85621583540073076, -0.19999999999999996, 0.90000000000000002, + { 1.5967346899325681, -0.19999999999999996, 0.90000000000000002, 1.0471975511965976 }, - { 0.95837725988001199, -0.19999999999999996, 0.90000000000000002, + { 2.2856537353421724, -0.19999999999999996, 0.90000000000000002, 1.2217304763960306 }, - { 1.0551821412633928, -0.19999999999999996, 0.90000000000000002, + { 3.4034714304613902, -0.19999999999999996, 0.90000000000000002, 1.3962634015954636 }, - { 1.1493679916141861, -0.19999999999999996, 0.90000000000000002, + { 5.0448269356200361, -0.19999999999999996, 0.90000000000000002, 1.5707963267948966 }, }; const double toler080 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.0000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.1735566504509650e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.1735566504509645e-16 +// mean(f - f_Boost): -3.6082248300317589e-17 +// variance(f - f_Boost): 8.2258607846939269e-33 +// stddev(f - f_Boost): 9.0696531271564778e-17 const testcase_ellint_3<double> data081[10] = { { 0.0000000000000000, -0.099999999999999978, 0.0000000000000000, 0.0000000000000000 }, - { 0.17454173353063659, -0.099999999999999978, 0.0000000000000000, + { 0.17454173353063662, -0.099999999999999978, 0.0000000000000000, 0.17453292519943295 }, - { 0.34913506721468091, -0.099999999999999978, 0.0000000000000000, + { 0.34913506721468096, -0.099999999999999978, 0.0000000000000000, 0.34906585039886590 }, - { 0.52382550016538942, -0.099999999999999978, 0.0000000000000000, + { 0.52382550016538953, -0.099999999999999978, 0.0000000000000000, 0.52359877559829882 }, { 0.69864700854177020, -0.099999999999999978, 0.0000000000000000, 0.69813170079773179 }, - { 0.87361792586964870, -0.099999999999999978, 0.0000000000000000, + { 0.87361792586964859, -0.099999999999999978, 0.0000000000000000, 0.87266462599716477 }, - { 1.0487386319621683, -0.099999999999999978, 0.0000000000000000, + { 1.0487386319621685, -0.099999999999999978, 0.0000000000000000, 1.0471975511965976 }, - { 1.2239913752078757, -0.099999999999999978, 0.0000000000000000, + { 1.2239913752078759, -0.099999999999999978, 0.0000000000000000, 1.2217304763960306 }, - { 1.3993423113684049, -0.099999999999999978, 0.0000000000000000, + { 1.3993423113684051, -0.099999999999999978, 0.0000000000000000, 1.3962634015954636 }, - { 1.5747455615173562, -0.099999999999999978, 0.0000000000000000, + { 1.5747455615173558, -0.099999999999999978, 0.0000000000000000, 1.5707963267948966 }, }; const double toler081 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.10000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3097339877269682e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.0305747373482148e-16 +// mean(f - f_Boost): -3.0531133177191807e-17 +// variance(f - f_Boost): 1.1508025840536076e-34 +// stddev(f - f_Boost): 1.0727546709539920e-17 const testcase_ellint_3<double> data082[10] = { { 0.0000000000000000, -0.099999999999999978, 0.10000000000000001, 0.0000000000000000 }, - { 0.17436589347616613, -0.099999999999999978, 0.10000000000000001, + { 0.17471821213559732, -0.099999999999999978, 0.10000000000000001, 0.17453292519943295 }, - { 0.34776067871237359, -0.099999999999999978, 0.10000000000000001, + { 0.35052902610011138, -0.099999999999999978, 0.10000000000000001, 0.34906585039886590 }, - { 0.51936064354727796, -0.099999999999999978, 0.10000000000000001, + { 0.52842865990255727, -0.099999999999999978, 0.10000000000000001, 0.52359877559829882 }, - { 0.68860303749364349, -0.099999999999999978, 0.10000000000000001, + { 0.70921799731166713, -0.099999999999999978, 0.10000000000000001, 0.69813170079773179 }, - { 0.85524561882332051, -0.099999999999999978, 0.10000000000000001, + { 0.89340330535868662, -0.099999999999999978, 0.10000000000000001, 0.87266462599716477 }, - { 1.0193708301908335, -0.099999999999999978, 0.10000000000000001, + { 1.0811075784236857, -0.099999999999999978, 0.10000000000000001, 1.0471975511965976 }, - { 1.1813474067123044, -0.099999999999999978, 0.10000000000000001, + { 1.2720133232666426, -0.099999999999999978, 0.10000000000000001, 1.2217304763960306 }, - { 1.3417670770424983, -0.099999999999999978, 0.10000000000000001, + { 1.4653630031861395, -0.099999999999999978, 0.10000000000000001, 1.3962634015954636 }, - { 1.5013711111199950, -0.099999999999999978, 0.10000000000000001, + { 1.6600374067558428, -0.099999999999999978, 0.10000000000000001, 1.5707963267948966 }, }; const double toler082 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.20000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.4399947764827574e-16 +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 1.6736714959992433e-16 +// mean(f - f_Boost): 5.5511151231257830e-18 +// variance(f - f_Boost): 3.8043060629871325e-36 +// stddev(f - f_Boost): 1.9504630380981673e-18 const testcase_ellint_3<double> data083[10] = { { 0.0000000000000000, -0.099999999999999978, 0.20000000000000001, 0.0000000000000000 }, - { 0.17419068786141340, -0.099999999999999978, 0.20000000000000001, + { 0.17489533344059083, -0.099999999999999978, 0.20000000000000001, 0.17453292519943295 }, - { 0.34640537686230133, -0.099999999999999978, 0.20000000000000001, + { 0.35194305707815038, -0.099999999999999978, 0.20000000000000001, 0.34906585039886590 }, - { 0.51502689171753946, -0.099999999999999978, 0.20000000000000001, + { 0.53317790741512527, -0.099999999999999978, 0.20000000000000001, 0.52359877559829882 }, - { 0.67904147863672715, -0.099999999999999978, 0.20000000000000001, + { 0.72036681615081222, -0.099999999999999978, 0.20000000000000001, 0.69813170079773179 }, - { 0.83811885126105179, -0.099999999999999978, 0.20000000000000001, + { 0.91480372268244303, -0.099999999999999978, 0.20000000000000001, 0.87266462599716477 }, - { 0.99255278555742787, -0.099999999999999978, 0.20000000000000001, + { 1.1170528708071514, -0.099999999999999978, 0.20000000000000001, 1.0471975511965976 }, - { 1.1431260546194930, -0.099999999999999978, 0.20000000000000001, + { 1.3266916802718358, -0.099999999999999978, 0.20000000000000001, 1.2217304763960306 }, - { 1.2909589656532101, -0.099999999999999978, 0.20000000000000001, + { 1.5421622241831547, -0.099999999999999978, 0.20000000000000001, 1.3962634015954636 }, - { 1.4373749386463430, -0.099999999999999978, 0.20000000000000001, + { 1.7608656115083421, -0.099999999999999978, 0.20000000000000001, 1.5707963267948966 }, }; const double toler083 = 2.5000000000000020e-13; -// Test data for k=-0.099999999999999978, nu=0.29999999999999999. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.5650492137236872e-16 +// Test data for k=-0.099999999999999978, nu=0.30000000000000004. +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 1.9186071760326645e-16 +// mean(f - f_Boost): -1.6653345369377347e-17 +// variance(f - f_Boost): 3.4238754566884194e-35 +// stddev(f - f_Boost): 5.8513891142945016e-18 const testcase_ellint_3<double> data084[10] = { - { 0.0000000000000000, -0.099999999999999978, 0.29999999999999999, + { 0.0000000000000000, -0.099999999999999978, 0.30000000000000004, 0.0000000000000000 }, - { 0.17401611261390104, -0.099999999999999978, 0.29999999999999999, + { 0.17507310163441189, -0.099999999999999978, 0.30000000000000004, 0.17453292519943295 }, - { 0.34506869507511773, -0.099999999999999978, 0.29999999999999999, + { 0.35337768072524217, -0.099999999999999978, 0.30000000000000004, 0.34906585039886590 }, - { 0.51081757604259859, -0.099999999999999978, 0.29999999999999999, + { 0.53808167801629170, -0.099999999999999978, 0.30000000000000004, 0.52359877559829882 }, - { 0.66992297597712303, -0.099999999999999978, 0.29999999999999999, + { 0.73215166755955019, -0.099999999999999978, 0.30000000000000004, 0.69813170079773179 }, - { 0.82209722856174228, -0.099999999999999978, 0.29999999999999999, + { 0.93806546000201219, -0.099999999999999978, 0.30000000000000004, 0.87266462599716477 }, - { 0.96792430487669590, -0.099999999999999978, 0.29999999999999999, + { 1.1573218723395986, -0.099999999999999978, 0.30000000000000004, 1.0471975511965976 }, - { 1.1085964108954092, -0.099999999999999978, 0.29999999999999999, + { 1.3897859679542097, -0.099999999999999978, 0.30000000000000004, 1.2217304763960306 }, - { 1.2456748370836999, -0.099999999999999978, 0.29999999999999999, + { 1.6331009404328622, -0.099999999999999978, 0.30000000000000004, 1.3962634015954636 }, - { 1.3809159606704959, -0.099999999999999978, 0.29999999999999999, + { 1.8826015946315438, -0.099999999999999978, 0.30000000000000004, 1.5707963267948966 }, }; const double toler084 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.40000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.6854758534459740e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.0338059536914377e-16 +// mean(f - f_Boost): 2.7755575615628914e-17 +// variance(f - f_Boost): 9.5107651574678308e-35 +// stddev(f - f_Boost): 9.7523151904908362e-18 const testcase_ellint_3<double> data085[10] = { { 0.0000000000000000, -0.099999999999999978, 0.40000000000000002, 0.0000000000000000 }, - { 0.17384216369897931, -0.099999999999999978, 0.40000000000000002, + { 0.17525152094559704, -0.099999999999999978, 0.40000000000000002, 0.17453292519943295 }, - { 0.34375018311376787, -0.099999999999999978, 0.40000000000000002, + { 0.35483343742825979, -0.099999999999999978, 0.40000000000000002, 0.34906585039886590 }, - { 0.50672650758380455, -0.099999999999999978, 0.40000000000000002, + { 0.54314913099505446, -0.099999999999999978, 0.40000000000000002, 0.52359877559829882 }, - { 0.66121264213337616, -0.099999999999999978, 0.40000000000000002, + { 0.74463962034766862, -0.099999999999999978, 0.40000000000000002, 0.69813170079773179 }, - { 0.80706202005774441, -0.099999999999999978, 0.40000000000000002, + { 0.96349276837570441, -0.099999999999999978, 0.40000000000000002, 0.87266462599716477 }, - { 0.94519376138245870, -0.099999999999999978, 0.40000000000000002, + { 1.2029081382746343, -0.099999999999999978, 0.40000000000000002, 1.0471975511965976 }, - { 1.0771880300759584, -0.099999999999999978, 0.40000000000000002, + { 1.4638022887050806, -0.099999999999999978, 0.40000000000000002, 1.2217304763960306 }, - { 1.2049711557188272, -0.099999999999999978, 0.40000000000000002, + { 1.7432413830105224, -0.099999999999999978, 0.40000000000000002, 1.3962634015954636 }, - { 1.3306223265207477, -0.099999999999999978, 0.40000000000000002, + { 2.0336367403076760, -0.099999999999999978, 0.40000000000000002, 1.5707963267948966 }, }; const double toler085 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.50000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8017534281650347e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.9864616042835278e-16 +// mean(f - f_Boost): 1.0547118733938987e-16 +// variance(f - f_Boost): 7.5633408838247182e-32 +// stddev(f - f_Boost): 2.7501528837184157e-16 const testcase_ellint_3<double> data086[10] = { { 0.0000000000000000, -0.099999999999999978, 0.50000000000000000, 0.0000000000000000 }, - { 0.17366883711936548, -0.099999999999999978, 0.50000000000000000, + { 0.17543059564292182, -0.099999999999999978, 0.50000000000000000, 0.17453292519943295 }, - { 0.34244940634881882, -0.099999999999999978, 0.50000000000000000, + { 0.35631088838721664, -0.099999999999999978, 0.50000000000000000, 0.34906585039886590 }, - { 0.50274793281634367, -0.099999999999999978, 0.50000000000000000, + { 0.54839023346436444, -0.099999999999999978, 0.50000000000000000, 0.52359877559829882 }, - { 0.65287941633275082, -0.099999999999999978, 0.50000000000000000, + { 0.75790846946088830, -0.099999999999999978, 0.50000000000000000, 0.69813170079773179 }, - { 0.79291198790315398, -0.099999999999999978, 0.50000000000000000, + { 0.99146713686720678, -0.099999999999999978, 0.50000000000000000, 0.87266462599716477 }, - { 0.92412201537880323, -0.099999999999999978, 0.50000000000000000, + { 1.2551692247937198, -0.099999999999999978, 0.50000000000000000, 1.0471975511965976 }, - { 1.0484480076799372, -0.099999999999999978, 0.50000000000000000, + { 1.5524660788146873, -0.099999999999999978, 0.50000000000000000, 1.2217304763960306 }, - { 1.1681168130475206, -0.099999999999999978, 0.50000000000000000, + { 1.8806578570830670, -0.099999999999999978, 0.50000000000000000, 1.3962634015954636 }, - { 1.2854480708580160, -0.099999999999999978, 0.50000000000000000, + { 2.2279868912966849, -0.099999999999999978, 0.50000000000000000, 1.5707963267948966 }, }; const double toler086 = 2.5000000000000020e-13; -// Test data for k=-0.099999999999999978, nu=0.59999999999999998. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.9142834151672032e-16 +// Test data for k=-0.099999999999999978, nu=0.60000000000000009. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.6726146516228014e-16 +// mean(f - f_Boost): -3.6082248300317589e-17 +// variance(f - f_Boost): 1.6073193116120635e-34 +// stddev(f - f_Boost): 1.2678009747638087e-17 const testcase_ellint_3<double> data087[10] = { - { 0.0000000000000000, -0.099999999999999978, 0.59999999999999998, + { 0.0000000000000000, -0.099999999999999978, 0.60000000000000009, 0.0000000000000000 }, - { 0.17349612891469013, -0.099999999999999978, 0.59999999999999998, + { 0.17561033003590576, -0.099999999999999978, 0.60000000000000009, 0.17453292519943295 }, - { 0.34116594505539444, -0.099999999999999978, 0.59999999999999998, + { 0.35781061668171932, -0.099999999999999978, 0.60000000000000009, 0.34906585039886590 }, - { 0.49887649430466674, -0.099999999999999978, 0.59999999999999998, + { 0.55381585659629196, -0.099999999999999978, 0.60000000000000009, 0.52359877559829882 }, - { 0.64489553282165146, -0.099999999999999978, 0.59999999999999998, + { 0.77204910484575640, -0.099999999999999978, 0.60000000000000009, 0.69813170079773179 }, - { 0.77956016553782437, -0.099999999999999978, 0.59999999999999998, + { 1.0224751740393108, -0.099999999999999978, 0.60000000000000009, 0.87266462599716477 }, - { 0.90451074530096287, -0.099999999999999978, 0.59999999999999998, + { 1.3160230906351114, -0.099999999999999978, 0.60000000000000009, 1.0471975511965976 }, - { 1.0220113666961632, -0.099999999999999978, 0.59999999999999998, + { 1.6616282844233206, -0.099999999999999978, 0.60000000000000009, 1.2217304763960306 }, - { 1.1345351441065563, -0.099999999999999978, 0.59999999999999998, + { 2.0592555664850392, -0.099999999999999978, 0.60000000000000009, 1.3962634015954636 }, - { 1.2445798942989255, -0.099999999999999978, 0.59999999999999998, + { 2.4913004919173822, -0.099999999999999978, 0.60000000000000009, 1.5707963267948966 }, }; const double toler087 = 2.5000000000000020e-13; -// Test data for k=-0.099999999999999978, nu=0.69999999999999996. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 5.5172091551439012e-16 +// Test data for k=-0.099999999999999978, nu=0.70000000000000007. +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 5 +// max(|f - f_Boost| / |f_Boost|): 2.1004074871280821e-16 +// mean(f - f_Boost): 3.3306690738754695e-17 +// variance(f - f_Boost): 1.3695501826753678e-34 +// stddev(f - f_Boost): 1.1702778228589003e-17 const testcase_ellint_3<double> data088[10] = { - { 0.0000000000000000, -0.099999999999999978, 0.69999999999999996, + { 0.0000000000000000, -0.099999999999999978, 0.70000000000000007, 0.0000000000000000 }, - { 0.17332403516105047, -0.099999999999999978, 0.69999999999999996, + { 0.17579072847532518, -0.099999999999999978, 0.70000000000000007, 0.17453292519943295 }, - { 0.33989939374896883, -0.099999999999999978, 0.69999999999999996, + { 0.35933322840606297, -0.099999999999999978, 0.70000000000000007, 0.34906585039886590 }, - { 0.49510719568614070, -0.099999999999999978, 0.69999999999999996, + { 0.55943788649460324, -0.099999999999999978, 0.70000000000000007, 0.52359877559829882 }, - { 0.63723607776354974, -0.099999999999999978, 0.69999999999999996, + { 0.78716856504031707, -0.099999999999999978, 0.70000000000000007, 0.69813170079773179 }, - { 0.76693133887935327, -0.099999999999999978, 0.69999999999999996, + { 1.0571501305617423, -0.099999999999999978, 0.70000000000000007, 0.87266462599716477 }, - { 0.88619382078823805, -0.099999999999999978, 0.69999999999999996, + { 1.3882948301743525, -0.099999999999999978, 0.70000000000000007, 1.0471975511965976 }, - { 0.99758012018676490, -0.099999999999999978, 0.69999999999999996, + { 1.8011785680114223, -0.099999999999999978, 0.70000000000000007, 1.2217304763960306 }, - { 1.1037642270814410, -0.099999999999999978, 0.69999999999999996, + { 2.3057268183616464, -0.099999999999999978, 0.70000000000000007, 1.3962634015954636 }, - { 1.2073745911083185, -0.099999999999999978, 0.69999999999999996, + { 2.8771910188009739, -0.099999999999999978, 0.70000000000000007, 1.5707963267948966 }, }; const double toler088 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1294144515772258e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.3133043868392355e-16 +// mean(f - f_Boost): 1.8041124150158794e-16 +// variance(f - f_Boost): 6.1843750436434569e-32 +// stddev(f - f_Boost): 2.4868403735751633e-16 const testcase_ellint_3<double> data089[10] = { { 0.0000000000000000, -0.099999999999999978, 0.80000000000000004, 0.0000000000000000 }, - { 0.17315255197057014, -0.099999999999999978, 0.80000000000000004, + { 0.17597179535373417, -0.099999999999999978, 0.80000000000000004, 0.17453292519943295 }, - { 0.33864936055747991, -0.099999999999999978, 0.80000000000000004, + { 0.36087935387831499, -0.099999999999999978, 0.80000000000000004, 0.34906585039886590 }, - { 0.49143537041117613, -0.099999999999999978, 0.80000000000000004, + { 0.56526935244526444, -0.099999999999999978, 0.80000000000000004, 0.52359877559829882 }, - { 0.62987861760047492, -0.099999999999999978, 0.80000000000000004, + { 0.80339402590612397, -0.099999999999999978, 0.80000000000000004, 0.69813170079773179 }, - { 0.75496005490917517, -0.099999999999999978, 0.80000000000000004, + { 1.0963358646374459, -0.099999999999999978, 0.80000000000000004, 0.87266462599716477 }, - { 0.86903081862701881, -0.099999999999999978, 0.80000000000000004, + { 1.4763748483246868, -0.099999999999999978, 0.80000000000000004, 1.0471975511965976 }, - { 0.97490814820725591, -0.099999999999999978, 0.80000000000000004, + { 1.9896610222794102, -0.099999999999999978, 0.80000000000000004, 1.2217304763960306 }, - { 1.0754290107171083, -0.099999999999999978, 0.80000000000000004, + { 2.6806423920122024, -0.099999999999999978, 0.80000000000000004, 1.3962634015954636 }, - { 1.1733158866987732, -0.099999999999999978, 0.80000000000000004, + { 3.5246199613295612, -0.099999999999999978, 0.80000000000000004, 1.5707963267948966 }, }; const double toler089 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.90000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2325599449457852e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.5624826890976725e-16 +// mean(f - f_Boost): 2.3314683517128288e-16 +// variance(f - f_Boost): 2.9401198977189756e-31 +// stddev(f - f_Boost): 5.4222872459129045e-16 const testcase_ellint_3<double> data090[10] = { { 0.0000000000000000, -0.099999999999999978, 0.90000000000000002, 0.0000000000000000 }, - { 0.17298167549096563, -0.099999999999999978, 0.90000000000000002, + { 0.17615353510599349, -0.099999999999999978, 0.90000000000000002, 0.17453292519943295 }, - { 0.33741546662741589, -0.099999999999999978, 0.90000000000000002, + { 0.36244964892922371, -0.099999999999999978, 0.90000000000000002, 0.34906585039886590 }, - { 0.48785665376856868, -0.099999999999999978, 0.90000000000000002, + { 0.57132457590110530, -0.099999999999999978, 0.90000000000000002, 0.52359877559829882 }, - { 0.62280288554518959, -0.099999999999999978, 0.90000000000000002, + { 0.82087808820385000, -0.099999999999999978, 0.90000000000000002, 0.69813170079773179 }, - { 0.74358903115455188, -0.099999999999999978, 0.90000000000000002, + { 1.1411894342144451, -0.099999999999999978, 0.90000000000000002, 0.87266462599716477 }, - { 0.85290207679298335, -0.099999999999999978, 0.90000000000000002, + { 1.5875929286844597, -0.099999999999999978, 0.90000000000000002, 1.0471975511965976 }, - { 0.95379006645397379, -0.099999999999999978, 0.90000000000000002, + { 2.2678622986596659, -0.099999999999999978, 0.90000000000000002, 1.2217304763960306 }, - { 1.0492213119872327, -0.099999999999999978, 0.90000000000000002, + { 3.3697528941897903, -0.099999999999999978, 0.90000000000000002, 1.3962634015954636 }, - { 1.1419839485283374, -0.099999999999999978, 0.90000000000000002, + { 4.9862890417305499, -0.099999999999999978, 0.90000000000000002, 1.5707963267948966 }, }; const double toler090 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.0000000000000000. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 2.1203697876423452e-16 +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.1203697876423447e-16 +// mean(f - f_Boost): -1.9428902930940238e-17 +// variance(f - f_Boost): 4.6602749271592373e-35 +// stddev(f - f_Boost): 6.8266206333435850e-18 const testcase_ellint_3<double> data091[10] = { { 0.0000000000000000, 0.0000000000000000, 0.0000000000000000, 0.0000000000000000 }, - { 0.17453292519943292, 0.0000000000000000, 0.0000000000000000, + { 0.17453292519943295, 0.0000000000000000, 0.0000000000000000, 0.17453292519943295 }, - { 0.34906585039886584, 0.0000000000000000, 0.0000000000000000, + { 0.34906585039886590, 0.0000000000000000, 0.0000000000000000, 0.34906585039886590 }, - { 0.52359877559829870, 0.0000000000000000, 0.0000000000000000, + { 0.52359877559829882, 0.0000000000000000, 0.0000000000000000, 0.52359877559829882 }, - { 0.69813170079773168, 0.0000000000000000, 0.0000000000000000, + { 0.69813170079773179, 0.0000000000000000, 0.0000000000000000, 0.69813170079773179 }, { 0.87266462599716477, 0.0000000000000000, 0.0000000000000000, 0.87266462599716477 }, - { 1.0471975511965974, 0.0000000000000000, 0.0000000000000000, + { 1.0471975511965976, 0.0000000000000000, 0.0000000000000000, 1.0471975511965976 }, - { 1.2217304763960304, 0.0000000000000000, 0.0000000000000000, + { 1.2217304763960306, 0.0000000000000000, 0.0000000000000000, 1.2217304763960306 }, - { 1.3962634015954631, 0.0000000000000000, 0.0000000000000000, + { 1.3962634015954636, 0.0000000000000000, 0.0000000000000000, 1.3962634015954636 }, { 1.5707963267948966, 0.0000000000000000, 0.0000000000000000, 1.5707963267948966 }, @@ -2678,849 +2950,939 @@ data091[10] = const double toler091 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.10000000000000001. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 2.1813975824747021e-16 +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.1019052604815601e-16 +// mean(f - f_Boost): 2.7755575615628915e-18 +// variance(f - f_Boost): 9.5107651574678312e-37 +// stddev(f - f_Boost): 9.7523151904908366e-19 const testcase_ellint_3<double> data092[10] = { { 0.0000000000000000, 0.0000000000000000, 0.10000000000000001, 0.0000000000000000 }, - { 0.17435710107516605, 0.0000000000000000, 0.10000000000000001, + { 0.17470938780535167, 0.0000000000000000, 0.10000000000000001, 0.17453292519943295 }, - { 0.34769194715329604, 0.0000000000000000, 0.10000000000000001, + { 0.35045931581655582, 0.0000000000000000, 0.10000000000000001, 0.34906585039886590 }, - { 0.51913731575866107, 0.0000000000000000, 0.10000000000000001, + { 0.52819841383849875, 0.0000000000000000, 0.10000000000000001, 0.52359877559829882 }, - { 0.68810051897078450, 0.0000000000000000, 0.10000000000000001, + { 0.70868910807992958, 0.0000000000000000, 0.10000000000000001, 0.69813170079773179 }, - { 0.85432615661706823, 0.0000000000000000, 0.10000000000000001, + { 0.89241311307249638, 0.0000000000000000, 0.10000000000000001, 0.87266462599716477 }, - { 1.0179006647340794, 0.0000000000000000, 0.10000000000000001, + { 1.0794871444666669, 0.0000000000000000, 0.10000000000000001, 1.0471975511965976 }, - { 1.1792120640746322, 0.0000000000000000, 0.10000000000000001, + { 1.2696086247356864, 0.0000000000000000, 0.10000000000000001, 1.2217304763960306 }, - { 1.3388834245070498, 0.0000000000000000, 0.10000000000000001, + { 1.4620562617494721, 0.0000000000000000, 0.10000000000000001, 1.3962634015954636 }, - { 1.4976955329233277, 0.0000000000000000, 0.10000000000000001, + { 1.6557647109660167, 0.0000000000000000, 0.10000000000000001, 1.5707963267948966 }, }; const double toler092 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.20000000000000001. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 2.2402804784409065e-16 +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.0831888697465320e-16 +// mean(f - f_Boost): -1.9428902930940238e-17 +// variance(f - f_Boost): 4.6602749271592373e-35 +// stddev(f - f_Boost): 6.8266206333435850e-18 const testcase_ellint_3<double> data093[10] = { { 0.0000000000000000, 0.0000000000000000, 0.20000000000000001, 0.0000000000000000 }, - { 0.17418191132226074, 0.0000000000000000, 0.20000000000000001, + { 0.17488649304197776, 0.0000000000000000, 0.20000000000000001, 0.17453292519943295 }, - { 0.34633712256943405, 0.0000000000000000, 0.20000000000000001, + { 0.35187284488675424, 0.0000000000000000, 0.20000000000000001, 0.34906585039886590 }, - { 0.51480684302043700, 0.0000000000000000, 0.20000000000000001, + { 0.53294400750146131, 0.0000000000000000, 0.20000000000000001, 0.52359877559829882 }, - { 0.67855102942481937, 0.0000000000000000, 0.20000000000000001, + { 0.71982347021822823, 0.0000000000000000, 0.20000000000000001, 0.69813170079773179 }, - { 0.83723056090326253, 0.0000000000000000, 0.20000000000000001, + { 0.91377311030258745, 0.0000000000000000, 0.20000000000000001, 0.87266462599716477 }, - { 0.99114645269578161, 0.0000000000000000, 0.20000000000000001, + { 1.1153429007215137, 0.0000000000000000, 0.20000000000000001, 1.0471975511965976 }, - { 1.1411014627915537, 0.0000000000000000, 0.20000000000000001, + { 1.3241202847784086, 0.0000000000000000, 0.20000000000000001, 1.2217304763960306 }, - { 1.2882448138013969, 0.0000000000000000, 0.20000000000000001, + { 1.5385854914338242, 0.0000000000000000, 0.20000000000000001, 1.3962634015954636 }, - { 1.4339343023863691, 0.0000000000000000, 0.20000000000000001, + { 1.7562036827601815, 0.0000000000000000, 0.20000000000000001, 1.5707963267948966 }, }; const double toler093 = 2.5000000000000020e-13; -// Test data for k=0.0000000000000000, nu=0.29999999999999999. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 2.2972291118632678e-16 +// Test data for k=0.0000000000000000, nu=0.30000000000000004. +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.0642101770923591e-16 +// mean(f - f_Boost): -1.9428902930940238e-17 +// variance(f - f_Boost): 4.6602749271592373e-35 +// stddev(f - f_Boost): 6.8266206333435850e-18 const testcase_ellint_3<double> data094[10] = { - { 0.0000000000000000, 0.0000000000000000, 0.29999999999999999, + { 0.0000000000000000, 0.0000000000000000, 0.30000000000000004, 0.0000000000000000 }, - { 0.17400735186871724, 0.0000000000000000, 0.29999999999999999, + { 0.17506424509761404, 0.0000000000000000, 0.30000000000000004, 0.17453292519943295 }, - { 0.34500091027020219, 0.0000000000000000, 0.29999999999999999, + { 0.35330695794774630, 0.0000000000000000, 0.30000000000000004, 0.34906585039886590 }, - { 0.51060069523901530, 0.0000000000000000, 0.29999999999999999, + { 0.53784398359522367, 0.0000000000000000, 0.30000000000000004, 0.52359877559829882 }, - { 0.66944393961375448, 0.0000000000000000, 0.29999999999999999, + { 0.73159289408687844, 0.0000000000000000, 0.30000000000000004, 0.69813170079773179 }, - { 0.82123776744538157, 0.0000000000000000, 0.29999999999999999, + { 0.93699031797084975, 0.0000000000000000, 0.30000000000000004, 0.87266462599716477 }, - { 0.96657579245516501, 0.0000000000000000, 0.29999999999999999, + { 1.1555098909390267, 0.0000000000000000, 0.30000000000000004, 1.0471975511965976 }, - { 1.1066703663542414, 0.0000000000000000, 0.29999999999999999, + { 1.3870184960144325, 0.0000000000000000, 0.30000000000000004, 1.2217304763960306 }, - { 1.2431094251944901, 0.0000000000000000, 0.29999999999999999, + { 1.6291980835772994, 0.0000000000000000, 0.30000000000000004, 1.3962634015954636 }, - { 1.3776795151134889, 0.0000000000000000, 0.29999999999999999, + { 1.8774607092226381, 0.0000000000000000, 0.30000000000000004, 1.5707963267948966 }, }; const double toler094 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.40000000000000002. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 2.3524218164111537e-16 +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.0449580089795878e-16 +// mean(f - f_Boost): -1.9428902930940238e-17 +// variance(f - f_Boost): 4.6602749271592373e-35 +// stddev(f - f_Boost): 6.8266206333435850e-18 const testcase_ellint_3<double> data095[10] = { { 0.0000000000000000, 0.0000000000000000, 0.40000000000000002, 0.0000000000000000 }, - { 0.17383341868035862, 0.0000000000000000, 0.40000000000000002, + { 0.17524264820030025, 0.0000000000000000, 0.40000000000000002, 0.17453292519943295 }, - { 0.34368286022299821, 0.0000000000000000, 0.40000000000000002, + { 0.35476219513871499, 0.0000000000000000, 0.40000000000000002, 0.34906585039886590 }, - { 0.50651268947499395, 0.0000000000000000, 0.40000000000000002, + { 0.54290749235440094, 0.0000000000000000, 0.40000000000000002, 0.52359877559829882 }, - { 0.66074441806097539, 0.0000000000000000, 0.40000000000000002, + { 0.74406433757109913, 0.0000000000000000, 0.40000000000000002, 0.69813170079773179 }, - { 0.80622931670113474, 0.0000000000000000, 0.40000000000000002, + { 0.96236826162553313, 0.0000000000000000, 0.40000000000000002, 0.87266462599716477 }, - { 0.94389791565435210, 0.0000000000000000, 0.40000000000000002, + { 1.2009785880262487, 0.0000000000000000, 0.40000000000000002, 1.0471975511965976 }, - { 1.0753503387899728, 0.0000000000000000, 0.40000000000000002, + { 1.4608000106167567, 0.0000000000000000, 0.40000000000000002, 1.2217304763960306 }, - { 1.2025374759127518, 0.0000000000000000, 0.40000000000000002, + { 1.7389349574753439, 0.0000000000000000, 0.40000000000000002, 1.3962634015954636 }, - { 1.3275651989026320, 0.0000000000000000, 0.40000000000000002, + { 2.0278893379868057, 0.0000000000000000, 0.40000000000000002, 1.5707963267948966 }, }; const double toler095 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.50000000000000000. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 3.6090167266677240e-16 +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.0254203825026289e-16 +// mean(f - f_Boost): -1.9428902930940238e-17 +// variance(f - f_Boost): 4.6602749271592373e-35 +// stddev(f - f_Boost): 6.8266206333435850e-18 const testcase_ellint_3<double> data096[10] = { { 0.0000000000000000, 0.0000000000000000, 0.50000000000000000, 0.0000000000000000 }, - { 0.17366010776037044, 0.0000000000000000, 0.50000000000000000, + { 0.17542170661831016, 0.0000000000000000, 0.50000000000000000, 0.17453292519943295 }, - { 0.34238253799539309, 0.0000000000000000, 0.50000000000000000, + { 0.35623911740195419, 0.0000000000000000, 0.50000000000000000, 0.34906585039886590 }, - { 0.50253707775976397, 0.0000000000000000, 0.50000000000000000, + { 0.54814449099863127, 0.0000000000000000, 0.50000000000000000, 0.52359877559829882 }, - { 0.65242145347295766, 0.0000000000000000, 0.50000000000000000, + { 0.75731546607718081, 0.0000000000000000, 0.50000000000000000, 0.69813170079773179 }, - { 0.79210420018698058, 0.0000000000000000, 0.50000000000000000, + { 0.99028751188233310, 0.0000000000000000, 0.50000000000000000, 0.87266462599716477 }, - { 0.92287437995632171, 0.0000000000000000, 0.50000000000000000, + { 1.2531022857760581, 0.0000000000000000, 0.50000000000000000, 1.0471975511965976 }, - { 1.0466900550798659, 0.0000000000000000, 0.50000000000000000, + { 1.5491761777615785, 0.0000000000000000, 0.50000000000000000, 1.2217304763960306 }, - { 1.1658007366618623, 0.0000000000000000, 0.50000000000000000, + { 1.8758359693666533, 0.0000000000000000, 0.50000000000000000, 1.3962634015954636 }, - { 1.2825498301618641, 0.0000000000000000, 0.50000000000000000, + { 2.2214414690791831, 0.0000000000000000, 0.50000000000000000, 1.5707963267948966 }, }; const double toler096 = 2.5000000000000020e-13; -// Test data for k=0.0000000000000000, nu=0.59999999999999998. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 2.4581288258006758e-16 +// Test data for k=0.0000000000000000, nu=0.60000000000000009. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 2.1742785192400269e-16 +// mean(f - f_Boost): 1.3877787807814457e-17 +// variance(f - f_Boost): 2.3776912893669577e-35 +// stddev(f - f_Boost): 4.8761575952454181e-18 const testcase_ellint_3<double> data097[10] = { - { 0.0000000000000000, 0.0000000000000000, 0.59999999999999998, + { 0.0000000000000000, 0.0000000000000000, 0.60000000000000009, 0.0000000000000000 }, - { 0.17348741514884700, 0.0000000000000000, 0.59999999999999998, + { 0.17560142466065651, 0.0000000000000000, 0.60000000000000009, 0.17453292519943295 }, - { 0.34109952405241289, 0.0000000000000000, 0.59999999999999998, + { 0.35773830754879005, 0.0000000000000000, 0.60000000000000009, 0.34906585039886590 }, - { 0.49866850781226285, 0.0000000000000000, 0.59999999999999998, + { 0.55356583986445973, 0.0000000000000000, 0.60000000000000009, 0.52359877559829882 }, - { 0.64444732407062499, 0.0000000000000000, 0.59999999999999998, + { 0.77143701715151514, 0.0000000000000000, 0.60000000000000009, 0.69813170079773179 }, - { 0.77877564686544720, 0.0000000000000000, 0.59999999999999998, + { 1.0212334940541210, 0.0000000000000000, 0.60000000000000009, 0.87266462599716477 }, - { 0.90330743691883475, 0.0000000000000000, 0.59999999999999998, + { 1.3137928444460387, 0.0000000000000000, 0.60000000000000009, 1.0471975511965976 }, - { 1.0203257987604104, 0.0000000000000000, 0.59999999999999998, + { 1.6579755004159076, 0.0000000000000000, 0.60000000000000009, 1.2217304763960306 }, - { 1.1323247918768629, 0.0000000000000000, 0.59999999999999998, + { 2.0537461418295506, 0.0000000000000000, 0.60000000000000009, 1.3962634015954636 }, - { 1.2418235332245127, 0.0000000000000000, 0.59999999999999998, + { 2.4836470664490253, 0.0000000000000000, 0.60000000000000009, 1.5707963267948966 }, }; const double toler097 = 2.5000000000000020e-13; -// Test data for k=0.0000000000000000, nu=0.69999999999999996. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 2.5088894797856263e-16 +// Test data for k=0.0000000000000000, nu=0.70000000000000007. +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 4 +// max(|f - f_Boost| / |f_Boost|): 3.0903019454022601e-16 +// mean(f - f_Boost): -6.9388939039072284e-17 +// variance(f - f_Boost): 5.9442282234173945e-34 +// stddev(f - f_Boost): 2.4380787976227090e-17 const testcase_ellint_3<double> data098[10] = { - { 0.0000000000000000, 0.0000000000000000, 0.69999999999999996, + { 0.0000000000000000, 0.0000000000000000, 0.70000000000000007, 0.0000000000000000 }, - { 0.17331533692234474, 0.0000000000000000, 0.69999999999999996, + { 0.17578180667760368, 0.0000000000000000, 0.70000000000000007, 0.17453292519943295 }, - { 0.33983341309265935, 0.0000000000000000, 0.69999999999999996, + { 0.35926037139410999, 0.0000000000000000, 0.70000000000000007, 0.34906585039886590 }, - { 0.49490198805931979, 0.0000000000000000, 0.69999999999999996, + { 0.55918341315855080, 0.0000000000000000, 0.70000000000000007, 0.52359877559829882 }, - { 0.63679715525145297, 0.0000000000000000, 0.69999999999999996, + { 0.78653584856932546, 0.0000000000000000, 0.70000000000000007, 0.69813170079773179 }, - { 0.76616861049481944, 0.0000000000000000, 0.69999999999999996, + { 1.0558379029273324, 0.0000000000000000, 0.70000000000000007, 0.87266462599716477 }, - { 0.88503143209004198, 0.0000000000000000, 0.69999999999999996, + { 1.3858662544850615, 0.0000000000000000, 0.70000000000000007, 1.0471975511965976 }, - { 0.99596060249112173, 0.0000000000000000, 0.69999999999999996, + { 1.7970491170359040, 0.0000000000000000, 0.70000000000000007, 1.2217304763960306 }, - { 1.1016495050260424, 0.0000000000000000, 0.69999999999999996, + { 2.2992404490153917, 0.0000000000000000, 0.70000000000000007, 1.3962634015954636 }, - { 1.2047457872617382, 0.0000000000000000, 0.69999999999999996, + { 2.8678686047727382, 0.0000000000000000, 0.70000000000000007, 1.5707963267948966 }, }; const double toler098 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.80000000000000004. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8375904358197891e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.2373744057922657e-16 +// mean(f - f_Boost): 1.0269562977782698e-16 +// variance(f - f_Boost): 1.4388836606733082e-32 +// stddev(f - f_Boost): 1.1995347684303728e-16 const testcase_ellint_3<double> data099[10] = { { 0.0000000000000000, 0.0000000000000000, 0.80000000000000004, 0.0000000000000000 }, - { 0.17314386919344210, 0.0000000000000000, 0.80000000000000004, + { 0.17596285706118869, 0.0000000000000000, 0.80000000000000004, 0.17453292519943295 }, - { 0.33858381342073240, 0.0000000000000000, 0.80000000000000004, + { 0.36080593896484231, 0.0000000000000000, 0.80000000000000004, 0.34906585039886590 }, - { 0.49123285640844727, 0.0000000000000000, 0.80000000000000004, + { 0.56501022706967863, 0.0000000000000000, 0.80000000000000004, 0.52359877559829882 }, - { 0.62944854858904509, 0.0000000000000000, 0.80000000000000004, + { 0.80273891984116930, 0.0000000000000000, 0.80000000000000004, 0.69813170079773179 }, - { 0.75421778305499343, 0.0000000000000000, 0.80000000000000004, + { 1.0949425007763358, 0.0000000000000000, 0.80000000000000004, 0.87266462599716477 }, - { 0.86790634112156617, 0.0000000000000000, 0.80000000000000004, + { 1.4736985692253419, 0.0000000000000000, 0.80000000000000004, 1.0471975511965976 }, - { 0.97334918087427558, 0.0000000000000000, 0.80000000000000004, + { 1.9848676587180696, 0.0000000000000000, 0.80000000000000004, 1.2217304763960306 }, - { 1.0734012615283985, 0.0000000000000000, 0.80000000000000004, + { 2.6726187823193546, 0.0000000000000000, 0.80000000000000004, 1.3962634015954636 }, - { 1.1708024551734544, 0.0000000000000000, 0.80000000000000004, + { 3.5124073655203634, 0.0000000000000000, 0.80000000000000004, 1.5707963267948966 }, }; const double toler099 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.90000000000000002. -// max(|f - f_GSL|): 1.1102230246251565e-16 -// max(|f - f_GSL| / |f_GSL|): 1.7838310376154469e-16 +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 6.6108624815885066e-16 +// mean(f - f_Boost): 2.1371793224034264e-16 +// variance(f - f_Boost): 5.6389326618626776e-33 +// stddev(f - f_Boost): 7.5092826966779442e-17 const testcase_ellint_3<double> data100[10] = { { 0.0000000000000000, 0.0000000000000000, 0.90000000000000002, 0.0000000000000000 }, - { 0.17297300811030597, 0.0000000000000000, 0.90000000000000002, + { 0.17614458024574997, 0.0000000000000000, 0.90000000000000002, 0.17453292519943295 }, - { 0.33735034635360817, 0.0000000000000000, 0.90000000000000002, + { 0.36237566578821978, 0.0000000000000000, 0.90000000000000002, 0.34906585039886590 }, - { 0.48765675230233130, 0.0000000000000000, 0.90000000000000002, + { 0.57106058859196640, 0.0000000000000000, 0.90000000000000002, 0.52359877559829882 }, - { 0.62238126886123568, 0.0000000000000000, 0.90000000000000002, + { 0.82019857015755915, 0.0000000000000000, 0.90000000000000002, 0.69813170079773179 }, - { 0.74286600807269243, 0.0000000000000000, 0.90000000000000002, + { 1.1397014388908147, 0.0000000000000000, 0.90000000000000002, 0.87266462599716477 }, - { 0.85181283909264949, 0.0000000000000000, 0.90000000000000002, + { 1.5845952415154960, 0.0000000000000000, 0.90000000000000002, 1.0471975511965976 }, - { 0.95228683995371133, 0.0000000000000000, 0.90000000000000002, + { 2.2620531413370775, 0.0000000000000000, 0.90000000000000002, 1.2217304763960306 }, - { 1.0472730487412552, 0.0000000000000000, 0.90000000000000002, + { 3.3587842061975066, 0.0000000000000000, 0.90000000000000002, 1.3962634015954636 }, - { 1.1395754288497419, 0.0000000000000000, 0.90000000000000002, + { 4.9672941328980507, 0.0000000000000000, 0.90000000000000002, 1.5707963267948966 }, }; const double toler100 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.0000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.1735566504509650e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.1735566504509645e-16 +// mean(f - f_Boost): -5.8286708792820721e-17 +// variance(f - f_Boost): 4.1942474344433133e-34 +// stddev(f - f_Boost): 2.0479861900030756e-17 const testcase_ellint_3<double> data101[10] = { { 0.0000000000000000, 0.10000000000000009, 0.0000000000000000, 0.0000000000000000 }, - { 0.17454173353063659, 0.10000000000000009, 0.0000000000000000, + { 0.17454173353063662, 0.10000000000000009, 0.0000000000000000, 0.17453292519943295 }, - { 0.34913506721468091, 0.10000000000000009, 0.0000000000000000, + { 0.34913506721468096, 0.10000000000000009, 0.0000000000000000, 0.34906585039886590 }, - { 0.52382550016538942, 0.10000000000000009, 0.0000000000000000, + { 0.52382550016538953, 0.10000000000000009, 0.0000000000000000, 0.52359877559829882 }, { 0.69864700854177020, 0.10000000000000009, 0.0000000000000000, 0.69813170079773179 }, - { 0.87361792586964870, 0.10000000000000009, 0.0000000000000000, + { 0.87361792586964859, 0.10000000000000009, 0.0000000000000000, 0.87266462599716477 }, - { 1.0487386319621683, 0.10000000000000009, 0.0000000000000000, + { 1.0487386319621685, 0.10000000000000009, 0.0000000000000000, 1.0471975511965976 }, - { 1.2239913752078757, 0.10000000000000009, 0.0000000000000000, + { 1.2239913752078759, 0.10000000000000009, 0.0000000000000000, 1.2217304763960306 }, - { 1.3993423113684049, 0.10000000000000009, 0.0000000000000000, + { 1.3993423113684051, 0.10000000000000009, 0.0000000000000000, 1.3962634015954636 }, - { 1.5747455615173562, 0.10000000000000009, 0.0000000000000000, + { 1.5747455615173560, 0.10000000000000009, 0.0000000000000000, 1.5707963267948966 }, }; const double toler101 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.10000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3097339877269682e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.0305747373482148e-16 +// mean(f - f_Boost): -3.0531133177191807e-17 +// variance(f - f_Boost): 1.1508025840536076e-34 +// stddev(f - f_Boost): 1.0727546709539920e-17 const testcase_ellint_3<double> data102[10] = { { 0.0000000000000000, 0.10000000000000009, 0.10000000000000001, 0.0000000000000000 }, - { 0.17436589347616613, 0.10000000000000009, 0.10000000000000001, + { 0.17471821213559732, 0.10000000000000009, 0.10000000000000001, 0.17453292519943295 }, - { 0.34776067871237359, 0.10000000000000009, 0.10000000000000001, + { 0.35052902610011138, 0.10000000000000009, 0.10000000000000001, 0.34906585039886590 }, - { 0.51936064354727796, 0.10000000000000009, 0.10000000000000001, + { 0.52842865990255727, 0.10000000000000009, 0.10000000000000001, 0.52359877559829882 }, - { 0.68860303749364349, 0.10000000000000009, 0.10000000000000001, + { 0.70921799731166713, 0.10000000000000009, 0.10000000000000001, 0.69813170079773179 }, - { 0.85524561882332051, 0.10000000000000009, 0.10000000000000001, + { 0.89340330535868662, 0.10000000000000009, 0.10000000000000001, 0.87266462599716477 }, - { 1.0193708301908335, 0.10000000000000009, 0.10000000000000001, + { 1.0811075784236857, 0.10000000000000009, 0.10000000000000001, 1.0471975511965976 }, - { 1.1813474067123044, 0.10000000000000009, 0.10000000000000001, + { 1.2720133232666426, 0.10000000000000009, 0.10000000000000001, 1.2217304763960306 }, - { 1.3417670770424983, 0.10000000000000009, 0.10000000000000001, + { 1.4653630031861395, 0.10000000000000009, 0.10000000000000001, 1.3962634015954636 }, - { 1.5013711111199950, 0.10000000000000009, 0.10000000000000001, + { 1.6600374067558428, 0.10000000000000009, 0.10000000000000001, 1.5707963267948966 }, }; const double toler102 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.20000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.4399947764827574e-16 +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 1.6736714959992433e-16 +// mean(f - f_Boost): 5.5511151231257830e-18 +// variance(f - f_Boost): 3.8043060629871325e-36 +// stddev(f - f_Boost): 1.9504630380981673e-18 const testcase_ellint_3<double> data103[10] = { { 0.0000000000000000, 0.10000000000000009, 0.20000000000000001, 0.0000000000000000 }, - { 0.17419068786141340, 0.10000000000000009, 0.20000000000000001, + { 0.17489533344059083, 0.10000000000000009, 0.20000000000000001, 0.17453292519943295 }, - { 0.34640537686230133, 0.10000000000000009, 0.20000000000000001, + { 0.35194305707815038, 0.10000000000000009, 0.20000000000000001, 0.34906585039886590 }, - { 0.51502689171753946, 0.10000000000000009, 0.20000000000000001, + { 0.53317790741512527, 0.10000000000000009, 0.20000000000000001, 0.52359877559829882 }, - { 0.67904147863672715, 0.10000000000000009, 0.20000000000000001, + { 0.72036681615081222, 0.10000000000000009, 0.20000000000000001, 0.69813170079773179 }, - { 0.83811885126105179, 0.10000000000000009, 0.20000000000000001, + { 0.91480372268244303, 0.10000000000000009, 0.20000000000000001, 0.87266462599716477 }, - { 0.99255278555742787, 0.10000000000000009, 0.20000000000000001, + { 1.1170528708071514, 0.10000000000000009, 0.20000000000000001, 1.0471975511965976 }, - { 1.1431260546194930, 0.10000000000000009, 0.20000000000000001, + { 1.3266916802718358, 0.10000000000000009, 0.20000000000000001, 1.2217304763960306 }, - { 1.2909589656532101, 0.10000000000000009, 0.20000000000000001, + { 1.5421622241831547, 0.10000000000000009, 0.20000000000000001, 1.3962634015954636 }, - { 1.4373749386463430, 0.10000000000000009, 0.20000000000000001, + { 1.7608656115083421, 0.10000000000000009, 0.20000000000000001, 1.5707963267948966 }, }; const double toler103 = 2.5000000000000020e-13; -// Test data for k=0.10000000000000009, nu=0.29999999999999999. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.5650492137236872e-16 +// Test data for k=0.10000000000000009, nu=0.30000000000000004. +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 1.9186071760326645e-16 +// mean(f - f_Boost): -1.6653345369377347e-17 +// variance(f - f_Boost): 3.4238754566884194e-35 +// stddev(f - f_Boost): 5.8513891142945016e-18 const testcase_ellint_3<double> data104[10] = { - { 0.0000000000000000, 0.10000000000000009, 0.29999999999999999, + { 0.0000000000000000, 0.10000000000000009, 0.30000000000000004, 0.0000000000000000 }, - { 0.17401611261390104, 0.10000000000000009, 0.29999999999999999, + { 0.17507310163441189, 0.10000000000000009, 0.30000000000000004, 0.17453292519943295 }, - { 0.34506869507511773, 0.10000000000000009, 0.29999999999999999, + { 0.35337768072524217, 0.10000000000000009, 0.30000000000000004, 0.34906585039886590 }, - { 0.51081757604259859, 0.10000000000000009, 0.29999999999999999, + { 0.53808167801629170, 0.10000000000000009, 0.30000000000000004, 0.52359877559829882 }, - { 0.66992297597712303, 0.10000000000000009, 0.29999999999999999, + { 0.73215166755955019, 0.10000000000000009, 0.30000000000000004, 0.69813170079773179 }, - { 0.82209722856174228, 0.10000000000000009, 0.29999999999999999, + { 0.93806546000201219, 0.10000000000000009, 0.30000000000000004, 0.87266462599716477 }, - { 0.96792430487669590, 0.10000000000000009, 0.29999999999999999, + { 1.1573218723395986, 0.10000000000000009, 0.30000000000000004, 1.0471975511965976 }, - { 1.1085964108954092, 0.10000000000000009, 0.29999999999999999, + { 1.3897859679542097, 0.10000000000000009, 0.30000000000000004, 1.2217304763960306 }, - { 1.2456748370836999, 0.10000000000000009, 0.29999999999999999, + { 1.6331009404328622, 0.10000000000000009, 0.30000000000000004, 1.3962634015954636 }, - { 1.3809159606704959, 0.10000000000000009, 0.29999999999999999, + { 1.8826015946315438, 0.10000000000000009, 0.30000000000000004, 1.5707963267948966 }, }; const double toler104 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.40000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.6854758534459740e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.0338059536914377e-16 +// mean(f - f_Boost): 2.7755575615628914e-17 +// variance(f - f_Boost): 9.5107651574678308e-35 +// stddev(f - f_Boost): 9.7523151904908362e-18 const testcase_ellint_3<double> data105[10] = { { 0.0000000000000000, 0.10000000000000009, 0.40000000000000002, 0.0000000000000000 }, - { 0.17384216369897931, 0.10000000000000009, 0.40000000000000002, + { 0.17525152094559704, 0.10000000000000009, 0.40000000000000002, 0.17453292519943295 }, - { 0.34375018311376787, 0.10000000000000009, 0.40000000000000002, + { 0.35483343742825979, 0.10000000000000009, 0.40000000000000002, 0.34906585039886590 }, - { 0.50672650758380455, 0.10000000000000009, 0.40000000000000002, + { 0.54314913099505446, 0.10000000000000009, 0.40000000000000002, 0.52359877559829882 }, - { 0.66121264213337616, 0.10000000000000009, 0.40000000000000002, + { 0.74463962034766862, 0.10000000000000009, 0.40000000000000002, 0.69813170079773179 }, - { 0.80706202005774441, 0.10000000000000009, 0.40000000000000002, + { 0.96349276837570441, 0.10000000000000009, 0.40000000000000002, 0.87266462599716477 }, - { 0.94519376138245870, 0.10000000000000009, 0.40000000000000002, + { 1.2029081382746343, 0.10000000000000009, 0.40000000000000002, 1.0471975511965976 }, - { 1.0771880300759584, 0.10000000000000009, 0.40000000000000002, + { 1.4638022887050806, 0.10000000000000009, 0.40000000000000002, 1.2217304763960306 }, - { 1.2049711557188272, 0.10000000000000009, 0.40000000000000002, + { 1.7432413830105224, 0.10000000000000009, 0.40000000000000002, 1.3962634015954636 }, - { 1.3306223265207477, 0.10000000000000009, 0.40000000000000002, + { 2.0336367403076760, 0.10000000000000009, 0.40000000000000002, 1.5707963267948966 }, }; const double toler105 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.50000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8017534281650347e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.9864616042835278e-16 +// mean(f - f_Boost): 9.4368957093138303e-17 +// variance(f - f_Boost): 7.7794254682023874e-32 +// stddev(f - f_Boost): 2.7891621444803792e-16 const testcase_ellint_3<double> data106[10] = { { 0.0000000000000000, 0.10000000000000009, 0.50000000000000000, 0.0000000000000000 }, - { 0.17366883711936548, 0.10000000000000009, 0.50000000000000000, + { 0.17543059564292182, 0.10000000000000009, 0.50000000000000000, 0.17453292519943295 }, - { 0.34244940634881882, 0.10000000000000009, 0.50000000000000000, + { 0.35631088838721664, 0.10000000000000009, 0.50000000000000000, 0.34906585039886590 }, - { 0.50274793281634367, 0.10000000000000009, 0.50000000000000000, + { 0.54839023346436455, 0.10000000000000009, 0.50000000000000000, 0.52359877559829882 }, - { 0.65287941633275082, 0.10000000000000009, 0.50000000000000000, + { 0.75790846946088830, 0.10000000000000009, 0.50000000000000000, 0.69813170079773179 }, - { 0.79291198790315398, 0.10000000000000009, 0.50000000000000000, + { 0.99146713686720678, 0.10000000000000009, 0.50000000000000000, 0.87266462599716477 }, - { 0.92412201537880323, 0.10000000000000009, 0.50000000000000000, + { 1.2551692247937198, 0.10000000000000009, 0.50000000000000000, 1.0471975511965976 }, - { 1.0484480076799372, 0.10000000000000009, 0.50000000000000000, + { 1.5524660788146873, 0.10000000000000009, 0.50000000000000000, 1.2217304763960306 }, - { 1.1681168130475206, 0.10000000000000009, 0.50000000000000000, + { 1.8806578570830670, 0.10000000000000009, 0.50000000000000000, 1.3962634015954636 }, - { 1.2854480708580160, 0.10000000000000009, 0.50000000000000000, + { 2.2279868912966849, 0.10000000000000009, 0.50000000000000000, 1.5707963267948966 }, }; const double toler106 = 2.5000000000000020e-13; -// Test data for k=0.10000000000000009, nu=0.59999999999999998. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.9142834151672032e-16 +// Test data for k=0.10000000000000009, nu=0.60000000000000009. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.6726146516228014e-16 +// mean(f - f_Boost): -3.6082248300317589e-17 +// variance(f - f_Boost): 1.6073193116120635e-34 +// stddev(f - f_Boost): 1.2678009747638087e-17 const testcase_ellint_3<double> data107[10] = { - { 0.0000000000000000, 0.10000000000000009, 0.59999999999999998, + { 0.0000000000000000, 0.10000000000000009, 0.60000000000000009, 0.0000000000000000 }, - { 0.17349612891469013, 0.10000000000000009, 0.59999999999999998, + { 0.17561033003590576, 0.10000000000000009, 0.60000000000000009, 0.17453292519943295 }, - { 0.34116594505539444, 0.10000000000000009, 0.59999999999999998, + { 0.35781061668171932, 0.10000000000000009, 0.60000000000000009, 0.34906585039886590 }, - { 0.49887649430466674, 0.10000000000000009, 0.59999999999999998, + { 0.55381585659629196, 0.10000000000000009, 0.60000000000000009, 0.52359877559829882 }, - { 0.64489553282165146, 0.10000000000000009, 0.59999999999999998, + { 0.77204910484575640, 0.10000000000000009, 0.60000000000000009, 0.69813170079773179 }, - { 0.77956016553782437, 0.10000000000000009, 0.59999999999999998, + { 1.0224751740393108, 0.10000000000000009, 0.60000000000000009, 0.87266462599716477 }, - { 0.90451074530096287, 0.10000000000000009, 0.59999999999999998, + { 1.3160230906351114, 0.10000000000000009, 0.60000000000000009, 1.0471975511965976 }, - { 1.0220113666961632, 0.10000000000000009, 0.59999999999999998, + { 1.6616282844233206, 0.10000000000000009, 0.60000000000000009, 1.2217304763960306 }, - { 1.1345351441065563, 0.10000000000000009, 0.59999999999999998, + { 2.0592555664850392, 0.10000000000000009, 0.60000000000000009, 1.3962634015954636 }, - { 1.2445798942989255, 0.10000000000000009, 0.59999999999999998, + { 2.4913004919173822, 0.10000000000000009, 0.60000000000000009, 1.5707963267948966 }, }; const double toler107 = 2.5000000000000020e-13; -// Test data for k=0.10000000000000009, nu=0.69999999999999996. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 5.5172091551439012e-16 +// Test data for k=0.10000000000000009, nu=0.70000000000000007. +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 5 +// max(|f - f_Boost| / |f_Boost|): 2.1004074871280821e-16 +// mean(f - f_Boost): 3.3306690738754695e-17 +// variance(f - f_Boost): 1.3695501826753678e-34 +// stddev(f - f_Boost): 1.1702778228589003e-17 const testcase_ellint_3<double> data108[10] = { - { 0.0000000000000000, 0.10000000000000009, 0.69999999999999996, + { 0.0000000000000000, 0.10000000000000009, 0.70000000000000007, 0.0000000000000000 }, - { 0.17332403516105047, 0.10000000000000009, 0.69999999999999996, + { 0.17579072847532518, 0.10000000000000009, 0.70000000000000007, 0.17453292519943295 }, - { 0.33989939374896883, 0.10000000000000009, 0.69999999999999996, + { 0.35933322840606297, 0.10000000000000009, 0.70000000000000007, 0.34906585039886590 }, - { 0.49510719568614070, 0.10000000000000009, 0.69999999999999996, + { 0.55943788649460324, 0.10000000000000009, 0.70000000000000007, 0.52359877559829882 }, - { 0.63723607776354974, 0.10000000000000009, 0.69999999999999996, + { 0.78716856504031707, 0.10000000000000009, 0.70000000000000007, 0.69813170079773179 }, - { 0.76693133887935327, 0.10000000000000009, 0.69999999999999996, + { 1.0571501305617423, 0.10000000000000009, 0.70000000000000007, 0.87266462599716477 }, - { 0.88619382078823805, 0.10000000000000009, 0.69999999999999996, + { 1.3882948301743525, 0.10000000000000009, 0.70000000000000007, 1.0471975511965976 }, - { 0.99758012018676490, 0.10000000000000009, 0.69999999999999996, + { 1.8011785680114223, 0.10000000000000009, 0.70000000000000007, 1.2217304763960306 }, - { 1.1037642270814410, 0.10000000000000009, 0.69999999999999996, + { 2.3057268183616464, 0.10000000000000009, 0.70000000000000007, 1.3962634015954636 }, - { 1.2073745911083185, 0.10000000000000009, 0.69999999999999996, + { 2.8771910188009739, 0.10000000000000009, 0.70000000000000007, 1.5707963267948966 }, }; const double toler108 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1294144515772258e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.3133043868392355e-16 +// mean(f - f_Boost): 1.8041124150158794e-16 +// variance(f - f_Boost): 6.1843750436434569e-32 +// stddev(f - f_Boost): 2.4868403735751633e-16 const testcase_ellint_3<double> data109[10] = { { 0.0000000000000000, 0.10000000000000009, 0.80000000000000004, 0.0000000000000000 }, - { 0.17315255197057014, 0.10000000000000009, 0.80000000000000004, + { 0.17597179535373417, 0.10000000000000009, 0.80000000000000004, 0.17453292519943295 }, - { 0.33864936055747991, 0.10000000000000009, 0.80000000000000004, + { 0.36087935387831499, 0.10000000000000009, 0.80000000000000004, 0.34906585039886590 }, - { 0.49143537041117613, 0.10000000000000009, 0.80000000000000004, + { 0.56526935244526444, 0.10000000000000009, 0.80000000000000004, 0.52359877559829882 }, - { 0.62987861760047492, 0.10000000000000009, 0.80000000000000004, + { 0.80339402590612397, 0.10000000000000009, 0.80000000000000004, 0.69813170079773179 }, - { 0.75496005490917517, 0.10000000000000009, 0.80000000000000004, + { 1.0963358646374459, 0.10000000000000009, 0.80000000000000004, 0.87266462599716477 }, - { 0.86903081862701881, 0.10000000000000009, 0.80000000000000004, + { 1.4763748483246868, 0.10000000000000009, 0.80000000000000004, 1.0471975511965976 }, - { 0.97490814820725591, 0.10000000000000009, 0.80000000000000004, + { 1.9896610222794102, 0.10000000000000009, 0.80000000000000004, 1.2217304763960306 }, - { 1.0754290107171083, 0.10000000000000009, 0.80000000000000004, + { 2.6806423920122024, 0.10000000000000009, 0.80000000000000004, 1.3962634015954636 }, - { 1.1733158866987732, 0.10000000000000009, 0.80000000000000004, + { 3.5246199613295612, 0.10000000000000009, 0.80000000000000004, 1.5707963267948966 }, }; const double toler109 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.90000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2325599449457852e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.5624826890976725e-16 +// mean(f - f_Boost): 2.3314683517128288e-16 +// variance(f - f_Boost): 2.9401198977189756e-31 +// stddev(f - f_Boost): 5.4222872459129045e-16 const testcase_ellint_3<double> data110[10] = { { 0.0000000000000000, 0.10000000000000009, 0.90000000000000002, 0.0000000000000000 }, - { 0.17298167549096563, 0.10000000000000009, 0.90000000000000002, + { 0.17615353510599349, 0.10000000000000009, 0.90000000000000002, 0.17453292519943295 }, - { 0.33741546662741589, 0.10000000000000009, 0.90000000000000002, + { 0.36244964892922371, 0.10000000000000009, 0.90000000000000002, 0.34906585039886590 }, - { 0.48785665376856868, 0.10000000000000009, 0.90000000000000002, + { 0.57132457590110530, 0.10000000000000009, 0.90000000000000002, 0.52359877559829882 }, - { 0.62280288554518959, 0.10000000000000009, 0.90000000000000002, + { 0.82087808820385000, 0.10000000000000009, 0.90000000000000002, 0.69813170079773179 }, - { 0.74358903115455188, 0.10000000000000009, 0.90000000000000002, + { 1.1411894342144451, 0.10000000000000009, 0.90000000000000002, 0.87266462599716477 }, - { 0.85290207679298335, 0.10000000000000009, 0.90000000000000002, + { 1.5875929286844597, 0.10000000000000009, 0.90000000000000002, 1.0471975511965976 }, - { 0.95379006645397379, 0.10000000000000009, 0.90000000000000002, + { 2.2678622986596659, 0.10000000000000009, 0.90000000000000002, 1.2217304763960306 }, - { 1.0492213119872327, 0.10000000000000009, 0.90000000000000002, + { 3.3697528941897903, 0.10000000000000009, 0.90000000000000002, 1.3962634015954636 }, - { 1.1419839485283374, 0.10000000000000009, 0.90000000000000002, + { 4.9862890417305499, 0.10000000000000009, 0.90000000000000002, 1.5707963267948966 }, }; const double toler110 = 2.5000000000000020e-13; -// Test data for k=0.19999999999999996, nu=0.0000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2156475739151676e-16 +// Test data for k=0.20000000000000018, nu=0.0000000000000000. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 4.2156475739151676e-16 +// mean(f - f_Boost): -5.2735593669694933e-17 +// variance(f - f_Boost): 3.0473442641042680e-32 +// stddev(f - f_Boost): 1.7456644190978597e-16 const testcase_ellint_3<double> data111[10] = { - { 0.0000000000000000, 0.19999999999999996, 0.0000000000000000, + { 0.0000000000000000, 0.20000000000000018, 0.0000000000000000, 0.0000000000000000 }, - { 0.17456817290292809, 0.19999999999999996, 0.0000000000000000, + { 0.17456817290292806, 0.20000000000000018, 0.0000000000000000, 0.17453292519943295 }, - { 0.34934315932086801, 0.19999999999999996, 0.0000000000000000, + { 0.34934315932086796, 0.20000000000000018, 0.0000000000000000, 0.34906585039886590 }, - { 0.52450880529443988, 0.19999999999999996, 0.0000000000000000, + { 0.52450880529443988, 0.20000000000000018, 0.0000000000000000, 0.52359877559829882 }, - { 0.70020491009844876, 0.19999999999999996, 0.0000000000000000, + { 0.70020491009844887, 0.20000000000000018, 0.0000000000000000, 0.69813170079773179 }, - { 0.87651006649967955, 0.19999999999999996, 0.0000000000000000, + { 0.87651006649967977, 0.20000000000000018, 0.0000000000000000, 0.87266462599716477 }, - { 1.0534305870298994, 0.19999999999999996, 0.0000000000000000, + { 1.0534305870298994, 0.20000000000000018, 0.0000000000000000, 1.0471975511965976 }, - { 1.2308975521670784, 0.19999999999999996, 0.0000000000000000, + { 1.2308975521670789, 0.20000000000000018, 0.0000000000000000, 1.2217304763960306 }, - { 1.4087733584990738, 0.19999999999999996, 0.0000000000000000, + { 1.4087733584990738, 0.20000000000000018, 0.0000000000000000, 1.3962634015954636 }, - { 1.5868678474541660, 0.19999999999999996, 0.0000000000000000, + { 1.5868678474541662, 0.20000000000000018, 0.0000000000000000, 1.5707963267948966 }, }; const double toler111 = 2.5000000000000020e-13; -// Test data for k=0.19999999999999996, nu=0.10000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.3374593253183472e-16 +// Test data for k=0.20000000000000018, nu=0.10000000000000001. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 4.0890622182605400e-16 +// mean(f - f_Boost): -3.8857805861880476e-17 +// variance(f - f_Boost): 2.8794792590749608e-32 +// stddev(f - f_Boost): 1.6969028431454054e-16 const testcase_ellint_3<double> data112[10] = { - { 0.0000000000000000, 0.19999999999999996, 0.10000000000000001, + { 0.0000000000000000, 0.20000000000000018, 0.10000000000000001, 0.0000000000000000 }, - { 0.17439228502691748, 0.19999999999999996, 0.10000000000000001, + { 0.17474469953608965, 0.20000000000000018, 0.10000000000000001, 0.17453292519943295 }, - { 0.34796731137565740, 0.19999999999999996, 0.10000000000000001, + { 0.35073860234984255, 0.20000000000000018, 0.10000000000000001, 0.34906585039886590 }, - { 0.52003370294544848, 0.19999999999999996, 0.10000000000000001, + { 0.52912258712951521, 0.20000000000000018, 0.10000000000000001, 0.52359877559829882 }, - { 0.69012222258631462, 0.19999999999999996, 0.10000000000000001, + { 0.71081701558898069, 0.20000000000000018, 0.10000000000000001, 0.69813170079773179 }, - { 0.85803491465566772, 0.19999999999999996, 0.10000000000000001, + { 0.89640758521169384, 0.20000000000000018, 0.10000000000000001, 0.87266462599716477 }, - { 1.0238463961099364, 0.19999999999999996, 0.10000000000000001, + { 1.0860417038089853, 0.20000000000000018, 0.10000000000000001, 1.0471975511965976 }, - { 1.1878691059202153, 0.19999999999999996, 0.10000000000000001, + { 1.2793599255528623, 0.20000000000000018, 0.10000000000000001, 1.2217304763960306 }, - { 1.3505985031831940, 0.19999999999999996, 0.10000000000000001, + { 1.4754938544089076, 0.20000000000000018, 0.10000000000000001, 1.3962634015954636 }, - { 1.5126513474261087, 0.19999999999999996, 0.10000000000000001, + { 1.6731552050562593, 0.20000000000000018, 0.10000000000000001, 1.5707963267948966 }, }; const double toler112 = 2.5000000000000020e-13; -// Test data for k=0.19999999999999996, nu=0.20000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.4549984059502760e-16 +// Test data for k=0.20000000000000018, nu=0.20000000000000001. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 3.9570963716579749e-16 +// mean(f - f_Boost): -5.8286708792820721e-17 +// variance(f - f_Boost): 3.1158217732380362e-32 +// stddev(f - f_Boost): 1.7651690494788412e-16 const testcase_ellint_3<double> data113[10] = { - { 0.0000000000000000, 0.19999999999999996, 0.20000000000000001, + { 0.0000000000000000, 0.20000000000000018, 0.20000000000000001, 0.0000000000000000 }, - { 0.17421703179583747, 0.19999999999999996, 0.20000000000000001, + { 0.17492186907740698, 0.20000000000000018, 0.20000000000000001, 0.17453292519943295 }, - { 0.34661057411998791, 0.19999999999999996, 0.20000000000000001, + { 0.35215414286134267, 0.20000000000000018, 0.20000000000000001, 0.34906585039886590 }, - { 0.51569006052647393, 0.19999999999999996, 0.20000000000000001, + { 0.53388285615182440, 0.20000000000000018, 0.20000000000000001, 0.52359877559829882 }, - { 0.68052412821107244, 0.19999999999999996, 0.20000000000000001, + { 0.72200960282688265, 0.20000000000000018, 0.20000000000000001, 0.69813170079773179 }, - { 0.84081341263313825, 0.19999999999999996, 0.20000000000000001, + { 0.91793087614428526, 0.20000000000000018, 0.20000000000000001, 0.87266462599716477 }, - { 0.99683359988842890, 0.19999999999999996, 0.20000000000000001, + { 1.1222602841587976, 0.20000000000000018, 0.20000000000000001, 1.0471975511965976 }, - { 1.1493086715118852, 0.19999999999999996, 0.20000000000000001, + { 1.3345489407496247, 0.20000000000000018, 0.20000000000000001, 1.2217304763960306 }, - { 1.2992699693957541, 0.19999999999999996, 0.20000000000000001, + { 1.5531225705475502, 0.20000000000000018, 0.20000000000000001, 1.3962634015954636 }, - { 1.4479323932249564, 0.19999999999999996, 0.20000000000000001, + { 1.7751816279738935, 0.20000000000000018, 0.20000000000000001, 1.5707963267948966 }, }; const double toler113 = 2.5000000000000020e-13; -// Test data for k=0.19999999999999996, nu=0.29999999999999999. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 5.3140668101543467e-16 +// Test data for k=0.20000000000000018, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.6785817924053817e-16 +// mean(f - f_Boost): -1.1102230246251566e-17 +// variance(f - f_Boost): 9.9840208317034302e-32 +// stddev(f - f_Boost): 3.1597501217190311e-16 const testcase_ellint_3<double> data114[10] = { - { 0.0000000000000000, 0.19999999999999996, 0.29999999999999999, + { 0.0000000000000000, 0.20000000000000018, 0.30000000000000004, 0.0000000000000000 }, - { 0.17404240913577704, 0.19999999999999996, 0.29999999999999999, + { 0.17509968571715159, 0.20000000000000018, 0.30000000000000004, 0.17453292519943295 }, - { 0.34527248032587193, 0.19999999999999996, 0.29999999999999999, + { 0.35359030214835629, 0.20000000000000018, 0.30000000000000004, 0.34906585039886590 }, - { 0.51147118981668416, 0.19999999999999996, 0.29999999999999999, + { 0.53879807274537084, 0.20000000000000018, 0.30000000000000004, 0.52359877559829882 }, - { 0.67137107867777601, 0.19999999999999996, 0.29999999999999999, + { 0.73384116418059731, 0.20000000000000018, 0.30000000000000004, 0.69813170079773179 }, - { 0.82470418188668893, 0.19999999999999996, 0.29999999999999999, + { 0.94132799329524031, 0.20000000000000018, 0.30000000000000004, 0.87266462599716477 }, - { 0.97202873223594299, 0.19999999999999996, 0.29999999999999999, + { 1.1628407021801439, 0.20000000000000018, 0.30000000000000004, 1.0471975511965976 }, - { 1.1144773569375266, 0.19999999999999996, 0.29999999999999999, + { 1.3982440216739438, 0.20000000000000018, 0.30000000000000004, 1.2217304763960306 }, - { 1.2535292433701000, 0.19999999999999996, 0.29999999999999999, + { 1.6450634983653640, 0.20000000000000018, 0.30000000000000004, 1.3962634015954636 }, - { 1.3908453514752477, 0.19999999999999996, 0.29999999999999999, + { 1.8983924169967099, 0.20000000000000018, 0.30000000000000004, 1.5707963267948966 }, }; const double toler114 = 2.5000000000000020e-13; -// Test data for k=0.19999999999999996, nu=0.40000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.6788709752760483e-16 +// Test data for k=0.20000000000000018, nu=0.40000000000000002. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 3.6738449250038925e-16 +// mean(f - f_Boost): -3.0531133177191807e-17 +// variance(f - f_Boost): 2.7810428396951687e-32 +// stddev(f - f_Boost): 1.6676458975739331e-16 const testcase_ellint_3<double> data115[10] = { - { 0.0000000000000000, 0.19999999999999996, 0.40000000000000002, + { 0.0000000000000000, 0.20000000000000018, 0.40000000000000002, 0.0000000000000000 }, - { 0.17386841301066674, 0.19999999999999996, 0.40000000000000002, + { 0.17527815368535152, 0.20000000000000018, 0.40000000000000002, 0.17453292519943295 }, - { 0.34395257914113253, 0.19999999999999996, 0.40000000000000002, + { 0.35504762134297801, 0.20000000000000018, 0.40000000000000002, 0.34906585039886590 }, - { 0.50737088376869466, 0.19999999999999996, 0.40000000000000002, + { 0.54387742353211344, 0.20000000000000018, 0.40000000000000002, 0.52359877559829882 }, - { 0.66262801717277631, 0.19999999999999996, 0.40000000000000002, + { 0.74637910471804259, 0.20000000000000018, 0.40000000000000002, 0.69813170079773179 }, - { 0.80958766645079094, 0.19999999999999996, 0.40000000000000002, + { 0.96690539714174639, 0.20000000000000018, 0.40000000000000002, 0.87266462599716477 }, - { 0.94913754236162040, 0.19999999999999996, 0.40000000000000002, + { 1.2087859420184757, 0.20000000000000018, 0.40000000000000002, 1.0471975511965976 }, - { 1.0827985514222997, 0.19999999999999996, 0.40000000000000002, + { 1.4729799844168852, 0.20000000000000018, 0.40000000000000002, 1.2217304763960306 }, - { 1.2124212429050478, 0.19999999999999996, 0.40000000000000002, + { 1.7564445064596661, 0.20000000000000018, 0.40000000000000002, 1.3962634015954636 }, - { 1.3400002519661005, 0.19999999999999996, 0.40000000000000002, + { 2.0512956926676806, 0.20000000000000018, 0.40000000000000002, 1.5707963267948966 }, }; const double toler115 = 2.5000000000000020e-13; -// Test data for k=0.19999999999999996, nu=0.50000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.7788201301356829e-16 +// Test data for k=0.20000000000000018, nu=0.50000000000000000. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.3841806057292116e-16 +// mean(f - f_Boost): 3.6082248300317589e-17 +// variance(f - f_Boost): 8.9638010532618564e-32 +// stddev(f - f_Boost): 2.9939607634806868e-16 const testcase_ellint_3<double> data116[10] = { - { 0.0000000000000000, 0.19999999999999996, 0.50000000000000000, + { 0.0000000000000000, 0.20000000000000018, 0.50000000000000000, 0.0000000000000000 }, - { 0.17369503942181799, 0.19999999999999996, 0.50000000000000000, + { 0.17545727725228877, 0.20000000000000018, 0.50000000000000000, 0.17453292519943295 }, - { 0.34265043534362660, 0.19999999999999996, 0.50000000000000000, + { 0.35652666242062175, 0.20000000000000018, 0.50000000000000000, 0.34906585039886590 }, - { 0.50338337208655415, 0.19999999999999996, 0.50000000000000000, + { 0.54913090549102406, 0.20000000000000018, 0.50000000000000000, 0.52359877559829882 }, - { 0.65426373297163609, 0.19999999999999996, 0.50000000000000000, + { 0.75970161209211551, 0.20000000000000018, 0.50000000000000000, 0.69813170079773179 }, - { 0.79536193036145808, 0.19999999999999996, 0.50000000000000000, + { 0.99504737401590326, 0.20000000000000018, 0.50000000000000000, 0.87266462599716477 }, - { 0.92791875910061605, 0.19999999999999996, 0.50000000000000000, + { 1.2614666007124373, 0.20000000000000018, 0.50000000000000000, 1.0471975511965976 }, - { 1.0538145052725829, 0.19999999999999996, 0.50000000000000000, + { 1.5625255355205498, 0.20000000000000018, 0.50000000000000000, 1.2217304763960306 }, - { 1.1752060022875899, 0.19999999999999996, 0.50000000000000000, + { 1.8954460255613346, 0.20000000000000018, 0.50000000000000000, 1.3962634015954636 }, - { 1.2943374404397372, 0.19999999999999996, 0.50000000000000000, + { 2.2481046259421302, 0.20000000000000018, 0.50000000000000000, 1.5707963267948966 }, }; const double toler116 = 2.5000000000000020e-13; -// Test data for k=0.19999999999999996, nu=0.59999999999999998. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.8899223779598256e-16 +// Test data for k=0.20000000000000018, nu=0.60000000000000009. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.5317584994994743e-16 +// mean(f - f_Boost): -1.3877787807814457e-17 +// variance(f - f_Boost): 1.0045745697575397e-31 +// stddev(f - f_Boost): 3.1695024369095219e-16 const testcase_ellint_3<double> data117[10] = { - { 0.0000000000000000, 0.19999999999999996, 0.59999999999999998, + { 0.0000000000000000, 0.20000000000000018, 0.60000000000000009, 0.0000000000000000 }, - { 0.17352228440746925, 0.19999999999999996, 0.59999999999999998, + { 0.17563706072900442, 0.20000000000000018, 0.60000000000000009, 0.17453292519943295 }, - { 0.34136562863713626, 0.19999999999999996, 0.59999999999999998, + { 0.35802800926807238, 0.20000000000000018, 0.60000000000000009, 0.34906585039886590 }, - { 0.49950328177638481, 0.19999999999999996, 0.59999999999999998, + { 0.55456942250515051, 0.20000000000000018, 0.60000000000000009, 0.52359877559829882 }, - { 0.64625032705690799, 0.19999999999999996, 0.59999999999999998, + { 0.77390003828438203, 0.20000000000000018, 0.60000000000000009, 0.69813170079773179 }, - { 0.78193941198403083, 0.19999999999999996, 0.59999999999999998, + { 1.0262441366366397, 0.20000000000000018, 0.60000000000000009, 0.87266462599716477 }, - { 0.90817230934317128, 0.19999999999999996, 0.59999999999999998, + { 1.3228192988439669, 0.20000000000000018, 0.60000000000000009, 1.0471975511965976 }, - { 1.0271563751276462, 0.19999999999999996, 0.59999999999999998, + { 1.6728005754680795, 0.20000000000000018, 0.60000000000000009, 1.2217304763960306 }, - { 1.1412999379040518, 0.19999999999999996, 0.59999999999999998, + { 2.0761587107468511, 0.20000000000000018, 0.60000000000000009, 1.3962634015954636 }, - { 1.2530330675914556, 0.19999999999999996, 0.59999999999999998, + { 2.5148333891629315, 0.20000000000000018, 0.60000000000000009, 1.5707963267948966 }, }; const double toler117 = 2.5000000000000020e-13; -// Test data for k=0.19999999999999996, nu=0.69999999999999996. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 5.9999318361775115e-16 +// Test data for k=0.20000000000000018, nu=0.70000000000000007. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.2209418045118284e-16 +// mean(f - f_Boost): 2.4980018054066023e-17 +// variance(f - f_Boost): 9.1989071679544611e-32 +// stddev(f - f_Boost): 3.0329700242426498e-16 const testcase_ellint_3<double> data118[10] = { - { 0.0000000000000000, 0.19999999999999996, 0.69999999999999996, + { 0.0000000000000000, 0.20000000000000018, 0.70000000000000007, 0.0000000000000000 }, - { 0.17335014404233895, 0.19999999999999996, 0.69999999999999996, + { 0.17581750846781172, 0.20000000000000018, 0.70000000000000007, 0.17453292519943295 }, - { 0.34009775298617811, 0.19999999999999996, 0.69999999999999996, + { 0.35955226882028513, 0.20000000000000018, 0.70000000000000007, 0.34906585039886590 }, - { 0.49572560201923810, 0.19999999999999996, 0.69999999999999996, + { 0.56020489659466499, 0.20000000000000018, 0.70000000000000007, 0.52359877559829882 }, - { 0.63856276669886503, 0.19999999999999996, 0.69999999999999996, + { 0.78908196988531498, 0.20000000000000018, 0.70000000000000007, 0.69813170079773179 }, - { 0.76924438644867565, 0.19999999999999996, 0.69999999999999996, + { 1.0611336754143517, 0.20000000000000018, 0.70000000000000007, 0.87266462599716477 }, - { 0.88973060843856466, 0.19999999999999996, 0.69999999999999996, + { 1.3956969951058884, 0.20000000000000018, 0.70000000000000007, 1.0471975511965976 }, - { 1.0025230471636377, 0.19999999999999996, 0.69999999999999996, + { 1.8138131612209609, 0.20000000000000018, 0.70000000000000007, 1.2217304763960306 }, - { 1.1102356376093103, 0.19999999999999996, 0.69999999999999996, + { 2.3256365528879561, 0.20000000000000018, 0.70000000000000007, 1.3962634015954636 }, - { 1.2154356555075863, 0.19999999999999996, 0.69999999999999996, + { 2.9058704854500963, 0.20000000000000018, 0.70000000000000007, 1.5707963267948966 }, }; const double toler118 = 2.5000000000000020e-13; -// Test data for k=0.19999999999999996, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 5.0901276230707249e-16 +// Test data for k=0.20000000000000018, nu=0.80000000000000004. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.7399960886656824e-16 +// mean(f - f_Boost): 1.3877787807814457e-16 +// variance(f - f_Boost): 1.7585404776158019e-31 +// stddev(f - f_Boost): 4.1934955319110593e-16 const testcase_ellint_3<double> data119[10] = { - { 0.0000000000000000, 0.19999999999999996, 0.80000000000000004, + { 0.0000000000000000, 0.20000000000000018, 0.80000000000000004, 0.0000000000000000 }, - { 0.17317861443718538, 0.19999999999999996, 0.80000000000000004, + { 0.17599862486281712, 0.20000000000000018, 0.80000000000000004, 0.17453292519943295 }, - { 0.33884641598718701, 0.19999999999999996, 0.80000000000000004, + { 0.36110007227128776, 0.20000000000000018, 0.80000000000000004, 0.34906585039886590 }, - { 0.49204565281259494, 0.19999999999999996, 0.80000000000000004, + { 0.56605039658567224, 0.20000000000000018, 0.80000000000000004, 0.52359877559829882 }, - { 0.63117851188220320, 0.19999999999999996, 0.80000000000000004, + { 0.80537523874517691, 0.20000000000000018, 0.80000000000000004, 0.69813170079773179 }, - { 0.75721095949544170, 0.19999999999999996, 0.80000000000000004, + { 1.1005662342414086, 0.20000000000000018, 0.80000000000000004, 0.87266462599716477 }, - { 0.87245201443919118, 0.19999999999999996, 0.80000000000000004, + { 1.4845340298105778, 0.20000000000000018, 0.80000000000000004, 1.0471975511965976 }, - { 0.97966584238831089, 0.19999999999999996, 0.80000000000000004, + { 2.0043332244969392, 0.20000000000000018, 0.80000000000000004, 1.2217304763960306 }, - { 1.0816336325174360, 0.19999999999999996, 0.80000000000000004, + { 2.7052856676744761, 0.20000000000000018, 0.80000000000000004, 1.3962634015954636 }, - { 1.1810223448909909, 0.19999999999999996, 0.80000000000000004, + { 3.5622166386422633, 0.20000000000000018, 0.80000000000000004, 1.5707963267948966 }, }; const double toler119 = 2.5000000000000020e-13; -// Test data for k=0.19999999999999996, nu=0.90000000000000002. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 6.4833128442756722e-16 +// Test data for k=0.20000000000000018, nu=0.90000000000000002. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.1718503329017390e-16 +// mean(f - f_Boost): 2.3592239273284576e-16 +// variance(f - f_Boost): 2.9295534376290287e-31 +// stddev(f - f_Boost): 5.4125349307224141e-16 const testcase_ellint_3<double> data120[10] = { - { 0.0000000000000000, 0.19999999999999996, 0.90000000000000002, + { 0.0000000000000000, 0.20000000000000018, 0.90000000000000002, 0.0000000000000000 }, - { 0.17300769173837277, 0.19999999999999996, 0.90000000000000002, + { 0.17618041435044951, 0.20000000000000018, 0.90000000000000002, 0.17453292519943295 }, - { 0.33761123827372508, 0.19999999999999996, 0.90000000000000002, + { 0.36267207636502929, 0.20000000000000018, 0.90000000000000002, 0.34906585039886590 }, - { 0.48845905690769426, 0.19999999999999996, 0.90000000000000002, + { 0.57212028758237743, 0.20000000000000018, 0.90000000000000002, 0.52359877559829882 }, - { 0.62407720017324952, 0.19999999999999996, 0.90000000000000002, + { 0.82293323876704483, 0.20000000000000018, 0.90000000000000002, 0.69813170079773179 }, - { 0.74578146525124289, 0.19999999999999996, 0.90000000000000002, + { 1.1457077279880388, 0.20000000000000018, 0.90000000000000002, 0.87266462599716477 }, - { 0.85621583540073076, 0.19999999999999996, 0.90000000000000002, + { 1.5967346899325681, 0.20000000000000018, 0.90000000000000002, 1.0471975511965976 }, - { 0.95837725988001199, 0.19999999999999996, 0.90000000000000002, + { 2.2856537353421724, 0.20000000000000018, 0.90000000000000002, 1.2217304763960306 }, - { 1.0551821412633928, 0.19999999999999996, 0.90000000000000002, + { 3.4034714304613902, 0.20000000000000018, 0.90000000000000002, 1.3962634015954636 }, - { 1.1493679916141861, 0.19999999999999996, 0.90000000000000002, + { 5.0448269356200370, 0.20000000000000018, 0.90000000000000002, 1.5707963267948966 }, }; const double toler120 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.0000000000000000. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.3361874537309281e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.2241249691539529e-16 +// mean(f - f_Boost): 2.7755575615628914e-17 +// variance(f - f_Boost): 2.1399221604302621e-32 +// stddev(f - f_Boost): 1.4628472785736254e-16 const testcase_ellint_3<double> data121[10] = { @@ -3528,19 +3890,19 @@ data121[10] = 0.0000000000000000 }, { 0.17461228653000099, 0.30000000000000004, 0.0000000000000000, 0.17453292519943295 }, - { 0.34969146102798415, 0.30000000000000004, 0.0000000000000000, + { 0.34969146102798421, 0.30000000000000004, 0.0000000000000000, 0.34906585039886590 }, - { 0.52565822873726320, 0.30000000000000004, 0.0000000000000000, + { 0.52565822873726309, 0.30000000000000004, 0.0000000000000000, 0.52359877559829882 }, - { 0.70284226512408532, 0.30000000000000004, 0.0000000000000000, + { 0.70284226512408543, 0.30000000000000004, 0.0000000000000000, 0.69813170079773179 }, - { 0.88144139195111182, 0.30000000000000004, 0.0000000000000000, + { 0.88144139195111171, 0.30000000000000004, 0.0000000000000000, 0.87266462599716477 }, { 1.0614897067260520, 0.30000000000000004, 0.0000000000000000, 1.0471975511965976 }, - { 1.2428416824174218, 0.30000000000000004, 0.0000000000000000, + { 1.2428416824174220, 0.30000000000000004, 0.0000000000000000, 1.2217304763960306 }, - { 1.4251795877015927, 0.30000000000000004, 0.0000000000000000, + { 1.4251795877015929, 0.30000000000000004, 0.0000000000000000, 1.3962634015954636 }, { 1.6080486199305128, 0.30000000000000004, 0.0000000000000000, 1.5707963267948966 }, @@ -3548,559 +3910,619 @@ data121[10] = const double toler121 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.10000000000000001. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.3908043711907203e-16 +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.1872304407982844e-16 +// mean(f - f_Boost): 7.2164496600635178e-17 +// variance(f - f_Boost): 4.3555500115139682e-32 +// stddev(f - f_Boost): 2.0869954507650391e-16 const testcase_ellint_3<double> data122[10] = { { 0.0000000000000000, 0.30000000000000004, 0.10000000000000001, 0.0000000000000000 }, - { 0.17443631884814376, 0.30000000000000004, 0.10000000000000001, + { 0.17478889331392972, 0.30000000000000004, 0.10000000000000001, 0.17453292519943295 }, - { 0.34831316835124926, 0.30000000000000004, 0.10000000000000001, + { 0.35108939018329183, 0.30000000000000004, 0.10000000000000001, 0.34906585039886590 }, - { 0.52116586276523857, 0.30000000000000004, 0.10000000000000001, + { 0.53028990896115835, 0.30000000000000004, 0.10000000000000001, 0.52359877559829882 }, - { 0.69269385837910036, 0.30000000000000004, 0.10000000000000001, + { 0.71352417052371409, 0.30000000000000004, 0.10000000000000001, 0.69813170079773179 }, - { 0.86279023163070856, 0.30000000000000004, 0.10000000000000001, + { 0.90153086032405894, 0.30000000000000004, 0.10000000000000001, 0.87266462599716477 }, - { 1.0315321461438263, 0.30000000000000004, 0.10000000000000001, + { 1.0945187977283313, 0.30000000000000004, 0.10000000000000001, 1.0471975511965976 }, - { 1.1991449111869024, 0.30000000000000004, 0.10000000000000001, + { 1.2920699268385683, 0.30000000000000004, 0.10000000000000001, 1.2217304763960306 }, - { 1.3659561780923213, 0.30000000000000004, 0.10000000000000001, + { 1.4931243665896394, 0.30000000000000004, 0.10000000000000001, 1.3962634015954636 }, - { 1.5323534693557528, 0.30000000000000004, 0.10000000000000001, + { 1.6960848815118226, 0.30000000000000004, 0.10000000000000001, 1.5707963267948966 }, }; const double toler122 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.20000000000000001. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.4447238179454079e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.2247497610332889e-16 +// mean(f - f_Boost): 6.6613381477509390e-17 +// variance(f - f_Boost): 1.7591111235252501e-32 +// stddev(f - f_Boost): 1.3263148659067538e-16 const testcase_ellint_3<double> data123[10] = { { 0.0000000000000000, 0.30000000000000004, 0.20000000000000001, 0.0000000000000000 }, - { 0.17426098615372088, 0.30000000000000004, 0.20000000000000001, + { 0.17496614335337535, 0.30000000000000004, 0.20000000000000001, 0.17453292519943295 }, - { 0.34695402664689923, 0.30000000000000004, 0.20000000000000001, + { 0.35250745937139372, 0.30000000000000004, 0.20000000000000001, 0.34906585039886590 }, - { 0.51680555567038933, 0.30000000000000004, 0.20000000000000001, + { 0.53506875002836884, 0.30000000000000004, 0.20000000000000001, 0.52359877559829882 }, - { 0.68303375225260210, 0.30000000000000004, 0.20000000000000001, + { 0.72479106622248191, 0.30000000000000004, 0.20000000000000001, 0.69813170079773179 }, - { 0.84540662891295026, 0.30000000000000004, 0.20000000000000001, + { 0.92326451535891607, 0.30000000000000004, 0.20000000000000001, 0.87266462599716477 }, - { 1.0041834051646927, 0.30000000000000004, 0.20000000000000001, + { 1.1312092060698349, 0.30000000000000004, 0.20000000000000001, 1.0471975511965976 }, - { 1.1599952702345711, 0.30000000000000004, 0.20000000000000001, + { 1.3481473154592321, 0.30000000000000004, 0.20000000000000001, 1.2217304763960306 }, - { 1.3137179520499165, 0.30000000000000004, 0.20000000000000001, + { 1.5722049569662750, 0.30000000000000004, 0.20000000000000001, 1.3962634015954636 }, - { 1.4663658145259877, 0.30000000000000004, 0.20000000000000001, + { 1.8002173372290500, 0.30000000000000004, 0.20000000000000001, 1.5707963267948966 }, }; const double toler123 = 2.5000000000000020e-13; -// Test data for k=0.30000000000000004, nu=0.29999999999999999. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.4979715256503266e-16 +// Test data for k=0.30000000000000004, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.1678685180047551e-16 +// mean(f - f_Boost): 1.0547118733938987e-16 +// variance(f - f_Boost): 7.5633408838247182e-32 +// stddev(f - f_Boost): 2.7501528837184157e-16 const testcase_ellint_3<double> data124[10] = { - { 0.0000000000000000, 0.30000000000000004, 0.29999999999999999, + { 0.0000000000000000, 0.30000000000000004, 0.30000000000000004, 0.0000000000000000 }, - { 0.17408628437042842, 0.30000000000000004, 0.29999999999999999, + { 0.17514404084107435, 0.30000000000000004, 0.30000000000000004, 0.17453292519943295 }, - { 0.34561356761638401, 0.30000000000000004, 0.29999999999999999, + { 0.35394619108645647, 0.30000000000000004, 0.30000000000000004, 0.34906585039886590 }, - { 0.51257058617875850, 0.30000000000000004, 0.29999999999999999, + { 0.54000325463372689, 0.30000000000000004, 0.30000000000000004, 0.52359877559829882 }, - { 0.67382207124602878, 0.30000000000000004, 0.29999999999999999, + { 0.73670193794067651, 0.30000000000000004, 0.30000000000000004, 0.69813170079773179 }, - { 0.82914751587825131, 0.30000000000000004, 0.29999999999999999, + { 0.94689345491722177, 0.30000000000000004, 0.30000000000000004, 0.87266462599716477 }, - { 0.97907434814374938, 0.30000000000000004, 0.29999999999999999, + { 1.1723274608389140, 0.30000000000000004, 0.30000000000000004, 1.0471975511965976 }, - { 1.1246399297351584, 0.30000000000000004, 0.29999999999999999, + { 1.4128880552936287, 0.30000000000000004, 0.30000000000000004, 1.2217304763960306 }, - { 1.2671793970398149, 0.30000000000000004, 0.29999999999999999, + { 1.6659010047449661, 0.30000000000000004, 0.30000000000000004, 1.3962634015954636 }, - { 1.4081767433479091, 0.30000000000000004, 0.29999999999999999, + { 1.9260216862473254, 0.30000000000000004, 0.30000000000000004, 1.5707963267948966 }, }; const double toler124 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.40000000000000002. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.5505716921759864e-16 +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.3983279132797385e-16 +// mean(f - f_Boost): 1.1657341758564144e-16 +// variance(f - f_Boost): 1.8245832308692586e-31 +// stddev(f - f_Boost): 4.2715140534349863e-16 const testcase_ellint_3<double> data125[10] = { { 0.0000000000000000, 0.30000000000000004, 0.40000000000000002, 0.0000000000000000 }, - { 0.17391220945982727, 0.30000000000000004, 0.40000000000000002, + { 0.17532259000954434, 0.30000000000000004, 0.40000000000000002, 0.17453292519943295 }, - { 0.34429133937639689, 0.30000000000000004, 0.40000000000000002, + { 0.35540612770983693, 0.30000000000000004, 0.40000000000000002, 0.34906585039886590 }, - { 0.50845471668581632, 0.30000000000000004, 0.40000000000000002, + { 0.54510265552938919, 0.30000000000000004, 0.40000000000000002, 0.52359877559829882 }, - { 0.66502347027873854, 0.30000000000000004, 0.40000000000000002, + { 0.74932476310965057, 0.30000000000000004, 0.40000000000000002, 0.69813170079773179 }, - { 0.81389191978012254, 0.30000000000000004, 0.40000000000000002, + { 0.97272793583093109, 0.30000000000000004, 0.40000000000000002, 0.87266462599716477 }, - { 0.95590618002140570, 0.30000000000000004, 0.40000000000000002, + { 1.2188928987074241, 0.30000000000000004, 0.40000000000000002, 1.0471975511965976 }, - { 1.0924915195213121, 0.30000000000000004, 0.40000000000000002, + { 1.4888771674085941, 0.30000000000000004, 0.40000000000000002, 1.2217304763960306 }, - { 1.2253651604038061, 0.30000000000000004, 0.40000000000000002, + { 1.7794558498219191, 0.30000000000000004, 0.40000000000000002, 1.3962634015954636 }, - { 1.3563643538969763, 0.30000000000000004, 0.40000000000000002, + { 2.0822121773175528, 0.30000000000000004, 0.40000000000000002, 1.5707963267948966 }, }; const double toler125 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.50000000000000000. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.7807908859023716e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.0516138451673425e-16 +// mean(f - f_Boost): 4.7184478546569152e-17 +// variance(f - f_Boost): 1.9448563670505968e-32 +// stddev(f - f_Boost): 1.3945810722401896e-16 const testcase_ellint_3<double> data126[10] = { { 0.0000000000000000, 0.30000000000000004, 0.50000000000000000, 0.0000000000000000 }, - { 0.17373875742088232, 0.30000000000000004, 0.50000000000000000, + { 0.17550179513158179, 0.30000000000000004, 0.50000000000000000, 0.17453292519943295 }, - { 0.34298690571124157, 0.30000000000000004, 0.50000000000000000, + { 0.35688783251681200, 0.30000000000000004, 0.50000000000000000, 0.34906585039886590 }, - { 0.50445214859646936, 0.30000000000000004, 0.50000000000000000, + { 0.55037700010142798, 0.30000000000000004, 0.50000000000000000, 0.52359877559829882 }, - { 0.65660648352418516, 0.30000000000000004, 0.50000000000000000, + { 0.76273839789895992, 0.30000000000000004, 0.50000000000000000, 0.69813170079773179 }, - { 0.79953670639287289, 0.30000000000000004, 0.50000000000000000, + { 1.0011570518830419, 0.30000000000000004, 0.50000000000000000, 0.87266462599716477 }, - { 0.93443393926588536, 0.30000000000000004, 0.50000000000000000, + { 1.2722987414055109, 0.30000000000000004, 0.50000000000000000, 1.0471975511965976 }, - { 1.0630838369016911, 0.30000000000000004, 0.50000000000000000, + { 1.5799590511080066, 0.30000000000000004, 0.50000000000000000, 1.2217304763960306 }, - { 1.1875197325653029, 0.30000000000000004, 0.50000000000000000, + { 1.9212367220124293, 0.30000000000000004, 0.50000000000000000, 1.3962634015954636 }, - { 1.3098448759814962, 0.30000000000000004, 0.50000000000000000, + { 2.2833505881933971, 0.30000000000000004, 0.50000000000000000, 1.5707963267948966 }, }; const double toler126 = 2.5000000000000020e-13; -// Test data for k=0.30000000000000004, nu=0.59999999999999998. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 7.0057999499931649e-16 +// Test data for k=0.30000000000000004, nu=0.60000000000000009. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.2121157428443725e-16 +// mean(f - f_Boost): 1.9428902930940239e-16 +// variance(f - f_Boost): 1.5987596229703424e-31 +// stddev(f - f_Boost): 3.9984492281012430e-16 const testcase_ellint_3<double> data127[10] = { - { 0.0000000000000000, 0.30000000000000004, 0.59999999999999998, + { 0.0000000000000000, 0.30000000000000004, 0.60000000000000009, 0.0000000000000000 }, - { 0.17356592428950823, 0.30000000000000004, 0.59999999999999998, + { 0.17568166052076745, 0.30000000000000004, 0.60000000000000009, 0.17453292519943295 }, - { 0.34169984536697379, 0.30000000000000004, 0.59999999999999998, + { 0.35839189074731181, 0.30000000000000004, 0.60000000000000009, 0.34906585039886590 }, - { 0.50055748266498457, 0.30000000000000004, 0.59999999999999998, + { 0.55583724744367558, 0.30000000000000004, 0.60000000000000009, 0.52359877559829882 }, - { 0.64854298527106768, 0.30000000000000004, 0.59999999999999998, + { 0.77703498090888223, 0.30000000000000004, 0.60000000000000009, 0.69813170079773179 }, - { 0.78599329284207431, 0.30000000000000004, 0.59999999999999998, + { 1.0326772113675962, 0.30000000000000004, 0.60000000000000009, 0.87266462599716477 }, - { 0.91445452089128199, 0.30000000000000004, 0.59999999999999998, + { 1.3345139983717369, 0.30000000000000004, 0.60000000000000009, 1.0471975511965976 }, - { 1.0360412952290587, 0.30000000000000004, 0.59999999999999998, + { 1.6921742922838403, 0.30000000000000004, 0.60000000000000009, 1.2217304763960306 }, - { 1.1530473919778641, 0.30000000000000004, 0.59999999999999998, + { 2.1056608968472186, 0.30000000000000004, 0.60000000000000009, 1.3962634015954636 }, - { 1.2677758800420669, 0.30000000000000004, 0.59999999999999998, + { 2.5560975528589061, 0.30000000000000004, 0.60000000000000009, 1.5707963267948966 }, }; const double toler127 = 2.5000000000000020e-13; -// Test data for k=0.30000000000000004, nu=0.69999999999999996. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 7.2239502844122443e-16 +// Test data for k=0.30000000000000004, nu=0.70000000000000007. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.0088945789059381e-16 +// mean(f - f_Boost): 2.1094237467877973e-16 +// variance(f - f_Boost): 3.0253363535298873e-31 +// stddev(f - f_Boost): 5.5003057674368314e-16 const testcase_ellint_3<double> data128[10] = { - { 0.0000000000000000, 0.30000000000000004, 0.69999999999999996, + { 0.0000000000000000, 0.30000000000000004, 0.70000000000000007, 0.0000000000000000 }, - { 0.17339370613812224, 0.30000000000000004, 0.69999999999999996, + { 0.17586219053197988, 0.30000000000000004, 0.70000000000000007, 0.17453292519943295 }, - { 0.34042975138455933, 0.30000000000000004, 0.69999999999999996, + { 0.35991891074557669, 0.30000000000000004, 0.70000000000000007, 0.34906585039886590 }, - { 0.49676568368075985, 0.30000000000000004, 0.69999999999999996, + { 0.56149538019961731, 0.30000000000000004, 0.70000000000000007, 0.52359877559829882 }, - { 0.64080774055753720, 0.30000000000000004, 0.69999999999999996, + { 0.79232303189667685, 0.30000000000000004, 0.70000000000000007, 0.69813170079773179 }, - { 0.77318507779667278, 0.30000000000000004, 0.69999999999999996, + { 1.0679345542878826, 0.30000000000000004, 0.70000000000000007, 0.87266462599716477 }, - { 0.89579782346548609, 0.30000000000000004, 0.69999999999999996, + { 1.4084400085913955, 0.30000000000000004, 0.70000000000000007, 1.0471975511965976 }, - { 1.0110573286052202, 0.30000000000000004, 0.69999999999999996, + { 1.8357382859296454, 0.30000000000000004, 0.70000000000000007, 1.2217304763960306 }, - { 1.1214710972949635, 0.30000000000000004, 0.69999999999999996, + { 2.3604197996171519, 0.30000000000000004, 0.70000000000000007, 1.3962634015954636 }, - { 1.2294913236274982, 0.30000000000000004, 0.69999999999999996, + { 2.9562123549913872, 0.30000000000000004, 0.70000000000000007, 1.5707963267948966 }, }; const double toler128 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.80000000000000004. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 7.4358357000101250e-16 +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.1197887707781618e-16 +// mean(f - f_Boost): 3.4416913763379854e-16 +// variance(f - f_Boost): 4.3461914185990199e-31 +// stddev(f - f_Boost): 6.5925650687718054e-16 const testcase_ellint_3<double> data129[10] = { { 0.0000000000000000, 0.30000000000000004, 0.80000000000000004, 0.0000000000000000 }, - { 0.17322209907520358, 0.30000000000000004, 0.80000000000000004, + { 0.17604338956191670, 0.30000000000000004, 0.80000000000000004, 0.17453292519943295 }, - { 0.33917623046949996, 0.30000000000000004, 0.80000000000000004, + { 0.36146952517410791, 0.30000000000000004, 0.80000000000000004, 0.34906585039886590 }, - { 0.49307204894329176, 0.30000000000000004, 0.80000000000000004, + { 0.56736453393774644, 0.30000000000000004, 0.80000000000000004, 0.52359877559829882 }, - { 0.63337802830291734, 0.30000000000000004, 0.80000000000000004, + { 0.80873149979001091, 0.30000000000000004, 0.80000000000000004, 0.69813170079773179 }, - { 0.76104540997689407, 0.30000000000000004, 0.80000000000000004, + { 1.1077903069860620, 0.30000000000000004, 0.80000000000000004, 0.87266462599716477 }, - { 0.87832009635450714, 0.30000000000000004, 0.80000000000000004, + { 1.4985874311132998, 0.30000000000000004, 0.80000000000000004, 1.0471975511965976 }, - { 0.98787879723171790, 0.30000000000000004, 0.80000000000000004, + { 2.0298167266724954, 0.30000000000000004, 0.80000000000000004, 1.2217304763960306 }, - { 1.0924036340069339, 0.30000000000000004, 0.80000000000000004, + { 2.7483929054985432, 0.30000000000000004, 0.80000000000000004, 1.3962634015954636 }, - { 1.1944567571590048, 0.30000000000000004, 0.80000000000000004, + { 3.6283050484567170, 0.30000000000000004, 0.80000000000000004, 1.5707963267948966 }, }; const double toler129 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.90000000000000002. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 7.6419688299804087e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 5.1301806687926828e-16 +// mean(f - f_Boost): 4.1633363423443370e-16 +// variance(f - f_Boost): 2.2835347143080263e-31 +// stddev(f - f_Boost): 4.7786344433405093e-16 const testcase_ellint_3<double> data130[10] = { { 0.0000000000000000, 0.30000000000000004, 0.90000000000000002, 0.0000000000000000 }, - { 0.17305109924485945, 0.30000000000000004, 0.90000000000000002, + { 0.17622526204962433, 0.30000000000000004, 0.90000000000000002, 0.17453292519943295 }, - { 0.33793890239556984, 0.30000000000000004, 0.90000000000000002, + { 0.36304439230777141, 0.30000000000000004, 0.90000000000000002, 0.34906585039886590 }, - { 0.48947218005089738, 0.30000000000000004, 0.90000000000000002, + { 0.57345914744719195, 0.30000000000000004, 0.90000000000000002, 0.52359877559829882 }, - { 0.62623332340775151, 0.30000000000000004, 0.90000000000000002, + { 0.82641512928845162, 0.30000000000000004, 0.90000000000000002, 0.69813170079773179 }, - { 0.74951596581511148, 0.30000000000000004, 0.90000000000000002, + { 1.1534256210757743, 0.30000000000000004, 0.90000000000000002, 0.87266462599716477 }, - { 0.86189886597755994, 0.30000000000000004, 0.90000000000000002, + { 1.6124900353411677, 0.30000000000000004, 0.90000000000000002, 1.0471975511965976 }, - { 0.96629451153092005, 0.30000000000000004, 0.90000000000000002, + { 2.3165905514845089, 0.30000000000000004, 0.90000000000000002, 1.2217304763960306 }, - { 1.0655269133492682, 0.30000000000000004, 0.90000000000000002, + { 3.4625619526539824, 0.30000000000000004, 0.90000000000000002, 1.3962634015954636 }, - { 1.1622376896064914, 0.30000000000000004, 0.90000000000000002, + { 5.1479514944016787, 0.30000000000000004, 0.90000000000000002, 1.5707963267948966 }, }; const double toler130 = 2.5000000000000020e-13; -// Test data for k=0.39999999999999991, nu=0.0000000000000000. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 5.4157225142938039e-16 +// Test data for k=0.40000000000000013, nu=0.0000000000000000. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.0831445028587608e-15 +// mean(f - f_Boost): 1.7486012637846215e-16 +// variance(f - f_Boost): 3.1664095331106078e-31 +// stddev(f - f_Boost): 5.6270858649132121e-16 const testcase_ellint_3<double> data131[10] = { - { 0.0000000000000000, 0.39999999999999991, 0.0000000000000000, + { 0.0000000000000000, 0.40000000000000013, 0.0000000000000000, 0.0000000000000000 }, - { 0.17467414669441528, 0.39999999999999991, 0.0000000000000000, + { 0.17467414669441528, 0.40000000000000013, 0.0000000000000000, 0.17453292519943295 }, - { 0.35018222772483443, 0.39999999999999991, 0.0000000000000000, + { 0.35018222772483443, 0.40000000000000013, 0.0000000000000000, 0.34906585039886590 }, - { 0.52729015917508737, 0.39999999999999991, 0.0000000000000000, + { 0.52729015917508748, 0.40000000000000013, 0.0000000000000000, 0.52359877559829882 }, - { 0.70662374407341244, 0.39999999999999991, 0.0000000000000000, + { 0.70662374407341244, 0.40000000000000013, 0.0000000000000000, 0.69813170079773179 }, - { 0.88859210497602170, 0.39999999999999991, 0.0000000000000000, + { 0.88859210497602159, 0.40000000000000013, 0.0000000000000000, 0.87266462599716477 }, - { 1.0733136290471379, 0.39999999999999991, 0.0000000000000000, + { 1.0733136290471381, 0.40000000000000013, 0.0000000000000000, 1.0471975511965976 }, - { 1.2605612170157061, 0.39999999999999991, 0.0000000000000000, + { 1.2605612170157066, 0.40000000000000013, 0.0000000000000000, 1.2217304763960306 }, - { 1.4497513956433439, 0.39999999999999991, 0.0000000000000000, + { 1.4497513956433439, 0.40000000000000013, 0.0000000000000000, 1.3962634015954636 }, - { 1.6399998658645112, 0.39999999999999991, 0.0000000000000000, + { 1.6399998658645112, 0.40000000000000013, 0.0000000000000000, 1.5707963267948966 }, }; const double toler131 = 2.5000000000000020e-13; -// Test data for k=0.39999999999999991, nu=0.10000000000000001. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 5.6859551010103832e-16 +// Test data for k=0.40000000000000013, nu=0.10000000000000001. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.0263824105456986e-15 +// mean(f - f_Boost): 1.7486012637846215e-16 +// variance(f - f_Boost): 3.1664095331106078e-31 +// stddev(f - f_Boost): 5.6270858649132121e-16 const testcase_ellint_3<double> data132[10] = { - { 0.0000000000000000, 0.39999999999999991, 0.10000000000000001, + { 0.0000000000000000, 0.40000000000000013, 0.10000000000000001, 0.0000000000000000 }, - { 0.17449806706684670, 0.39999999999999991, 0.10000000000000001, + { 0.17485086590796767, 0.40000000000000013, 0.10000000000000001, 0.17453292519943295 }, - { 0.34880048623856075, 0.39999999999999991, 0.10000000000000001, + { 0.35158366412506992, 0.40000000000000013, 0.10000000000000001, 0.34906585039886590 }, - { 0.52277322065757392, 0.39999999999999991, 0.10000000000000001, + { 0.53194731675711726, 0.40000000000000013, 0.10000000000000001, 0.52359877559829882 }, - { 0.69638072056918365, 0.39999999999999991, 0.10000000000000001, + { 0.71740615528010931, 0.40000000000000013, 0.10000000000000001, 0.69813170079773179 }, - { 0.86968426619831540, 0.39999999999999991, 0.10000000000000001, + { 0.90896157773487030, 0.40000000000000013, 0.10000000000000001, 0.87266462599716477 }, - { 1.0428044206578095, 0.39999999999999991, 0.10000000000000001, + { 1.1069605483834348, 0.40000000000000013, 0.10000000000000001, 1.0471975511965976 }, - { 1.2158651158274378, 0.39999999999999991, 0.10000000000000001, + { 1.3109353428823001, 0.40000000000000013, 0.10000000000000001, 1.2217304763960306 }, - { 1.3889447129893324, 0.39999999999999991, 0.10000000000000001, + { 1.5195460789903450, 0.40000000000000013, 0.10000000000000001, 1.3962634015954636 }, - { 1.5620566886683604, 0.39999999999999991, 0.10000000000000001, + { 1.7306968836847190, 0.40000000000000013, 0.10000000000000001, 1.5707963267948966 }, }; const double toler132 = 2.5000000000000020e-13; -// Test data for k=0.39999999999999991, nu=0.20000000000000001. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 5.9444065952225719e-16 +// Test data for k=0.40000000000000013, nu=0.20000000000000001. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.6644296021947179e-16 +// mean(f - f_Boost): 2.0816681711721685e-16 +// variance(f - f_Boost): 3.0360740073926687e-31 +// stddev(f - f_Boost): 5.5100580826273227e-16 const testcase_ellint_3<double> data133[10] = { - { 0.0000000000000000, 0.39999999999999991, 0.20000000000000001, + { 0.0000000000000000, 0.40000000000000013, 0.20000000000000001, 0.0000000000000000 }, - { 0.17432262290723397, 0.39999999999999991, 0.20000000000000001, + { 0.17502822886437389, 0.40000000000000013, 0.20000000000000001, 0.17453292519943295 }, - { 0.34743795258968596, 0.39999999999999991, 0.20000000000000001, + { 0.35300530062530805, 0.40000000000000013, 0.20000000000000001, 0.34906585039886590 }, - { 0.51838919472805112, 0.39999999999999991, 0.20000000000000001, + { 0.53675259548210896, 0.40000000000000013, 0.20000000000000001, 0.52359877559829882 }, - { 0.68663134739057907, 0.39999999999999991, 0.20000000000000001, + { 0.72878006428676934, 0.40000000000000013, 0.20000000000000001, 0.69813170079773179 }, - { 0.85206432981833979, 0.39999999999999991, 0.20000000000000001, + { 0.93100219010583574, 0.40000000000000013, 0.20000000000000001, 0.87266462599716477 }, - { 1.0149595349004430, 0.39999999999999991, 0.20000000000000001, + { 1.1443487271187611, 0.40000000000000013, 0.20000000000000001, 1.0471975511965976 }, - { 1.1758349405464676, 0.39999999999999991, 0.20000000000000001, + { 1.3683427764108813, 0.40000000000000013, 0.20000000000000001, 1.2217304763960306 }, - { 1.3353337673882637, 0.39999999999999991, 0.20000000000000001, + { 1.6008221459300933, 0.40000000000000013, 0.20000000000000001, 1.3962634015954636 }, - { 1.4941414344266770, 0.39999999999999991, 0.20000000000000001, + { 1.8380358826317627, 0.40000000000000013, 0.20000000000000001, 1.5707963267948966 }, }; const double toler133 = 2.5000000000000020e-13; -// Test data for k=0.39999999999999991, nu=0.29999999999999999. -// max(|f - f_GSL|): 1.1102230246251565e-15 -// max(|f - f_GSL| / |f_GSL|): 7.7406350888907249e-16 +// Test data for k=0.40000000000000013, nu=0.30000000000000004. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.0271556462838835e-16 +// mean(f - f_Boost): 2.0816681711721685e-16 +// variance(f - f_Boost): 3.0360740073926687e-31 +// stddev(f - f_Boost): 5.5100580826273227e-16 const testcase_ellint_3<double> data134[10] = { - { 0.0000000000000000, 0.39999999999999991, 0.29999999999999999, + { 0.0000000000000000, 0.40000000000000013, 0.30000000000000004, 0.0000000000000000 }, - { 0.17414781013591540, 0.39999999999999991, 0.29999999999999999, + { 0.17520623975982899, 0.40000000000000013, 0.30000000000000004, 0.17453292519943295 }, - { 0.34609415696777285, 0.39999999999999991, 0.29999999999999999, + { 0.35444766141612105, 0.40000000000000013, 0.30000000000000004, 0.34906585039886590 }, - { 0.51413131295862535, 0.39999999999999991, 0.29999999999999999, + { 0.54171455841536009, 0.40000000000000013, 0.30000000000000004, 0.52359877559829882 }, - { 0.67733527622935630, 0.39999999999999991, 0.29999999999999999, + { 0.74080517001084012, 0.40000000000000013, 0.30000000000000004, 0.69813170079773179 }, - { 0.83558675182733266, 0.39999999999999991, 0.29999999999999999, + { 0.95496950509296574, 0.40000000000000013, 0.30000000000000004, 0.87266462599716477 }, - { 0.98940140808865906, 0.39999999999999991, 0.29999999999999999, + { 1.1862627879844718, 0.40000000000000013, 0.30000000000000004, 1.0471975511965976 }, - { 1.1396968797728058, 0.39999999999999991, 0.29999999999999999, + { 1.4346501803799458, 0.40000000000000013, 0.30000000000000004, 1.2217304763960306 }, - { 1.2875920037865090, 0.39999999999999991, 0.29999999999999999, + { 1.6971744798077699, 0.40000000000000013, 0.30000000000000004, 1.3962634015954636 }, - { 1.4342789859950078, 0.39999999999999991, 0.29999999999999999, + { 1.9677924132520139, 0.40000000000000013, 0.30000000000000004, 1.5707963267948966 }, }; const double toler134 = 2.5000000000000020e-13; -// Test data for k=0.39999999999999991, nu=0.40000000000000002. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.4314214811441816e-16 +// Test data for k=0.40000000000000013, nu=0.40000000000000002. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 8.3436329231972794e-16 +// mean(f - f_Boost): 2.3037127760972000e-16 +// variance(f - f_Boost): 2.9507053793392374e-31 +// stddev(f - f_Boost): 5.4320395611033958e-16 const testcase_ellint_3<double> data135[10] = { - { 0.0000000000000000, 0.39999999999999991, 0.40000000000000002, + { 0.0000000000000000, 0.40000000000000013, 0.40000000000000002, 0.0000000000000000 }, - { 0.17397362471112707, 0.39999999999999991, 0.40000000000000002, + { 0.17538490283034375, 0.40000000000000013, 0.40000000000000002, 0.17453292519943295 }, - { 0.34476864603333196, 0.39999999999999991, 0.40000000000000002, + { 0.35591129064319948, 0.40000000000000013, 0.40000000000000002, 0.34906585039886590 }, - { 0.50999329415379346, 0.39999999999999991, 0.40000000000000002, + { 0.54684250413264535, 0.40000000000000013, 0.40000000000000002, 0.52359877559829882 }, - { 0.66845674551396006, 0.39999999999999991, 0.40000000000000002, + { 0.75355027742668290, 0.40000000000000013, 0.40000000000000002, 0.69813170079773179 }, - { 0.82012848346231748, 0.39999999999999991, 0.40000000000000002, + { 0.98117935026780634, 0.40000000000000013, 0.40000000000000002, 0.87266462599716477 }, - { 0.96582449258349057, 0.39999999999999991, 0.40000000000000002, + { 1.2337464222030736, 0.40000000000000013, 0.40000000000000002, 1.0471975511965976 }, - { 1.1068473749476286, 0.39999999999999991, 0.40000000000000002, + { 1.5125183419289221, 0.40000000000000013, 0.40000000000000002, 1.2217304763960306 }, - { 1.2447132729159989, 0.39999999999999991, 0.40000000000000002, + { 1.8140224451130313, 0.40000000000000013, 0.40000000000000002, 1.3962634015954636 }, - { 1.3809986210732901, 0.39999999999999991, 0.40000000000000002, + { 2.1289968719280026, 0.40000000000000013, 0.40000000000000002, 1.5707963267948966 }, }; const double toler135 = 2.5000000000000020e-13; -// Test data for k=0.39999999999999991, nu=0.50000000000000000. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.6621057007519435e-16 +// Test data for k=0.40000000000000013, nu=0.50000000000000000. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.7013794022122431e-16 +// mean(f - f_Boost): 2.3037127760972000e-16 +// variance(f - f_Boost): 1.4989821857033475e-31 +// stddev(f - f_Boost): 3.8716691306248618e-16 const testcase_ellint_3<double> data136[10] = { - { 0.0000000000000000, 0.39999999999999991, 0.50000000000000000, + { 0.0000000000000000, 0.40000000000000013, 0.50000000000000000, 0.0000000000000000 }, - { 0.17380006262854136, 0.39999999999999991, 0.50000000000000000, + { 0.17556422235224273, 0.40000000000000013, 0.50000000000000000, 0.17453292519943295 }, - { 0.34346098216756610, 0.39999999999999991, 0.50000000000000000, + { 0.35739675341763921, 0.40000000000000013, 0.50000000000000000, 0.34906585039886590 }, - { 0.50596929935059420, 0.39999999999999991, 0.50000000000000000, + { 0.55214655195037188, 0.40000000000000013, 0.50000000000000000, 0.52359877559829882 }, - { 0.65996392089131251, 0.39999999999999991, 0.50000000000000000, + { 0.76709520942047438, 0.40000000000000013, 0.50000000000000000, 0.69813170079773179 }, - { 0.80558463511364786, 0.39999999999999991, 0.50000000000000000, + { 1.0100278761577499, 0.40000000000000013, 0.50000000000000000, 0.87266462599716477 }, - { 0.94397834522857704, 0.39999999999999991, 0.50000000000000000, + { 1.2882265661384342, 0.40000000000000013, 0.50000000000000000, 1.0471975511965976 }, - { 1.0768075114108115, 0.39999999999999991, 0.50000000000000000, + { 1.6059059780051876, 0.40000000000000013, 0.50000000000000000, 1.2217304763960306 }, - { 1.2059184624251333, 0.39999999999999991, 0.50000000000000000, + { 1.9600182740224081, 0.40000000000000013, 0.50000000000000000, 1.3962634015954636 }, - { 1.3331797176377398, 0.39999999999999991, 0.50000000000000000, + { 2.3367461373176512, 0.40000000000000013, 0.50000000000000000, 1.5707963267948966 }, }; const double toler136 = 2.5000000000000020e-13; -// Test data for k=0.39999999999999991, nu=0.59999999999999998. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 6.8853630717730749e-16 +// Test data for k=0.40000000000000013, nu=0.60000000000000009. +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 8.4792115132836117e-16 +// mean(f - f_Boost): 2.3037127760972000e-16 +// variance(f - f_Boost): 4.8893797490374802e-31 +// stddev(f - f_Boost): 6.9924099915819294e-16 const testcase_ellint_3<double> data137[10] = { - { 0.0000000000000000, 0.39999999999999991, 0.59999999999999998, + { 0.0000000000000000, 0.40000000000000013, 0.60000000000000009, 0.0000000000000000 }, - { 0.17362711992081245, 0.39999999999999991, 0.59999999999999998, + { 0.17574420264267029, 0.40000000000000013, 0.60000000000000009, 0.17453292519943295 }, - { 0.34217074276403953, 0.39999999999999991, 0.59999999999999998, + { 0.35890463689046265, 0.40000000000000013, 0.60000000000000009, 0.34906585039886590 }, - { 0.50205389185761606, 0.39999999999999991, 0.59999999999999998, + { 0.55763773975194486, 0.40000000000000013, 0.60000000000000009, 0.52359877559829882 }, - { 0.65182834920372734, 0.39999999999999991, 0.59999999999999998, + { 0.78153324227761267, 0.40000000000000013, 0.60000000000000009, 0.69813170079773179 }, - { 0.79186512820565136, 0.39999999999999991, 0.59999999999999998, + { 1.0420205885765887, 0.40000000000000013, 0.60000000000000009, 0.87266462599716477 }, - { 0.92365535916287134, 0.39999999999999991, 0.59999999999999998, + { 1.3517205230381770, 0.40000000000000013, 0.60000000000000009, 1.0471975511965976 }, - { 1.0491915663957907, 0.39999999999999991, 0.59999999999999998, + { 1.7210360970313896, 0.40000000000000013, 0.60000000000000009, 1.2217304763960306 }, - { 1.1705934291745106, 0.39999999999999991, 0.59999999999999998, + { 2.1500780510169246, 0.40000000000000013, 0.60000000000000009, 1.3962634015954636 }, - { 1.2899514672527024, 0.39999999999999991, 0.59999999999999998, + { 2.6186940209850191, 0.40000000000000013, 0.60000000000000009, 1.5707963267948966 }, }; const double toler137 = 2.5000000000000020e-13; -// Test data for k=0.39999999999999991, nu=0.69999999999999996. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 7.1018730557776469e-16 +// Test data for k=0.40000000000000013, nu=0.70000000000000007. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.8573292020719759e-16 +// mean(f - f_Boost): 2.2759572004815707e-16 +// variance(f - f_Boost): 2.9613098824898137e-31 +// stddev(f - f_Boost): 5.4417918762938862e-16 const testcase_ellint_3<double> data138[10] = { - { 0.0000000000000000, 0.39999999999999991, 0.69999999999999996, + { 0.0000000000000000, 0.40000000000000013, 0.70000000000000007, 0.0000000000000000 }, - { 0.17345479265712868, 0.39999999999999991, 0.69999999999999996, + { 0.17592484806010436, 0.40000000000000013, 0.70000000000000007, 0.17453292519943295 }, - { 0.34089751955950354, 0.39999999999999991, 0.69999999999999996, + { 0.36043555139631439, 0.40000000000000013, 0.70000000000000007, 0.34906585039886590 }, - { 0.49824200167361332, 0.39999999999999991, 0.69999999999999996, + { 0.56332813669944881, 0.40000000000000013, 0.70000000000000007, 0.52359877559829882 }, - { 0.64402450341199402, 0.39999999999999991, 0.69999999999999996, + { 0.79697424562157548, 0.40000000000000013, 0.70000000000000007, 0.69813170079773179 }, - { 0.77889207804122873, 0.39999999999999991, 0.69999999999999996, + { 1.0778155987523672, 0.40000000000000013, 0.70000000000000007, 0.87266462599716477 }, - { 0.90468169720957992, 0.39999999999999991, 0.69999999999999996, + { 1.4272018169896268, 0.40000000000000013, 0.70000000000000007, 1.0471975511965976 }, - { 1.0236847823692916, 0.39999999999999991, 0.69999999999999996, + { 1.8684377907453382, 0.40000000000000013, 0.70000000000000007, 1.2217304763960306 }, - { 1.1382465247425166, 0.39999999999999991, 0.69999999999999996, + { 2.4128677409207473, 0.40000000000000013, 0.70000000000000007, 1.3962634015954636 }, - { 1.2506255923253344, 0.39999999999999991, 0.69999999999999996, + { 3.0327078743873246, 0.40000000000000013, 0.70000000000000007, 1.5707963267948966 }, }; const double toler138 = 2.5000000000000020e-13; -// Test data for k=0.39999999999999991, nu=0.80000000000000004. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 7.3122171115555478e-16 +// Test data for k=0.40000000000000013, nu=0.80000000000000004. +// max(|f - f_Boost|): 3.5527136788005009e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.5273712585384737e-16 +// mean(f - f_Boost): 4.5241588253475131e-16 +// variance(f - f_Boost): 1.1866477068555882e-30 +// stddev(f - f_Boost): 1.0893336067778265e-15 const testcase_ellint_3<double> data139[10] = { - { 0.0000000000000000, 0.39999999999999991, 0.80000000000000004, + { 0.0000000000000000, 0.40000000000000013, 0.80000000000000004, 0.0000000000000000 }, - { 0.17328307694277154, 0.39999999999999991, 0.80000000000000004, + { 0.17610616300487833, 0.40000000000000013, 0.80000000000000004, 0.17453292519943295 }, - { 0.33964091800132007, 0.39999999999999991, 0.80000000000000004, + { 0.36199013167171978, 0.40000000000000013, 0.80000000000000004, 0.34906585039886590 }, - { 0.49452889372467440, 0.39999999999999991, 0.80000000000000004, + { 0.56923097361842434, 0.40000000000000013, 0.80000000000000004, 0.52359877559829882 }, - { 0.63652940095937316, 0.39999999999999991, 0.80000000000000004, + { 0.81354878456624347, 0.40000000000000013, 0.80000000000000004, 0.69813170079773179 }, - { 0.76659772511159097, 0.39999999999999991, 0.80000000000000004, + { 1.1182902719261825, 0.40000000000000013, 0.80000000000000004, 0.87266462599716477 }, - { 0.88691047977338111, 0.39999999999999991, 0.80000000000000004, + { 1.5192950589409022, 0.40000000000000013, 0.80000000000000004, 1.0471975511965976 }, - { 1.0000273200611638, 0.39999999999999991, 0.80000000000000004, + { 2.0678761710223981, 0.40000000000000013, 0.80000000000000004, 1.2217304763960306 }, - { 1.1084787902188009, 0.39999999999999991, 0.80000000000000004, + { 2.8135222249879788, 0.40000000000000013, 0.80000000000000004, 1.3962634015954636 }, - { 1.2146499565727209, 0.39999999999999991, 0.80000000000000004, + { 3.7289548002199902, 0.40000000000000013, 0.80000000000000004, 1.5707963267948966 }, }; const double toler139 = 2.5000000000000020e-13; -// Test data for k=0.39999999999999991, nu=0.90000000000000002. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 7.5168974431077345e-16 +// Test data for k=0.40000000000000013, nu=0.90000000000000002. +// max(|f - f_Boost|): 6.2172489379008766e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.1718379478872251e-15 +// mean(f - f_Boost): 8.4099394115355610e-16 +// variance(f - f_Boost): 3.5684096037099424e-30 +// stddev(f - f_Boost): 1.8890234523980751e-15 const testcase_ellint_3<double> data140[10] = { - { 0.0000000000000000, 0.39999999999999991, 0.90000000000000002, + { 0.0000000000000000, 0.40000000000000013, 0.90000000000000002, 0.0000000000000000 }, - { 0.17311196891868127, 0.39999999999999991, 0.90000000000000002, + { 0.17628815191971123, 0.40000000000000013, 0.90000000000000002, 0.17453292519943295 }, - { 0.33840055664911906, 0.39999999999999991, 0.90000000000000002, + { 0.36356903815378772, 0.40000000000000013, 0.90000000000000002, 0.34906585039886590 }, - { 0.49091013944075329, 0.39999999999999991, 0.90000000000000002, + { 0.57536079447000310, 0.40000000000000013, 0.90000000000000002, 0.52359877559829882 }, - { 0.62932228186809580, 0.39999999999999991, 0.90000000000000002, + { 0.83141355850172571, 0.40000000000000013, 0.90000000000000002, 0.69813170079773179 }, - { 0.75492278323019801, 0.39999999999999991, 0.90000000000000002, + { 1.1646481598721361, 0.40000000000000013, 0.90000000000000002, 0.87266462599716477 }, - { 0.87021659043854294, 0.39999999999999991, 0.90000000000000002, + { 1.6357275034001995, 0.40000000000000013, 0.90000000000000002, 1.0471975511965976 }, - { 0.97800245228239246, 0.39999999999999991, 0.90000000000000002, + { 2.3628787566572402, 0.40000000000000013, 0.90000000000000002, 1.2217304763960306 }, - { 1.0809625773173697, 0.39999999999999991, 0.90000000000000002, + { 3.5521010369134962, 0.40000000000000013, 0.90000000000000002, 1.3962634015954636 }, - { 1.1815758115929846, 0.39999999999999991, 0.90000000000000002, + { 5.3055535102872513, 0.40000000000000013, 0.90000000000000002, 1.5707963267948966 }, }; const double toler140 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.0000000000000000. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.1201497220602069e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.4551389361831220e-16 +// mean(f - f_Boost): -1.3877787807814457e-17 +// variance(f - f_Boost): 2.5893058141206173e-32 +// stddev(f - f_Boost): 1.6091320064309879e-16 const testcase_ellint_3<double> data141[10] = { @@ -4108,289 +4530,319 @@ data141[10] = 0.0000000000000000 }, { 0.17475385514035785, 0.50000000000000000, 0.0000000000000000, 0.17453292519943295 }, - { 0.35081868470101585, 0.50000000000000000, 0.0000000000000000, + { 0.35081868470101579, 0.50000000000000000, 0.0000000000000000, 0.34906585039886590 }, { 0.52942862705190574, 0.50000000000000000, 0.0000000000000000, 0.52359877559829882 }, - { 0.71164727562630314, 0.50000000000000000, 0.0000000000000000, + { 0.71164727562630326, 0.50000000000000000, 0.0000000000000000, 0.69813170079773179 }, { 0.89824523594227768, 0.50000000000000000, 0.0000000000000000, 0.87266462599716477 }, - { 1.0895506700518851, 0.50000000000000000, 0.0000000000000000, + { 1.0895506700518853, 0.50000000000000000, 0.0000000000000000, 1.0471975511965976 }, - { 1.2853005857432931, 0.50000000000000000, 0.0000000000000000, + { 1.2853005857432933, 0.50000000000000000, 0.0000000000000000, 1.2217304763960306 }, - { 1.4845545520549484, 0.50000000000000000, 0.0000000000000000, + { 1.4845545520549488, 0.50000000000000000, 0.0000000000000000, 1.3962634015954636 }, - { 1.6857503548125963, 0.50000000000000000, 0.0000000000000000, + { 1.6857503548125961, 0.50000000000000000, 0.0000000000000000, 1.5707963267948966 }, }; const double toler141 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.10000000000000001. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.1662857256911530e-16 +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.7416868347177582e-16 +// mean(f - f_Boost): 2.7755575615628915e-18 +// variance(f - f_Boost): 5.4326441655972001e-32 +// stddev(f - f_Boost): 2.3308033305273100e-16 const testcase_ellint_3<double> data142[10] = { { 0.0000000000000000, 0.50000000000000000, 0.10000000000000001, 0.0000000000000000 }, - { 0.17457763120814676, 0.50000000000000000, 0.10000000000000001, + { 0.17493071928248824, 0.50000000000000000, 0.10000000000000001, 0.17453292519943295 }, - { 0.34943246340849154, 0.50000000000000000, 0.10000000000000001, + { 0.35222467688034798, 0.50000000000000000, 0.10000000000000001, 0.34906585039886590 }, - { 0.52487937869610790, 0.50000000000000000, 0.10000000000000001, + { 0.53411928652008112, 0.50000000000000000, 0.10000000000000001, 0.52359877559829882 }, - { 0.70127785096388384, 0.50000000000000000, 0.10000000000000001, + { 0.72256398117177589, 0.50000000000000000, 0.10000000000000001, 0.69813170079773179 }, - { 0.87898815988624479, 0.50000000000000000, 0.10000000000000001, + { 0.91899583232771009, 0.50000000000000000, 0.10000000000000001, 0.87266462599716477 }, - { 1.0582764576094172, 0.50000000000000000, 0.10000000000000001, + { 1.1240549163055360, 0.50000000000000000, 0.10000000000000001, 1.0471975511965976 }, - { 1.2391936844060205, 0.50000000000000000, 0.10000000000000001, + { 1.3372938086286021, 0.50000000000000000, 0.10000000000000001, 1.2217304763960306 }, - { 1.4214793542995841, 0.50000000000000000, 0.10000000000000001, + { 1.5570024469132429, 0.50000000000000000, 0.10000000000000001, 1.3962634015954636 }, - { 1.6045524936084892, 0.50000000000000000, 0.10000000000000001, + { 1.7803034946545480, 0.50000000000000000, 0.10000000000000001, 1.5707963267948966 }, }; const double toler142 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.20000000000000001. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.2114786773102175e-16 +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.1198767993730867e-16 +// mean(f - f_Boost): 2.7755575615628914e-17 +// variance(f - f_Boost): 5.0311947683004831e-32 +// stddev(f - f_Boost): 2.2430324938128922e-16 const testcase_ellint_3<double> data143[10] = { { 0.0000000000000000, 0.50000000000000000, 0.20000000000000001, 0.0000000000000000 }, - { 0.17440204336345433, 0.50000000000000000, 0.20000000000000001, + { 0.17510822779582402, 0.50000000000000000, 0.20000000000000001, 0.17453292519943295 }, - { 0.34806552388338824, 0.50000000000000000, 0.20000000000000001, + { 0.35365094725531487, 0.50000000000000000, 0.20000000000000001, 0.34906585039886590 }, - { 0.52046416757129810, 0.50000000000000000, 0.20000000000000001, + { 0.53895933237328697, 0.50000000000000000, 0.20000000000000001, 0.52359877559829882 }, - { 0.69140924550993865, 0.50000000000000000, 0.20000000000000001, + { 0.73408090840070794, 0.50000000000000000, 0.20000000000000001, 0.69813170079773179 }, - { 0.86104678636125520, 0.50000000000000000, 0.20000000000000001, + { 0.94145442818535396, 0.50000000000000000, 0.20000000000000001, 0.87266462599716477 }, - { 1.0297439459053981, 0.50000000000000000, 0.20000000000000001, + { 1.1624120186296487, 0.50000000000000000, 0.20000000000000001, 1.0471975511965976 }, - { 1.1979214112912033, 0.50000000000000000, 0.20000000000000001, + { 1.3965823372867114, 0.50000000000000000, 0.20000000000000001, 1.2217304763960306 }, - { 1.3659033858648930, 0.50000000000000000, 0.20000000000000001, + { 1.6414308440430099, 0.50000000000000000, 0.20000000000000001, 1.3962634015954636 }, - { 1.5338490483665983, 0.50000000000000000, 0.20000000000000001, + { 1.8922947612264018, 0.50000000000000000, 0.20000000000000001, 1.5707963267948966 }, }; const double toler143 = 2.5000000000000020e-13; -// Test data for k=0.50000000000000000, nu=0.29999999999999999. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.2557837230041312e-16 +// Test data for k=0.50000000000000000, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.3800262770228813e-16 +// mean(f - f_Boost): 5.8286708792820721e-17 +// variance(f - f_Boost): 8.5027191584278157e-32 +// stddev(f - f_Boost): 2.9159422419567599e-16 const testcase_ellint_3<double> data144[10] = { - { 0.0000000000000000, 0.50000000000000000, 0.29999999999999999, + { 0.0000000000000000, 0.50000000000000000, 0.30000000000000004, 0.0000000000000000 }, - { 0.17422708752228896, 0.50000000000000000, 0.29999999999999999, + { 0.17528638488102041, 0.50000000000000000, 0.30000000000000004, 0.17453292519943295 }, - { 0.34671739434855858, 0.50000000000000000, 0.29999999999999999, + { 0.35509802222332720, 0.50000000000000000, 0.30000000000000004, 0.34906585039886590 }, - { 0.51617616305641878, 0.50000000000000000, 0.29999999999999999, + { 0.54395740731866193, 0.50000000000000000, 0.30000000000000004, 0.52359877559829882 }, - { 0.68200047612545167, 0.50000000000000000, 0.29999999999999999, + { 0.74625871438752667, 0.50000000000000000, 0.30000000000000004, 0.69813170079773179 }, - { 0.84427217869498372, 0.50000000000000000, 0.29999999999999999, + { 0.96588271186092023, 0.50000000000000000, 0.30000000000000004, 0.87266462599716477 }, - { 1.0035637821389782, 0.50000000000000000, 0.29999999999999999, + { 1.2054319584357329, 0.50000000000000000, 0.30000000000000004, 1.0471975511965976 }, - { 1.1606800483933111, 0.50000000000000000, 0.29999999999999999, + { 1.4651077994832871, 0.50000000000000000, 0.30000000000000004, 1.2217304763960306 }, - { 1.3164407134643459, 0.50000000000000000, 0.29999999999999999, + { 1.7416018368052644, 0.50000000000000000, 0.30000000000000004, 1.3962634015954636 }, - { 1.4715681939859637, 0.50000000000000000, 0.29999999999999999, + { 2.0277924458111314, 0.50000000000000000, 0.30000000000000004, 1.5707963267948966 }, }; const double toler144 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.40000000000000002. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.2992508582900068e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.0439932918341581e-16 +// mean(f - f_Boost): 3.0531133177191807e-17 +// variance(f - f_Boost): 9.0809736800018602e-32 +// stddev(f - f_Boost): 3.0134653938616686e-16 const testcase_ellint_3<double> data145[10] = { { 0.0000000000000000, 0.50000000000000000, 0.40000000000000002, 0.0000000000000000 }, - { 0.17405275963859917, 0.50000000000000000, 0.40000000000000002, + { 0.17546519477859268, 0.50000000000000000, 0.40000000000000002, 0.17453292519943295 }, - { 0.34538761957029329, 0.50000000000000000, 0.40000000000000002, + { 0.35656644822531680, 0.50000000000000000, 0.40000000000000002, 0.34906585039886590 }, - { 0.51200902646603907, 0.50000000000000000, 0.40000000000000002, + { 0.54912289677411319, 0.50000000000000000, 0.40000000000000002, 0.52359877559829882 }, - { 0.67301522212868792, 0.50000000000000000, 0.40000000000000002, + { 0.75916731611690047, 0.50000000000000000, 0.40000000000000002, 0.69813170079773179 }, - { 0.82853844466313320, 0.50000000000000000, 0.40000000000000002, + { 0.99260415631328214, 0.50000000000000000, 0.40000000000000002, 0.87266462599716477 }, - { 0.97942097862681488, 0.50000000000000000, 0.40000000000000002, + { 1.2541925856918670, 0.50000000000000000, 0.40000000000000002, 1.0471975511965976 }, - { 1.1268429801220614, 0.50000000000000000, 0.40000000000000002, + { 1.5456393705347609, 0.50000000000000000, 0.40000000000000002, 1.2217304763960306 }, - { 1.2720406704533922, 0.50000000000000000, 0.40000000000000002, + { 1.8631904972952076, 0.50000000000000000, 0.40000000000000002, 1.3962634015954636 }, - { 1.4161679518465340, 0.50000000000000000, 0.40000000000000002, + { 2.1962905366178065, 0.50000000000000000, 0.40000000000000002, 1.5707963267948966 }, }; const double toler145 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.50000000000000000. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3419255755184137e-16 +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.6797816859260978e-16 +// mean(f - f_Boost): 9.4368957093138303e-17 +// variance(f - f_Boost): 7.7794254682023874e-32 +// stddev(f - f_Boost): 2.7891621444803792e-16 const testcase_ellint_3<double> data146[10] = { { 0.0000000000000000, 0.50000000000000000, 0.50000000000000000, 0.0000000000000000 }, - { 0.17387905570381157, 0.50000000000000000, 0.50000000000000000, + { 0.17564466176941509, 0.50000000000000000, 0.50000000000000000, 0.17453292519943295 }, - { 0.34407576010465207, 0.50000000000000000, 0.50000000000000000, + { 0.35805679276065394, 0.50000000000000000, 0.50000000000000000, 0.34906585039886590 }, - { 0.50795686560160824, 0.50000000000000000, 0.50000000000000000, + { 0.55446601496200032, 0.50000000000000000, 0.50000000000000000, 0.52359877559829882 }, - { 0.66442115453330164, 0.50000000000000000, 0.50000000000000000, + { 0.77288783578259013, 0.50000000000000000, 0.50000000000000000, 0.69813170079773179 }, - { 0.81373829119355345, 0.50000000000000000, 0.50000000000000000, + { 1.0220246013918972, 0.50000000000000000, 0.50000000000000000, 0.87266462599716477 }, - { 0.95705743313235825, 0.50000000000000000, 0.50000000000000000, + { 1.3101681612463965, 0.50000000000000000, 0.50000000000000000, 1.0471975511965976 }, - { 1.0959131991362554, 0.50000000000000000, 0.50000000000000000, + { 1.6422994881851025, 0.50000000000000000, 0.50000000000000000, 1.2217304763960306 }, - { 1.2318900529754597, 0.50000000000000000, 0.50000000000000000, + { 2.0152636030998816, 0.50000000000000000, 0.50000000000000000, 1.3962634015954636 }, - { 1.3664739530045971, 0.50000000000000000, 0.50000000000000000, + { 2.4136715042011945, 0.50000000000000000, 0.50000000000000000, 1.5707963267948966 }, }; const double toler146 = 2.5000000000000020e-13; -// Test data for k=0.50000000000000000, nu=0.59999999999999998. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3838494104749599e-16 +// Test data for k=0.50000000000000000, nu=0.60000000000000009. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.9178421578645735e-16 +// mean(f - f_Boost): 1.3322676295501878e-16 +// variance(f - f_Boost): 1.7749370367472766e-31 +// stddev(f - f_Boost): 4.2130001622920411e-16 const testcase_ellint_3<double> data147[10] = { - { 0.0000000000000000, 0.50000000000000000, 0.59999999999999998, + { 0.0000000000000000, 0.50000000000000000, 0.60000000000000009, 0.0000000000000000 }, - { 0.17370597174637581, 0.50000000000000000, 0.59999999999999998, + { 0.17582479017522740, 0.50000000000000000, 0.60000000000000009, 0.17453292519943295 }, - { 0.34278139158591414, 0.50000000000000000, 0.59999999999999998, + { 0.35956964546660036, 0.50000000000000000, 0.60000000000000009, 0.34906585039886590 }, - { 0.50401419439302708, 0.50000000000000000, 0.59999999999999998, + { 0.55999790372984193, 0.50000000000000000, 0.60000000000000009, 0.52359877559829882 }, - { 0.65618938076167210, 0.50000000000000000, 0.59999999999999998, + { 0.78751507911209895, 0.50000000000000000, 0.60000000000000009, 0.69813170079773179 }, - { 0.79977959248855424, 0.50000000000000000, 0.59999999999999998, + { 1.0546620505035220, 0.50000000000000000, 0.60000000000000009, 0.87266462599716477 }, - { 0.93625925190753545, 0.50000000000000000, 0.59999999999999998, + { 1.3754438357425935, 0.50000000000000000, 0.60000000000000009, 1.0471975511965976 }, - { 1.0674905658379708, 0.50000000000000000, 0.59999999999999998, + { 1.7615727400820127, 0.50000000000000000, 0.60000000000000009, 1.2217304763960306 }, - { 1.1953481298023050, 0.50000000000000000, 0.59999999999999998, + { 2.2134638067565242, 0.50000000000000000, 0.60000000000000009, 1.3962634015954636 }, - { 1.3215740290190876, 0.50000000000000000, 0.59999999999999998, + { 2.7090491861753558, 0.50000000000000000, 0.60000000000000009, 1.5707963267948966 }, }; const double toler147 = 2.5000000000000020e-13; -// Test data for k=0.50000000000000000, nu=0.69999999999999996. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 3.4250604066951477e-16 +// Test data for k=0.50000000000000000, nu=0.70000000000000007. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.0745105182189226e-16 +// mean(f - f_Boost): 4.1633363423443370e-17 +// variance(f - f_Boost): 1.9996383743576116e-32 +// stddev(f - f_Boost): 1.4140857026211713e-16 const testcase_ellint_3<double> data148[10] = { - { 0.0000000000000000, 0.50000000000000000, 0.69999999999999996, + { 0.0000000000000000, 0.50000000000000000, 0.70000000000000007, 0.0000000000000000 }, - { 0.17353350383131641, 0.50000000000000000, 0.69999999999999996, + { 0.17600558435914915, 0.50000000000000000, 0.70000000000000007, 0.17453292519943295 }, - { 0.34150410405436771, 0.50000000000000000, 0.69999999999999996, + { 0.36110561926726259, 0.50000000000000000, 0.70000000000000007, 0.34906585039886590 }, - { 0.50017589696443487, 0.50000000000000000, 0.69999999999999996, + { 0.56573074641137111, 0.50000000000000000, 0.70000000000000007, 0.52359877559829882 }, - { 0.64829398188419951, 0.50000000000000000, 0.69999999999999996, + { 0.80316073084237205, 0.50000000000000000, 0.70000000000000007, 0.69813170079773179 }, - { 0.78658270782402073, 0.50000000000000000, 0.69999999999999996, + { 1.0911910688131461, 0.50000000000000000, 0.70000000000000007, 0.87266462599716477 }, - { 0.91684738336675053, 0.50000000000000000, 0.69999999999999996, + { 1.4530946406380640, 0.50000000000000000, 0.70000000000000007, 1.0471975511965976 }, - { 1.0412486789555935, 0.50000000000000000, 0.69999999999999996, + { 1.9144386536785372, 0.50000000000000000, 0.70000000000000007, 1.2217304763960306 }, - { 1.1619021847612001, 0.50000000000000000, 0.69999999999999996, + { 2.4878788958234970, 0.50000000000000000, 0.70000000000000007, 1.3962634015954636 }, - { 1.2807475181182502, 0.50000000000000000, 0.69999999999999996, + { 3.1433945297859225, 0.50000000000000000, 0.70000000000000007, 1.5707963267948966 }, }; const double toler148 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.5715240651179632e-16 +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.4380477375534667e-16 +// mean(f - f_Boost): 2.3037127760972000e-16 +// variance(f - f_Boost): 1.4989821857033475e-31 +// stddev(f - f_Boost): 3.8716691306248618e-16 const testcase_ellint_3<double> data149[10] = { { 0.0000000000000000, 0.50000000000000000, 0.80000000000000004, 0.0000000000000000 }, - { 0.17336164805979126, 0.50000000000000000, 0.80000000000000004, + { 0.17618704872620228, 0.50000000000000000, 0.80000000000000004, 0.17453292519943295 }, - { 0.34024350132086773, 0.50000000000000000, 0.80000000000000004, + { 0.36266535159745827, 0.50000000000000000, 0.80000000000000004, 0.34906585039886590 }, - { 0.49643719555734073, 0.50000000000000000, 0.80000000000000004, + { 0.57167789954529158, 0.50000000000000000, 0.80000000000000004, 0.52359877559829882 }, - { 0.64071162456976150, 0.50000000000000000, 0.80000000000000004, + { 0.81995752984315018, 0.50000000000000000, 0.80000000000000004, 0.69813170079773179 }, - { 0.77407836177211908, 0.50000000000000000, 0.80000000000000004, + { 1.1325112162158122, 0.50000000000000000, 0.80000000000000004, 0.87266462599716477 }, - { 0.89867058251905652, 0.50000000000000000, 0.80000000000000004, + { 1.5479055930718042, 0.50000000000000000, 0.80000000000000004, 1.0471975511965976 }, - { 1.0169181822134910, 0.50000000000000000, 0.80000000000000004, + { 2.1215243941010486, 0.50000000000000000, 0.80000000000000004, 1.2217304763960306 }, - { 1.1311363312779448, 0.50000000000000000, 0.80000000000000004, + { 2.9069405767650132, 0.50000000000000000, 0.80000000000000004, 1.3962634015954636 }, - { 1.2434165408189539, 0.50000000000000000, 0.80000000000000004, + { 3.8750701888108066, 0.50000000000000000, 0.80000000000000004, 1.5707963267948966 }, }; const double toler149 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.90000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.4664649039489274e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.6192315188521289e-16 +// mean(f - f_Boost): 3.5249581031848718e-16 +// variance(f - f_Boost): 2.5029385557256515e-31 +// stddev(f - f_Boost): 5.0029376927217987e-16 const testcase_ellint_3<double> data150[10] = { { 0.0000000000000000, 0.50000000000000000, 0.90000000000000002, 0.0000000000000000 }, - { 0.17319040056865681, 0.50000000000000000, 0.90000000000000002, + { 0.17636918772384180, 0.50000000000000000, 0.90000000000000002, 0.17453292519943295 }, - { 0.33899920036578557, 0.50000000000000000, 0.90000000000000002, + { 0.36424950570740700, 0.50000000000000000, 0.90000000000000002, 0.34906585039886590 }, - { 0.49279362182695174, 0.50000000000000000, 0.90000000000000002, + { 0.57785404590231426, 0.50000000000000000, 0.90000000000000002, 0.52359877559829882 }, - { 0.63342123379746151, 0.50000000000000000, 0.90000000000000002, + { 0.83806480521716531, 0.50000000000000000, 0.90000000000000002, 0.69813170079773179 }, - { 0.76220595179550321, 0.50000000000000000, 0.90000000000000002, + { 1.1798568683069752, 0.50000000000000000, 0.90000000000000002, 0.87266462599716477 }, - { 0.88160004743532294, 0.50000000000000000, 0.90000000000000002, + { 1.6678766243739607, 0.50000000000000000, 0.90000000000000002, 1.0471975511965976 }, - { 0.99427448642310123, 0.50000000000000000, 0.90000000000000002, + { 2.4282976450693483, 0.50000000000000000, 0.90000000000000002, 1.2217304763960306 }, - { 1.1027091512470095, 0.50000000000000000, 0.90000000000000002, + { 3.6810787666126656, 0.50000000000000000, 0.90000000000000002, 1.3962634015954636 }, - { 1.2091116095504744, 0.50000000000000000, 0.90000000000000002, + { 5.5355132096026454, 0.50000000000000000, 0.90000000000000002, 1.5707963267948966 }, }; const double toler150 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.0000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3664899092028927e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.3664899092028927e-16 +// mean(f - f_Boost): 3.0531133177191807e-17 +// variance(f - f_Boost): 7.8758646268991113e-33 +// stddev(f - f_Boost): 8.8746068233466605e-17 const testcase_ellint_3<double> data151[10] = { @@ -4398,19 +4850,19 @@ data151[10] = 0.0000000000000000 }, { 0.17485154362988359, 0.60000000000000009, 0.0000000000000000, 0.17453292519943295 }, - { 0.35160509865544326, 0.60000000000000009, 0.0000000000000000, + { 0.35160509865544320, 0.60000000000000009, 0.0000000000000000, 0.34906585039886590 }, { 0.53210652578446138, 0.60000000000000009, 0.0000000000000000, 0.52359877559829882 }, { 0.71805304664485659, 0.60000000000000009, 0.0000000000000000, 0.69813170079773179 }, - { 0.91082759030195970, 0.60000000000000009, 0.0000000000000000, + { 0.91082759030195981, 0.60000000000000009, 0.0000000000000000, 0.87266462599716477 }, { 1.1112333229323361, 0.60000000000000009, 0.0000000000000000, 1.0471975511965976 }, { 1.3191461190365270, 0.60000000000000009, 0.0000000000000000, 1.2217304763960306 }, - { 1.5332022105084775, 0.60000000000000009, 0.0000000000000000, + { 1.5332022105084779, 0.60000000000000009, 0.0000000000000000, 1.3962634015954636 }, { 1.7507538029157526, 0.60000000000000009, 0.0000000000000000, 1.5707963267948966 }, @@ -4418,559 +4870,619 @@ data151[10] = const double toler151 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.10000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.4937942733669112e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.2335247010355137e-16 +// mean(f - f_Boost): 8.6042284408449634e-17 +// variance(f - f_Boost): 2.2835347143080263e-33 +// stddev(f - f_Boost): 4.7786344433405099e-17 const testcase_ellint_3<double> data152[10] = { { 0.0000000000000000, 0.60000000000000009, 0.10000000000000001, 0.0000000000000000 }, - { 0.17467514275022011, 0.60000000000000009, 0.10000000000000001, + { 0.17502858548476194, 0.60000000000000009, 0.10000000000000001, 0.17453292519943295 }, - { 0.35021333086258255, 0.60000000000000009, 0.10000000000000001, + { 0.35301673150537388, 0.60000000000000009, 0.10000000000000001, 0.34906585039886590 }, - { 0.52751664092962691, 0.60000000000000009, 0.10000000000000001, + { 0.53683932476326812, 0.60000000000000009, 0.10000000000000001, 0.52359877559829882 }, - { 0.70752126971957874, 0.60000000000000009, 0.10000000000000001, + { 0.72914228589586771, 0.60000000000000009, 0.10000000000000001, 0.69813170079773179 }, - { 0.89111058756112871, 0.60000000000000009, 0.10000000000000001, + { 0.93208036718354692, 0.60000000000000009, 0.10000000000000001, 0.87266462599716477 }, - { 1.0789241202877768, 0.60000000000000009, 0.10000000000000001, + { 1.1468984688863377, 0.60000000000000009, 0.10000000000000001, 1.0471975511965976 }, - { 1.2710800210399946, 0.60000000000000009, 0.10000000000000001, + { 1.3733904977062528, 0.60000000000000009, 0.10000000000000001, 1.2217304763960306 }, - { 1.4669060574440276, 0.60000000000000009, 0.10000000000000001, + { 1.6094225663372157, 0.60000000000000009, 0.10000000000000001, 1.3962634015954636 }, - { 1.6648615773343014, 0.60000000000000009, 0.10000000000000001, + { 1.8508766487100685, 0.60000000000000009, 0.10000000000000001, 1.5707963267948966 }, }; const double toler152 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.20000000000000001. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1891472451898755e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 2.2547200163366559e-16 +// mean(f - f_Boost): -2.4980018054066023e-17 +// variance(f - f_Boost): 2.1685495635542404e-32 +// stddev(f - f_Boost): 1.4725995937641163e-16 const testcase_ellint_3<double> data153[10] = { { 0.0000000000000000, 0.60000000000000009, 0.20000000000000001, 0.0000000000000000 }, - { 0.17449937871800650, 0.60000000000000009, 0.20000000000000001, + { 0.17520627248155893, 0.60000000000000009, 0.20000000000000001, 0.17453292519943295 }, - { 0.34884093647346553, 0.60000000000000009, 0.20000000000000001, + { 0.35444873935437748, 0.60000000000000009, 0.20000000000000001, 0.34906585039886590 }, - { 0.52306221119844087, 0.60000000000000009, 0.20000000000000001, + { 0.54172310557682524, 0.60000000000000009, 0.20000000000000001, 0.52359877559829882 }, - { 0.69749955678982223, 0.60000000000000009, 0.20000000000000001, + { 0.74084300280734672, 0.60000000000000009, 0.20000000000000001, 0.69813170079773179 }, - { 0.87274610682416853, 0.60000000000000009, 0.20000000000000001, + { 0.95509001527006121, 0.60000000000000009, 0.20000000000000001, 0.87266462599716477 }, - { 1.0494620540750792, 0.60000000000000009, 0.20000000000000001, + { 1.1865688084431796, 0.60000000000000009, 0.20000000000000001, 1.0471975511965976 }, - { 1.2280847305507339, 0.60000000000000009, 0.20000000000000001, + { 1.4352978868932600, 0.60000000000000009, 0.20000000000000001, 1.2217304763960306 }, - { 1.4085436279696888, 0.60000000000000009, 0.20000000000000001, + { 1.6983400371331818, 0.60000000000000009, 0.20000000000000001, 1.3962634015954636 }, - { 1.5901418016279374, 0.60000000000000009, 0.20000000000000001, + { 1.9695980282802217, 0.60000000000000009, 0.20000000000000001, 1.5707963267948966 }, }; const double toler153 = 2.5000000000000020e-13; -// Test data for k=0.60000000000000009, nu=0.29999999999999999. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.7339932380431439e-16 +// Test data for k=0.60000000000000009, nu=0.30000000000000004. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.9470074709717020e-16 +// mean(f - f_Boost): 3.0531133177191807e-17 +// variance(f - f_Boost): 1.1508025840536076e-34 +// stddev(f - f_Boost): 1.0727546709539920e-17 const testcase_ellint_3<double> data154[10] = { - { 0.0000000000000000, 0.60000000000000009, 0.29999999999999999, + { 0.0000000000000000, 0.60000000000000009, 0.30000000000000004, 0.0000000000000000 }, - { 0.17432424744393932, 0.60000000000000009, 0.29999999999999999, + { 0.17538460882640122, 0.60000000000000009, 0.30000000000000004, 0.17453292519943295 }, - { 0.34748744127146447, 0.60000000000000009, 0.29999999999999999, + { 0.35590165133735557, 0.60000000000000009, 0.30000000000000004, 0.34906585039886590 }, - { 0.51873632743924825, 0.60000000000000009, 0.29999999999999999, + { 0.54676661152254535, 0.60000000000000009, 0.30000000000000004, 0.52359877559829882 }, - { 0.68794610396313116, 0.60000000000000009, 0.29999999999999999, + { 0.75321709418305305, 0.60000000000000009, 0.30000000000000004, 0.69813170079773179 }, - { 0.85558070175468726, 0.60000000000000009, 0.29999999999999999, + { 0.98012637808992920, 0.60000000000000009, 0.30000000000000004, 0.87266462599716477 }, - { 1.0224416343605653, 0.60000000000000009, 0.29999999999999999, + { 1.2310891277158875, 0.60000000000000009, 0.30000000000000004, 1.0471975511965976 }, - { 1.1893144457936788, 0.60000000000000009, 0.29999999999999999, + { 1.5069157924585623, 0.60000000000000009, 0.30000000000000004, 1.2217304763960306 }, - { 1.3566435377982575, 0.60000000000000009, 0.29999999999999999, + { 1.8039583598337940, 0.60000000000000009, 0.30000000000000004, 1.3962634015954636 }, - { 1.5243814243493585, 0.60000000000000009, 0.29999999999999999, + { 2.1134154405060599, 0.60000000000000009, 0.30000000000000004, 1.5707963267948966 }, }; const double toler154 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.40000000000000002. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 4.5440898085101625e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.8974839914337670e-16 +// mean(f - f_Boost): -1.3877787807814457e-17 +// variance(f - f_Boost): 2.2849613290816465e-32 +// stddev(f - f_Boost): 1.5116088545260797e-16 const testcase_ellint_3<double> data155[10] = { { 0.0000000000000000, 0.60000000000000009, 0.40000000000000002, 0.0000000000000000 }, - { 0.17414974487670717, 0.60000000000000009, 0.40000000000000002, + { 0.17556359876533037, 0.60000000000000009, 0.40000000000000002, 0.17453292519943295 }, - { 0.34615238767335027, 0.60000000000000009, 0.40000000000000002, + { 0.35737601674244679, 0.60000000000000009, 0.40000000000000002, 0.34906585039886590 }, - { 0.51453257838108557, 0.60000000000000009, 0.40000000000000002, + { 0.55197933771320218, 0.60000000000000009, 0.40000000000000002, 0.52359877559829882 }, - { 0.67882386787534399, 0.60000000000000009, 0.40000000000000002, + { 0.76633591620002905, 0.60000000000000009, 0.40000000000000002, 0.69813170079773179 }, - { 0.83948470233173578, 0.60000000000000009, 0.40000000000000002, + { 1.0075231136019616, 0.60000000000000009, 0.40000000000000002, 0.87266462599716477 }, - { 0.99753496200073977, 0.60000000000000009, 0.40000000000000002, + { 1.2815842073813450, 0.60000000000000009, 0.40000000000000002, 1.0471975511965976 }, - { 1.1541101404388487, 0.60000000000000009, 0.40000000000000002, + { 1.5911666941449827, 0.60000000000000009, 0.40000000000000002, 1.2217304763960306 }, - { 1.3100911323398816, 0.60000000000000009, 0.40000000000000002, + { 1.9323227566025762, 0.60000000000000009, 0.40000000000000002, 1.3962634015954636 }, - { 1.4659345278069984, 0.60000000000000009, 0.40000000000000002, + { 2.2925036420985130, 0.60000000000000009, 0.40000000000000002, 1.5707963267948966 }, }; const double toler155 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.50000000000000000. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 4.7124937590522226e-16 +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 2.1397785842303966e-16 +// mean(f - f_Boost): 9.1593399531575410e-17 +// variance(f - f_Boost): 1.5339913122479866e-32 +// stddev(f - f_Boost): 1.2385440291923362e-16 const testcase_ellint_3<double> data156[10] = { { 0.0000000000000000, 0.60000000000000009, 0.50000000000000000, 0.0000000000000000 }, - { 0.17397586700252807, 0.60000000000000009, 0.50000000000000000, + { 0.17574324658480217, 0.60000000000000009, 0.50000000000000000, 0.17453292519943295 }, - { 0.34483533397138516, 0.60000000000000009, 0.50000000000000000, + { 0.35887240603169313, 0.60000000000000009, 0.50000000000000000, 0.34906585039886590 }, - { 0.51044500461706477, 0.60000000000000009, 0.50000000000000000, + { 0.55737161826345261, 0.60000000000000009, 0.50000000000000000, 0.52359877559829882 }, - { 0.67009988034712664, 0.60000000000000009, 0.50000000000000000, + { 0.78028227313077458, 0.60000000000000009, 0.50000000000000000, 0.69813170079773179 }, - { 0.82434762375735193, 0.60000000000000009, 0.50000000000000000, + { 1.0376989776486290, 0.60000000000000009, 0.50000000000000000, 0.87266462599716477 }, - { 0.97447346702798998, 0.60000000000000009, 0.50000000000000000, + { 1.3395933991042928, 0.60000000000000009, 0.50000000000000000, 1.0471975511965976 }, - { 1.1219494000522143, 0.60000000000000009, 0.50000000000000000, + { 1.6924049626591784, 0.60000000000000009, 0.50000000000000000, 1.2217304763960306 }, - { 1.2680242605954486, 0.60000000000000009, 0.50000000000000000, + { 2.0931011856518920, 0.60000000000000009, 0.50000000000000000, 1.3962634015954636 }, - { 1.4135484285693078, 0.60000000000000009, 0.50000000000000000, + { 2.5239007084492711, 0.60000000000000009, 0.50000000000000000, 1.5707963267948966 }, }; const double toler156 = 2.5000000000000020e-13; -// Test data for k=0.60000000000000009, nu=0.59999999999999998. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.0652177678695900e-16 +// Test data for k=0.60000000000000009, nu=0.60000000000000009. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.6651378277398083e-16 +// mean(f - f_Boost): 1.1934897514720432e-16 +// variance(f - f_Boost): 1.7585404776158019e-33 +// stddev(f - f_Boost): 4.1934955319110598e-17 const testcase_ellint_3<double> data157[10] = { - { 0.0000000000000000, 0.60000000000000009, 0.59999999999999998, + { 0.0000000000000000, 0.60000000000000009, 0.60000000000000009, 0.0000000000000000 }, - { 0.17380260984469353, 0.60000000000000009, 0.59999999999999998, + { 0.17592355661219386, 0.60000000000000009, 0.60000000000000009, 0.17453292519943295 }, - { 0.34353585361777839, 0.60000000000000009, 0.59999999999999998, + { 0.36039141192661606, 0.60000000000000009, 0.60000000000000009, 0.34906585039886590 }, - { 0.50646805774321380, 0.60000000000000009, 0.59999999999999998, + { 0.56295472636903854, 0.60000000000000009, 0.60000000000000009, 0.52359877559829882 }, - { 0.66174468108625506, 0.60000000000000009, 0.59999999999999998, + { 0.79515295130165986, 0.60000000000000009, 0.60000000000000009, 0.69813170079773179 }, - { 0.81007462280278408, 0.60000000000000009, 0.59999999999999998, + { 1.0711886441942242, 0.60000000000000009, 0.60000000000000009, 0.87266462599716477 }, - { 0.95303466945718729, 0.60000000000000009, 0.59999999999999998, + { 1.4072952835139891, 0.60000000000000009, 0.60000000000000009, 1.0471975511965976 }, - { 1.0924118588677505, 0.60000000000000009, 0.59999999999999998, + { 1.8174863977376825, 0.60000000000000009, 0.60000000000000009, 1.2217304763960306 }, - { 1.2297640574847937, 0.60000000000000009, 0.59999999999999998, + { 2.3029921578542232, 0.60000000000000009, 0.60000000000000009, 1.3962634015954636 }, - { 1.3662507535812816, 0.60000000000000009, 0.59999999999999998, + { 2.8388723099514972, 0.60000000000000009, 0.60000000000000009, 1.5707963267948966 }, }; const double toler157 = 2.5000000000000020e-13; -// Test data for k=0.60000000000000009, nu=0.69999999999999996. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1692457486457856e-16 +// Test data for k=0.60000000000000009, nu=0.70000000000000007. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 2.0027679235921772e-16 +// mean(f - f_Boost): -1.3877787807814457e-17 +// variance(f - f_Boost): 2.2849613290816465e-32 +// stddev(f - f_Boost): 1.5116088545260797e-16 const testcase_ellint_3<double> data158[10] = { - { 0.0000000000000000, 0.60000000000000009, 0.69999999999999996, + { 0.0000000000000000, 0.60000000000000009, 0.70000000000000007, 0.0000000000000000 }, - { 0.17362996946312007, 0.60000000000000009, 0.69999999999999996, + { 0.17610453321631936, 0.60000000000000009, 0.70000000000000007, 0.17453292519943295 }, - { 0.34225353454870588, 0.60000000000000009, 0.69999999999999996, + { 0.36193365056369764, 0.60000000000000009, 0.70000000000000007, 0.34906585039886590 }, - { 0.50259656397799524, 0.60000000000000009, 0.69999999999999996, + { 0.56874098962268527, 0.60000000000000009, 0.70000000000000007, 0.52359877559829882 }, - { 0.65373184496628933, 0.60000000000000009, 0.69999999999999996, + { 0.81106198671477181, 0.60000000000000009, 0.70000000000000007, 0.69813170079773179 }, - { 0.79658372884056439, 0.60000000000000009, 0.69999999999999996, + { 1.1086886419010082, 0.60000000000000009, 0.70000000000000007, 0.87266462599716477 }, - { 0.93303240100245421, 0.60000000000000009, 0.69999999999999996, + { 1.4879048567239257, 0.60000000000000009, 0.70000000000000007, 1.0471975511965976 }, - { 1.0651547944716557, 0.60000000000000009, 0.69999999999999996, + { 1.9780310073615925, 0.60000000000000009, 0.70000000000000007, 1.2217304763960306 }, - { 1.1947676204853441, 0.60000000000000009, 0.69999999999999996, + { 2.5941545586772712, 0.60000000000000009, 0.70000000000000007, 1.3962634015954636 }, - { 1.3232737468822813, 0.60000000000000009, 0.69999999999999996, + { 3.3029735898397159, 0.60000000000000009, 0.70000000000000007, 1.5707963267948966 }, }; const double toler158 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2705175719241326e-16 +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 7.3044933435043190e-16 +// mean(f - f_Boost): 2.6367796834847468e-16 +// variance(f - f_Boost): 8.5834655546147173e-33 +// stddev(f - f_Boost): 9.2646994309662939e-17 const testcase_ellint_3<double> data159[10] = { { 0.0000000000000000, 0.60000000000000009, 0.80000000000000004, 0.0000000000000000 }, - { 0.17345794195390685, 0.60000000000000009, 0.80000000000000004, + { 0.17628618080795252, 0.60000000000000009, 0.80000000000000004, 0.17453292519943295 }, - { 0.34098797854531027, 0.60000000000000009, 0.80000000000000004, + { 0.36349976272521012, 0.60000000000000009, 0.80000000000000004, 0.34906585039886590 }, - { 0.49882569168826213, 0.60000000000000009, 0.80000000000000004, + { 0.57474392342151914, 0.60000000000000009, 0.80000000000000004, 0.52359877559829882 }, - { 0.64603758566475511, 0.60000000000000009, 0.80000000000000004, + { 0.82814493499158170, 0.60000000000000009, 0.80000000000000004, 0.69813170079773179 }, - { 0.78380365594769730, 0.60000000000000009, 0.80000000000000004, + { 1.1511281795998280, 0.60000000000000009, 0.80000000000000004, 0.87266462599716477 }, - { 0.91430946255611190, 0.60000000000000009, 0.80000000000000004, + { 1.5864286332503075, 0.60000000000000009, 0.80000000000000004, 1.0471975511965976 }, - { 1.0398955217270607, 0.60000000000000009, 0.80000000000000004, + { 2.1958944866494527, 0.60000000000000009, 0.80000000000000004, 1.2217304763960306 }, - { 1.1625948314277679, 0.60000000000000009, 0.80000000000000004, + { 3.0398358172574604, 0.60000000000000009, 0.80000000000000004, 1.3962634015954636 }, - { 1.2840021261752192, 0.60000000000000009, 0.80000000000000004, + { 4.0867036409261832, 0.60000000000000009, 0.80000000000000004, 1.5707963267948966 }, }; const double toler159 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.90000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.5585887739668036e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.5952142720718732e-16 +// mean(f - f_Boost): 4.6351811278100284e-16 +// variance(f - f_Boost): 2.1278339779151204e-31 +// stddev(f - f_Boost): 4.6128450851021651e-16 const testcase_ellint_3<double> data160[10] = { { 0.0000000000000000, 0.60000000000000009, 0.90000000000000002, 0.0000000000000000 }, - { 0.17328652344890030, 0.60000000000000009, 0.90000000000000002, + { 0.17646850384035848, 0.60000000000000009, 0.90000000000000002, 0.17453292519943295 }, - { 0.33973880062929018, 0.60000000000000009, 0.90000000000000002, + { 0.36509041515134105, 0.60000000000000009, 0.90000000000000002, 0.34906585039886590 }, - { 0.49515092233122743, 0.60000000000000009, 0.90000000000000002, + { 0.58097838596260631, 0.60000000000000009, 0.90000000000000002, 0.52359877559829882 }, - { 0.63864042139737043, 0.60000000000000009, 0.90000000000000002, + { 0.84656453396163722, 0.60000000000000009, 0.90000000000000002, 0.69813170079773179 }, - { 0.77167205646538850, 0.60000000000000009, 0.90000000000000002, + { 1.1997828426963724, 0.60000000000000009, 0.90000000000000002, 0.87266462599716477 }, - { 0.89673202848034383, 0.60000000000000009, 0.90000000000000002, + { 1.7112436789225605, 0.60000000000000009, 0.90000000000000002, 1.0471975511965976 }, - { 1.0163984492661304, 0.60000000000000009, 0.90000000000000002, + { 2.5193168553672312, 0.60000000000000009, 0.90000000000000002, 1.2217304763960306 }, - { 1.1328845785162431, 0.60000000000000009, 0.90000000000000002, + { 3.8656670488606690, 0.60000000000000009, 0.90000000000000002, 1.3962634015954636 }, - { 1.2479362973851873, 0.60000000000000009, 0.90000000000000002, + { 5.8709993116265604, 0.60000000000000009, 0.90000000000000002, 1.5707963267948966 }, }; const double toler160 = 2.5000000000000020e-13; -// Test data for k=0.69999999999999996, nu=0.0000000000000000. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 3.5930208052157665e-16 +// Test data for k=0.70000000000000018, nu=0.0000000000000000. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.1569224977685422e-16 +// mean(f - f_Boost): 7.7715611723760953e-17 +// variance(f - f_Boost): 1.6571557210371951e-32 +// stddev(f - f_Boost): 1.2873056051447903e-16 const testcase_ellint_3<double> data161[10] = { - { 0.0000000000000000, 0.69999999999999996, 0.0000000000000000, + { 0.0000000000000000, 0.70000000000000018, 0.0000000000000000, 0.0000000000000000 }, - { 0.17496737466916723, 0.69999999999999996, 0.0000000000000000, + { 0.17496737466916723, 0.70000000000000018, 0.0000000000000000, 0.17453292519943295 }, - { 0.35254687535677925, 0.69999999999999996, 0.0000000000000000, + { 0.35254687535677931, 0.70000000000000018, 0.0000000000000000, 0.34906585039886590 }, - { 0.53536740275997119, 0.69999999999999996, 0.0000000000000000, + { 0.53536740275997130, 0.70000000000000018, 0.0000000000000000, 0.52359877559829882 }, - { 0.72603797651684454, 0.69999999999999996, 0.0000000000000000, + { 0.72603797651684454, 0.70000000000000018, 0.0000000000000000, 0.69813170079773179 }, - { 0.92698296348313458, 0.69999999999999996, 0.0000000000000000, + { 0.92698296348313447, 0.70000000000000018, 0.0000000000000000, 0.87266462599716477 }, - { 1.1400447527693316, 0.69999999999999996, 0.0000000000000000, + { 1.1400447527693318, 0.70000000000000018, 0.0000000000000000, 1.0471975511965976 }, - { 1.3657668117194073, 0.69999999999999996, 0.0000000000000000, + { 1.3657668117194073, 0.70000000000000018, 0.0000000000000000, 1.2217304763960306 }, - { 1.6024686895959159, 0.69999999999999996, 0.0000000000000000, + { 1.6024686895959164, 0.70000000000000018, 0.0000000000000000, 1.3962634015954636 }, - { 1.8456939983747236, 0.69999999999999996, 0.0000000000000000, + { 1.8456939983747236, 0.70000000000000018, 0.0000000000000000, 1.5707963267948966 }, }; const double toler161 = 2.5000000000000020e-13; -// Test data for k=0.69999999999999996, nu=0.10000000000000001. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 3.6735282577377367e-16 +// Test data for k=0.70000000000000018, nu=0.10000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.9552278747527691e-16 +// mean(f - f_Boost): 1.1102230246251565e-16 +// variance(f - f_Boost): 1.3695501826753678e-32 +// stddev(f - f_Boost): 1.1702778228589004e-16 const testcase_ellint_3<double> data162[10] = { - { 0.0000000000000000, 0.69999999999999996, 0.10000000000000001, + { 0.0000000000000000, 0.70000000000000018, 0.10000000000000001, 0.0000000000000000 }, - { 0.17479076384884684, 0.69999999999999996, 0.10000000000000001, + { 0.17514462737300920, 0.70000000000000018, 0.10000000000000001, 0.17453292519943295 }, - { 0.35114844900396364, 0.69999999999999996, 0.10000000000000001, + { 0.35396527997470451, 0.70000000000000018, 0.10000000000000001, 0.34906585039886590 }, - { 0.53072776947527001, 0.69999999999999996, 0.10000000000000001, + { 0.54015179589433981, 0.70000000000000018, 0.10000000000000001, 0.52359877559829882 }, - { 0.71530198262386235, 0.69999999999999996, 0.10000000000000001, + { 0.73734430854477728, 0.70000000000000018, 0.10000000000000001, 0.69813170079773179 }, - { 0.90666760677828306, 0.69999999999999996, 0.10000000000000001, + { 0.94888950796697047, 0.70000000000000018, 0.10000000000000001, 0.87266462599716477 }, - { 1.1063366517438080, 0.69999999999999996, 0.10000000000000001, + { 1.1772807959736322, 0.70000000000000018, 0.10000000000000001, 1.0471975511965976 }, - { 1.3149477243092149, 0.69999999999999996, 0.10000000000000001, + { 1.4231796401075834, 0.70000000000000018, 0.10000000000000001, 1.2217304763960306 }, - { 1.5314886725038925, 0.69999999999999996, 0.10000000000000001, + { 1.6841856799887471, 0.70000000000000018, 0.10000000000000001, 1.3962634015954636 }, - { 1.7528050171757608, 0.69999999999999996, 0.10000000000000001, + { 1.9541347343119564, 0.70000000000000018, 0.10000000000000001, 1.5707963267948966 }, }; const double toler162 = 2.5000000000000020e-13; -// Test data for k=0.69999999999999996, nu=0.20000000000000001. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 3.7517969287516802e-16 +// Test data for k=0.70000000000000018, nu=0.20000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.7430437016285820e-16 +// mean(f - f_Boost): 3.3306690738754695e-17 +// variance(f - f_Boost): 1.3695501826753678e-34 +// stddev(f - f_Boost): 1.1702778228589003e-17 const testcase_ellint_3<double> data163[10] = { - { 0.0000000000000000, 0.69999999999999996, 0.20000000000000001, + { 0.0000000000000000, 0.70000000000000018, 0.20000000000000001, 0.0000000000000000 }, - { 0.17461479077791475, 0.69999999999999996, 0.20000000000000001, + { 0.17532252613350796, 0.70000000000000018, 0.20000000000000001, 0.17453292519943295 }, - { 0.34976950621407538, 0.69999999999999996, 0.20000000000000001, + { 0.35540417596807522, 0.70000000000000018, 0.20000000000000001, 0.34906585039886590 }, - { 0.52622533231350177, 0.69999999999999996, 0.20000000000000001, + { 0.54508913033361928, 0.70000000000000018, 0.20000000000000001, 0.52359877559829882 }, - { 0.70508774017895215, 0.69999999999999996, 0.20000000000000001, + { 0.74927635777718415, 0.70000000000000018, 0.20000000000000001, 0.69813170079773179 }, - { 0.88775302531730294, 0.69999999999999996, 0.20000000000000001, + { 0.97261706337936338, 0.70000000000000018, 0.20000000000000001, 0.87266462599716477 }, - { 1.0756195476149006, 0.69999999999999996, 0.20000000000000001, + { 1.2187303976209327, 0.70000000000000018, 0.20000000000000001, 1.0471975511965976 }, - { 1.2695349716654374, 0.69999999999999996, 0.20000000000000001, + { 1.4887796709222487, 0.70000000000000018, 0.20000000000000001, 1.2217304763960306 }, - { 1.4690814617070540, 0.69999999999999996, 0.20000000000000001, + { 1.7796581281839214, 0.70000000000000018, 0.20000000000000001, 1.3962634015954636 }, - { 1.6721098780092145, 0.69999999999999996, 0.20000000000000001, + { 2.0829290325820207, 0.70000000000000018, 0.20000000000000001, 1.5707963267948966 }, }; const double toler163 = 2.5000000000000020e-13; -// Test data for k=0.69999999999999996, nu=0.29999999999999999. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8280039841080712e-16 +// Test data for k=0.70000000000000018, nu=0.30000000000000004. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.2570807706941696e-16 +// mean(f - f_Boost): 8.8817841970012528e-17 +// variance(f - f_Boost): 1.5582437633995295e-32 +// stddev(f - f_Boost): 1.2482963443828271e-16 const testcase_ellint_3<double> data164[10] = { - { 0.0000000000000000, 0.69999999999999996, 0.29999999999999999, + { 0.0000000000000000, 0.70000000000000018, 0.30000000000000004, 0.0000000000000000 }, - { 0.17443945136076175, 0.69999999999999996, 0.29999999999999999, + { 0.17550107516328570, 0.70000000000000018, 0.30000000000000004, 0.17453292519943295 }, - { 0.34840956983535287, 0.69999999999999996, 0.29999999999999999, + { 0.35686409576571965, 0.70000000000000018, 0.30000000000000004, 0.34906585039886590 }, - { 0.52185308551329168, 0.69999999999999996, 0.29999999999999999, + { 0.55018827316513352, 0.70000000000000018, 0.30000000000000004, 0.52359877559829882 }, - { 0.69535240431168255, 0.69999999999999996, 0.29999999999999999, + { 0.76189759494390275, 0.70000000000000018, 0.30000000000000004, 0.69813170079773179 }, - { 0.87007983473964923, 0.69999999999999996, 0.29999999999999999, + { 0.99844623430885626, 0.70000000000000018, 0.30000000000000004, 0.87266462599716477 }, - { 1.0474657975577066, 0.69999999999999996, 0.29999999999999999, + { 1.2652862989039833, 0.70000000000000018, 0.30000000000000004, 1.0471975511965976 }, - { 1.2286225419931891, 0.69999999999999996, 0.29999999999999999, + { 1.5647666808691361, 0.70000000000000018, 0.30000000000000004, 1.2217304763960306 }, - { 1.4136490671013271, 0.69999999999999996, 0.29999999999999999, + { 1.8932499694938165, 0.70000000000000018, 0.30000000000000004, 1.3962634015954636 }, - { 1.6011813647733213, 0.69999999999999996, 0.29999999999999999, + { 2.2392290510988535, 0.70000000000000018, 0.30000000000000004, 1.5707963267948966 }, }; const double toler164 = 2.5000000000000020e-13; -// Test data for k=0.69999999999999996, nu=0.40000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.3472957053482092e-16 +// Test data for k=0.70000000000000018, nu=0.40000000000000002. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.3719045096496910e-16 +// mean(f - f_Boost): 1.3600232051658169e-16 +// variance(f - f_Boost): 1.1718213750516114e-32 +// stddev(f - f_Boost): 1.0825069861444829e-16 const testcase_ellint_3<double> data165[10] = { - { 0.0000000000000000, 0.69999999999999996, 0.40000000000000002, + { 0.0000000000000000, 0.70000000000000018, 0.40000000000000002, 0.0000000000000000 }, - { 0.17426474153983229, 0.69999999999999996, 0.40000000000000002, + { 0.17568027871494424, 0.70000000000000018, 0.40000000000000002, 0.17453292519943295 }, - { 0.34706817945773732, 0.69999999999999996, 0.40000000000000002, + { 0.35834559208180261, 0.70000000000000018, 0.40000000000000002, 0.34906585039886590 }, - { 0.51760452851738148, 0.69999999999999996, 0.40000000000000002, + { 0.55545885451190613, 0.70000000000000018, 0.40000000000000002, 0.52359877559829882 }, - { 0.68605801534722755, 0.69999999999999996, 0.40000000000000002, + { 0.77528120402568113, 0.70000000000000018, 0.40000000000000002, 0.69813170079773179 }, - { 0.85351339387296532, 0.69999999999999996, 0.40000000000000002, + { 1.0267241287600322, 0.70000000000000018, 0.40000000000000002, 0.87266462599716477 }, - { 1.0215297967969539, 0.69999999999999996, 0.40000000000000002, + { 1.3181380338980246, 0.70000000000000018, 0.40000000000000002, 1.0471975511965976 }, - { 1.1915051074460530, 0.69999999999999996, 0.40000000000000002, + { 1.6542840785132087, 0.70000000000000018, 0.40000000000000002, 1.2217304763960306 }, - { 1.3639821911744707, 0.69999999999999996, 0.40000000000000002, + { 2.0315595131131823, 0.70000000000000018, 0.40000000000000002, 1.3962634015954636 }, - { 1.5382162002954762, 0.69999999999999996, 0.40000000000000002, + { 2.4342502915307880, 0.70000000000000018, 0.40000000000000002, 1.5707963267948966 }, }; const double toler165 = 2.5000000000000020e-13; -// Test data for k=0.69999999999999996, nu=0.50000000000000000. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 3.9748346743390620e-16 +// Test data for k=0.70000000000000018, nu=0.50000000000000000. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.0277361210295499e-16 +// mean(f - f_Boost): 1.6930901125533636e-16 +// variance(f - f_Boost): 6.3799163752809956e-32 +// stddev(f - f_Boost): 2.5258496343371268e-16 const testcase_ellint_3<double> data166[10] = { - { 0.0000000000000000, 0.69999999999999996, 0.50000000000000000, + { 0.0000000000000000, 0.70000000000000018, 0.50000000000000000, 0.0000000000000000 }, - { 0.17409065729516096, 0.69999999999999996, 0.50000000000000000, + { 0.17586014108156545, 0.70000000000000018, 0.50000000000000000, 0.17453292519943295 }, - { 0.34574489064986091, 0.69999999999999996, 0.50000000000000000, + { 0.35984923894341653, 0.70000000000000018, 0.50000000000000000, 0.34906585039886590 }, - { 0.51347361925579782, 0.69999999999999996, 0.50000000000000000, + { 0.56091135606739995, 0.70000000000000018, 0.50000000000000000, 0.52359877559829882 }, - { 0.67717079489579279, 0.69999999999999996, 0.50000000000000000, + { 0.78951212635197054, 0.70000000000000018, 0.50000000000000000, 0.69813170079773179 }, - { 0.83793902055292280, 0.69999999999999996, 0.50000000000000000, + { 1.0578865732938731, 0.70000000000000018, 0.50000000000000000, 0.87266462599716477 }, - { 0.99752863545289705, 0.69999999999999996, 0.50000000000000000, + { 1.3789149005151722, 0.70000000000000018, 0.50000000000000000, 1.0471975511965976 }, - { 1.1576240080401501, 0.69999999999999996, 0.50000000000000000, + { 1.7620212286086228, 0.70000000000000018, 0.50000000000000000, 1.2217304763960306 }, - { 1.3191464023923762, 0.69999999999999996, 0.50000000000000000, + { 2.2051554347435589, 0.70000000000000018, 0.50000000000000000, 1.3962634015954636 }, - { 1.4818433192178544, 0.69999999999999996, 0.50000000000000000, + { 2.6868019968236996, 0.70000000000000018, 0.50000000000000000, 1.5707963267948966 }, }; const double toler166 = 2.5000000000000020e-13; -// Test data for k=0.69999999999999996, nu=0.59999999999999998. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 4.0457157538295173e-16 +// Test data for k=0.70000000000000018, nu=0.60000000000000009. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.8597454441867134e-16 +// mean(f - f_Boost): 2.5535129566378598e-16 +// variance(f - f_Boost): 2.8561208198482198e-31 +// stddev(f - f_Boost): 5.3442687243889785e-16 const testcase_ellint_3<double> data167[10] = { - { 0.0000000000000000, 0.69999999999999996, 0.59999999999999998, + { 0.0000000000000000, 0.70000000000000018, 0.60000000000000009, 0.0000000000000000 }, - { 0.17391719464391614, 0.69999999999999996, 0.59999999999999998, + { 0.17604066659721918, 0.70000000000000018, 0.60000000000000009, 0.17453292519943295 }, - { 0.34443927423869031, 0.69999999999999996, 0.59999999999999998, + { 0.36137563278353424, 0.70000000000000018, 0.60000000000000009, 0.34906585039886590 }, - { 0.50945473266486063, 0.69999999999999996, 0.59999999999999998, + { 0.56655721272747606, 0.70000000000000018, 0.60000000000000009, 0.52359877559829882 }, - { 0.66866056326513812, 0.69999999999999996, 0.59999999999999998, + { 0.80468966552978305, 0.70000000000000018, 0.60000000000000009, 0.69813170079773179 }, - { 0.82325830002337352, 0.69999999999999996, 0.59999999999999998, + { 1.0924902943683852, 0.70000000000000018, 0.60000000000000009, 0.87266462599716477 }, - { 0.97522808245669368, 0.69999999999999996, 0.59999999999999998, + { 1.4499247992499800, 0.70000000000000018, 0.60000000000000009, 1.0471975511965976 }, - { 1.1265300613705285, 0.69999999999999996, 0.59999999999999998, + { 1.8953714382113818, 0.70000000000000018, 0.60000000000000009, 1.2217304763960306 }, - { 1.2784066076152001, 0.69999999999999996, 0.59999999999999998, + { 2.4323229949248670, 0.70000000000000018, 0.60000000000000009, 1.3962634015954636 }, - { 1.4309994736080540, 0.69999999999999996, 0.59999999999999998, + { 3.0314573496746746, 0.70000000000000018, 0.60000000000000009, 1.5707963267948966 }, }; const double toler167 = 2.5000000000000020e-13; -// Test data for k=0.69999999999999996, nu=0.69999999999999996. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 5.4867405596732161e-16 +// Test data for k=0.70000000000000018, nu=0.70000000000000007. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.2316852368580916e-16 +// mean(f - f_Boost): 7.7715611723760953e-17 +// variance(f - f_Boost): 7.4564398834547797e-34 +// stddev(f - f_Boost): 2.7306482533374340e-17 const testcase_ellint_3<double> data168[10] = { - { 0.0000000000000000, 0.69999999999999996, 0.69999999999999996, + { 0.0000000000000000, 0.70000000000000018, 0.70000000000000007, 0.0000000000000000 }, - { 0.17374434963995031, 0.69999999999999996, 0.69999999999999996, + { 0.17622185963747933, 0.70000000000000018, 0.70000000000000007, 0.17453292519943295 }, - { 0.34315091562900674, 0.69999999999999996, 0.69999999999999996, + { 0.36292539360435261, 0.70000000000000018, 0.70000000000000007, 0.34906585039886590 }, - { 0.50554262375653347, 0.69999999999999996, 0.69999999999999996, + { 0.57240892970150015, 0.70000000000000018, 0.70000000000000007, 0.52359877559829882 }, - { 0.66050025406305801, 0.69999999999999996, 0.69999999999999996, + { 0.82093084713182629, 0.70000000000000018, 0.70000000000000007, 0.69813170079773179 }, - { 0.80938620118847404, 0.69999999999999996, 0.69999999999999996, + { 1.1312609022179871, 0.70000000000000018, 0.70000000000000007, 0.87266462599716477 }, - { 0.95443223855852144, 0.69999999999999996, 0.69999999999999996, + { 1.5345768067715795, 0.70000000000000018, 0.70000000000000007, 1.0471975511965976 }, - { 1.0978573207128304, 0.69999999999999996, 0.69999999999999996, + { 2.0668847445934424, 0.70000000000000018, 0.70000000000000007, 1.2217304763960306 }, - { 1.2411754575007123, 0.69999999999999996, 0.69999999999999996, + { 2.7483444537551245, 0.70000000000000018, 0.70000000000000007, 1.3962634015954636 }, - { 1.3848459188329196, 0.69999999999999996, 0.69999999999999996, + { 3.5408408771788569, 0.70000000000000018, 0.70000000000000007, 1.5707963267948966 }, }; const double toler168 = 2.5000000000000020e-13; -// Test data for k=0.69999999999999996, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1829502028913879e-16 +// Test data for k=0.70000000000000018, nu=0.80000000000000004. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.1198716111867353e-16 +// mean(f - f_Boost): 2.2482016248659419e-16 +// variance(f - f_Boost): 5.4326441655972001e-32 +// stddev(f - f_Boost): 2.3308033305273100e-16 const testcase_ellint_3<double> data169[10] = { - { 0.0000000000000000, 0.69999999999999996, 0.80000000000000004, + { 0.0000000000000000, 0.70000000000000018, 0.80000000000000004, 0.0000000000000000 }, - { 0.17357211837335740, 0.69999999999999996, 0.80000000000000004, + { 0.17640372461994805, 0.70000000000000018, 0.80000000000000004, 0.17453292519943295 }, - { 0.34187941416012108, 0.69999999999999996, 0.80000000000000004, + { 0.36449916621651091, 0.70000000000000018, 0.80000000000000004, 0.34906585039886590 }, - { 0.50173239465478259, 0.69999999999999996, 0.80000000000000004, + { 0.57848021800372584, 0.70000000000000018, 0.80000000000000004, 0.52359877559829882 }, - { 0.65266550725988315, 0.69999999999999996, 0.80000000000000004, + { 0.83837480968392586, 0.70000000000000018, 0.80000000000000004, 0.69813170079773179 }, - { 0.79624879865249298, 0.69999999999999996, 0.80000000000000004, + { 1.1751669030061143, 0.70000000000000018, 0.80000000000000004, 0.87266462599716477 }, - { 0.93497577043296920, 0.69999999999999996, 0.80000000000000004, + { 1.6381851899173603, 0.70000000000000018, 0.80000000000000004, 1.0471975511965976 }, - { 1.0713041566930750, 0.69999999999999996, 0.80000000000000004, + { 2.3002065924302197, 0.70000000000000018, 0.80000000000000004, 1.2217304763960306 }, - { 1.2069772023255654, 0.69999999999999996, 0.80000000000000004, + { 3.2337600665337871, 0.70000000000000018, 0.80000000000000004, 1.3962634015954636 }, - { 1.3427110650397531, 0.69999999999999996, 0.80000000000000004, + { 4.4042405729076970, 0.70000000000000018, 0.80000000000000004, 1.5707963267948966 }, }; const double toler169 = 2.5000000000000020e-13; -// Test data for k=0.69999999999999996, nu=0.90000000000000002. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2494869624129105e-16 +// Test data for k=0.70000000000000018, nu=0.90000000000000002. +// max(|f - f_Boost|): 3.5527136788005009e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 8.5869439826269878e-16 +// mean(f - f_Boost): 7.4384942649885490e-16 +// variance(f - f_Boost): 9.7403930714297352e-31 +// stddev(f - f_Boost): 9.8693429727767263e-16 const testcase_ellint_3<double> data170[10] = { - { 0.0000000000000000, 0.69999999999999996, 0.90000000000000002, + { 0.0000000000000000, 0.70000000000000018, 0.90000000000000002, 0.0000000000000000 }, - { 0.17340049697003637, 0.69999999999999996, 0.90000000000000002, + { 0.17658626600478800, 0.70000000000000018, 0.90000000000000002, 0.17453292519943295 }, - { 0.34062438249741556, 0.69999999999999996, 0.90000000000000002, + { 0.36609762156017206, 0.70000000000000018, 0.90000000000000002, 0.34906585039886590 }, - { 0.49801946510076867, 0.69999999999999996, 0.90000000000000002, + { 0.58478615187842409, 0.70000000000000018, 0.90000000000000002, 0.52359877559829882 }, - { 0.64513432604750476, 0.69999999999999996, 0.90000000000000002, + { 0.85718862878291846, 0.70000000000000018, 0.90000000000000002, 0.69813170079773179 }, - { 0.78378145487573758, 0.69999999999999996, 0.90000000000000002, + { 1.2255385617397643, 0.70000000000000018, 0.90000000000000002, 0.87266462599716477 }, - { 0.91671799500854623, 0.69999999999999996, 0.90000000000000002, + { 1.7696521899992941, 0.70000000000000018, 0.90000000000000002, 1.0471975511965976 }, - { 1.0466193579463123, 0.69999999999999996, 0.90000000000000002, + { 2.6476314987883507, 0.70000000000000018, 0.90000000000000002, 1.2217304763960306 }, - { 1.1754218079199146, 0.69999999999999996, 0.90000000000000002, + { 4.1373434902898083, 0.70000000000000018, 0.90000000000000002, 1.3962634015954636 }, - { 1.3040500499695913, 0.69999999999999996, 0.90000000000000002, + { 6.3796094177887763, 0.70000000000000018, 0.90000000000000002, 1.5707963267948966 }, }; const double toler170 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.0000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1175183168766718e-16 +// max(|f - f_Boost|): 1.5543122344752192e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.7898565163847540e-16 +// mean(f - f_Boost): 2.3869795029440865e-16 +// variance(f - f_Boost): 2.1368406725192426e-31 +// stddev(f - f_Boost): 4.6225974002926564e-16 const testcase_ellint_3<double> data171[10] = { @@ -4978,596 +5490,654 @@ data171[10] = 0.0000000000000000 }, { 0.17510154241338899, 0.80000000000000004, 0.0000000000000000, 0.17453292519943295 }, - { 0.35365068839779390, 0.80000000000000004, 0.0000000000000000, + { 0.35365068839779396, 0.80000000000000004, 0.0000000000000000, 0.34906585039886590 }, { 0.53926804409084550, 0.80000000000000004, 0.0000000000000000, 0.52359877559829882 }, - { 0.73587926028070361, 0.80000000000000004, 0.0000000000000000, + { 0.73587926028070372, 0.80000000000000004, 0.0000000000000000, 0.69813170079773179 }, { 0.94770942970071170, 0.80000000000000004, 0.0000000000000000, 0.87266462599716477 }, { 1.1789022995388236, 0.80000000000000004, 0.0000000000000000, 1.0471975511965976 }, - { 1.4323027881876009, 0.80000000000000004, 0.0000000000000000, + { 1.4323027881876012, 0.80000000000000004, 0.0000000000000000, 1.2217304763960306 }, - { 1.7069629739121674, 0.80000000000000004, 0.0000000000000000, + { 1.7069629739121677, 0.80000000000000004, 0.0000000000000000, 1.3962634015954636 }, - { 1.9953027776647296, 0.80000000000000004, 0.0000000000000000, + { 1.9953027776647294, 0.80000000000000004, 0.0000000000000000, 1.5707963267948966 }, }; const double toler171 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.10000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1537164503193145e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 8.3898786942190374e-16 +// mean(f - f_Boost): 2.3869795029440865e-16 +// variance(f - f_Boost): 2.9190059990693968e-31 +// stddev(f - f_Boost): 5.4027826155319237e-16 const testcase_ellint_3<double> data172[10] = { { 0.0000000000000000, 0.80000000000000004, 0.10000000000000001, 0.0000000000000000 }, - { 0.17492468824017163, 0.80000000000000004, 0.10000000000000001, + { 0.17527903952342144, 0.80000000000000004, 0.10000000000000001, 0.17453292519943295 }, - { 0.35224443521476911, 0.80000000000000004, 0.10000000000000001, + { 0.35507705313548549, 0.80000000000000004, 0.10000000000000001, 0.34906585039886590 }, - { 0.53456851853226950, 0.80000000000000004, 0.10000000000000001, + { 0.54411455987643553, 0.80000000000000004, 0.10000000000000001, 0.52359877559829882 }, - { 0.72488875602364922, 0.80000000000000004, 0.10000000000000001, + { 0.74745625666804383, 0.80000000000000004, 0.10000000000000001, 0.69813170079773179 }, - { 0.92661354274638952, 0.80000000000000004, 0.10000000000000001, + { 0.97046953684238557, 0.80000000000000004, 0.10000000000000001, 0.87266462599716477 }, - { 1.1432651144499075, 0.80000000000000004, 0.10000000000000001, + { 1.2183080025184605, 0.80000000000000004, 0.10000000000000001, 1.0471975511965976 }, - { 1.3774479927211429, 0.80000000000000004, 0.10000000000000001, + { 1.4943711151994405, 0.80000000000000004, 0.10000000000000001, 1.2217304763960306 }, - { 1.6287092337196041, 0.80000000000000004, 0.10000000000000001, + { 1.7972401309544201, 0.80000000000000004, 0.10000000000000001, 1.3962634015954636 }, - { 1.8910755418379521, 0.80000000000000004, 0.10000000000000001, + { 2.1172616484005085, 0.80000000000000004, 0.10000000000000001, 1.5707963267948966 }, }; const double toler172 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.20000000000000001. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1894552974436829e-16 +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.8513740186068518e-16 +// mean(f - f_Boost): 2.8310687127941490e-16 +// variance(f - f_Boost): 2.7528339102381189e-31 +// stddev(f - f_Boost): 5.2467455724840699e-16 const testcase_ellint_3<double> data173[10] = { { 0.0000000000000000, 0.80000000000000004, 0.20000000000000001, 0.0000000000000000 }, - { 0.17474847286224940, 0.80000000000000004, 0.20000000000000001, + { 0.17545718375086419, 0.80000000000000004, 0.20000000000000001, 0.17453292519943295 }, - { 0.35085779529084682, 0.80000000000000004, 0.20000000000000001, + { 0.35652404627248163, 0.80000000000000004, 0.20000000000000001, 0.34906585039886590 }, - { 0.53000829263059146, 0.80000000000000004, 0.20000000000000001, + { 0.54911638512920913, 0.80000000000000004, 0.20000000000000001, 0.52359877559829882 }, - { 0.71443466027453384, 0.80000000000000004, 0.20000000000000001, + { 0.75967684282131176, 0.80000000000000004, 0.20000000000000001, 0.69813170079773179 }, - { 0.90698196872715420, 0.80000000000000004, 0.20000000000000001, + { 0.99513526893543769, 0.80000000000000004, 0.20000000000000001, 0.87266462599716477 }, - { 1.1108198200558579, 0.80000000000000004, 0.20000000000000001, + { 1.2622192109995993, 0.80000000000000004, 0.20000000000000001, 1.0471975511965976 }, - { 1.3284988909963957, 0.80000000000000004, 0.20000000000000001, + { 1.5654106676347741, 0.80000000000000004, 0.20000000000000001, 1.2217304763960306 }, - { 1.5600369318140328, 0.80000000000000004, 0.20000000000000001, + { 1.9029531718534984, 0.80000000000000004, 0.20000000000000001, 1.3962634015954636 }, - { 1.8007226661734588, 0.80000000000000004, 0.20000000000000001, + { 2.2624789434186798, 0.80000000000000004, 0.20000000000000001, 1.5707963267948966 }, }; const double toler173 = 2.5000000000000020e-13; -// Test data for k=0.80000000000000004, nu=0.29999999999999999. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2247517409029886e-16 +// Test data for k=0.80000000000000004, nu=0.30000000000000004. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.2825261583337354e-16 +// mean(f - f_Boost): 2.6367796834847468e-16 +// variance(f - f_Boost): 2.8249350208968825e-31 +// stddev(f - f_Boost): 5.3150117788175054e-16 const testcase_ellint_3<double> data174[10] = { - { 0.0000000000000000, 0.80000000000000004, 0.29999999999999999, + { 0.0000000000000000, 0.80000000000000004, 0.30000000000000004, 0.0000000000000000 }, - { 0.17457289217669889, 0.80000000000000004, 0.29999999999999999, + { 0.17563597931587369, 0.80000000000000004, 0.30000000000000004, 0.17453292519943295 }, - { 0.34949028801501258, 0.80000000000000004, 0.29999999999999999, + { 0.35799220412005128, 0.80000000000000004, 0.30000000000000004, 0.34906585039886590 }, - { 0.52558024362769307, 0.80000000000000004, 0.29999999999999999, + { 0.55428253691111318, 0.80000000000000004, 0.30000000000000004, 0.52359877559829882 }, - { 0.70447281740094891, 0.80000000000000004, 0.29999999999999999, + { 0.77260647376977365, 0.80000000000000004, 0.30000000000000004, 0.69813170079773179 }, - { 0.88864745641528986, 0.80000000000000004, 0.29999999999999999, + { 1.0220015271210958, 0.80000000000000004, 0.30000000000000004, 0.87266462599716477 }, - { 1.0811075819341462, 0.80000000000000004, 0.29999999999999999, + { 1.3115965312302671, 0.80000000000000004, 0.30000000000000004, 1.0471975511965976 }, - { 1.2844589654082377, 0.80000000000000004, 0.29999999999999999, + { 1.6478518468813512, 0.80000000000000004, 0.30000000000000004, 1.2217304763960306 }, - { 1.4991461361277847, 0.80000000000000004, 0.29999999999999999, + { 2.0290458414203481, 0.80000000000000004, 0.30000000000000004, 1.3962634015954636 }, - { 1.7214611048717301, 0.80000000000000004, 0.29999999999999999, + { 2.4392042002725693, 0.80000000000000004, 0.30000000000000004, 1.5707963267948966 }, }; const double toler174 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.40000000000000002. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2596216594752862e-16 +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 8.3462748389836647e-16 +// mean(f - f_Boost): 3.3861802251067273e-16 +// variance(f - f_Boost): 4.3719465706454422e-31 +// stddev(f - f_Boost): 6.6120696991527871e-16 const testcase_ellint_3<double> data175[10] = { { 0.0000000000000000, 0.80000000000000004, 0.40000000000000002, 0.0000000000000000 }, - { 0.17439794211872175, 0.80000000000000004, 0.40000000000000002, + { 0.17581543047866136, 0.80000000000000004, 0.40000000000000002, 0.17453292519943295 }, - { 0.34814144964568972, 0.80000000000000004, 0.40000000000000002, + { 0.35948208343061633, 0.80000000000000004, 0.40000000000000002, 0.34906585039886590 }, - { 0.52127776285273064, 0.80000000000000004, 0.40000000000000002, + { 0.55962280893702021, 0.80000000000000004, 0.40000000000000002, 0.52359877559829882 }, - { 0.69496411438966588, 0.80000000000000004, 0.40000000000000002, + { 0.78632063889234116, 0.80000000000000004, 0.40000000000000002, 0.69813170079773179 }, - { 0.87146878427509589, 0.80000000000000004, 0.40000000000000002, + { 1.0514333069550323, 0.80000000000000004, 0.40000000000000002, 0.87266462599716477 }, - { 1.0537579024937762, 0.80000000000000004, 0.40000000000000002, + { 1.3677213138838757, 0.80000000000000004, 0.40000000000000002, 1.0471975511965976 }, - { 1.2445534387922637, 0.80000000000000004, 0.40000000000000002, + { 1.7451736773665165, 0.80000000000000004, 0.40000000000000002, 1.2217304763960306 }, - { 1.4446769766361993, 0.80000000000000004, 0.40000000000000002, + { 2.1830100424586831, 0.80000000000000004, 0.40000000000000002, 1.3962634015954636 }, - { 1.6512267838651289, 0.80000000000000004, 0.40000000000000002, + { 2.6604037035529724, 0.80000000000000004, 0.40000000000000002, 1.5707963267948966 }, }; const double toler175 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.50000000000000000. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.2940800093915668e-16 +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.0388243828581744e-16 +// mean(f - f_Boost): 3.8580250105724191e-16 +// variance(f - f_Boost): 6.4106456575047741e-31 +// stddev(f - f_Boost): 8.0066507713929764e-16 const testcase_ellint_3<double> data176[10] = { { 0.0000000000000000, 0.80000000000000004, 0.50000000000000000, 0.0000000000000000 }, - { 0.17422361866118044, 0.80000000000000004, 0.50000000000000000, + { 0.17599554153999472, 0.80000000000000004, 0.50000000000000000, 0.17453292519943295 }, - { 0.34681083254170475, 0.80000000000000004, 0.50000000000000000, + { 0.36099426243351540, 0.80000000000000004, 0.50000000000000000, 0.34906585039886590 }, - { 0.51709470815494440, 0.80000000000000004, 0.50000000000000000, + { 0.56514786174780673, 0.80000000000000004, 0.50000000000000000, 0.52359877559829882 }, - { 0.68587375344080237, 0.80000000000000004, 0.50000000000000000, + { 0.80090697622371010, 0.80000000000000004, 0.50000000000000000, 0.69813170079773179 }, - { 0.85532571852810624, 0.80000000000000004, 0.50000000000000000, + { 1.0838891627679339, 0.80000000000000004, 0.50000000000000000, 0.87266462599716477 }, - { 1.0284677391874903, 0.80000000000000004, 0.50000000000000000, + { 1.4323506654466280, 0.80000000000000004, 0.50000000000000000, 1.0471975511965976 }, - { 1.2081693942686225, 0.80000000000000004, 0.50000000000000000, + { 1.8625761085390575, 0.80000000000000004, 0.50000000000000000, 1.2217304763960306 }, - { 1.3955803006426311, 0.80000000000000004, 0.50000000000000000, + { 2.3768757305654766, 0.80000000000000004, 0.50000000000000000, 1.3962634015954636 }, - { 1.5884528947755532, 0.80000000000000004, 0.50000000000000000, + { 2.9478781158239746, 0.80000000000000004, 0.50000000000000000, 1.5707963267948966 }, }; const double toler176 = 2.5000000000000020e-13; -// Test data for k=0.80000000000000004, nu=0.59999999999999998. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.3281408974056389e-16 +// Test data for k=0.80000000000000004, nu=0.60000000000000009. +// max(|f - f_Boost|): 3.5527136788005009e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.0631099169042069e-15 +// mean(f - f_Boost): 4.8294701571194306e-16 +// variance(f - f_Boost): 1.1633910328160319e-30 +// stddev(f - f_Boost): 1.0786060600682865e-15 const testcase_ellint_3<double> data177[10] = { - { 0.0000000000000000, 0.80000000000000004, 0.59999999999999998, + { 0.0000000000000000, 0.80000000000000004, 0.60000000000000009, 0.0000000000000000 }, - { 0.17404991781414089, 0.80000000000000004, 0.59999999999999998, + { 0.17617631684170665, 0.80000000000000004, 0.60000000000000009, 0.17453292519943295 }, - { 0.34549800443625167, 0.80000000000000004, 0.59999999999999998, + { 0.36252934193666231, 0.80000000000000004, 0.60000000000000009, 0.34906585039886590 }, - { 0.51302536167001545, 0.80000000000000004, 0.59999999999999998, + { 0.57086932622945163, 0.80000000000000004, 0.60000000000000009, 0.52359877559829882 }, - { 0.67717065003912236, 0.80000000000000004, 0.59999999999999998, + { 0.81646796740150973, 0.80000000000000004, 0.60000000000000009, 0.69813170079773179 }, - { 0.84011512421134416, 0.80000000000000004, 0.59999999999999998, + { 1.1199552158519064, 0.80000000000000004, 0.60000000000000009, 0.87266462599716477 }, - { 1.0049863847088740, 0.80000000000000004, 0.59999999999999998, + { 1.5079766673336394, 0.80000000000000004, 0.60000000000000009, 1.0471975511965976 }, - { 1.1748145941898920, 0.80000000000000004, 0.59999999999999998, + { 2.0082747447038165, 0.80000000000000004, 0.60000000000000009, 1.2217304763960306 }, - { 1.3510319699755071, 0.80000000000000004, 0.59999999999999998, + { 2.6315146066775523, 0.80000000000000004, 0.60000000000000009, 1.3962634015954636 }, - { 1.5319262547427865, 0.80000000000000004, 0.59999999999999998, + { 3.3418121892288051, 0.80000000000000004, 0.60000000000000009, 1.5707963267948966 }, }; const double toler177 = 2.5000000000000020e-13; -// Test data for k=0.80000000000000004, nu=0.69999999999999996. -// max(|f - f_GSL|): 2.2204460492503131e-16 -// max(|f - f_GSL| / |f_GSL|): 4.3618176466061808e-16 +// Test data for k=0.80000000000000004, nu=0.70000000000000007. +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.6544679145741375e-16 +// mean(f - f_Boost): 3.2751579226442120e-16 +// variance(f - f_Boost): 4.4236851331020672e-31 +// stddev(f - f_Boost): 6.6510789599147505e-16 const testcase_ellint_3<double> data178[10] = { - { 0.0000000000000000, 0.80000000000000004, 0.69999999999999996, + { 0.0000000000000000, 0.80000000000000004, 0.70000000000000007, 0.0000000000000000 }, - { 0.17387683562442199, 0.80000000000000004, 0.69999999999999996, + { 0.17635776076721221, 0.80000000000000004, 0.70000000000000007, 0.17453292519943295 }, - { 0.34420254775101611, 0.80000000000000004, 0.69999999999999996, + { 0.36408794649916976, 0.80000000000000004, 0.70000000000000007, 0.34906585039886590 }, - { 0.50906439222143673, 0.80000000000000004, 0.69999999999999996, + { 0.57679992290624138, 0.80000000000000004, 0.70000000000000007, 0.52359877559829882 }, - { 0.66882693152688422, 0.80000000000000004, 0.69999999999999996, + { 0.83312441418142813, 0.80000000000000004, 0.70000000000000007, 0.69813170079773179 }, - { 0.82574792844091316, 0.80000000000000004, 0.69999999999999996, + { 1.1603958891464856, 0.80000000000000004, 0.70000000000000007, 0.87266462599716477 }, - { 0.98310431309490931, 0.80000000000000004, 0.69999999999999996, + { 1.5982855143796213, 0.80000000000000004, 0.70000000000000007, 1.0471975511965976 }, - { 1.1440884535113258, 0.80000000000000004, 0.69999999999999996, + { 2.1962484408371821, 0.80000000000000004, 0.70000000000000007, 1.2217304763960306 }, - { 1.3103743938952537, 0.80000000000000004, 0.69999999999999996, + { 2.9873281786111869, 0.80000000000000004, 0.70000000000000007, 1.3962634015954636 }, - { 1.4806912324625332, 0.80000000000000004, 0.69999999999999996, + { 3.9268876980046397, 0.80000000000000004, 0.70000000000000007, 1.5707963267948966 }, }; const double toler178 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.3951228558314112e-16 +// max(|f - f_Boost|): 4.4408920985006262e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.0176949165011079e-16 +// mean(f - f_Boost): 7.0499162063697436e-16 +// variance(f - f_Boost): 1.7230805408026989e-30 +// stddev(f - f_Boost): 1.3126616246400665e-15 const testcase_ellint_3<double> data179[10] = { { 0.0000000000000000, 0.80000000000000004, 0.80000000000000004, 0.0000000000000000 }, - { 0.17370436817515203, 0.80000000000000004, 0.80000000000000004, + { 0.17653987774203392, 0.80000000000000004, 0.80000000000000004, 0.17453292519943295 }, - { 0.34292405894783395, 0.80000000000000004, 0.80000000000000004, + { 0.36567072568046877, 0.80000000000000004, 0.80000000000000004, 0.34906585039886590 }, - { 0.50520682176250076, 0.80000000000000004, 0.80000000000000004, + { 0.58295359996558616, 0.80000000000000004, 0.80000000000000004, 0.52359877559829882 }, - { 0.66081751679736178, 0.80000000000000004, 0.80000000000000004, + { 0.85101998309176108, 0.80000000000000004, 0.80000000000000004, 0.69813170079773179 }, - { 0.81214672249355102, 0.80000000000000004, 0.80000000000000004, + { 1.2062322059736537, 0.80000000000000004, 0.80000000000000004, 0.87266462599716477 }, - { 0.96264481387685552, 0.80000000000000004, 0.80000000000000004, + { 1.7090321420917429, 0.80000000000000004, 0.80000000000000004, 1.0471975511965976 }, - { 1.1156611352656258, 0.80000000000000004, 0.80000000000000004, + { 2.4529058049405066, 0.80000000000000004, 0.80000000000000004, 1.2217304763960306 }, - { 1.2730756225143889, 0.80000000000000004, 0.80000000000000004, + { 3.5368893360106948, 0.80000000000000004, 0.80000000000000004, 1.3962634015954636 }, - { 1.4339837018309471, 0.80000000000000004, 0.80000000000000004, + { 4.9246422058196062, 0.80000000000000004, 0.80000000000000004, 1.5707963267948966 }, }; const double toler179 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.90000000000000002. -// max(|f - f_GSL|): 3.3306690738754696e-16 -// max(|f - f_GSL| / |f_GSL|): 4.4280684534289690e-16 +// max(|f - f_Boost|): 4.4408920985006262e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.7782721357365268e-16 +// mean(f - f_Boost): 8.9928064994637676e-16 +// variance(f - f_Boost): 1.5485199571025344e-30 +// stddev(f - f_Boost): 1.2443954183066307e-15 const testcase_ellint_3<double> data180[10] = { { 0.0000000000000000, 0.80000000000000004, 0.90000000000000002, 0.0000000000000000 }, - { 0.17353251158533151, 0.80000000000000004, 0.90000000000000002, + { 0.17672267223433513, 0.80000000000000004, 0.90000000000000002, 0.17453292519943295 }, - { 0.34166214791545768, 0.80000000000000004, 0.90000000000000002, + { 0.36727835537196063, 0.80000000000000004, 0.90000000000000002, 0.34906585039886590 }, - { 0.50144799535130569, 0.80000000000000004, 0.90000000000000002, + { 0.58934569363716649, 0.80000000000000004, 0.90000000000000002, 0.52359877559829882 }, - { 0.65311976193814425, 0.80000000000000004, 0.90000000000000002, + { 0.87032723471138851, 0.80000000000000004, 0.90000000000000002, 0.69813170079773179 }, - { 0.79924384892320866, 0.80000000000000004, 0.90000000000000002, + { 1.2588676111323349, 0.80000000000000004, 0.90000000000000002, 0.87266462599716477 }, - { 0.94345762353365603, 0.80000000000000004, 0.90000000000000002, + { 1.8498731900660019, 0.80000000000000004, 0.90000000000000002, 1.0471975511965976 }, - { 1.0892582069219161, 0.80000000000000004, 0.90000000000000002, + { 2.8368381299300420, 0.80000000000000004, 0.90000000000000002, 1.2217304763960306 }, - { 1.2387000876610268, 0.80000000000000004, 0.90000000000000002, + { 4.5674844191654058, 0.80000000000000004, 0.90000000000000002, 1.3962634015954636 }, - { 1.3911845406776222, 0.80000000000000004, 0.90000000000000002, + { 7.2263259298637115, 0.80000000000000004, 0.90000000000000002, 1.5707963267948966 }, }; const double toler180 = 2.5000000000000020e-13; -// Test data for k=0.89999999999999991, nu=0.0000000000000000. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8945813740035884e-16 +// Test data for k=0.90000000000000013, nu=0.0000000000000000. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.3381508715713360e-16 +// mean(f - f_Boost): 5.8286708792820721e-17 +// variance(f - f_Boost): 4.1942474344433133e-34 +// stddev(f - f_Boost): 2.0479861900030756e-17 const testcase_ellint_3<double> data181[10] = { - { 0.0000000000000000, 0.89999999999999991, 0.0000000000000000, + { 0.0000000000000000, 0.90000000000000013, 0.0000000000000000, 0.0000000000000000 }, - { 0.17525427376115024, 0.89999999999999991, 0.0000000000000000, + { 0.17525427376115027, 0.90000000000000013, 0.0000000000000000, 0.17453292519943295 }, - { 0.35492464591297446, 0.89999999999999991, 0.0000000000000000, + { 0.35492464591297446, 0.90000000000000013, 0.0000000000000000, 0.34906585039886590 }, - { 0.54388221416157112, 0.89999999999999991, 0.0000000000000000, + { 0.54388221416157123, 0.90000000000000013, 0.0000000000000000, 0.52359877559829882 }, - { 0.74797400423532490, 0.89999999999999991, 0.0000000000000000, + { 0.74797400423532512, 0.90000000000000013, 0.0000000000000000, 0.69813170079773179 }, - { 0.97463898451966458, 0.89999999999999991, 0.0000000000000000, + { 0.97463898451966446, 0.90000000000000013, 0.0000000000000000, 0.87266462599716477 }, - { 1.2334463254523440, 0.89999999999999991, 0.0000000000000000, + { 1.2334463254523440, 0.90000000000000013, 0.0000000000000000, 1.0471975511965976 }, - { 1.5355247765594910, 0.89999999999999991, 0.0000000000000000, + { 1.5355247765594915, 0.90000000000000013, 0.0000000000000000, 1.2217304763960306 }, - { 1.8882928567775117, 0.89999999999999991, 0.0000000000000000, + { 1.8882928567775128, 0.90000000000000013, 0.0000000000000000, 1.3962634015954636 }, - { 2.2805491384227703, 0.89999999999999991, 0.0000000000000000, + { 2.2805491384227707, 0.90000000000000013, 0.0000000000000000, 1.5707963267948966 }, }; const double toler181 = 2.5000000000000020e-13; -// Test data for k=0.89999999999999991, nu=0.10000000000000001. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 4.1237990617685137e-16 +// Test data for k=0.90000000000000013, nu=0.10000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.1500594295134815e-16 +// mean(f - f_Boost): 9.1593399531575410e-17 +// variance(f - f_Boost): 1.0357223256482469e-33 +// stddev(f - f_Boost): 3.2182640128619758e-17 const testcase_ellint_3<double> data182[10] = { - { 0.0000000000000000, 0.89999999999999991, 0.10000000000000001, + { 0.0000000000000000, 0.90000000000000013, 0.10000000000000001, 0.0000000000000000 }, - { 0.17507714233254656, 0.89999999999999991, 0.10000000000000001, + { 0.17543204932716244, 0.90000000000000013, 0.10000000000000001, 0.17453292519943295 }, - { 0.35350932904326521, 0.89999999999999991, 0.10000000000000001, + { 0.35636022898551184, 0.90000000000000013, 0.10000000000000001, 0.34906585039886590 }, - { 0.53911129989870976, 0.89999999999999991, 0.10000000000000001, + { 0.54880278898382595, 0.90000000000000013, 0.10000000000000001, 0.52359877559829882 }, - { 0.73666644254508395, 0.89999999999999991, 0.10000000000000001, + { 0.75988834774529268, 0.90000000000000013, 0.10000000000000001, 0.69813170079773179 }, - { 0.95250736612100195, 0.89999999999999991, 0.10000000000000001, + { 0.99853303003568117, 0.90000000000000013, 0.10000000000000001, 0.87266462599716477 }, - { 1.1950199550905594, 0.89999999999999991, 0.10000000000000001, + { 1.2759958823999022, 0.90000000000000013, 0.10000000000000001, 1.0471975511965976 }, - { 1.4741687286340848, 0.89999999999999991, 0.10000000000000001, + { 1.6051187364639401, 0.90000000000000013, 0.10000000000000001, 1.2217304763960306 }, - { 1.7968678183506053, 0.89999999999999991, 0.10000000000000001, + { 1.9941406879519474, 0.90000000000000013, 0.10000000000000001, 1.3962634015954636 }, - { 2.1537868513875287, 0.89999999999999991, 0.10000000000000001, + { 2.4295011187834890, 0.90000000000000013, 0.10000000000000001, 1.5707963267948966 }, }; const double toler182 = 2.5000000000000020e-13; -// Test data for k=0.89999999999999991, nu=0.20000000000000001. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 4.3446165733924066e-16 +// Test data for k=0.90000000000000013, nu=0.20000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.9533518431433547e-16 +// mean(f - f_Boost): 1.0269562977782698e-16 +// variance(f - f_Boost): 1.4388836606733082e-32 +// stddev(f - f_Boost): 1.1995347684303728e-16 const testcase_ellint_3<double> data183[10] = { - { 0.0000000000000000, 0.89999999999999991, 0.20000000000000001, + { 0.0000000000000000, 0.90000000000000013, 0.20000000000000001, 0.0000000000000000 }, - { 0.17490065089140927, 0.89999999999999991, 0.20000000000000001, + { 0.17561047321968409, 0.90000000000000013, 0.20000000000000001, 0.17453292519943295 }, - { 0.35211377590661436, 0.89999999999999991, 0.20000000000000001, + { 0.35781659944356109, 0.90000000000000013, 0.20000000000000001, 0.34906585039886590 }, - { 0.53448220334204100, 0.89999999999999991, 0.20000000000000001, + { 0.55388150905215283, 0.90000000000000013, 0.20000000000000001, 0.52359877559829882 }, - { 0.72591368943179579, 0.89999999999999991, 0.20000000000000001, + { 0.77246874123251441, 0.90000000000000013, 0.20000000000000001, 0.69813170079773179 }, - { 0.93192539780038763, 0.89999999999999991, 0.20000000000000001, + { 1.0244466254771925, 0.90000000000000013, 0.20000000000000001, 0.87266462599716477 }, - { 1.1600809679692683, 0.89999999999999991, 0.20000000000000001, + { 1.3234824077640801, 0.90000000000000013, 0.20000000000000001, 1.0471975511965976 }, - { 1.4195407225882508, 0.89999999999999991, 0.20000000000000001, + { 1.6849848968804240, 0.90000000000000013, 0.20000000000000001, 1.2217304763960306 }, - { 1.7168966476424521, 0.89999999999999991, 0.20000000000000001, + { 2.1185749045502278, 0.90000000000000013, 0.20000000000000001, 1.3962634015954636 }, - { 2.0443194576468895, 0.89999999999999991, 0.20000000000000001, + { 2.6076835743348417, 0.90000000000000013, 0.20000000000000001, 1.5707963267948966 }, }; const double toler183 = 2.5000000000000020e-13; -// Test data for k=0.89999999999999991, nu=0.29999999999999999. -// max(|f - f_GSL|): 1.1102230246251565e-15 -// max(|f - f_GSL| / |f_GSL|): 5.6974600067013622e-16 +// Test data for k=0.90000000000000013, nu=0.30000000000000004. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.9712691025502371e-16 +// mean(f - f_Boost): 6.9388939039072284e-17 +// variance(f - f_Boost): 5.9442282234173945e-34 +// stddev(f - f_Boost): 2.4380787976227090e-17 const testcase_ellint_3<double> data184[10] = { - { 0.0000000000000000, 0.89999999999999991, 0.29999999999999999, + { 0.0000000000000000, 0.90000000000000013, 0.30000000000000004, 0.0000000000000000 }, - { 0.17472479532647531, 0.89999999999999991, 0.29999999999999999, + { 0.17578954966746221, 0.90000000000000013, 0.30000000000000004, 0.17453292519943295 }, - { 0.35073750187374114, 0.89999999999999991, 0.29999999999999999, + { 0.35929429810867447, 0.90000000000000013, 0.30000000000000004, 0.34906585039886590 }, - { 0.52998766129466957, 0.89999999999999991, 0.29999999999999999, + { 0.55912757154240822, 0.90000000000000013, 0.30000000000000004, 0.52359877559829882 }, - { 0.71566993548699553, 0.89999999999999991, 0.29999999999999999, + { 0.78578314722025389, 0.90000000000000013, 0.30000000000000004, 0.69813170079773179 }, - { 0.91271517762560195, 0.89999999999999991, 0.29999999999999999, + { 1.0526941001131365, 0.90000000000000013, 0.30000000000000004, 0.87266462599716477 }, - { 1.1281241199843370, 0.89999999999999991, 0.29999999999999999, + { 1.3769682234538601, 0.90000000000000013, 0.30000000000000004, 1.0471975511965976 }, - { 1.3704929576917448, 0.89999999999999991, 0.29999999999999999, + { 1.7779437432911240, 0.90000000000000013, 0.30000000000000004, 1.2217304763960306 }, - { 1.6461981511487711, 0.89999999999999991, 0.29999999999999999, + { 2.2676509341813635, 0.90000000000000013, 0.30000000000000004, 1.3962634015954636 }, - { 1.9486280260314426, 0.89999999999999991, 0.29999999999999999, + { 2.8256506968858517, 0.90000000000000013, 0.30000000000000004, 1.5707963267948966 }, }; const double toler184 = 2.5000000000000020e-13; -// Test data for k=0.89999999999999991, nu=0.40000000000000002. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 4.7646208744449464e-16 +// Test data for k=0.90000000000000013, nu=0.40000000000000002. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.7042235432234642e-16 +// mean(f - f_Boost): 1.8041124150158794e-16 +// variance(f - f_Boost): 8.5834655546147173e-33 +// stddev(f - f_Boost): 9.2646994309662939e-17 const testcase_ellint_3<double> data185[10] = { - { 0.0000000000000000, 0.89999999999999991, 0.40000000000000002, + { 0.0000000000000000, 0.90000000000000013, 0.40000000000000002, 0.0000000000000000 }, - { 0.17454957156468837, 0.89999999999999991, 0.40000000000000002, + { 0.17596928293938452, 0.90000000000000013, 0.40000000000000002, 0.17453292519943295 }, - { 0.34938003933330430, 0.89999999999999991, 0.40000000000000002, + { 0.36079388642472821, 0.90000000000000013, 0.40000000000000002, 0.34906585039886590 }, - { 0.52562093533067433, 0.89999999999999991, 0.40000000000000002, + { 0.56455096667115612, 0.90000000000000013, 0.40000000000000002, 0.52359877559829882 }, - { 0.70589461324915670, 0.89999999999999991, 0.40000000000000002, + { 0.79990996997869435, 0.90000000000000013, 0.40000000000000002, 0.69813170079773179 }, - { 0.89472658511942849, 0.89999999999999991, 0.40000000000000002, + { 1.0836647913872215, 0.90000000000000013, 0.40000000000000002, 0.87266462599716477 }, - { 1.0987419542323440, 0.89999999999999991, 0.40000000000000002, + { 1.4378726836091849, 0.90000000000000013, 0.40000000000000002, 1.0471975511965976 }, - { 1.3261349565496301, 0.89999999999999991, 0.40000000000000002, + { 1.8880446720682853, 0.90000000000000013, 0.40000000000000002, 1.2217304763960306 }, - { 1.5831293909853763, 0.89999999999999991, 0.40000000000000002, + { 2.4505848932025232, 0.90000000000000013, 0.40000000000000002, 1.3962634015954636 }, - { 1.8641114227238351, 0.89999999999999991, 0.40000000000000002, + { 3.1000689868578624, 0.90000000000000013, 0.40000000000000002, 1.5707963267948966 }, }; const double toler185 = 2.5000000000000020e-13; -// Test data for k=0.89999999999999991, nu=0.50000000000000000. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 4.9652155758573562e-16 +// Test data for k=0.90000000000000013, nu=0.50000000000000000. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.3939646155354115e-16 +// mean(f - f_Boost): 1.5820678100908481e-16 +// variance(f - f_Boost): 1.0089970755557622e-32 +// stddev(f - f_Boost): 1.0044884646205561e-16 const testcase_ellint_3<double> data186[10] = { - { 0.0000000000000000, 0.89999999999999991, 0.50000000000000000, + { 0.0000000000000000, 0.90000000000000013, 0.50000000000000000, 0.0000000000000000 }, - { 0.17437497557073334, 0.89999999999999991, 0.50000000000000000, + { 0.17614967734498183, 0.90000000000000013, 0.50000000000000000, 0.17453292519943295 }, - { 0.34804093691586013, 0.89999999999999991, 0.50000000000000000, + { 0.36231594750319435, 0.90000000000000013, 0.50000000000000000, 0.34906585039886590 }, - { 0.52137576320372891, 0.89999999999999991, 0.50000000000000000, + { 0.57016256984349567, 0.90000000000000013, 0.50000000000000000, 0.52359877559829882 }, - { 0.69655163996912262, 0.89999999999999991, 0.50000000000000000, + { 0.81494025918293422, 0.90000000000000013, 0.50000000000000000, 0.69813170079773179 }, - { 0.87783188683054236, 0.89999999999999991, 0.50000000000000000, + { 1.1178482279283477, 0.90000000000000013, 0.50000000000000000, 0.87266462599716477 }, - { 1.0716015959755185, 0.89999999999999991, 0.50000000000000000, + { 1.5081455873012106, 0.90000000000000013, 0.50000000000000000, 1.0471975511965976 }, - { 1.2857636916026749, 0.89999999999999991, 0.50000000000000000, + { 2.0213599730863998, 0.90000000000000013, 0.50000000000000000, 1.2217304763960306 }, - { 1.5264263913252358, 0.89999999999999991, 0.50000000000000000, + { 2.6822467012926832, 0.90000000000000013, 0.50000000000000000, 1.3962634015954636 }, - { 1.7888013241937863, 0.89999999999999991, 0.50000000000000000, + { 3.4591069002104686, 0.90000000000000013, 0.50000000000000000, 1.5707963267948966 }, }; const double toler186 = 2.5000000000000020e-13; -// Test data for k=0.89999999999999991, nu=0.59999999999999998. -// max(|f - f_GSL|): 6.6613381477509392e-16 -// max(|f - f_GSL| / |f_GSL|): 3.8702201113622378e-16 +// Test data for k=0.90000000000000013, nu=0.60000000000000009. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.4914274070443813e-16 +// mean(f - f_Boost): 3.4694469519536142e-16 +// variance(f - f_Boost): 2.5224926888894056e-31 +// stddev(f - f_Boost): 5.0224423231027804e-16 const testcase_ellint_3<double> data187[10] = { - { 0.0000000000000000, 0.89999999999999991, 0.59999999999999998, + { 0.0000000000000000, 0.90000000000000013, 0.60000000000000009, 0.0000000000000000 }, - { 0.17420100334657812, 0.89999999999999991, 0.59999999999999998, + { 0.17633073723493825, 0.90000000000000013, 0.60000000000000009, 0.17453292519943295 }, - { 0.34671975876122157, 0.89999999999999991, 0.59999999999999998, + { 0.36386108723492810, 0.90000000000000013, 0.60000000000000009, 0.34906585039886590 }, - { 0.51724631570707946, 0.89999999999999991, 0.59999999999999998, + { 0.57597424744716241, 0.90000000000000013, 0.60000000000000009, 0.52359877559829882 }, - { 0.68760879113743023, 0.89999999999999991, 0.59999999999999998, + { 0.83098051948501150, 0.90000000000000013, 0.60000000000000009, 0.69813170079773179 }, - { 0.86192157779698364, 0.89999999999999991, 0.59999999999999998, + { 1.1558706545698916, 0.90000000000000013, 0.60000000000000009, 0.87266462599716477 }, - { 1.0464279696166354, 0.89999999999999991, 0.59999999999999998, + { 1.5905576379415669, 0.90000000000000013, 0.60000000000000009, 1.0471975511965976 }, - { 1.2488156247094004, 0.89999999999999991, 0.59999999999999998, + { 2.1875186010215084, 0.90000000000000013, 0.60000000000000009, 1.2217304763960306 }, - { 1.4750988777188470, 0.89999999999999991, 0.59999999999999998, + { 2.9885767771316853, 0.90000000000000013, 0.60000000000000009, 1.3962634015954636 }, - { 1.7211781128919525, 0.89999999999999991, 0.59999999999999998, + { 3.9549939883570238, 0.90000000000000013, 0.60000000000000009, 1.5707963267948966 }, }; const double toler187 = 2.5000000000000020e-13; -// Test data for k=0.89999999999999991, nu=0.69999999999999996. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 4.3410843563834748e-16 +// Test data for k=0.90000000000000013, nu=0.70000000000000007. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.5442489886293633e-16 +// mean(f - f_Boost): 4.3576253716537392e-16 +// variance(f - f_Boost): 2.2187568928205130e-31 +// stddev(f - f_Boost): 4.7103682370070737e-16 const testcase_ellint_3<double> data188[10] = { - { 0.0000000000000000, 0.89999999999999991, 0.69999999999999996, + { 0.0000000000000000, 0.90000000000000013, 0.70000000000000007, 0.0000000000000000 }, - { 0.17402765093102207, 0.89999999999999991, 0.69999999999999996, + { 0.17651246700160939, 0.90000000000000013, 0.70000000000000007, 0.17453292519943295 }, - { 0.34541608382635131, 0.89999999999999991, 0.69999999999999996, + { 0.36542993547358982, 0.90000000000000013, 0.70000000000000007, 0.34906585039886590 }, - { 0.51322715827061682, 0.89999999999999991, 0.69999999999999996, + { 0.58199897877674867, 0.90000000000000013, 0.70000000000000007, 0.52359877559829882 }, - { 0.67903717872440272, 0.89999999999999991, 0.69999999999999996, + { 0.84815633587352857, 0.90000000000000013, 0.70000000000000007, 0.69813170079773179 }, - { 0.84690113601682671, 0.89999999999999991, 0.69999999999999996, + { 1.1985495623872375, 0.90000000000000013, 0.70000000000000007, 0.87266462599716477 }, - { 1.0229914311548418, 0.89999999999999991, 0.69999999999999996, + { 1.6892158134027691, 0.90000000000000013, 0.70000000000000007, 1.0471975511965976 }, - { 1.2148329639709381, 0.89999999999999991, 0.69999999999999996, + { 2.4029722191094236, 0.90000000000000013, 0.70000000000000007, 1.2217304763960306 }, - { 1.4283586501307799, 0.89999999999999991, 0.69999999999999996, + { 3.4201084941340061, 0.90000000000000013, 0.70000000000000007, 1.3962634015954636 }, - { 1.6600480747670940, 0.89999999999999991, 0.69999999999999996, + { 4.6985482312992444, 0.90000000000000013, 0.70000000000000007, 1.5707963267948966 }, }; const double toler188 = 2.5000000000000020e-13; -// Test data for k=0.89999999999999991, nu=0.80000000000000004. -// max(|f - f_GSL|): 4.4408920985006262e-16 -// max(|f - f_GSL| / |f_GSL|): 3.3100928058463168e-16 +// Test data for k=0.90000000000000013, nu=0.80000000000000004. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.9362432595976420e-16 +// mean(f - f_Boost): 3.0531133177191805e-16 +// variance(f - f_Boost): 1.1508025840536076e-32 +// stddev(f - f_Boost): 1.0727546709539920e-16 const testcase_ellint_3<double> data189[10] = { - { 0.0000000000000000, 0.89999999999999991, 0.80000000000000004, + { 0.0000000000000000, 0.90000000000000013, 0.80000000000000004, 0.0000000000000000 }, - { 0.17385491439925146, 0.89999999999999991, 0.80000000000000004, + { 0.17669487107954862, 0.90000000000000013, 0.80000000000000004, 0.17453292519943295 }, - { 0.34412950523113928, 0.89999999999999991, 0.80000000000000004, + { 0.36702314729628421, 0.90000000000000013, 0.80000000000000004, 0.34906585039886590 }, - { 0.50931321668729590, 0.89999999999999991, 0.80000000000000004, + { 0.58825099711365492, 0.90000000000000013, 0.80000000000000004, 0.52359877559829882 }, - { 0.67081081392296327, 0.89999999999999991, 0.80000000000000004, + { 0.86661711422209031, 0.90000000000000013, 0.80000000000000004, 0.69813170079773179 }, - { 0.83268846097293259, 0.89999999999999991, 0.80000000000000004, + { 1.2469779109884802, 0.90000000000000013, 0.80000000000000004, 0.87266462599716477 }, - { 1.0010985015814027, 0.89999999999999991, 0.80000000000000004, + { 1.8105469760531578, 0.90000000000000013, 0.80000000000000004, 1.0471975511965976 }, - { 1.1834394045489678, 0.89999999999999991, 0.80000000000000004, + { 2.6989505165893752, 0.90000000000000013, 0.80000000000000004, 1.2217304763960306 }, - { 1.3855695891683182, 0.89999999999999991, 0.80000000000000004, + { 4.0935213267757433, 0.90000000000000013, 0.80000000000000004, 1.3962634015954636 }, - { 1.6044591960982202, 0.89999999999999991, 0.80000000000000004, + { 5.9820740813645727, 0.90000000000000013, 0.80000000000000004, 1.5707963267948966 }, }; const double toler189 = 2.5000000000000020e-13; -// Test data for k=0.89999999999999991, nu=0.90000000000000002. -// max(|f - f_GSL|): 8.8817841970012523e-16 -// max(|f - f_GSL| / |f_GSL|): 5.7167507456081732e-16 +// Test data for k=0.90000000000000013, nu=0.90000000000000002. +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.9577148062669782e-16 +// mean(f - f_Boost): 5.9119376061289588e-16 +// variance(f - f_Boost): 1.7340883003959522e-31 +// stddev(f - f_Boost): 4.1642385863395872e-16 const testcase_ellint_3<double> data190[10] = { - { 0.0000000000000000, 0.89999999999999991, 0.90000000000000002, + { 0.0000000000000000, 0.90000000000000013, 0.90000000000000002, 0.0000000000000000 }, - { 0.17368278986240135, 0.89999999999999991, 0.90000000000000002, + { 0.17687795394604169, 0.90000000000000013, 0.90000000000000002, 0.17453292519943295 }, - { 0.34285962963961397, 0.89999999999999991, 0.90000000000000002, + { 0.36864140434751286, 0.90000000000000013, 0.90000000000000002, 0.34906585039886590 }, - { 0.50549974644993312, 0.89999999999999991, 0.90000000000000002, + { 0.59474595366817051, 0.90000000000000013, 0.90000000000000002, 0.52359877559829882 }, - { 0.66290623857720876, 0.89999999999999991, 0.90000000000000002, + { 0.88654237226056665, 0.90000000000000013, 0.90000000000000002, 0.69813170079773179 }, - { 0.81921183128847175, 0.89999999999999991, 0.90000000000000002, + { 1.3026595810616726, 0.90000000000000013, 0.90000000000000002, 0.87266462599716477 }, - { 0.98058481956066390, 0.89999999999999991, 0.90000000000000002, + { 1.9653635459278080, 0.90000000000000013, 0.90000000000000002, 1.0471975511965976 }, - { 1.1543223520473569, 0.89999999999999991, 0.90000000000000002, + { 3.1451407527189468, 0.90000000000000013, 0.90000000000000002, 1.2217304763960306 }, - { 1.3462119782292934, 0.89999999999999991, 0.90000000000000002, + { 5.3745230680316132, 0.90000000000000013, 0.90000000000000002, 1.3962634015954636 }, - { 1.5536420236310948, 0.89999999999999991, 0.90000000000000002, + { 8.9942562031858717, 0.90000000000000013, 0.90000000000000002, 1.5707963267948966 }, }; const double toler190 = 2.5000000000000020e-13; -template<typename Tp, unsigned int Num> +template<typename Ret, unsigned int Num> void - test(const testcase_ellint_3<Tp> (&data)[Num], Tp toler) + test(const testcase_ellint_3<Ret> (&data)[Num], Ret toler) { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); + bool test __attribute__((unused)) = true; + const Ret eps = std::numeric_limits<Ret>::epsilon(); + Ret max_abs_diff = -Ret(1); + Ret max_abs_frac = -Ret(1); unsigned int num_datum = Num; for (unsigned int i = 0; i < num_datum; ++i) { - const Tp f = std::ellint_3(data[i].k, data[i].nu, + const Ret f = std::ellint_3(data[i].k, data[i].nu, data[i].phi); - const Tp f0 = data[i].f0; - const Tp diff = f - f0; + const Ret f0 = data[i].f0; + const Ret diff = f - f0; if (std::abs(diff) > max_abs_diff) max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) + if (std::abs(f0) > Ret(10) * eps + && std::abs(f) > Ret(10) * eps) { - const Tp frac = diff / f0; + const Ret frac = diff / f0; if (std::abs(frac) > max_abs_frac) max_abs_frac = std::abs(frac); } diff --git a/libstdc++-v3/testsuite/special_functions/13_ellint_3/pr66689.cc b/libstdc++-v3/testsuite/special_functions/13_ellint_3/pr66689.cc new file mode 100644 index 00000000000..e261003592d --- /dev/null +++ b/libstdc++-v3/testsuite/special_functions/13_ellint_3/pr66689.cc @@ -0,0 +1,26 @@ +// { dg-do run { target c++11 } } +// { dg-require-c-std "" } +// { dg-options "-D__STDCPP_WANT_MATH_SPEC_FUNCS__" } +// { dg-add-options ieee } + +#include <cmath> +#include <testsuite_hooks.h> + +void +test01() +{ + const double pi = 3.141592654; + + double Pi1 = std::ellint_3(0.75, 0.0, pi / 2.0); + VERIFY(std::abs(Pi1 - 1.91099) < 0.00001); + + double Pi2 = std::ellint_3(0.75, 0.5, pi / 2.0); + VERIFY(std::abs(Pi2 - 2.80011) < 0.00001); +} + +int +main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/special_functions/14_expint/pr68397.cc b/libstdc++-v3/testsuite/special_functions/14_expint/pr68397.cc new file mode 100644 index 00000000000..8da16d1fc69 --- /dev/null +++ b/libstdc++-v3/testsuite/special_functions/14_expint/pr68397.cc @@ -0,0 +1,47 @@ +// { dg-do run { target c++11 } } +// { dg-options "-D__STDCPP_WANT_MATH_SPEC_FUNCS__" } +// Copyright (C) 2017 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// PR libstdc++/68397 - std::tr1::expint fails in __expint_En_cont_frac +// for some long double arguments due to low __max_iter value + +#include <cmath> +#include <testsuite_hooks.h> + +int +test01() +{ + // Answers from Wolfram Alpha. + long double ans_ok = -0.10001943365331651406888645149537315243646135979573L; + long double ans_bomb = -0.10777727809650077516264612749163100483995270163783L; + + auto Ei_ok = std::expint(-1.500001L); + auto diff_ok = Ei_ok - ans_ok; + VERIFY(std::abs(diff_ok) < 1.0e-15); + + auto Ei_bomb = std::expint(-1.450001L); + auto diff_bomb = Ei_bomb - ans_bomb; + VERIFY(std::abs(diff_bomb) < 1.0e-15); +} + +int +main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/06_comp_ellint_3/check_value.cc b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/06_comp_ellint_3/check_value.cc index 0c187d71188..ed11917401f 100644 --- a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/06_comp_ellint_3/check_value.cc +++ b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/06_comp_ellint_3/check_value.cc @@ -1,6 +1,7 @@ -// 2007-02-04 Edward Smith-Rowland <3dw4rd@verizon.net> +// { dg-do run { target c++11 } } +// { dg-options "-D__STDCPP_WANT_MATH_SPEC_FUNCS__" } // -// Copyright (C) 2007-2017 Free Software Foundation, Inc. +// Copyright (C) 2016-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -18,826 +19,490 @@ // <http://www.gnu.org/licenses/>. // comp_ellint_3 - - // Compare against values generated by the GNU Scientific Library. // The GSL can be found on the web: http://www.gnu.org/software/gsl/ - +#include <limits> #include <tr1/cmath> #if defined(__TEST_DEBUG) -#include <iostream> -#define VERIFY(A) \ -if (!(A)) \ - { \ - std::cout << "line " << __LINE__ \ - << " max_abs_frac = " << max_abs_frac \ - << std::endl; \ - } +# include <iostream> +# define VERIFY(A) \ + if (!(A)) \ + { \ + std::cout << "line " << __LINE__ \ + << " max_abs_frac = " << max_abs_frac \ + << std::endl; \ + } #else -#include <testsuite_hooks.h> +# include <testsuite_hooks.h> #endif -#include "../testcase.h" - +#include <specfun_testcase.h> // Test data for k=-0.90000000000000002. -testcase_comp_ellint_3<double> data001[] = { +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 5 +// max(|f - f_Boost| / |f_Boost|): 1.2838262090802751e-16 +// mean(f - f_Boost): 4.4408920985006264e-17 +// variance(f - f_Boost): 2.4347558803117648e-34 +// stddev(f - f_Boost): 1.5603704304785339e-17 +const testcase_comp_ellint_3<double> +data001[10] = +{ { 2.2805491384227703, -0.90000000000000002, 0.0000000000000000 }, - { 2.1537868513875287, -0.90000000000000002, 0.10000000000000001 }, - { 2.0443194576468890, -0.90000000000000002, 0.20000000000000001 }, - { 1.9486280260314426, -0.90000000000000002, 0.29999999999999999 }, - { 1.8641114227238349, -0.90000000000000002, 0.40000000000000002 }, - { 1.7888013241937861, -0.90000000000000002, 0.50000000000000000 }, - { 1.7211781128919523, -0.90000000000000002, 0.59999999999999998 }, - { 1.6600480747670938, -0.90000000000000002, 0.69999999999999996 }, - { 1.6044591960982204, -0.90000000000000002, 0.80000000000000004 }, - { 1.5536420236310946, -0.90000000000000002, 0.90000000000000002 }, + { 2.4295011187834885, -0.90000000000000002, 0.10000000000000001 }, + { 2.6076835743348412, -0.90000000000000002, 0.20000000000000001 }, + { 2.8256506968858512, -0.90000000000000002, 0.30000000000000004 }, + { 3.1000689868578619, -0.90000000000000002, 0.40000000000000002 }, + { 3.4591069002104677, -0.90000000000000002, 0.50000000000000000 }, + { 3.9549939883570229, -0.90000000000000002, 0.60000000000000009 }, + { 4.6985482312992435, -0.90000000000000002, 0.70000000000000007 }, + { 5.9820740813645710, -0.90000000000000002, 0.80000000000000004 }, + { 8.9942562031858699, -0.90000000000000002, 0.90000000000000002 }, }; - -// Test function for k=-0.90000000000000002. -template <typename Tp> -void test001() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data001) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data001[i].k), Tp(data001[i].nu)); - const Tp f0 = data001[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +const double toler001 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004. -testcase_comp_ellint_3<double> data002[] = { - { 1.9953027776647296, -0.80000000000000004, 0.0000000000000000 }, - { 1.8910755418379521, -0.80000000000000004, 0.10000000000000001 }, - { 1.8007226661734588, -0.80000000000000004, 0.20000000000000001 }, - { 1.7214611048717301, -0.80000000000000004, 0.29999999999999999 }, - { 1.6512267838651289, -0.80000000000000004, 0.40000000000000002 }, - { 1.5884528947755532, -0.80000000000000004, 0.50000000000000000 }, - { 1.5319262547427865, -0.80000000000000004, 0.59999999999999998 }, - { 1.4806912324625332, -0.80000000000000004, 0.69999999999999996 }, - { 1.4339837018309474, -0.80000000000000004, 0.80000000000000004 }, - { 1.3911845406776222, -0.80000000000000004, 0.90000000000000002 }, -}; - -// Test function for k=-0.80000000000000004. -template <typename Tp> -void test002() +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.1949393471095187e-16 +// mean(f - f_Boost): 9.5479180117763459e-16 +// variance(f - f_Boost): 5.4782007307014711e-34 +// stddev(f - f_Boost): 2.3405556457178006e-17 +const testcase_comp_ellint_3<double> +data002[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data002) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data002[i].k), Tp(data002[i].nu)); - const Tp f0 = data002[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.69999999999999996. -testcase_comp_ellint_3<double> data003[] = { - { 1.8456939983747236, -0.69999999999999996, 0.0000000000000000 }, - { 1.7528050171757608, -0.69999999999999996, 0.10000000000000001 }, - { 1.6721098780092147, -0.69999999999999996, 0.20000000000000001 }, - { 1.6011813647733213, -0.69999999999999996, 0.29999999999999999 }, - { 1.5382162002954762, -0.69999999999999996, 0.40000000000000002 }, - { 1.4818433192178544, -0.69999999999999996, 0.50000000000000000 }, - { 1.4309994736080540, -0.69999999999999996, 0.59999999999999998 }, - { 1.3848459188329196, -0.69999999999999996, 0.69999999999999996 }, - { 1.3427110650397533, -0.69999999999999996, 0.80000000000000004 }, - { 1.3040500499695911, -0.69999999999999996, 0.90000000000000002 }, + { 1.9953027776647294, -0.80000000000000004, 0.0000000000000000 }, + { 2.1172616484005085, -0.80000000000000004, 0.10000000000000001 }, + { 2.2624789434186798, -0.80000000000000004, 0.20000000000000001 }, + { 2.4392042002725698, -0.80000000000000004, 0.30000000000000004 }, + { 2.6604037035529728, -0.80000000000000004, 0.40000000000000002 }, + { 2.9478781158239751, -0.80000000000000004, 0.50000000000000000 }, + { 3.3418121892288055, -0.80000000000000004, 0.60000000000000009 }, + { 3.9268876980046397, -0.80000000000000004, 0.70000000000000007 }, + { 4.9246422058196071, -0.80000000000000004, 0.80000000000000004 }, + { 7.2263259298637132, -0.80000000000000004, 0.90000000000000002 }, }; +const double toler002 = 2.5000000000000020e-13; -// Test function for k=-0.69999999999999996. -template <typename Tp> -void test003() +// Test data for k=-0.69999999999999996. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 3 +// max(|f - f_Boost| / |f_Boost|): 1.9832236886714888e-16 +// mean(f - f_Boost): -1.5543122344752191e-16 +// variance(f - f_Boost): 2.9825759533819119e-33 +// stddev(f - f_Boost): 5.4612965066748680e-17 +const testcase_comp_ellint_3<double> +data003[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data003) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data003[i].k), Tp(data003[i].nu)); - const Tp f0 = data003[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} + { 1.8456939983747234, -0.69999999999999996, 0.0000000000000000 }, + { 1.9541347343119564, -0.69999999999999996, 0.10000000000000001 }, + { 2.0829290325820202, -0.69999999999999996, 0.20000000000000001 }, + { 2.2392290510988535, -0.69999999999999996, 0.30000000000000004 }, + { 2.4342502915307880, -0.69999999999999996, 0.40000000000000002 }, + { 2.6868019968236996, -0.69999999999999996, 0.50000000000000000 }, + { 3.0314573496746742, -0.69999999999999996, 0.60000000000000009 }, + { 3.5408408771788564, -0.69999999999999996, 0.70000000000000007 }, + { 4.4042405729076961, -0.69999999999999996, 0.80000000000000004 }, + { 6.3796094177887754, -0.69999999999999996, 0.90000000000000002 }, +}; +const double toler003 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998. -testcase_comp_ellint_3<double> data004[] = { +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 2 +// max(|f - f_Boost| / |f_Boost|): 2.2547200163366559e-16 +// mean(f - f_Boost): -1.9984014443252818e-16 +// variance(f - f_Boost): 4.9303806576313241e-33 +// stddev(f - f_Boost): 7.0216669371534022e-17 +const testcase_comp_ellint_3<double> +data004[10] = +{ { 1.7507538029157526, -0.59999999999999998, 0.0000000000000000 }, - { 1.6648615773343014, -0.59999999999999998, 0.10000000000000001 }, - { 1.5901418016279374, -0.59999999999999998, 0.20000000000000001 }, - { 1.5243814243493585, -0.59999999999999998, 0.29999999999999999 }, - { 1.4659345278069984, -0.59999999999999998, 0.40000000000000002 }, - { 1.4135484285693078, -0.59999999999999998, 0.50000000000000000 }, - { 1.3662507535812816, -0.59999999999999998, 0.59999999999999998 }, - { 1.3232737468822811, -0.59999999999999998, 0.69999999999999996 }, - { 1.2840021261752192, -0.59999999999999998, 0.80000000000000004 }, - { 1.2479362973851875, -0.59999999999999998, 0.90000000000000002 }, + { 1.8508766487100685, -0.59999999999999998, 0.10000000000000001 }, + { 1.9695980282802217, -0.59999999999999998, 0.20000000000000001 }, + { 2.1134154405060599, -0.59999999999999998, 0.30000000000000004 }, + { 2.2925036420985130, -0.59999999999999998, 0.40000000000000002 }, + { 2.5239007084492711, -0.59999999999999998, 0.50000000000000000 }, + { 2.8388723099514972, -0.59999999999999998, 0.60000000000000009 }, + { 3.3029735898397159, -0.59999999999999998, 0.70000000000000007 }, + { 4.0867036409261832, -0.59999999999999998, 0.80000000000000004 }, + { 5.8709993116265604, -0.59999999999999998, 0.90000000000000002 }, }; - -// Test function for k=-0.59999999999999998. -template <typename Tp> -void test004() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data004) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data004[i].k), Tp(data004[i].nu)); - const Tp f0 = data004[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +const double toler004 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000. -testcase_comp_ellint_3<double> data005[] = { - { 1.6857503548125963, -0.50000000000000000, 0.0000000000000000 }, - { 1.6045524936084892, -0.50000000000000000, 0.10000000000000001 }, - { 1.5338490483665983, -0.50000000000000000, 0.20000000000000001 }, - { 1.4715681939859637, -0.50000000000000000, 0.29999999999999999 }, - { 1.4161679518465340, -0.50000000000000000, 0.40000000000000002 }, - { 1.3664739530045971, -0.50000000000000000, 0.50000000000000000 }, - { 1.3215740290190876, -0.50000000000000000, 0.59999999999999998 }, - { 1.2807475181182502, -0.50000000000000000, 0.69999999999999996 }, - { 1.2434165408189539, -0.50000000000000000, 0.80000000000000004 }, - { 1.2091116095504744, -0.50000000000000000, 0.90000000000000002 }, -}; - -// Test function for k=-0.50000000000000000. -template <typename Tp> -void test005() +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 3 +// max(|f - f_Boost| / |f_Boost|): 2.1900131385114407e-16 +// mean(f - f_Boost): 2.4424906541753446e-16 +// variance(f - f_Boost): 7.3651365379430888e-33 +// stddev(f - f_Boost): 8.5820373676319358e-17 +const testcase_comp_ellint_3<double> +data005[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data005) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data005[i].k), Tp(data005[i].nu)); - const Tp f0 = data005[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.40000000000000002. -testcase_comp_ellint_3<double> data006[] = { - { 1.6399998658645112, -0.40000000000000002, 0.0000000000000000 }, - { 1.5620566886683604, -0.40000000000000002, 0.10000000000000001 }, - { 1.4941414344266770, -0.40000000000000002, 0.20000000000000001 }, - { 1.4342789859950078, -0.40000000000000002, 0.29999999999999999 }, - { 1.3809986210732901, -0.40000000000000002, 0.40000000000000002 }, - { 1.3331797176377398, -0.40000000000000002, 0.50000000000000000 }, - { 1.2899514672527024, -0.40000000000000002, 0.59999999999999998 }, - { 1.2506255923253344, -0.40000000000000002, 0.69999999999999996 }, - { 1.2146499565727209, -0.40000000000000002, 0.80000000000000004 }, - { 1.1815758115929846, -0.40000000000000002, 0.90000000000000002 }, + { 1.6857503548125961, -0.50000000000000000, 0.0000000000000000 }, + { 1.7803034946545482, -0.50000000000000000, 0.10000000000000001 }, + { 1.8922947612264021, -0.50000000000000000, 0.20000000000000001 }, + { 2.0277924458111314, -0.50000000000000000, 0.30000000000000004 }, + { 2.1962905366178065, -0.50000000000000000, 0.40000000000000002 }, + { 2.4136715042011945, -0.50000000000000000, 0.50000000000000000 }, + { 2.7090491861753558, -0.50000000000000000, 0.60000000000000009 }, + { 3.1433945297859229, -0.50000000000000000, 0.70000000000000007 }, + { 3.8750701888108070, -0.50000000000000000, 0.80000000000000004 }, + { 5.5355132096026463, -0.50000000000000000, 0.90000000000000002 }, }; - -// Test function for k=-0.40000000000000002. -template <typename Tp> -void test006() +const double toler005 = 2.5000000000000020e-13; + +// Test data for k=-0.39999999999999991. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.1718164615986397e-16 +// mean(f - f_Boost): 6.2172489379008762e-16 +// variance(f - f_Boost): 1.6458949750907531e-31 +// stddev(f - f_Boost): 4.0569631192441877e-16 +const testcase_comp_ellint_3<double> +data006[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data006) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data006[i].k), Tp(data006[i].nu)); - const Tp f0 = data006[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.30000000000000004. -testcase_comp_ellint_3<double> data007[] = { - { 1.6080486199305126, -0.30000000000000004, 0.0000000000000000 }, - { 1.5323534693557526, -0.30000000000000004, 0.10000000000000001 }, - { 1.4663658145259875, -0.30000000000000004, 0.20000000000000001 }, - { 1.4081767433479089, -0.30000000000000004, 0.29999999999999999 }, - { 1.3563643538969761, -0.30000000000000004, 0.40000000000000002 }, - { 1.3098448759814960, -0.30000000000000004, 0.50000000000000000 }, - { 1.2677758800420666, -0.30000000000000004, 0.59999999999999998 }, - { 1.2294913236274980, -0.30000000000000004, 0.69999999999999996 }, - { 1.1944567571590046, -0.30000000000000004, 0.80000000000000004 }, - { 1.1622376896064912, -0.30000000000000004, 0.90000000000000002 }, + { 1.6399998658645112, -0.39999999999999991, 0.0000000000000000 }, + { 1.7306968836847190, -0.39999999999999991, 0.10000000000000001 }, + { 1.8380358826317627, -0.39999999999999991, 0.20000000000000001 }, + { 1.9677924132520139, -0.39999999999999991, 0.30000000000000004 }, + { 2.1289968719280026, -0.39999999999999991, 0.40000000000000002 }, + { 2.3367461373176512, -0.39999999999999991, 0.50000000000000000 }, + { 2.6186940209850191, -0.39999999999999991, 0.60000000000000009 }, + { 3.0327078743873246, -0.39999999999999991, 0.70000000000000007 }, + { 3.7289548002199902, -0.39999999999999991, 0.80000000000000004 }, + { 5.3055535102872513, -0.39999999999999991, 0.90000000000000002 }, }; - -// Test function for k=-0.30000000000000004. -template <typename Tp> -void test007() +const double toler006 = 2.5000000000000020e-13; + +// Test data for k=-0.29999999999999993. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.9274792319434433e-16 +// mean(f - f_Boost): 6.2172489379008762e-16 +// variance(f - f_Boost): 8.7651211691223537e-33 +// stddev(f - f_Boost): 9.3622225828712025e-17 +const testcase_comp_ellint_3<double> +data007[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data007) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data007[i].k), Tp(data007[i].nu)); - const Tp f0 = data007[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.19999999999999996. -testcase_comp_ellint_3<double> data008[] = { - { 1.5868678474541664, -0.19999999999999996, 0.0000000000000000 }, - { 1.5126513474261092, -0.19999999999999996, 0.10000000000000001 }, - { 1.4479323932249568, -0.19999999999999996, 0.20000000000000001 }, - { 1.3908453514752481, -0.19999999999999996, 0.29999999999999999 }, - { 1.3400002519661010, -0.19999999999999996, 0.40000000000000002 }, - { 1.2943374404397376, -0.19999999999999996, 0.50000000000000000 }, - { 1.2530330675914561, -0.19999999999999996, 0.59999999999999998 }, - { 1.2154356555075867, -0.19999999999999996, 0.69999999999999996 }, - { 1.1810223448909913, -0.19999999999999996, 0.80000000000000004 }, - { 1.1493679916141863, -0.19999999999999996, 0.90000000000000002 }, + { 1.6080486199305128, -0.29999999999999993, 0.0000000000000000 }, + { 1.6960848815118226, -0.29999999999999993, 0.10000000000000001 }, + { 1.8002173372290500, -0.29999999999999993, 0.20000000000000001 }, + { 1.9260216862473254, -0.29999999999999993, 0.30000000000000004 }, + { 2.0822121773175533, -0.29999999999999993, 0.40000000000000002 }, + { 2.2833505881933971, -0.29999999999999993, 0.50000000000000000 }, + { 2.5560975528589065, -0.29999999999999993, 0.60000000000000009 }, + { 2.9562123549913877, -0.29999999999999993, 0.70000000000000007 }, + { 3.6283050484567170, -0.29999999999999993, 0.80000000000000004 }, + { 5.1479514944016795, -0.29999999999999993, 0.90000000000000002 }, }; +const double toler007 = 2.5000000000000020e-13; -// Test function for k=-0.19999999999999996. -template <typename Tp> -void test008() +// Test data for k=-0.19999999999999996. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.9753938705764407e-16 +// mean(f - f_Boost): 3.1086244689504381e-16 +// variance(f - f_Boost): 4.1147374377268827e-32 +// stddev(f - f_Boost): 2.0284815596220939e-16 +const testcase_comp_ellint_3<double> +data008[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data008) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data008[i].k), Tp(data008[i].nu)); - const Tp f0 = data008[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.099999999999999978. -testcase_comp_ellint_3<double> data009[] = { - { 1.5747455615173562, -0.099999999999999978, 0.0000000000000000 }, - { 1.5013711111199950, -0.099999999999999978, 0.10000000000000001 }, - { 1.4373749386463430, -0.099999999999999978, 0.20000000000000001 }, - { 1.3809159606704959, -0.099999999999999978, 0.29999999999999999 }, - { 1.3306223265207477, -0.099999999999999978, 0.40000000000000002 }, - { 1.2854480708580160, -0.099999999999999978, 0.50000000000000000 }, - { 1.2445798942989255, -0.099999999999999978, 0.59999999999999998 }, - { 1.2073745911083187, -0.099999999999999978, 0.69999999999999996 }, - { 1.1733158866987732, -0.099999999999999978, 0.80000000000000004 }, - { 1.1419839485283374, -0.099999999999999978, 0.90000000000000002 }, + { 1.5868678474541662, -0.19999999999999996, 0.0000000000000000 }, + { 1.6731552050562593, -0.19999999999999996, 0.10000000000000001 }, + { 1.7751816279738935, -0.19999999999999996, 0.20000000000000001 }, + { 1.8983924169967101, -0.19999999999999996, 0.30000000000000004 }, + { 2.0512956926676806, -0.19999999999999996, 0.40000000000000002 }, + { 2.2481046259421302, -0.19999999999999996, 0.50000000000000000 }, + { 2.5148333891629315, -0.19999999999999996, 0.60000000000000009 }, + { 2.9058704854500967, -0.19999999999999996, 0.70000000000000007 }, + { 3.5622166386422633, -0.19999999999999996, 0.80000000000000004 }, + { 5.0448269356200370, -0.19999999999999996, 0.90000000000000002 }, }; +const double toler008 = 2.5000000000000020e-13; -// Test function for k=-0.099999999999999978. -template <typename Tp> -void test009() +// Test data for k=-0.099999999999999978. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 5 +// max(|f - f_Boost| / |f_Boost|): 1.9932308021417639e-16 +// mean(f - f_Boost): 0.0000000000000000 +// variance(f - f_Boost): 6.8368087769470551e-64 +// stddev(f - f_Boost): 2.6147291976315738e-32 +const testcase_comp_ellint_3<double> +data009[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data009) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data009[i].k), Tp(data009[i].nu)); - const Tp f0 = data009[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} + { 1.5747455615173560, -0.099999999999999978, 0.0000000000000000 }, + { 1.6600374067558428, -0.099999999999999978, 0.10000000000000001 }, + { 1.7608656115083421, -0.099999999999999978, 0.20000000000000001 }, + { 1.8826015946315438, -0.099999999999999978, 0.30000000000000004 }, + { 2.0336367403076760, -0.099999999999999978, 0.40000000000000002 }, + { 2.2279868912966849, -0.099999999999999978, 0.50000000000000000 }, + { 2.4913004919173827, -0.099999999999999978, 0.60000000000000009 }, + { 2.8771910188009744, -0.099999999999999978, 0.70000000000000007 }, + { 3.5246199613295617, -0.099999999999999978, 0.80000000000000004 }, + { 4.9862890417305508, -0.099999999999999978, 0.90000000000000002 }, +}; +const double toler009 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000. -testcase_comp_ellint_3<double> data010[] = { +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 2.1899085000907084e-16 +// mean(f - f_Boost): -2.2204460492503131e-16 +// variance(f - f_Boost): 5.4782007307014711e-32 +// stddev(f - f_Boost): 2.3405556457178008e-16 +const testcase_comp_ellint_3<double> +data010[10] = +{ { 1.5707963267948966, 0.0000000000000000, 0.0000000000000000 }, - { 1.4976955329233277, 0.0000000000000000, 0.10000000000000001 }, - { 1.4339343023863691, 0.0000000000000000, 0.20000000000000001 }, - { 1.3776795151134889, 0.0000000000000000, 0.29999999999999999 }, - { 1.3275651989026322, 0.0000000000000000, 0.40000000000000002 }, - { 1.2825498301618641, 0.0000000000000000, 0.50000000000000000 }, - { 1.2418235332245127, 0.0000000000000000, 0.59999999999999998 }, - { 1.2047457872617382, 0.0000000000000000, 0.69999999999999996 }, - { 1.1708024551734544, 0.0000000000000000, 0.80000000000000004 }, - { 1.1395754288497419, 0.0000000000000000, 0.90000000000000002 }, + { 1.6557647109660170, 0.0000000000000000, 0.10000000000000001 }, + { 1.7562036827601817, 0.0000000000000000, 0.20000000000000001 }, + { 1.8774607092226381, 0.0000000000000000, 0.30000000000000004 }, + { 2.0278893379868062, 0.0000000000000000, 0.40000000000000002 }, + { 2.2214414690791831, 0.0000000000000000, 0.50000000000000000 }, + { 2.4836470664490258, 0.0000000000000000, 0.60000000000000009 }, + { 2.8678686047727386, 0.0000000000000000, 0.70000000000000007 }, + { 3.5124073655203634, 0.0000000000000000, 0.80000000000000004 }, + { 4.9672941328980516, 0.0000000000000000, 0.90000000000000002 }, }; - -// Test function for k=0.0000000000000000. -template <typename Tp> -void test010() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data010) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data010[i].k), Tp(data010[i].nu)); - const Tp f0 = data010[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +const double toler010 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009. -testcase_comp_ellint_3<double> data011[] = { - { 1.5747455615173562, 0.10000000000000009, 0.0000000000000000 }, - { 1.5013711111199950, 0.10000000000000009, 0.10000000000000001 }, - { 1.4373749386463430, 0.10000000000000009, 0.20000000000000001 }, - { 1.3809159606704959, 0.10000000000000009, 0.29999999999999999 }, - { 1.3306223265207477, 0.10000000000000009, 0.40000000000000002 }, - { 1.2854480708580160, 0.10000000000000009, 0.50000000000000000 }, - { 1.2445798942989255, 0.10000000000000009, 0.59999999999999998 }, - { 1.2073745911083187, 0.10000000000000009, 0.69999999999999996 }, - { 1.1733158866987732, 0.10000000000000009, 0.80000000000000004 }, - { 1.1419839485283374, 0.10000000000000009, 0.90000000000000002 }, -}; - -// Test function for k=0.10000000000000009. -template <typename Tp> -void test011() +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 5 +// max(|f - f_Boost| / |f_Boost|): 1.9932308021417639e-16 +// mean(f - f_Boost): -2.2204460492503132e-17 +// variance(f - f_Boost): 6.0868897007794120e-35 +// stddev(f - f_Boost): 7.8018521523926693e-18 +const testcase_comp_ellint_3<double> +data011[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data011) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data011[i].k), Tp(data011[i].nu)); - const Tp f0 = data011[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.19999999999999996. -testcase_comp_ellint_3<double> data012[] = { - { 1.5868678474541664, 0.19999999999999996, 0.0000000000000000 }, - { 1.5126513474261092, 0.19999999999999996, 0.10000000000000001 }, - { 1.4479323932249568, 0.19999999999999996, 0.20000000000000001 }, - { 1.3908453514752481, 0.19999999999999996, 0.29999999999999999 }, - { 1.3400002519661010, 0.19999999999999996, 0.40000000000000002 }, - { 1.2943374404397376, 0.19999999999999996, 0.50000000000000000 }, - { 1.2530330675914561, 0.19999999999999996, 0.59999999999999998 }, - { 1.2154356555075867, 0.19999999999999996, 0.69999999999999996 }, - { 1.1810223448909913, 0.19999999999999996, 0.80000000000000004 }, - { 1.1493679916141863, 0.19999999999999996, 0.90000000000000002 }, + { 1.5747455615173560, 0.10000000000000009, 0.0000000000000000 }, + { 1.6600374067558428, 0.10000000000000009, 0.10000000000000001 }, + { 1.7608656115083421, 0.10000000000000009, 0.20000000000000001 }, + { 1.8826015946315440, 0.10000000000000009, 0.30000000000000004 }, + { 2.0336367403076760, 0.10000000000000009, 0.40000000000000002 }, + { 2.2279868912966849, 0.10000000000000009, 0.50000000000000000 }, + { 2.4913004919173827, 0.10000000000000009, 0.60000000000000009 }, + { 2.8771910188009744, 0.10000000000000009, 0.70000000000000007 }, + { 3.5246199613295617, 0.10000000000000009, 0.80000000000000004 }, + { 4.9862890417305508, 0.10000000000000009, 0.90000000000000002 }, }; - -// Test function for k=0.19999999999999996. -template <typename Tp> -void test012() +const double toler011 = 2.5000000000000020e-13; + +// Test data for k=0.20000000000000018. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.9753938705764407e-16 +// mean(f - f_Boost): 3.1086244689504381e-16 +// variance(f - f_Boost): 4.1147374377268827e-32 +// stddev(f - f_Boost): 2.0284815596220939e-16 +const testcase_comp_ellint_3<double> +data012[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data012) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data012[i].k), Tp(data012[i].nu)); - const Tp f0 = data012[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.30000000000000004. -testcase_comp_ellint_3<double> data013[] = { - { 1.6080486199305126, 0.30000000000000004, 0.0000000000000000 }, - { 1.5323534693557526, 0.30000000000000004, 0.10000000000000001 }, - { 1.4663658145259875, 0.30000000000000004, 0.20000000000000001 }, - { 1.4081767433479089, 0.30000000000000004, 0.29999999999999999 }, - { 1.3563643538969761, 0.30000000000000004, 0.40000000000000002 }, - { 1.3098448759814960, 0.30000000000000004, 0.50000000000000000 }, - { 1.2677758800420666, 0.30000000000000004, 0.59999999999999998 }, - { 1.2294913236274980, 0.30000000000000004, 0.69999999999999996 }, - { 1.1944567571590046, 0.30000000000000004, 0.80000000000000004 }, - { 1.1622376896064912, 0.30000000000000004, 0.90000000000000002 }, + { 1.5868678474541662, 0.20000000000000018, 0.0000000000000000 }, + { 1.6731552050562593, 0.20000000000000018, 0.10000000000000001 }, + { 1.7751816279738935, 0.20000000000000018, 0.20000000000000001 }, + { 1.8983924169967101, 0.20000000000000018, 0.30000000000000004 }, + { 2.0512956926676806, 0.20000000000000018, 0.40000000000000002 }, + { 2.2481046259421302, 0.20000000000000018, 0.50000000000000000 }, + { 2.5148333891629315, 0.20000000000000018, 0.60000000000000009 }, + { 2.9058704854500967, 0.20000000000000018, 0.70000000000000007 }, + { 3.5622166386422633, 0.20000000000000018, 0.80000000000000004 }, + { 5.0448269356200370, 0.20000000000000018, 0.90000000000000002 }, }; +const double toler012 = 2.5000000000000020e-13; -// Test function for k=0.30000000000000004. -template <typename Tp> -void test013() +// Test data for k=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.4585997630846713e-16 +// mean(f - f_Boost): 5.1070259132757197e-16 +// variance(f - f_Boost): 1.7591111235252501e-32 +// stddev(f - f_Boost): 1.3263148659067538e-16 +const testcase_comp_ellint_3<double> +data013[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data013) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data013[i].k), Tp(data013[i].nu)); - const Tp f0 = data013[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.39999999999999991. -testcase_comp_ellint_3<double> data014[] = { - { 1.6399998658645112, 0.39999999999999991, 0.0000000000000000 }, - { 1.5620566886683604, 0.39999999999999991, 0.10000000000000001 }, - { 1.4941414344266770, 0.39999999999999991, 0.20000000000000001 }, - { 1.4342789859950078, 0.39999999999999991, 0.29999999999999999 }, - { 1.3809986210732901, 0.39999999999999991, 0.40000000000000002 }, - { 1.3331797176377398, 0.39999999999999991, 0.50000000000000000 }, - { 1.2899514672527024, 0.39999999999999991, 0.59999999999999998 }, - { 1.2506255923253344, 0.39999999999999991, 0.69999999999999996 }, - { 1.2146499565727209, 0.39999999999999991, 0.80000000000000004 }, - { 1.1815758115929846, 0.39999999999999991, 0.90000000000000002 }, + { 1.6080486199305128, 0.30000000000000004, 0.0000000000000000 }, + { 1.6960848815118228, 0.30000000000000004, 0.10000000000000001 }, + { 1.8002173372290500, 0.30000000000000004, 0.20000000000000001 }, + { 1.9260216862473254, 0.30000000000000004, 0.30000000000000004 }, + { 2.0822121773175533, 0.30000000000000004, 0.40000000000000002 }, + { 2.2833505881933975, 0.30000000000000004, 0.50000000000000000 }, + { 2.5560975528589065, 0.30000000000000004, 0.60000000000000009 }, + { 2.9562123549913877, 0.30000000000000004, 0.70000000000000007 }, + { 3.6283050484567174, 0.30000000000000004, 0.80000000000000004 }, + { 5.1479514944016795, 0.30000000000000004, 0.90000000000000002 }, }; - -// Test function for k=0.39999999999999991. -template <typename Tp> -void test014() +const double toler013 = 2.5000000000000020e-13; + +// Test data for k=0.40000000000000013. +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.7696531428672557e-16 +// mean(f - f_Boost): 1.1990408665951691e-15 +// variance(f - f_Boost): 2.6514491536595121e-31 +// stddev(f - f_Boost): 5.1492224205791612e-16 +const testcase_comp_ellint_3<double> +data014[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data014) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data014[i].k), Tp(data014[i].nu)); - const Tp f0 = data014[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.50000000000000000. -testcase_comp_ellint_3<double> data015[] = { - { 1.6857503548125963, 0.50000000000000000, 0.0000000000000000 }, - { 1.6045524936084892, 0.50000000000000000, 0.10000000000000001 }, - { 1.5338490483665983, 0.50000000000000000, 0.20000000000000001 }, - { 1.4715681939859637, 0.50000000000000000, 0.29999999999999999 }, - { 1.4161679518465340, 0.50000000000000000, 0.40000000000000002 }, - { 1.3664739530045971, 0.50000000000000000, 0.50000000000000000 }, - { 1.3215740290190876, 0.50000000000000000, 0.59999999999999998 }, - { 1.2807475181182502, 0.50000000000000000, 0.69999999999999996 }, - { 1.2434165408189539, 0.50000000000000000, 0.80000000000000004 }, - { 1.2091116095504744, 0.50000000000000000, 0.90000000000000002 }, + { 1.6399998658645112, 0.40000000000000013, 0.0000000000000000 }, + { 1.7306968836847190, 0.40000000000000013, 0.10000000000000001 }, + { 1.8380358826317629, 0.40000000000000013, 0.20000000000000001 }, + { 1.9677924132520141, 0.40000000000000013, 0.30000000000000004 }, + { 2.1289968719280030, 0.40000000000000013, 0.40000000000000002 }, + { 2.3367461373176512, 0.40000000000000013, 0.50000000000000000 }, + { 2.6186940209850196, 0.40000000000000013, 0.60000000000000009 }, + { 3.0327078743873246, 0.40000000000000013, 0.70000000000000007 }, + { 3.7289548002199906, 0.40000000000000013, 0.80000000000000004 }, + { 5.3055535102872522, 0.40000000000000013, 0.90000000000000002 }, }; +const double toler014 = 2.5000000000000020e-13; -// Test function for k=0.50000000000000000. -template <typename Tp> -void test015() +// Test data for k=0.50000000000000000. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 3 +// max(|f - f_Boost| / |f_Boost|): 2.1900131385114407e-16 +// mean(f - f_Boost): 2.4424906541753446e-16 +// variance(f - f_Boost): 7.3651365379430888e-33 +// stddev(f - f_Boost): 8.5820373676319358e-17 +const testcase_comp_ellint_3<double> +data015[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data015) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data015[i].k), Tp(data015[i].nu)); - const Tp f0 = data015[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} + { 1.6857503548125961, 0.50000000000000000, 0.0000000000000000 }, + { 1.7803034946545482, 0.50000000000000000, 0.10000000000000001 }, + { 1.8922947612264021, 0.50000000000000000, 0.20000000000000001 }, + { 2.0277924458111314, 0.50000000000000000, 0.30000000000000004 }, + { 2.1962905366178065, 0.50000000000000000, 0.40000000000000002 }, + { 2.4136715042011945, 0.50000000000000000, 0.50000000000000000 }, + { 2.7090491861753558, 0.50000000000000000, 0.60000000000000009 }, + { 3.1433945297859229, 0.50000000000000000, 0.70000000000000007 }, + { 3.8750701888108070, 0.50000000000000000, 0.80000000000000004 }, + { 5.5355132096026463, 0.50000000000000000, 0.90000000000000002 }, +}; +const double toler015 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009. -testcase_comp_ellint_3<double> data016[] = { +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 2 +// max(|f - f_Boost| / |f_Boost|): 2.2547200163366559e-16 +// mean(f - f_Boost): -2.2204460492503131e-16 +// variance(f - f_Boost): 6.0868897007794117e-33 +// stddev(f - f_Boost): 7.8018521523926690e-17 +const testcase_comp_ellint_3<double> +data016[10] = +{ { 1.7507538029157526, 0.60000000000000009, 0.0000000000000000 }, - { 1.6648615773343014, 0.60000000000000009, 0.10000000000000001 }, - { 1.5901418016279374, 0.60000000000000009, 0.20000000000000001 }, - { 1.5243814243493585, 0.60000000000000009, 0.29999999999999999 }, - { 1.4659345278069984, 0.60000000000000009, 0.40000000000000002 }, - { 1.4135484285693078, 0.60000000000000009, 0.50000000000000000 }, - { 1.3662507535812816, 0.60000000000000009, 0.59999999999999998 }, - { 1.3232737468822811, 0.60000000000000009, 0.69999999999999996 }, - { 1.2840021261752192, 0.60000000000000009, 0.80000000000000004 }, - { 1.2479362973851875, 0.60000000000000009, 0.90000000000000002 }, + { 1.8508766487100687, 0.60000000000000009, 0.10000000000000001 }, + { 1.9695980282802217, 0.60000000000000009, 0.20000000000000001 }, + { 2.1134154405060599, 0.60000000000000009, 0.30000000000000004 }, + { 2.2925036420985130, 0.60000000000000009, 0.40000000000000002 }, + { 2.5239007084492711, 0.60000000000000009, 0.50000000000000000 }, + { 2.8388723099514976, 0.60000000000000009, 0.60000000000000009 }, + { 3.3029735898397159, 0.60000000000000009, 0.70000000000000007 }, + { 4.0867036409261832, 0.60000000000000009, 0.80000000000000004 }, + { 5.8709993116265613, 0.60000000000000009, 0.90000000000000002 }, }; - -// Test function for k=0.60000000000000009. -template <typename Tp> -void test016() +const double toler016 = 2.5000000000000020e-13; + +// Test data for k=0.70000000000000018. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 2.9298727220933567e-16 +// mean(f - f_Boost): 4.8849813083506892e-16 +// variance(f - f_Boost): 2.0476296953421943e-31 +// stddev(f - f_Boost): 4.5250742483877478e-16 +const testcase_comp_ellint_3<double> +data017[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data016) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data016[i].k), Tp(data016[i].nu)); - const Tp f0 = data016[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.69999999999999996. -testcase_comp_ellint_3<double> data017[] = { - { 1.8456939983747236, 0.69999999999999996, 0.0000000000000000 }, - { 1.7528050171757608, 0.69999999999999996, 0.10000000000000001 }, - { 1.6721098780092147, 0.69999999999999996, 0.20000000000000001 }, - { 1.6011813647733213, 0.69999999999999996, 0.29999999999999999 }, - { 1.5382162002954762, 0.69999999999999996, 0.40000000000000002 }, - { 1.4818433192178544, 0.69999999999999996, 0.50000000000000000 }, - { 1.4309994736080540, 0.69999999999999996, 0.59999999999999998 }, - { 1.3848459188329196, 0.69999999999999996, 0.69999999999999996 }, - { 1.3427110650397533, 0.69999999999999996, 0.80000000000000004 }, - { 1.3040500499695911, 0.69999999999999996, 0.90000000000000002 }, + { 1.8456939983747238, 0.70000000000000018, 0.0000000000000000 }, + { 1.9541347343119566, 0.70000000000000018, 0.10000000000000001 }, + { 2.0829290325820207, 0.70000000000000018, 0.20000000000000001 }, + { 2.2392290510988540, 0.70000000000000018, 0.30000000000000004 }, + { 2.4342502915307880, 0.70000000000000018, 0.40000000000000002 }, + { 2.6868019968237000, 0.70000000000000018, 0.50000000000000000 }, + { 3.0314573496746746, 0.70000000000000018, 0.60000000000000009 }, + { 3.5408408771788569, 0.70000000000000018, 0.70000000000000007 }, + { 4.4042405729076970, 0.70000000000000018, 0.80000000000000004 }, + { 6.3796094177887763, 0.70000000000000018, 0.90000000000000002 }, }; - -// Test function for k=0.69999999999999996. -template <typename Tp> -void test017() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data017) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data017[i].k), Tp(data017[i].nu)); - const Tp f0 = data017[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +const double toler017 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004. -testcase_comp_ellint_3<double> data018[] = { - { 1.9953027776647296, 0.80000000000000004, 0.0000000000000000 }, - { 1.8910755418379521, 0.80000000000000004, 0.10000000000000001 }, - { 1.8007226661734588, 0.80000000000000004, 0.20000000000000001 }, - { 1.7214611048717301, 0.80000000000000004, 0.29999999999999999 }, - { 1.6512267838651289, 0.80000000000000004, 0.40000000000000002 }, - { 1.5884528947755532, 0.80000000000000004, 0.50000000000000000 }, - { 1.5319262547427865, 0.80000000000000004, 0.59999999999999998 }, - { 1.4806912324625332, 0.80000000000000004, 0.69999999999999996 }, - { 1.4339837018309474, 0.80000000000000004, 0.80000000000000004 }, - { 1.3911845406776222, 0.80000000000000004, 0.90000000000000002 }, -}; - -// Test function for k=0.80000000000000004. -template <typename Tp> -void test018() +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.1949393471095187e-16 +// mean(f - f_Boost): 9.5479180117763459e-16 +// variance(f - f_Boost): 5.4782007307014711e-34 +// stddev(f - f_Boost): 2.3405556457178006e-17 +const testcase_comp_ellint_3<double> +data018[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data018) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data018[i].k), Tp(data018[i].nu)); - const Tp f0 = data018[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.89999999999999991. -testcase_comp_ellint_3<double> data019[] = { - { 2.2805491384227699, 0.89999999999999991, 0.0000000000000000 }, - { 2.1537868513875282, 0.89999999999999991, 0.10000000000000001 }, - { 2.0443194576468890, 0.89999999999999991, 0.20000000000000001 }, - { 1.9486280260314424, 0.89999999999999991, 0.29999999999999999 }, - { 1.8641114227238347, 0.89999999999999991, 0.40000000000000002 }, - { 1.7888013241937859, 0.89999999999999991, 0.50000000000000000 }, - { 1.7211781128919521, 0.89999999999999991, 0.59999999999999998 }, - { 1.6600480747670936, 0.89999999999999991, 0.69999999999999996 }, - { 1.6044591960982200, 0.89999999999999991, 0.80000000000000004 }, - { 1.5536420236310944, 0.89999999999999991, 0.90000000000000002 }, + { 1.9953027776647294, 0.80000000000000004, 0.0000000000000000 }, + { 2.1172616484005085, 0.80000000000000004, 0.10000000000000001 }, + { 2.2624789434186798, 0.80000000000000004, 0.20000000000000001 }, + { 2.4392042002725698, 0.80000000000000004, 0.30000000000000004 }, + { 2.6604037035529728, 0.80000000000000004, 0.40000000000000002 }, + { 2.9478781158239751, 0.80000000000000004, 0.50000000000000000 }, + { 3.3418121892288055, 0.80000000000000004, 0.60000000000000009 }, + { 3.9268876980046397, 0.80000000000000004, 0.70000000000000007 }, + { 4.9246422058196071, 0.80000000000000004, 0.80000000000000004 }, + { 7.2263259298637132, 0.80000000000000004, 0.90000000000000002 }, }; - -// Test function for k=0.89999999999999991. -template <typename Tp> -void test019() +const double toler018 = 2.5000000000000020e-13; + +// Test data for k=0.90000000000000013. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 3 +// max(|f - f_Boost| / |f_Boost|): 1.5716352001310461e-16 +// mean(f - f_Boost): 4.4408920985006264e-17 +// variance(f - f_Boost): 2.4347558803117648e-34 +// stddev(f - f_Boost): 1.5603704304785339e-17 +const testcase_comp_ellint_3<double> +data019[10] = { - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data019) - / sizeof(testcase_comp_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::comp_ellint_3(Tp(data019[i].k), Tp(data019[i].nu)); - const Tp f0 = data019[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} + { 2.2805491384227707, 0.90000000000000013, 0.0000000000000000 }, + { 2.4295011187834890, 0.90000000000000013, 0.10000000000000001 }, + { 2.6076835743348421, 0.90000000000000013, 0.20000000000000001 }, + { 2.8256506968858521, 0.90000000000000013, 0.30000000000000004 }, + { 3.1000689868578628, 0.90000000000000013, 0.40000000000000002 }, + { 3.4591069002104686, 0.90000000000000013, 0.50000000000000000 }, + { 3.9549939883570242, 0.90000000000000013, 0.60000000000000009 }, + { 4.6985482312992453, 0.90000000000000013, 0.70000000000000007 }, + { 5.9820740813645727, 0.90000000000000013, 0.80000000000000004 }, + { 8.9942562031858735, 0.90000000000000013, 0.90000000000000002 }, +}; +const double toler019 = 2.5000000000000020e-13; + +template<typename Ret, unsigned int Num> + void + test(const testcase_comp_ellint_3<Ret> (&data)[Num], Ret toler) + { + bool test __attribute__((unused)) = true; + const Ret eps = std::numeric_limits<Ret>::epsilon(); + Ret max_abs_diff = -Ret(1); + Ret max_abs_frac = -Ret(1); + unsigned int num_datum = Num; + for (unsigned int i = 0; i < num_datum; ++i) + { + const Ret f = std::tr1::comp_ellint_3(data[i].k, data[i].nu); + const Ret f0 = data[i].f0; + const Ret diff = f - f0; + if (std::abs(diff) > max_abs_diff) + max_abs_diff = std::abs(diff); + if (std::abs(f0) > Ret(10) * eps + && std::abs(f) > Ret(10) * eps) + { + const Ret frac = diff / f0; + if (std::abs(frac) > max_abs_frac) + max_abs_frac = std::abs(frac); + } + } + VERIFY(max_abs_frac < toler); + } -int main(int, char**) +int +main() { - test001<double>(); - test002<double>(); - test003<double>(); - test004<double>(); - test005<double>(); - test006<double>(); - test007<double>(); - test008<double>(); - test009<double>(); - test010<double>(); - test011<double>(); - test012<double>(); - test013<double>(); - test014<double>(); - test015<double>(); - test016<double>(); - test017<double>(); - test018<double>(); - test019<double>(); + test(data001, toler001); + test(data002, toler002); + test(data003, toler003); + test(data004, toler004); + test(data005, toler005); + test(data006, toler006); + test(data007, toler007); + test(data008, toler008); + test(data009, toler009); + test(data010, toler010); + test(data011, toler011); + test(data012, toler012); + test(data013, toler013); + test(data014, toler014); + test(data015, toler015); + test(data016, toler016); + test(data017, toler017); + test(data018, toler018); + test(data019, toler019); return 0; } diff --git a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/06_comp_ellint_3/pr66689.cc b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/06_comp_ellint_3/pr66689.cc new file mode 100644 index 00000000000..7b274d64d2b --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/06_comp_ellint_3/pr66689.cc @@ -0,0 +1,20 @@ + +#include <tr1/cmath> +#include <testsuite_hooks.h> + +void +test01() +{ + double Pi1 = std::tr1::comp_ellint_3(0.75, 0.0); + VERIFY(std::abs(Pi1 - 1.91099) < 0.00001); + + double Pi2 = std::tr1::comp_ellint_3(0.75, 0.5); + VERIFY(std::abs(Pi2 - 2.80011) < 0.00001); +} + +int +main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/14_ellint_3/check_value.cc b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/14_ellint_3/check_value.cc index 2e402c68793..e0bd7037480 100644 --- a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/14_ellint_3/check_value.cc +++ b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/14_ellint_3/check_value.cc @@ -1,6 +1,7 @@ -// 2007-02-04 Edward Smith-Rowland <3dw4rd@verizon.net> +// { dg-do run { target c++11 } } +// { dg-options "-D__STDCPP_WANT_MATH_SPEC_FUNCS__" } // -// Copyright (C) 2007-2017 Free Software Foundation, Inc. +// Copyright (C) 2016-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -18,10098 +19,6324 @@ // <http://www.gnu.org/licenses/>. // ellint_3 - - // Compare against values generated by the GNU Scientific Library. // The GSL can be found on the web: http://www.gnu.org/software/gsl/ - +#include <limits> #include <tr1/cmath> #if defined(__TEST_DEBUG) -#include <iostream> -#define VERIFY(A) \ -if (!(A)) \ - { \ - std::cout << "line " << __LINE__ \ - << " max_abs_frac = " << max_abs_frac \ - << std::endl; \ - } +# include <iostream> +# define VERIFY(A) \ + if (!(A)) \ + { \ + std::cout << "line " << __LINE__ \ + << " max_abs_frac = " << max_abs_frac \ + << std::endl; \ + } #else -#include <testsuite_hooks.h> +# include <testsuite_hooks.h> #endif -#include "../testcase.h" - +#include <specfun_testcase.h> // Test data for k=-0.90000000000000002, nu=0.0000000000000000. -testcase_ellint_3<double> data001[] = { - { -0.0000000000000000, -0.90000000000000002, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17525427376115027, -0.90000000000000002, 0.0000000000000000, - 0.17453292519943295 }, - { 0.35492464591297446, -0.90000000000000002, 0.0000000000000000, - 0.34906585039886590 }, - { 0.54388221416157134, -0.90000000000000002, 0.0000000000000000, - 0.52359877559829882 }, - { 0.74797400423532523, -0.90000000000000002, 0.0000000000000000, - 0.69813170079773179 }, - { 0.97463898451966458, -0.90000000000000002, 0.0000000000000000, - 0.87266462599716477 }, - { 1.2334463254523440, -0.90000000000000002, 0.0000000000000000, - 1.0471975511965976 }, - { 1.5355247765594910, -0.90000000000000002, 0.0000000000000000, - 1.2217304763960306 }, - { 1.8882928567775124, -0.90000000000000002, 0.0000000000000000, - 1.3962634015954636 }, - { 2.2805491384227703, -0.90000000000000002, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.90000000000000002, nu=0.0000000000000000. -template <typename Tp> -void test001() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data001) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data001[i].k), Tp(data001[i].nu), - Tp(data001[i].phi)); - const Tp f0 = data001[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 5.7842011620951154e-16 +// mean(f - f_Boost): 5.8286708792820721e-17 +// variance(f - f_Boost): 4.1942474344433133e-34 +// stddev(f - f_Boost): 2.0479861900030756e-17 +const testcase_ellint_3<double> +data001[10] = +{ + { 0.0000000000000000, -0.90000000000000002, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17525427376115027, -0.90000000000000002, 0.0000000000000000, + 0.17453292519943295 }, + { 0.35492464591297446, -0.90000000000000002, 0.0000000000000000, + 0.34906585039886590 }, + { 0.54388221416157123, -0.90000000000000002, 0.0000000000000000, + 0.52359877559829882 }, + { 0.74797400423532512, -0.90000000000000002, 0.0000000000000000, + 0.69813170079773179 }, + { 0.97463898451966446, -0.90000000000000002, 0.0000000000000000, + 0.87266462599716477 }, + { 1.2334463254523438, -0.90000000000000002, 0.0000000000000000, + 1.0471975511965976 }, + { 1.5355247765594913, -0.90000000000000002, 0.0000000000000000, + 1.2217304763960306 }, + { 1.8882928567775126, -0.90000000000000002, 0.0000000000000000, + 1.3962634015954636 }, + { 2.2805491384227703, -0.90000000000000002, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler001 = 2.5000000000000020e-13; // Test data for k=-0.90000000000000002, nu=0.10000000000000001. -testcase_ellint_3<double> data002[] = { - { -0.0000000000000000, -0.90000000000000002, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17507714233254659, -0.90000000000000002, 0.10000000000000001, - 0.17453292519943295 }, - { 0.35350932904326521, -0.90000000000000002, 0.10000000000000001, - 0.34906585039886590 }, - { 0.53911129989870998, -0.90000000000000002, 0.10000000000000001, - 0.52359877559829882 }, - { 0.73666644254508429, -0.90000000000000002, 0.10000000000000001, - 0.69813170079773179 }, - { 0.95250736612100184, -0.90000000000000002, 0.10000000000000001, - 0.87266462599716477 }, - { 1.1950199550905594, -0.90000000000000002, 0.10000000000000001, - 1.0471975511965976 }, - { 1.4741687286340848, -0.90000000000000002, 0.10000000000000001, - 1.2217304763960306 }, - { 1.7968678183506059, -0.90000000000000002, 0.10000000000000001, - 1.3962634015954636 }, - { 2.1537868513875287, -0.90000000000000002, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.90000000000000002, nu=0.10000000000000001. -template <typename Tp> -void test002() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data002) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data002[i].k), Tp(data002[i].nu), - Tp(data002[i].phi)); - const Tp f0 = data002[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.1500594295134815e-16 +// mean(f - f_Boost): 1.0269562977782698e-16 +// variance(f - f_Boost): 1.4388836606733082e-32 +// stddev(f - f_Boost): 1.1995347684303728e-16 +const testcase_ellint_3<double> +data002[10] = +{ + { 0.0000000000000000, -0.90000000000000002, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17543204932716244, -0.90000000000000002, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35636022898551184, -0.90000000000000002, 0.10000000000000001, + 0.34906585039886590 }, + { 0.54880278898382584, -0.90000000000000002, 0.10000000000000001, + 0.52359877559829882 }, + { 0.75988834774529268, -0.90000000000000002, 0.10000000000000001, + 0.69813170079773179 }, + { 0.99853303003568117, -0.90000000000000002, 0.10000000000000001, + 0.87266462599716477 }, + { 1.2759958823999022, -0.90000000000000002, 0.10000000000000001, + 1.0471975511965976 }, + { 1.6051187364639401, -0.90000000000000002, 0.10000000000000001, + 1.2217304763960306 }, + { 1.9941406879519472, -0.90000000000000002, 0.10000000000000001, + 1.3962634015954636 }, + { 2.4295011187834881, -0.90000000000000002, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler002 = 2.5000000000000020e-13; // Test data for k=-0.90000000000000002, nu=0.20000000000000001. -testcase_ellint_3<double> data003[] = { - { -0.0000000000000000, -0.90000000000000002, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17490065089140930, -0.90000000000000002, 0.20000000000000001, - 0.17453292519943295 }, - { 0.35211377590661436, -0.90000000000000002, 0.20000000000000001, - 0.34906585039886590 }, - { 0.53448220334204122, -0.90000000000000002, 0.20000000000000001, - 0.52359877559829882 }, - { 0.72591368943179613, -0.90000000000000002, 0.20000000000000001, - 0.69813170079773179 }, - { 0.93192539780038763, -0.90000000000000002, 0.20000000000000001, - 0.87266462599716477 }, - { 1.1600809679692683, -0.90000000000000002, 0.20000000000000001, - 1.0471975511965976 }, - { 1.4195407225882508, -0.90000000000000002, 0.20000000000000001, - 1.2217304763960306 }, - { 1.7168966476424528, -0.90000000000000002, 0.20000000000000001, - 1.3962634015954636 }, - { 2.0443194576468890, -0.90000000000000002, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.90000000000000002, nu=0.20000000000000001. -template <typename Tp> -void test003() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data003) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data003[i].k), Tp(data003[i].nu), - Tp(data003[i].phi)); - const Tp f0 = data003[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.90000000000000002, nu=0.29999999999999999. -testcase_ellint_3<double> data004[] = { - { -0.0000000000000000, -0.90000000000000002, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17472479532647534, -0.90000000000000002, 0.29999999999999999, - 0.17453292519943295 }, - { 0.35073750187374114, -0.90000000000000002, 0.29999999999999999, - 0.34906585039886590 }, - { 0.52998766129466979, -0.90000000000000002, 0.29999999999999999, - 0.52359877559829882 }, - { 0.71566993548699587, -0.90000000000000002, 0.29999999999999999, - 0.69813170079773179 }, - { 0.91271517762560195, -0.90000000000000002, 0.29999999999999999, - 0.87266462599716477 }, - { 1.1281241199843370, -0.90000000000000002, 0.29999999999999999, - 1.0471975511965976 }, - { 1.3704929576917448, -0.90000000000000002, 0.29999999999999999, - 1.2217304763960306 }, - { 1.6461981511487715, -0.90000000000000002, 0.29999999999999999, - 1.3962634015954636 }, - { 1.9486280260314426, -0.90000000000000002, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=-0.90000000000000002, nu=0.29999999999999999. -template <typename Tp> -void test004() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data004) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data004[i].k), Tp(data004[i].nu), - Tp(data004[i].phi)); - const Tp f0 = data004[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 5.2711357908578066e-16 +// mean(f - f_Boost): 8.0491169285323847e-17 +// variance(f - f_Boost): 7.9985534974304465e-34 +// stddev(f - f_Boost): 2.8281714052423424e-17 +const testcase_ellint_3<double> +data003[10] = +{ + { 0.0000000000000000, -0.90000000000000002, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17561047321968409, -0.90000000000000002, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35781659944356109, -0.90000000000000002, 0.20000000000000001, + 0.34906585039886590 }, + { 0.55388150905215283, -0.90000000000000002, 0.20000000000000001, + 0.52359877559829882 }, + { 0.77246874123251441, -0.90000000000000002, 0.20000000000000001, + 0.69813170079773179 }, + { 1.0244466254771925, -0.90000000000000002, 0.20000000000000001, + 0.87266462599716477 }, + { 1.3234824077640801, -0.90000000000000002, 0.20000000000000001, + 1.0471975511965976 }, + { 1.6849848968804237, -0.90000000000000002, 0.20000000000000001, + 1.2217304763960306 }, + { 2.1185749045502273, -0.90000000000000002, 0.20000000000000001, + 1.3962634015954636 }, + { 2.6076835743348412, -0.90000000000000002, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler003 = 2.5000000000000020e-13; + +// Test data for k=-0.90000000000000002, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.9955372494296814e-16 +// mean(f - f_Boost): 5.8286708792820721e-17 +// variance(f - f_Boost): 4.1942474344433133e-34 +// stddev(f - f_Boost): 2.0479861900030756e-17 +const testcase_ellint_3<double> +data004[10] = +{ + { 0.0000000000000000, -0.90000000000000002, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17578954966746221, -0.90000000000000002, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35929429810867447, -0.90000000000000002, 0.30000000000000004, + 0.34906585039886590 }, + { 0.55912757154240811, -0.90000000000000002, 0.30000000000000004, + 0.52359877559829882 }, + { 0.78578314722025389, -0.90000000000000002, 0.30000000000000004, + 0.69813170079773179 }, + { 1.0526941001131365, -0.90000000000000002, 0.30000000000000004, + 0.87266462599716477 }, + { 1.3769682234538601, -0.90000000000000002, 0.30000000000000004, + 1.0471975511965976 }, + { 1.7779437432911238, -0.90000000000000002, 0.30000000000000004, + 1.2217304763960306 }, + { 2.2676509341813631, -0.90000000000000002, 0.30000000000000004, + 1.3962634015954636 }, + { 2.8256506968858512, -0.90000000000000002, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler004 = 2.5000000000000020e-13; // Test data for k=-0.90000000000000002, nu=0.40000000000000002. -testcase_ellint_3<double> data005[] = { - { -0.0000000000000000, -0.90000000000000002, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17454957156468839, -0.90000000000000002, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34938003933330430, -0.90000000000000002, 0.40000000000000002, - 0.34906585039886590 }, - { 0.52562093533067455, -0.90000000000000002, 0.40000000000000002, - 0.52359877559829882 }, - { 0.70589461324915703, -0.90000000000000002, 0.40000000000000002, - 0.69813170079773179 }, - { 0.89472658511942849, -0.90000000000000002, 0.40000000000000002, - 0.87266462599716477 }, - { 1.0987419542323440, -0.90000000000000002, 0.40000000000000002, - 1.0471975511965976 }, - { 1.3261349565496301, -0.90000000000000002, 0.40000000000000002, - 1.2217304763960306 }, - { 1.5831293909853767, -0.90000000000000002, 0.40000000000000002, - 1.3962634015954636 }, - { 1.8641114227238349, -0.90000000000000002, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.90000000000000002, nu=0.40000000000000002. -template <typename Tp> -void test005() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data005) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data005[i].k), Tp(data005[i].nu), - Tp(data005[i].phi)); - const Tp f0 = data005[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.7042235432234642e-16 +// mean(f - f_Boost): 2.0261570199409106e-16 +// variance(f - f_Boost): 5.8024227149195491e-32 +// stddev(f - f_Boost): 2.4088218520512364e-16 +const testcase_ellint_3<double> +data005[10] = +{ + { 0.0000000000000000, -0.90000000000000002, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17596928293938452, -0.90000000000000002, 0.40000000000000002, + 0.17453292519943295 }, + { 0.36079388642472821, -0.90000000000000002, 0.40000000000000002, + 0.34906585039886590 }, + { 0.56455096667115612, -0.90000000000000002, 0.40000000000000002, + 0.52359877559829882 }, + { 0.79990996997869435, -0.90000000000000002, 0.40000000000000002, + 0.69813170079773179 }, + { 1.0836647913872215, -0.90000000000000002, 0.40000000000000002, + 0.87266462599716477 }, + { 1.4378726836091849, -0.90000000000000002, 0.40000000000000002, + 1.0471975511965976 }, + { 1.8880446720682853, -0.90000000000000002, 0.40000000000000002, + 1.2217304763960306 }, + { 2.4505848932025227, -0.90000000000000002, 0.40000000000000002, + 1.3962634015954636 }, + { 3.1000689868578615, -0.90000000000000002, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler005 = 2.5000000000000020e-13; // Test data for k=-0.90000000000000002, nu=0.50000000000000000. -testcase_ellint_3<double> data006[] = { - { -0.0000000000000000, -0.90000000000000002, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17437497557073336, -0.90000000000000002, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34804093691586013, -0.90000000000000002, 0.50000000000000000, - 0.34906585039886590 }, - { 0.52137576320372914, -0.90000000000000002, 0.50000000000000000, - 0.52359877559829882 }, - { 0.69655163996912284, -0.90000000000000002, 0.50000000000000000, - 0.69813170079773179 }, - { 0.87783188683054236, -0.90000000000000002, 0.50000000000000000, - 0.87266462599716477 }, - { 1.0716015959755185, -0.90000000000000002, 0.50000000000000000, - 1.0471975511965976 }, - { 1.2857636916026747, -0.90000000000000002, 0.50000000000000000, - 1.2217304763960306 }, - { 1.5264263913252365, -0.90000000000000002, 0.50000000000000000, - 1.3962634015954636 }, - { 1.7888013241937861, -0.90000000000000002, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.90000000000000002, nu=0.50000000000000000. -template <typename Tp> -void test006() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data006) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data006[i].k), Tp(data006[i].nu), - Tp(data006[i].phi)); - const Tp f0 = data006[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.90000000000000002, nu=0.59999999999999998. -testcase_ellint_3<double> data007[] = { - { -0.0000000000000000, -0.90000000000000002, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17420100334657815, -0.90000000000000002, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34671975876122157, -0.90000000000000002, 0.59999999999999998, - 0.34906585039886590 }, - { 0.51724631570707968, -0.90000000000000002, 0.59999999999999998, - 0.52359877559829882 }, - { 0.68760879113743056, -0.90000000000000002, 0.59999999999999998, - 0.69813170079773179 }, - { 0.86192157779698364, -0.90000000000000002, 0.59999999999999998, - 0.87266462599716477 }, - { 1.0464279696166354, -0.90000000000000002, 0.59999999999999998, - 1.0471975511965976 }, - { 1.2488156247094004, -0.90000000000000002, 0.59999999999999998, - 1.2217304763960306 }, - { 1.4750988777188474, -0.90000000000000002, 0.59999999999999998, - 1.3962634015954636 }, - { 1.7211781128919523, -0.90000000000000002, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=-0.90000000000000002, nu=0.59999999999999998. -template <typename Tp> -void test007() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data007) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data007[i].k), Tp(data007[i].nu), - Tp(data007[i].phi)); - const Tp f0 = data007[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.90000000000000002, nu=0.69999999999999996. -testcase_ellint_3<double> data008[] = { - { -0.0000000000000000, -0.90000000000000002, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17402765093102210, -0.90000000000000002, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34541608382635131, -0.90000000000000002, 0.69999999999999996, - 0.34906585039886590 }, - { 0.51322715827061705, -0.90000000000000002, 0.69999999999999996, - 0.52359877559829882 }, - { 0.67903717872440306, -0.90000000000000002, 0.69999999999999996, - 0.69813170079773179 }, - { 0.84690113601682671, -0.90000000000000002, 0.69999999999999996, - 0.87266462599716477 }, - { 1.0229914311548418, -0.90000000000000002, 0.69999999999999996, - 1.0471975511965976 }, - { 1.2148329639709381, -0.90000000000000002, 0.69999999999999996, - 1.2217304763960306 }, - { 1.4283586501307806, -0.90000000000000002, 0.69999999999999996, - 1.3962634015954636 }, - { 1.6600480747670938, -0.90000000000000002, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=-0.90000000000000002, nu=0.69999999999999996. -template <typename Tp> -void test008() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data008) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data008[i].k), Tp(data008[i].nu), - Tp(data008[i].phi)); - const Tp f0 = data008[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 3.8944086593755267e-16 +// mean(f - f_Boost): 6.9388939039072284e-17 +// variance(f - f_Boost): 1.7333369499485123e-32 +// stddev(f - f_Boost): 1.3165625507162629e-16 +const testcase_ellint_3<double> +data006[10] = +{ + { 0.0000000000000000, -0.90000000000000002, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17614967734498183, -0.90000000000000002, 0.50000000000000000, + 0.17453292519943295 }, + { 0.36231594750319435, -0.90000000000000002, 0.50000000000000000, + 0.34906585039886590 }, + { 0.57016256984349567, -0.90000000000000002, 0.50000000000000000, + 0.52359877559829882 }, + { 0.81494025918293422, -0.90000000000000002, 0.50000000000000000, + 0.69813170079773179 }, + { 1.1178482279283477, -0.90000000000000002, 0.50000000000000000, + 0.87266462599716477 }, + { 1.5081455873012106, -0.90000000000000002, 0.50000000000000000, + 1.0471975511965976 }, + { 2.0213599730863998, -0.90000000000000002, 0.50000000000000000, + 1.2217304763960306 }, + { 2.6822467012926827, -0.90000000000000002, 0.50000000000000000, + 1.3962634015954636 }, + { 3.4591069002104677, -0.90000000000000002, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler006 = 2.5000000000000020e-13; + +// Test data for k=-0.90000000000000002, nu=0.60000000000000009. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.0602096790645418e-16 +// mean(f - f_Boost): 1.0269562977782698e-16 +// variance(f - f_Boost): 1.4388836606733082e-32 +// stddev(f - f_Boost): 1.1995347684303728e-16 +const testcase_ellint_3<double> +data007[10] = +{ + { 0.0000000000000000, -0.90000000000000002, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17633073723493825, -0.90000000000000002, 0.60000000000000009, + 0.17453292519943295 }, + { 0.36386108723492810, -0.90000000000000002, 0.60000000000000009, + 0.34906585039886590 }, + { 0.57597424744716241, -0.90000000000000002, 0.60000000000000009, + 0.52359877559829882 }, + { 0.83098051948501150, -0.90000000000000002, 0.60000000000000009, + 0.69813170079773179 }, + { 1.1558706545698916, -0.90000000000000002, 0.60000000000000009, + 0.87266462599716477 }, + { 1.5905576379415669, -0.90000000000000002, 0.60000000000000009, + 1.0471975511965976 }, + { 2.1875186010215080, -0.90000000000000002, 0.60000000000000009, + 1.2217304763960306 }, + { 2.9885767771316849, -0.90000000000000002, 0.60000000000000009, + 1.3962634015954636 }, + { 3.9549939883570224, -0.90000000000000002, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler007 = 2.5000000000000020e-13; + +// Test data for k=-0.90000000000000002, nu=0.70000000000000007. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 5.1938610791060186e-16 +// mean(f - f_Boost): 3.0253577421035517e-16 +// variance(f - f_Boost): 4.2342877557562532e-32 +// stddev(f - f_Boost): 2.0577385051935665e-16 +const testcase_ellint_3<double> +data008[10] = +{ + { 0.0000000000000000, -0.90000000000000002, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17651246700160939, -0.90000000000000002, 0.70000000000000007, + 0.17453292519943295 }, + { 0.36542993547358982, -0.90000000000000002, 0.70000000000000007, + 0.34906585039886590 }, + { 0.58199897877674867, -0.90000000000000002, 0.70000000000000007, + 0.52359877559829882 }, + { 0.84815633587352857, -0.90000000000000002, 0.70000000000000007, + 0.69813170079773179 }, + { 1.1985495623872375, -0.90000000000000002, 0.70000000000000007, + 0.87266462599716477 }, + { 1.6892158134027688, -0.90000000000000002, 0.70000000000000007, + 1.0471975511965976 }, + { 2.4029722191094236, -0.90000000000000002, 0.70000000000000007, + 1.2217304763960306 }, + { 3.4201084941340052, -0.90000000000000002, 0.70000000000000007, + 1.3962634015954636 }, + { 4.6985482312992435, -0.90000000000000002, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler008 = 2.5000000000000020e-13; // Test data for k=-0.90000000000000002, nu=0.80000000000000004. -testcase_ellint_3<double> data009[] = { - { -0.0000000000000000, -0.90000000000000002, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17385491439925149, -0.90000000000000002, 0.80000000000000004, - 0.17453292519943295 }, - { 0.34412950523113928, -0.90000000000000002, 0.80000000000000004, - 0.34906585039886590 }, - { 0.50931321668729612, -0.90000000000000002, 0.80000000000000004, - 0.52359877559829882 }, - { 0.67081081392296349, -0.90000000000000002, 0.80000000000000004, - 0.69813170079773179 }, - { 0.83268846097293259, -0.90000000000000002, 0.80000000000000004, - 0.87266462599716477 }, - { 1.0010985015814027, -0.90000000000000002, 0.80000000000000004, - 1.0471975511965976 }, - { 1.1834394045489678, -0.90000000000000002, 0.80000000000000004, - 1.2217304763960306 }, - { 1.3855695891683188, -0.90000000000000002, 0.80000000000000004, - 1.3962634015954636 }, - { 1.6044591960982204, -0.90000000000000002, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=-0.90000000000000002, nu=0.80000000000000004. -template <typename Tp> -void test009() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data009) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data009[i].k), Tp(data009[i].nu), - Tp(data009[i].phi)); - const Tp f0 = data009[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 6.5091520146032660e-16 +// mean(f - f_Boost): 2.8310687127941490e-16 +// variance(f - f_Boost): 9.8950000698295322e-33 +// stddev(f - f_Boost): 9.9473614943006532e-17 +const testcase_ellint_3<double> +data009[10] = +{ + { 0.0000000000000000, -0.90000000000000002, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17669487107954862, -0.90000000000000002, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36702314729628421, -0.90000000000000002, 0.80000000000000004, + 0.34906585039886590 }, + { 0.58825099711365492, -0.90000000000000002, 0.80000000000000004, + 0.52359877559829882 }, + { 0.86661711422209031, -0.90000000000000002, 0.80000000000000004, + 0.69813170079773179 }, + { 1.2469779109884802, -0.90000000000000002, 0.80000000000000004, + 0.87266462599716477 }, + { 1.8105469760531578, -0.90000000000000002, 0.80000000000000004, + 1.0471975511965976 }, + { 2.6989505165893752, -0.90000000000000002, 0.80000000000000004, + 1.2217304763960306 }, + { 4.0935213267757424, -0.90000000000000002, 0.80000000000000004, + 1.3962634015954636 }, + { 5.9820740813645710, -0.90000000000000002, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler009 = 2.5000000000000020e-13; // Test data for k=-0.90000000000000002, nu=0.90000000000000002. -testcase_ellint_3<double> data010[] = { - { -0.0000000000000000, -0.90000000000000002, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17368278986240138, -0.90000000000000002, 0.90000000000000002, - 0.17453292519943295 }, - { 0.34285962963961397, -0.90000000000000002, 0.90000000000000002, - 0.34906585039886590 }, - { 0.50549974644993323, -0.90000000000000002, 0.90000000000000002, - 0.52359877559829882 }, - { 0.66290623857720898, -0.90000000000000002, 0.90000000000000002, - 0.69813170079773179 }, - { 0.81921183128847164, -0.90000000000000002, 0.90000000000000002, - 0.87266462599716477 }, - { 0.98058481956066390, -0.90000000000000002, 0.90000000000000002, - 1.0471975511965976 }, - { 1.1543223520473567, -0.90000000000000002, 0.90000000000000002, - 1.2217304763960306 }, - { 1.3462119782292938, -0.90000000000000002, 0.90000000000000002, - 1.3962634015954636 }, - { 1.5536420236310946, -0.90000000000000002, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.90000000000000002, nu=0.90000000000000002. -template <typename Tp> -void test010() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data010) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data010[i].k), Tp(data010[i].nu), - Tp(data010[i].phi)); - const Tp f0 = data010[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 8.2628580104449673e-16 +// mean(f - f_Boost): 8.5764728652293339e-16 +// variance(f - f_Boost): 8.9671393318321280e-31 +// stddev(f - f_Boost): 9.4694980499666013e-16 +const testcase_ellint_3<double> +data010[10] = +{ + { 0.0000000000000000, -0.90000000000000002, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17687795394604169, -0.90000000000000002, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36864140434751286, -0.90000000000000002, 0.90000000000000002, + 0.34906585039886590 }, + { 0.59474595366817051, -0.90000000000000002, 0.90000000000000002, + 0.52359877559829882 }, + { 0.88654237226056665, -0.90000000000000002, 0.90000000000000002, + 0.69813170079773179 }, + { 1.3026595810616726, -0.90000000000000002, 0.90000000000000002, + 0.87266462599716477 }, + { 1.9653635459278078, -0.90000000000000002, 0.90000000000000002, + 1.0471975511965976 }, + { 3.1451407527189463, -0.90000000000000002, 0.90000000000000002, + 1.2217304763960306 }, + { 5.3745230680316114, -0.90000000000000002, 0.90000000000000002, + 1.3962634015954636 }, + { 8.9942562031858682, -0.90000000000000002, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler010 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.0000000000000000. -testcase_ellint_3<double> data011[] = { - { -0.0000000000000000, -0.80000000000000004, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17510154241338902, -0.80000000000000004, 0.0000000000000000, - 0.17453292519943295 }, - { 0.35365068839779390, -0.80000000000000004, 0.0000000000000000, - 0.34906585039886590 }, - { 0.53926804409084561, -0.80000000000000004, 0.0000000000000000, - 0.52359877559829882 }, - { 0.73587926028070383, -0.80000000000000004, 0.0000000000000000, - 0.69813170079773179 }, - { 0.94770942970071170, -0.80000000000000004, 0.0000000000000000, - 0.87266462599716477 }, - { 1.1789022995388239, -0.80000000000000004, 0.0000000000000000, - 1.0471975511965976 }, - { 1.4323027881876009, -0.80000000000000004, 0.0000000000000000, - 1.2217304763960306 }, - { 1.7069629739121674, -0.80000000000000004, 0.0000000000000000, - 1.3962634015954636 }, - { 1.9953027776647296, -0.80000000000000004, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.80000000000000004, nu=0.0000000000000000. -template <typename Tp> -void test011() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data011) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data011[i].k), Tp(data011[i].nu), - Tp(data011[i].phi)); - const Tp f0 = data011[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.5543122344752192e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.7898565163847540e-16 +// mean(f - f_Boost): 2.3869795029440865e-16 +// variance(f - f_Boost): 2.1368406725192426e-31 +// stddev(f - f_Boost): 4.6225974002926564e-16 +const testcase_ellint_3<double> +data011[10] = +{ + { 0.0000000000000000, -0.80000000000000004, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17510154241338899, -0.80000000000000004, 0.0000000000000000, + 0.17453292519943295 }, + { 0.35365068839779396, -0.80000000000000004, 0.0000000000000000, + 0.34906585039886590 }, + { 0.53926804409084550, -0.80000000000000004, 0.0000000000000000, + 0.52359877559829882 }, + { 0.73587926028070372, -0.80000000000000004, 0.0000000000000000, + 0.69813170079773179 }, + { 0.94770942970071170, -0.80000000000000004, 0.0000000000000000, + 0.87266462599716477 }, + { 1.1789022995388236, -0.80000000000000004, 0.0000000000000000, + 1.0471975511965976 }, + { 1.4323027881876012, -0.80000000000000004, 0.0000000000000000, + 1.2217304763960306 }, + { 1.7069629739121677, -0.80000000000000004, 0.0000000000000000, + 1.3962634015954636 }, + { 1.9953027776647294, -0.80000000000000004, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler011 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.10000000000000001. -testcase_ellint_3<double> data012[] = { - { -0.0000000000000000, -0.80000000000000004, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17492468824017166, -0.80000000000000004, 0.10000000000000001, - 0.17453292519943295 }, - { 0.35224443521476911, -0.80000000000000004, 0.10000000000000001, - 0.34906585039886590 }, - { 0.53456851853226961, -0.80000000000000004, 0.10000000000000001, - 0.52359877559829882 }, - { 0.72488875602364944, -0.80000000000000004, 0.10000000000000001, - 0.69813170079773179 }, - { 0.92661354274638952, -0.80000000000000004, 0.10000000000000001, - 0.87266462599716477 }, - { 1.1432651144499077, -0.80000000000000004, 0.10000000000000001, - 1.0471975511965976 }, - { 1.3774479927211429, -0.80000000000000004, 0.10000000000000001, - 1.2217304763960306 }, - { 1.6287092337196041, -0.80000000000000004, 0.10000000000000001, - 1.3962634015954636 }, - { 1.8910755418379521, -0.80000000000000004, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.80000000000000004, nu=0.10000000000000001. -template <typename Tp> -void test012() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data012) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data012[i].k), Tp(data012[i].nu), - Tp(data012[i].phi)); - const Tp f0 = data012[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 8.3898786942190374e-16 +// mean(f - f_Boost): 2.3869795029440865e-16 +// variance(f - f_Boost): 2.9190059990693968e-31 +// stddev(f - f_Boost): 5.4027826155319237e-16 +const testcase_ellint_3<double> +data012[10] = +{ + { 0.0000000000000000, -0.80000000000000004, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17527903952342144, -0.80000000000000004, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35507705313548549, -0.80000000000000004, 0.10000000000000001, + 0.34906585039886590 }, + { 0.54411455987643553, -0.80000000000000004, 0.10000000000000001, + 0.52359877559829882 }, + { 0.74745625666804383, -0.80000000000000004, 0.10000000000000001, + 0.69813170079773179 }, + { 0.97046953684238557, -0.80000000000000004, 0.10000000000000001, + 0.87266462599716477 }, + { 1.2183080025184605, -0.80000000000000004, 0.10000000000000001, + 1.0471975511965976 }, + { 1.4943711151994405, -0.80000000000000004, 0.10000000000000001, + 1.2217304763960306 }, + { 1.7972401309544201, -0.80000000000000004, 0.10000000000000001, + 1.3962634015954636 }, + { 2.1172616484005085, -0.80000000000000004, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler012 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.20000000000000001. -testcase_ellint_3<double> data013[] = { - { -0.0000000000000000, -0.80000000000000004, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17474847286224943, -0.80000000000000004, 0.20000000000000001, - 0.17453292519943295 }, - { 0.35085779529084682, -0.80000000000000004, 0.20000000000000001, - 0.34906585039886590 }, - { 0.53000829263059157, -0.80000000000000004, 0.20000000000000001, - 0.52359877559829882 }, - { 0.71443466027453406, -0.80000000000000004, 0.20000000000000001, - 0.69813170079773179 }, - { 0.90698196872715420, -0.80000000000000004, 0.20000000000000001, - 0.87266462599716477 }, - { 1.1108198200558581, -0.80000000000000004, 0.20000000000000001, - 1.0471975511965976 }, - { 1.3284988909963957, -0.80000000000000004, 0.20000000000000001, - 1.2217304763960306 }, - { 1.5600369318140328, -0.80000000000000004, 0.20000000000000001, - 1.3962634015954636 }, - { 1.8007226661734588, -0.80000000000000004, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.80000000000000004, nu=0.20000000000000001. -template <typename Tp> -void test013() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data013) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data013[i].k), Tp(data013[i].nu), - Tp(data013[i].phi)); - const Tp f0 = data013[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.80000000000000004, nu=0.29999999999999999. -testcase_ellint_3<double> data014[] = { - { -0.0000000000000000, -0.80000000000000004, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17457289217669891, -0.80000000000000004, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34949028801501258, -0.80000000000000004, 0.29999999999999999, - 0.34906585039886590 }, - { 0.52558024362769318, -0.80000000000000004, 0.29999999999999999, - 0.52359877559829882 }, - { 0.70447281740094914, -0.80000000000000004, 0.29999999999999999, - 0.69813170079773179 }, - { 0.88864745641528986, -0.80000000000000004, 0.29999999999999999, - 0.87266462599716477 }, - { 1.0811075819341465, -0.80000000000000004, 0.29999999999999999, - 1.0471975511965976 }, - { 1.2844589654082377, -0.80000000000000004, 0.29999999999999999, - 1.2217304763960306 }, - { 1.4991461361277849, -0.80000000000000004, 0.29999999999999999, - 1.3962634015954636 }, - { 1.7214611048717301, -0.80000000000000004, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=-0.80000000000000004, nu=0.29999999999999999. -template <typename Tp> -void test014() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data014) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data014[i].k), Tp(data014[i].nu), - Tp(data014[i].phi)); - const Tp f0 = data014[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.8513740186068518e-16 +// mean(f - f_Boost): 2.8310687127941490e-16 +// variance(f - f_Boost): 2.7528339102381189e-31 +// stddev(f - f_Boost): 5.2467455724840699e-16 +const testcase_ellint_3<double> +data013[10] = +{ + { 0.0000000000000000, -0.80000000000000004, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17545718375086419, -0.80000000000000004, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35652404627248163, -0.80000000000000004, 0.20000000000000001, + 0.34906585039886590 }, + { 0.54911638512920913, -0.80000000000000004, 0.20000000000000001, + 0.52359877559829882 }, + { 0.75967684282131176, -0.80000000000000004, 0.20000000000000001, + 0.69813170079773179 }, + { 0.99513526893543769, -0.80000000000000004, 0.20000000000000001, + 0.87266462599716477 }, + { 1.2622192109995993, -0.80000000000000004, 0.20000000000000001, + 1.0471975511965976 }, + { 1.5654106676347741, -0.80000000000000004, 0.20000000000000001, + 1.2217304763960306 }, + { 1.9029531718534984, -0.80000000000000004, 0.20000000000000001, + 1.3962634015954636 }, + { 2.2624789434186798, -0.80000000000000004, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler013 = 2.5000000000000020e-13; + +// Test data for k=-0.80000000000000004, nu=0.30000000000000004. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.2825261583337354e-16 +// mean(f - f_Boost): 2.6367796834847468e-16 +// variance(f - f_Boost): 2.8249350208968825e-31 +// stddev(f - f_Boost): 5.3150117788175054e-16 +const testcase_ellint_3<double> +data014[10] = +{ + { 0.0000000000000000, -0.80000000000000004, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17563597931587369, -0.80000000000000004, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35799220412005128, -0.80000000000000004, 0.30000000000000004, + 0.34906585039886590 }, + { 0.55428253691111318, -0.80000000000000004, 0.30000000000000004, + 0.52359877559829882 }, + { 0.77260647376977365, -0.80000000000000004, 0.30000000000000004, + 0.69813170079773179 }, + { 1.0220015271210958, -0.80000000000000004, 0.30000000000000004, + 0.87266462599716477 }, + { 1.3115965312302671, -0.80000000000000004, 0.30000000000000004, + 1.0471975511965976 }, + { 1.6478518468813512, -0.80000000000000004, 0.30000000000000004, + 1.2217304763960306 }, + { 2.0290458414203481, -0.80000000000000004, 0.30000000000000004, + 1.3962634015954636 }, + { 2.4392042002725693, -0.80000000000000004, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler014 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.40000000000000002. -testcase_ellint_3<double> data015[] = { - { -0.0000000000000000, -0.80000000000000004, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17439794211872178, -0.80000000000000004, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34814144964568972, -0.80000000000000004, 0.40000000000000002, - 0.34906585039886590 }, - { 0.52127776285273075, -0.80000000000000004, 0.40000000000000002, - 0.52359877559829882 }, - { 0.69496411438966599, -0.80000000000000004, 0.40000000000000002, - 0.69813170079773179 }, - { 0.87146878427509589, -0.80000000000000004, 0.40000000000000002, - 0.87266462599716477 }, - { 1.0537579024937762, -0.80000000000000004, 0.40000000000000002, - 1.0471975511965976 }, - { 1.2445534387922637, -0.80000000000000004, 0.40000000000000002, - 1.2217304763960306 }, - { 1.4446769766361993, -0.80000000000000004, 0.40000000000000002, - 1.3962634015954636 }, - { 1.6512267838651289, -0.80000000000000004, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.80000000000000004, nu=0.40000000000000002. -template <typename Tp> -void test015() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data015) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data015[i].k), Tp(data015[i].nu), - Tp(data015[i].phi)); - const Tp f0 = data015[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 8.3462748389836647e-16 +// mean(f - f_Boost): 3.3861802251067273e-16 +// variance(f - f_Boost): 4.3719465706454422e-31 +// stddev(f - f_Boost): 6.6120696991527871e-16 +const testcase_ellint_3<double> +data015[10] = +{ + { 0.0000000000000000, -0.80000000000000004, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17581543047866136, -0.80000000000000004, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35948208343061633, -0.80000000000000004, 0.40000000000000002, + 0.34906585039886590 }, + { 0.55962280893702021, -0.80000000000000004, 0.40000000000000002, + 0.52359877559829882 }, + { 0.78632063889234116, -0.80000000000000004, 0.40000000000000002, + 0.69813170079773179 }, + { 1.0514333069550323, -0.80000000000000004, 0.40000000000000002, + 0.87266462599716477 }, + { 1.3677213138838757, -0.80000000000000004, 0.40000000000000002, + 1.0471975511965976 }, + { 1.7451736773665165, -0.80000000000000004, 0.40000000000000002, + 1.2217304763960306 }, + { 2.1830100424586831, -0.80000000000000004, 0.40000000000000002, + 1.3962634015954636 }, + { 2.6604037035529724, -0.80000000000000004, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler015 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.50000000000000000. -testcase_ellint_3<double> data016[] = { - { -0.0000000000000000, -0.80000000000000004, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17422361866118047, -0.80000000000000004, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34681083254170475, -0.80000000000000004, 0.50000000000000000, - 0.34906585039886590 }, - { 0.51709470815494440, -0.80000000000000004, 0.50000000000000000, - 0.52359877559829882 }, - { 0.68587375344080259, -0.80000000000000004, 0.50000000000000000, - 0.69813170079773179 }, - { 0.85532571852810624, -0.80000000000000004, 0.50000000000000000, - 0.87266462599716477 }, - { 1.0284677391874906, -0.80000000000000004, 0.50000000000000000, - 1.0471975511965976 }, - { 1.2081693942686225, -0.80000000000000004, 0.50000000000000000, - 1.2217304763960306 }, - { 1.3955803006426311, -0.80000000000000004, 0.50000000000000000, - 1.3962634015954636 }, - { 1.5884528947755532, -0.80000000000000004, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.80000000000000004, nu=0.50000000000000000. -template <typename Tp> -void test016() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data016) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data016[i].k), Tp(data016[i].nu), - Tp(data016[i].phi)); - const Tp f0 = data016[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.80000000000000004, nu=0.59999999999999998. -testcase_ellint_3<double> data017[] = { - { -0.0000000000000000, -0.80000000000000004, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17404991781414092, -0.80000000000000004, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34549800443625167, -0.80000000000000004, 0.59999999999999998, - 0.34906585039886590 }, - { 0.51302536167001556, -0.80000000000000004, 0.59999999999999998, - 0.52359877559829882 }, - { 0.67717065003912258, -0.80000000000000004, 0.59999999999999998, - 0.69813170079773179 }, - { 0.84011512421134416, -0.80000000000000004, 0.59999999999999998, - 0.87266462599716477 }, - { 1.0049863847088742, -0.80000000000000004, 0.59999999999999998, - 1.0471975511965976 }, - { 1.1748145941898918, -0.80000000000000004, 0.59999999999999998, - 1.2217304763960306 }, - { 1.3510319699755071, -0.80000000000000004, 0.59999999999999998, - 1.3962634015954636 }, - { 1.5319262547427865, -0.80000000000000004, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=-0.80000000000000004, nu=0.59999999999999998. -template <typename Tp> -void test017() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data017) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data017[i].k), Tp(data017[i].nu), - Tp(data017[i].phi)); - const Tp f0 = data017[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.80000000000000004, nu=0.69999999999999996. -testcase_ellint_3<double> data018[] = { - { -0.0000000000000000, -0.80000000000000004, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17387683562442202, -0.80000000000000004, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34420254775101611, -0.80000000000000004, 0.69999999999999996, - 0.34906585039886590 }, - { 0.50906439222143685, -0.80000000000000004, 0.69999999999999996, - 0.52359877559829882 }, - { 0.66882693152688433, -0.80000000000000004, 0.69999999999999996, - 0.69813170079773179 }, - { 0.82574792844091316, -0.80000000000000004, 0.69999999999999996, - 0.87266462599716477 }, - { 0.98310431309490953, -0.80000000000000004, 0.69999999999999996, - 1.0471975511965976 }, - { 1.1440884535113258, -0.80000000000000004, 0.69999999999999996, - 1.2217304763960306 }, - { 1.3103743938952537, -0.80000000000000004, 0.69999999999999996, - 1.3962634015954636 }, - { 1.4806912324625332, -0.80000000000000004, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=-0.80000000000000004, nu=0.69999999999999996. -template <typename Tp> -void test018() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data018) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data018[i].k), Tp(data018[i].nu), - Tp(data018[i].phi)); - const Tp f0 = data018[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.0388243828581744e-16 +// mean(f - f_Boost): 3.8580250105724191e-16 +// variance(f - f_Boost): 6.4106456575047741e-31 +// stddev(f - f_Boost): 8.0066507713929764e-16 +const testcase_ellint_3<double> +data016[10] = +{ + { 0.0000000000000000, -0.80000000000000004, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17599554153999472, -0.80000000000000004, 0.50000000000000000, + 0.17453292519943295 }, + { 0.36099426243351540, -0.80000000000000004, 0.50000000000000000, + 0.34906585039886590 }, + { 0.56514786174780673, -0.80000000000000004, 0.50000000000000000, + 0.52359877559829882 }, + { 0.80090697622371010, -0.80000000000000004, 0.50000000000000000, + 0.69813170079773179 }, + { 1.0838891627679339, -0.80000000000000004, 0.50000000000000000, + 0.87266462599716477 }, + { 1.4323506654466280, -0.80000000000000004, 0.50000000000000000, + 1.0471975511965976 }, + { 1.8625761085390575, -0.80000000000000004, 0.50000000000000000, + 1.2217304763960306 }, + { 2.3768757305654766, -0.80000000000000004, 0.50000000000000000, + 1.3962634015954636 }, + { 2.9478781158239746, -0.80000000000000004, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler016 = 2.5000000000000020e-13; + +// Test data for k=-0.80000000000000004, nu=0.60000000000000009. +// max(|f - f_Boost|): 3.5527136788005009e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.0631099169042069e-15 +// mean(f - f_Boost): 4.8294701571194306e-16 +// variance(f - f_Boost): 1.1633910328160319e-30 +// stddev(f - f_Boost): 1.0786060600682865e-15 +const testcase_ellint_3<double> +data017[10] = +{ + { 0.0000000000000000, -0.80000000000000004, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17617631684170665, -0.80000000000000004, 0.60000000000000009, + 0.17453292519943295 }, + { 0.36252934193666231, -0.80000000000000004, 0.60000000000000009, + 0.34906585039886590 }, + { 0.57086932622945163, -0.80000000000000004, 0.60000000000000009, + 0.52359877559829882 }, + { 0.81646796740150973, -0.80000000000000004, 0.60000000000000009, + 0.69813170079773179 }, + { 1.1199552158519064, -0.80000000000000004, 0.60000000000000009, + 0.87266462599716477 }, + { 1.5079766673336394, -0.80000000000000004, 0.60000000000000009, + 1.0471975511965976 }, + { 2.0082747447038165, -0.80000000000000004, 0.60000000000000009, + 1.2217304763960306 }, + { 2.6315146066775523, -0.80000000000000004, 0.60000000000000009, + 1.3962634015954636 }, + { 3.3418121892288051, -0.80000000000000004, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler017 = 2.5000000000000020e-13; + +// Test data for k=-0.80000000000000004, nu=0.70000000000000007. +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.6544679145741375e-16 +// mean(f - f_Boost): 3.2751579226442120e-16 +// variance(f - f_Boost): 4.4236851331020672e-31 +// stddev(f - f_Boost): 6.6510789599147505e-16 +const testcase_ellint_3<double> +data018[10] = +{ + { 0.0000000000000000, -0.80000000000000004, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17635776076721221, -0.80000000000000004, 0.70000000000000007, + 0.17453292519943295 }, + { 0.36408794649916976, -0.80000000000000004, 0.70000000000000007, + 0.34906585039886590 }, + { 0.57679992290624138, -0.80000000000000004, 0.70000000000000007, + 0.52359877559829882 }, + { 0.83312441418142813, -0.80000000000000004, 0.70000000000000007, + 0.69813170079773179 }, + { 1.1603958891464856, -0.80000000000000004, 0.70000000000000007, + 0.87266462599716477 }, + { 1.5982855143796213, -0.80000000000000004, 0.70000000000000007, + 1.0471975511965976 }, + { 2.1962484408371821, -0.80000000000000004, 0.70000000000000007, + 1.2217304763960306 }, + { 2.9873281786111869, -0.80000000000000004, 0.70000000000000007, + 1.3962634015954636 }, + { 3.9268876980046397, -0.80000000000000004, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler018 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.80000000000000004. -testcase_ellint_3<double> data019[] = { - { -0.0000000000000000, -0.80000000000000004, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17370436817515206, -0.80000000000000004, 0.80000000000000004, - 0.17453292519943295 }, - { 0.34292405894783395, -0.80000000000000004, 0.80000000000000004, - 0.34906585039886590 }, - { 0.50520682176250087, -0.80000000000000004, 0.80000000000000004, - 0.52359877559829882 }, - { 0.66081751679736189, -0.80000000000000004, 0.80000000000000004, - 0.69813170079773179 }, - { 0.81214672249355102, -0.80000000000000004, 0.80000000000000004, - 0.87266462599716477 }, - { 0.96264481387685574, -0.80000000000000004, 0.80000000000000004, - 1.0471975511965976 }, - { 1.1156611352656258, -0.80000000000000004, 0.80000000000000004, - 1.2217304763960306 }, - { 1.2730756225143889, -0.80000000000000004, 0.80000000000000004, - 1.3962634015954636 }, - { 1.4339837018309474, -0.80000000000000004, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=-0.80000000000000004, nu=0.80000000000000004. -template <typename Tp> -void test019() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data019) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data019[i].k), Tp(data019[i].nu), - Tp(data019[i].phi)); - const Tp f0 = data019[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.0176949165011079e-16 +// mean(f - f_Boost): 7.0499162063697436e-16 +// variance(f - f_Boost): 1.7230805408026989e-30 +// stddev(f - f_Boost): 1.3126616246400665e-15 +const testcase_ellint_3<double> +data019[10] = +{ + { 0.0000000000000000, -0.80000000000000004, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17653987774203392, -0.80000000000000004, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36567072568046877, -0.80000000000000004, 0.80000000000000004, + 0.34906585039886590 }, + { 0.58295359996558616, -0.80000000000000004, 0.80000000000000004, + 0.52359877559829882 }, + { 0.85101998309176108, -0.80000000000000004, 0.80000000000000004, + 0.69813170079773179 }, + { 1.2062322059736537, -0.80000000000000004, 0.80000000000000004, + 0.87266462599716477 }, + { 1.7090321420917429, -0.80000000000000004, 0.80000000000000004, + 1.0471975511965976 }, + { 2.4529058049405066, -0.80000000000000004, 0.80000000000000004, + 1.2217304763960306 }, + { 3.5368893360106948, -0.80000000000000004, 0.80000000000000004, + 1.3962634015954636 }, + { 4.9246422058196062, -0.80000000000000004, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler019 = 2.5000000000000020e-13; // Test data for k=-0.80000000000000004, nu=0.90000000000000002. -testcase_ellint_3<double> data020[] = { - { -0.0000000000000000, -0.80000000000000004, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17353251158533153, -0.80000000000000004, 0.90000000000000002, - 0.17453292519943295 }, - { 0.34166214791545768, -0.80000000000000004, 0.90000000000000002, - 0.34906585039886590 }, - { 0.50144799535130580, -0.80000000000000004, 0.90000000000000002, - 0.52359877559829882 }, - { 0.65311976193814447, -0.80000000000000004, 0.90000000000000002, - 0.69813170079773179 }, - { 0.79924384892320866, -0.80000000000000004, 0.90000000000000002, - 0.87266462599716477 }, - { 0.94345762353365625, -0.80000000000000004, 0.90000000000000002, - 1.0471975511965976 }, - { 1.0892582069219159, -0.80000000000000004, 0.90000000000000002, - 1.2217304763960306 }, - { 1.2387000876610268, -0.80000000000000004, 0.90000000000000002, - 1.3962634015954636 }, - { 1.3911845406776222, -0.80000000000000004, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.80000000000000004, nu=0.90000000000000002. -template <typename Tp> -void test020() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data020) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data020[i].k), Tp(data020[i].nu), - Tp(data020[i].phi)); - const Tp f0 = data020[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.7782721357365268e-16 +// mean(f - f_Boost): 8.9928064994637676e-16 +// variance(f - f_Boost): 1.5485199571025344e-30 +// stddev(f - f_Boost): 1.2443954183066307e-15 +const testcase_ellint_3<double> +data020[10] = +{ + { 0.0000000000000000, -0.80000000000000004, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17672267223433513, -0.80000000000000004, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36727835537196063, -0.80000000000000004, 0.90000000000000002, + 0.34906585039886590 }, + { 0.58934569363716649, -0.80000000000000004, 0.90000000000000002, + 0.52359877559829882 }, + { 0.87032723471138851, -0.80000000000000004, 0.90000000000000002, + 0.69813170079773179 }, + { 1.2588676111323349, -0.80000000000000004, 0.90000000000000002, + 0.87266462599716477 }, + { 1.8498731900660019, -0.80000000000000004, 0.90000000000000002, + 1.0471975511965976 }, + { 2.8368381299300420, -0.80000000000000004, 0.90000000000000002, + 1.2217304763960306 }, + { 4.5674844191654058, -0.80000000000000004, 0.90000000000000002, + 1.3962634015954636 }, + { 7.2263259298637115, -0.80000000000000004, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler020 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.0000000000000000. -testcase_ellint_3<double> data021[] = { - { -0.0000000000000000, -0.69999999999999996, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17496737466916720, -0.69999999999999996, 0.0000000000000000, - 0.17453292519943295 }, - { 0.35254687535677925, -0.69999999999999996, 0.0000000000000000, - 0.34906585039886590 }, - { 0.53536740275997130, -0.69999999999999996, 0.0000000000000000, - 0.52359877559829882 }, - { 0.72603797651684465, -0.69999999999999996, 0.0000000000000000, - 0.69813170079773179 }, - { 0.92698296348313458, -0.69999999999999996, 0.0000000000000000, - 0.87266462599716477 }, - { 1.1400447527693316, -0.69999999999999996, 0.0000000000000000, - 1.0471975511965976 }, - { 1.3657668117194071, -0.69999999999999996, 0.0000000000000000, - 1.2217304763960306 }, - { 1.6024686895959159, -0.69999999999999996, 0.0000000000000000, - 1.3962634015954636 }, - { 1.8456939983747236, -0.69999999999999996, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.69999999999999996, nu=0.0000000000000000. -template <typename Tp> -void test021() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data021) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data021[i].k), Tp(data021[i].nu), - Tp(data021[i].phi)); - const Tp f0 = data021[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 5.5425633303580569e-16 +// mean(f - f_Boost): 7.7715611723760953e-17 +// variance(f - f_Boost): 7.4564398834547797e-34 +// stddev(f - f_Boost): 2.7306482533374340e-17 +const testcase_ellint_3<double> +data021[10] = +{ + { 0.0000000000000000, -0.69999999999999996, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17496737466916723, -0.69999999999999996, 0.0000000000000000, + 0.17453292519943295 }, + { 0.35254687535677931, -0.69999999999999996, 0.0000000000000000, + 0.34906585039886590 }, + { 0.53536740275997130, -0.69999999999999996, 0.0000000000000000, + 0.52359877559829882 }, + { 0.72603797651684454, -0.69999999999999996, 0.0000000000000000, + 0.69813170079773179 }, + { 0.92698296348313447, -0.69999999999999996, 0.0000000000000000, + 0.87266462599716477 }, + { 1.1400447527693316, -0.69999999999999996, 0.0000000000000000, + 1.0471975511965976 }, + { 1.3657668117194071, -0.69999999999999996, 0.0000000000000000, + 1.2217304763960306 }, + { 1.6024686895959162, -0.69999999999999996, 0.0000000000000000, + 1.3962634015954636 }, + { 1.8456939983747234, -0.69999999999999996, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler021 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.10000000000000001. -testcase_ellint_3<double> data022[] = { - { -0.0000000000000000, -0.69999999999999996, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17479076384884681, -0.69999999999999996, 0.10000000000000001, - 0.17453292519943295 }, - { 0.35114844900396364, -0.69999999999999996, 0.10000000000000001, - 0.34906585039886590 }, - { 0.53072776947527012, -0.69999999999999996, 0.10000000000000001, - 0.52359877559829882 }, - { 0.71530198262386246, -0.69999999999999996, 0.10000000000000001, - 0.69813170079773179 }, - { 0.90666760677828306, -0.69999999999999996, 0.10000000000000001, - 0.87266462599716477 }, - { 1.1063366517438080, -0.69999999999999996, 0.10000000000000001, - 1.0471975511965976 }, - { 1.3149477243092147, -0.69999999999999996, 0.10000000000000001, - 1.2217304763960306 }, - { 1.5314886725038925, -0.69999999999999996, 0.10000000000000001, - 1.3962634015954636 }, - { 1.7528050171757608, -0.69999999999999996, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.69999999999999996, nu=0.10000000000000001. -template <typename Tp> -void test022() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data022) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data022[i].k), Tp(data022[i].nu), - Tp(data022[i].phi)); - const Tp f0 = data022[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 5.2736371663370261e-16 +// mean(f - f_Boost): 8.8817841970012528e-17 +// variance(f - f_Boost): 9.7390235212470591e-34 +// stddev(f - f_Boost): 3.1207408609570677e-17 +const testcase_ellint_3<double> +data022[10] = +{ + { 0.0000000000000000, -0.69999999999999996, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17514462737300920, -0.69999999999999996, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35396527997470451, -0.69999999999999996, 0.10000000000000001, + 0.34906585039886590 }, + { 0.54015179589433981, -0.69999999999999996, 0.10000000000000001, + 0.52359877559829882 }, + { 0.73734430854477728, -0.69999999999999996, 0.10000000000000001, + 0.69813170079773179 }, + { 0.94888950796697047, -0.69999999999999996, 0.10000000000000001, + 0.87266462599716477 }, + { 1.1772807959736322, -0.69999999999999996, 0.10000000000000001, + 1.0471975511965976 }, + { 1.4231796401075831, -0.69999999999999996, 0.10000000000000001, + 1.2217304763960306 }, + { 1.6841856799887469, -0.69999999999999996, 0.10000000000000001, + 1.3962634015954636 }, + { 1.9541347343119562, -0.69999999999999996, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler022 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.20000000000000001. -testcase_ellint_3<double> data023[] = { - { -0.0000000000000000, -0.69999999999999996, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17461479077791472, -0.69999999999999996, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34976950621407538, -0.69999999999999996, 0.20000000000000001, - 0.34906585039886590 }, - { 0.52622533231350188, -0.69999999999999996, 0.20000000000000001, - 0.52359877559829882 }, - { 0.70508774017895226, -0.69999999999999996, 0.20000000000000001, - 0.69813170079773179 }, - { 0.88775302531730294, -0.69999999999999996, 0.20000000000000001, - 0.87266462599716477 }, - { 1.0756195476149006, -0.69999999999999996, 0.20000000000000001, - 1.0471975511965976 }, - { 1.2695349716654372, -0.69999999999999996, 0.20000000000000001, - 1.2217304763960306 }, - { 1.4690814617070540, -0.69999999999999996, 0.20000000000000001, - 1.3962634015954636 }, - { 1.6721098780092147, -0.69999999999999996, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.69999999999999996, nu=0.20000000000000001. -template <typename Tp> -void test023() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data023) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data023[i].k), Tp(data023[i].nu), - Tp(data023[i].phi)); - const Tp f0 = data023[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.69999999999999996, nu=0.29999999999999999. -testcase_ellint_3<double> data024[] = { - { -0.0000000000000000, -0.69999999999999996, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17443945136076172, -0.69999999999999996, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34840956983535287, -0.69999999999999996, 0.29999999999999999, - 0.34906585039886590 }, - { 0.52185308551329179, -0.69999999999999996, 0.29999999999999999, - 0.52359877559829882 }, - { 0.69535240431168266, -0.69999999999999996, 0.29999999999999999, - 0.69813170079773179 }, - { 0.87007983473964923, -0.69999999999999996, 0.29999999999999999, - 0.87266462599716477 }, - { 1.0474657975577066, -0.69999999999999996, 0.29999999999999999, - 1.0471975511965976 }, - { 1.2286225419931889, -0.69999999999999996, 0.29999999999999999, - 1.2217304763960306 }, - { 1.4136490671013271, -0.69999999999999996, 0.29999999999999999, - 1.3962634015954636 }, - { 1.6011813647733213, -0.69999999999999996, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=-0.69999999999999996, nu=0.29999999999999999. -template <typename Tp> -void test024() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data024) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data024[i].k), Tp(data024[i].nu), - Tp(data024[i].phi)); - const Tp f0 = data024[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.9907249355047774e-16 +// mean(f - f_Boost): 3.3306690738754695e-17 +// variance(f - f_Boost): 1.3695501826753678e-34 +// stddev(f - f_Boost): 1.1702778228589003e-17 +const testcase_ellint_3<double> +data023[10] = +{ + { 0.0000000000000000, -0.69999999999999996, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17532252613350796, -0.69999999999999996, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35540417596807522, -0.69999999999999996, 0.20000000000000001, + 0.34906585039886590 }, + { 0.54508913033361928, -0.69999999999999996, 0.20000000000000001, + 0.52359877559829882 }, + { 0.74927635777718415, -0.69999999999999996, 0.20000000000000001, + 0.69813170079773179 }, + { 0.97261706337936338, -0.69999999999999996, 0.20000000000000001, + 0.87266462599716477 }, + { 1.2187303976209327, -0.69999999999999996, 0.20000000000000001, + 1.0471975511965976 }, + { 1.4887796709222487, -0.69999999999999996, 0.20000000000000001, + 1.2217304763960306 }, + { 1.7796581281839212, -0.69999999999999996, 0.20000000000000001, + 1.3962634015954636 }, + { 2.0829290325820202, -0.69999999999999996, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler023 = 2.5000000000000020e-13; + +// Test data for k=-0.69999999999999996, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.6912897610535316e-16 +// mean(f - f_Boost): 1.6653345369377347e-17 +// variance(f - f_Boost): 2.6207864467918357e-32 +// stddev(f - f_Boost): 1.6188843216214787e-16 +const testcase_ellint_3<double> +data024[10] = +{ + { 0.0000000000000000, -0.69999999999999996, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17550107516328570, -0.69999999999999996, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35686409576571959, -0.69999999999999996, 0.30000000000000004, + 0.34906585039886590 }, + { 0.55018827316513352, -0.69999999999999996, 0.30000000000000004, + 0.52359877559829882 }, + { 0.76189759494390275, -0.69999999999999996, 0.30000000000000004, + 0.69813170079773179 }, + { 0.99844623430885615, -0.69999999999999996, 0.30000000000000004, + 0.87266462599716477 }, + { 1.2652862989039833, -0.69999999999999996, 0.30000000000000004, + 1.0471975511965976 }, + { 1.5647666808691361, -0.69999999999999996, 0.30000000000000004, + 1.2217304763960306 }, + { 1.8932499694938163, -0.69999999999999996, 0.30000000000000004, + 1.3962634015954636 }, + { 2.2392290510988535, -0.69999999999999996, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler024 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.40000000000000002. -testcase_ellint_3<double> data025[] = { - { -0.0000000000000000, -0.69999999999999996, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17426474153983226, -0.69999999999999996, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34706817945773732, -0.69999999999999996, 0.40000000000000002, - 0.34906585039886590 }, - { 0.51760452851738159, -0.69999999999999996, 0.40000000000000002, - 0.52359877559829882 }, - { 0.68605801534722766, -0.69999999999999996, 0.40000000000000002, - 0.69813170079773179 }, - { 0.85351339387296532, -0.69999999999999996, 0.40000000000000002, - 0.87266462599716477 }, - { 1.0215297967969537, -0.69999999999999996, 0.40000000000000002, - 1.0471975511965976 }, - { 1.1915051074460528, -0.69999999999999996, 0.40000000000000002, - 1.2217304763960306 }, - { 1.3639821911744707, -0.69999999999999996, 0.40000000000000002, - 1.3962634015954636 }, - { 1.5382162002954762, -0.69999999999999996, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.69999999999999996, nu=0.40000000000000002. -template <typename Tp> -void test025() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data025) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data025[i].k), Tp(data025[i].nu), - Tp(data025[i].phi)); - const Tp f0 = data025[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 6.5578567644745380e-16 +// mean(f - f_Boost): 1.4710455076283324e-16 +// variance(f - f_Boost): 2.6715739327327140e-33 +// stddev(f - f_Boost): 5.1687270509601433e-17 +const testcase_ellint_3<double> +data025[10] = +{ + { 0.0000000000000000, -0.69999999999999996, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17568027871494424, -0.69999999999999996, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35834559208180261, -0.69999999999999996, 0.40000000000000002, + 0.34906585039886590 }, + { 0.55545885451190613, -0.69999999999999996, 0.40000000000000002, + 0.52359877559829882 }, + { 0.77528120402568101, -0.69999999999999996, 0.40000000000000002, + 0.69813170079773179 }, + { 1.0267241287600319, -0.69999999999999996, 0.40000000000000002, + 0.87266462599716477 }, + { 1.3181380338980246, -0.69999999999999996, 0.40000000000000002, + 1.0471975511965976 }, + { 1.6542840785132085, -0.69999999999999996, 0.40000000000000002, + 1.2217304763960306 }, + { 2.0315595131131818, -0.69999999999999996, 0.40000000000000002, + 1.3962634015954636 }, + { 2.4342502915307875, -0.69999999999999996, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler025 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.50000000000000000. -testcase_ellint_3<double> data026[] = { - { -0.0000000000000000, -0.69999999999999996, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17409065729516093, -0.69999999999999996, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34574489064986091, -0.69999999999999996, 0.50000000000000000, - 0.34906585039886590 }, - { 0.51347361925579793, -0.69999999999999996, 0.50000000000000000, - 0.52359877559829882 }, - { 0.67717079489579290, -0.69999999999999996, 0.50000000000000000, - 0.69813170079773179 }, - { 0.83793902055292280, -0.69999999999999996, 0.50000000000000000, - 0.87266462599716477 }, - { 0.99752863545289705, -0.69999999999999996, 0.50000000000000000, - 1.0471975511965976 }, - { 1.1576240080401499, -0.69999999999999996, 0.50000000000000000, - 1.2217304763960306 }, - { 1.3191464023923762, -0.69999999999999996, 0.50000000000000000, - 1.3962634015954636 }, - { 1.4818433192178544, -0.69999999999999996, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.69999999999999996, nu=0.50000000000000000. -template <typename Tp> -void test026() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data026) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data026[i].k), Tp(data026[i].nu), - Tp(data026[i].phi)); - const Tp f0 = data026[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.69999999999999996, nu=0.59999999999999998. -testcase_ellint_3<double> data027[] = { - { -0.0000000000000000, -0.69999999999999996, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17391719464391611, -0.69999999999999996, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34443927423869031, -0.69999999999999996, 0.59999999999999998, - 0.34906585039886590 }, - { 0.50945473266486074, -0.69999999999999996, 0.59999999999999998, - 0.52359877559829882 }, - { 0.66866056326513823, -0.69999999999999996, 0.59999999999999998, - 0.69813170079773179 }, - { 0.82325830002337352, -0.69999999999999996, 0.59999999999999998, - 0.87266462599716477 }, - { 0.97522808245669357, -0.69999999999999996, 0.59999999999999998, - 1.0471975511965976 }, - { 1.1265300613705282, -0.69999999999999996, 0.59999999999999998, - 1.2217304763960306 }, - { 1.2784066076152003, -0.69999999999999996, 0.59999999999999998, - 1.3962634015954636 }, - { 1.4309994736080540, -0.69999999999999996, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=-0.69999999999999996, nu=0.59999999999999998. -template <typename Tp> -void test027() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data027) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data027[i].k), Tp(data027[i].nu), - Tp(data027[i].phi)); - const Tp f0 = data027[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.69999999999999996, nu=0.69999999999999996. -testcase_ellint_3<double> data028[] = { - { -0.0000000000000000, -0.69999999999999996, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17374434963995028, -0.69999999999999996, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34315091562900674, -0.69999999999999996, 0.69999999999999996, - 0.34906585039886590 }, - { 0.50554262375653358, -0.69999999999999996, 0.69999999999999996, - 0.52359877559829882 }, - { 0.66050025406305812, -0.69999999999999996, 0.69999999999999996, - 0.69813170079773179 }, - { 0.80938620118847404, -0.69999999999999996, 0.69999999999999996, - 0.87266462599716477 }, - { 0.95443223855852144, -0.69999999999999996, 0.69999999999999996, - 1.0471975511965976 }, - { 1.0978573207128302, -0.69999999999999996, 0.69999999999999996, - 1.2217304763960306 }, - { 1.2411754575007123, -0.69999999999999996, 0.69999999999999996, - 1.3962634015954636 }, - { 1.3848459188329196, -0.69999999999999996, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=-0.69999999999999996, nu=0.69999999999999996. -template <typename Tp> -void test028() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data028) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data028[i].k), Tp(data028[i].nu), - Tp(data028[i].phi)); - const Tp f0 = data028[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 6.0416041815443256e-16 +// mean(f - f_Boost): 1.9151347174783951e-16 +// variance(f - f_Boost): 7.8758646268991113e-33 +// stddev(f - f_Boost): 8.8746068233466605e-17 +const testcase_ellint_3<double> +data026[10] = +{ + { 0.0000000000000000, -0.69999999999999996, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17586014108156545, -0.69999999999999996, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35984923894341653, -0.69999999999999996, 0.50000000000000000, + 0.34906585039886590 }, + { 0.56091135606739995, -0.69999999999999996, 0.50000000000000000, + 0.52359877559829882 }, + { 0.78951212635197054, -0.69999999999999996, 0.50000000000000000, + 0.69813170079773179 }, + { 1.0578865732938729, -0.69999999999999996, 0.50000000000000000, + 0.87266462599716477 }, + { 1.3789149005151722, -0.69999999999999996, 0.50000000000000000, + 1.0471975511965976 }, + { 1.7620212286086225, -0.69999999999999996, 0.50000000000000000, + 1.2217304763960306 }, + { 2.2051554347435585, -0.69999999999999996, 0.50000000000000000, + 1.3962634015954636 }, + { 2.6868019968236991, -0.69999999999999996, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler026 = 2.5000000000000020e-13; + +// Test data for k=-0.69999999999999996, nu=0.60000000000000009. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.6515644573247170e-16 +// mean(f - f_Boost): 9.9920072216264091e-17 +// variance(f - f_Boost): 1.2325951644078310e-33 +// stddev(f - f_Boost): 3.5108334685767011e-17 +const testcase_ellint_3<double> +data027[10] = +{ + { 0.0000000000000000, -0.69999999999999996, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17604066659721918, -0.69999999999999996, 0.60000000000000009, + 0.17453292519943295 }, + { 0.36137563278353424, -0.69999999999999996, 0.60000000000000009, + 0.34906585039886590 }, + { 0.56655721272747606, -0.69999999999999996, 0.60000000000000009, + 0.52359877559829882 }, + { 0.80468966552978305, -0.69999999999999996, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0924902943683852, -0.69999999999999996, 0.60000000000000009, + 0.87266462599716477 }, + { 1.4499247992499797, -0.69999999999999996, 0.60000000000000009, + 1.0471975511965976 }, + { 1.8953714382113815, -0.69999999999999996, 0.60000000000000009, + 1.2217304763960306 }, + { 2.4323229949248670, -0.69999999999999996, 0.60000000000000009, + 1.3962634015954636 }, + { 3.0314573496746742, -0.69999999999999996, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler027 = 2.5000000000000020e-13; + +// Test data for k=-0.69999999999999996, nu=0.70000000000000007. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.8475278552871384e-16 +// mean(f - f_Boost): 9.9920072216264091e-17 +// variance(f - f_Boost): 1.2325951644078310e-33 +// stddev(f - f_Boost): 3.5108334685767011e-17 +const testcase_ellint_3<double> +data028[10] = +{ + { 0.0000000000000000, -0.69999999999999996, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17622185963747933, -0.69999999999999996, 0.70000000000000007, + 0.17453292519943295 }, + { 0.36292539360435261, -0.69999999999999996, 0.70000000000000007, + 0.34906585039886590 }, + { 0.57240892970150015, -0.69999999999999996, 0.70000000000000007, + 0.52359877559829882 }, + { 0.82093084713182629, -0.69999999999999996, 0.70000000000000007, + 0.69813170079773179 }, + { 1.1312609022179871, -0.69999999999999996, 0.70000000000000007, + 0.87266462599716477 }, + { 1.5345768067715795, -0.69999999999999996, 0.70000000000000007, + 1.0471975511965976 }, + { 2.0668847445934420, -0.69999999999999996, 0.70000000000000007, + 1.2217304763960306 }, + { 2.7483444537551240, -0.69999999999999996, 0.70000000000000007, + 1.3962634015954636 }, + { 3.5408408771788560, -0.69999999999999996, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler028 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.80000000000000004. -testcase_ellint_3<double> data029[] = { - { -0.0000000000000000, -0.69999999999999996, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17357211837335737, -0.69999999999999996, 0.80000000000000004, - 0.17453292519943295 }, - { 0.34187941416012108, -0.69999999999999996, 0.80000000000000004, - 0.34906585039886590 }, - { 0.50173239465478270, -0.69999999999999996, 0.80000000000000004, - 0.52359877559829882 }, - { 0.65266550725988315, -0.69999999999999996, 0.80000000000000004, - 0.69813170079773179 }, - { 0.79624879865249298, -0.69999999999999996, 0.80000000000000004, - 0.87266462599716477 }, - { 0.93497577043296920, -0.69999999999999996, 0.80000000000000004, - 1.0471975511965976 }, - { 1.0713041566930748, -0.69999999999999996, 0.80000000000000004, - 1.2217304763960306 }, - { 1.2069772023255652, -0.69999999999999996, 0.80000000000000004, - 1.3962634015954636 }, - { 1.3427110650397533, -0.69999999999999996, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=-0.69999999999999996, nu=0.80000000000000004. -template <typename Tp> -void test029() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data029) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data029[i].k), Tp(data029[i].nu), - Tp(data029[i].phi)); - const Tp f0 = data029[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 6.8664526853112274e-16 +// mean(f - f_Boost): 1.6930901125533636e-16 +// variance(f - f_Boost): 3.5389557150937801e-33 +// stddev(f - f_Boost): 5.9489122661994095e-17 +const testcase_ellint_3<double> +data029[10] = +{ + { 0.0000000000000000, -0.69999999999999996, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17640372461994805, -0.69999999999999996, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36449916621651091, -0.69999999999999996, 0.80000000000000004, + 0.34906585039886590 }, + { 0.57848021800372573, -0.69999999999999996, 0.80000000000000004, + 0.52359877559829882 }, + { 0.83837480968392586, -0.69999999999999996, 0.80000000000000004, + 0.69813170079773179 }, + { 1.1751669030061143, -0.69999999999999996, 0.80000000000000004, + 0.87266462599716477 }, + { 1.6381851899173601, -0.69999999999999996, 0.80000000000000004, + 1.0471975511965976 }, + { 2.3002065924302197, -0.69999999999999996, 0.80000000000000004, + 1.2217304763960306 }, + { 3.2337600665337862, -0.69999999999999996, 0.80000000000000004, + 1.3962634015954636 }, + { 4.4042405729076961, -0.69999999999999996, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler029 = 2.5000000000000020e-13; // Test data for k=-0.69999999999999996, nu=0.90000000000000002. -testcase_ellint_3<double> data030[] = { - { -0.0000000000000000, -0.69999999999999996, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17340049697003634, -0.69999999999999996, 0.90000000000000002, - 0.17453292519943295 }, - { 0.34062438249741556, -0.69999999999999996, 0.90000000000000002, - 0.34906585039886590 }, - { 0.49801946510076878, -0.69999999999999996, 0.90000000000000002, - 0.52359877559829882 }, - { 0.64513432604750487, -0.69999999999999996, 0.90000000000000002, - 0.69813170079773179 }, - { 0.78378145487573758, -0.69999999999999996, 0.90000000000000002, - 0.87266462599716477 }, - { 0.91671799500854634, -0.69999999999999996, 0.90000000000000002, - 1.0471975511965976 }, - { 1.0466193579463123, -0.69999999999999996, 0.90000000000000002, - 1.2217304763960306 }, - { 1.1754218079199146, -0.69999999999999996, 0.90000000000000002, - 1.3962634015954636 }, - { 1.3040500499695911, -0.69999999999999996, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.69999999999999996, nu=0.90000000000000002. -template <typename Tp> -void test030() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data030) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data030[i].k), Tp(data030[i].nu), - Tp(data030[i].phi)); - const Tp f0 = data030[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 3.5527136788005009e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 8.5869439826269878e-16 +// mean(f - f_Boost): 6.7723604502134545e-16 +// variance(f - f_Boost): 4.8757508225668289e-31 +// stddev(f - f_Boost): 6.9826576763914390e-16 +const testcase_ellint_3<double> +data030[10] = +{ + { 0.0000000000000000, -0.69999999999999996, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17658626600478800, -0.69999999999999996, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36609762156017206, -0.69999999999999996, 0.90000000000000002, + 0.34906585039886590 }, + { 0.58478615187842409, -0.69999999999999996, 0.90000000000000002, + 0.52359877559829882 }, + { 0.85718862878291846, -0.69999999999999996, 0.90000000000000002, + 0.69813170079773179 }, + { 1.2255385617397643, -0.69999999999999996, 0.90000000000000002, + 0.87266462599716477 }, + { 1.7696521899992939, -0.69999999999999996, 0.90000000000000002, + 1.0471975511965976 }, + { 2.6476314987883502, -0.69999999999999996, 0.90000000000000002, + 1.2217304763960306 }, + { 4.1373434902898083, -0.69999999999999996, 0.90000000000000002, + 1.3962634015954636 }, + { 6.3796094177887746, -0.69999999999999996, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler030 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.0000000000000000. -testcase_ellint_3<double> data031[] = { - { -0.0000000000000000, -0.59999999999999998, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17485154362988362, -0.59999999999999998, 0.0000000000000000, - 0.17453292519943295 }, - { 0.35160509865544326, -0.59999999999999998, 0.0000000000000000, - 0.34906585039886590 }, - { 0.53210652578446160, -0.59999999999999998, 0.0000000000000000, - 0.52359877559829882 }, - { 0.71805304664485670, -0.59999999999999998, 0.0000000000000000, - 0.69813170079773179 }, - { 0.91082759030195970, -0.59999999999999998, 0.0000000000000000, - 0.87266462599716477 }, - { 1.1112333229323361, -0.59999999999999998, 0.0000000000000000, - 1.0471975511965976 }, - { 1.3191461190365270, -0.59999999999999998, 0.0000000000000000, - 1.2217304763960306 }, - { 1.5332022105084773, -0.59999999999999998, 0.0000000000000000, - 1.3962634015954636 }, - { 1.7507538029157526, -0.59999999999999998, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.59999999999999998, nu=0.0000000000000000. -template <typename Tp> -void test031() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data031) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data031[i].k), Tp(data031[i].nu), - Tp(data031[i].phi)); - const Tp f0 = data031[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.3664899092028927e-16 +// mean(f - f_Boost): 5.2735593669694933e-17 +// variance(f - f_Boost): 3.4333862218458872e-34 +// stddev(f - f_Boost): 1.8529398861932589e-17 +const testcase_ellint_3<double> +data031[10] = +{ + { 0.0000000000000000, -0.59999999999999998, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17485154362988359, -0.59999999999999998, 0.0000000000000000, + 0.17453292519943295 }, + { 0.35160509865544320, -0.59999999999999998, 0.0000000000000000, + 0.34906585039886590 }, + { 0.53210652578446138, -0.59999999999999998, 0.0000000000000000, + 0.52359877559829882 }, + { 0.71805304664485659, -0.59999999999999998, 0.0000000000000000, + 0.69813170079773179 }, + { 0.91082759030195981, -0.59999999999999998, 0.0000000000000000, + 0.87266462599716477 }, + { 1.1112333229323361, -0.59999999999999998, 0.0000000000000000, + 1.0471975511965976 }, + { 1.3191461190365270, -0.59999999999999998, 0.0000000000000000, + 1.2217304763960306 }, + { 1.5332022105084779, -0.59999999999999998, 0.0000000000000000, + 1.3962634015954636 }, + { 1.7507538029157523, -0.59999999999999998, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler031 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.10000000000000001. -testcase_ellint_3<double> data032[] = { - { -0.0000000000000000, -0.59999999999999998, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17467514275022014, -0.59999999999999998, 0.10000000000000001, - 0.17453292519943295 }, - { 0.35021333086258255, -0.59999999999999998, 0.10000000000000001, - 0.34906585039886590 }, - { 0.52751664092962713, -0.59999999999999998, 0.10000000000000001, - 0.52359877559829882 }, - { 0.70752126971957885, -0.59999999999999998, 0.10000000000000001, - 0.69813170079773179 }, - { 0.89111058756112871, -0.59999999999999998, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0789241202877768, -0.59999999999999998, 0.10000000000000001, - 1.0471975511965976 }, - { 1.2710800210399946, -0.59999999999999998, 0.10000000000000001, - 1.2217304763960306 }, - { 1.4669060574440276, -0.59999999999999998, 0.10000000000000001, - 1.3962634015954636 }, - { 1.6648615773343014, -0.59999999999999998, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.59999999999999998, nu=0.10000000000000001. -template <typename Tp> -void test032() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data032) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data032[i].k), Tp(data032[i].nu), - Tp(data032[i].phi)); - const Tp f0 = data032[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.2335247010355137e-16 +// mean(f - f_Boost): 8.6042284408449634e-17 +// variance(f - f_Boost): 2.2835347143080263e-33 +// stddev(f - f_Boost): 4.7786344433405099e-17 +const testcase_ellint_3<double> +data032[10] = +{ + { 0.0000000000000000, -0.59999999999999998, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17502858548476194, -0.59999999999999998, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35301673150537388, -0.59999999999999998, 0.10000000000000001, + 0.34906585039886590 }, + { 0.53683932476326812, -0.59999999999999998, 0.10000000000000001, + 0.52359877559829882 }, + { 0.72914228589586771, -0.59999999999999998, 0.10000000000000001, + 0.69813170079773179 }, + { 0.93208036718354692, -0.59999999999999998, 0.10000000000000001, + 0.87266462599716477 }, + { 1.1468984688863377, -0.59999999999999998, 0.10000000000000001, + 1.0471975511965976 }, + { 1.3733904977062528, -0.59999999999999998, 0.10000000000000001, + 1.2217304763960306 }, + { 1.6094225663372157, -0.59999999999999998, 0.10000000000000001, + 1.3962634015954636 }, + { 1.8508766487100685, -0.59999999999999998, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler032 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.20000000000000001. -testcase_ellint_3<double> data033[] = { - { -0.0000000000000000, -0.59999999999999998, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17449937871800653, -0.59999999999999998, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34884093647346553, -0.59999999999999998, 0.20000000000000001, - 0.34906585039886590 }, - { 0.52306221119844110, -0.59999999999999998, 0.20000000000000001, - 0.52359877559829882 }, - { 0.69749955678982223, -0.59999999999999998, 0.20000000000000001, - 0.69813170079773179 }, - { 0.87274610682416853, -0.59999999999999998, 0.20000000000000001, - 0.87266462599716477 }, - { 1.0494620540750792, -0.59999999999999998, 0.20000000000000001, - 1.0471975511965976 }, - { 1.2280847305507339, -0.59999999999999998, 0.20000000000000001, - 1.2217304763960306 }, - { 1.4085436279696886, -0.59999999999999998, 0.20000000000000001, - 1.3962634015954636 }, - { 1.5901418016279374, -0.59999999999999998, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.59999999999999998, nu=0.20000000000000001. -template <typename Tp> -void test033() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data033) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data033[i].k), Tp(data033[i].nu), - Tp(data033[i].phi)); - const Tp f0 = data033[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.59999999999999998, nu=0.29999999999999999. -testcase_ellint_3<double> data034[] = { - { -0.0000000000000000, -0.59999999999999998, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17432424744393935, -0.59999999999999998, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34748744127146447, -0.59999999999999998, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51873632743924847, -0.59999999999999998, 0.29999999999999999, - 0.52359877559829882 }, - { 0.68794610396313127, -0.59999999999999998, 0.29999999999999999, - 0.69813170079773179 }, - { 0.85558070175468726, -0.59999999999999998, 0.29999999999999999, - 0.87266462599716477 }, - { 1.0224416343605653, -0.59999999999999998, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1893144457936788, -0.59999999999999998, 0.29999999999999999, - 1.2217304763960306 }, - { 1.3566435377982575, -0.59999999999999998, 0.29999999999999999, - 1.3962634015954636 }, - { 1.5243814243493585, -0.59999999999999998, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=-0.59999999999999998, nu=0.29999999999999999. -template <typename Tp> -void test034() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data034) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data034[i].k), Tp(data034[i].nu), - Tp(data034[i].phi)); - const Tp f0 = data034[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.0940560416437693e-16 +// mean(f - f_Boost): 4.1633363423443370e-17 +// variance(f - f_Boost): 8.5834655546147173e-33 +// stddev(f - f_Boost): 9.2646994309662939e-17 +const testcase_ellint_3<double> +data033[10] = +{ + { 0.0000000000000000, -0.59999999999999998, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17520627248155893, -0.59999999999999998, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35444873935437748, -0.59999999999999998, 0.20000000000000001, + 0.34906585039886590 }, + { 0.54172310557682524, -0.59999999999999998, 0.20000000000000001, + 0.52359877559829882 }, + { 0.74084300280734672, -0.59999999999999998, 0.20000000000000001, + 0.69813170079773179 }, + { 0.95509001527006121, -0.59999999999999998, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1865688084431796, -0.59999999999999998, 0.20000000000000001, + 1.0471975511965976 }, + { 1.4352978868932598, -0.59999999999999998, 0.20000000000000001, + 1.2217304763960306 }, + { 1.6983400371331816, -0.59999999999999998, 0.20000000000000001, + 1.3962634015954636 }, + { 1.9695980282802215, -0.59999999999999998, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler033 = 2.5000000000000020e-13; + +// Test data for k=-0.59999999999999998, nu=0.30000000000000004. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.9470074709717020e-16 +// mean(f - f_Boost): 7.4940054162198071e-17 +// variance(f - f_Boost): 1.6823592487044846e-32 +// stddev(f - f_Boost): 1.2970579203352812e-16 +const testcase_ellint_3<double> +data034[10] = +{ + { 0.0000000000000000, -0.59999999999999998, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17538460882640122, -0.59999999999999998, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35590165133735557, -0.59999999999999998, 0.30000000000000004, + 0.34906585039886590 }, + { 0.54676661152254535, -0.59999999999999998, 0.30000000000000004, + 0.52359877559829882 }, + { 0.75321709418305305, -0.59999999999999998, 0.30000000000000004, + 0.69813170079773179 }, + { 0.98012637808992920, -0.59999999999999998, 0.30000000000000004, + 0.87266462599716477 }, + { 1.2310891277158875, -0.59999999999999998, 0.30000000000000004, + 1.0471975511965976 }, + { 1.5069157924585623, -0.59999999999999998, 0.30000000000000004, + 1.2217304763960306 }, + { 1.8039583598337940, -0.59999999999999998, 0.30000000000000004, + 1.3962634015954636 }, + { 2.1134154405060599, -0.59999999999999998, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler034 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.40000000000000002. -testcase_ellint_3<double> data035[] = { - { -0.0000000000000000, -0.59999999999999998, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17414974487670720, -0.59999999999999998, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34615238767335027, -0.59999999999999998, 0.40000000000000002, - 0.34906585039886590 }, - { 0.51453257838108579, -0.59999999999999998, 0.40000000000000002, - 0.52359877559829882 }, - { 0.67882386787534410, -0.59999999999999998, 0.40000000000000002, - 0.69813170079773179 }, - { 0.83948470233173578, -0.59999999999999998, 0.40000000000000002, - 0.87266462599716477 }, - { 0.99753496200073977, -0.59999999999999998, 0.40000000000000002, - 1.0471975511965976 }, - { 1.1541101404388487, -0.59999999999999998, 0.40000000000000002, - 1.2217304763960306 }, - { 1.3100911323398814, -0.59999999999999998, 0.40000000000000002, - 1.3962634015954636 }, - { 1.4659345278069984, -0.59999999999999998, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.59999999999999998, nu=0.40000000000000002. -template <typename Tp> -void test035() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data035) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data035[i].k), Tp(data035[i].nu), - Tp(data035[i].phi)); - const Tp f0 = data035[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.7909659715991921e-16 +// mean(f - f_Boost): -2.7755575615628915e-18 +// variance(f - f_Boost): 2.4044165394594425e-32 +// stddev(f - f_Boost): 1.5506181152880429e-16 +const testcase_ellint_3<double> +data035[10] = +{ + { 0.0000000000000000, -0.59999999999999998, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17556359876533037, -0.59999999999999998, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35737601674244679, -0.59999999999999998, 0.40000000000000002, + 0.34906585039886590 }, + { 0.55197933771320218, -0.59999999999999998, 0.40000000000000002, + 0.52359877559829882 }, + { 0.76633591620002894, -0.59999999999999998, 0.40000000000000002, + 0.69813170079773179 }, + { 1.0075231136019616, -0.59999999999999998, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2815842073813450, -0.59999999999999998, 0.40000000000000002, + 1.0471975511965976 }, + { 1.5911666941449827, -0.59999999999999998, 0.40000000000000002, + 1.2217304763960306 }, + { 1.9323227566025762, -0.59999999999999998, 0.40000000000000002, + 1.3962634015954636 }, + { 2.2925036420985130, -0.59999999999999998, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler035 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.50000000000000000. -testcase_ellint_3<double> data036[] = { - { -0.0000000000000000, -0.59999999999999998, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17397586700252810, -0.59999999999999998, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34483533397138516, -0.59999999999999998, 0.50000000000000000, - 0.34906585039886590 }, - { 0.51044500461706499, -0.59999999999999998, 0.50000000000000000, - 0.52359877559829882 }, - { 0.67009988034712675, -0.59999999999999998, 0.50000000000000000, - 0.69813170079773179 }, - { 0.82434762375735193, -0.59999999999999998, 0.50000000000000000, - 0.87266462599716477 }, - { 0.97447346702798998, -0.59999999999999998, 0.50000000000000000, - 1.0471975511965976 }, - { 1.1219494000522143, -0.59999999999999998, 0.50000000000000000, - 1.2217304763960306 }, - { 1.2680242605954486, -0.59999999999999998, 0.50000000000000000, - 1.3962634015954636 }, - { 1.4135484285693078, -0.59999999999999998, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.59999999999999998, nu=0.50000000000000000. -template <typename Tp> -void test036() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data036) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data036[i].k), Tp(data036[i].nu), - Tp(data036[i].phi)); - const Tp f0 = data036[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.59999999999999998, nu=0.59999999999999998. -testcase_ellint_3<double> data037[] = { - { -0.0000000000000000, -0.59999999999999998, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17380260984469356, -0.59999999999999998, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34353585361777839, -0.59999999999999998, 0.59999999999999998, - 0.34906585039886590 }, - { 0.50646805774321402, -0.59999999999999998, 0.59999999999999998, - 0.52359877559829882 }, - { 0.66174468108625517, -0.59999999999999998, 0.59999999999999998, - 0.69813170079773179 }, - { 0.81007462280278408, -0.59999999999999998, 0.59999999999999998, - 0.87266462599716477 }, - { 0.95303466945718729, -0.59999999999999998, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0924118588677503, -0.59999999999999998, 0.59999999999999998, - 1.2217304763960306 }, - { 1.2297640574847937, -0.59999999999999998, 0.59999999999999998, - 1.3962634015954636 }, - { 1.3662507535812816, -0.59999999999999998, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=-0.59999999999999998, nu=0.59999999999999998. -template <typename Tp> -void test037() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data037) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data037[i].k), Tp(data037[i].nu), - Tp(data037[i].phi)); - const Tp f0 = data037[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.59999999999999998, nu=0.69999999999999996. -testcase_ellint_3<double> data038[] = { - { -0.0000000000000000, -0.59999999999999998, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17362996946312009, -0.59999999999999998, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34225353454870588, -0.59999999999999998, 0.69999999999999996, - 0.34906585039886590 }, - { 0.50259656397799546, -0.59999999999999998, 0.69999999999999996, - 0.52359877559829882 }, - { 0.65373184496628944, -0.59999999999999998, 0.69999999999999996, - 0.69813170079773179 }, - { 0.79658372884056439, -0.59999999999999998, 0.69999999999999996, - 0.87266462599716477 }, - { 0.93303240100245421, -0.59999999999999998, 0.69999999999999996, - 1.0471975511965976 }, - { 1.0651547944716557, -0.59999999999999998, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1947676204853441, -0.59999999999999998, 0.69999999999999996, - 1.3962634015954636 }, - { 1.3232737468822811, -0.59999999999999998, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=-0.59999999999999998, nu=0.69999999999999996. -template <typename Tp> -void test038() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data038) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data038[i].k), Tp(data038[i].nu), - Tp(data038[i].phi)); - const Tp f0 = data038[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.6240126899196213e-16 +// mean(f - f_Boost): 9.1593399531575410e-17 +// variance(f - f_Boost): 1.0357223256482469e-33 +// stddev(f - f_Boost): 3.2182640128619758e-17 +const testcase_ellint_3<double> +data036[10] = +{ + { 0.0000000000000000, -0.59999999999999998, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17574324658480217, -0.59999999999999998, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35887240603169313, -0.59999999999999998, 0.50000000000000000, + 0.34906585039886590 }, + { 0.55737161826345261, -0.59999999999999998, 0.50000000000000000, + 0.52359877559829882 }, + { 0.78028227313077458, -0.59999999999999998, 0.50000000000000000, + 0.69813170079773179 }, + { 1.0376989776486290, -0.59999999999999998, 0.50000000000000000, + 0.87266462599716477 }, + { 1.3395933991042925, -0.59999999999999998, 0.50000000000000000, + 1.0471975511965976 }, + { 1.6924049626591782, -0.59999999999999998, 0.50000000000000000, + 1.2217304763960306 }, + { 2.0931011856518920, -0.59999999999999998, 0.50000000000000000, + 1.3962634015954636 }, + { 2.5239007084492706, -0.59999999999999998, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler036 = 2.5000000000000020e-13; + +// Test data for k=-0.59999999999999998, nu=0.60000000000000009. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.6651378277398083e-16 +// mean(f - f_Boost): 1.1934897514720432e-16 +// variance(f - f_Boost): 1.7585404776158019e-33 +// stddev(f - f_Boost): 4.1934955319110598e-17 +const testcase_ellint_3<double> +data037[10] = +{ + { 0.0000000000000000, -0.59999999999999998, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17592355661219386, -0.59999999999999998, 0.60000000000000009, + 0.17453292519943295 }, + { 0.36039141192661606, -0.59999999999999998, 0.60000000000000009, + 0.34906585039886590 }, + { 0.56295472636903854, -0.59999999999999998, 0.60000000000000009, + 0.52359877559829882 }, + { 0.79515295130165986, -0.59999999999999998, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0711886441942242, -0.59999999999999998, 0.60000000000000009, + 0.87266462599716477 }, + { 1.4072952835139891, -0.59999999999999998, 0.60000000000000009, + 1.0471975511965976 }, + { 1.8174863977376825, -0.59999999999999998, 0.60000000000000009, + 1.2217304763960306 }, + { 2.3029921578542232, -0.59999999999999998, 0.60000000000000009, + 1.3962634015954636 }, + { 2.8388723099514972, -0.59999999999999998, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler037 = 2.5000000000000020e-13; + +// Test data for k=-0.59999999999999998, nu=0.70000000000000007. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.2451074234797436e-16 +// mean(f - f_Boost): 5.2735593669694933e-17 +// variance(f - f_Boost): 3.4333862218458872e-34 +// stddev(f - f_Boost): 1.8529398861932589e-17 +const testcase_ellint_3<double> +data038[10] = +{ + { 0.0000000000000000, -0.59999999999999998, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17610453321631936, -0.59999999999999998, 0.70000000000000007, + 0.17453292519943295 }, + { 0.36193365056369764, -0.59999999999999998, 0.70000000000000007, + 0.34906585039886590 }, + { 0.56874098962268527, -0.59999999999999998, 0.70000000000000007, + 0.52359877559829882 }, + { 0.81106198671477181, -0.59999999999999998, 0.70000000000000007, + 0.69813170079773179 }, + { 1.1086886419010082, -0.59999999999999998, 0.70000000000000007, + 0.87266462599716477 }, + { 1.4879048567239257, -0.59999999999999998, 0.70000000000000007, + 1.0471975511965976 }, + { 1.9780310073615923, -0.59999999999999998, 0.70000000000000007, + 1.2217304763960306 }, + { 2.5941545586772712, -0.59999999999999998, 0.70000000000000007, + 1.3962634015954636 }, + { 3.3029735898397155, -0.59999999999999998, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler038 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.80000000000000004. -testcase_ellint_3<double> data039[] = { - { -0.0000000000000000, -0.59999999999999998, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17345794195390687, -0.59999999999999998, 0.80000000000000004, - 0.17453292519943295 }, - { 0.34098797854531027, -0.59999999999999998, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49882569168826230, -0.59999999999999998, 0.80000000000000004, - 0.52359877559829882 }, - { 0.64603758566475511, -0.59999999999999998, 0.80000000000000004, - 0.69813170079773179 }, - { 0.78380365594769730, -0.59999999999999998, 0.80000000000000004, - 0.87266462599716477 }, - { 0.91430946255611190, -0.59999999999999998, 0.80000000000000004, - 1.0471975511965976 }, - { 1.0398955217270607, -0.59999999999999998, 0.80000000000000004, - 1.2217304763960306 }, - { 1.1625948314277676, -0.59999999999999998, 0.80000000000000004, - 1.3962634015954636 }, - { 1.2840021261752192, -0.59999999999999998, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=-0.59999999999999998, nu=0.80000000000000004. -template <typename Tp> -void test039() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data039) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data039[i].k), Tp(data039[i].nu), - Tp(data039[i].phi)); - const Tp f0 = data039[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.3826960061025914e-16 +// mean(f - f_Boost): 2.7478019859472625e-16 +// variance(f - f_Boost): 4.6451528105588637e-32 +// stddev(f - f_Boost): 2.1552616570984749e-16 +const testcase_ellint_3<double> +data039[10] = +{ + { 0.0000000000000000, -0.59999999999999998, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17628618080795252, -0.59999999999999998, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36349976272521012, -0.59999999999999998, 0.80000000000000004, + 0.34906585039886590 }, + { 0.57474392342151914, -0.59999999999999998, 0.80000000000000004, + 0.52359877559829882 }, + { 0.82814493499158159, -0.59999999999999998, 0.80000000000000004, + 0.69813170079773179 }, + { 1.1511281795998280, -0.59999999999999998, 0.80000000000000004, + 0.87266462599716477 }, + { 1.5864286332503075, -0.59999999999999998, 0.80000000000000004, + 1.0471975511965976 }, + { 2.1958944866494527, -0.59999999999999998, 0.80000000000000004, + 1.2217304763960306 }, + { 3.0398358172574604, -0.59999999999999998, 0.80000000000000004, + 1.3962634015954636 }, + { 4.0867036409261832, -0.59999999999999998, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler039 = 2.5000000000000020e-13; // Test data for k=-0.59999999999999998, nu=0.90000000000000002. -testcase_ellint_3<double> data040[] = { - { -0.0000000000000000, -0.59999999999999998, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17328652344890033, -0.59999999999999998, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33973880062929018, -0.59999999999999998, 0.90000000000000002, - 0.34906585039886590 }, - { 0.49515092233122765, -0.59999999999999998, 0.90000000000000002, - 0.52359877559829882 }, - { 0.63864042139737043, -0.59999999999999998, 0.90000000000000002, - 0.69813170079773179 }, - { 0.77167205646538850, -0.59999999999999998, 0.90000000000000002, - 0.87266462599716477 }, - { 0.89673202848034383, -0.59999999999999998, 0.90000000000000002, - 1.0471975511965976 }, - { 1.0163984492661304, -0.59999999999999998, 0.90000000000000002, - 1.2217304763960306 }, - { 1.1328845785162431, -0.59999999999999998, 0.90000000000000002, - 1.3962634015954636 }, - { 1.2479362973851875, -0.59999999999999998, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.59999999999999998, nu=0.90000000000000002. -template <typename Tp> -void test040() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data040) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data040[i].k), Tp(data040[i].nu), - Tp(data040[i].phi)); - const Tp f0 = data040[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 5.7440178400898422e-16 +// mean(f - f_Boost): 5.0792703376600914e-16 +// variance(f - f_Boost): 1.9863137923719990e-31 +// stddev(f - f_Boost): 4.4568080420543122e-16 +const testcase_ellint_3<double> +data040[10] = +{ + { 0.0000000000000000, -0.59999999999999998, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17646850384035848, -0.59999999999999998, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36509041515134105, -0.59999999999999998, 0.90000000000000002, + 0.34906585039886590 }, + { 0.58097838596260631, -0.59999999999999998, 0.90000000000000002, + 0.52359877559829882 }, + { 0.84656453396163722, -0.59999999999999998, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1997828426963724, -0.59999999999999998, 0.90000000000000002, + 0.87266462599716477 }, + { 1.7112436789225605, -0.59999999999999998, 0.90000000000000002, + 1.0471975511965976 }, + { 2.5193168553672312, -0.59999999999999998, 0.90000000000000002, + 1.2217304763960306 }, + { 3.8656670488606686, -0.59999999999999998, 0.90000000000000002, + 1.3962634015954636 }, + { 5.8709993116265595, -0.59999999999999998, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler040 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.0000000000000000. -testcase_ellint_3<double> data041[] = { - { -0.0000000000000000, -0.50000000000000000, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17475385514035785, -0.50000000000000000, 0.0000000000000000, - 0.17453292519943295 }, - { 0.35081868470101585, -0.50000000000000000, 0.0000000000000000, - 0.34906585039886590 }, - { 0.52942862705190585, -0.50000000000000000, 0.0000000000000000, - 0.52359877559829882 }, - { 0.71164727562630326, -0.50000000000000000, 0.0000000000000000, - 0.69813170079773179 }, - { 0.89824523594227768, -0.50000000000000000, 0.0000000000000000, - 0.87266462599716477 }, - { 1.0895506700518851, -0.50000000000000000, 0.0000000000000000, - 1.0471975511965976 }, - { 1.2853005857432933, -0.50000000000000000, 0.0000000000000000, - 1.2217304763960306 }, - { 1.4845545520549484, -0.50000000000000000, 0.0000000000000000, - 1.3962634015954636 }, - { 1.6857503548125963, -0.50000000000000000, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.50000000000000000, nu=0.0000000000000000. -template <typename Tp> -void test041() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data041) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data041[i].k), Tp(data041[i].nu), - Tp(data041[i].phi)); - const Tp f0 = data041[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.4551389361831220e-16 +// mean(f - f_Boost): -1.3877787807814457e-17 +// variance(f - f_Boost): 2.5893058141206173e-32 +// stddev(f - f_Boost): 1.6091320064309879e-16 +const testcase_ellint_3<double> +data041[10] = +{ + { 0.0000000000000000, -0.50000000000000000, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17475385514035785, -0.50000000000000000, 0.0000000000000000, + 0.17453292519943295 }, + { 0.35081868470101579, -0.50000000000000000, 0.0000000000000000, + 0.34906585039886590 }, + { 0.52942862705190574, -0.50000000000000000, 0.0000000000000000, + 0.52359877559829882 }, + { 0.71164727562630326, -0.50000000000000000, 0.0000000000000000, + 0.69813170079773179 }, + { 0.89824523594227768, -0.50000000000000000, 0.0000000000000000, + 0.87266462599716477 }, + { 1.0895506700518853, -0.50000000000000000, 0.0000000000000000, + 1.0471975511965976 }, + { 1.2853005857432933, -0.50000000000000000, 0.0000000000000000, + 1.2217304763960306 }, + { 1.4845545520549488, -0.50000000000000000, 0.0000000000000000, + 1.3962634015954636 }, + { 1.6857503548125961, -0.50000000000000000, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler041 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.10000000000000001. -testcase_ellint_3<double> data042[] = { - { -0.0000000000000000, -0.50000000000000000, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17457763120814676, -0.50000000000000000, 0.10000000000000001, - 0.17453292519943295 }, - { 0.34943246340849154, -0.50000000000000000, 0.10000000000000001, - 0.34906585039886590 }, - { 0.52487937869610801, -0.50000000000000000, 0.10000000000000001, - 0.52359877559829882 }, - { 0.70127785096388395, -0.50000000000000000, 0.10000000000000001, - 0.69813170079773179 }, - { 0.87898815988624479, -0.50000000000000000, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0582764576094172, -0.50000000000000000, 0.10000000000000001, - 1.0471975511965976 }, - { 1.2391936844060207, -0.50000000000000000, 0.10000000000000001, - 1.2217304763960306 }, - { 1.4214793542995841, -0.50000000000000000, 0.10000000000000001, - 1.3962634015954636 }, - { 1.6045524936084892, -0.50000000000000000, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.50000000000000000, nu=0.10000000000000001. -template <typename Tp> -void test042() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data042) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data042[i].k), Tp(data042[i].nu), - Tp(data042[i].phi)); - const Tp f0 = data042[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.7416868347177582e-16 +// mean(f - f_Boost): 2.7755575615628915e-18 +// variance(f - f_Boost): 5.4326441655972001e-32 +// stddev(f - f_Boost): 2.3308033305273100e-16 +const testcase_ellint_3<double> +data042[10] = +{ + { 0.0000000000000000, -0.50000000000000000, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17493071928248824, -0.50000000000000000, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35222467688034798, -0.50000000000000000, 0.10000000000000001, + 0.34906585039886590 }, + { 0.53411928652008112, -0.50000000000000000, 0.10000000000000001, + 0.52359877559829882 }, + { 0.72256398117177589, -0.50000000000000000, 0.10000000000000001, + 0.69813170079773179 }, + { 0.91899583232771009, -0.50000000000000000, 0.10000000000000001, + 0.87266462599716477 }, + { 1.1240549163055360, -0.50000000000000000, 0.10000000000000001, + 1.0471975511965976 }, + { 1.3372938086286021, -0.50000000000000000, 0.10000000000000001, + 1.2217304763960306 }, + { 1.5570024469132429, -0.50000000000000000, 0.10000000000000001, + 1.3962634015954636 }, + { 1.7803034946545480, -0.50000000000000000, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler042 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.20000000000000001. -testcase_ellint_3<double> data043[] = { - { -0.0000000000000000, -0.50000000000000000, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17440204336345433, -0.50000000000000000, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34806552388338824, -0.50000000000000000, 0.20000000000000001, - 0.34906585039886590 }, - { 0.52046416757129821, -0.50000000000000000, 0.20000000000000001, - 0.52359877559829882 }, - { 0.69140924550993876, -0.50000000000000000, 0.20000000000000001, - 0.69813170079773179 }, - { 0.86104678636125520, -0.50000000000000000, 0.20000000000000001, - 0.87266462599716477 }, - { 1.0297439459053981, -0.50000000000000000, 0.20000000000000001, - 1.0471975511965976 }, - { 1.1979214112912036, -0.50000000000000000, 0.20000000000000001, - 1.2217304763960306 }, - { 1.3659033858648930, -0.50000000000000000, 0.20000000000000001, - 1.3962634015954636 }, - { 1.5338490483665983, -0.50000000000000000, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.50000000000000000, nu=0.20000000000000001. -template <typename Tp> -void test043() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data043) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data043[i].k), Tp(data043[i].nu), - Tp(data043[i].phi)); - const Tp f0 = data043[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.50000000000000000, nu=0.29999999999999999. -testcase_ellint_3<double> data044[] = { - { -0.0000000000000000, -0.50000000000000000, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17422708752228896, -0.50000000000000000, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34671739434855858, -0.50000000000000000, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51617616305641889, -0.50000000000000000, 0.29999999999999999, - 0.52359877559829882 }, - { 0.68200047612545178, -0.50000000000000000, 0.29999999999999999, - 0.69813170079773179 }, - { 0.84427217869498372, -0.50000000000000000, 0.29999999999999999, - 0.87266462599716477 }, - { 1.0035637821389782, -0.50000000000000000, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1606800483933113, -0.50000000000000000, 0.29999999999999999, - 1.2217304763960306 }, - { 1.3164407134643459, -0.50000000000000000, 0.29999999999999999, - 1.3962634015954636 }, - { 1.4715681939859637, -0.50000000000000000, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=-0.50000000000000000, nu=0.29999999999999999. -template <typename Tp> -void test044() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data044) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data044[i].k), Tp(data044[i].nu), - Tp(data044[i].phi)); - const Tp f0 = data044[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.1198767993730867e-16 +// mean(f - f_Boost): 2.7755575615628914e-17 +// variance(f - f_Boost): 5.0311947683004831e-32 +// stddev(f - f_Boost): 2.2430324938128922e-16 +const testcase_ellint_3<double> +data043[10] = +{ + { 0.0000000000000000, -0.50000000000000000, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17510822779582402, -0.50000000000000000, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35365094725531487, -0.50000000000000000, 0.20000000000000001, + 0.34906585039886590 }, + { 0.53895933237328697, -0.50000000000000000, 0.20000000000000001, + 0.52359877559829882 }, + { 0.73408090840070794, -0.50000000000000000, 0.20000000000000001, + 0.69813170079773179 }, + { 0.94145442818535396, -0.50000000000000000, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1624120186296487, -0.50000000000000000, 0.20000000000000001, + 1.0471975511965976 }, + { 1.3965823372867114, -0.50000000000000000, 0.20000000000000001, + 1.2217304763960306 }, + { 1.6414308440430099, -0.50000000000000000, 0.20000000000000001, + 1.3962634015954636 }, + { 1.8922947612264018, -0.50000000000000000, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler043 = 2.5000000000000020e-13; + +// Test data for k=-0.50000000000000000, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.3800262770228813e-16 +// mean(f - f_Boost): 5.8286708792820721e-17 +// variance(f - f_Boost): 8.5027191584278157e-32 +// stddev(f - f_Boost): 2.9159422419567599e-16 +const testcase_ellint_3<double> +data044[10] = +{ + { 0.0000000000000000, -0.50000000000000000, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17528638488102041, -0.50000000000000000, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35509802222332720, -0.50000000000000000, 0.30000000000000004, + 0.34906585039886590 }, + { 0.54395740731866193, -0.50000000000000000, 0.30000000000000004, + 0.52359877559829882 }, + { 0.74625871438752667, -0.50000000000000000, 0.30000000000000004, + 0.69813170079773179 }, + { 0.96588271186092023, -0.50000000000000000, 0.30000000000000004, + 0.87266462599716477 }, + { 1.2054319584357329, -0.50000000000000000, 0.30000000000000004, + 1.0471975511965976 }, + { 1.4651077994832871, -0.50000000000000000, 0.30000000000000004, + 1.2217304763960306 }, + { 1.7416018368052644, -0.50000000000000000, 0.30000000000000004, + 1.3962634015954636 }, + { 2.0277924458111314, -0.50000000000000000, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler044 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.40000000000000002. -testcase_ellint_3<double> data045[] = { - { -0.0000000000000000, -0.50000000000000000, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17405275963859917, -0.50000000000000000, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34538761957029329, -0.50000000000000000, 0.40000000000000002, - 0.34906585039886590 }, - { 0.51200902646603919, -0.50000000000000000, 0.40000000000000002, - 0.52359877559829882 }, - { 0.67301522212868792, -0.50000000000000000, 0.40000000000000002, - 0.69813170079773179 }, - { 0.82853844466313320, -0.50000000000000000, 0.40000000000000002, - 0.87266462599716477 }, - { 0.97942097862681488, -0.50000000000000000, 0.40000000000000002, - 1.0471975511965976 }, - { 1.1268429801220616, -0.50000000000000000, 0.40000000000000002, - 1.2217304763960306 }, - { 1.2720406704533922, -0.50000000000000000, 0.40000000000000002, - 1.3962634015954636 }, - { 1.4161679518465340, -0.50000000000000000, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.50000000000000000, nu=0.40000000000000002. -template <typename Tp> -void test045() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data045) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data045[i].k), Tp(data045[i].nu), - Tp(data045[i].phi)); - const Tp f0 = data045[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.0439932918341581e-16 +// mean(f - f_Boost): 3.0531133177191807e-17 +// variance(f - f_Boost): 9.0809736800018602e-32 +// stddev(f - f_Boost): 3.0134653938616686e-16 +const testcase_ellint_3<double> +data045[10] = +{ + { 0.0000000000000000, -0.50000000000000000, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17546519477859268, -0.50000000000000000, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35656644822531680, -0.50000000000000000, 0.40000000000000002, + 0.34906585039886590 }, + { 0.54912289677411319, -0.50000000000000000, 0.40000000000000002, + 0.52359877559829882 }, + { 0.75916731611690047, -0.50000000000000000, 0.40000000000000002, + 0.69813170079773179 }, + { 0.99260415631328214, -0.50000000000000000, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2541925856918670, -0.50000000000000000, 0.40000000000000002, + 1.0471975511965976 }, + { 1.5456393705347609, -0.50000000000000000, 0.40000000000000002, + 1.2217304763960306 }, + { 1.8631904972952076, -0.50000000000000000, 0.40000000000000002, + 1.3962634015954636 }, + { 2.1962905366178065, -0.50000000000000000, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler045 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.50000000000000000. -testcase_ellint_3<double> data046[] = { - { -0.0000000000000000, -0.50000000000000000, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17387905570381157, -0.50000000000000000, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34407576010465207, -0.50000000000000000, 0.50000000000000000, - 0.34906585039886590 }, - { 0.50795686560160835, -0.50000000000000000, 0.50000000000000000, - 0.52359877559829882 }, - { 0.66442115453330175, -0.50000000000000000, 0.50000000000000000, - 0.69813170079773179 }, - { 0.81373829119355345, -0.50000000000000000, 0.50000000000000000, - 0.87266462599716477 }, - { 0.95705743313235825, -0.50000000000000000, 0.50000000000000000, - 1.0471975511965976 }, - { 1.0959131991362556, -0.50000000000000000, 0.50000000000000000, - 1.2217304763960306 }, - { 1.2318900529754597, -0.50000000000000000, 0.50000000000000000, - 1.3962634015954636 }, - { 1.3664739530045971, -0.50000000000000000, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.50000000000000000, nu=0.50000000000000000. -template <typename Tp> -void test046() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data046) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data046[i].k), Tp(data046[i].nu), - Tp(data046[i].phi)); - const Tp f0 = data046[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.50000000000000000, nu=0.59999999999999998. -testcase_ellint_3<double> data047[] = { - { -0.0000000000000000, -0.50000000000000000, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17370597174637581, -0.50000000000000000, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34278139158591414, -0.50000000000000000, 0.59999999999999998, - 0.34906585039886590 }, - { 0.50401419439302719, -0.50000000000000000, 0.59999999999999998, - 0.52359877559829882 }, - { 0.65618938076167221, -0.50000000000000000, 0.59999999999999998, - 0.69813170079773179 }, - { 0.79977959248855424, -0.50000000000000000, 0.59999999999999998, - 0.87266462599716477 }, - { 0.93625925190753545, -0.50000000000000000, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0674905658379710, -0.50000000000000000, 0.59999999999999998, - 1.2217304763960306 }, - { 1.1953481298023048, -0.50000000000000000, 0.59999999999999998, - 1.3962634015954636 }, - { 1.3215740290190876, -0.50000000000000000, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=-0.50000000000000000, nu=0.59999999999999998. -template <typename Tp> -void test047() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data047) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data047[i].k), Tp(data047[i].nu), - Tp(data047[i].phi)); - const Tp f0 = data047[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.50000000000000000, nu=0.69999999999999996. -testcase_ellint_3<double> data048[] = { - { -0.0000000000000000, -0.50000000000000000, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17353350383131641, -0.50000000000000000, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34150410405436771, -0.50000000000000000, 0.69999999999999996, - 0.34906585039886590 }, - { 0.50017589696443487, -0.50000000000000000, 0.69999999999999996, - 0.52359877559829882 }, - { 0.64829398188419962, -0.50000000000000000, 0.69999999999999996, - 0.69813170079773179 }, - { 0.78658270782402073, -0.50000000000000000, 0.69999999999999996, - 0.87266462599716477 }, - { 0.91684738336675053, -0.50000000000000000, 0.69999999999999996, - 1.0471975511965976 }, - { 1.0412486789555937, -0.50000000000000000, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1619021847612001, -0.50000000000000000, 0.69999999999999996, - 1.3962634015954636 }, - { 1.2807475181182502, -0.50000000000000000, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=-0.50000000000000000, nu=0.69999999999999996. -template <typename Tp> -void test048() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data048) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data048[i].k), Tp(data048[i].nu), - Tp(data048[i].phi)); - const Tp f0 = data048[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.6797816859260978e-16 +// mean(f - f_Boost): 9.4368957093138303e-17 +// variance(f - f_Boost): 7.7794254682023874e-32 +// stddev(f - f_Boost): 2.7891621444803792e-16 +const testcase_ellint_3<double> +data046[10] = +{ + { 0.0000000000000000, -0.50000000000000000, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17564466176941509, -0.50000000000000000, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35805679276065394, -0.50000000000000000, 0.50000000000000000, + 0.34906585039886590 }, + { 0.55446601496200032, -0.50000000000000000, 0.50000000000000000, + 0.52359877559829882 }, + { 0.77288783578259013, -0.50000000000000000, 0.50000000000000000, + 0.69813170079773179 }, + { 1.0220246013918972, -0.50000000000000000, 0.50000000000000000, + 0.87266462599716477 }, + { 1.3101681612463965, -0.50000000000000000, 0.50000000000000000, + 1.0471975511965976 }, + { 1.6422994881851025, -0.50000000000000000, 0.50000000000000000, + 1.2217304763960306 }, + { 2.0152636030998816, -0.50000000000000000, 0.50000000000000000, + 1.3962634015954636 }, + { 2.4136715042011945, -0.50000000000000000, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler046 = 2.5000000000000020e-13; + +// Test data for k=-0.50000000000000000, nu=0.60000000000000009. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.9178421578645735e-16 +// mean(f - f_Boost): 1.3322676295501878e-16 +// variance(f - f_Boost): 1.7749370367472766e-31 +// stddev(f - f_Boost): 4.2130001622920411e-16 +const testcase_ellint_3<double> +data047[10] = +{ + { 0.0000000000000000, -0.50000000000000000, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17582479017522740, -0.50000000000000000, 0.60000000000000009, + 0.17453292519943295 }, + { 0.35956964546660036, -0.50000000000000000, 0.60000000000000009, + 0.34906585039886590 }, + { 0.55999790372984193, -0.50000000000000000, 0.60000000000000009, + 0.52359877559829882 }, + { 0.78751507911209895, -0.50000000000000000, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0546620505035220, -0.50000000000000000, 0.60000000000000009, + 0.87266462599716477 }, + { 1.3754438357425935, -0.50000000000000000, 0.60000000000000009, + 1.0471975511965976 }, + { 1.7615727400820127, -0.50000000000000000, 0.60000000000000009, + 1.2217304763960306 }, + { 2.2134638067565242, -0.50000000000000000, 0.60000000000000009, + 1.3962634015954636 }, + { 2.7090491861753558, -0.50000000000000000, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler047 = 2.5000000000000020e-13; + +// Test data for k=-0.50000000000000000, nu=0.70000000000000007. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.0745105182189226e-16 +// mean(f - f_Boost): 4.1633363423443370e-17 +// variance(f - f_Boost): 1.9996383743576116e-32 +// stddev(f - f_Boost): 1.4140857026211713e-16 +const testcase_ellint_3<double> +data048[10] = +{ + { 0.0000000000000000, -0.50000000000000000, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17600558435914915, -0.50000000000000000, 0.70000000000000007, + 0.17453292519943295 }, + { 0.36110561926726259, -0.50000000000000000, 0.70000000000000007, + 0.34906585039886590 }, + { 0.56573074641137111, -0.50000000000000000, 0.70000000000000007, + 0.52359877559829882 }, + { 0.80316073084237205, -0.50000000000000000, 0.70000000000000007, + 0.69813170079773179 }, + { 1.0911910688131461, -0.50000000000000000, 0.70000000000000007, + 0.87266462599716477 }, + { 1.4530946406380640, -0.50000000000000000, 0.70000000000000007, + 1.0471975511965976 }, + { 1.9144386536785372, -0.50000000000000000, 0.70000000000000007, + 1.2217304763960306 }, + { 2.4878788958234970, -0.50000000000000000, 0.70000000000000007, + 1.3962634015954636 }, + { 3.1433945297859225, -0.50000000000000000, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler048 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.80000000000000004. -testcase_ellint_3<double> data049[] = { - { -0.0000000000000000, -0.50000000000000000, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17336164805979126, -0.50000000000000000, 0.80000000000000004, - 0.17453292519943295 }, - { 0.34024350132086773, -0.50000000000000000, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49643719555734084, -0.50000000000000000, 0.80000000000000004, - 0.52359877559829882 }, - { 0.64071162456976150, -0.50000000000000000, 0.80000000000000004, - 0.69813170079773179 }, - { 0.77407836177211908, -0.50000000000000000, 0.80000000000000004, - 0.87266462599716477 }, - { 0.89867058251905652, -0.50000000000000000, 0.80000000000000004, - 1.0471975511965976 }, - { 1.0169181822134912, -0.50000000000000000, 0.80000000000000004, - 1.2217304763960306 }, - { 1.1311363312779448, -0.50000000000000000, 0.80000000000000004, - 1.3962634015954636 }, - { 1.2434165408189539, -0.50000000000000000, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=-0.50000000000000000, nu=0.80000000000000004. -template <typename Tp> -void test049() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data049) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data049[i].k), Tp(data049[i].nu), - Tp(data049[i].phi)); - const Tp f0 = data049[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.4380477375534667e-16 +// mean(f - f_Boost): 2.3037127760972000e-16 +// variance(f - f_Boost): 1.4989821857033475e-31 +// stddev(f - f_Boost): 3.8716691306248618e-16 +const testcase_ellint_3<double> +data049[10] = +{ + { 0.0000000000000000, -0.50000000000000000, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17618704872620228, -0.50000000000000000, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36266535159745827, -0.50000000000000000, 0.80000000000000004, + 0.34906585039886590 }, + { 0.57167789954529158, -0.50000000000000000, 0.80000000000000004, + 0.52359877559829882 }, + { 0.81995752984315018, -0.50000000000000000, 0.80000000000000004, + 0.69813170079773179 }, + { 1.1325112162158122, -0.50000000000000000, 0.80000000000000004, + 0.87266462599716477 }, + { 1.5479055930718042, -0.50000000000000000, 0.80000000000000004, + 1.0471975511965976 }, + { 2.1215243941010486, -0.50000000000000000, 0.80000000000000004, + 1.2217304763960306 }, + { 2.9069405767650132, -0.50000000000000000, 0.80000000000000004, + 1.3962634015954636 }, + { 3.8750701888108066, -0.50000000000000000, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler049 = 2.5000000000000020e-13; // Test data for k=-0.50000000000000000, nu=0.90000000000000002. -testcase_ellint_3<double> data050[] = { - { -0.0000000000000000, -0.50000000000000000, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17319040056865681, -0.50000000000000000, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33899920036578557, -0.50000000000000000, 0.90000000000000002, - 0.34906585039886590 }, - { 0.49279362182695186, -0.50000000000000000, 0.90000000000000002, - 0.52359877559829882 }, - { 0.63342123379746151, -0.50000000000000000, 0.90000000000000002, - 0.69813170079773179 }, - { 0.76220595179550321, -0.50000000000000000, 0.90000000000000002, - 0.87266462599716477 }, - { 0.88160004743532294, -0.50000000000000000, 0.90000000000000002, - 1.0471975511965976 }, - { 0.99427448642310134, -0.50000000000000000, 0.90000000000000002, - 1.2217304763960306 }, - { 1.1027091512470093, -0.50000000000000000, 0.90000000000000002, - 1.3962634015954636 }, - { 1.2091116095504744, -0.50000000000000000, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.50000000000000000, nu=0.90000000000000002. -template <typename Tp> -void test050() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data050) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data050[i].k), Tp(data050[i].nu), - Tp(data050[i].phi)); - const Tp f0 = data050[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.40000000000000002, nu=0.0000000000000000. -testcase_ellint_3<double> data051[] = { - { -0.0000000000000000, -0.40000000000000002, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17467414669441531, -0.40000000000000002, 0.0000000000000000, - 0.17453292519943295 }, - { 0.35018222772483443, -0.40000000000000002, 0.0000000000000000, - 0.34906585039886590 }, - { 0.52729015917508748, -0.40000000000000002, 0.0000000000000000, - 0.52359877559829882 }, - { 0.70662374407341255, -0.40000000000000002, 0.0000000000000000, - 0.69813170079773179 }, - { 0.88859210497602170, -0.40000000000000002, 0.0000000000000000, - 0.87266462599716477 }, - { 1.0733136290471379, -0.40000000000000002, 0.0000000000000000, - 1.0471975511965976 }, - { 1.2605612170157061, -0.40000000000000002, 0.0000000000000000, - 1.2217304763960306 }, - { 1.4497513956433437, -0.40000000000000002, 0.0000000000000000, - 1.3962634015954636 }, - { 1.6399998658645112, -0.40000000000000002, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.40000000000000002, nu=0.0000000000000000. -template <typename Tp> -void test051() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data051) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data051[i].k), Tp(data051[i].nu), - Tp(data051[i].phi)); - const Tp f0 = data051[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.40000000000000002, nu=0.10000000000000001. -testcase_ellint_3<double> data052[] = { - { -0.0000000000000000, -0.40000000000000002, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17449806706684673, -0.40000000000000002, 0.10000000000000001, - 0.17453292519943295 }, - { 0.34880048623856075, -0.40000000000000002, 0.10000000000000001, - 0.34906585039886590 }, - { 0.52277322065757403, -0.40000000000000002, 0.10000000000000001, - 0.52359877559829882 }, - { 0.69638072056918376, -0.40000000000000002, 0.10000000000000001, - 0.69813170079773179 }, - { 0.86968426619831540, -0.40000000000000002, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0428044206578095, -0.40000000000000002, 0.10000000000000001, - 1.0471975511965976 }, - { 1.2158651158274378, -0.40000000000000002, 0.10000000000000001, - 1.2217304763960306 }, - { 1.3889447129893322, -0.40000000000000002, 0.10000000000000001, - 1.3962634015954636 }, - { 1.5620566886683604, -0.40000000000000002, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.40000000000000002, nu=0.10000000000000001. -template <typename Tp> -void test052() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data052) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data052[i].k), Tp(data052[i].nu), - Tp(data052[i].phi)); - const Tp f0 = data052[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.40000000000000002, nu=0.20000000000000001. -testcase_ellint_3<double> data053[] = { - { -0.0000000000000000, -0.40000000000000002, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17432262290723399, -0.40000000000000002, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34743795258968596, -0.40000000000000002, 0.20000000000000001, - 0.34906585039886590 }, - { 0.51838919472805123, -0.40000000000000002, 0.20000000000000001, - 0.52359877559829882 }, - { 0.68663134739057918, -0.40000000000000002, 0.20000000000000001, - 0.69813170079773179 }, - { 0.85206432981833979, -0.40000000000000002, 0.20000000000000001, - 0.87266462599716477 }, - { 1.0149595349004430, -0.40000000000000002, 0.20000000000000001, - 1.0471975511965976 }, - { 1.1758349405464676, -0.40000000000000002, 0.20000000000000001, - 1.2217304763960306 }, - { 1.3353337673882635, -0.40000000000000002, 0.20000000000000001, - 1.3962634015954636 }, - { 1.4941414344266770, -0.40000000000000002, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.40000000000000002, nu=0.20000000000000001. -template <typename Tp> -void test053() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data053) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data053[i].k), Tp(data053[i].nu), - Tp(data053[i].phi)); - const Tp f0 = data053[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.40000000000000002, nu=0.29999999999999999. -testcase_ellint_3<double> data054[] = { - { -0.0000000000000000, -0.40000000000000002, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17414781013591543, -0.40000000000000002, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34609415696777285, -0.40000000000000002, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51413131295862546, -0.40000000000000002, 0.29999999999999999, - 0.52359877559829882 }, - { 0.67733527622935630, -0.40000000000000002, 0.29999999999999999, - 0.69813170079773179 }, - { 0.83558675182733266, -0.40000000000000002, 0.29999999999999999, - 0.87266462599716477 }, - { 0.98940140808865906, -0.40000000000000002, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1396968797728058, -0.40000000000000002, 0.29999999999999999, - 1.2217304763960306 }, - { 1.2875920037865087, -0.40000000000000002, 0.29999999999999999, - 1.3962634015954636 }, - { 1.4342789859950078, -0.40000000000000002, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=-0.40000000000000002, nu=0.29999999999999999. -template <typename Tp> -void test054() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data054) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data054[i].k), Tp(data054[i].nu), - Tp(data054[i].phi)); - const Tp f0 = data054[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.40000000000000002, nu=0.40000000000000002. -testcase_ellint_3<double> data055[] = { - { -0.0000000000000000, -0.40000000000000002, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17397362471112710, -0.40000000000000002, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34476864603333196, -0.40000000000000002, 0.40000000000000002, - 0.34906585039886590 }, - { 0.50999329415379357, -0.40000000000000002, 0.40000000000000002, - 0.52359877559829882 }, - { 0.66845674551396017, -0.40000000000000002, 0.40000000000000002, - 0.69813170079773179 }, - { 0.82012848346231748, -0.40000000000000002, 0.40000000000000002, - 0.87266462599716477 }, - { 0.96582449258349057, -0.40000000000000002, 0.40000000000000002, - 1.0471975511965976 }, - { 1.1068473749476286, -0.40000000000000002, 0.40000000000000002, - 1.2217304763960306 }, - { 1.2447132729159986, -0.40000000000000002, 0.40000000000000002, - 1.3962634015954636 }, - { 1.3809986210732901, -0.40000000000000002, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.40000000000000002, nu=0.40000000000000002. -template <typename Tp> -void test055() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data055) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data055[i].k), Tp(data055[i].nu), - Tp(data055[i].phi)); - const Tp f0 = data055[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.40000000000000002, nu=0.50000000000000000. -testcase_ellint_3<double> data056[] = { - { -0.0000000000000000, -0.40000000000000002, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17380006262854139, -0.40000000000000002, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34346098216756610, -0.40000000000000002, 0.50000000000000000, - 0.34906585039886590 }, - { 0.50596929935059420, -0.40000000000000002, 0.50000000000000000, - 0.52359877559829882 }, - { 0.65996392089131262, -0.40000000000000002, 0.50000000000000000, - 0.69813170079773179 }, - { 0.80558463511364786, -0.40000000000000002, 0.50000000000000000, - 0.87266462599716477 }, - { 0.94397834522857704, -0.40000000000000002, 0.50000000000000000, - 1.0471975511965976 }, - { 1.0768075114108115, -0.40000000000000002, 0.50000000000000000, - 1.2217304763960306 }, - { 1.2059184624251329, -0.40000000000000002, 0.50000000000000000, - 1.3962634015954636 }, - { 1.3331797176377398, -0.40000000000000002, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.40000000000000002, nu=0.50000000000000000. -template <typename Tp> -void test056() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data056) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data056[i].k), Tp(data056[i].nu), - Tp(data056[i].phi)); - const Tp f0 = data056[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.40000000000000002, nu=0.59999999999999998. -testcase_ellint_3<double> data057[] = { - { -0.0000000000000000, -0.40000000000000002, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17362711992081248, -0.40000000000000002, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34217074276403953, -0.40000000000000002, 0.59999999999999998, - 0.34906585039886590 }, - { 0.50205389185761617, -0.40000000000000002, 0.59999999999999998, - 0.52359877559829882 }, - { 0.65182834920372745, -0.40000000000000002, 0.59999999999999998, - 0.69813170079773179 }, - { 0.79186512820565136, -0.40000000000000002, 0.59999999999999998, - 0.87266462599716477 }, - { 0.92365535916287134, -0.40000000000000002, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0491915663957907, -0.40000000000000002, 0.59999999999999998, - 1.2217304763960306 }, - { 1.1705934291745104, -0.40000000000000002, 0.59999999999999998, - 1.3962634015954636 }, - { 1.2899514672527024, -0.40000000000000002, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=-0.40000000000000002, nu=0.59999999999999998. -template <typename Tp> -void test057() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data057) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data057[i].k), Tp(data057[i].nu), - Tp(data057[i].phi)); - const Tp f0 = data057[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.40000000000000002, nu=0.69999999999999996. -testcase_ellint_3<double> data058[] = { - { -0.0000000000000000, -0.40000000000000002, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17345479265712871, -0.40000000000000002, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34089751955950354, -0.40000000000000002, 0.69999999999999996, - 0.34906585039886590 }, - { 0.49824200167361343, -0.40000000000000002, 0.69999999999999996, - 0.52359877559829882 }, - { 0.64402450341199413, -0.40000000000000002, 0.69999999999999996, - 0.69813170079773179 }, - { 0.77889207804122873, -0.40000000000000002, 0.69999999999999996, - 0.87266462599716477 }, - { 0.90468169720957992, -0.40000000000000002, 0.69999999999999996, - 1.0471975511965976 }, - { 1.0236847823692916, -0.40000000000000002, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1382465247425164, -0.40000000000000002, 0.69999999999999996, - 1.3962634015954636 }, - { 1.2506255923253344, -0.40000000000000002, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=-0.40000000000000002, nu=0.69999999999999996. -template <typename Tp> -void test058() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data058) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data058[i].k), Tp(data058[i].nu), - Tp(data058[i].phi)); - const Tp f0 = data058[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.40000000000000002, nu=0.80000000000000004. -testcase_ellint_3<double> data059[] = { - { -0.0000000000000000, -0.40000000000000002, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17328307694277156, -0.40000000000000002, 0.80000000000000004, - 0.17453292519943295 }, - { 0.33964091800132007, -0.40000000000000002, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49452889372467451, -0.40000000000000002, 0.80000000000000004, - 0.52359877559829882 }, - { 0.63652940095937327, -0.40000000000000002, 0.80000000000000004, - 0.69813170079773179 }, - { 0.76659772511159097, -0.40000000000000002, 0.80000000000000004, - 0.87266462599716477 }, - { 0.88691047977338111, -0.40000000000000002, 0.80000000000000004, - 1.0471975511965976 }, - { 1.0000273200611638, -0.40000000000000002, 0.80000000000000004, - 1.2217304763960306 }, - { 1.1084787902188007, -0.40000000000000002, 0.80000000000000004, - 1.3962634015954636 }, - { 1.2146499565727209, -0.40000000000000002, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=-0.40000000000000002, nu=0.80000000000000004. -template <typename Tp> -void test059() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data059) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data059[i].k), Tp(data059[i].nu), - Tp(data059[i].phi)); - const Tp f0 = data059[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.40000000000000002, nu=0.90000000000000002. -testcase_ellint_3<double> data060[] = { - { -0.0000000000000000, -0.40000000000000002, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17311196891868130, -0.40000000000000002, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33840055664911906, -0.40000000000000002, 0.90000000000000002, - 0.34906585039886590 }, - { 0.49091013944075340, -0.40000000000000002, 0.90000000000000002, - 0.52359877559829882 }, - { 0.62932228186809591, -0.40000000000000002, 0.90000000000000002, - 0.69813170079773179 }, - { 0.75492278323019801, -0.40000000000000002, 0.90000000000000002, - 0.87266462599716477 }, - { 0.87021659043854294, -0.40000000000000002, 0.90000000000000002, - 1.0471975511965976 }, - { 0.97800245228239246, -0.40000000000000002, 0.90000000000000002, - 1.2217304763960306 }, - { 1.0809625773173694, -0.40000000000000002, 0.90000000000000002, - 1.3962634015954636 }, - { 1.1815758115929846, -0.40000000000000002, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.40000000000000002, nu=0.90000000000000002. -template <typename Tp> -void test060() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data060) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data060[i].k), Tp(data060[i].nu), - Tp(data060[i].phi)); - const Tp f0 = data060[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.30000000000000004, nu=0.0000000000000000. -testcase_ellint_3<double> data061[] = { - { -0.0000000000000000, -0.30000000000000004, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17461228653000102, -0.30000000000000004, 0.0000000000000000, - 0.17453292519943295 }, - { 0.34969146102798415, -0.30000000000000004, 0.0000000000000000, - 0.34906585039886590 }, - { 0.52565822873726320, -0.30000000000000004, 0.0000000000000000, - 0.52359877559829882 }, - { 0.70284226512408532, -0.30000000000000004, 0.0000000000000000, - 0.69813170079773179 }, - { 0.88144139195111182, -0.30000000000000004, 0.0000000000000000, - 0.87266462599716477 }, - { 1.0614897067260523, -0.30000000000000004, 0.0000000000000000, - 1.0471975511965976 }, - { 1.2428416824174218, -0.30000000000000004, 0.0000000000000000, - 1.2217304763960306 }, - { 1.4251795877015925, -0.30000000000000004, 0.0000000000000000, - 1.3962634015954636 }, - { 1.6080486199305126, -0.30000000000000004, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.30000000000000004, nu=0.0000000000000000. -template <typename Tp> -void test061() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data061) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data061[i].k), Tp(data061[i].nu), - Tp(data061[i].phi)); - const Tp f0 = data061[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.30000000000000004, nu=0.10000000000000001. -testcase_ellint_3<double> data062[] = { - { -0.0000000000000000, -0.30000000000000004, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17443631884814378, -0.30000000000000004, 0.10000000000000001, - 0.17453292519943295 }, - { 0.34831316835124926, -0.30000000000000004, 0.10000000000000001, - 0.34906585039886590 }, - { 0.52116586276523857, -0.30000000000000004, 0.10000000000000001, - 0.52359877559829882 }, - { 0.69269385837910036, -0.30000000000000004, 0.10000000000000001, - 0.69813170079773179 }, - { 0.86279023163070856, -0.30000000000000004, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0315321461438265, -0.30000000000000004, 0.10000000000000001, - 1.0471975511965976 }, - { 1.1991449111869024, -0.30000000000000004, 0.10000000000000001, - 1.2217304763960306 }, - { 1.3659561780923211, -0.30000000000000004, 0.10000000000000001, - 1.3962634015954636 }, - { 1.5323534693557526, -0.30000000000000004, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.30000000000000004, nu=0.10000000000000001. -template <typename Tp> -void test062() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data062) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data062[i].k), Tp(data062[i].nu), - Tp(data062[i].phi)); - const Tp f0 = data062[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.30000000000000004, nu=0.20000000000000001. -testcase_ellint_3<double> data063[] = { - { -0.0000000000000000, -0.30000000000000004, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17426098615372090, -0.30000000000000004, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34695402664689923, -0.30000000000000004, 0.20000000000000001, - 0.34906585039886590 }, - { 0.51680555567038933, -0.30000000000000004, 0.20000000000000001, - 0.52359877559829882 }, - { 0.68303375225260210, -0.30000000000000004, 0.20000000000000001, - 0.69813170079773179 }, - { 0.84540662891295026, -0.30000000000000004, 0.20000000000000001, - 0.87266462599716477 }, - { 1.0041834051646927, -0.30000000000000004, 0.20000000000000001, - 1.0471975511965976 }, - { 1.1599952702345711, -0.30000000000000004, 0.20000000000000001, - 1.2217304763960306 }, - { 1.3137179520499163, -0.30000000000000004, 0.20000000000000001, - 1.3962634015954636 }, - { 1.4663658145259875, -0.30000000000000004, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.30000000000000004, nu=0.20000000000000001. -template <typename Tp> -void test063() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data063) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data063[i].k), Tp(data063[i].nu), - Tp(data063[i].phi)); - const Tp f0 = data063[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.30000000000000004, nu=0.29999999999999999. -testcase_ellint_3<double> data064[] = { - { -0.0000000000000000, -0.30000000000000004, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17408628437042845, -0.30000000000000004, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34561356761638401, -0.30000000000000004, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51257058617875850, -0.30000000000000004, 0.29999999999999999, - 0.52359877559829882 }, - { 0.67382207124602866, -0.30000000000000004, 0.29999999999999999, - 0.69813170079773179 }, - { 0.82914751587825131, -0.30000000000000004, 0.29999999999999999, - 0.87266462599716477 }, - { 0.97907434814374950, -0.30000000000000004, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1246399297351584, -0.30000000000000004, 0.29999999999999999, - 1.2217304763960306 }, - { 1.2671793970398146, -0.30000000000000004, 0.29999999999999999, - 1.3962634015954636 }, - { 1.4081767433479089, -0.30000000000000004, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=-0.30000000000000004, nu=0.29999999999999999. -template <typename Tp> -void test064() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data064) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data064[i].k), Tp(data064[i].nu), - Tp(data064[i].phi)); - const Tp f0 = data064[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.30000000000000004, nu=0.40000000000000002. -testcase_ellint_3<double> data065[] = { - { -0.0000000000000000, -0.30000000000000004, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17391220945982730, -0.30000000000000004, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34429133937639689, -0.30000000000000004, 0.40000000000000002, - 0.34906585039886590 }, - { 0.50845471668581632, -0.30000000000000004, 0.40000000000000002, - 0.52359877559829882 }, - { 0.66502347027873854, -0.30000000000000004, 0.40000000000000002, - 0.69813170079773179 }, - { 0.81389191978012254, -0.30000000000000004, 0.40000000000000002, - 0.87266462599716477 }, - { 0.95590618002140593, -0.30000000000000004, 0.40000000000000002, - 1.0471975511965976 }, - { 1.0924915195213121, -0.30000000000000004, 0.40000000000000002, - 1.2217304763960306 }, - { 1.2253651604038058, -0.30000000000000004, 0.40000000000000002, - 1.3962634015954636 }, - { 1.3563643538969761, -0.30000000000000004, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.30000000000000004, nu=0.40000000000000002. -template <typename Tp> -void test065() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data065) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data065[i].k), Tp(data065[i].nu), - Tp(data065[i].phi)); - const Tp f0 = data065[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.30000000000000004, nu=0.50000000000000000. -testcase_ellint_3<double> data066[] = { - { -0.0000000000000000, -0.30000000000000004, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17373875742088235, -0.30000000000000004, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34298690571124157, -0.30000000000000004, 0.50000000000000000, - 0.34906585039886590 }, - { 0.50445214859646936, -0.30000000000000004, 0.50000000000000000, - 0.52359877559829882 }, - { 0.65660648352418516, -0.30000000000000004, 0.50000000000000000, - 0.69813170079773179 }, - { 0.79953670639287289, -0.30000000000000004, 0.50000000000000000, - 0.87266462599716477 }, - { 0.93443393926588558, -0.30000000000000004, 0.50000000000000000, - 1.0471975511965976 }, - { 1.0630838369016911, -0.30000000000000004, 0.50000000000000000, - 1.2217304763960306 }, - { 1.1875197325653026, -0.30000000000000004, 0.50000000000000000, - 1.3962634015954636 }, - { 1.3098448759814960, -0.30000000000000004, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.30000000000000004, nu=0.50000000000000000. -template <typename Tp> -void test066() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data066) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data066[i].k), Tp(data066[i].nu), - Tp(data066[i].phi)); - const Tp f0 = data066[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.30000000000000004, nu=0.59999999999999998. -testcase_ellint_3<double> data067[] = { - { -0.0000000000000000, -0.30000000000000004, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17356592428950826, -0.30000000000000004, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34169984536697379, -0.30000000000000004, 0.59999999999999998, - 0.34906585039886590 }, - { 0.50055748266498457, -0.30000000000000004, 0.59999999999999998, - 0.52359877559829882 }, - { 0.64854298527106768, -0.30000000000000004, 0.59999999999999998, - 0.69813170079773179 }, - { 0.78599329284207431, -0.30000000000000004, 0.59999999999999998, - 0.87266462599716477 }, - { 0.91445452089128221, -0.30000000000000004, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0360412952290587, -0.30000000000000004, 0.59999999999999998, - 1.2217304763960306 }, - { 1.1530473919778639, -0.30000000000000004, 0.59999999999999998, - 1.3962634015954636 }, - { 1.2677758800420666, -0.30000000000000004, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=-0.30000000000000004, nu=0.59999999999999998. -template <typename Tp> -void test067() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data067) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data067[i].k), Tp(data067[i].nu), - Tp(data067[i].phi)); - const Tp f0 = data067[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.30000000000000004, nu=0.69999999999999996. -testcase_ellint_3<double> data068[] = { - { -0.0000000000000000, -0.30000000000000004, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17339370613812227, -0.30000000000000004, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34042975138455933, -0.30000000000000004, 0.69999999999999996, - 0.34906585039886590 }, - { 0.49676568368075985, -0.30000000000000004, 0.69999999999999996, - 0.52359877559829882 }, - { 0.64080774055753720, -0.30000000000000004, 0.69999999999999996, - 0.69813170079773179 }, - { 0.77318507779667278, -0.30000000000000004, 0.69999999999999996, - 0.87266462599716477 }, - { 0.89579782346548631, -0.30000000000000004, 0.69999999999999996, - 1.0471975511965976 }, - { 1.0110573286052202, -0.30000000000000004, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1214710972949633, -0.30000000000000004, 0.69999999999999996, - 1.3962634015954636 }, - { 1.2294913236274980, -0.30000000000000004, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=-0.30000000000000004, nu=0.69999999999999996. -template <typename Tp> -void test068() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data068) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data068[i].k), Tp(data068[i].nu), - Tp(data068[i].phi)); - const Tp f0 = data068[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.30000000000000004, nu=0.80000000000000004. -testcase_ellint_3<double> data069[] = { - { -0.0000000000000000, -0.30000000000000004, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17322209907520361, -0.30000000000000004, 0.80000000000000004, - 0.17453292519943295 }, - { 0.33917623046949996, -0.30000000000000004, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49307204894329176, -0.30000000000000004, 0.80000000000000004, - 0.52359877559829882 }, - { 0.63337802830291723, -0.30000000000000004, 0.80000000000000004, - 0.69813170079773179 }, - { 0.76104540997689407, -0.30000000000000004, 0.80000000000000004, - 0.87266462599716477 }, - { 0.87832009635450736, -0.30000000000000004, 0.80000000000000004, - 1.0471975511965976 }, - { 0.98787879723171790, -0.30000000000000004, 0.80000000000000004, - 1.2217304763960306 }, - { 1.0924036340069336, -0.30000000000000004, 0.80000000000000004, - 1.3962634015954636 }, - { 1.1944567571590046, -0.30000000000000004, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=-0.30000000000000004, nu=0.80000000000000004. -template <typename Tp> -void test069() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data069) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data069[i].k), Tp(data069[i].nu), - Tp(data069[i].phi)); - const Tp f0 = data069[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.30000000000000004, nu=0.90000000000000002. -testcase_ellint_3<double> data070[] = { - { -0.0000000000000000, -0.30000000000000004, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17305109924485948, -0.30000000000000004, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33793890239556984, -0.30000000000000004, 0.90000000000000002, - 0.34906585039886590 }, - { 0.48947218005089738, -0.30000000000000004, 0.90000000000000002, - 0.52359877559829882 }, - { 0.62623332340775151, -0.30000000000000004, 0.90000000000000002, - 0.69813170079773179 }, - { 0.74951596581511148, -0.30000000000000004, 0.90000000000000002, - 0.87266462599716477 }, - { 0.86189886597756005, -0.30000000000000004, 0.90000000000000002, - 1.0471975511965976 }, - { 0.96629451153092005, -0.30000000000000004, 0.90000000000000002, - 1.2217304763960306 }, - { 1.0655269133492680, -0.30000000000000004, 0.90000000000000002, - 1.3962634015954636 }, - { 1.1622376896064912, -0.30000000000000004, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.30000000000000004, nu=0.90000000000000002. -template <typename Tp> -void test070() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data070) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data070[i].k), Tp(data070[i].nu), - Tp(data070[i].phi)); - const Tp f0 = data070[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.6192315188521289e-16 +// mean(f - f_Boost): 3.5249581031848718e-16 +// variance(f - f_Boost): 2.5029385557256515e-31 +// stddev(f - f_Boost): 5.0029376927217987e-16 +const testcase_ellint_3<double> +data050[10] = +{ + { 0.0000000000000000, -0.50000000000000000, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17636918772384180, -0.50000000000000000, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36424950570740700, -0.50000000000000000, 0.90000000000000002, + 0.34906585039886590 }, + { 0.57785404590231426, -0.50000000000000000, 0.90000000000000002, + 0.52359877559829882 }, + { 0.83806480521716531, -0.50000000000000000, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1798568683069752, -0.50000000000000000, 0.90000000000000002, + 0.87266462599716477 }, + { 1.6678766243739607, -0.50000000000000000, 0.90000000000000002, + 1.0471975511965976 }, + { 2.4282976450693483, -0.50000000000000000, 0.90000000000000002, + 1.2217304763960306 }, + { 3.6810787666126656, -0.50000000000000000, 0.90000000000000002, + 1.3962634015954636 }, + { 5.5355132096026454, -0.50000000000000000, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler050 = 2.5000000000000020e-13; + +// Test data for k=-0.39999999999999991, nu=0.0000000000000000. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.1423314994346225e-16 +// mean(f - f_Boost): 1.9428902930940238e-17 +// variance(f - f_Boost): 2.2263750157116445e-32 +// stddev(f - f_Boost): 1.4921042241450980e-16 +const testcase_ellint_3<double> +data051[10] = +{ + { 0.0000000000000000, -0.39999999999999991, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17467414669441528, -0.39999999999999991, 0.0000000000000000, + 0.17453292519943295 }, + { 0.35018222772483443, -0.39999999999999991, 0.0000000000000000, + 0.34906585039886590 }, + { 0.52729015917508748, -0.39999999999999991, 0.0000000000000000, + 0.52359877559829882 }, + { 0.70662374407341244, -0.39999999999999991, 0.0000000000000000, + 0.69813170079773179 }, + { 0.88859210497602159, -0.39999999999999991, 0.0000000000000000, + 0.87266462599716477 }, + { 1.0733136290471381, -0.39999999999999991, 0.0000000000000000, + 1.0471975511965976 }, + { 1.2605612170157066, -0.39999999999999991, 0.0000000000000000, + 1.2217304763960306 }, + { 1.4497513956433439, -0.39999999999999991, 0.0000000000000000, + 1.3962634015954636 }, + { 1.6399998658645112, -0.39999999999999991, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler051 = 2.5000000000000020e-13; + +// Test data for k=-0.39999999999999991, nu=0.10000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.8489340395463703e-16 +// mean(f - f_Boost): 6.3837823915946496e-17 +// variance(f - f_Boost): 4.4785242050000272e-32 +// stddev(f - f_Boost): 2.1162523963365114e-16 +const testcase_ellint_3<double> +data052[10] = +{ + { 0.0000000000000000, -0.39999999999999991, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17485086590796767, -0.39999999999999991, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35158366412506992, -0.39999999999999991, 0.10000000000000001, + 0.34906585039886590 }, + { 0.53194731675711726, -0.39999999999999991, 0.10000000000000001, + 0.52359877559829882 }, + { 0.71740615528010931, -0.39999999999999991, 0.10000000000000001, + 0.69813170079773179 }, + { 0.90896157773487030, -0.39999999999999991, 0.10000000000000001, + 0.87266462599716477 }, + { 1.1069605483834348, -0.39999999999999991, 0.10000000000000001, + 1.0471975511965976 }, + { 1.3109353428823001, -0.39999999999999991, 0.10000000000000001, + 1.2217304763960306 }, + { 1.5195460789903448, -0.39999999999999991, 0.10000000000000001, + 1.3962634015954636 }, + { 1.7306968836847187, -0.39999999999999991, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler052 = 2.5000000000000020e-13; + +// Test data for k=-0.39999999999999991, nu=0.20000000000000001. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.0467985583872730e-16 +// mean(f - f_Boost): 8.6042284408449634e-17 +// variance(f - f_Boost): 1.5826864298542218e-32 +// stddev(f - f_Boost): 1.2580486595733180e-16 +const testcase_ellint_3<double> +data053[10] = +{ + { 0.0000000000000000, -0.39999999999999991, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17502822886437389, -0.39999999999999991, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35300530062530805, -0.39999999999999991, 0.20000000000000001, + 0.34906585039886590 }, + { 0.53675259548210896, -0.39999999999999991, 0.20000000000000001, + 0.52359877559829882 }, + { 0.72878006428676934, -0.39999999999999991, 0.20000000000000001, + 0.69813170079773179 }, + { 0.93100219010583563, -0.39999999999999991, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1443487271187609, -0.39999999999999991, 0.20000000000000001, + 1.0471975511965976 }, + { 1.3683427764108813, -0.39999999999999991, 0.20000000000000001, + 1.2217304763960306 }, + { 1.6008221459300933, -0.39999999999999991, 0.20000000000000001, + 1.3962634015954636 }, + { 1.8380358826317627, -0.39999999999999991, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler053 = 2.5000000000000020e-13; + +// Test data for k=-0.39999999999999991, nu=0.30000000000000004. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 2.9973414591826100e-16 +// mean(f - f_Boost): 8.6042284408449634e-17 +// variance(f - f_Boost): 1.5826864298542218e-32 +// stddev(f - f_Boost): 1.2580486595733180e-16 +const testcase_ellint_3<double> +data054[10] = +{ + { 0.0000000000000000, -0.39999999999999991, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17520623975982899, -0.39999999999999991, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35444766141612105, -0.39999999999999991, 0.30000000000000004, + 0.34906585039886590 }, + { 0.54171455841536009, -0.39999999999999991, 0.30000000000000004, + 0.52359877559829882 }, + { 0.74080517001084012, -0.39999999999999991, 0.30000000000000004, + 0.69813170079773179 }, + { 0.95496950509296563, -0.39999999999999991, 0.30000000000000004, + 0.87266462599716477 }, + { 1.1862627879844718, -0.39999999999999991, 0.30000000000000004, + 1.0471975511965976 }, + { 1.4346501803799458, -0.39999999999999991, 0.30000000000000004, + 1.2217304763960306 }, + { 1.6971744798077697, -0.39999999999999991, 0.30000000000000004, + 1.3962634015954636 }, + { 1.9677924132520139, -0.39999999999999991, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler054 = 2.5000000000000020e-13; + +// Test data for k=-0.39999999999999991, nu=0.40000000000000002. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.2577246923979600e-16 +// mean(f - f_Boost): 1.8596235662471373e-16 +// variance(f - f_Boost): 1.6222417021441306e-31 +// stddev(f - f_Boost): 4.0277061736727151e-16 +const testcase_ellint_3<double> +data055[10] = +{ + { 0.0000000000000000, -0.39999999999999991, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17538490283034375, -0.39999999999999991, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35591129064319948, -0.39999999999999991, 0.40000000000000002, + 0.34906585039886590 }, + { 0.54684250413264535, -0.39999999999999991, 0.40000000000000002, + 0.52359877559829882 }, + { 0.75355027742668290, -0.39999999999999991, 0.40000000000000002, + 0.69813170079773179 }, + { 0.98117935026780634, -0.39999999999999991, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2337464222030734, -0.39999999999999991, 0.40000000000000002, + 1.0471975511965976 }, + { 1.5125183419289221, -0.39999999999999991, 0.40000000000000002, + 1.2217304763960306 }, + { 1.8140224451130311, -0.39999999999999991, 0.40000000000000002, + 1.3962634015954636 }, + { 2.1289968719280026, -0.39999999999999991, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler055 = 2.5000000000000020e-13; + +// Test data for k=-0.39999999999999991, nu=0.50000000000000000. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.8009196014748294e-16 +// mean(f - f_Boost): 1.6375789613221060e-16 +// variance(f - f_Boost): 6.4788283329186610e-32 +// stddev(f - f_Boost): 2.5453542647181080e-16 +const testcase_ellint_3<double> +data056[10] = +{ + { 0.0000000000000000, -0.39999999999999991, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17556422235224273, -0.39999999999999991, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35739675341763921, -0.39999999999999991, 0.50000000000000000, + 0.34906585039886590 }, + { 0.55214655195037188, -0.39999999999999991, 0.50000000000000000, + 0.52359877559829882 }, + { 0.76709520942047438, -0.39999999999999991, 0.50000000000000000, + 0.69813170079773179 }, + { 1.0100278761577499, -0.39999999999999991, 0.50000000000000000, + 0.87266462599716477 }, + { 1.2882265661384342, -0.39999999999999991, 0.50000000000000000, + 1.0471975511965976 }, + { 1.6059059780051874, -0.39999999999999991, 0.50000000000000000, + 1.2217304763960306 }, + { 1.9600182740224081, -0.39999999999999991, 0.50000000000000000, + 1.3962634015954636 }, + { 2.3367461373176508, -0.39999999999999991, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler056 = 2.5000000000000020e-13; + +// Test data for k=-0.39999999999999991, nu=0.60000000000000009. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 2.8411408870840790e-16 +// mean(f - f_Boost): 9.7144514654701197e-17 +// variance(f - f_Boost): 1.4860570558543486e-32 +// stddev(f - f_Boost): 1.2190393988113545e-16 +const testcase_ellint_3<double> +data057[10] = +{ + { 0.0000000000000000, -0.39999999999999991, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17574420264267029, -0.39999999999999991, 0.60000000000000009, + 0.17453292519943295 }, + { 0.35890463689046265, -0.39999999999999991, 0.60000000000000009, + 0.34906585039886590 }, + { 0.55763773975194486, -0.39999999999999991, 0.60000000000000009, + 0.52359877559829882 }, + { 0.78153324227761267, -0.39999999999999991, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0420205885765887, -0.39999999999999991, 0.60000000000000009, + 0.87266462599716477 }, + { 1.3517205230381770, -0.39999999999999991, 0.60000000000000009, + 1.0471975511965976 }, + { 1.7210360970313896, -0.39999999999999991, 0.60000000000000009, + 1.2217304763960306 }, + { 2.1500780510169242, -0.39999999999999991, 0.60000000000000009, + 1.3962634015954636 }, + { 2.6186940209850191, -0.39999999999999991, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler057 = 2.5000000000000020e-13; + +// Test data for k=-0.39999999999999991, nu=0.70000000000000007. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.1553900340611668e-16 +// mean(f - f_Boost): 1.1657341758564144e-16 +// variance(f - f_Boost): 1.3242789405258207e-32 +// stddev(f - f_Boost): 1.1507731924779187e-16 +const testcase_ellint_3<double> +data058[10] = +{ + { 0.0000000000000000, -0.39999999999999991, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17592484806010436, -0.39999999999999991, 0.70000000000000007, + 0.17453292519943295 }, + { 0.36043555139631439, -0.39999999999999991, 0.70000000000000007, + 0.34906585039886590 }, + { 0.56332813669944881, -0.39999999999999991, 0.70000000000000007, + 0.52359877559829882 }, + { 0.79697424562157548, -0.39999999999999991, 0.70000000000000007, + 0.69813170079773179 }, + { 1.0778155987523672, -0.39999999999999991, 0.70000000000000007, + 0.87266462599716477 }, + { 1.4272018169896268, -0.39999999999999991, 0.70000000000000007, + 1.0471975511965976 }, + { 1.8684377907453380, -0.39999999999999991, 0.70000000000000007, + 1.2217304763960306 }, + { 2.4128677409207469, -0.39999999999999991, 0.70000000000000007, + 1.3962634015954636 }, + { 3.0327078743873241, -0.39999999999999991, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler058 = 2.5000000000000020e-13; + +// Test data for k=-0.39999999999999991, nu=0.80000000000000004. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.5727642219519274e-16 +// mean(f - f_Boost): 2.1926904736346843e-16 +// variance(f - f_Boost): 1.5293405480859847e-31 +// stddev(f - f_Boost): 3.9106783913868252e-16 +const testcase_ellint_3<double> +data059[10] = +{ + { 0.0000000000000000, -0.39999999999999991, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17610616300487833, -0.39999999999999991, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36199013167171978, -0.39999999999999991, 0.80000000000000004, + 0.34906585039886590 }, + { 0.56923097361842423, -0.39999999999999991, 0.80000000000000004, + 0.52359877559829882 }, + { 0.81354878456624347, -0.39999999999999991, 0.80000000000000004, + 0.69813170079773179 }, + { 1.1182902719261825, -0.39999999999999991, 0.80000000000000004, + 0.87266462599716477 }, + { 1.5192950589409022, -0.39999999999999991, 0.80000000000000004, + 1.0471975511965976 }, + { 2.0678761710223981, -0.39999999999999991, 0.80000000000000004, + 1.2217304763960306 }, + { 2.8135222249879783, -0.39999999999999991, 0.80000000000000004, + 1.3962634015954636 }, + { 3.7289548002199902, -0.39999999999999991, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler059 = 2.5000000000000020e-13; + +// Test data for k=-0.39999999999999991, nu=0.90000000000000002. +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.0221626338023938e-16 +// mean(f - f_Boost): 4.1910919179599658e-16 +// variance(f - f_Boost): 6.2246150910247033e-31 +// stddev(f - f_Boost): 7.8896229891070860e-16 +const testcase_ellint_3<double> +data060[10] = +{ + { 0.0000000000000000, -0.39999999999999991, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17628815191971123, -0.39999999999999991, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36356903815378772, -0.39999999999999991, 0.90000000000000002, + 0.34906585039886590 }, + { 0.57536079447000310, -0.39999999999999991, 0.90000000000000002, + 0.52359877559829882 }, + { 0.83141355850172571, -0.39999999999999991, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1646481598721361, -0.39999999999999991, 0.90000000000000002, + 0.87266462599716477 }, + { 1.6357275034001995, -0.39999999999999991, 0.90000000000000002, + 1.0471975511965976 }, + { 2.3628787566572398, -0.39999999999999991, 0.90000000000000002, + 1.2217304763960306 }, + { 3.5521010369134958, -0.39999999999999991, 0.90000000000000002, + 1.3962634015954636 }, + { 5.3055535102872513, -0.39999999999999991, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler060 = 2.5000000000000020e-13; + +// Test data for k=-0.29999999999999993, nu=0.0000000000000000. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.2241249691539529e-16 +// mean(f - f_Boost): 4.9960036108132046e-17 +// variance(f - f_Boost): 4.6872855002064458e-32 +// stddev(f - f_Boost): 2.1650139722889657e-16 +const testcase_ellint_3<double> +data061[10] = +{ + { 0.0000000000000000, -0.29999999999999993, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17461228653000099, -0.29999999999999993, 0.0000000000000000, + 0.17453292519943295 }, + { 0.34969146102798421, -0.29999999999999993, 0.0000000000000000, + 0.34906585039886590 }, + { 0.52565822873726309, -0.29999999999999993, 0.0000000000000000, + 0.52359877559829882 }, + { 0.70284226512408543, -0.29999999999999993, 0.0000000000000000, + 0.69813170079773179 }, + { 0.88144139195111171, -0.29999999999999993, 0.0000000000000000, + 0.87266462599716477 }, + { 1.0614897067260520, -0.29999999999999993, 0.0000000000000000, + 1.0471975511965976 }, + { 1.2428416824174220, -0.29999999999999993, 0.0000000000000000, + 1.2217304763960306 }, + { 1.4251795877015929, -0.29999999999999993, 0.0000000000000000, + 1.3962634015954636 }, + { 1.6080486199305126, -0.29999999999999993, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler061 = 2.5000000000000020e-13; + +// Test data for k=-0.29999999999999993, nu=0.10000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.1872304407982844e-16 +// mean(f - f_Boost): 9.4368957093138303e-17 +// variance(f - f_Boost): 4.0359883022230488e-32 +// stddev(f - f_Boost): 2.0089769292411121e-16 +const testcase_ellint_3<double> +data062[10] = +{ + { 0.0000000000000000, -0.29999999999999993, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17478889331392972, -0.29999999999999993, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35108939018329183, -0.29999999999999993, 0.10000000000000001, + 0.34906585039886590 }, + { 0.53028990896115835, -0.29999999999999993, 0.10000000000000001, + 0.52359877559829882 }, + { 0.71352417052371409, -0.29999999999999993, 0.10000000000000001, + 0.69813170079773179 }, + { 0.90153086032405894, -0.29999999999999993, 0.10000000000000001, + 0.87266462599716477 }, + { 1.0945187977283313, -0.29999999999999993, 0.10000000000000001, + 1.0471975511965976 }, + { 1.2920699268385680, -0.29999999999999993, 0.10000000000000001, + 1.2217304763960306 }, + { 1.4931243665896394, -0.29999999999999993, 0.10000000000000001, + 1.3962634015954636 }, + { 1.6960848815118226, -0.29999999999999993, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler062 = 2.5000000000000020e-13; + +// Test data for k=-0.29999999999999993, nu=0.20000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.2247497610332889e-16 +// mean(f - f_Boost): 1.1102230246251565e-16 +// variance(f - f_Boost): 3.8043060629871325e-32 +// stddev(f - f_Boost): 1.9504630380981672e-16 +const testcase_ellint_3<double> +data063[10] = +{ + { 0.0000000000000000, -0.29999999999999993, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17496614335337535, -0.29999999999999993, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35250745937139372, -0.29999999999999993, 0.20000000000000001, + 0.34906585039886590 }, + { 0.53506875002836884, -0.29999999999999993, 0.20000000000000001, + 0.52359877559829882 }, + { 0.72479106622248191, -0.29999999999999993, 0.20000000000000001, + 0.69813170079773179 }, + { 0.92326451535891607, -0.29999999999999993, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1312092060698349, -0.29999999999999993, 0.20000000000000001, + 1.0471975511965976 }, + { 1.3481473154592321, -0.29999999999999993, 0.20000000000000001, + 1.2217304763960306 }, + { 1.5722049569662748, -0.29999999999999993, 0.20000000000000001, + 1.3962634015954636 }, + { 1.8002173372290498, -0.29999999999999993, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler063 = 2.5000000000000020e-13; + +// Test data for k=-0.29999999999999993, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.1678685180047551e-16 +// mean(f - f_Boost): 1.0547118733938987e-16 +// variance(f - f_Boost): 7.5633408838247182e-32 +// stddev(f - f_Boost): 2.7501528837184157e-16 +const testcase_ellint_3<double> +data064[10] = +{ + { 0.0000000000000000, -0.29999999999999993, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17514404084107435, -0.29999999999999993, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35394619108645647, -0.29999999999999993, 0.30000000000000004, + 0.34906585039886590 }, + { 0.54000325463372689, -0.29999999999999993, 0.30000000000000004, + 0.52359877559829882 }, + { 0.73670193794067651, -0.29999999999999993, 0.30000000000000004, + 0.69813170079773179 }, + { 0.94689345491722177, -0.29999999999999993, 0.30000000000000004, + 0.87266462599716477 }, + { 1.1723274608389140, -0.29999999999999993, 0.30000000000000004, + 1.0471975511965976 }, + { 1.4128880552936287, -0.29999999999999993, 0.30000000000000004, + 1.2217304763960306 }, + { 1.6659010047449661, -0.29999999999999993, 0.30000000000000004, + 1.3962634015954636 }, + { 1.9260216862473254, -0.29999999999999993, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler064 = 2.5000000000000020e-13; + +// Test data for k=-0.29999999999999993, nu=0.40000000000000002. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.3983279132797385e-16 +// mean(f - f_Boost): 1.1657341758564144e-16 +// variance(f - f_Boost): 1.8245832308692586e-31 +// stddev(f - f_Boost): 4.2715140534349863e-16 +const testcase_ellint_3<double> +data065[10] = +{ + { 0.0000000000000000, -0.29999999999999993, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17532259000954434, -0.29999999999999993, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35540612770983693, -0.29999999999999993, 0.40000000000000002, + 0.34906585039886590 }, + { 0.54510265552938919, -0.29999999999999993, 0.40000000000000002, + 0.52359877559829882 }, + { 0.74932476310965057, -0.29999999999999993, 0.40000000000000002, + 0.69813170079773179 }, + { 0.97272793583093109, -0.29999999999999993, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2188928987074241, -0.29999999999999993, 0.40000000000000002, + 1.0471975511965976 }, + { 1.4888771674085941, -0.29999999999999993, 0.40000000000000002, + 1.2217304763960306 }, + { 1.7794558498219191, -0.29999999999999993, 0.40000000000000002, + 1.3962634015954636 }, + { 2.0822121773175528, -0.29999999999999993, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler065 = 2.5000000000000020e-13; + +// Test data for k=-0.29999999999999993, nu=0.50000000000000000. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.0516138451673425e-16 +// mean(f - f_Boost): 4.7184478546569152e-17 +// variance(f - f_Boost): 1.9448563670505968e-32 +// stddev(f - f_Boost): 1.3945810722401896e-16 +const testcase_ellint_3<double> +data066[10] = +{ + { 0.0000000000000000, -0.29999999999999993, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17550179513158179, -0.29999999999999993, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35688783251681200, -0.29999999999999993, 0.50000000000000000, + 0.34906585039886590 }, + { 0.55037700010142798, -0.29999999999999993, 0.50000000000000000, + 0.52359877559829882 }, + { 0.76273839789895992, -0.29999999999999993, 0.50000000000000000, + 0.69813170079773179 }, + { 1.0011570518830419, -0.29999999999999993, 0.50000000000000000, + 0.87266462599716477 }, + { 1.2722987414055109, -0.29999999999999993, 0.50000000000000000, + 1.0471975511965976 }, + { 1.5799590511080066, -0.29999999999999993, 0.50000000000000000, + 1.2217304763960306 }, + { 1.9212367220124293, -0.29999999999999993, 0.50000000000000000, + 1.3962634015954636 }, + { 2.2833505881933971, -0.29999999999999993, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler066 = 2.5000000000000020e-13; + +// Test data for k=-0.29999999999999993, nu=0.60000000000000009. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.2121157428443725e-16 +// mean(f - f_Boost): 1.9428902930940239e-16 +// variance(f - f_Boost): 1.5987596229703424e-31 +// stddev(f - f_Boost): 3.9984492281012430e-16 +const testcase_ellint_3<double> +data067[10] = +{ + { 0.0000000000000000, -0.29999999999999993, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17568166052076745, -0.29999999999999993, 0.60000000000000009, + 0.17453292519943295 }, + { 0.35839189074731181, -0.29999999999999993, 0.60000000000000009, + 0.34906585039886590 }, + { 0.55583724744367558, -0.29999999999999993, 0.60000000000000009, + 0.52359877559829882 }, + { 0.77703498090888223, -0.29999999999999993, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0326772113675962, -0.29999999999999993, 0.60000000000000009, + 0.87266462599716477 }, + { 1.3345139983717369, -0.29999999999999993, 0.60000000000000009, + 1.0471975511965976 }, + { 1.6921742922838403, -0.29999999999999993, 0.60000000000000009, + 1.2217304763960306 }, + { 2.1056608968472186, -0.29999999999999993, 0.60000000000000009, + 1.3962634015954636 }, + { 2.5560975528589061, -0.29999999999999993, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler067 = 2.5000000000000020e-13; + +// Test data for k=-0.29999999999999993, nu=0.70000000000000007. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.0088945789059381e-16 +// mean(f - f_Boost): 1.6653345369377348e-16 +// variance(f - f_Boost): 3.1994213989721786e-31 +// stddev(f - f_Boost): 5.6563428104846852e-16 +const testcase_ellint_3<double> +data068[10] = +{ + { 0.0000000000000000, -0.29999999999999993, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17586219053197988, -0.29999999999999993, 0.70000000000000007, + 0.17453292519943295 }, + { 0.35991891074557669, -0.29999999999999993, 0.70000000000000007, + 0.34906585039886590 }, + { 0.56149538019961731, -0.29999999999999993, 0.70000000000000007, + 0.52359877559829882 }, + { 0.79232303189667685, -0.29999999999999993, 0.70000000000000007, + 0.69813170079773179 }, + { 1.0679345542878826, -0.29999999999999993, 0.70000000000000007, + 0.87266462599716477 }, + { 1.4084400085913955, -0.29999999999999993, 0.70000000000000007, + 1.0471975511965976 }, + { 1.8357382859296454, -0.29999999999999993, 0.70000000000000007, + 1.2217304763960306 }, + { 2.3604197996171519, -0.29999999999999993, 0.70000000000000007, + 1.3962634015954636 }, + { 2.9562123549913872, -0.29999999999999993, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler068 = 2.5000000000000020e-13; + +// Test data for k=-0.29999999999999993, nu=0.80000000000000004. +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.1197887707781618e-16 +// mean(f - f_Boost): 3.4416913763379854e-16 +// variance(f - f_Boost): 4.3461914185990199e-31 +// stddev(f - f_Boost): 6.5925650687718054e-16 +const testcase_ellint_3<double> +data069[10] = +{ + { 0.0000000000000000, -0.29999999999999993, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17604338956191670, -0.29999999999999993, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36146952517410791, -0.29999999999999993, 0.80000000000000004, + 0.34906585039886590 }, + { 0.56736453393774644, -0.29999999999999993, 0.80000000000000004, + 0.52359877559829882 }, + { 0.80873149979001091, -0.29999999999999993, 0.80000000000000004, + 0.69813170079773179 }, + { 1.1077903069860620, -0.29999999999999993, 0.80000000000000004, + 0.87266462599716477 }, + { 1.4985874311132998, -0.29999999999999993, 0.80000000000000004, + 1.0471975511965976 }, + { 2.0298167266724954, -0.29999999999999993, 0.80000000000000004, + 1.2217304763960306 }, + { 2.7483929054985432, -0.29999999999999993, 0.80000000000000004, + 1.3962634015954636 }, + { 3.6283050484567170, -0.29999999999999993, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler069 = 2.5000000000000020e-13; + +// Test data for k=-0.29999999999999993, nu=0.90000000000000002. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 5.1301806687926828e-16 +// mean(f - f_Boost): 4.1633363423443370e-16 +// variance(f - f_Boost): 2.2835347143080263e-31 +// stddev(f - f_Boost): 4.7786344433405093e-16 +const testcase_ellint_3<double> +data070[10] = +{ + { 0.0000000000000000, -0.29999999999999993, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17622526204962433, -0.29999999999999993, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36304439230777141, -0.29999999999999993, 0.90000000000000002, + 0.34906585039886590 }, + { 0.57345914744719195, -0.29999999999999993, 0.90000000000000002, + 0.52359877559829882 }, + { 0.82641512928845162, -0.29999999999999993, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1534256210757743, -0.29999999999999993, 0.90000000000000002, + 0.87266462599716477 }, + { 1.6124900353411677, -0.29999999999999993, 0.90000000000000002, + 1.0471975511965976 }, + { 2.3165905514845089, -0.29999999999999993, 0.90000000000000002, + 1.2217304763960306 }, + { 3.4625619526539824, -0.29999999999999993, 0.90000000000000002, + 1.3962634015954636 }, + { 5.1479514944016787, -0.29999999999999993, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler070 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.0000000000000000. -testcase_ellint_3<double> data071[] = { - { -0.0000000000000000, -0.19999999999999996, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17456817290292811, -0.19999999999999996, 0.0000000000000000, - 0.17453292519943295 }, - { 0.34934315932086801, -0.19999999999999996, 0.0000000000000000, - 0.34906585039886590 }, - { 0.52450880529443988, -0.19999999999999996, 0.0000000000000000, - 0.52359877559829882 }, - { 0.70020491009844910, -0.19999999999999996, 0.0000000000000000, - 0.69813170079773179 }, - { 0.87651006649967955, -0.19999999999999996, 0.0000000000000000, - 0.87266462599716477 }, - { 1.0534305870298994, -0.19999999999999996, 0.0000000000000000, - 1.0471975511965976 }, - { 1.2308975521670784, -0.19999999999999996, 0.0000000000000000, - 1.2217304763960306 }, - { 1.4087733584990738, -0.19999999999999996, 0.0000000000000000, - 1.3962634015954636 }, - { 1.5868678474541664, -0.19999999999999996, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.19999999999999996, nu=0.0000000000000000. -template <typename Tp> -void test071() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data071) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data071[i].k), Tp(data071[i].nu), - Tp(data071[i].phi)); - const Tp f0 = data071[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 4.2156475739151676e-16 +// mean(f - f_Boost): -5.2735593669694933e-17 +// variance(f - f_Boost): 3.0473442641042680e-32 +// stddev(f - f_Boost): 1.7456644190978597e-16 +const testcase_ellint_3<double> +data071[10] = +{ + { 0.0000000000000000, -0.19999999999999996, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17456817290292806, -0.19999999999999996, 0.0000000000000000, + 0.17453292519943295 }, + { 0.34934315932086796, -0.19999999999999996, 0.0000000000000000, + 0.34906585039886590 }, + { 0.52450880529443988, -0.19999999999999996, 0.0000000000000000, + 0.52359877559829882 }, + { 0.70020491009844887, -0.19999999999999996, 0.0000000000000000, + 0.69813170079773179 }, + { 0.87651006649967977, -0.19999999999999996, 0.0000000000000000, + 0.87266462599716477 }, + { 1.0534305870298994, -0.19999999999999996, 0.0000000000000000, + 1.0471975511965976 }, + { 1.2308975521670789, -0.19999999999999996, 0.0000000000000000, + 1.2217304763960306 }, + { 1.4087733584990738, -0.19999999999999996, 0.0000000000000000, + 1.3962634015954636 }, + { 1.5868678474541662, -0.19999999999999996, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler071 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.10000000000000001. -testcase_ellint_3<double> data072[] = { - { -0.0000000000000000, -0.19999999999999996, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17439228502691750, -0.19999999999999996, 0.10000000000000001, - 0.17453292519943295 }, - { 0.34796731137565740, -0.19999999999999996, 0.10000000000000001, - 0.34906585039886590 }, - { 0.52003370294544848, -0.19999999999999996, 0.10000000000000001, - 0.52359877559829882 }, - { 0.69012222258631495, -0.19999999999999996, 0.10000000000000001, - 0.69813170079773179 }, - { 0.85803491465566772, -0.19999999999999996, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0238463961099364, -0.19999999999999996, 0.10000000000000001, - 1.0471975511965976 }, - { 1.1878691059202153, -0.19999999999999996, 0.10000000000000001, - 1.2217304763960306 }, - { 1.3505985031831940, -0.19999999999999996, 0.10000000000000001, - 1.3962634015954636 }, - { 1.5126513474261092, -0.19999999999999996, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.19999999999999996, nu=0.10000000000000001. -template <typename Tp> -void test072() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data072) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data072[i].k), Tp(data072[i].nu), - Tp(data072[i].phi)); - const Tp f0 = data072[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 4.0890622182605400e-16 +// mean(f - f_Boost): -3.8857805861880476e-17 +// variance(f - f_Boost): 2.8794792590749608e-32 +// stddev(f - f_Boost): 1.6969028431454054e-16 +const testcase_ellint_3<double> +data072[10] = +{ + { 0.0000000000000000, -0.19999999999999996, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17474469953608965, -0.19999999999999996, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35073860234984255, -0.19999999999999996, 0.10000000000000001, + 0.34906585039886590 }, + { 0.52912258712951521, -0.19999999999999996, 0.10000000000000001, + 0.52359877559829882 }, + { 0.71081701558898069, -0.19999999999999996, 0.10000000000000001, + 0.69813170079773179 }, + { 0.89640758521169384, -0.19999999999999996, 0.10000000000000001, + 0.87266462599716477 }, + { 1.0860417038089853, -0.19999999999999996, 0.10000000000000001, + 1.0471975511965976 }, + { 1.2793599255528623, -0.19999999999999996, 0.10000000000000001, + 1.2217304763960306 }, + { 1.4754938544089076, -0.19999999999999996, 0.10000000000000001, + 1.3962634015954636 }, + { 1.6731552050562593, -0.19999999999999996, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler072 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.20000000000000001. -testcase_ellint_3<double> data073[] = { - { -0.0000000000000000, -0.19999999999999996, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17421703179583750, -0.19999999999999996, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34661057411998791, -0.19999999999999996, 0.20000000000000001, - 0.34906585039886590 }, - { 0.51569006052647393, -0.19999999999999996, 0.20000000000000001, - 0.52359877559829882 }, - { 0.68052412821107278, -0.19999999999999996, 0.20000000000000001, - 0.69813170079773179 }, - { 0.84081341263313825, -0.19999999999999996, 0.20000000000000001, - 0.87266462599716477 }, - { 0.99683359988842890, -0.19999999999999996, 0.20000000000000001, - 1.0471975511965976 }, - { 1.1493086715118852, -0.19999999999999996, 0.20000000000000001, - 1.2217304763960306 }, - { 1.2992699693957541, -0.19999999999999996, 0.20000000000000001, - 1.3962634015954636 }, - { 1.4479323932249568, -0.19999999999999996, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.19999999999999996, nu=0.20000000000000001. -template <typename Tp> -void test073() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data073) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data073[i].k), Tp(data073[i].nu), - Tp(data073[i].phi)); - const Tp f0 = data073[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.19999999999999996, nu=0.29999999999999999. -testcase_ellint_3<double> data074[] = { - { -0.0000000000000000, -0.19999999999999996, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17404240913577707, -0.19999999999999996, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34527248032587193, -0.19999999999999996, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51147118981668416, -0.19999999999999996, 0.29999999999999999, - 0.52359877559829882 }, - { 0.67137107867777635, -0.19999999999999996, 0.29999999999999999, - 0.69813170079773179 }, - { 0.82470418188668893, -0.19999999999999996, 0.29999999999999999, - 0.87266462599716477 }, - { 0.97202873223594299, -0.19999999999999996, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1144773569375266, -0.19999999999999996, 0.29999999999999999, - 1.2217304763960306 }, - { 1.2535292433701000, -0.19999999999999996, 0.29999999999999999, - 1.3962634015954636 }, - { 1.3908453514752481, -0.19999999999999996, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=-0.19999999999999996, nu=0.29999999999999999. -template <typename Tp> -void test074() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data074) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data074[i].k), Tp(data074[i].nu), - Tp(data074[i].phi)); - const Tp f0 = data074[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 3.9570963716579749e-16 +// mean(f - f_Boost): -5.8286708792820721e-17 +// variance(f - f_Boost): 3.1158217732380362e-32 +// stddev(f - f_Boost): 1.7651690494788412e-16 +const testcase_ellint_3<double> +data073[10] = +{ + { 0.0000000000000000, -0.19999999999999996, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17492186907740698, -0.19999999999999996, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35215414286134267, -0.19999999999999996, 0.20000000000000001, + 0.34906585039886590 }, + { 0.53388285615182440, -0.19999999999999996, 0.20000000000000001, + 0.52359877559829882 }, + { 0.72200960282688265, -0.19999999999999996, 0.20000000000000001, + 0.69813170079773179 }, + { 0.91793087614428526, -0.19999999999999996, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1222602841587976, -0.19999999999999996, 0.20000000000000001, + 1.0471975511965976 }, + { 1.3345489407496247, -0.19999999999999996, 0.20000000000000001, + 1.2217304763960306 }, + { 1.5531225705475502, -0.19999999999999996, 0.20000000000000001, + 1.3962634015954636 }, + { 1.7751816279738935, -0.19999999999999996, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler073 = 2.5000000000000020e-13; + +// Test data for k=-0.19999999999999996, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.6785817924053817e-16 +// mean(f - f_Boost): -1.1102230246251566e-17 +// variance(f - f_Boost): 9.9840208317034302e-32 +// stddev(f - f_Boost): 3.1597501217190311e-16 +const testcase_ellint_3<double> +data074[10] = +{ + { 0.0000000000000000, -0.19999999999999996, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17509968571715159, -0.19999999999999996, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35359030214835629, -0.19999999999999996, 0.30000000000000004, + 0.34906585039886590 }, + { 0.53879807274537084, -0.19999999999999996, 0.30000000000000004, + 0.52359877559829882 }, + { 0.73384116418059731, -0.19999999999999996, 0.30000000000000004, + 0.69813170079773179 }, + { 0.94132799329524031, -0.19999999999999996, 0.30000000000000004, + 0.87266462599716477 }, + { 1.1628407021801439, -0.19999999999999996, 0.30000000000000004, + 1.0471975511965976 }, + { 1.3982440216739438, -0.19999999999999996, 0.30000000000000004, + 1.2217304763960306 }, + { 1.6450634983653640, -0.19999999999999996, 0.30000000000000004, + 1.3962634015954636 }, + { 1.8983924169967099, -0.19999999999999996, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler074 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.40000000000000002. -testcase_ellint_3<double> data075[] = { - { -0.0000000000000000, -0.19999999999999996, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17386841301066677, -0.19999999999999996, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34395257914113253, -0.19999999999999996, 0.40000000000000002, - 0.34906585039886590 }, - { 0.50737088376869466, -0.19999999999999996, 0.40000000000000002, - 0.52359877559829882 }, - { 0.66262801717277664, -0.19999999999999996, 0.40000000000000002, - 0.69813170079773179 }, - { 0.80958766645079094, -0.19999999999999996, 0.40000000000000002, - 0.87266462599716477 }, - { 0.94913754236162040, -0.19999999999999996, 0.40000000000000002, - 1.0471975511965976 }, - { 1.0827985514223000, -0.19999999999999996, 0.40000000000000002, - 1.2217304763960306 }, - { 1.2124212429050478, -0.19999999999999996, 0.40000000000000002, - 1.3962634015954636 }, - { 1.3400002519661010, -0.19999999999999996, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.19999999999999996, nu=0.40000000000000002. -template <typename Tp> -void test075() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data075) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data075[i].k), Tp(data075[i].nu), - Tp(data075[i].phi)); - const Tp f0 = data075[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.3298410018355870e-16 +// mean(f - f_Boost): 1.3877787807814457e-17 +// variance(f - f_Boost): 9.4370567274974557e-32 +// stddev(f - f_Boost): 3.0719792850046133e-16 +const testcase_ellint_3<double> +data075[10] = +{ + { 0.0000000000000000, -0.19999999999999996, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17527815368535152, -0.19999999999999996, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35504762134297801, -0.19999999999999996, 0.40000000000000002, + 0.34906585039886590 }, + { 0.54387742353211344, -0.19999999999999996, 0.40000000000000002, + 0.52359877559829882 }, + { 0.74637910471804259, -0.19999999999999996, 0.40000000000000002, + 0.69813170079773179 }, + { 0.96690539714174639, -0.19999999999999996, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2087859420184757, -0.19999999999999996, 0.40000000000000002, + 1.0471975511965976 }, + { 1.4729799844168852, -0.19999999999999996, 0.40000000000000002, + 1.2217304763960306 }, + { 1.7564445064596661, -0.19999999999999996, 0.40000000000000002, + 1.3962634015954636 }, + { 2.0512956926676802, -0.19999999999999996, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler075 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.50000000000000000. -testcase_ellint_3<double> data076[] = { - { -0.0000000000000000, -0.19999999999999996, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17369503942181802, -0.19999999999999996, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34265043534362660, -0.19999999999999996, 0.50000000000000000, - 0.34906585039886590 }, - { 0.50338337208655415, -0.19999999999999996, 0.50000000000000000, - 0.52359877559829882 }, - { 0.65426373297163642, -0.19999999999999996, 0.50000000000000000, - 0.69813170079773179 }, - { 0.79536193036145808, -0.19999999999999996, 0.50000000000000000, - 0.87266462599716477 }, - { 0.92791875910061605, -0.19999999999999996, 0.50000000000000000, - 1.0471975511965976 }, - { 1.0538145052725829, -0.19999999999999996, 0.50000000000000000, - 1.2217304763960306 }, - { 1.1752060022875899, -0.19999999999999996, 0.50000000000000000, - 1.3962634015954636 }, - { 1.2943374404397376, -0.19999999999999996, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.19999999999999996, nu=0.50000000000000000. -template <typename Tp> -void test076() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data076) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data076[i].k), Tp(data076[i].nu), - Tp(data076[i].phi)); - const Tp f0 = data076[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.19999999999999996, nu=0.59999999999999998. -testcase_ellint_3<double> data077[] = { - { -0.0000000000000000, -0.19999999999999996, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17352228440746928, -0.19999999999999996, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34136562863713626, -0.19999999999999996, 0.59999999999999998, - 0.34906585039886590 }, - { 0.49950328177638481, -0.19999999999999996, 0.59999999999999998, - 0.52359877559829882 }, - { 0.64625032705690832, -0.19999999999999996, 0.59999999999999998, - 0.69813170079773179 }, - { 0.78193941198403094, -0.19999999999999996, 0.59999999999999998, - 0.87266462599716477 }, - { 0.90817230934317128, -0.19999999999999996, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0271563751276462, -0.19999999999999996, 0.59999999999999998, - 1.2217304763960306 }, - { 1.1412999379040518, -0.19999999999999996, 0.59999999999999998, - 1.3962634015954636 }, - { 1.2530330675914561, -0.19999999999999996, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=-0.19999999999999996, nu=0.59999999999999998. -template <typename Tp> -void test077() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data077) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data077[i].k), Tp(data077[i].nu), - Tp(data077[i].phi)); - const Tp f0 = data077[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.19999999999999996, nu=0.69999999999999996. -testcase_ellint_3<double> data078[] = { - { -0.0000000000000000, -0.19999999999999996, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17335014404233898, -0.19999999999999996, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34009775298617811, -0.19999999999999996, 0.69999999999999996, - 0.34906585039886590 }, - { 0.49572560201923810, -0.19999999999999996, 0.69999999999999996, - 0.52359877559829882 }, - { 0.63856276669886525, -0.19999999999999996, 0.69999999999999996, - 0.69813170079773179 }, - { 0.76924438644867565, -0.19999999999999996, 0.69999999999999996, - 0.87266462599716477 }, - { 0.88973060843856466, -0.19999999999999996, 0.69999999999999996, - 1.0471975511965976 }, - { 1.0025230471636377, -0.19999999999999996, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1102356376093103, -0.19999999999999996, 0.69999999999999996, - 1.3962634015954636 }, - { 1.2154356555075867, -0.19999999999999996, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=-0.19999999999999996, nu=0.69999999999999996. -template <typename Tp> -void test078() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data078) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data078[i].k), Tp(data078[i].nu), - Tp(data078[i].phi)); - const Tp f0 = data078[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.3841806057292116e-16 +// mean(f - f_Boost): 8.0491169285323847e-17 +// variance(f - f_Boost): 8.0538110429953348e-32 +// stddev(f - f_Boost): 2.8379237204328335e-16 +const testcase_ellint_3<double> +data076[10] = +{ + { 0.0000000000000000, -0.19999999999999996, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17545727725228877, -0.19999999999999996, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35652666242062175, -0.19999999999999996, 0.50000000000000000, + 0.34906585039886590 }, + { 0.54913090549102406, -0.19999999999999996, 0.50000000000000000, + 0.52359877559829882 }, + { 0.75970161209211551, -0.19999999999999996, 0.50000000000000000, + 0.69813170079773179 }, + { 0.99504737401590326, -0.19999999999999996, 0.50000000000000000, + 0.87266462599716477 }, + { 1.2614666007124373, -0.19999999999999996, 0.50000000000000000, + 1.0471975511965976 }, + { 1.5625255355205496, -0.19999999999999996, 0.50000000000000000, + 1.2217304763960306 }, + { 1.8954460255613343, -0.19999999999999996, 0.50000000000000000, + 1.3962634015954636 }, + { 2.2481046259421302, -0.19999999999999996, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler076 = 2.5000000000000020e-13; + +// Test data for k=-0.19999999999999996, nu=0.60000000000000009. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.5317584994994743e-16 +// mean(f - f_Boost): -1.3877787807814457e-17 +// variance(f - f_Boost): 1.0045745697575397e-31 +// stddev(f - f_Boost): 3.1695024369095219e-16 +const testcase_ellint_3<double> +data077[10] = +{ + { 0.0000000000000000, -0.19999999999999996, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17563706072900442, -0.19999999999999996, 0.60000000000000009, + 0.17453292519943295 }, + { 0.35802800926807238, -0.19999999999999996, 0.60000000000000009, + 0.34906585039886590 }, + { 0.55456942250515051, -0.19999999999999996, 0.60000000000000009, + 0.52359877559829882 }, + { 0.77390003828438203, -0.19999999999999996, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0262441366366397, -0.19999999999999996, 0.60000000000000009, + 0.87266462599716477 }, + { 1.3228192988439669, -0.19999999999999996, 0.60000000000000009, + 1.0471975511965976 }, + { 1.6728005754680795, -0.19999999999999996, 0.60000000000000009, + 1.2217304763960306 }, + { 2.0761587107468511, -0.19999999999999996, 0.60000000000000009, + 1.3962634015954636 }, + { 2.5148333891629315, -0.19999999999999996, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler077 = 2.5000000000000020e-13; + +// Test data for k=-0.19999999999999996, nu=0.70000000000000007. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.1818454249546518e-16 +// mean(f - f_Boost): 3.6082248300317589e-17 +// variance(f - f_Boost): 8.9638010532618564e-32 +// stddev(f - f_Boost): 2.9939607634806868e-16 +const testcase_ellint_3<double> +data078[10] = +{ + { 0.0000000000000000, -0.19999999999999996, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17581750846781172, -0.19999999999999996, 0.70000000000000007, + 0.17453292519943295 }, + { 0.35955226882028513, -0.19999999999999996, 0.70000000000000007, + 0.34906585039886590 }, + { 0.56020489659466499, -0.19999999999999996, 0.70000000000000007, + 0.52359877559829882 }, + { 0.78908196988531487, -0.19999999999999996, 0.70000000000000007, + 0.69813170079773179 }, + { 1.0611336754143517, -0.19999999999999996, 0.70000000000000007, + 0.87266462599716477 }, + { 1.3956969951058884, -0.19999999999999996, 0.70000000000000007, + 1.0471975511965976 }, + { 1.8138131612209609, -0.19999999999999996, 0.70000000000000007, + 1.2217304763960306 }, + { 2.3256365528879561, -0.19999999999999996, 0.70000000000000007, + 1.3962634015954636 }, + { 2.9058704854500963, -0.19999999999999996, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler078 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.80000000000000004. -testcase_ellint_3<double> data079[] = { - { -0.0000000000000000, -0.19999999999999996, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17317861443718541, -0.19999999999999996, 0.80000000000000004, - 0.17453292519943295 }, - { 0.33884641598718701, -0.19999999999999996, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49204565281259494, -0.19999999999999996, 0.80000000000000004, - 0.52359877559829882 }, - { 0.63117851188220353, -0.19999999999999996, 0.80000000000000004, - 0.69813170079773179 }, - { 0.75721095949544170, -0.19999999999999996, 0.80000000000000004, - 0.87266462599716477 }, - { 0.87245201443919118, -0.19999999999999996, 0.80000000000000004, - 1.0471975511965976 }, - { 0.97966584238831089, -0.19999999999999996, 0.80000000000000004, - 1.2217304763960306 }, - { 1.0816336325174360, -0.19999999999999996, 0.80000000000000004, - 1.3962634015954636 }, - { 1.1810223448909913, -0.19999999999999996, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=-0.19999999999999996, nu=0.80000000000000004. -template <typename Tp> -void test079() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data079) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data079[i].k), Tp(data079[i].nu), - Tp(data079[i].phi)); - const Tp f0 = data079[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.9866614515542431e-16 +// mean(f - f_Boost): 1.8318679906315082e-16 +// variance(f - f_Boost): 3.1335688610218711e-31 +// stddev(f - f_Boost): 5.5978289193417400e-16 +const testcase_ellint_3<double> +data079[10] = +{ + { 0.0000000000000000, -0.19999999999999996, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17599862486281712, -0.19999999999999996, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36110007227128776, -0.19999999999999996, 0.80000000000000004, + 0.34906585039886590 }, + { 0.56605039658567224, -0.19999999999999996, 0.80000000000000004, + 0.52359877559829882 }, + { 0.80537523874517691, -0.19999999999999996, 0.80000000000000004, + 0.69813170079773179 }, + { 1.1005662342414086, -0.19999999999999996, 0.80000000000000004, + 0.87266462599716477 }, + { 1.4845340298105778, -0.19999999999999996, 0.80000000000000004, + 1.0471975511965976 }, + { 2.0043332244969392, -0.19999999999999996, 0.80000000000000004, + 1.2217304763960306 }, + { 2.7052856676744761, -0.19999999999999996, 0.80000000000000004, + 1.3962634015954636 }, + { 3.5622166386422629, -0.19999999999999996, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler079 = 2.5000000000000020e-13; // Test data for k=-0.19999999999999996, nu=0.90000000000000002. -testcase_ellint_3<double> data080[] = { - { -0.0000000000000000, -0.19999999999999996, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17300769173837280, -0.19999999999999996, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33761123827372508, -0.19999999999999996, 0.90000000000000002, - 0.34906585039886590 }, - { 0.48845905690769426, -0.19999999999999996, 0.90000000000000002, - 0.52359877559829882 }, - { 0.62407720017324986, -0.19999999999999996, 0.90000000000000002, - 0.69813170079773179 }, - { 0.74578146525124289, -0.19999999999999996, 0.90000000000000002, - 0.87266462599716477 }, - { 0.85621583540073076, -0.19999999999999996, 0.90000000000000002, - 1.0471975511965976 }, - { 0.95837725988001199, -0.19999999999999996, 0.90000000000000002, - 1.2217304763960306 }, - { 1.0551821412633928, -0.19999999999999996, 0.90000000000000002, - 1.3962634015954636 }, - { 1.1493679916141863, -0.19999999999999996, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.19999999999999996, nu=0.90000000000000002. -template <typename Tp> -void test080() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data080) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data080[i].k), Tp(data080[i].nu), - Tp(data080[i].phi)); - const Tp f0 = data080[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.2817178727913890e-16 +// mean(f - f_Boost): 3.4694469519536142e-16 +// variance(f - f_Boost): 6.6311432369155086e-31 +// stddev(f - f_Boost): 8.1431831840598485e-16 +const testcase_ellint_3<double> +data080[10] = +{ + { 0.0000000000000000, -0.19999999999999996, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17618041435044951, -0.19999999999999996, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36267207636502929, -0.19999999999999996, 0.90000000000000002, + 0.34906585039886590 }, + { 0.57212028758237743, -0.19999999999999996, 0.90000000000000002, + 0.52359877559829882 }, + { 0.82293323876704483, -0.19999999999999996, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1457077279880385, -0.19999999999999996, 0.90000000000000002, + 0.87266462599716477 }, + { 1.5967346899325681, -0.19999999999999996, 0.90000000000000002, + 1.0471975511965976 }, + { 2.2856537353421724, -0.19999999999999996, 0.90000000000000002, + 1.2217304763960306 }, + { 3.4034714304613902, -0.19999999999999996, 0.90000000000000002, + 1.3962634015954636 }, + { 5.0448269356200361, -0.19999999999999996, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler080 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.0000000000000000. -testcase_ellint_3<double> data081[] = { - { -0.0000000000000000, -0.099999999999999978, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17454173353063665, -0.099999999999999978, 0.0000000000000000, - 0.17453292519943295 }, - { 0.34913506721468085, -0.099999999999999978, 0.0000000000000000, - 0.34906585039886590 }, - { 0.52382550016538953, -0.099999999999999978, 0.0000000000000000, - 0.52359877559829882 }, - { 0.69864700854177031, -0.099999999999999978, 0.0000000000000000, - 0.69813170079773179 }, - { 0.87361792586964870, -0.099999999999999978, 0.0000000000000000, - 0.87266462599716477 }, - { 1.0487386319621685, -0.099999999999999978, 0.0000000000000000, - 1.0471975511965976 }, - { 1.2239913752078757, -0.099999999999999978, 0.0000000000000000, - 1.2217304763960306 }, - { 1.3993423113684049, -0.099999999999999978, 0.0000000000000000, - 1.3962634015954636 }, - { 1.5747455615173562, -0.099999999999999978, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.099999999999999978, nu=0.0000000000000000. -template <typename Tp> -void test081() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data081) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data081[i].k), Tp(data081[i].nu), - Tp(data081[i].phi)); - const Tp f0 = data081[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.1735566504509645e-16 +// mean(f - f_Boost): -3.6082248300317589e-17 +// variance(f - f_Boost): 8.2258607846939269e-33 +// stddev(f - f_Boost): 9.0696531271564778e-17 +const testcase_ellint_3<double> +data081[10] = +{ + { 0.0000000000000000, -0.099999999999999978, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17454173353063662, -0.099999999999999978, 0.0000000000000000, + 0.17453292519943295 }, + { 0.34913506721468096, -0.099999999999999978, 0.0000000000000000, + 0.34906585039886590 }, + { 0.52382550016538953, -0.099999999999999978, 0.0000000000000000, + 0.52359877559829882 }, + { 0.69864700854177020, -0.099999999999999978, 0.0000000000000000, + 0.69813170079773179 }, + { 0.87361792586964859, -0.099999999999999978, 0.0000000000000000, + 0.87266462599716477 }, + { 1.0487386319621685, -0.099999999999999978, 0.0000000000000000, + 1.0471975511965976 }, + { 1.2239913752078759, -0.099999999999999978, 0.0000000000000000, + 1.2217304763960306 }, + { 1.3993423113684051, -0.099999999999999978, 0.0000000000000000, + 1.3962634015954636 }, + { 1.5747455615173558, -0.099999999999999978, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler081 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.10000000000000001. -testcase_ellint_3<double> data082[] = { - { -0.0000000000000000, -0.099999999999999978, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17436589347616618, -0.099999999999999978, 0.10000000000000001, - 0.17453292519943295 }, - { 0.34776067871237354, -0.099999999999999978, 0.10000000000000001, - 0.34906585039886590 }, - { 0.51936064354727807, -0.099999999999999978, 0.10000000000000001, - 0.52359877559829882 }, - { 0.68860303749364360, -0.099999999999999978, 0.10000000000000001, - 0.69813170079773179 }, - { 0.85524561882332051, -0.099999999999999978, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0193708301908337, -0.099999999999999978, 0.10000000000000001, - 1.0471975511965976 }, - { 1.1813474067123044, -0.099999999999999978, 0.10000000000000001, - 1.2217304763960306 }, - { 1.3417670770424983, -0.099999999999999978, 0.10000000000000001, - 1.3962634015954636 }, - { 1.5013711111199950, -0.099999999999999978, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.099999999999999978, nu=0.10000000000000001. -template <typename Tp> -void test082() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data082) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data082[i].k), Tp(data082[i].nu), - Tp(data082[i].phi)); - const Tp f0 = data082[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.0305747373482148e-16 +// mean(f - f_Boost): -3.0531133177191807e-17 +// variance(f - f_Boost): 1.1508025840536076e-34 +// stddev(f - f_Boost): 1.0727546709539920e-17 +const testcase_ellint_3<double> +data082[10] = +{ + { 0.0000000000000000, -0.099999999999999978, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17471821213559732, -0.099999999999999978, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35052902610011138, -0.099999999999999978, 0.10000000000000001, + 0.34906585039886590 }, + { 0.52842865990255727, -0.099999999999999978, 0.10000000000000001, + 0.52359877559829882 }, + { 0.70921799731166713, -0.099999999999999978, 0.10000000000000001, + 0.69813170079773179 }, + { 0.89340330535868662, -0.099999999999999978, 0.10000000000000001, + 0.87266462599716477 }, + { 1.0811075784236857, -0.099999999999999978, 0.10000000000000001, + 1.0471975511965976 }, + { 1.2720133232666426, -0.099999999999999978, 0.10000000000000001, + 1.2217304763960306 }, + { 1.4653630031861395, -0.099999999999999978, 0.10000000000000001, + 1.3962634015954636 }, + { 1.6600374067558428, -0.099999999999999978, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler082 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.20000000000000001. -testcase_ellint_3<double> data083[] = { - { -0.0000000000000000, -0.099999999999999978, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17419068786141345, -0.099999999999999978, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34640537686230127, -0.099999999999999978, 0.20000000000000001, - 0.34906585039886590 }, - { 0.51502689171753957, -0.099999999999999978, 0.20000000000000001, - 0.52359877559829882 }, - { 0.67904147863672726, -0.099999999999999978, 0.20000000000000001, - 0.69813170079773179 }, - { 0.83811885126105179, -0.099999999999999978, 0.20000000000000001, - 0.87266462599716477 }, - { 0.99255278555742810, -0.099999999999999978, 0.20000000000000001, - 1.0471975511965976 }, - { 1.1431260546194930, -0.099999999999999978, 0.20000000000000001, - 1.2217304763960306 }, - { 1.2909589656532101, -0.099999999999999978, 0.20000000000000001, - 1.3962634015954636 }, - { 1.4373749386463430, -0.099999999999999978, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=-0.099999999999999978, nu=0.20000000000000001. -template <typename Tp> -void test083() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data083) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data083[i].k), Tp(data083[i].nu), - Tp(data083[i].phi)); - const Tp f0 = data083[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.099999999999999978, nu=0.29999999999999999. -testcase_ellint_3<double> data084[] = { - { -0.0000000000000000, -0.099999999999999978, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17401611261390110, -0.099999999999999978, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34506869507511767, -0.099999999999999978, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51081757604259870, -0.099999999999999978, 0.29999999999999999, - 0.52359877559829882 }, - { 0.66992297597712303, -0.099999999999999978, 0.29999999999999999, - 0.69813170079773179 }, - { 0.82209722856174228, -0.099999999999999978, 0.29999999999999999, - 0.87266462599716477 }, - { 0.96792430487669612, -0.099999999999999978, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1085964108954092, -0.099999999999999978, 0.29999999999999999, - 1.2217304763960306 }, - { 1.2456748370836999, -0.099999999999999978, 0.29999999999999999, - 1.3962634015954636 }, - { 1.3809159606704959, -0.099999999999999978, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=-0.099999999999999978, nu=0.29999999999999999. -template <typename Tp> -void test084() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data084) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data084[i].k), Tp(data084[i].nu), - Tp(data084[i].phi)); - const Tp f0 = data084[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 1.6736714959992433e-16 +// mean(f - f_Boost): 5.5511151231257830e-18 +// variance(f - f_Boost): 3.8043060629871325e-36 +// stddev(f - f_Boost): 1.9504630380981673e-18 +const testcase_ellint_3<double> +data083[10] = +{ + { 0.0000000000000000, -0.099999999999999978, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17489533344059083, -0.099999999999999978, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35194305707815038, -0.099999999999999978, 0.20000000000000001, + 0.34906585039886590 }, + { 0.53317790741512527, -0.099999999999999978, 0.20000000000000001, + 0.52359877559829882 }, + { 0.72036681615081222, -0.099999999999999978, 0.20000000000000001, + 0.69813170079773179 }, + { 0.91480372268244303, -0.099999999999999978, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1170528708071514, -0.099999999999999978, 0.20000000000000001, + 1.0471975511965976 }, + { 1.3266916802718358, -0.099999999999999978, 0.20000000000000001, + 1.2217304763960306 }, + { 1.5421622241831547, -0.099999999999999978, 0.20000000000000001, + 1.3962634015954636 }, + { 1.7608656115083421, -0.099999999999999978, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler083 = 2.5000000000000020e-13; + +// Test data for k=-0.099999999999999978, nu=0.30000000000000004. +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 1.9186071760326645e-16 +// mean(f - f_Boost): -1.6653345369377347e-17 +// variance(f - f_Boost): 3.4238754566884194e-35 +// stddev(f - f_Boost): 5.8513891142945016e-18 +const testcase_ellint_3<double> +data084[10] = +{ + { 0.0000000000000000, -0.099999999999999978, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17507310163441189, -0.099999999999999978, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35337768072524217, -0.099999999999999978, 0.30000000000000004, + 0.34906585039886590 }, + { 0.53808167801629170, -0.099999999999999978, 0.30000000000000004, + 0.52359877559829882 }, + { 0.73215166755955019, -0.099999999999999978, 0.30000000000000004, + 0.69813170079773179 }, + { 0.93806546000201219, -0.099999999999999978, 0.30000000000000004, + 0.87266462599716477 }, + { 1.1573218723395986, -0.099999999999999978, 0.30000000000000004, + 1.0471975511965976 }, + { 1.3897859679542097, -0.099999999999999978, 0.30000000000000004, + 1.2217304763960306 }, + { 1.6331009404328622, -0.099999999999999978, 0.30000000000000004, + 1.3962634015954636 }, + { 1.8826015946315438, -0.099999999999999978, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler084 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.40000000000000002. -testcase_ellint_3<double> data085[] = { - { -0.0000000000000000, -0.099999999999999978, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17384216369897937, -0.099999999999999978, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34375018311376782, -0.099999999999999978, 0.40000000000000002, - 0.34906585039886590 }, - { 0.50672650758380455, -0.099999999999999978, 0.40000000000000002, - 0.52359877559829882 }, - { 0.66121264213337616, -0.099999999999999978, 0.40000000000000002, - 0.69813170079773179 }, - { 0.80706202005774441, -0.099999999999999978, 0.40000000000000002, - 0.87266462599716477 }, - { 0.94519376138245892, -0.099999999999999978, 0.40000000000000002, - 1.0471975511965976 }, - { 1.0771880300759584, -0.099999999999999978, 0.40000000000000002, - 1.2217304763960306 }, - { 1.2049711557188272, -0.099999999999999978, 0.40000000000000002, - 1.3962634015954636 }, - { 1.3306223265207477, -0.099999999999999978, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.099999999999999978, nu=0.40000000000000002. -template <typename Tp> -void test085() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data085) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data085[i].k), Tp(data085[i].nu), - Tp(data085[i].phi)); - const Tp f0 = data085[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.0338059536914377e-16 +// mean(f - f_Boost): 2.7755575615628914e-17 +// variance(f - f_Boost): 9.5107651574678308e-35 +// stddev(f - f_Boost): 9.7523151904908362e-18 +const testcase_ellint_3<double> +data085[10] = +{ + { 0.0000000000000000, -0.099999999999999978, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17525152094559704, -0.099999999999999978, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35483343742825979, -0.099999999999999978, 0.40000000000000002, + 0.34906585039886590 }, + { 0.54314913099505446, -0.099999999999999978, 0.40000000000000002, + 0.52359877559829882 }, + { 0.74463962034766862, -0.099999999999999978, 0.40000000000000002, + 0.69813170079773179 }, + { 0.96349276837570441, -0.099999999999999978, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2029081382746343, -0.099999999999999978, 0.40000000000000002, + 1.0471975511965976 }, + { 1.4638022887050806, -0.099999999999999978, 0.40000000000000002, + 1.2217304763960306 }, + { 1.7432413830105224, -0.099999999999999978, 0.40000000000000002, + 1.3962634015954636 }, + { 2.0336367403076760, -0.099999999999999978, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler085 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.50000000000000000. -testcase_ellint_3<double> data086[] = { - { -0.0000000000000000, -0.099999999999999978, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17366883711936554, -0.099999999999999978, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34244940634881876, -0.099999999999999978, 0.50000000000000000, - 0.34906585039886590 }, - { 0.50274793281634378, -0.099999999999999978, 0.50000000000000000, - 0.52359877559829882 }, - { 0.65287941633275093, -0.099999999999999978, 0.50000000000000000, - 0.69813170079773179 }, - { 0.79291198790315398, -0.099999999999999978, 0.50000000000000000, - 0.87266462599716477 }, - { 0.92412201537880345, -0.099999999999999978, 0.50000000000000000, - 1.0471975511965976 }, - { 1.0484480076799370, -0.099999999999999978, 0.50000000000000000, - 1.2217304763960306 }, - { 1.1681168130475206, -0.099999999999999978, 0.50000000000000000, - 1.3962634015954636 }, - { 1.2854480708580160, -0.099999999999999978, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=-0.099999999999999978, nu=0.50000000000000000. -template <typename Tp> -void test086() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data086) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data086[i].k), Tp(data086[i].nu), - Tp(data086[i].phi)); - const Tp f0 = data086[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.099999999999999978, nu=0.59999999999999998. -testcase_ellint_3<double> data087[] = { - { -0.0000000000000000, -0.099999999999999978, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17349612891469018, -0.099999999999999978, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34116594505539438, -0.099999999999999978, 0.59999999999999998, - 0.34906585039886590 }, - { 0.49887649430466685, -0.099999999999999978, 0.59999999999999998, - 0.52359877559829882 }, - { 0.64489553282165157, -0.099999999999999978, 0.59999999999999998, - 0.69813170079773179 }, - { 0.77956016553782437, -0.099999999999999978, 0.59999999999999998, - 0.87266462599716477 }, - { 0.90451074530096309, -0.099999999999999978, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0220113666961632, -0.099999999999999978, 0.59999999999999998, - 1.2217304763960306 }, - { 1.1345351441065563, -0.099999999999999978, 0.59999999999999998, - 1.3962634015954636 }, - { 1.2445798942989255, -0.099999999999999978, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=-0.099999999999999978, nu=0.59999999999999998. -template <typename Tp> -void test087() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data087) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data087[i].k), Tp(data087[i].nu), - Tp(data087[i].phi)); - const Tp f0 = data087[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=-0.099999999999999978, nu=0.69999999999999996. -testcase_ellint_3<double> data088[] = { - { -0.0000000000000000, -0.099999999999999978, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17332403516105052, -0.099999999999999978, 0.69999999999999996, - 0.17453292519943295 }, - { 0.33989939374896877, -0.099999999999999978, 0.69999999999999996, - 0.34906585039886590 }, - { 0.49510719568614081, -0.099999999999999978, 0.69999999999999996, - 0.52359877559829882 }, - { 0.63723607776354974, -0.099999999999999978, 0.69999999999999996, - 0.69813170079773179 }, - { 0.76693133887935327, -0.099999999999999978, 0.69999999999999996, - 0.87266462599716477 }, - { 0.88619382078823827, -0.099999999999999978, 0.69999999999999996, - 1.0471975511965976 }, - { 0.99758012018676490, -0.099999999999999978, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1037642270814410, -0.099999999999999978, 0.69999999999999996, - 1.3962634015954636 }, - { 1.2073745911083187, -0.099999999999999978, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=-0.099999999999999978, nu=0.69999999999999996. -template <typename Tp> -void test088() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data088) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data088[i].k), Tp(data088[i].nu), - Tp(data088[i].phi)); - const Tp f0 = data088[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.9864616042835278e-16 +// mean(f - f_Boost): 1.0547118733938987e-16 +// variance(f - f_Boost): 7.5633408838247182e-32 +// stddev(f - f_Boost): 2.7501528837184157e-16 +const testcase_ellint_3<double> +data086[10] = +{ + { 0.0000000000000000, -0.099999999999999978, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17543059564292182, -0.099999999999999978, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35631088838721664, -0.099999999999999978, 0.50000000000000000, + 0.34906585039886590 }, + { 0.54839023346436444, -0.099999999999999978, 0.50000000000000000, + 0.52359877559829882 }, + { 0.75790846946088830, -0.099999999999999978, 0.50000000000000000, + 0.69813170079773179 }, + { 0.99146713686720678, -0.099999999999999978, 0.50000000000000000, + 0.87266462599716477 }, + { 1.2551692247937198, -0.099999999999999978, 0.50000000000000000, + 1.0471975511965976 }, + { 1.5524660788146873, -0.099999999999999978, 0.50000000000000000, + 1.2217304763960306 }, + { 1.8806578570830670, -0.099999999999999978, 0.50000000000000000, + 1.3962634015954636 }, + { 2.2279868912966849, -0.099999999999999978, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler086 = 2.5000000000000020e-13; + +// Test data for k=-0.099999999999999978, nu=0.60000000000000009. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.6726146516228014e-16 +// mean(f - f_Boost): -3.6082248300317589e-17 +// variance(f - f_Boost): 1.6073193116120635e-34 +// stddev(f - f_Boost): 1.2678009747638087e-17 +const testcase_ellint_3<double> +data087[10] = +{ + { 0.0000000000000000, -0.099999999999999978, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17561033003590576, -0.099999999999999978, 0.60000000000000009, + 0.17453292519943295 }, + { 0.35781061668171932, -0.099999999999999978, 0.60000000000000009, + 0.34906585039886590 }, + { 0.55381585659629196, -0.099999999999999978, 0.60000000000000009, + 0.52359877559829882 }, + { 0.77204910484575640, -0.099999999999999978, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0224751740393108, -0.099999999999999978, 0.60000000000000009, + 0.87266462599716477 }, + { 1.3160230906351114, -0.099999999999999978, 0.60000000000000009, + 1.0471975511965976 }, + { 1.6616282844233206, -0.099999999999999978, 0.60000000000000009, + 1.2217304763960306 }, + { 2.0592555664850392, -0.099999999999999978, 0.60000000000000009, + 1.3962634015954636 }, + { 2.4913004919173822, -0.099999999999999978, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler087 = 2.5000000000000020e-13; + +// Test data for k=-0.099999999999999978, nu=0.70000000000000007. +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 5 +// max(|f - f_Boost| / |f_Boost|): 2.1004074871280821e-16 +// mean(f - f_Boost): 3.3306690738754695e-17 +// variance(f - f_Boost): 1.3695501826753678e-34 +// stddev(f - f_Boost): 1.1702778228589003e-17 +const testcase_ellint_3<double> +data088[10] = +{ + { 0.0000000000000000, -0.099999999999999978, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17579072847532518, -0.099999999999999978, 0.70000000000000007, + 0.17453292519943295 }, + { 0.35933322840606297, -0.099999999999999978, 0.70000000000000007, + 0.34906585039886590 }, + { 0.55943788649460324, -0.099999999999999978, 0.70000000000000007, + 0.52359877559829882 }, + { 0.78716856504031707, -0.099999999999999978, 0.70000000000000007, + 0.69813170079773179 }, + { 1.0571501305617423, -0.099999999999999978, 0.70000000000000007, + 0.87266462599716477 }, + { 1.3882948301743525, -0.099999999999999978, 0.70000000000000007, + 1.0471975511965976 }, + { 1.8011785680114223, -0.099999999999999978, 0.70000000000000007, + 1.2217304763960306 }, + { 2.3057268183616464, -0.099999999999999978, 0.70000000000000007, + 1.3962634015954636 }, + { 2.8771910188009739, -0.099999999999999978, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler088 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.80000000000000004. -testcase_ellint_3<double> data089[] = { - { -0.0000000000000000, -0.099999999999999978, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17315255197057020, -0.099999999999999978, 0.80000000000000004, - 0.17453292519943295 }, - { 0.33864936055747985, -0.099999999999999978, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49143537041117619, -0.099999999999999978, 0.80000000000000004, - 0.52359877559829882 }, - { 0.62987861760047492, -0.099999999999999978, 0.80000000000000004, - 0.69813170079773179 }, - { 0.75496005490917517, -0.099999999999999978, 0.80000000000000004, - 0.87266462599716477 }, - { 0.86903081862701903, -0.099999999999999978, 0.80000000000000004, - 1.0471975511965976 }, - { 0.97490814820725591, -0.099999999999999978, 0.80000000000000004, - 1.2217304763960306 }, - { 1.0754290107171083, -0.099999999999999978, 0.80000000000000004, - 1.3962634015954636 }, - { 1.1733158866987732, -0.099999999999999978, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=-0.099999999999999978, nu=0.80000000000000004. -template <typename Tp> -void test089() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data089) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data089[i].k), Tp(data089[i].nu), - Tp(data089[i].phi)); - const Tp f0 = data089[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.3133043868392355e-16 +// mean(f - f_Boost): 1.8041124150158794e-16 +// variance(f - f_Boost): 6.1843750436434569e-32 +// stddev(f - f_Boost): 2.4868403735751633e-16 +const testcase_ellint_3<double> +data089[10] = +{ + { 0.0000000000000000, -0.099999999999999978, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17597179535373417, -0.099999999999999978, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36087935387831499, -0.099999999999999978, 0.80000000000000004, + 0.34906585039886590 }, + { 0.56526935244526444, -0.099999999999999978, 0.80000000000000004, + 0.52359877559829882 }, + { 0.80339402590612397, -0.099999999999999978, 0.80000000000000004, + 0.69813170079773179 }, + { 1.0963358646374459, -0.099999999999999978, 0.80000000000000004, + 0.87266462599716477 }, + { 1.4763748483246868, -0.099999999999999978, 0.80000000000000004, + 1.0471975511965976 }, + { 1.9896610222794102, -0.099999999999999978, 0.80000000000000004, + 1.2217304763960306 }, + { 2.6806423920122024, -0.099999999999999978, 0.80000000000000004, + 1.3962634015954636 }, + { 3.5246199613295612, -0.099999999999999978, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler089 = 2.5000000000000020e-13; // Test data for k=-0.099999999999999978, nu=0.90000000000000002. -testcase_ellint_3<double> data090[] = { - { -0.0000000000000000, -0.099999999999999978, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17298167549096569, -0.099999999999999978, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33741546662741584, -0.099999999999999978, 0.90000000000000002, - 0.34906585039886590 }, - { 0.48785665376856879, -0.099999999999999978, 0.90000000000000002, - 0.52359877559829882 }, - { 0.62280288554518959, -0.099999999999999978, 0.90000000000000002, - 0.69813170079773179 }, - { 0.74358903115455199, -0.099999999999999978, 0.90000000000000002, - 0.87266462599716477 }, - { 0.85290207679298358, -0.099999999999999978, 0.90000000000000002, - 1.0471975511965976 }, - { 0.95379006645397379, -0.099999999999999978, 0.90000000000000002, - 1.2217304763960306 }, - { 1.0492213119872327, -0.099999999999999978, 0.90000000000000002, - 1.3962634015954636 }, - { 1.1419839485283374, -0.099999999999999978, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=-0.099999999999999978, nu=0.90000000000000002. -template <typename Tp> -void test090() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data090) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data090[i].k), Tp(data090[i].nu), - Tp(data090[i].phi)); - const Tp f0 = data090[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.5624826890976725e-16 +// mean(f - f_Boost): 2.3314683517128288e-16 +// variance(f - f_Boost): 2.9401198977189756e-31 +// stddev(f - f_Boost): 5.4222872459129045e-16 +const testcase_ellint_3<double> +data090[10] = +{ + { 0.0000000000000000, -0.099999999999999978, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17615353510599349, -0.099999999999999978, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36244964892922371, -0.099999999999999978, 0.90000000000000002, + 0.34906585039886590 }, + { 0.57132457590110530, -0.099999999999999978, 0.90000000000000002, + 0.52359877559829882 }, + { 0.82087808820385000, -0.099999999999999978, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1411894342144451, -0.099999999999999978, 0.90000000000000002, + 0.87266462599716477 }, + { 1.5875929286844597, -0.099999999999999978, 0.90000000000000002, + 1.0471975511965976 }, + { 2.2678622986596659, -0.099999999999999978, 0.90000000000000002, + 1.2217304763960306 }, + { 3.3697528941897903, -0.099999999999999978, 0.90000000000000002, + 1.3962634015954636 }, + { 4.9862890417305499, -0.099999999999999978, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler090 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.0000000000000000. -testcase_ellint_3<double> data091[] = { - { -0.0000000000000000, 0.0000000000000000, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17453292519943295, 0.0000000000000000, 0.0000000000000000, - 0.17453292519943295 }, - { 0.34906585039886584, 0.0000000000000000, 0.0000000000000000, - 0.34906585039886590 }, - { 0.52359877559829882, 0.0000000000000000, 0.0000000000000000, - 0.52359877559829882 }, - { 0.69813170079773179, 0.0000000000000000, 0.0000000000000000, - 0.69813170079773179 }, - { 0.87266462599716477, 0.0000000000000000, 0.0000000000000000, - 0.87266462599716477 }, - { 1.0471975511965976, 0.0000000000000000, 0.0000000000000000, - 1.0471975511965976 }, - { 1.2217304763960304, 0.0000000000000000, 0.0000000000000000, - 1.2217304763960306 }, - { 1.3962634015954631, 0.0000000000000000, 0.0000000000000000, - 1.3962634015954636 }, - { 1.5707963267948966, 0.0000000000000000, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.0000000000000000, nu=0.0000000000000000. -template <typename Tp> -void test091() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data091) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data091[i].k), Tp(data091[i].nu), - Tp(data091[i].phi)); - const Tp f0 = data091[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.1203697876423447e-16 +// mean(f - f_Boost): -1.9428902930940238e-17 +// variance(f - f_Boost): 4.6602749271592373e-35 +// stddev(f - f_Boost): 6.8266206333435850e-18 +const testcase_ellint_3<double> +data091[10] = +{ + { 0.0000000000000000, 0.0000000000000000, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17453292519943295, 0.0000000000000000, 0.0000000000000000, + 0.17453292519943295 }, + { 0.34906585039886590, 0.0000000000000000, 0.0000000000000000, + 0.34906585039886590 }, + { 0.52359877559829882, 0.0000000000000000, 0.0000000000000000, + 0.52359877559829882 }, + { 0.69813170079773179, 0.0000000000000000, 0.0000000000000000, + 0.69813170079773179 }, + { 0.87266462599716477, 0.0000000000000000, 0.0000000000000000, + 0.87266462599716477 }, + { 1.0471975511965976, 0.0000000000000000, 0.0000000000000000, + 1.0471975511965976 }, + { 1.2217304763960306, 0.0000000000000000, 0.0000000000000000, + 1.2217304763960306 }, + { 1.3962634015954636, 0.0000000000000000, 0.0000000000000000, + 1.3962634015954636 }, + { 1.5707963267948966, 0.0000000000000000, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler091 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.10000000000000001. -testcase_ellint_3<double> data092[] = { - { -0.0000000000000000, 0.0000000000000000, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17435710107516608, 0.0000000000000000, 0.10000000000000001, - 0.17453292519943295 }, - { 0.34769194715329604, 0.0000000000000000, 0.10000000000000001, - 0.34906585039886590 }, - { 0.51913731575866118, 0.0000000000000000, 0.10000000000000001, - 0.52359877559829882 }, - { 0.68810051897078461, 0.0000000000000000, 0.10000000000000001, - 0.69813170079773179 }, - { 0.85432615661706823, 0.0000000000000000, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0179006647340796, 0.0000000000000000, 0.10000000000000001, - 1.0471975511965976 }, - { 1.1792120640746322, 0.0000000000000000, 0.10000000000000001, - 1.2217304763960306 }, - { 1.3388834245070498, 0.0000000000000000, 0.10000000000000001, - 1.3962634015954636 }, - { 1.4976955329233277, 0.0000000000000000, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.0000000000000000, nu=0.10000000000000001. -template <typename Tp> -void test092() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data092) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data092[i].k), Tp(data092[i].nu), - Tp(data092[i].phi)); - const Tp f0 = data092[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.1019052604815601e-16 +// mean(f - f_Boost): 2.7755575615628915e-18 +// variance(f - f_Boost): 9.5107651574678312e-37 +// stddev(f - f_Boost): 9.7523151904908366e-19 +const testcase_ellint_3<double> +data092[10] = +{ + { 0.0000000000000000, 0.0000000000000000, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17470938780535167, 0.0000000000000000, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35045931581655582, 0.0000000000000000, 0.10000000000000001, + 0.34906585039886590 }, + { 0.52819841383849875, 0.0000000000000000, 0.10000000000000001, + 0.52359877559829882 }, + { 0.70868910807992958, 0.0000000000000000, 0.10000000000000001, + 0.69813170079773179 }, + { 0.89241311307249638, 0.0000000000000000, 0.10000000000000001, + 0.87266462599716477 }, + { 1.0794871444666669, 0.0000000000000000, 0.10000000000000001, + 1.0471975511965976 }, + { 1.2696086247356864, 0.0000000000000000, 0.10000000000000001, + 1.2217304763960306 }, + { 1.4620562617494721, 0.0000000000000000, 0.10000000000000001, + 1.3962634015954636 }, + { 1.6557647109660167, 0.0000000000000000, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler092 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.20000000000000001. -testcase_ellint_3<double> data093[] = { - { -0.0000000000000000, 0.0000000000000000, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17418191132226077, 0.0000000000000000, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34633712256943405, 0.0000000000000000, 0.20000000000000001, - 0.34906585039886590 }, - { 0.51480684302043711, 0.0000000000000000, 0.20000000000000001, - 0.52359877559829882 }, - { 0.67855102942481949, 0.0000000000000000, 0.20000000000000001, - 0.69813170079773179 }, - { 0.83723056090326253, 0.0000000000000000, 0.20000000000000001, - 0.87266462599716477 }, - { 0.99114645269578183, 0.0000000000000000, 0.20000000000000001, - 1.0471975511965976 }, - { 1.1411014627915537, 0.0000000000000000, 0.20000000000000001, - 1.2217304763960306 }, - { 1.2882448138013969, 0.0000000000000000, 0.20000000000000001, - 1.3962634015954636 }, - { 1.4339343023863691, 0.0000000000000000, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.0000000000000000, nu=0.20000000000000001. -template <typename Tp> -void test093() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data093) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data093[i].k), Tp(data093[i].nu), - Tp(data093[i].phi)); - const Tp f0 = data093[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.0000000000000000, nu=0.29999999999999999. -testcase_ellint_3<double> data094[] = { - { -0.0000000000000000, 0.0000000000000000, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17400735186871727, 0.0000000000000000, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34500091027020219, 0.0000000000000000, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51060069523901541, 0.0000000000000000, 0.29999999999999999, - 0.52359877559829882 }, - { 0.66944393961375459, 0.0000000000000000, 0.29999999999999999, - 0.69813170079773179 }, - { 0.82123776744538157, 0.0000000000000000, 0.29999999999999999, - 0.87266462599716477 }, - { 0.96657579245516523, 0.0000000000000000, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1066703663542414, 0.0000000000000000, 0.29999999999999999, - 1.2217304763960306 }, - { 1.2431094251944901, 0.0000000000000000, 0.29999999999999999, - 1.3962634015954636 }, - { 1.3776795151134889, 0.0000000000000000, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=0.0000000000000000, nu=0.29999999999999999. -template <typename Tp> -void test094() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data094) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data094[i].k), Tp(data094[i].nu), - Tp(data094[i].phi)); - const Tp f0 = data094[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.0831888697465320e-16 +// mean(f - f_Boost): -1.9428902930940238e-17 +// variance(f - f_Boost): 4.6602749271592373e-35 +// stddev(f - f_Boost): 6.8266206333435850e-18 +const testcase_ellint_3<double> +data093[10] = +{ + { 0.0000000000000000, 0.0000000000000000, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17488649304197776, 0.0000000000000000, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35187284488675424, 0.0000000000000000, 0.20000000000000001, + 0.34906585039886590 }, + { 0.53294400750146131, 0.0000000000000000, 0.20000000000000001, + 0.52359877559829882 }, + { 0.71982347021822823, 0.0000000000000000, 0.20000000000000001, + 0.69813170079773179 }, + { 0.91377311030258745, 0.0000000000000000, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1153429007215137, 0.0000000000000000, 0.20000000000000001, + 1.0471975511965976 }, + { 1.3241202847784086, 0.0000000000000000, 0.20000000000000001, + 1.2217304763960306 }, + { 1.5385854914338242, 0.0000000000000000, 0.20000000000000001, + 1.3962634015954636 }, + { 1.7562036827601815, 0.0000000000000000, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler093 = 2.5000000000000020e-13; + +// Test data for k=0.0000000000000000, nu=0.30000000000000004. +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.0642101770923591e-16 +// mean(f - f_Boost): -1.9428902930940238e-17 +// variance(f - f_Boost): 4.6602749271592373e-35 +// stddev(f - f_Boost): 6.8266206333435850e-18 +const testcase_ellint_3<double> +data094[10] = +{ + { 0.0000000000000000, 0.0000000000000000, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17506424509761404, 0.0000000000000000, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35330695794774630, 0.0000000000000000, 0.30000000000000004, + 0.34906585039886590 }, + { 0.53784398359522367, 0.0000000000000000, 0.30000000000000004, + 0.52359877559829882 }, + { 0.73159289408687844, 0.0000000000000000, 0.30000000000000004, + 0.69813170079773179 }, + { 0.93699031797084975, 0.0000000000000000, 0.30000000000000004, + 0.87266462599716477 }, + { 1.1555098909390267, 0.0000000000000000, 0.30000000000000004, + 1.0471975511965976 }, + { 1.3870184960144325, 0.0000000000000000, 0.30000000000000004, + 1.2217304763960306 }, + { 1.6291980835772994, 0.0000000000000000, 0.30000000000000004, + 1.3962634015954636 }, + { 1.8774607092226381, 0.0000000000000000, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler094 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.40000000000000002. -testcase_ellint_3<double> data095[] = { - { -0.0000000000000000, 0.0000000000000000, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17383341868035865, 0.0000000000000000, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34368286022299821, 0.0000000000000000, 0.40000000000000002, - 0.34906585039886590 }, - { 0.50651268947499406, 0.0000000000000000, 0.40000000000000002, - 0.52359877559829882 }, - { 0.66074441806097550, 0.0000000000000000, 0.40000000000000002, - 0.69813170079773179 }, - { 0.80622931670113485, 0.0000000000000000, 0.40000000000000002, - 0.87266462599716477 }, - { 0.94389791565435233, 0.0000000000000000, 0.40000000000000002, - 1.0471975511965976 }, - { 1.0753503387899728, 0.0000000000000000, 0.40000000000000002, - 1.2217304763960306 }, - { 1.2025374759127518, 0.0000000000000000, 0.40000000000000002, - 1.3962634015954636 }, - { 1.3275651989026322, 0.0000000000000000, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.0000000000000000, nu=0.40000000000000002. -template <typename Tp> -void test095() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data095) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data095[i].k), Tp(data095[i].nu), - Tp(data095[i].phi)); - const Tp f0 = data095[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.0449580089795878e-16 +// mean(f - f_Boost): -1.9428902930940238e-17 +// variance(f - f_Boost): 4.6602749271592373e-35 +// stddev(f - f_Boost): 6.8266206333435850e-18 +const testcase_ellint_3<double> +data095[10] = +{ + { 0.0000000000000000, 0.0000000000000000, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17524264820030025, 0.0000000000000000, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35476219513871499, 0.0000000000000000, 0.40000000000000002, + 0.34906585039886590 }, + { 0.54290749235440094, 0.0000000000000000, 0.40000000000000002, + 0.52359877559829882 }, + { 0.74406433757109913, 0.0000000000000000, 0.40000000000000002, + 0.69813170079773179 }, + { 0.96236826162553313, 0.0000000000000000, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2009785880262487, 0.0000000000000000, 0.40000000000000002, + 1.0471975511965976 }, + { 1.4608000106167567, 0.0000000000000000, 0.40000000000000002, + 1.2217304763960306 }, + { 1.7389349574753439, 0.0000000000000000, 0.40000000000000002, + 1.3962634015954636 }, + { 2.0278893379868057, 0.0000000000000000, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler095 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.50000000000000000. -testcase_ellint_3<double> data096[] = { - { -0.0000000000000000, 0.0000000000000000, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17366010776037047, 0.0000000000000000, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34238253799539309, 0.0000000000000000, 0.50000000000000000, - 0.34906585039886590 }, - { 0.50253707775976408, 0.0000000000000000, 0.50000000000000000, - 0.52359877559829882 }, - { 0.65242145347295766, 0.0000000000000000, 0.50000000000000000, - 0.69813170079773179 }, - { 0.79210420018698058, 0.0000000000000000, 0.50000000000000000, - 0.87266462599716477 }, - { 0.92287437995632193, 0.0000000000000000, 0.50000000000000000, - 1.0471975511965976 }, - { 1.0466900550798661, 0.0000000000000000, 0.50000000000000000, - 1.2217304763960306 }, - { 1.1658007366618623, 0.0000000000000000, 0.50000000000000000, - 1.3962634015954636 }, - { 1.2825498301618641, 0.0000000000000000, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.0000000000000000, nu=0.50000000000000000. -template <typename Tp> -void test096() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data096) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data096[i].k), Tp(data096[i].nu), - Tp(data096[i].phi)); - const Tp f0 = data096[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.0000000000000000, nu=0.59999999999999998. -testcase_ellint_3<double> data097[] = { - { -0.0000000000000000, 0.0000000000000000, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17348741514884702, 0.0000000000000000, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34109952405241289, 0.0000000000000000, 0.59999999999999998, - 0.34906585039886590 }, - { 0.49866850781226296, 0.0000000000000000, 0.59999999999999998, - 0.52359877559829882 }, - { 0.64444732407062510, 0.0000000000000000, 0.59999999999999998, - 0.69813170079773179 }, - { 0.77877564686544720, 0.0000000000000000, 0.59999999999999998, - 0.87266462599716477 }, - { 0.90330743691883497, 0.0000000000000000, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0203257987604104, 0.0000000000000000, 0.59999999999999998, - 1.2217304763960306 }, - { 1.1323247918768631, 0.0000000000000000, 0.59999999999999998, - 1.3962634015954636 }, - { 1.2418235332245127, 0.0000000000000000, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=0.0000000000000000, nu=0.59999999999999998. -template <typename Tp> -void test097() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data097) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data097[i].k), Tp(data097[i].nu), - Tp(data097[i].phi)); - const Tp f0 = data097[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.0000000000000000, nu=0.69999999999999996. -testcase_ellint_3<double> data098[] = { - { -0.0000000000000000, 0.0000000000000000, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17331533692234477, 0.0000000000000000, 0.69999999999999996, - 0.17453292519943295 }, - { 0.33983341309265941, 0.0000000000000000, 0.69999999999999996, - 0.34906585039886590 }, - { 0.49490198805931990, 0.0000000000000000, 0.69999999999999996, - 0.52359877559829882 }, - { 0.63679715525145308, 0.0000000000000000, 0.69999999999999996, - 0.69813170079773179 }, - { 0.76616861049481944, 0.0000000000000000, 0.69999999999999996, - 0.87266462599716477 }, - { 0.88503143209004220, 0.0000000000000000, 0.69999999999999996, - 1.0471975511965976 }, - { 0.99596060249112173, 0.0000000000000000, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1016495050260424, 0.0000000000000000, 0.69999999999999996, - 1.3962634015954636 }, - { 1.2047457872617382, 0.0000000000000000, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=0.0000000000000000, nu=0.69999999999999996. -template <typename Tp> -void test098() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data098) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data098[i].k), Tp(data098[i].nu), - Tp(data098[i].phi)); - const Tp f0 = data098[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.0254203825026289e-16 +// mean(f - f_Boost): -1.9428902930940238e-17 +// variance(f - f_Boost): 4.6602749271592373e-35 +// stddev(f - f_Boost): 6.8266206333435850e-18 +const testcase_ellint_3<double> +data096[10] = +{ + { 0.0000000000000000, 0.0000000000000000, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17542170661831016, 0.0000000000000000, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35623911740195419, 0.0000000000000000, 0.50000000000000000, + 0.34906585039886590 }, + { 0.54814449099863127, 0.0000000000000000, 0.50000000000000000, + 0.52359877559829882 }, + { 0.75731546607718081, 0.0000000000000000, 0.50000000000000000, + 0.69813170079773179 }, + { 0.99028751188233310, 0.0000000000000000, 0.50000000000000000, + 0.87266462599716477 }, + { 1.2531022857760581, 0.0000000000000000, 0.50000000000000000, + 1.0471975511965976 }, + { 1.5491761777615785, 0.0000000000000000, 0.50000000000000000, + 1.2217304763960306 }, + { 1.8758359693666533, 0.0000000000000000, 0.50000000000000000, + 1.3962634015954636 }, + { 2.2214414690791831, 0.0000000000000000, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler096 = 2.5000000000000020e-13; + +// Test data for k=0.0000000000000000, nu=0.60000000000000009. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 2.1742785192400269e-16 +// mean(f - f_Boost): 1.3877787807814457e-17 +// variance(f - f_Boost): 2.3776912893669577e-35 +// stddev(f - f_Boost): 4.8761575952454181e-18 +const testcase_ellint_3<double> +data097[10] = +{ + { 0.0000000000000000, 0.0000000000000000, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17560142466065651, 0.0000000000000000, 0.60000000000000009, + 0.17453292519943295 }, + { 0.35773830754879005, 0.0000000000000000, 0.60000000000000009, + 0.34906585039886590 }, + { 0.55356583986445973, 0.0000000000000000, 0.60000000000000009, + 0.52359877559829882 }, + { 0.77143701715151514, 0.0000000000000000, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0212334940541210, 0.0000000000000000, 0.60000000000000009, + 0.87266462599716477 }, + { 1.3137928444460387, 0.0000000000000000, 0.60000000000000009, + 1.0471975511965976 }, + { 1.6579755004159076, 0.0000000000000000, 0.60000000000000009, + 1.2217304763960306 }, + { 2.0537461418295506, 0.0000000000000000, 0.60000000000000009, + 1.3962634015954636 }, + { 2.4836470664490253, 0.0000000000000000, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler097 = 2.5000000000000020e-13; + +// Test data for k=0.0000000000000000, nu=0.70000000000000007. +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 4 +// max(|f - f_Boost| / |f_Boost|): 3.0903019454022601e-16 +// mean(f - f_Boost): -6.9388939039072284e-17 +// variance(f - f_Boost): 5.9442282234173945e-34 +// stddev(f - f_Boost): 2.4380787976227090e-17 +const testcase_ellint_3<double> +data098[10] = +{ + { 0.0000000000000000, 0.0000000000000000, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17578180667760368, 0.0000000000000000, 0.70000000000000007, + 0.17453292519943295 }, + { 0.35926037139410999, 0.0000000000000000, 0.70000000000000007, + 0.34906585039886590 }, + { 0.55918341315855080, 0.0000000000000000, 0.70000000000000007, + 0.52359877559829882 }, + { 0.78653584856932546, 0.0000000000000000, 0.70000000000000007, + 0.69813170079773179 }, + { 1.0558379029273324, 0.0000000000000000, 0.70000000000000007, + 0.87266462599716477 }, + { 1.3858662544850615, 0.0000000000000000, 0.70000000000000007, + 1.0471975511965976 }, + { 1.7970491170359040, 0.0000000000000000, 0.70000000000000007, + 1.2217304763960306 }, + { 2.2992404490153917, 0.0000000000000000, 0.70000000000000007, + 1.3962634015954636 }, + { 2.8678686047727382, 0.0000000000000000, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler098 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.80000000000000004. -testcase_ellint_3<double> data099[] = { - { -0.0000000000000000, 0.0000000000000000, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17314386919344213, 0.0000000000000000, 0.80000000000000004, - 0.17453292519943295 }, - { 0.33858381342073240, 0.0000000000000000, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49123285640844738, 0.0000000000000000, 0.80000000000000004, - 0.52359877559829882 }, - { 0.62944854858904520, 0.0000000000000000, 0.80000000000000004, - 0.69813170079773179 }, - { 0.75421778305499343, 0.0000000000000000, 0.80000000000000004, - 0.87266462599716477 }, - { 0.86790634112156639, 0.0000000000000000, 0.80000000000000004, - 1.0471975511965976 }, - { 0.97334918087427558, 0.0000000000000000, 0.80000000000000004, - 1.2217304763960306 }, - { 1.0734012615283985, 0.0000000000000000, 0.80000000000000004, - 1.3962634015954636 }, - { 1.1708024551734544, 0.0000000000000000, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=0.0000000000000000, nu=0.80000000000000004. -template <typename Tp> -void test099() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data099) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data099[i].k), Tp(data099[i].nu), - Tp(data099[i].phi)); - const Tp f0 = data099[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.2373744057922657e-16 +// mean(f - f_Boost): 1.0269562977782698e-16 +// variance(f - f_Boost): 1.4388836606733082e-32 +// stddev(f - f_Boost): 1.1995347684303728e-16 +const testcase_ellint_3<double> +data099[10] = +{ + { 0.0000000000000000, 0.0000000000000000, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17596285706118869, 0.0000000000000000, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36080593896484231, 0.0000000000000000, 0.80000000000000004, + 0.34906585039886590 }, + { 0.56501022706967863, 0.0000000000000000, 0.80000000000000004, + 0.52359877559829882 }, + { 0.80273891984116930, 0.0000000000000000, 0.80000000000000004, + 0.69813170079773179 }, + { 1.0949425007763358, 0.0000000000000000, 0.80000000000000004, + 0.87266462599716477 }, + { 1.4736985692253419, 0.0000000000000000, 0.80000000000000004, + 1.0471975511965976 }, + { 1.9848676587180696, 0.0000000000000000, 0.80000000000000004, + 1.2217304763960306 }, + { 2.6726187823193546, 0.0000000000000000, 0.80000000000000004, + 1.3962634015954636 }, + { 3.5124073655203634, 0.0000000000000000, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler099 = 2.5000000000000020e-13; // Test data for k=0.0000000000000000, nu=0.90000000000000002. -testcase_ellint_3<double> data100[] = { - { -0.0000000000000000, 0.0000000000000000, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17297300811030600, 0.0000000000000000, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33735034635360817, 0.0000000000000000, 0.90000000000000002, - 0.34906585039886590 }, - { 0.48765675230233141, 0.0000000000000000, 0.90000000000000002, - 0.52359877559829882 }, - { 0.62238126886123568, 0.0000000000000000, 0.90000000000000002, - 0.69813170079773179 }, - { 0.74286600807269243, 0.0000000000000000, 0.90000000000000002, - 0.87266462599716477 }, - { 0.85181283909264971, 0.0000000000000000, 0.90000000000000002, - 1.0471975511965976 }, - { 0.95228683995371122, 0.0000000000000000, 0.90000000000000002, - 1.2217304763960306 }, - { 1.0472730487412552, 0.0000000000000000, 0.90000000000000002, - 1.3962634015954636 }, - { 1.1395754288497419, 0.0000000000000000, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.0000000000000000, nu=0.90000000000000002. -template <typename Tp> -void test100() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data100) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data100[i].k), Tp(data100[i].nu), - Tp(data100[i].phi)); - const Tp f0 = data100[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 6.6108624815885066e-16 +// mean(f - f_Boost): 2.1371793224034264e-16 +// variance(f - f_Boost): 5.6389326618626776e-33 +// stddev(f - f_Boost): 7.5092826966779442e-17 +const testcase_ellint_3<double> +data100[10] = +{ + { 0.0000000000000000, 0.0000000000000000, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17614458024574997, 0.0000000000000000, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36237566578821978, 0.0000000000000000, 0.90000000000000002, + 0.34906585039886590 }, + { 0.57106058859196640, 0.0000000000000000, 0.90000000000000002, + 0.52359877559829882 }, + { 0.82019857015755915, 0.0000000000000000, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1397014388908147, 0.0000000000000000, 0.90000000000000002, + 0.87266462599716477 }, + { 1.5845952415154960, 0.0000000000000000, 0.90000000000000002, + 1.0471975511965976 }, + { 2.2620531413370775, 0.0000000000000000, 0.90000000000000002, + 1.2217304763960306 }, + { 3.3587842061975066, 0.0000000000000000, 0.90000000000000002, + 1.3962634015954636 }, + { 4.9672941328980507, 0.0000000000000000, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler100 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.0000000000000000. -testcase_ellint_3<double> data101[] = { - { -0.0000000000000000, 0.10000000000000009, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17454173353063665, 0.10000000000000009, 0.0000000000000000, - 0.17453292519943295 }, - { 0.34913506721468085, 0.10000000000000009, 0.0000000000000000, - 0.34906585039886590 }, - { 0.52382550016538953, 0.10000000000000009, 0.0000000000000000, - 0.52359877559829882 }, - { 0.69864700854177031, 0.10000000000000009, 0.0000000000000000, - 0.69813170079773179 }, - { 0.87361792586964870, 0.10000000000000009, 0.0000000000000000, - 0.87266462599716477 }, - { 1.0487386319621685, 0.10000000000000009, 0.0000000000000000, - 1.0471975511965976 }, - { 1.2239913752078757, 0.10000000000000009, 0.0000000000000000, - 1.2217304763960306 }, - { 1.3993423113684049, 0.10000000000000009, 0.0000000000000000, - 1.3962634015954636 }, - { 1.5747455615173562, 0.10000000000000009, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.10000000000000009, nu=0.0000000000000000. -template <typename Tp> -void test101() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data101) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data101[i].k), Tp(data101[i].nu), - Tp(data101[i].phi)); - const Tp f0 = data101[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.1735566504509645e-16 +// mean(f - f_Boost): -5.8286708792820721e-17 +// variance(f - f_Boost): 4.1942474344433133e-34 +// stddev(f - f_Boost): 2.0479861900030756e-17 +const testcase_ellint_3<double> +data101[10] = +{ + { 0.0000000000000000, 0.10000000000000009, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17454173353063662, 0.10000000000000009, 0.0000000000000000, + 0.17453292519943295 }, + { 0.34913506721468096, 0.10000000000000009, 0.0000000000000000, + 0.34906585039886590 }, + { 0.52382550016538953, 0.10000000000000009, 0.0000000000000000, + 0.52359877559829882 }, + { 0.69864700854177020, 0.10000000000000009, 0.0000000000000000, + 0.69813170079773179 }, + { 0.87361792586964859, 0.10000000000000009, 0.0000000000000000, + 0.87266462599716477 }, + { 1.0487386319621685, 0.10000000000000009, 0.0000000000000000, + 1.0471975511965976 }, + { 1.2239913752078759, 0.10000000000000009, 0.0000000000000000, + 1.2217304763960306 }, + { 1.3993423113684051, 0.10000000000000009, 0.0000000000000000, + 1.3962634015954636 }, + { 1.5747455615173560, 0.10000000000000009, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler101 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.10000000000000001. -testcase_ellint_3<double> data102[] = { - { -0.0000000000000000, 0.10000000000000009, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17436589347616618, 0.10000000000000009, 0.10000000000000001, - 0.17453292519943295 }, - { 0.34776067871237354, 0.10000000000000009, 0.10000000000000001, - 0.34906585039886590 }, - { 0.51936064354727807, 0.10000000000000009, 0.10000000000000001, - 0.52359877559829882 }, - { 0.68860303749364360, 0.10000000000000009, 0.10000000000000001, - 0.69813170079773179 }, - { 0.85524561882332051, 0.10000000000000009, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0193708301908337, 0.10000000000000009, 0.10000000000000001, - 1.0471975511965976 }, - { 1.1813474067123044, 0.10000000000000009, 0.10000000000000001, - 1.2217304763960306 }, - { 1.3417670770424983, 0.10000000000000009, 0.10000000000000001, - 1.3962634015954636 }, - { 1.5013711111199950, 0.10000000000000009, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.10000000000000009, nu=0.10000000000000001. -template <typename Tp> -void test102() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data102) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data102[i].k), Tp(data102[i].nu), - Tp(data102[i].phi)); - const Tp f0 = data102[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.0305747373482148e-16 +// mean(f - f_Boost): -3.0531133177191807e-17 +// variance(f - f_Boost): 1.1508025840536076e-34 +// stddev(f - f_Boost): 1.0727546709539920e-17 +const testcase_ellint_3<double> +data102[10] = +{ + { 0.0000000000000000, 0.10000000000000009, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17471821213559732, 0.10000000000000009, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35052902610011138, 0.10000000000000009, 0.10000000000000001, + 0.34906585039886590 }, + { 0.52842865990255727, 0.10000000000000009, 0.10000000000000001, + 0.52359877559829882 }, + { 0.70921799731166713, 0.10000000000000009, 0.10000000000000001, + 0.69813170079773179 }, + { 0.89340330535868662, 0.10000000000000009, 0.10000000000000001, + 0.87266462599716477 }, + { 1.0811075784236857, 0.10000000000000009, 0.10000000000000001, + 1.0471975511965976 }, + { 1.2720133232666426, 0.10000000000000009, 0.10000000000000001, + 1.2217304763960306 }, + { 1.4653630031861395, 0.10000000000000009, 0.10000000000000001, + 1.3962634015954636 }, + { 1.6600374067558428, 0.10000000000000009, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler102 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.20000000000000001. -testcase_ellint_3<double> data103[] = { - { -0.0000000000000000, 0.10000000000000009, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17419068786141345, 0.10000000000000009, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34640537686230127, 0.10000000000000009, 0.20000000000000001, - 0.34906585039886590 }, - { 0.51502689171753957, 0.10000000000000009, 0.20000000000000001, - 0.52359877559829882 }, - { 0.67904147863672726, 0.10000000000000009, 0.20000000000000001, - 0.69813170079773179 }, - { 0.83811885126105179, 0.10000000000000009, 0.20000000000000001, - 0.87266462599716477 }, - { 0.99255278555742810, 0.10000000000000009, 0.20000000000000001, - 1.0471975511965976 }, - { 1.1431260546194930, 0.10000000000000009, 0.20000000000000001, - 1.2217304763960306 }, - { 1.2909589656532101, 0.10000000000000009, 0.20000000000000001, - 1.3962634015954636 }, - { 1.4373749386463430, 0.10000000000000009, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.10000000000000009, nu=0.20000000000000001. -template <typename Tp> -void test103() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data103) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data103[i].k), Tp(data103[i].nu), - Tp(data103[i].phi)); - const Tp f0 = data103[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.10000000000000009, nu=0.29999999999999999. -testcase_ellint_3<double> data104[] = { - { -0.0000000000000000, 0.10000000000000009, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17401611261390110, 0.10000000000000009, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34506869507511767, 0.10000000000000009, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51081757604259870, 0.10000000000000009, 0.29999999999999999, - 0.52359877559829882 }, - { 0.66992297597712303, 0.10000000000000009, 0.29999999999999999, - 0.69813170079773179 }, - { 0.82209722856174228, 0.10000000000000009, 0.29999999999999999, - 0.87266462599716477 }, - { 0.96792430487669612, 0.10000000000000009, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1085964108954092, 0.10000000000000009, 0.29999999999999999, - 1.2217304763960306 }, - { 1.2456748370836999, 0.10000000000000009, 0.29999999999999999, - 1.3962634015954636 }, - { 1.3809159606704959, 0.10000000000000009, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=0.10000000000000009, nu=0.29999999999999999. -template <typename Tp> -void test104() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data104) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data104[i].k), Tp(data104[i].nu), - Tp(data104[i].phi)); - const Tp f0 = data104[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 1.6736714959992433e-16 +// mean(f - f_Boost): 5.5511151231257830e-18 +// variance(f - f_Boost): 3.8043060629871325e-36 +// stddev(f - f_Boost): 1.9504630380981673e-18 +const testcase_ellint_3<double> +data103[10] = +{ + { 0.0000000000000000, 0.10000000000000009, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17489533344059083, 0.10000000000000009, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35194305707815038, 0.10000000000000009, 0.20000000000000001, + 0.34906585039886590 }, + { 0.53317790741512527, 0.10000000000000009, 0.20000000000000001, + 0.52359877559829882 }, + { 0.72036681615081222, 0.10000000000000009, 0.20000000000000001, + 0.69813170079773179 }, + { 0.91480372268244303, 0.10000000000000009, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1170528708071514, 0.10000000000000009, 0.20000000000000001, + 1.0471975511965976 }, + { 1.3266916802718358, 0.10000000000000009, 0.20000000000000001, + 1.2217304763960306 }, + { 1.5421622241831547, 0.10000000000000009, 0.20000000000000001, + 1.3962634015954636 }, + { 1.7608656115083421, 0.10000000000000009, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler103 = 2.5000000000000020e-13; + +// Test data for k=0.10000000000000009, nu=0.30000000000000004. +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 1.9186071760326645e-16 +// mean(f - f_Boost): -1.6653345369377347e-17 +// variance(f - f_Boost): 3.4238754566884194e-35 +// stddev(f - f_Boost): 5.8513891142945016e-18 +const testcase_ellint_3<double> +data104[10] = +{ + { 0.0000000000000000, 0.10000000000000009, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17507310163441189, 0.10000000000000009, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35337768072524217, 0.10000000000000009, 0.30000000000000004, + 0.34906585039886590 }, + { 0.53808167801629170, 0.10000000000000009, 0.30000000000000004, + 0.52359877559829882 }, + { 0.73215166755955019, 0.10000000000000009, 0.30000000000000004, + 0.69813170079773179 }, + { 0.93806546000201219, 0.10000000000000009, 0.30000000000000004, + 0.87266462599716477 }, + { 1.1573218723395986, 0.10000000000000009, 0.30000000000000004, + 1.0471975511965976 }, + { 1.3897859679542097, 0.10000000000000009, 0.30000000000000004, + 1.2217304763960306 }, + { 1.6331009404328622, 0.10000000000000009, 0.30000000000000004, + 1.3962634015954636 }, + { 1.8826015946315438, 0.10000000000000009, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler104 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.40000000000000002. -testcase_ellint_3<double> data105[] = { - { -0.0000000000000000, 0.10000000000000009, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17384216369897937, 0.10000000000000009, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34375018311376782, 0.10000000000000009, 0.40000000000000002, - 0.34906585039886590 }, - { 0.50672650758380455, 0.10000000000000009, 0.40000000000000002, - 0.52359877559829882 }, - { 0.66121264213337616, 0.10000000000000009, 0.40000000000000002, - 0.69813170079773179 }, - { 0.80706202005774441, 0.10000000000000009, 0.40000000000000002, - 0.87266462599716477 }, - { 0.94519376138245892, 0.10000000000000009, 0.40000000000000002, - 1.0471975511965976 }, - { 1.0771880300759584, 0.10000000000000009, 0.40000000000000002, - 1.2217304763960306 }, - { 1.2049711557188272, 0.10000000000000009, 0.40000000000000002, - 1.3962634015954636 }, - { 1.3306223265207477, 0.10000000000000009, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.10000000000000009, nu=0.40000000000000002. -template <typename Tp> -void test105() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data105) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data105[i].k), Tp(data105[i].nu), - Tp(data105[i].phi)); - const Tp f0 = data105[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.0338059536914377e-16 +// mean(f - f_Boost): 2.7755575615628914e-17 +// variance(f - f_Boost): 9.5107651574678308e-35 +// stddev(f - f_Boost): 9.7523151904908362e-18 +const testcase_ellint_3<double> +data105[10] = +{ + { 0.0000000000000000, 0.10000000000000009, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17525152094559704, 0.10000000000000009, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35483343742825979, 0.10000000000000009, 0.40000000000000002, + 0.34906585039886590 }, + { 0.54314913099505446, 0.10000000000000009, 0.40000000000000002, + 0.52359877559829882 }, + { 0.74463962034766862, 0.10000000000000009, 0.40000000000000002, + 0.69813170079773179 }, + { 0.96349276837570441, 0.10000000000000009, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2029081382746343, 0.10000000000000009, 0.40000000000000002, + 1.0471975511965976 }, + { 1.4638022887050806, 0.10000000000000009, 0.40000000000000002, + 1.2217304763960306 }, + { 1.7432413830105224, 0.10000000000000009, 0.40000000000000002, + 1.3962634015954636 }, + { 2.0336367403076760, 0.10000000000000009, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler105 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.50000000000000000. -testcase_ellint_3<double> data106[] = { - { -0.0000000000000000, 0.10000000000000009, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17366883711936554, 0.10000000000000009, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34244940634881876, 0.10000000000000009, 0.50000000000000000, - 0.34906585039886590 }, - { 0.50274793281634378, 0.10000000000000009, 0.50000000000000000, - 0.52359877559829882 }, - { 0.65287941633275093, 0.10000000000000009, 0.50000000000000000, - 0.69813170079773179 }, - { 0.79291198790315398, 0.10000000000000009, 0.50000000000000000, - 0.87266462599716477 }, - { 0.92412201537880345, 0.10000000000000009, 0.50000000000000000, - 1.0471975511965976 }, - { 1.0484480076799370, 0.10000000000000009, 0.50000000000000000, - 1.2217304763960306 }, - { 1.1681168130475206, 0.10000000000000009, 0.50000000000000000, - 1.3962634015954636 }, - { 1.2854480708580160, 0.10000000000000009, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.10000000000000009, nu=0.50000000000000000. -template <typename Tp> -void test106() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data106) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data106[i].k), Tp(data106[i].nu), - Tp(data106[i].phi)); - const Tp f0 = data106[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.10000000000000009, nu=0.59999999999999998. -testcase_ellint_3<double> data107[] = { - { -0.0000000000000000, 0.10000000000000009, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17349612891469018, 0.10000000000000009, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34116594505539438, 0.10000000000000009, 0.59999999999999998, - 0.34906585039886590 }, - { 0.49887649430466685, 0.10000000000000009, 0.59999999999999998, - 0.52359877559829882 }, - { 0.64489553282165157, 0.10000000000000009, 0.59999999999999998, - 0.69813170079773179 }, - { 0.77956016553782437, 0.10000000000000009, 0.59999999999999998, - 0.87266462599716477 }, - { 0.90451074530096309, 0.10000000000000009, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0220113666961632, 0.10000000000000009, 0.59999999999999998, - 1.2217304763960306 }, - { 1.1345351441065563, 0.10000000000000009, 0.59999999999999998, - 1.3962634015954636 }, - { 1.2445798942989255, 0.10000000000000009, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=0.10000000000000009, nu=0.59999999999999998. -template <typename Tp> -void test107() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data107) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data107[i].k), Tp(data107[i].nu), - Tp(data107[i].phi)); - const Tp f0 = data107[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.10000000000000009, nu=0.69999999999999996. -testcase_ellint_3<double> data108[] = { - { -0.0000000000000000, 0.10000000000000009, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17332403516105052, 0.10000000000000009, 0.69999999999999996, - 0.17453292519943295 }, - { 0.33989939374896877, 0.10000000000000009, 0.69999999999999996, - 0.34906585039886590 }, - { 0.49510719568614081, 0.10000000000000009, 0.69999999999999996, - 0.52359877559829882 }, - { 0.63723607776354974, 0.10000000000000009, 0.69999999999999996, - 0.69813170079773179 }, - { 0.76693133887935327, 0.10000000000000009, 0.69999999999999996, - 0.87266462599716477 }, - { 0.88619382078823827, 0.10000000000000009, 0.69999999999999996, - 1.0471975511965976 }, - { 0.99758012018676490, 0.10000000000000009, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1037642270814410, 0.10000000000000009, 0.69999999999999996, - 1.3962634015954636 }, - { 1.2073745911083187, 0.10000000000000009, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=0.10000000000000009, nu=0.69999999999999996. -template <typename Tp> -void test108() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data108) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data108[i].k), Tp(data108[i].nu), - Tp(data108[i].phi)); - const Tp f0 = data108[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.9864616042835278e-16 +// mean(f - f_Boost): 9.4368957093138303e-17 +// variance(f - f_Boost): 7.7794254682023874e-32 +// stddev(f - f_Boost): 2.7891621444803792e-16 +const testcase_ellint_3<double> +data106[10] = +{ + { 0.0000000000000000, 0.10000000000000009, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17543059564292182, 0.10000000000000009, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35631088838721664, 0.10000000000000009, 0.50000000000000000, + 0.34906585039886590 }, + { 0.54839023346436455, 0.10000000000000009, 0.50000000000000000, + 0.52359877559829882 }, + { 0.75790846946088830, 0.10000000000000009, 0.50000000000000000, + 0.69813170079773179 }, + { 0.99146713686720678, 0.10000000000000009, 0.50000000000000000, + 0.87266462599716477 }, + { 1.2551692247937198, 0.10000000000000009, 0.50000000000000000, + 1.0471975511965976 }, + { 1.5524660788146873, 0.10000000000000009, 0.50000000000000000, + 1.2217304763960306 }, + { 1.8806578570830670, 0.10000000000000009, 0.50000000000000000, + 1.3962634015954636 }, + { 2.2279868912966849, 0.10000000000000009, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler106 = 2.5000000000000020e-13; + +// Test data for k=0.10000000000000009, nu=0.60000000000000009. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.6726146516228014e-16 +// mean(f - f_Boost): -3.6082248300317589e-17 +// variance(f - f_Boost): 1.6073193116120635e-34 +// stddev(f - f_Boost): 1.2678009747638087e-17 +const testcase_ellint_3<double> +data107[10] = +{ + { 0.0000000000000000, 0.10000000000000009, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17561033003590576, 0.10000000000000009, 0.60000000000000009, + 0.17453292519943295 }, + { 0.35781061668171932, 0.10000000000000009, 0.60000000000000009, + 0.34906585039886590 }, + { 0.55381585659629196, 0.10000000000000009, 0.60000000000000009, + 0.52359877559829882 }, + { 0.77204910484575640, 0.10000000000000009, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0224751740393108, 0.10000000000000009, 0.60000000000000009, + 0.87266462599716477 }, + { 1.3160230906351114, 0.10000000000000009, 0.60000000000000009, + 1.0471975511965976 }, + { 1.6616282844233206, 0.10000000000000009, 0.60000000000000009, + 1.2217304763960306 }, + { 2.0592555664850392, 0.10000000000000009, 0.60000000000000009, + 1.3962634015954636 }, + { 2.4913004919173822, 0.10000000000000009, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler107 = 2.5000000000000020e-13; + +// Test data for k=0.10000000000000009, nu=0.70000000000000007. +// max(|f - f_Boost|): 2.2204460492503131e-16 at index 5 +// max(|f - f_Boost| / |f_Boost|): 2.1004074871280821e-16 +// mean(f - f_Boost): 3.3306690738754695e-17 +// variance(f - f_Boost): 1.3695501826753678e-34 +// stddev(f - f_Boost): 1.1702778228589003e-17 +const testcase_ellint_3<double> +data108[10] = +{ + { 0.0000000000000000, 0.10000000000000009, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17579072847532518, 0.10000000000000009, 0.70000000000000007, + 0.17453292519943295 }, + { 0.35933322840606297, 0.10000000000000009, 0.70000000000000007, + 0.34906585039886590 }, + { 0.55943788649460324, 0.10000000000000009, 0.70000000000000007, + 0.52359877559829882 }, + { 0.78716856504031707, 0.10000000000000009, 0.70000000000000007, + 0.69813170079773179 }, + { 1.0571501305617423, 0.10000000000000009, 0.70000000000000007, + 0.87266462599716477 }, + { 1.3882948301743525, 0.10000000000000009, 0.70000000000000007, + 1.0471975511965976 }, + { 1.8011785680114223, 0.10000000000000009, 0.70000000000000007, + 1.2217304763960306 }, + { 2.3057268183616464, 0.10000000000000009, 0.70000000000000007, + 1.3962634015954636 }, + { 2.8771910188009739, 0.10000000000000009, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler108 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.80000000000000004. -testcase_ellint_3<double> data109[] = { - { -0.0000000000000000, 0.10000000000000009, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17315255197057020, 0.10000000000000009, 0.80000000000000004, - 0.17453292519943295 }, - { 0.33864936055747985, 0.10000000000000009, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49143537041117619, 0.10000000000000009, 0.80000000000000004, - 0.52359877559829882 }, - { 0.62987861760047492, 0.10000000000000009, 0.80000000000000004, - 0.69813170079773179 }, - { 0.75496005490917517, 0.10000000000000009, 0.80000000000000004, - 0.87266462599716477 }, - { 0.86903081862701903, 0.10000000000000009, 0.80000000000000004, - 1.0471975511965976 }, - { 0.97490814820725591, 0.10000000000000009, 0.80000000000000004, - 1.2217304763960306 }, - { 1.0754290107171083, 0.10000000000000009, 0.80000000000000004, - 1.3962634015954636 }, - { 1.1733158866987732, 0.10000000000000009, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=0.10000000000000009, nu=0.80000000000000004. -template <typename Tp> -void test109() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data109) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data109[i].k), Tp(data109[i].nu), - Tp(data109[i].phi)); - const Tp f0 = data109[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.3133043868392355e-16 +// mean(f - f_Boost): 1.8041124150158794e-16 +// variance(f - f_Boost): 6.1843750436434569e-32 +// stddev(f - f_Boost): 2.4868403735751633e-16 +const testcase_ellint_3<double> +data109[10] = +{ + { 0.0000000000000000, 0.10000000000000009, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17597179535373417, 0.10000000000000009, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36087935387831499, 0.10000000000000009, 0.80000000000000004, + 0.34906585039886590 }, + { 0.56526935244526444, 0.10000000000000009, 0.80000000000000004, + 0.52359877559829882 }, + { 0.80339402590612397, 0.10000000000000009, 0.80000000000000004, + 0.69813170079773179 }, + { 1.0963358646374459, 0.10000000000000009, 0.80000000000000004, + 0.87266462599716477 }, + { 1.4763748483246868, 0.10000000000000009, 0.80000000000000004, + 1.0471975511965976 }, + { 1.9896610222794102, 0.10000000000000009, 0.80000000000000004, + 1.2217304763960306 }, + { 2.6806423920122024, 0.10000000000000009, 0.80000000000000004, + 1.3962634015954636 }, + { 3.5246199613295612, 0.10000000000000009, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler109 = 2.5000000000000020e-13; // Test data for k=0.10000000000000009, nu=0.90000000000000002. -testcase_ellint_3<double> data110[] = { - { -0.0000000000000000, 0.10000000000000009, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17298167549096569, 0.10000000000000009, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33741546662741584, 0.10000000000000009, 0.90000000000000002, - 0.34906585039886590 }, - { 0.48785665376856879, 0.10000000000000009, 0.90000000000000002, - 0.52359877559829882 }, - { 0.62280288554518959, 0.10000000000000009, 0.90000000000000002, - 0.69813170079773179 }, - { 0.74358903115455199, 0.10000000000000009, 0.90000000000000002, - 0.87266462599716477 }, - { 0.85290207679298358, 0.10000000000000009, 0.90000000000000002, - 1.0471975511965976 }, - { 0.95379006645397379, 0.10000000000000009, 0.90000000000000002, - 1.2217304763960306 }, - { 1.0492213119872327, 0.10000000000000009, 0.90000000000000002, - 1.3962634015954636 }, - { 1.1419839485283374, 0.10000000000000009, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.10000000000000009, nu=0.90000000000000002. -template <typename Tp> -void test110() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data110) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data110[i].k), Tp(data110[i].nu), - Tp(data110[i].phi)); - const Tp f0 = data110[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.19999999999999996, nu=0.0000000000000000. -testcase_ellint_3<double> data111[] = { - { -0.0000000000000000, 0.19999999999999996, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17456817290292811, 0.19999999999999996, 0.0000000000000000, - 0.17453292519943295 }, - { 0.34934315932086801, 0.19999999999999996, 0.0000000000000000, - 0.34906585039886590 }, - { 0.52450880529443988, 0.19999999999999996, 0.0000000000000000, - 0.52359877559829882 }, - { 0.70020491009844910, 0.19999999999999996, 0.0000000000000000, - 0.69813170079773179 }, - { 0.87651006649967955, 0.19999999999999996, 0.0000000000000000, - 0.87266462599716477 }, - { 1.0534305870298994, 0.19999999999999996, 0.0000000000000000, - 1.0471975511965976 }, - { 1.2308975521670784, 0.19999999999999996, 0.0000000000000000, - 1.2217304763960306 }, - { 1.4087733584990738, 0.19999999999999996, 0.0000000000000000, - 1.3962634015954636 }, - { 1.5868678474541664, 0.19999999999999996, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.19999999999999996, nu=0.0000000000000000. -template <typename Tp> -void test111() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data111) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data111[i].k), Tp(data111[i].nu), - Tp(data111[i].phi)); - const Tp f0 = data111[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.19999999999999996, nu=0.10000000000000001. -testcase_ellint_3<double> data112[] = { - { -0.0000000000000000, 0.19999999999999996, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17439228502691750, 0.19999999999999996, 0.10000000000000001, - 0.17453292519943295 }, - { 0.34796731137565740, 0.19999999999999996, 0.10000000000000001, - 0.34906585039886590 }, - { 0.52003370294544848, 0.19999999999999996, 0.10000000000000001, - 0.52359877559829882 }, - { 0.69012222258631495, 0.19999999999999996, 0.10000000000000001, - 0.69813170079773179 }, - { 0.85803491465566772, 0.19999999999999996, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0238463961099364, 0.19999999999999996, 0.10000000000000001, - 1.0471975511965976 }, - { 1.1878691059202153, 0.19999999999999996, 0.10000000000000001, - 1.2217304763960306 }, - { 1.3505985031831940, 0.19999999999999996, 0.10000000000000001, - 1.3962634015954636 }, - { 1.5126513474261092, 0.19999999999999996, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.19999999999999996, nu=0.10000000000000001. -template <typename Tp> -void test112() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data112) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data112[i].k), Tp(data112[i].nu), - Tp(data112[i].phi)); - const Tp f0 = data112[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.19999999999999996, nu=0.20000000000000001. -testcase_ellint_3<double> data113[] = { - { -0.0000000000000000, 0.19999999999999996, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17421703179583750, 0.19999999999999996, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34661057411998791, 0.19999999999999996, 0.20000000000000001, - 0.34906585039886590 }, - { 0.51569006052647393, 0.19999999999999996, 0.20000000000000001, - 0.52359877559829882 }, - { 0.68052412821107278, 0.19999999999999996, 0.20000000000000001, - 0.69813170079773179 }, - { 0.84081341263313825, 0.19999999999999996, 0.20000000000000001, - 0.87266462599716477 }, - { 0.99683359988842890, 0.19999999999999996, 0.20000000000000001, - 1.0471975511965976 }, - { 1.1493086715118852, 0.19999999999999996, 0.20000000000000001, - 1.2217304763960306 }, - { 1.2992699693957541, 0.19999999999999996, 0.20000000000000001, - 1.3962634015954636 }, - { 1.4479323932249568, 0.19999999999999996, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.19999999999999996, nu=0.20000000000000001. -template <typename Tp> -void test113() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data113) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data113[i].k), Tp(data113[i].nu), - Tp(data113[i].phi)); - const Tp f0 = data113[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.19999999999999996, nu=0.29999999999999999. -testcase_ellint_3<double> data114[] = { - { -0.0000000000000000, 0.19999999999999996, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17404240913577707, 0.19999999999999996, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34527248032587193, 0.19999999999999996, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51147118981668416, 0.19999999999999996, 0.29999999999999999, - 0.52359877559829882 }, - { 0.67137107867777635, 0.19999999999999996, 0.29999999999999999, - 0.69813170079773179 }, - { 0.82470418188668893, 0.19999999999999996, 0.29999999999999999, - 0.87266462599716477 }, - { 0.97202873223594299, 0.19999999999999996, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1144773569375266, 0.19999999999999996, 0.29999999999999999, - 1.2217304763960306 }, - { 1.2535292433701000, 0.19999999999999996, 0.29999999999999999, - 1.3962634015954636 }, - { 1.3908453514752481, 0.19999999999999996, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=0.19999999999999996, nu=0.29999999999999999. -template <typename Tp> -void test114() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data114) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data114[i].k), Tp(data114[i].nu), - Tp(data114[i].phi)); - const Tp f0 = data114[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.19999999999999996, nu=0.40000000000000002. -testcase_ellint_3<double> data115[] = { - { -0.0000000000000000, 0.19999999999999996, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17386841301066677, 0.19999999999999996, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34395257914113253, 0.19999999999999996, 0.40000000000000002, - 0.34906585039886590 }, - { 0.50737088376869466, 0.19999999999999996, 0.40000000000000002, - 0.52359877559829882 }, - { 0.66262801717277664, 0.19999999999999996, 0.40000000000000002, - 0.69813170079773179 }, - { 0.80958766645079094, 0.19999999999999996, 0.40000000000000002, - 0.87266462599716477 }, - { 0.94913754236162040, 0.19999999999999996, 0.40000000000000002, - 1.0471975511965976 }, - { 1.0827985514223000, 0.19999999999999996, 0.40000000000000002, - 1.2217304763960306 }, - { 1.2124212429050478, 0.19999999999999996, 0.40000000000000002, - 1.3962634015954636 }, - { 1.3400002519661010, 0.19999999999999996, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.19999999999999996, nu=0.40000000000000002. -template <typename Tp> -void test115() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data115) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data115[i].k), Tp(data115[i].nu), - Tp(data115[i].phi)); - const Tp f0 = data115[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.19999999999999996, nu=0.50000000000000000. -testcase_ellint_3<double> data116[] = { - { -0.0000000000000000, 0.19999999999999996, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17369503942181802, 0.19999999999999996, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34265043534362660, 0.19999999999999996, 0.50000000000000000, - 0.34906585039886590 }, - { 0.50338337208655415, 0.19999999999999996, 0.50000000000000000, - 0.52359877559829882 }, - { 0.65426373297163642, 0.19999999999999996, 0.50000000000000000, - 0.69813170079773179 }, - { 0.79536193036145808, 0.19999999999999996, 0.50000000000000000, - 0.87266462599716477 }, - { 0.92791875910061605, 0.19999999999999996, 0.50000000000000000, - 1.0471975511965976 }, - { 1.0538145052725829, 0.19999999999999996, 0.50000000000000000, - 1.2217304763960306 }, - { 1.1752060022875899, 0.19999999999999996, 0.50000000000000000, - 1.3962634015954636 }, - { 1.2943374404397376, 0.19999999999999996, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.19999999999999996, nu=0.50000000000000000. -template <typename Tp> -void test116() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data116) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data116[i].k), Tp(data116[i].nu), - Tp(data116[i].phi)); - const Tp f0 = data116[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.19999999999999996, nu=0.59999999999999998. -testcase_ellint_3<double> data117[] = { - { -0.0000000000000000, 0.19999999999999996, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17352228440746928, 0.19999999999999996, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34136562863713626, 0.19999999999999996, 0.59999999999999998, - 0.34906585039886590 }, - { 0.49950328177638481, 0.19999999999999996, 0.59999999999999998, - 0.52359877559829882 }, - { 0.64625032705690832, 0.19999999999999996, 0.59999999999999998, - 0.69813170079773179 }, - { 0.78193941198403094, 0.19999999999999996, 0.59999999999999998, - 0.87266462599716477 }, - { 0.90817230934317128, 0.19999999999999996, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0271563751276462, 0.19999999999999996, 0.59999999999999998, - 1.2217304763960306 }, - { 1.1412999379040518, 0.19999999999999996, 0.59999999999999998, - 1.3962634015954636 }, - { 1.2530330675914561, 0.19999999999999996, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=0.19999999999999996, nu=0.59999999999999998. -template <typename Tp> -void test117() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data117) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data117[i].k), Tp(data117[i].nu), - Tp(data117[i].phi)); - const Tp f0 = data117[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.19999999999999996, nu=0.69999999999999996. -testcase_ellint_3<double> data118[] = { - { -0.0000000000000000, 0.19999999999999996, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17335014404233898, 0.19999999999999996, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34009775298617811, 0.19999999999999996, 0.69999999999999996, - 0.34906585039886590 }, - { 0.49572560201923810, 0.19999999999999996, 0.69999999999999996, - 0.52359877559829882 }, - { 0.63856276669886525, 0.19999999999999996, 0.69999999999999996, - 0.69813170079773179 }, - { 0.76924438644867565, 0.19999999999999996, 0.69999999999999996, - 0.87266462599716477 }, - { 0.88973060843856466, 0.19999999999999996, 0.69999999999999996, - 1.0471975511965976 }, - { 1.0025230471636377, 0.19999999999999996, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1102356376093103, 0.19999999999999996, 0.69999999999999996, - 1.3962634015954636 }, - { 1.2154356555075867, 0.19999999999999996, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=0.19999999999999996, nu=0.69999999999999996. -template <typename Tp> -void test118() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data118) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data118[i].k), Tp(data118[i].nu), - Tp(data118[i].phi)); - const Tp f0 = data118[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.19999999999999996, nu=0.80000000000000004. -testcase_ellint_3<double> data119[] = { - { -0.0000000000000000, 0.19999999999999996, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17317861443718541, 0.19999999999999996, 0.80000000000000004, - 0.17453292519943295 }, - { 0.33884641598718701, 0.19999999999999996, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49204565281259494, 0.19999999999999996, 0.80000000000000004, - 0.52359877559829882 }, - { 0.63117851188220353, 0.19999999999999996, 0.80000000000000004, - 0.69813170079773179 }, - { 0.75721095949544170, 0.19999999999999996, 0.80000000000000004, - 0.87266462599716477 }, - { 0.87245201443919118, 0.19999999999999996, 0.80000000000000004, - 1.0471975511965976 }, - { 0.97966584238831089, 0.19999999999999996, 0.80000000000000004, - 1.2217304763960306 }, - { 1.0816336325174360, 0.19999999999999996, 0.80000000000000004, - 1.3962634015954636 }, - { 1.1810223448909913, 0.19999999999999996, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=0.19999999999999996, nu=0.80000000000000004. -template <typename Tp> -void test119() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data119) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data119[i].k), Tp(data119[i].nu), - Tp(data119[i].phi)); - const Tp f0 = data119[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.19999999999999996, nu=0.90000000000000002. -testcase_ellint_3<double> data120[] = { - { -0.0000000000000000, 0.19999999999999996, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17300769173837280, 0.19999999999999996, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33761123827372508, 0.19999999999999996, 0.90000000000000002, - 0.34906585039886590 }, - { 0.48845905690769426, 0.19999999999999996, 0.90000000000000002, - 0.52359877559829882 }, - { 0.62407720017324986, 0.19999999999999996, 0.90000000000000002, - 0.69813170079773179 }, - { 0.74578146525124289, 0.19999999999999996, 0.90000000000000002, - 0.87266462599716477 }, - { 0.85621583540073076, 0.19999999999999996, 0.90000000000000002, - 1.0471975511965976 }, - { 0.95837725988001199, 0.19999999999999996, 0.90000000000000002, - 1.2217304763960306 }, - { 1.0551821412633928, 0.19999999999999996, 0.90000000000000002, - 1.3962634015954636 }, - { 1.1493679916141863, 0.19999999999999996, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.19999999999999996, nu=0.90000000000000002. -template <typename Tp> -void test120() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data120) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data120[i].k), Tp(data120[i].nu), - Tp(data120[i].phi)); - const Tp f0 = data120[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.5624826890976725e-16 +// mean(f - f_Boost): 2.3314683517128288e-16 +// variance(f - f_Boost): 2.9401198977189756e-31 +// stddev(f - f_Boost): 5.4222872459129045e-16 +const testcase_ellint_3<double> +data110[10] = +{ + { 0.0000000000000000, 0.10000000000000009, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17615353510599349, 0.10000000000000009, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36244964892922371, 0.10000000000000009, 0.90000000000000002, + 0.34906585039886590 }, + { 0.57132457590110530, 0.10000000000000009, 0.90000000000000002, + 0.52359877559829882 }, + { 0.82087808820385000, 0.10000000000000009, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1411894342144451, 0.10000000000000009, 0.90000000000000002, + 0.87266462599716477 }, + { 1.5875929286844597, 0.10000000000000009, 0.90000000000000002, + 1.0471975511965976 }, + { 2.2678622986596659, 0.10000000000000009, 0.90000000000000002, + 1.2217304763960306 }, + { 3.3697528941897903, 0.10000000000000009, 0.90000000000000002, + 1.3962634015954636 }, + { 4.9862890417305499, 0.10000000000000009, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler110 = 2.5000000000000020e-13; + +// Test data for k=0.20000000000000018, nu=0.0000000000000000. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 4.2156475739151676e-16 +// mean(f - f_Boost): -5.2735593669694933e-17 +// variance(f - f_Boost): 3.0473442641042680e-32 +// stddev(f - f_Boost): 1.7456644190978597e-16 +const testcase_ellint_3<double> +data111[10] = +{ + { 0.0000000000000000, 0.20000000000000018, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17456817290292806, 0.20000000000000018, 0.0000000000000000, + 0.17453292519943295 }, + { 0.34934315932086796, 0.20000000000000018, 0.0000000000000000, + 0.34906585039886590 }, + { 0.52450880529443988, 0.20000000000000018, 0.0000000000000000, + 0.52359877559829882 }, + { 0.70020491009844887, 0.20000000000000018, 0.0000000000000000, + 0.69813170079773179 }, + { 0.87651006649967977, 0.20000000000000018, 0.0000000000000000, + 0.87266462599716477 }, + { 1.0534305870298994, 0.20000000000000018, 0.0000000000000000, + 1.0471975511965976 }, + { 1.2308975521670789, 0.20000000000000018, 0.0000000000000000, + 1.2217304763960306 }, + { 1.4087733584990738, 0.20000000000000018, 0.0000000000000000, + 1.3962634015954636 }, + { 1.5868678474541662, 0.20000000000000018, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler111 = 2.5000000000000020e-13; + +// Test data for k=0.20000000000000018, nu=0.10000000000000001. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 4.0890622182605400e-16 +// mean(f - f_Boost): -3.8857805861880476e-17 +// variance(f - f_Boost): 2.8794792590749608e-32 +// stddev(f - f_Boost): 1.6969028431454054e-16 +const testcase_ellint_3<double> +data112[10] = +{ + { 0.0000000000000000, 0.20000000000000018, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17474469953608965, 0.20000000000000018, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35073860234984255, 0.20000000000000018, 0.10000000000000001, + 0.34906585039886590 }, + { 0.52912258712951521, 0.20000000000000018, 0.10000000000000001, + 0.52359877559829882 }, + { 0.71081701558898069, 0.20000000000000018, 0.10000000000000001, + 0.69813170079773179 }, + { 0.89640758521169384, 0.20000000000000018, 0.10000000000000001, + 0.87266462599716477 }, + { 1.0860417038089853, 0.20000000000000018, 0.10000000000000001, + 1.0471975511965976 }, + { 1.2793599255528623, 0.20000000000000018, 0.10000000000000001, + 1.2217304763960306 }, + { 1.4754938544089076, 0.20000000000000018, 0.10000000000000001, + 1.3962634015954636 }, + { 1.6731552050562593, 0.20000000000000018, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler112 = 2.5000000000000020e-13; + +// Test data for k=0.20000000000000018, nu=0.20000000000000001. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 3.9570963716579749e-16 +// mean(f - f_Boost): -5.8286708792820721e-17 +// variance(f - f_Boost): 3.1158217732380362e-32 +// stddev(f - f_Boost): 1.7651690494788412e-16 +const testcase_ellint_3<double> +data113[10] = +{ + { 0.0000000000000000, 0.20000000000000018, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17492186907740698, 0.20000000000000018, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35215414286134267, 0.20000000000000018, 0.20000000000000001, + 0.34906585039886590 }, + { 0.53388285615182440, 0.20000000000000018, 0.20000000000000001, + 0.52359877559829882 }, + { 0.72200960282688265, 0.20000000000000018, 0.20000000000000001, + 0.69813170079773179 }, + { 0.91793087614428526, 0.20000000000000018, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1222602841587976, 0.20000000000000018, 0.20000000000000001, + 1.0471975511965976 }, + { 1.3345489407496247, 0.20000000000000018, 0.20000000000000001, + 1.2217304763960306 }, + { 1.5531225705475502, 0.20000000000000018, 0.20000000000000001, + 1.3962634015954636 }, + { 1.7751816279738935, 0.20000000000000018, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler113 = 2.5000000000000020e-13; + +// Test data for k=0.20000000000000018, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.6785817924053817e-16 +// mean(f - f_Boost): -1.1102230246251566e-17 +// variance(f - f_Boost): 9.9840208317034302e-32 +// stddev(f - f_Boost): 3.1597501217190311e-16 +const testcase_ellint_3<double> +data114[10] = +{ + { 0.0000000000000000, 0.20000000000000018, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17509968571715159, 0.20000000000000018, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35359030214835629, 0.20000000000000018, 0.30000000000000004, + 0.34906585039886590 }, + { 0.53879807274537084, 0.20000000000000018, 0.30000000000000004, + 0.52359877559829882 }, + { 0.73384116418059731, 0.20000000000000018, 0.30000000000000004, + 0.69813170079773179 }, + { 0.94132799329524031, 0.20000000000000018, 0.30000000000000004, + 0.87266462599716477 }, + { 1.1628407021801439, 0.20000000000000018, 0.30000000000000004, + 1.0471975511965976 }, + { 1.3982440216739438, 0.20000000000000018, 0.30000000000000004, + 1.2217304763960306 }, + { 1.6450634983653640, 0.20000000000000018, 0.30000000000000004, + 1.3962634015954636 }, + { 1.8983924169967099, 0.20000000000000018, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler114 = 2.5000000000000020e-13; + +// Test data for k=0.20000000000000018, nu=0.40000000000000002. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 6 +// max(|f - f_Boost| / |f_Boost|): 3.6738449250038925e-16 +// mean(f - f_Boost): -3.0531133177191807e-17 +// variance(f - f_Boost): 2.7810428396951687e-32 +// stddev(f - f_Boost): 1.6676458975739331e-16 +const testcase_ellint_3<double> +data115[10] = +{ + { 0.0000000000000000, 0.20000000000000018, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17527815368535152, 0.20000000000000018, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35504762134297801, 0.20000000000000018, 0.40000000000000002, + 0.34906585039886590 }, + { 0.54387742353211344, 0.20000000000000018, 0.40000000000000002, + 0.52359877559829882 }, + { 0.74637910471804259, 0.20000000000000018, 0.40000000000000002, + 0.69813170079773179 }, + { 0.96690539714174639, 0.20000000000000018, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2087859420184757, 0.20000000000000018, 0.40000000000000002, + 1.0471975511965976 }, + { 1.4729799844168852, 0.20000000000000018, 0.40000000000000002, + 1.2217304763960306 }, + { 1.7564445064596661, 0.20000000000000018, 0.40000000000000002, + 1.3962634015954636 }, + { 2.0512956926676806, 0.20000000000000018, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler115 = 2.5000000000000020e-13; + +// Test data for k=0.20000000000000018, nu=0.50000000000000000. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.3841806057292116e-16 +// mean(f - f_Boost): 3.6082248300317589e-17 +// variance(f - f_Boost): 8.9638010532618564e-32 +// stddev(f - f_Boost): 2.9939607634806868e-16 +const testcase_ellint_3<double> +data116[10] = +{ + { 0.0000000000000000, 0.20000000000000018, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17545727725228877, 0.20000000000000018, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35652666242062175, 0.20000000000000018, 0.50000000000000000, + 0.34906585039886590 }, + { 0.54913090549102406, 0.20000000000000018, 0.50000000000000000, + 0.52359877559829882 }, + { 0.75970161209211551, 0.20000000000000018, 0.50000000000000000, + 0.69813170079773179 }, + { 0.99504737401590326, 0.20000000000000018, 0.50000000000000000, + 0.87266462599716477 }, + { 1.2614666007124373, 0.20000000000000018, 0.50000000000000000, + 1.0471975511965976 }, + { 1.5625255355205498, 0.20000000000000018, 0.50000000000000000, + 1.2217304763960306 }, + { 1.8954460255613346, 0.20000000000000018, 0.50000000000000000, + 1.3962634015954636 }, + { 2.2481046259421302, 0.20000000000000018, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler116 = 2.5000000000000020e-13; + +// Test data for k=0.20000000000000018, nu=0.60000000000000009. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.5317584994994743e-16 +// mean(f - f_Boost): -1.3877787807814457e-17 +// variance(f - f_Boost): 1.0045745697575397e-31 +// stddev(f - f_Boost): 3.1695024369095219e-16 +const testcase_ellint_3<double> +data117[10] = +{ + { 0.0000000000000000, 0.20000000000000018, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17563706072900442, 0.20000000000000018, 0.60000000000000009, + 0.17453292519943295 }, + { 0.35802800926807238, 0.20000000000000018, 0.60000000000000009, + 0.34906585039886590 }, + { 0.55456942250515051, 0.20000000000000018, 0.60000000000000009, + 0.52359877559829882 }, + { 0.77390003828438203, 0.20000000000000018, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0262441366366397, 0.20000000000000018, 0.60000000000000009, + 0.87266462599716477 }, + { 1.3228192988439669, 0.20000000000000018, 0.60000000000000009, + 1.0471975511965976 }, + { 1.6728005754680795, 0.20000000000000018, 0.60000000000000009, + 1.2217304763960306 }, + { 2.0761587107468511, 0.20000000000000018, 0.60000000000000009, + 1.3962634015954636 }, + { 2.5148333891629315, 0.20000000000000018, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler117 = 2.5000000000000020e-13; + +// Test data for k=0.20000000000000018, nu=0.70000000000000007. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.2209418045118284e-16 +// mean(f - f_Boost): 2.4980018054066023e-17 +// variance(f - f_Boost): 9.1989071679544611e-32 +// stddev(f - f_Boost): 3.0329700242426498e-16 +const testcase_ellint_3<double> +data118[10] = +{ + { 0.0000000000000000, 0.20000000000000018, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17581750846781172, 0.20000000000000018, 0.70000000000000007, + 0.17453292519943295 }, + { 0.35955226882028513, 0.20000000000000018, 0.70000000000000007, + 0.34906585039886590 }, + { 0.56020489659466499, 0.20000000000000018, 0.70000000000000007, + 0.52359877559829882 }, + { 0.78908196988531498, 0.20000000000000018, 0.70000000000000007, + 0.69813170079773179 }, + { 1.0611336754143517, 0.20000000000000018, 0.70000000000000007, + 0.87266462599716477 }, + { 1.3956969951058884, 0.20000000000000018, 0.70000000000000007, + 1.0471975511965976 }, + { 1.8138131612209609, 0.20000000000000018, 0.70000000000000007, + 1.2217304763960306 }, + { 2.3256365528879561, 0.20000000000000018, 0.70000000000000007, + 1.3962634015954636 }, + { 2.9058704854500963, 0.20000000000000018, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler118 = 2.5000000000000020e-13; + +// Test data for k=0.20000000000000018, nu=0.80000000000000004. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.7399960886656824e-16 +// mean(f - f_Boost): 1.3877787807814457e-16 +// variance(f - f_Boost): 1.7585404776158019e-31 +// stddev(f - f_Boost): 4.1934955319110593e-16 +const testcase_ellint_3<double> +data119[10] = +{ + { 0.0000000000000000, 0.20000000000000018, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17599862486281712, 0.20000000000000018, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36110007227128776, 0.20000000000000018, 0.80000000000000004, + 0.34906585039886590 }, + { 0.56605039658567224, 0.20000000000000018, 0.80000000000000004, + 0.52359877559829882 }, + { 0.80537523874517691, 0.20000000000000018, 0.80000000000000004, + 0.69813170079773179 }, + { 1.1005662342414086, 0.20000000000000018, 0.80000000000000004, + 0.87266462599716477 }, + { 1.4845340298105778, 0.20000000000000018, 0.80000000000000004, + 1.0471975511965976 }, + { 2.0043332244969392, 0.20000000000000018, 0.80000000000000004, + 1.2217304763960306 }, + { 2.7052856676744761, 0.20000000000000018, 0.80000000000000004, + 1.3962634015954636 }, + { 3.5622166386422633, 0.20000000000000018, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler119 = 2.5000000000000020e-13; + +// Test data for k=0.20000000000000018, nu=0.90000000000000002. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.1718503329017390e-16 +// mean(f - f_Boost): 2.3592239273284576e-16 +// variance(f - f_Boost): 2.9295534376290287e-31 +// stddev(f - f_Boost): 5.4125349307224141e-16 +const testcase_ellint_3<double> +data120[10] = +{ + { 0.0000000000000000, 0.20000000000000018, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17618041435044951, 0.20000000000000018, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36267207636502929, 0.20000000000000018, 0.90000000000000002, + 0.34906585039886590 }, + { 0.57212028758237743, 0.20000000000000018, 0.90000000000000002, + 0.52359877559829882 }, + { 0.82293323876704483, 0.20000000000000018, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1457077279880388, 0.20000000000000018, 0.90000000000000002, + 0.87266462599716477 }, + { 1.5967346899325681, 0.20000000000000018, 0.90000000000000002, + 1.0471975511965976 }, + { 2.2856537353421724, 0.20000000000000018, 0.90000000000000002, + 1.2217304763960306 }, + { 3.4034714304613902, 0.20000000000000018, 0.90000000000000002, + 1.3962634015954636 }, + { 5.0448269356200370, 0.20000000000000018, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler120 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.0000000000000000. -testcase_ellint_3<double> data121[] = { - { -0.0000000000000000, 0.30000000000000004, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17461228653000102, 0.30000000000000004, 0.0000000000000000, - 0.17453292519943295 }, - { 0.34969146102798415, 0.30000000000000004, 0.0000000000000000, - 0.34906585039886590 }, - { 0.52565822873726320, 0.30000000000000004, 0.0000000000000000, - 0.52359877559829882 }, - { 0.70284226512408532, 0.30000000000000004, 0.0000000000000000, - 0.69813170079773179 }, - { 0.88144139195111182, 0.30000000000000004, 0.0000000000000000, - 0.87266462599716477 }, - { 1.0614897067260523, 0.30000000000000004, 0.0000000000000000, - 1.0471975511965976 }, - { 1.2428416824174218, 0.30000000000000004, 0.0000000000000000, - 1.2217304763960306 }, - { 1.4251795877015925, 0.30000000000000004, 0.0000000000000000, - 1.3962634015954636 }, - { 1.6080486199305126, 0.30000000000000004, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.30000000000000004, nu=0.0000000000000000. -template <typename Tp> -void test121() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data121) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data121[i].k), Tp(data121[i].nu), - Tp(data121[i].phi)); - const Tp f0 = data121[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.2241249691539529e-16 +// mean(f - f_Boost): 2.7755575615628914e-17 +// variance(f - f_Boost): 2.1399221604302621e-32 +// stddev(f - f_Boost): 1.4628472785736254e-16 +const testcase_ellint_3<double> +data121[10] = +{ + { 0.0000000000000000, 0.30000000000000004, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17461228653000099, 0.30000000000000004, 0.0000000000000000, + 0.17453292519943295 }, + { 0.34969146102798421, 0.30000000000000004, 0.0000000000000000, + 0.34906585039886590 }, + { 0.52565822873726309, 0.30000000000000004, 0.0000000000000000, + 0.52359877559829882 }, + { 0.70284226512408543, 0.30000000000000004, 0.0000000000000000, + 0.69813170079773179 }, + { 0.88144139195111171, 0.30000000000000004, 0.0000000000000000, + 0.87266462599716477 }, + { 1.0614897067260520, 0.30000000000000004, 0.0000000000000000, + 1.0471975511965976 }, + { 1.2428416824174220, 0.30000000000000004, 0.0000000000000000, + 1.2217304763960306 }, + { 1.4251795877015929, 0.30000000000000004, 0.0000000000000000, + 1.3962634015954636 }, + { 1.6080486199305128, 0.30000000000000004, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler121 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.10000000000000001. -testcase_ellint_3<double> data122[] = { - { -0.0000000000000000, 0.30000000000000004, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17443631884814378, 0.30000000000000004, 0.10000000000000001, - 0.17453292519943295 }, - { 0.34831316835124926, 0.30000000000000004, 0.10000000000000001, - 0.34906585039886590 }, - { 0.52116586276523857, 0.30000000000000004, 0.10000000000000001, - 0.52359877559829882 }, - { 0.69269385837910036, 0.30000000000000004, 0.10000000000000001, - 0.69813170079773179 }, - { 0.86279023163070856, 0.30000000000000004, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0315321461438265, 0.30000000000000004, 0.10000000000000001, - 1.0471975511965976 }, - { 1.1991449111869024, 0.30000000000000004, 0.10000000000000001, - 1.2217304763960306 }, - { 1.3659561780923211, 0.30000000000000004, 0.10000000000000001, - 1.3962634015954636 }, - { 1.5323534693557526, 0.30000000000000004, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.30000000000000004, nu=0.10000000000000001. -template <typename Tp> -void test122() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data122) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data122[i].k), Tp(data122[i].nu), - Tp(data122[i].phi)); - const Tp f0 = data122[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.1872304407982844e-16 +// mean(f - f_Boost): 7.2164496600635178e-17 +// variance(f - f_Boost): 4.3555500115139682e-32 +// stddev(f - f_Boost): 2.0869954507650391e-16 +const testcase_ellint_3<double> +data122[10] = +{ + { 0.0000000000000000, 0.30000000000000004, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17478889331392972, 0.30000000000000004, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35108939018329183, 0.30000000000000004, 0.10000000000000001, + 0.34906585039886590 }, + { 0.53028990896115835, 0.30000000000000004, 0.10000000000000001, + 0.52359877559829882 }, + { 0.71352417052371409, 0.30000000000000004, 0.10000000000000001, + 0.69813170079773179 }, + { 0.90153086032405894, 0.30000000000000004, 0.10000000000000001, + 0.87266462599716477 }, + { 1.0945187977283313, 0.30000000000000004, 0.10000000000000001, + 1.0471975511965976 }, + { 1.2920699268385683, 0.30000000000000004, 0.10000000000000001, + 1.2217304763960306 }, + { 1.4931243665896394, 0.30000000000000004, 0.10000000000000001, + 1.3962634015954636 }, + { 1.6960848815118226, 0.30000000000000004, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler122 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.20000000000000001. -testcase_ellint_3<double> data123[] = { - { -0.0000000000000000, 0.30000000000000004, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17426098615372090, 0.30000000000000004, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34695402664689923, 0.30000000000000004, 0.20000000000000001, - 0.34906585039886590 }, - { 0.51680555567038933, 0.30000000000000004, 0.20000000000000001, - 0.52359877559829882 }, - { 0.68303375225260210, 0.30000000000000004, 0.20000000000000001, - 0.69813170079773179 }, - { 0.84540662891295026, 0.30000000000000004, 0.20000000000000001, - 0.87266462599716477 }, - { 1.0041834051646927, 0.30000000000000004, 0.20000000000000001, - 1.0471975511965976 }, - { 1.1599952702345711, 0.30000000000000004, 0.20000000000000001, - 1.2217304763960306 }, - { 1.3137179520499163, 0.30000000000000004, 0.20000000000000001, - 1.3962634015954636 }, - { 1.4663658145259875, 0.30000000000000004, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.30000000000000004, nu=0.20000000000000001. -template <typename Tp> -void test123() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data123) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data123[i].k), Tp(data123[i].nu), - Tp(data123[i].phi)); - const Tp f0 = data123[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.30000000000000004, nu=0.29999999999999999. -testcase_ellint_3<double> data124[] = { - { -0.0000000000000000, 0.30000000000000004, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17408628437042845, 0.30000000000000004, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34561356761638401, 0.30000000000000004, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51257058617875850, 0.30000000000000004, 0.29999999999999999, - 0.52359877559829882 }, - { 0.67382207124602866, 0.30000000000000004, 0.29999999999999999, - 0.69813170079773179 }, - { 0.82914751587825131, 0.30000000000000004, 0.29999999999999999, - 0.87266462599716477 }, - { 0.97907434814374950, 0.30000000000000004, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1246399297351584, 0.30000000000000004, 0.29999999999999999, - 1.2217304763960306 }, - { 1.2671793970398146, 0.30000000000000004, 0.29999999999999999, - 1.3962634015954636 }, - { 1.4081767433479089, 0.30000000000000004, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=0.30000000000000004, nu=0.29999999999999999. -template <typename Tp> -void test124() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data124) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data124[i].k), Tp(data124[i].nu), - Tp(data124[i].phi)); - const Tp f0 = data124[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.2247497610332889e-16 +// mean(f - f_Boost): 6.6613381477509390e-17 +// variance(f - f_Boost): 1.7591111235252501e-32 +// stddev(f - f_Boost): 1.3263148659067538e-16 +const testcase_ellint_3<double> +data123[10] = +{ + { 0.0000000000000000, 0.30000000000000004, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17496614335337535, 0.30000000000000004, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35250745937139372, 0.30000000000000004, 0.20000000000000001, + 0.34906585039886590 }, + { 0.53506875002836884, 0.30000000000000004, 0.20000000000000001, + 0.52359877559829882 }, + { 0.72479106622248191, 0.30000000000000004, 0.20000000000000001, + 0.69813170079773179 }, + { 0.92326451535891607, 0.30000000000000004, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1312092060698349, 0.30000000000000004, 0.20000000000000001, + 1.0471975511965976 }, + { 1.3481473154592321, 0.30000000000000004, 0.20000000000000001, + 1.2217304763960306 }, + { 1.5722049569662750, 0.30000000000000004, 0.20000000000000001, + 1.3962634015954636 }, + { 1.8002173372290500, 0.30000000000000004, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler123 = 2.5000000000000020e-13; + +// Test data for k=0.30000000000000004, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.1678685180047551e-16 +// mean(f - f_Boost): 1.0547118733938987e-16 +// variance(f - f_Boost): 7.5633408838247182e-32 +// stddev(f - f_Boost): 2.7501528837184157e-16 +const testcase_ellint_3<double> +data124[10] = +{ + { 0.0000000000000000, 0.30000000000000004, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17514404084107435, 0.30000000000000004, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35394619108645647, 0.30000000000000004, 0.30000000000000004, + 0.34906585039886590 }, + { 0.54000325463372689, 0.30000000000000004, 0.30000000000000004, + 0.52359877559829882 }, + { 0.73670193794067651, 0.30000000000000004, 0.30000000000000004, + 0.69813170079773179 }, + { 0.94689345491722177, 0.30000000000000004, 0.30000000000000004, + 0.87266462599716477 }, + { 1.1723274608389140, 0.30000000000000004, 0.30000000000000004, + 1.0471975511965976 }, + { 1.4128880552936287, 0.30000000000000004, 0.30000000000000004, + 1.2217304763960306 }, + { 1.6659010047449661, 0.30000000000000004, 0.30000000000000004, + 1.3962634015954636 }, + { 1.9260216862473254, 0.30000000000000004, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler124 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.40000000000000002. -testcase_ellint_3<double> data125[] = { - { -0.0000000000000000, 0.30000000000000004, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17391220945982730, 0.30000000000000004, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34429133937639689, 0.30000000000000004, 0.40000000000000002, - 0.34906585039886590 }, - { 0.50845471668581632, 0.30000000000000004, 0.40000000000000002, - 0.52359877559829882 }, - { 0.66502347027873854, 0.30000000000000004, 0.40000000000000002, - 0.69813170079773179 }, - { 0.81389191978012254, 0.30000000000000004, 0.40000000000000002, - 0.87266462599716477 }, - { 0.95590618002140593, 0.30000000000000004, 0.40000000000000002, - 1.0471975511965976 }, - { 1.0924915195213121, 0.30000000000000004, 0.40000000000000002, - 1.2217304763960306 }, - { 1.2253651604038058, 0.30000000000000004, 0.40000000000000002, - 1.3962634015954636 }, - { 1.3563643538969761, 0.30000000000000004, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.30000000000000004, nu=0.40000000000000002. -template <typename Tp> -void test125() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data125) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data125[i].k), Tp(data125[i].nu), - Tp(data125[i].phi)); - const Tp f0 = data125[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.3983279132797385e-16 +// mean(f - f_Boost): 1.1657341758564144e-16 +// variance(f - f_Boost): 1.8245832308692586e-31 +// stddev(f - f_Boost): 4.2715140534349863e-16 +const testcase_ellint_3<double> +data125[10] = +{ + { 0.0000000000000000, 0.30000000000000004, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17532259000954434, 0.30000000000000004, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35540612770983693, 0.30000000000000004, 0.40000000000000002, + 0.34906585039886590 }, + { 0.54510265552938919, 0.30000000000000004, 0.40000000000000002, + 0.52359877559829882 }, + { 0.74932476310965057, 0.30000000000000004, 0.40000000000000002, + 0.69813170079773179 }, + { 0.97272793583093109, 0.30000000000000004, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2188928987074241, 0.30000000000000004, 0.40000000000000002, + 1.0471975511965976 }, + { 1.4888771674085941, 0.30000000000000004, 0.40000000000000002, + 1.2217304763960306 }, + { 1.7794558498219191, 0.30000000000000004, 0.40000000000000002, + 1.3962634015954636 }, + { 2.0822121773175528, 0.30000000000000004, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler125 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.50000000000000000. -testcase_ellint_3<double> data126[] = { - { -0.0000000000000000, 0.30000000000000004, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17373875742088235, 0.30000000000000004, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34298690571124157, 0.30000000000000004, 0.50000000000000000, - 0.34906585039886590 }, - { 0.50445214859646936, 0.30000000000000004, 0.50000000000000000, - 0.52359877559829882 }, - { 0.65660648352418516, 0.30000000000000004, 0.50000000000000000, - 0.69813170079773179 }, - { 0.79953670639287289, 0.30000000000000004, 0.50000000000000000, - 0.87266462599716477 }, - { 0.93443393926588558, 0.30000000000000004, 0.50000000000000000, - 1.0471975511965976 }, - { 1.0630838369016911, 0.30000000000000004, 0.50000000000000000, - 1.2217304763960306 }, - { 1.1875197325653026, 0.30000000000000004, 0.50000000000000000, - 1.3962634015954636 }, - { 1.3098448759814960, 0.30000000000000004, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.30000000000000004, nu=0.50000000000000000. -template <typename Tp> -void test126() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data126) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data126[i].k), Tp(data126[i].nu), - Tp(data126[i].phi)); - const Tp f0 = data126[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.30000000000000004, nu=0.59999999999999998. -testcase_ellint_3<double> data127[] = { - { -0.0000000000000000, 0.30000000000000004, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17356592428950826, 0.30000000000000004, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34169984536697379, 0.30000000000000004, 0.59999999999999998, - 0.34906585039886590 }, - { 0.50055748266498457, 0.30000000000000004, 0.59999999999999998, - 0.52359877559829882 }, - { 0.64854298527106768, 0.30000000000000004, 0.59999999999999998, - 0.69813170079773179 }, - { 0.78599329284207431, 0.30000000000000004, 0.59999999999999998, - 0.87266462599716477 }, - { 0.91445452089128221, 0.30000000000000004, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0360412952290587, 0.30000000000000004, 0.59999999999999998, - 1.2217304763960306 }, - { 1.1530473919778639, 0.30000000000000004, 0.59999999999999998, - 1.3962634015954636 }, - { 1.2677758800420666, 0.30000000000000004, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=0.30000000000000004, nu=0.59999999999999998. -template <typename Tp> -void test127() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data127) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data127[i].k), Tp(data127[i].nu), - Tp(data127[i].phi)); - const Tp f0 = data127[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.30000000000000004, nu=0.69999999999999996. -testcase_ellint_3<double> data128[] = { - { -0.0000000000000000, 0.30000000000000004, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17339370613812227, 0.30000000000000004, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34042975138455933, 0.30000000000000004, 0.69999999999999996, - 0.34906585039886590 }, - { 0.49676568368075985, 0.30000000000000004, 0.69999999999999996, - 0.52359877559829882 }, - { 0.64080774055753720, 0.30000000000000004, 0.69999999999999996, - 0.69813170079773179 }, - { 0.77318507779667278, 0.30000000000000004, 0.69999999999999996, - 0.87266462599716477 }, - { 0.89579782346548631, 0.30000000000000004, 0.69999999999999996, - 1.0471975511965976 }, - { 1.0110573286052202, 0.30000000000000004, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1214710972949633, 0.30000000000000004, 0.69999999999999996, - 1.3962634015954636 }, - { 1.2294913236274980, 0.30000000000000004, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=0.30000000000000004, nu=0.69999999999999996. -template <typename Tp> -void test128() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data128) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data128[i].k), Tp(data128[i].nu), - Tp(data128[i].phi)); - const Tp f0 = data128[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.0516138451673425e-16 +// mean(f - f_Boost): 4.7184478546569152e-17 +// variance(f - f_Boost): 1.9448563670505968e-32 +// stddev(f - f_Boost): 1.3945810722401896e-16 +const testcase_ellint_3<double> +data126[10] = +{ + { 0.0000000000000000, 0.30000000000000004, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17550179513158179, 0.30000000000000004, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35688783251681200, 0.30000000000000004, 0.50000000000000000, + 0.34906585039886590 }, + { 0.55037700010142798, 0.30000000000000004, 0.50000000000000000, + 0.52359877559829882 }, + { 0.76273839789895992, 0.30000000000000004, 0.50000000000000000, + 0.69813170079773179 }, + { 1.0011570518830419, 0.30000000000000004, 0.50000000000000000, + 0.87266462599716477 }, + { 1.2722987414055109, 0.30000000000000004, 0.50000000000000000, + 1.0471975511965976 }, + { 1.5799590511080066, 0.30000000000000004, 0.50000000000000000, + 1.2217304763960306 }, + { 1.9212367220124293, 0.30000000000000004, 0.50000000000000000, + 1.3962634015954636 }, + { 2.2833505881933971, 0.30000000000000004, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler126 = 2.5000000000000020e-13; + +// Test data for k=0.30000000000000004, nu=0.60000000000000009. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.2121157428443725e-16 +// mean(f - f_Boost): 1.9428902930940239e-16 +// variance(f - f_Boost): 1.5987596229703424e-31 +// stddev(f - f_Boost): 3.9984492281012430e-16 +const testcase_ellint_3<double> +data127[10] = +{ + { 0.0000000000000000, 0.30000000000000004, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17568166052076745, 0.30000000000000004, 0.60000000000000009, + 0.17453292519943295 }, + { 0.35839189074731181, 0.30000000000000004, 0.60000000000000009, + 0.34906585039886590 }, + { 0.55583724744367558, 0.30000000000000004, 0.60000000000000009, + 0.52359877559829882 }, + { 0.77703498090888223, 0.30000000000000004, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0326772113675962, 0.30000000000000004, 0.60000000000000009, + 0.87266462599716477 }, + { 1.3345139983717369, 0.30000000000000004, 0.60000000000000009, + 1.0471975511965976 }, + { 1.6921742922838403, 0.30000000000000004, 0.60000000000000009, + 1.2217304763960306 }, + { 2.1056608968472186, 0.30000000000000004, 0.60000000000000009, + 1.3962634015954636 }, + { 2.5560975528589061, 0.30000000000000004, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler127 = 2.5000000000000020e-13; + +// Test data for k=0.30000000000000004, nu=0.70000000000000007. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.0088945789059381e-16 +// mean(f - f_Boost): 2.1094237467877973e-16 +// variance(f - f_Boost): 3.0253363535298873e-31 +// stddev(f - f_Boost): 5.5003057674368314e-16 +const testcase_ellint_3<double> +data128[10] = +{ + { 0.0000000000000000, 0.30000000000000004, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17586219053197988, 0.30000000000000004, 0.70000000000000007, + 0.17453292519943295 }, + { 0.35991891074557669, 0.30000000000000004, 0.70000000000000007, + 0.34906585039886590 }, + { 0.56149538019961731, 0.30000000000000004, 0.70000000000000007, + 0.52359877559829882 }, + { 0.79232303189667685, 0.30000000000000004, 0.70000000000000007, + 0.69813170079773179 }, + { 1.0679345542878826, 0.30000000000000004, 0.70000000000000007, + 0.87266462599716477 }, + { 1.4084400085913955, 0.30000000000000004, 0.70000000000000007, + 1.0471975511965976 }, + { 1.8357382859296454, 0.30000000000000004, 0.70000000000000007, + 1.2217304763960306 }, + { 2.3604197996171519, 0.30000000000000004, 0.70000000000000007, + 1.3962634015954636 }, + { 2.9562123549913872, 0.30000000000000004, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler128 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.80000000000000004. -testcase_ellint_3<double> data129[] = { - { -0.0000000000000000, 0.30000000000000004, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17322209907520361, 0.30000000000000004, 0.80000000000000004, - 0.17453292519943295 }, - { 0.33917623046949996, 0.30000000000000004, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49307204894329176, 0.30000000000000004, 0.80000000000000004, - 0.52359877559829882 }, - { 0.63337802830291723, 0.30000000000000004, 0.80000000000000004, - 0.69813170079773179 }, - { 0.76104540997689407, 0.30000000000000004, 0.80000000000000004, - 0.87266462599716477 }, - { 0.87832009635450736, 0.30000000000000004, 0.80000000000000004, - 1.0471975511965976 }, - { 0.98787879723171790, 0.30000000000000004, 0.80000000000000004, - 1.2217304763960306 }, - { 1.0924036340069336, 0.30000000000000004, 0.80000000000000004, - 1.3962634015954636 }, - { 1.1944567571590046, 0.30000000000000004, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=0.30000000000000004, nu=0.80000000000000004. -template <typename Tp> -void test129() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data129) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data129[i].k), Tp(data129[i].nu), - Tp(data129[i].phi)); - const Tp f0 = data129[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 6.1197887707781618e-16 +// mean(f - f_Boost): 3.4416913763379854e-16 +// variance(f - f_Boost): 4.3461914185990199e-31 +// stddev(f - f_Boost): 6.5925650687718054e-16 +const testcase_ellint_3<double> +data129[10] = +{ + { 0.0000000000000000, 0.30000000000000004, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17604338956191670, 0.30000000000000004, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36146952517410791, 0.30000000000000004, 0.80000000000000004, + 0.34906585039886590 }, + { 0.56736453393774644, 0.30000000000000004, 0.80000000000000004, + 0.52359877559829882 }, + { 0.80873149979001091, 0.30000000000000004, 0.80000000000000004, + 0.69813170079773179 }, + { 1.1077903069860620, 0.30000000000000004, 0.80000000000000004, + 0.87266462599716477 }, + { 1.4985874311132998, 0.30000000000000004, 0.80000000000000004, + 1.0471975511965976 }, + { 2.0298167266724954, 0.30000000000000004, 0.80000000000000004, + 1.2217304763960306 }, + { 2.7483929054985432, 0.30000000000000004, 0.80000000000000004, + 1.3962634015954636 }, + { 3.6283050484567170, 0.30000000000000004, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler129 = 2.5000000000000020e-13; // Test data for k=0.30000000000000004, nu=0.90000000000000002. -testcase_ellint_3<double> data130[] = { - { -0.0000000000000000, 0.30000000000000004, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17305109924485948, 0.30000000000000004, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33793890239556984, 0.30000000000000004, 0.90000000000000002, - 0.34906585039886590 }, - { 0.48947218005089738, 0.30000000000000004, 0.90000000000000002, - 0.52359877559829882 }, - { 0.62623332340775151, 0.30000000000000004, 0.90000000000000002, - 0.69813170079773179 }, - { 0.74951596581511148, 0.30000000000000004, 0.90000000000000002, - 0.87266462599716477 }, - { 0.86189886597756005, 0.30000000000000004, 0.90000000000000002, - 1.0471975511965976 }, - { 0.96629451153092005, 0.30000000000000004, 0.90000000000000002, - 1.2217304763960306 }, - { 1.0655269133492680, 0.30000000000000004, 0.90000000000000002, - 1.3962634015954636 }, - { 1.1622376896064912, 0.30000000000000004, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.30000000000000004, nu=0.90000000000000002. -template <typename Tp> -void test130() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data130) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data130[i].k), Tp(data130[i].nu), - Tp(data130[i].phi)); - const Tp f0 = data130[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.39999999999999991, nu=0.0000000000000000. -testcase_ellint_3<double> data131[] = { - { -0.0000000000000000, 0.39999999999999991, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17467414669441531, 0.39999999999999991, 0.0000000000000000, - 0.17453292519943295 }, - { 0.35018222772483443, 0.39999999999999991, 0.0000000000000000, - 0.34906585039886590 }, - { 0.52729015917508748, 0.39999999999999991, 0.0000000000000000, - 0.52359877559829882 }, - { 0.70662374407341255, 0.39999999999999991, 0.0000000000000000, - 0.69813170079773179 }, - { 0.88859210497602170, 0.39999999999999991, 0.0000000000000000, - 0.87266462599716477 }, - { 1.0733136290471379, 0.39999999999999991, 0.0000000000000000, - 1.0471975511965976 }, - { 1.2605612170157061, 0.39999999999999991, 0.0000000000000000, - 1.2217304763960306 }, - { 1.4497513956433437, 0.39999999999999991, 0.0000000000000000, - 1.3962634015954636 }, - { 1.6399998658645112, 0.39999999999999991, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.39999999999999991, nu=0.0000000000000000. -template <typename Tp> -void test131() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data131) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data131[i].k), Tp(data131[i].nu), - Tp(data131[i].phi)); - const Tp f0 = data131[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.39999999999999991, nu=0.10000000000000001. -testcase_ellint_3<double> data132[] = { - { -0.0000000000000000, 0.39999999999999991, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17449806706684673, 0.39999999999999991, 0.10000000000000001, - 0.17453292519943295 }, - { 0.34880048623856075, 0.39999999999999991, 0.10000000000000001, - 0.34906585039886590 }, - { 0.52277322065757403, 0.39999999999999991, 0.10000000000000001, - 0.52359877559829882 }, - { 0.69638072056918376, 0.39999999999999991, 0.10000000000000001, - 0.69813170079773179 }, - { 0.86968426619831540, 0.39999999999999991, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0428044206578095, 0.39999999999999991, 0.10000000000000001, - 1.0471975511965976 }, - { 1.2158651158274378, 0.39999999999999991, 0.10000000000000001, - 1.2217304763960306 }, - { 1.3889447129893322, 0.39999999999999991, 0.10000000000000001, - 1.3962634015954636 }, - { 1.5620566886683604, 0.39999999999999991, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.39999999999999991, nu=0.10000000000000001. -template <typename Tp> -void test132() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data132) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data132[i].k), Tp(data132[i].nu), - Tp(data132[i].phi)); - const Tp f0 = data132[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.39999999999999991, nu=0.20000000000000001. -testcase_ellint_3<double> data133[] = { - { -0.0000000000000000, 0.39999999999999991, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17432262290723399, 0.39999999999999991, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34743795258968596, 0.39999999999999991, 0.20000000000000001, - 0.34906585039886590 }, - { 0.51838919472805123, 0.39999999999999991, 0.20000000000000001, - 0.52359877559829882 }, - { 0.68663134739057918, 0.39999999999999991, 0.20000000000000001, - 0.69813170079773179 }, - { 0.85206432981833979, 0.39999999999999991, 0.20000000000000001, - 0.87266462599716477 }, - { 1.0149595349004430, 0.39999999999999991, 0.20000000000000001, - 1.0471975511965976 }, - { 1.1758349405464676, 0.39999999999999991, 0.20000000000000001, - 1.2217304763960306 }, - { 1.3353337673882635, 0.39999999999999991, 0.20000000000000001, - 1.3962634015954636 }, - { 1.4941414344266770, 0.39999999999999991, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.39999999999999991, nu=0.20000000000000001. -template <typename Tp> -void test133() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data133) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data133[i].k), Tp(data133[i].nu), - Tp(data133[i].phi)); - const Tp f0 = data133[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.39999999999999991, nu=0.29999999999999999. -testcase_ellint_3<double> data134[] = { - { -0.0000000000000000, 0.39999999999999991, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17414781013591543, 0.39999999999999991, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34609415696777285, 0.39999999999999991, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51413131295862546, 0.39999999999999991, 0.29999999999999999, - 0.52359877559829882 }, - { 0.67733527622935630, 0.39999999999999991, 0.29999999999999999, - 0.69813170079773179 }, - { 0.83558675182733266, 0.39999999999999991, 0.29999999999999999, - 0.87266462599716477 }, - { 0.98940140808865906, 0.39999999999999991, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1396968797728058, 0.39999999999999991, 0.29999999999999999, - 1.2217304763960306 }, - { 1.2875920037865087, 0.39999999999999991, 0.29999999999999999, - 1.3962634015954636 }, - { 1.4342789859950078, 0.39999999999999991, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=0.39999999999999991, nu=0.29999999999999999. -template <typename Tp> -void test134() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data134) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data134[i].k), Tp(data134[i].nu), - Tp(data134[i].phi)); - const Tp f0 = data134[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.39999999999999991, nu=0.40000000000000002. -testcase_ellint_3<double> data135[] = { - { -0.0000000000000000, 0.39999999999999991, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17397362471112710, 0.39999999999999991, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34476864603333196, 0.39999999999999991, 0.40000000000000002, - 0.34906585039886590 }, - { 0.50999329415379357, 0.39999999999999991, 0.40000000000000002, - 0.52359877559829882 }, - { 0.66845674551396017, 0.39999999999999991, 0.40000000000000002, - 0.69813170079773179 }, - { 0.82012848346231748, 0.39999999999999991, 0.40000000000000002, - 0.87266462599716477 }, - { 0.96582449258349057, 0.39999999999999991, 0.40000000000000002, - 1.0471975511965976 }, - { 1.1068473749476286, 0.39999999999999991, 0.40000000000000002, - 1.2217304763960306 }, - { 1.2447132729159986, 0.39999999999999991, 0.40000000000000002, - 1.3962634015954636 }, - { 1.3809986210732901, 0.39999999999999991, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.39999999999999991, nu=0.40000000000000002. -template <typename Tp> -void test135() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data135) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data135[i].k), Tp(data135[i].nu), - Tp(data135[i].phi)); - const Tp f0 = data135[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.39999999999999991, nu=0.50000000000000000. -testcase_ellint_3<double> data136[] = { - { -0.0000000000000000, 0.39999999999999991, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17380006262854139, 0.39999999999999991, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34346098216756610, 0.39999999999999991, 0.50000000000000000, - 0.34906585039886590 }, - { 0.50596929935059420, 0.39999999999999991, 0.50000000000000000, - 0.52359877559829882 }, - { 0.65996392089131262, 0.39999999999999991, 0.50000000000000000, - 0.69813170079773179 }, - { 0.80558463511364786, 0.39999999999999991, 0.50000000000000000, - 0.87266462599716477 }, - { 0.94397834522857704, 0.39999999999999991, 0.50000000000000000, - 1.0471975511965976 }, - { 1.0768075114108115, 0.39999999999999991, 0.50000000000000000, - 1.2217304763960306 }, - { 1.2059184624251329, 0.39999999999999991, 0.50000000000000000, - 1.3962634015954636 }, - { 1.3331797176377398, 0.39999999999999991, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.39999999999999991, nu=0.50000000000000000. -template <typename Tp> -void test136() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data136) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data136[i].k), Tp(data136[i].nu), - Tp(data136[i].phi)); - const Tp f0 = data136[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.39999999999999991, nu=0.59999999999999998. -testcase_ellint_3<double> data137[] = { - { -0.0000000000000000, 0.39999999999999991, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17362711992081248, 0.39999999999999991, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34217074276403953, 0.39999999999999991, 0.59999999999999998, - 0.34906585039886590 }, - { 0.50205389185761617, 0.39999999999999991, 0.59999999999999998, - 0.52359877559829882 }, - { 0.65182834920372745, 0.39999999999999991, 0.59999999999999998, - 0.69813170079773179 }, - { 0.79186512820565136, 0.39999999999999991, 0.59999999999999998, - 0.87266462599716477 }, - { 0.92365535916287134, 0.39999999999999991, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0491915663957907, 0.39999999999999991, 0.59999999999999998, - 1.2217304763960306 }, - { 1.1705934291745104, 0.39999999999999991, 0.59999999999999998, - 1.3962634015954636 }, - { 1.2899514672527024, 0.39999999999999991, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=0.39999999999999991, nu=0.59999999999999998. -template <typename Tp> -void test137() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data137) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data137[i].k), Tp(data137[i].nu), - Tp(data137[i].phi)); - const Tp f0 = data137[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.39999999999999991, nu=0.69999999999999996. -testcase_ellint_3<double> data138[] = { - { -0.0000000000000000, 0.39999999999999991, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17345479265712871, 0.39999999999999991, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34089751955950354, 0.39999999999999991, 0.69999999999999996, - 0.34906585039886590 }, - { 0.49824200167361343, 0.39999999999999991, 0.69999999999999996, - 0.52359877559829882 }, - { 0.64402450341199413, 0.39999999999999991, 0.69999999999999996, - 0.69813170079773179 }, - { 0.77889207804122873, 0.39999999999999991, 0.69999999999999996, - 0.87266462599716477 }, - { 0.90468169720957992, 0.39999999999999991, 0.69999999999999996, - 1.0471975511965976 }, - { 1.0236847823692916, 0.39999999999999991, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1382465247425164, 0.39999999999999991, 0.69999999999999996, - 1.3962634015954636 }, - { 1.2506255923253344, 0.39999999999999991, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=0.39999999999999991, nu=0.69999999999999996. -template <typename Tp> -void test138() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data138) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data138[i].k), Tp(data138[i].nu), - Tp(data138[i].phi)); - const Tp f0 = data138[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.39999999999999991, nu=0.80000000000000004. -testcase_ellint_3<double> data139[] = { - { -0.0000000000000000, 0.39999999999999991, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17328307694277156, 0.39999999999999991, 0.80000000000000004, - 0.17453292519943295 }, - { 0.33964091800132007, 0.39999999999999991, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49452889372467451, 0.39999999999999991, 0.80000000000000004, - 0.52359877559829882 }, - { 0.63652940095937327, 0.39999999999999991, 0.80000000000000004, - 0.69813170079773179 }, - { 0.76659772511159097, 0.39999999999999991, 0.80000000000000004, - 0.87266462599716477 }, - { 0.88691047977338111, 0.39999999999999991, 0.80000000000000004, - 1.0471975511965976 }, - { 1.0000273200611640, 0.39999999999999991, 0.80000000000000004, - 1.2217304763960306 }, - { 1.1084787902188007, 0.39999999999999991, 0.80000000000000004, - 1.3962634015954636 }, - { 1.2146499565727209, 0.39999999999999991, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=0.39999999999999991, nu=0.80000000000000004. -template <typename Tp> -void test139() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data139) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data139[i].k), Tp(data139[i].nu), - Tp(data139[i].phi)); - const Tp f0 = data139[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.39999999999999991, nu=0.90000000000000002. -testcase_ellint_3<double> data140[] = { - { -0.0000000000000000, 0.39999999999999991, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17311196891868130, 0.39999999999999991, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33840055664911906, 0.39999999999999991, 0.90000000000000002, - 0.34906585039886590 }, - { 0.49091013944075340, 0.39999999999999991, 0.90000000000000002, - 0.52359877559829882 }, - { 0.62932228186809591, 0.39999999999999991, 0.90000000000000002, - 0.69813170079773179 }, - { 0.75492278323019801, 0.39999999999999991, 0.90000000000000002, - 0.87266462599716477 }, - { 0.87021659043854294, 0.39999999999999991, 0.90000000000000002, - 1.0471975511965976 }, - { 0.97800245228239246, 0.39999999999999991, 0.90000000000000002, - 1.2217304763960306 }, - { 1.0809625773173694, 0.39999999999999991, 0.90000000000000002, - 1.3962634015954636 }, - { 1.1815758115929846, 0.39999999999999991, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.39999999999999991, nu=0.90000000000000002. -template <typename Tp> -void test140() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data140) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data140[i].k), Tp(data140[i].nu), - Tp(data140[i].phi)); - const Tp f0 = data140[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 5.1301806687926828e-16 +// mean(f - f_Boost): 4.1633363423443370e-16 +// variance(f - f_Boost): 2.2835347143080263e-31 +// stddev(f - f_Boost): 4.7786344433405093e-16 +const testcase_ellint_3<double> +data130[10] = +{ + { 0.0000000000000000, 0.30000000000000004, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17622526204962433, 0.30000000000000004, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36304439230777141, 0.30000000000000004, 0.90000000000000002, + 0.34906585039886590 }, + { 0.57345914744719195, 0.30000000000000004, 0.90000000000000002, + 0.52359877559829882 }, + { 0.82641512928845162, 0.30000000000000004, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1534256210757743, 0.30000000000000004, 0.90000000000000002, + 0.87266462599716477 }, + { 1.6124900353411677, 0.30000000000000004, 0.90000000000000002, + 1.0471975511965976 }, + { 2.3165905514845089, 0.30000000000000004, 0.90000000000000002, + 1.2217304763960306 }, + { 3.4625619526539824, 0.30000000000000004, 0.90000000000000002, + 1.3962634015954636 }, + { 5.1479514944016787, 0.30000000000000004, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler130 = 2.5000000000000020e-13; + +// Test data for k=0.40000000000000013, nu=0.0000000000000000. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.0831445028587608e-15 +// mean(f - f_Boost): 1.7486012637846215e-16 +// variance(f - f_Boost): 3.1664095331106078e-31 +// stddev(f - f_Boost): 5.6270858649132121e-16 +const testcase_ellint_3<double> +data131[10] = +{ + { 0.0000000000000000, 0.40000000000000013, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17467414669441528, 0.40000000000000013, 0.0000000000000000, + 0.17453292519943295 }, + { 0.35018222772483443, 0.40000000000000013, 0.0000000000000000, + 0.34906585039886590 }, + { 0.52729015917508748, 0.40000000000000013, 0.0000000000000000, + 0.52359877559829882 }, + { 0.70662374407341244, 0.40000000000000013, 0.0000000000000000, + 0.69813170079773179 }, + { 0.88859210497602159, 0.40000000000000013, 0.0000000000000000, + 0.87266462599716477 }, + { 1.0733136290471381, 0.40000000000000013, 0.0000000000000000, + 1.0471975511965976 }, + { 1.2605612170157066, 0.40000000000000013, 0.0000000000000000, + 1.2217304763960306 }, + { 1.4497513956433439, 0.40000000000000013, 0.0000000000000000, + 1.3962634015954636 }, + { 1.6399998658645112, 0.40000000000000013, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler131 = 2.5000000000000020e-13; + +// Test data for k=0.40000000000000013, nu=0.10000000000000001. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.0263824105456986e-15 +// mean(f - f_Boost): 1.7486012637846215e-16 +// variance(f - f_Boost): 3.1664095331106078e-31 +// stddev(f - f_Boost): 5.6270858649132121e-16 +const testcase_ellint_3<double> +data132[10] = +{ + { 0.0000000000000000, 0.40000000000000013, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17485086590796767, 0.40000000000000013, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35158366412506992, 0.40000000000000013, 0.10000000000000001, + 0.34906585039886590 }, + { 0.53194731675711726, 0.40000000000000013, 0.10000000000000001, + 0.52359877559829882 }, + { 0.71740615528010931, 0.40000000000000013, 0.10000000000000001, + 0.69813170079773179 }, + { 0.90896157773487030, 0.40000000000000013, 0.10000000000000001, + 0.87266462599716477 }, + { 1.1069605483834348, 0.40000000000000013, 0.10000000000000001, + 1.0471975511965976 }, + { 1.3109353428823001, 0.40000000000000013, 0.10000000000000001, + 1.2217304763960306 }, + { 1.5195460789903450, 0.40000000000000013, 0.10000000000000001, + 1.3962634015954636 }, + { 1.7306968836847190, 0.40000000000000013, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler132 = 2.5000000000000020e-13; + +// Test data for k=0.40000000000000013, nu=0.20000000000000001. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.6644296021947179e-16 +// mean(f - f_Boost): 2.0816681711721685e-16 +// variance(f - f_Boost): 3.0360740073926687e-31 +// stddev(f - f_Boost): 5.5100580826273227e-16 +const testcase_ellint_3<double> +data133[10] = +{ + { 0.0000000000000000, 0.40000000000000013, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17502822886437389, 0.40000000000000013, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35300530062530805, 0.40000000000000013, 0.20000000000000001, + 0.34906585039886590 }, + { 0.53675259548210896, 0.40000000000000013, 0.20000000000000001, + 0.52359877559829882 }, + { 0.72878006428676934, 0.40000000000000013, 0.20000000000000001, + 0.69813170079773179 }, + { 0.93100219010583574, 0.40000000000000013, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1443487271187611, 0.40000000000000013, 0.20000000000000001, + 1.0471975511965976 }, + { 1.3683427764108813, 0.40000000000000013, 0.20000000000000001, + 1.2217304763960306 }, + { 1.6008221459300933, 0.40000000000000013, 0.20000000000000001, + 1.3962634015954636 }, + { 1.8380358826317627, 0.40000000000000013, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler133 = 2.5000000000000020e-13; + +// Test data for k=0.40000000000000013, nu=0.30000000000000004. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.0271556462838835e-16 +// mean(f - f_Boost): 2.0816681711721685e-16 +// variance(f - f_Boost): 3.0360740073926687e-31 +// stddev(f - f_Boost): 5.5100580826273227e-16 +const testcase_ellint_3<double> +data134[10] = +{ + { 0.0000000000000000, 0.40000000000000013, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17520623975982899, 0.40000000000000013, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35444766141612105, 0.40000000000000013, 0.30000000000000004, + 0.34906585039886590 }, + { 0.54171455841536009, 0.40000000000000013, 0.30000000000000004, + 0.52359877559829882 }, + { 0.74080517001084012, 0.40000000000000013, 0.30000000000000004, + 0.69813170079773179 }, + { 0.95496950509296574, 0.40000000000000013, 0.30000000000000004, + 0.87266462599716477 }, + { 1.1862627879844718, 0.40000000000000013, 0.30000000000000004, + 1.0471975511965976 }, + { 1.4346501803799458, 0.40000000000000013, 0.30000000000000004, + 1.2217304763960306 }, + { 1.6971744798077699, 0.40000000000000013, 0.30000000000000004, + 1.3962634015954636 }, + { 1.9677924132520139, 0.40000000000000013, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler134 = 2.5000000000000020e-13; + +// Test data for k=0.40000000000000013, nu=0.40000000000000002. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 8.3436329231972794e-16 +// mean(f - f_Boost): 2.3037127760972000e-16 +// variance(f - f_Boost): 2.9507053793392374e-31 +// stddev(f - f_Boost): 5.4320395611033958e-16 +const testcase_ellint_3<double> +data135[10] = +{ + { 0.0000000000000000, 0.40000000000000013, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17538490283034375, 0.40000000000000013, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35591129064319948, 0.40000000000000013, 0.40000000000000002, + 0.34906585039886590 }, + { 0.54684250413264535, 0.40000000000000013, 0.40000000000000002, + 0.52359877559829882 }, + { 0.75355027742668290, 0.40000000000000013, 0.40000000000000002, + 0.69813170079773179 }, + { 0.98117935026780634, 0.40000000000000013, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2337464222030736, 0.40000000000000013, 0.40000000000000002, + 1.0471975511965976 }, + { 1.5125183419289221, 0.40000000000000013, 0.40000000000000002, + 1.2217304763960306 }, + { 1.8140224451130313, 0.40000000000000013, 0.40000000000000002, + 1.3962634015954636 }, + { 2.1289968719280026, 0.40000000000000013, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler135 = 2.5000000000000020e-13; + +// Test data for k=0.40000000000000013, nu=0.50000000000000000. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.7013794022122431e-16 +// mean(f - f_Boost): 2.3037127760972000e-16 +// variance(f - f_Boost): 1.4989821857033475e-31 +// stddev(f - f_Boost): 3.8716691306248618e-16 +const testcase_ellint_3<double> +data136[10] = +{ + { 0.0000000000000000, 0.40000000000000013, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17556422235224273, 0.40000000000000013, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35739675341763921, 0.40000000000000013, 0.50000000000000000, + 0.34906585039886590 }, + { 0.55214655195037188, 0.40000000000000013, 0.50000000000000000, + 0.52359877559829882 }, + { 0.76709520942047438, 0.40000000000000013, 0.50000000000000000, + 0.69813170079773179 }, + { 1.0100278761577499, 0.40000000000000013, 0.50000000000000000, + 0.87266462599716477 }, + { 1.2882265661384342, 0.40000000000000013, 0.50000000000000000, + 1.0471975511965976 }, + { 1.6059059780051876, 0.40000000000000013, 0.50000000000000000, + 1.2217304763960306 }, + { 1.9600182740224081, 0.40000000000000013, 0.50000000000000000, + 1.3962634015954636 }, + { 2.3367461373176512, 0.40000000000000013, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler136 = 2.5000000000000020e-13; + +// Test data for k=0.40000000000000013, nu=0.60000000000000009. +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 8.4792115132836117e-16 +// mean(f - f_Boost): 2.3037127760972000e-16 +// variance(f - f_Boost): 4.8893797490374802e-31 +// stddev(f - f_Boost): 6.9924099915819294e-16 +const testcase_ellint_3<double> +data137[10] = +{ + { 0.0000000000000000, 0.40000000000000013, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17574420264267029, 0.40000000000000013, 0.60000000000000009, + 0.17453292519943295 }, + { 0.35890463689046265, 0.40000000000000013, 0.60000000000000009, + 0.34906585039886590 }, + { 0.55763773975194486, 0.40000000000000013, 0.60000000000000009, + 0.52359877559829882 }, + { 0.78153324227761267, 0.40000000000000013, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0420205885765887, 0.40000000000000013, 0.60000000000000009, + 0.87266462599716477 }, + { 1.3517205230381770, 0.40000000000000013, 0.60000000000000009, + 1.0471975511965976 }, + { 1.7210360970313896, 0.40000000000000013, 0.60000000000000009, + 1.2217304763960306 }, + { 2.1500780510169246, 0.40000000000000013, 0.60000000000000009, + 1.3962634015954636 }, + { 2.6186940209850191, 0.40000000000000013, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler137 = 2.5000000000000020e-13; + +// Test data for k=0.40000000000000013, nu=0.70000000000000007. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.8573292020719759e-16 +// mean(f - f_Boost): 2.2759572004815707e-16 +// variance(f - f_Boost): 2.9613098824898137e-31 +// stddev(f - f_Boost): 5.4417918762938862e-16 +const testcase_ellint_3<double> +data138[10] = +{ + { 0.0000000000000000, 0.40000000000000013, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17592484806010436, 0.40000000000000013, 0.70000000000000007, + 0.17453292519943295 }, + { 0.36043555139631439, 0.40000000000000013, 0.70000000000000007, + 0.34906585039886590 }, + { 0.56332813669944881, 0.40000000000000013, 0.70000000000000007, + 0.52359877559829882 }, + { 0.79697424562157548, 0.40000000000000013, 0.70000000000000007, + 0.69813170079773179 }, + { 1.0778155987523672, 0.40000000000000013, 0.70000000000000007, + 0.87266462599716477 }, + { 1.4272018169896268, 0.40000000000000013, 0.70000000000000007, + 1.0471975511965976 }, + { 1.8684377907453382, 0.40000000000000013, 0.70000000000000007, + 1.2217304763960306 }, + { 2.4128677409207473, 0.40000000000000013, 0.70000000000000007, + 1.3962634015954636 }, + { 3.0327078743873246, 0.40000000000000013, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler138 = 2.5000000000000020e-13; + +// Test data for k=0.40000000000000013, nu=0.80000000000000004. +// max(|f - f_Boost|): 3.5527136788005009e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.5273712585384737e-16 +// mean(f - f_Boost): 4.5241588253475131e-16 +// variance(f - f_Boost): 1.1866477068555882e-30 +// stddev(f - f_Boost): 1.0893336067778265e-15 +const testcase_ellint_3<double> +data139[10] = +{ + { 0.0000000000000000, 0.40000000000000013, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17610616300487833, 0.40000000000000013, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36199013167171978, 0.40000000000000013, 0.80000000000000004, + 0.34906585039886590 }, + { 0.56923097361842434, 0.40000000000000013, 0.80000000000000004, + 0.52359877559829882 }, + { 0.81354878456624347, 0.40000000000000013, 0.80000000000000004, + 0.69813170079773179 }, + { 1.1182902719261825, 0.40000000000000013, 0.80000000000000004, + 0.87266462599716477 }, + { 1.5192950589409022, 0.40000000000000013, 0.80000000000000004, + 1.0471975511965976 }, + { 2.0678761710223981, 0.40000000000000013, 0.80000000000000004, + 1.2217304763960306 }, + { 2.8135222249879788, 0.40000000000000013, 0.80000000000000004, + 1.3962634015954636 }, + { 3.7289548002199902, 0.40000000000000013, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler139 = 2.5000000000000020e-13; + +// Test data for k=0.40000000000000013, nu=0.90000000000000002. +// max(|f - f_Boost|): 6.2172489379008766e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.1718379478872251e-15 +// mean(f - f_Boost): 8.4099394115355610e-16 +// variance(f - f_Boost): 3.5684096037099424e-30 +// stddev(f - f_Boost): 1.8890234523980751e-15 +const testcase_ellint_3<double> +data140[10] = +{ + { 0.0000000000000000, 0.40000000000000013, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17628815191971123, 0.40000000000000013, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36356903815378772, 0.40000000000000013, 0.90000000000000002, + 0.34906585039886590 }, + { 0.57536079447000310, 0.40000000000000013, 0.90000000000000002, + 0.52359877559829882 }, + { 0.83141355850172571, 0.40000000000000013, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1646481598721361, 0.40000000000000013, 0.90000000000000002, + 0.87266462599716477 }, + { 1.6357275034001995, 0.40000000000000013, 0.90000000000000002, + 1.0471975511965976 }, + { 2.3628787566572402, 0.40000000000000013, 0.90000000000000002, + 1.2217304763960306 }, + { 3.5521010369134962, 0.40000000000000013, 0.90000000000000002, + 1.3962634015954636 }, + { 5.3055535102872513, 0.40000000000000013, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler140 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.0000000000000000. -testcase_ellint_3<double> data141[] = { - { -0.0000000000000000, 0.50000000000000000, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17475385514035785, 0.50000000000000000, 0.0000000000000000, - 0.17453292519943295 }, - { 0.35081868470101585, 0.50000000000000000, 0.0000000000000000, - 0.34906585039886590 }, - { 0.52942862705190585, 0.50000000000000000, 0.0000000000000000, - 0.52359877559829882 }, - { 0.71164727562630326, 0.50000000000000000, 0.0000000000000000, - 0.69813170079773179 }, - { 0.89824523594227768, 0.50000000000000000, 0.0000000000000000, - 0.87266462599716477 }, - { 1.0895506700518851, 0.50000000000000000, 0.0000000000000000, - 1.0471975511965976 }, - { 1.2853005857432933, 0.50000000000000000, 0.0000000000000000, - 1.2217304763960306 }, - { 1.4845545520549484, 0.50000000000000000, 0.0000000000000000, - 1.3962634015954636 }, - { 1.6857503548125963, 0.50000000000000000, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.50000000000000000, nu=0.0000000000000000. -template <typename Tp> -void test141() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data141) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data141[i].k), Tp(data141[i].nu), - Tp(data141[i].phi)); - const Tp f0 = data141[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.4551389361831220e-16 +// mean(f - f_Boost): -1.3877787807814457e-17 +// variance(f - f_Boost): 2.5893058141206173e-32 +// stddev(f - f_Boost): 1.6091320064309879e-16 +const testcase_ellint_3<double> +data141[10] = +{ + { 0.0000000000000000, 0.50000000000000000, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17475385514035785, 0.50000000000000000, 0.0000000000000000, + 0.17453292519943295 }, + { 0.35081868470101579, 0.50000000000000000, 0.0000000000000000, + 0.34906585039886590 }, + { 0.52942862705190574, 0.50000000000000000, 0.0000000000000000, + 0.52359877559829882 }, + { 0.71164727562630326, 0.50000000000000000, 0.0000000000000000, + 0.69813170079773179 }, + { 0.89824523594227768, 0.50000000000000000, 0.0000000000000000, + 0.87266462599716477 }, + { 1.0895506700518853, 0.50000000000000000, 0.0000000000000000, + 1.0471975511965976 }, + { 1.2853005857432933, 0.50000000000000000, 0.0000000000000000, + 1.2217304763960306 }, + { 1.4845545520549488, 0.50000000000000000, 0.0000000000000000, + 1.3962634015954636 }, + { 1.6857503548125961, 0.50000000000000000, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler141 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.10000000000000001. -testcase_ellint_3<double> data142[] = { - { -0.0000000000000000, 0.50000000000000000, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17457763120814676, 0.50000000000000000, 0.10000000000000001, - 0.17453292519943295 }, - { 0.34943246340849154, 0.50000000000000000, 0.10000000000000001, - 0.34906585039886590 }, - { 0.52487937869610801, 0.50000000000000000, 0.10000000000000001, - 0.52359877559829882 }, - { 0.70127785096388395, 0.50000000000000000, 0.10000000000000001, - 0.69813170079773179 }, - { 0.87898815988624479, 0.50000000000000000, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0582764576094172, 0.50000000000000000, 0.10000000000000001, - 1.0471975511965976 }, - { 1.2391936844060207, 0.50000000000000000, 0.10000000000000001, - 1.2217304763960306 }, - { 1.4214793542995841, 0.50000000000000000, 0.10000000000000001, - 1.3962634015954636 }, - { 1.6045524936084892, 0.50000000000000000, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.50000000000000000, nu=0.10000000000000001. -template <typename Tp> -void test142() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data142) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data142[i].k), Tp(data142[i].nu), - Tp(data142[i].phi)); - const Tp f0 = data142[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.7416868347177582e-16 +// mean(f - f_Boost): 2.7755575615628915e-18 +// variance(f - f_Boost): 5.4326441655972001e-32 +// stddev(f - f_Boost): 2.3308033305273100e-16 +const testcase_ellint_3<double> +data142[10] = +{ + { 0.0000000000000000, 0.50000000000000000, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17493071928248824, 0.50000000000000000, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35222467688034798, 0.50000000000000000, 0.10000000000000001, + 0.34906585039886590 }, + { 0.53411928652008112, 0.50000000000000000, 0.10000000000000001, + 0.52359877559829882 }, + { 0.72256398117177589, 0.50000000000000000, 0.10000000000000001, + 0.69813170079773179 }, + { 0.91899583232771009, 0.50000000000000000, 0.10000000000000001, + 0.87266462599716477 }, + { 1.1240549163055360, 0.50000000000000000, 0.10000000000000001, + 1.0471975511965976 }, + { 1.3372938086286021, 0.50000000000000000, 0.10000000000000001, + 1.2217304763960306 }, + { 1.5570024469132429, 0.50000000000000000, 0.10000000000000001, + 1.3962634015954636 }, + { 1.7803034946545480, 0.50000000000000000, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler142 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.20000000000000001. -testcase_ellint_3<double> data143[] = { - { -0.0000000000000000, 0.50000000000000000, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17440204336345433, 0.50000000000000000, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34806552388338824, 0.50000000000000000, 0.20000000000000001, - 0.34906585039886590 }, - { 0.52046416757129821, 0.50000000000000000, 0.20000000000000001, - 0.52359877559829882 }, - { 0.69140924550993876, 0.50000000000000000, 0.20000000000000001, - 0.69813170079773179 }, - { 0.86104678636125520, 0.50000000000000000, 0.20000000000000001, - 0.87266462599716477 }, - { 1.0297439459053981, 0.50000000000000000, 0.20000000000000001, - 1.0471975511965976 }, - { 1.1979214112912036, 0.50000000000000000, 0.20000000000000001, - 1.2217304763960306 }, - { 1.3659033858648930, 0.50000000000000000, 0.20000000000000001, - 1.3962634015954636 }, - { 1.5338490483665983, 0.50000000000000000, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.50000000000000000, nu=0.20000000000000001. -template <typename Tp> -void test143() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data143) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data143[i].k), Tp(data143[i].nu), - Tp(data143[i].phi)); - const Tp f0 = data143[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.50000000000000000, nu=0.29999999999999999. -testcase_ellint_3<double> data144[] = { - { -0.0000000000000000, 0.50000000000000000, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17422708752228896, 0.50000000000000000, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34671739434855858, 0.50000000000000000, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51617616305641889, 0.50000000000000000, 0.29999999999999999, - 0.52359877559829882 }, - { 0.68200047612545178, 0.50000000000000000, 0.29999999999999999, - 0.69813170079773179 }, - { 0.84427217869498372, 0.50000000000000000, 0.29999999999999999, - 0.87266462599716477 }, - { 1.0035637821389782, 0.50000000000000000, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1606800483933113, 0.50000000000000000, 0.29999999999999999, - 1.2217304763960306 }, - { 1.3164407134643459, 0.50000000000000000, 0.29999999999999999, - 1.3962634015954636 }, - { 1.4715681939859637, 0.50000000000000000, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=0.50000000000000000, nu=0.29999999999999999. -template <typename Tp> -void test144() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data144) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data144[i].k), Tp(data144[i].nu), - Tp(data144[i].phi)); - const Tp f0 = data144[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.1198767993730867e-16 +// mean(f - f_Boost): 2.7755575615628914e-17 +// variance(f - f_Boost): 5.0311947683004831e-32 +// stddev(f - f_Boost): 2.2430324938128922e-16 +const testcase_ellint_3<double> +data143[10] = +{ + { 0.0000000000000000, 0.50000000000000000, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17510822779582402, 0.50000000000000000, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35365094725531487, 0.50000000000000000, 0.20000000000000001, + 0.34906585039886590 }, + { 0.53895933237328697, 0.50000000000000000, 0.20000000000000001, + 0.52359877559829882 }, + { 0.73408090840070794, 0.50000000000000000, 0.20000000000000001, + 0.69813170079773179 }, + { 0.94145442818535396, 0.50000000000000000, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1624120186296487, 0.50000000000000000, 0.20000000000000001, + 1.0471975511965976 }, + { 1.3965823372867114, 0.50000000000000000, 0.20000000000000001, + 1.2217304763960306 }, + { 1.6414308440430099, 0.50000000000000000, 0.20000000000000001, + 1.3962634015954636 }, + { 1.8922947612264018, 0.50000000000000000, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler143 = 2.5000000000000020e-13; + +// Test data for k=0.50000000000000000, nu=0.30000000000000004. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.3800262770228813e-16 +// mean(f - f_Boost): 5.8286708792820721e-17 +// variance(f - f_Boost): 8.5027191584278157e-32 +// stddev(f - f_Boost): 2.9159422419567599e-16 +const testcase_ellint_3<double> +data144[10] = +{ + { 0.0000000000000000, 0.50000000000000000, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17528638488102041, 0.50000000000000000, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35509802222332720, 0.50000000000000000, 0.30000000000000004, + 0.34906585039886590 }, + { 0.54395740731866193, 0.50000000000000000, 0.30000000000000004, + 0.52359877559829882 }, + { 0.74625871438752667, 0.50000000000000000, 0.30000000000000004, + 0.69813170079773179 }, + { 0.96588271186092023, 0.50000000000000000, 0.30000000000000004, + 0.87266462599716477 }, + { 1.2054319584357329, 0.50000000000000000, 0.30000000000000004, + 1.0471975511965976 }, + { 1.4651077994832871, 0.50000000000000000, 0.30000000000000004, + 1.2217304763960306 }, + { 1.7416018368052644, 0.50000000000000000, 0.30000000000000004, + 1.3962634015954636 }, + { 2.0277924458111314, 0.50000000000000000, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler144 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.40000000000000002. -testcase_ellint_3<double> data145[] = { - { -0.0000000000000000, 0.50000000000000000, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17405275963859917, 0.50000000000000000, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34538761957029329, 0.50000000000000000, 0.40000000000000002, - 0.34906585039886590 }, - { 0.51200902646603919, 0.50000000000000000, 0.40000000000000002, - 0.52359877559829882 }, - { 0.67301522212868792, 0.50000000000000000, 0.40000000000000002, - 0.69813170079773179 }, - { 0.82853844466313320, 0.50000000000000000, 0.40000000000000002, - 0.87266462599716477 }, - { 0.97942097862681488, 0.50000000000000000, 0.40000000000000002, - 1.0471975511965976 }, - { 1.1268429801220616, 0.50000000000000000, 0.40000000000000002, - 1.2217304763960306 }, - { 1.2720406704533922, 0.50000000000000000, 0.40000000000000002, - 1.3962634015954636 }, - { 1.4161679518465340, 0.50000000000000000, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.50000000000000000, nu=0.40000000000000002. -template <typename Tp> -void test145() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data145) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data145[i].k), Tp(data145[i].nu), - Tp(data145[i].phi)); - const Tp f0 = data145[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.0439932918341581e-16 +// mean(f - f_Boost): 3.0531133177191807e-17 +// variance(f - f_Boost): 9.0809736800018602e-32 +// stddev(f - f_Boost): 3.0134653938616686e-16 +const testcase_ellint_3<double> +data145[10] = +{ + { 0.0000000000000000, 0.50000000000000000, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17546519477859268, 0.50000000000000000, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35656644822531680, 0.50000000000000000, 0.40000000000000002, + 0.34906585039886590 }, + { 0.54912289677411319, 0.50000000000000000, 0.40000000000000002, + 0.52359877559829882 }, + { 0.75916731611690047, 0.50000000000000000, 0.40000000000000002, + 0.69813170079773179 }, + { 0.99260415631328214, 0.50000000000000000, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2541925856918670, 0.50000000000000000, 0.40000000000000002, + 1.0471975511965976 }, + { 1.5456393705347609, 0.50000000000000000, 0.40000000000000002, + 1.2217304763960306 }, + { 1.8631904972952076, 0.50000000000000000, 0.40000000000000002, + 1.3962634015954636 }, + { 2.1962905366178065, 0.50000000000000000, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler145 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.50000000000000000. -testcase_ellint_3<double> data146[] = { - { -0.0000000000000000, 0.50000000000000000, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17387905570381157, 0.50000000000000000, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34407576010465207, 0.50000000000000000, 0.50000000000000000, - 0.34906585039886590 }, - { 0.50795686560160835, 0.50000000000000000, 0.50000000000000000, - 0.52359877559829882 }, - { 0.66442115453330175, 0.50000000000000000, 0.50000000000000000, - 0.69813170079773179 }, - { 0.81373829119355345, 0.50000000000000000, 0.50000000000000000, - 0.87266462599716477 }, - { 0.95705743313235825, 0.50000000000000000, 0.50000000000000000, - 1.0471975511965976 }, - { 1.0959131991362556, 0.50000000000000000, 0.50000000000000000, - 1.2217304763960306 }, - { 1.2318900529754597, 0.50000000000000000, 0.50000000000000000, - 1.3962634015954636 }, - { 1.3664739530045971, 0.50000000000000000, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.50000000000000000, nu=0.50000000000000000. -template <typename Tp> -void test146() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data146) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data146[i].k), Tp(data146[i].nu), - Tp(data146[i].phi)); - const Tp f0 = data146[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.50000000000000000, nu=0.59999999999999998. -testcase_ellint_3<double> data147[] = { - { -0.0000000000000000, 0.50000000000000000, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17370597174637581, 0.50000000000000000, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34278139158591414, 0.50000000000000000, 0.59999999999999998, - 0.34906585039886590 }, - { 0.50401419439302719, 0.50000000000000000, 0.59999999999999998, - 0.52359877559829882 }, - { 0.65618938076167221, 0.50000000000000000, 0.59999999999999998, - 0.69813170079773179 }, - { 0.79977959248855424, 0.50000000000000000, 0.59999999999999998, - 0.87266462599716477 }, - { 0.93625925190753545, 0.50000000000000000, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0674905658379710, 0.50000000000000000, 0.59999999999999998, - 1.2217304763960306 }, - { 1.1953481298023048, 0.50000000000000000, 0.59999999999999998, - 1.3962634015954636 }, - { 1.3215740290190876, 0.50000000000000000, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=0.50000000000000000, nu=0.59999999999999998. -template <typename Tp> -void test147() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data147) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data147[i].k), Tp(data147[i].nu), - Tp(data147[i].phi)); - const Tp f0 = data147[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.50000000000000000, nu=0.69999999999999996. -testcase_ellint_3<double> data148[] = { - { -0.0000000000000000, 0.50000000000000000, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17353350383131641, 0.50000000000000000, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34150410405436771, 0.50000000000000000, 0.69999999999999996, - 0.34906585039886590 }, - { 0.50017589696443487, 0.50000000000000000, 0.69999999999999996, - 0.52359877559829882 }, - { 0.64829398188419962, 0.50000000000000000, 0.69999999999999996, - 0.69813170079773179 }, - { 0.78658270782402073, 0.50000000000000000, 0.69999999999999996, - 0.87266462599716477 }, - { 0.91684738336675053, 0.50000000000000000, 0.69999999999999996, - 1.0471975511965976 }, - { 1.0412486789555937, 0.50000000000000000, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1619021847612001, 0.50000000000000000, 0.69999999999999996, - 1.3962634015954636 }, - { 1.2807475181182502, 0.50000000000000000, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=0.50000000000000000, nu=0.69999999999999996. -template <typename Tp> -void test148() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data148) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data148[i].k), Tp(data148[i].nu), - Tp(data148[i].phi)); - const Tp f0 = data148[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.6797816859260978e-16 +// mean(f - f_Boost): 9.4368957093138303e-17 +// variance(f - f_Boost): 7.7794254682023874e-32 +// stddev(f - f_Boost): 2.7891621444803792e-16 +const testcase_ellint_3<double> +data146[10] = +{ + { 0.0000000000000000, 0.50000000000000000, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17564466176941509, 0.50000000000000000, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35805679276065394, 0.50000000000000000, 0.50000000000000000, + 0.34906585039886590 }, + { 0.55446601496200032, 0.50000000000000000, 0.50000000000000000, + 0.52359877559829882 }, + { 0.77288783578259013, 0.50000000000000000, 0.50000000000000000, + 0.69813170079773179 }, + { 1.0220246013918972, 0.50000000000000000, 0.50000000000000000, + 0.87266462599716477 }, + { 1.3101681612463965, 0.50000000000000000, 0.50000000000000000, + 1.0471975511965976 }, + { 1.6422994881851025, 0.50000000000000000, 0.50000000000000000, + 1.2217304763960306 }, + { 2.0152636030998816, 0.50000000000000000, 0.50000000000000000, + 1.3962634015954636 }, + { 2.4136715042011945, 0.50000000000000000, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler146 = 2.5000000000000020e-13; + +// Test data for k=0.50000000000000000, nu=0.60000000000000009. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.9178421578645735e-16 +// mean(f - f_Boost): 1.3322676295501878e-16 +// variance(f - f_Boost): 1.7749370367472766e-31 +// stddev(f - f_Boost): 4.2130001622920411e-16 +const testcase_ellint_3<double> +data147[10] = +{ + { 0.0000000000000000, 0.50000000000000000, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17582479017522740, 0.50000000000000000, 0.60000000000000009, + 0.17453292519943295 }, + { 0.35956964546660036, 0.50000000000000000, 0.60000000000000009, + 0.34906585039886590 }, + { 0.55999790372984193, 0.50000000000000000, 0.60000000000000009, + 0.52359877559829882 }, + { 0.78751507911209895, 0.50000000000000000, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0546620505035220, 0.50000000000000000, 0.60000000000000009, + 0.87266462599716477 }, + { 1.3754438357425935, 0.50000000000000000, 0.60000000000000009, + 1.0471975511965976 }, + { 1.7615727400820127, 0.50000000000000000, 0.60000000000000009, + 1.2217304763960306 }, + { 2.2134638067565242, 0.50000000000000000, 0.60000000000000009, + 1.3962634015954636 }, + { 2.7090491861753558, 0.50000000000000000, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler147 = 2.5000000000000020e-13; + +// Test data for k=0.50000000000000000, nu=0.70000000000000007. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.0745105182189226e-16 +// mean(f - f_Boost): 4.1633363423443370e-17 +// variance(f - f_Boost): 1.9996383743576116e-32 +// stddev(f - f_Boost): 1.4140857026211713e-16 +const testcase_ellint_3<double> +data148[10] = +{ + { 0.0000000000000000, 0.50000000000000000, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17600558435914915, 0.50000000000000000, 0.70000000000000007, + 0.17453292519943295 }, + { 0.36110561926726259, 0.50000000000000000, 0.70000000000000007, + 0.34906585039886590 }, + { 0.56573074641137111, 0.50000000000000000, 0.70000000000000007, + 0.52359877559829882 }, + { 0.80316073084237205, 0.50000000000000000, 0.70000000000000007, + 0.69813170079773179 }, + { 1.0911910688131461, 0.50000000000000000, 0.70000000000000007, + 0.87266462599716477 }, + { 1.4530946406380640, 0.50000000000000000, 0.70000000000000007, + 1.0471975511965976 }, + { 1.9144386536785372, 0.50000000000000000, 0.70000000000000007, + 1.2217304763960306 }, + { 2.4878788958234970, 0.50000000000000000, 0.70000000000000007, + 1.3962634015954636 }, + { 3.1433945297859225, 0.50000000000000000, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler148 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.80000000000000004. -testcase_ellint_3<double> data149[] = { - { -0.0000000000000000, 0.50000000000000000, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17336164805979126, 0.50000000000000000, 0.80000000000000004, - 0.17453292519943295 }, - { 0.34024350132086773, 0.50000000000000000, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49643719555734084, 0.50000000000000000, 0.80000000000000004, - 0.52359877559829882 }, - { 0.64071162456976150, 0.50000000000000000, 0.80000000000000004, - 0.69813170079773179 }, - { 0.77407836177211908, 0.50000000000000000, 0.80000000000000004, - 0.87266462599716477 }, - { 0.89867058251905652, 0.50000000000000000, 0.80000000000000004, - 1.0471975511965976 }, - { 1.0169181822134912, 0.50000000000000000, 0.80000000000000004, - 1.2217304763960306 }, - { 1.1311363312779448, 0.50000000000000000, 0.80000000000000004, - 1.3962634015954636 }, - { 1.2434165408189539, 0.50000000000000000, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=0.50000000000000000, nu=0.80000000000000004. -template <typename Tp> -void test149() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data149) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data149[i].k), Tp(data149[i].nu), - Tp(data149[i].phi)); - const Tp f0 = data149[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.4380477375534667e-16 +// mean(f - f_Boost): 2.3037127760972000e-16 +// variance(f - f_Boost): 1.4989821857033475e-31 +// stddev(f - f_Boost): 3.8716691306248618e-16 +const testcase_ellint_3<double> +data149[10] = +{ + { 0.0000000000000000, 0.50000000000000000, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17618704872620228, 0.50000000000000000, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36266535159745827, 0.50000000000000000, 0.80000000000000004, + 0.34906585039886590 }, + { 0.57167789954529158, 0.50000000000000000, 0.80000000000000004, + 0.52359877559829882 }, + { 0.81995752984315018, 0.50000000000000000, 0.80000000000000004, + 0.69813170079773179 }, + { 1.1325112162158122, 0.50000000000000000, 0.80000000000000004, + 0.87266462599716477 }, + { 1.5479055930718042, 0.50000000000000000, 0.80000000000000004, + 1.0471975511965976 }, + { 2.1215243941010486, 0.50000000000000000, 0.80000000000000004, + 1.2217304763960306 }, + { 2.9069405767650132, 0.50000000000000000, 0.80000000000000004, + 1.3962634015954636 }, + { 3.8750701888108066, 0.50000000000000000, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler149 = 2.5000000000000020e-13; // Test data for k=0.50000000000000000, nu=0.90000000000000002. -testcase_ellint_3<double> data150[] = { - { -0.0000000000000000, 0.50000000000000000, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17319040056865681, 0.50000000000000000, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33899920036578557, 0.50000000000000000, 0.90000000000000002, - 0.34906585039886590 }, - { 0.49279362182695186, 0.50000000000000000, 0.90000000000000002, - 0.52359877559829882 }, - { 0.63342123379746151, 0.50000000000000000, 0.90000000000000002, - 0.69813170079773179 }, - { 0.76220595179550321, 0.50000000000000000, 0.90000000000000002, - 0.87266462599716477 }, - { 0.88160004743532294, 0.50000000000000000, 0.90000000000000002, - 1.0471975511965976 }, - { 0.99427448642310134, 0.50000000000000000, 0.90000000000000002, - 1.2217304763960306 }, - { 1.1027091512470093, 0.50000000000000000, 0.90000000000000002, - 1.3962634015954636 }, - { 1.2091116095504744, 0.50000000000000000, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.50000000000000000, nu=0.90000000000000002. -template <typename Tp> -void test150() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data150) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data150[i].k), Tp(data150[i].nu), - Tp(data150[i].phi)); - const Tp f0 = data150[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 3.6192315188521289e-16 +// mean(f - f_Boost): 3.5249581031848718e-16 +// variance(f - f_Boost): 2.5029385557256515e-31 +// stddev(f - f_Boost): 5.0029376927217987e-16 +const testcase_ellint_3<double> +data150[10] = +{ + { 0.0000000000000000, 0.50000000000000000, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17636918772384180, 0.50000000000000000, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36424950570740700, 0.50000000000000000, 0.90000000000000002, + 0.34906585039886590 }, + { 0.57785404590231426, 0.50000000000000000, 0.90000000000000002, + 0.52359877559829882 }, + { 0.83806480521716531, 0.50000000000000000, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1798568683069752, 0.50000000000000000, 0.90000000000000002, + 0.87266462599716477 }, + { 1.6678766243739607, 0.50000000000000000, 0.90000000000000002, + 1.0471975511965976 }, + { 2.4282976450693483, 0.50000000000000000, 0.90000000000000002, + 1.2217304763960306 }, + { 3.6810787666126656, 0.50000000000000000, 0.90000000000000002, + 1.3962634015954636 }, + { 5.5355132096026454, 0.50000000000000000, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler150 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.0000000000000000. -testcase_ellint_3<double> data151[] = { - { -0.0000000000000000, 0.60000000000000009, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17485154362988362, 0.60000000000000009, 0.0000000000000000, - 0.17453292519943295 }, - { 0.35160509865544326, 0.60000000000000009, 0.0000000000000000, - 0.34906585039886590 }, - { 0.53210652578446160, 0.60000000000000009, 0.0000000000000000, - 0.52359877559829882 }, - { 0.71805304664485670, 0.60000000000000009, 0.0000000000000000, - 0.69813170079773179 }, - { 0.91082759030195970, 0.60000000000000009, 0.0000000000000000, - 0.87266462599716477 }, - { 1.1112333229323366, 0.60000000000000009, 0.0000000000000000, - 1.0471975511965976 }, - { 1.3191461190365270, 0.60000000000000009, 0.0000000000000000, - 1.2217304763960306 }, - { 1.5332022105084775, 0.60000000000000009, 0.0000000000000000, - 1.3962634015954636 }, - { 1.7507538029157526, 0.60000000000000009, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.60000000000000009, nu=0.0000000000000000. -template <typename Tp> -void test151() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data151) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data151[i].k), Tp(data151[i].nu), - Tp(data151[i].phi)); - const Tp f0 = data151[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.3664899092028927e-16 +// mean(f - f_Boost): 3.0531133177191807e-17 +// variance(f - f_Boost): 7.8758646268991113e-33 +// stddev(f - f_Boost): 8.8746068233466605e-17 +const testcase_ellint_3<double> +data151[10] = +{ + { 0.0000000000000000, 0.60000000000000009, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17485154362988359, 0.60000000000000009, 0.0000000000000000, + 0.17453292519943295 }, + { 0.35160509865544320, 0.60000000000000009, 0.0000000000000000, + 0.34906585039886590 }, + { 0.53210652578446138, 0.60000000000000009, 0.0000000000000000, + 0.52359877559829882 }, + { 0.71805304664485659, 0.60000000000000009, 0.0000000000000000, + 0.69813170079773179 }, + { 0.91082759030195981, 0.60000000000000009, 0.0000000000000000, + 0.87266462599716477 }, + { 1.1112333229323361, 0.60000000000000009, 0.0000000000000000, + 1.0471975511965976 }, + { 1.3191461190365270, 0.60000000000000009, 0.0000000000000000, + 1.2217304763960306 }, + { 1.5332022105084779, 0.60000000000000009, 0.0000000000000000, + 1.3962634015954636 }, + { 1.7507538029157526, 0.60000000000000009, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler151 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.10000000000000001. -testcase_ellint_3<double> data152[] = { - { -0.0000000000000000, 0.60000000000000009, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17467514275022014, 0.60000000000000009, 0.10000000000000001, - 0.17453292519943295 }, - { 0.35021333086258255, 0.60000000000000009, 0.10000000000000001, - 0.34906585039886590 }, - { 0.52751664092962713, 0.60000000000000009, 0.10000000000000001, - 0.52359877559829882 }, - { 0.70752126971957885, 0.60000000000000009, 0.10000000000000001, - 0.69813170079773179 }, - { 0.89111058756112871, 0.60000000000000009, 0.10000000000000001, - 0.87266462599716477 }, - { 1.0789241202877773, 0.60000000000000009, 0.10000000000000001, - 1.0471975511965976 }, - { 1.2710800210399946, 0.60000000000000009, 0.10000000000000001, - 1.2217304763960306 }, - { 1.4669060574440278, 0.60000000000000009, 0.10000000000000001, - 1.3962634015954636 }, - { 1.6648615773343014, 0.60000000000000009, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.60000000000000009, nu=0.10000000000000001. -template <typename Tp> -void test152() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data152) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data152[i].k), Tp(data152[i].nu), - Tp(data152[i].phi)); - const Tp f0 = data152[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.2335247010355137e-16 +// mean(f - f_Boost): 8.6042284408449634e-17 +// variance(f - f_Boost): 2.2835347143080263e-33 +// stddev(f - f_Boost): 4.7786344433405099e-17 +const testcase_ellint_3<double> +data152[10] = +{ + { 0.0000000000000000, 0.60000000000000009, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17502858548476194, 0.60000000000000009, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35301673150537388, 0.60000000000000009, 0.10000000000000001, + 0.34906585039886590 }, + { 0.53683932476326812, 0.60000000000000009, 0.10000000000000001, + 0.52359877559829882 }, + { 0.72914228589586771, 0.60000000000000009, 0.10000000000000001, + 0.69813170079773179 }, + { 0.93208036718354692, 0.60000000000000009, 0.10000000000000001, + 0.87266462599716477 }, + { 1.1468984688863377, 0.60000000000000009, 0.10000000000000001, + 1.0471975511965976 }, + { 1.3733904977062528, 0.60000000000000009, 0.10000000000000001, + 1.2217304763960306 }, + { 1.6094225663372157, 0.60000000000000009, 0.10000000000000001, + 1.3962634015954636 }, + { 1.8508766487100685, 0.60000000000000009, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler152 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.20000000000000001. -testcase_ellint_3<double> data153[] = { - { -0.0000000000000000, 0.60000000000000009, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17449937871800653, 0.60000000000000009, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34884093647346553, 0.60000000000000009, 0.20000000000000001, - 0.34906585039886590 }, - { 0.52306221119844110, 0.60000000000000009, 0.20000000000000001, - 0.52359877559829882 }, - { 0.69749955678982223, 0.60000000000000009, 0.20000000000000001, - 0.69813170079773179 }, - { 0.87274610682416853, 0.60000000000000009, 0.20000000000000001, - 0.87266462599716477 }, - { 1.0494620540750796, 0.60000000000000009, 0.20000000000000001, - 1.0471975511965976 }, - { 1.2280847305507339, 0.60000000000000009, 0.20000000000000001, - 1.2217304763960306 }, - { 1.4085436279696888, 0.60000000000000009, 0.20000000000000001, - 1.3962634015954636 }, - { 1.5901418016279374, 0.60000000000000009, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.60000000000000009, nu=0.20000000000000001. -template <typename Tp> -void test153() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data153) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data153[i].k), Tp(data153[i].nu), - Tp(data153[i].phi)); - const Tp f0 = data153[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.60000000000000009, nu=0.29999999999999999. -testcase_ellint_3<double> data154[] = { - { -0.0000000000000000, 0.60000000000000009, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17432424744393935, 0.60000000000000009, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34748744127146447, 0.60000000000000009, 0.29999999999999999, - 0.34906585039886590 }, - { 0.51873632743924847, 0.60000000000000009, 0.29999999999999999, - 0.52359877559829882 }, - { 0.68794610396313127, 0.60000000000000009, 0.29999999999999999, - 0.69813170079773179 }, - { 0.85558070175468726, 0.60000000000000009, 0.29999999999999999, - 0.87266462599716477 }, - { 1.0224416343605658, 0.60000000000000009, 0.29999999999999999, - 1.0471975511965976 }, - { 1.1893144457936788, 0.60000000000000009, 0.29999999999999999, - 1.2217304763960306 }, - { 1.3566435377982575, 0.60000000000000009, 0.29999999999999999, - 1.3962634015954636 }, - { 1.5243814243493585, 0.60000000000000009, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=0.60000000000000009, nu=0.29999999999999999. -template <typename Tp> -void test154() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data154) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data154[i].k), Tp(data154[i].nu), - Tp(data154[i].phi)); - const Tp f0 = data154[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 2.2547200163366559e-16 +// mean(f - f_Boost): -2.4980018054066023e-17 +// variance(f - f_Boost): 2.1685495635542404e-32 +// stddev(f - f_Boost): 1.4725995937641163e-16 +const testcase_ellint_3<double> +data153[10] = +{ + { 0.0000000000000000, 0.60000000000000009, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17520627248155893, 0.60000000000000009, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35444873935437748, 0.60000000000000009, 0.20000000000000001, + 0.34906585039886590 }, + { 0.54172310557682524, 0.60000000000000009, 0.20000000000000001, + 0.52359877559829882 }, + { 0.74084300280734672, 0.60000000000000009, 0.20000000000000001, + 0.69813170079773179 }, + { 0.95509001527006121, 0.60000000000000009, 0.20000000000000001, + 0.87266462599716477 }, + { 1.1865688084431796, 0.60000000000000009, 0.20000000000000001, + 1.0471975511965976 }, + { 1.4352978868932600, 0.60000000000000009, 0.20000000000000001, + 1.2217304763960306 }, + { 1.6983400371331818, 0.60000000000000009, 0.20000000000000001, + 1.3962634015954636 }, + { 1.9695980282802217, 0.60000000000000009, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler153 = 2.5000000000000020e-13; + +// Test data for k=0.60000000000000009, nu=0.30000000000000004. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.9470074709717020e-16 +// mean(f - f_Boost): 3.0531133177191807e-17 +// variance(f - f_Boost): 1.1508025840536076e-34 +// stddev(f - f_Boost): 1.0727546709539920e-17 +const testcase_ellint_3<double> +data154[10] = +{ + { 0.0000000000000000, 0.60000000000000009, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17538460882640122, 0.60000000000000009, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35590165133735557, 0.60000000000000009, 0.30000000000000004, + 0.34906585039886590 }, + { 0.54676661152254535, 0.60000000000000009, 0.30000000000000004, + 0.52359877559829882 }, + { 0.75321709418305305, 0.60000000000000009, 0.30000000000000004, + 0.69813170079773179 }, + { 0.98012637808992920, 0.60000000000000009, 0.30000000000000004, + 0.87266462599716477 }, + { 1.2310891277158875, 0.60000000000000009, 0.30000000000000004, + 1.0471975511965976 }, + { 1.5069157924585623, 0.60000000000000009, 0.30000000000000004, + 1.2217304763960306 }, + { 1.8039583598337940, 0.60000000000000009, 0.30000000000000004, + 1.3962634015954636 }, + { 2.1134154405060599, 0.60000000000000009, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler154 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.40000000000000002. -testcase_ellint_3<double> data155[] = { - { -0.0000000000000000, 0.60000000000000009, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17414974487670720, 0.60000000000000009, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34615238767335027, 0.60000000000000009, 0.40000000000000002, - 0.34906585039886590 }, - { 0.51453257838108579, 0.60000000000000009, 0.40000000000000002, - 0.52359877559829882 }, - { 0.67882386787534410, 0.60000000000000009, 0.40000000000000002, - 0.69813170079773179 }, - { 0.83948470233173578, 0.60000000000000009, 0.40000000000000002, - 0.87266462599716477 }, - { 0.99753496200074021, 0.60000000000000009, 0.40000000000000002, - 1.0471975511965976 }, - { 1.1541101404388487, 0.60000000000000009, 0.40000000000000002, - 1.2217304763960306 }, - { 1.3100911323398816, 0.60000000000000009, 0.40000000000000002, - 1.3962634015954636 }, - { 1.4659345278069984, 0.60000000000000009, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.60000000000000009, nu=0.40000000000000002. -template <typename Tp> -void test155() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data155) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data155[i].k), Tp(data155[i].nu), - Tp(data155[i].phi)); - const Tp f0 = data155[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 2.8974839914337670e-16 +// mean(f - f_Boost): -1.3877787807814457e-17 +// variance(f - f_Boost): 2.2849613290816465e-32 +// stddev(f - f_Boost): 1.5116088545260797e-16 +const testcase_ellint_3<double> +data155[10] = +{ + { 0.0000000000000000, 0.60000000000000009, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17556359876533037, 0.60000000000000009, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35737601674244679, 0.60000000000000009, 0.40000000000000002, + 0.34906585039886590 }, + { 0.55197933771320218, 0.60000000000000009, 0.40000000000000002, + 0.52359877559829882 }, + { 0.76633591620002905, 0.60000000000000009, 0.40000000000000002, + 0.69813170079773179 }, + { 1.0075231136019616, 0.60000000000000009, 0.40000000000000002, + 0.87266462599716477 }, + { 1.2815842073813450, 0.60000000000000009, 0.40000000000000002, + 1.0471975511965976 }, + { 1.5911666941449827, 0.60000000000000009, 0.40000000000000002, + 1.2217304763960306 }, + { 1.9323227566025762, 0.60000000000000009, 0.40000000000000002, + 1.3962634015954636 }, + { 2.2925036420985130, 0.60000000000000009, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler155 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.50000000000000000. -testcase_ellint_3<double> data156[] = { - { -0.0000000000000000, 0.60000000000000009, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17397586700252810, 0.60000000000000009, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34483533397138516, 0.60000000000000009, 0.50000000000000000, - 0.34906585039886590 }, - { 0.51044500461706499, 0.60000000000000009, 0.50000000000000000, - 0.52359877559829882 }, - { 0.67009988034712675, 0.60000000000000009, 0.50000000000000000, - 0.69813170079773179 }, - { 0.82434762375735193, 0.60000000000000009, 0.50000000000000000, - 0.87266462599716477 }, - { 0.97447346702799043, 0.60000000000000009, 0.50000000000000000, - 1.0471975511965976 }, - { 1.1219494000522143, 0.60000000000000009, 0.50000000000000000, - 1.2217304763960306 }, - { 1.2680242605954488, 0.60000000000000009, 0.50000000000000000, - 1.3962634015954636 }, - { 1.4135484285693078, 0.60000000000000009, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.60000000000000009, nu=0.50000000000000000. -template <typename Tp> -void test156() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data156) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data156[i].k), Tp(data156[i].nu), - Tp(data156[i].phi)); - const Tp f0 = data156[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.60000000000000009, nu=0.59999999999999998. -testcase_ellint_3<double> data157[] = { - { -0.0000000000000000, 0.60000000000000009, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17380260984469356, 0.60000000000000009, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34353585361777839, 0.60000000000000009, 0.59999999999999998, - 0.34906585039886590 }, - { 0.50646805774321402, 0.60000000000000009, 0.59999999999999998, - 0.52359877559829882 }, - { 0.66174468108625517, 0.60000000000000009, 0.59999999999999998, - 0.69813170079773179 }, - { 0.81007462280278408, 0.60000000000000009, 0.59999999999999998, - 0.87266462599716477 }, - { 0.95303466945718773, 0.60000000000000009, 0.59999999999999998, - 1.0471975511965976 }, - { 1.0924118588677503, 0.60000000000000009, 0.59999999999999998, - 1.2217304763960306 }, - { 1.2297640574847937, 0.60000000000000009, 0.59999999999999998, - 1.3962634015954636 }, - { 1.3662507535812816, 0.60000000000000009, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=0.60000000000000009, nu=0.59999999999999998. -template <typename Tp> -void test157() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data157) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data157[i].k), Tp(data157[i].nu), - Tp(data157[i].phi)); - const Tp f0 = data157[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.60000000000000009, nu=0.69999999999999996. -testcase_ellint_3<double> data158[] = { - { -0.0000000000000000, 0.60000000000000009, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17362996946312009, 0.60000000000000009, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34225353454870588, 0.60000000000000009, 0.69999999999999996, - 0.34906585039886590 }, - { 0.50259656397799546, 0.60000000000000009, 0.69999999999999996, - 0.52359877559829882 }, - { 0.65373184496628944, 0.60000000000000009, 0.69999999999999996, - 0.69813170079773179 }, - { 0.79658372884056439, 0.60000000000000009, 0.69999999999999996, - 0.87266462599716477 }, - { 0.93303240100245466, 0.60000000000000009, 0.69999999999999996, - 1.0471975511965976 }, - { 1.0651547944716557, 0.60000000000000009, 0.69999999999999996, - 1.2217304763960306 }, - { 1.1947676204853441, 0.60000000000000009, 0.69999999999999996, - 1.3962634015954636 }, - { 1.3232737468822811, 0.60000000000000009, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=0.60000000000000009, nu=0.69999999999999996. -template <typename Tp> -void test158() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data158) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data158[i].k), Tp(data158[i].nu), - Tp(data158[i].phi)); - const Tp f0 = data158[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 2.1397785842303966e-16 +// mean(f - f_Boost): 9.1593399531575410e-17 +// variance(f - f_Boost): 1.5339913122479866e-32 +// stddev(f - f_Boost): 1.2385440291923362e-16 +const testcase_ellint_3<double> +data156[10] = +{ + { 0.0000000000000000, 0.60000000000000009, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17574324658480217, 0.60000000000000009, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35887240603169313, 0.60000000000000009, 0.50000000000000000, + 0.34906585039886590 }, + { 0.55737161826345261, 0.60000000000000009, 0.50000000000000000, + 0.52359877559829882 }, + { 0.78028227313077458, 0.60000000000000009, 0.50000000000000000, + 0.69813170079773179 }, + { 1.0376989776486290, 0.60000000000000009, 0.50000000000000000, + 0.87266462599716477 }, + { 1.3395933991042928, 0.60000000000000009, 0.50000000000000000, + 1.0471975511965976 }, + { 1.6924049626591784, 0.60000000000000009, 0.50000000000000000, + 1.2217304763960306 }, + { 2.0931011856518920, 0.60000000000000009, 0.50000000000000000, + 1.3962634015954636 }, + { 2.5239007084492711, 0.60000000000000009, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler156 = 2.5000000000000020e-13; + +// Test data for k=0.60000000000000009, nu=0.60000000000000009. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.6651378277398083e-16 +// mean(f - f_Boost): 1.1934897514720432e-16 +// variance(f - f_Boost): 1.7585404776158019e-33 +// stddev(f - f_Boost): 4.1934955319110598e-17 +const testcase_ellint_3<double> +data157[10] = +{ + { 0.0000000000000000, 0.60000000000000009, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17592355661219386, 0.60000000000000009, 0.60000000000000009, + 0.17453292519943295 }, + { 0.36039141192661606, 0.60000000000000009, 0.60000000000000009, + 0.34906585039886590 }, + { 0.56295472636903854, 0.60000000000000009, 0.60000000000000009, + 0.52359877559829882 }, + { 0.79515295130165986, 0.60000000000000009, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0711886441942242, 0.60000000000000009, 0.60000000000000009, + 0.87266462599716477 }, + { 1.4072952835139891, 0.60000000000000009, 0.60000000000000009, + 1.0471975511965976 }, + { 1.8174863977376825, 0.60000000000000009, 0.60000000000000009, + 1.2217304763960306 }, + { 2.3029921578542232, 0.60000000000000009, 0.60000000000000009, + 1.3962634015954636 }, + { 2.8388723099514972, 0.60000000000000009, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler157 = 2.5000000000000020e-13; + +// Test data for k=0.60000000000000009, nu=0.70000000000000007. +// max(|f - f_Boost|): 4.4408920985006262e-16 at index 9 +// max(|f - f_Boost| / |f_Boost|): 2.0027679235921772e-16 +// mean(f - f_Boost): -1.3877787807814457e-17 +// variance(f - f_Boost): 2.2849613290816465e-32 +// stddev(f - f_Boost): 1.5116088545260797e-16 +const testcase_ellint_3<double> +data158[10] = +{ + { 0.0000000000000000, 0.60000000000000009, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17610453321631936, 0.60000000000000009, 0.70000000000000007, + 0.17453292519943295 }, + { 0.36193365056369764, 0.60000000000000009, 0.70000000000000007, + 0.34906585039886590 }, + { 0.56874098962268527, 0.60000000000000009, 0.70000000000000007, + 0.52359877559829882 }, + { 0.81106198671477181, 0.60000000000000009, 0.70000000000000007, + 0.69813170079773179 }, + { 1.1086886419010082, 0.60000000000000009, 0.70000000000000007, + 0.87266462599716477 }, + { 1.4879048567239257, 0.60000000000000009, 0.70000000000000007, + 1.0471975511965976 }, + { 1.9780310073615925, 0.60000000000000009, 0.70000000000000007, + 1.2217304763960306 }, + { 2.5941545586772712, 0.60000000000000009, 0.70000000000000007, + 1.3962634015954636 }, + { 3.3029735898397159, 0.60000000000000009, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler158 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.80000000000000004. -testcase_ellint_3<double> data159[] = { - { -0.0000000000000000, 0.60000000000000009, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17345794195390687, 0.60000000000000009, 0.80000000000000004, - 0.17453292519943295 }, - { 0.34098797854531027, 0.60000000000000009, 0.80000000000000004, - 0.34906585039886590 }, - { 0.49882569168826230, 0.60000000000000009, 0.80000000000000004, - 0.52359877559829882 }, - { 0.64603758566475511, 0.60000000000000009, 0.80000000000000004, - 0.69813170079773179 }, - { 0.78380365594769730, 0.60000000000000009, 0.80000000000000004, - 0.87266462599716477 }, - { 0.91430946255611223, 0.60000000000000009, 0.80000000000000004, - 1.0471975511965976 }, - { 1.0398955217270607, 0.60000000000000009, 0.80000000000000004, - 1.2217304763960306 }, - { 1.1625948314277679, 0.60000000000000009, 0.80000000000000004, - 1.3962634015954636 }, - { 1.2840021261752192, 0.60000000000000009, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=0.60000000000000009, nu=0.80000000000000004. -template <typename Tp> -void test159() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data159) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data159[i].k), Tp(data159[i].nu), - Tp(data159[i].phi)); - const Tp f0 = data159[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 7.3044933435043190e-16 +// mean(f - f_Boost): 2.6367796834847468e-16 +// variance(f - f_Boost): 8.5834655546147173e-33 +// stddev(f - f_Boost): 9.2646994309662939e-17 +const testcase_ellint_3<double> +data159[10] = +{ + { 0.0000000000000000, 0.60000000000000009, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17628618080795252, 0.60000000000000009, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36349976272521012, 0.60000000000000009, 0.80000000000000004, + 0.34906585039886590 }, + { 0.57474392342151914, 0.60000000000000009, 0.80000000000000004, + 0.52359877559829882 }, + { 0.82814493499158170, 0.60000000000000009, 0.80000000000000004, + 0.69813170079773179 }, + { 1.1511281795998280, 0.60000000000000009, 0.80000000000000004, + 0.87266462599716477 }, + { 1.5864286332503075, 0.60000000000000009, 0.80000000000000004, + 1.0471975511965976 }, + { 2.1958944866494527, 0.60000000000000009, 0.80000000000000004, + 1.2217304763960306 }, + { 3.0398358172574604, 0.60000000000000009, 0.80000000000000004, + 1.3962634015954636 }, + { 4.0867036409261832, 0.60000000000000009, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler159 = 2.5000000000000020e-13; // Test data for k=0.60000000000000009, nu=0.90000000000000002. -testcase_ellint_3<double> data160[] = { - { -0.0000000000000000, 0.60000000000000009, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17328652344890033, 0.60000000000000009, 0.90000000000000002, - 0.17453292519943295 }, - { 0.33973880062929018, 0.60000000000000009, 0.90000000000000002, - 0.34906585039886590 }, - { 0.49515092233122765, 0.60000000000000009, 0.90000000000000002, - 0.52359877559829882 }, - { 0.63864042139737043, 0.60000000000000009, 0.90000000000000002, - 0.69813170079773179 }, - { 0.77167205646538850, 0.60000000000000009, 0.90000000000000002, - 0.87266462599716477 }, - { 0.89673202848034428, 0.60000000000000009, 0.90000000000000002, - 1.0471975511965976 }, - { 1.0163984492661304, 0.60000000000000009, 0.90000000000000002, - 1.2217304763960306 }, - { 1.1328845785162431, 0.60000000000000009, 0.90000000000000002, - 1.3962634015954636 }, - { 1.2479362973851875, 0.60000000000000009, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.60000000000000009, nu=0.90000000000000002. -template <typename Tp> -void test160() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data160) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data160[i].k), Tp(data160[i].nu), - Tp(data160[i].phi)); - const Tp f0 = data160[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.69999999999999996, nu=0.0000000000000000. -testcase_ellint_3<double> data161[] = { - { -0.0000000000000000, 0.69999999999999996, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17496737466916720, 0.69999999999999996, 0.0000000000000000, - 0.17453292519943295 }, - { 0.35254687535677925, 0.69999999999999996, 0.0000000000000000, - 0.34906585039886590 }, - { 0.53536740275997130, 0.69999999999999996, 0.0000000000000000, - 0.52359877559829882 }, - { 0.72603797651684465, 0.69999999999999996, 0.0000000000000000, - 0.69813170079773179 }, - { 0.92698296348313458, 0.69999999999999996, 0.0000000000000000, - 0.87266462599716477 }, - { 1.1400447527693316, 0.69999999999999996, 0.0000000000000000, - 1.0471975511965976 }, - { 1.3657668117194071, 0.69999999999999996, 0.0000000000000000, - 1.2217304763960306 }, - { 1.6024686895959159, 0.69999999999999996, 0.0000000000000000, - 1.3962634015954636 }, - { 1.8456939983747236, 0.69999999999999996, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.69999999999999996, nu=0.0000000000000000. -template <typename Tp> -void test161() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data161) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data161[i].k), Tp(data161[i].nu), - Tp(data161[i].phi)); - const Tp f0 = data161[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.69999999999999996, nu=0.10000000000000001. -testcase_ellint_3<double> data162[] = { - { -0.0000000000000000, 0.69999999999999996, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17479076384884681, 0.69999999999999996, 0.10000000000000001, - 0.17453292519943295 }, - { 0.35114844900396364, 0.69999999999999996, 0.10000000000000001, - 0.34906585039886590 }, - { 0.53072776947527012, 0.69999999999999996, 0.10000000000000001, - 0.52359877559829882 }, - { 0.71530198262386246, 0.69999999999999996, 0.10000000000000001, - 0.69813170079773179 }, - { 0.90666760677828306, 0.69999999999999996, 0.10000000000000001, - 0.87266462599716477 }, - { 1.1063366517438080, 0.69999999999999996, 0.10000000000000001, - 1.0471975511965976 }, - { 1.3149477243092147, 0.69999999999999996, 0.10000000000000001, - 1.2217304763960306 }, - { 1.5314886725038925, 0.69999999999999996, 0.10000000000000001, - 1.3962634015954636 }, - { 1.7528050171757608, 0.69999999999999996, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.69999999999999996, nu=0.10000000000000001. -template <typename Tp> -void test162() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data162) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data162[i].k), Tp(data162[i].nu), - Tp(data162[i].phi)); - const Tp f0 = data162[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.69999999999999996, nu=0.20000000000000001. -testcase_ellint_3<double> data163[] = { - { -0.0000000000000000, 0.69999999999999996, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17461479077791472, 0.69999999999999996, 0.20000000000000001, - 0.17453292519943295 }, - { 0.34976950621407538, 0.69999999999999996, 0.20000000000000001, - 0.34906585039886590 }, - { 0.52622533231350188, 0.69999999999999996, 0.20000000000000001, - 0.52359877559829882 }, - { 0.70508774017895226, 0.69999999999999996, 0.20000000000000001, - 0.69813170079773179 }, - { 0.88775302531730294, 0.69999999999999996, 0.20000000000000001, - 0.87266462599716477 }, - { 1.0756195476149006, 0.69999999999999996, 0.20000000000000001, - 1.0471975511965976 }, - { 1.2695349716654372, 0.69999999999999996, 0.20000000000000001, - 1.2217304763960306 }, - { 1.4690814617070540, 0.69999999999999996, 0.20000000000000001, - 1.3962634015954636 }, - { 1.6721098780092147, 0.69999999999999996, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.69999999999999996, nu=0.20000000000000001. -template <typename Tp> -void test163() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data163) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data163[i].k), Tp(data163[i].nu), - Tp(data163[i].phi)); - const Tp f0 = data163[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.69999999999999996, nu=0.29999999999999999. -testcase_ellint_3<double> data164[] = { - { -0.0000000000000000, 0.69999999999999996, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17443945136076172, 0.69999999999999996, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34840956983535287, 0.69999999999999996, 0.29999999999999999, - 0.34906585039886590 }, - { 0.52185308551329179, 0.69999999999999996, 0.29999999999999999, - 0.52359877559829882 }, - { 0.69535240431168266, 0.69999999999999996, 0.29999999999999999, - 0.69813170079773179 }, - { 0.87007983473964923, 0.69999999999999996, 0.29999999999999999, - 0.87266462599716477 }, - { 1.0474657975577066, 0.69999999999999996, 0.29999999999999999, - 1.0471975511965976 }, - { 1.2286225419931889, 0.69999999999999996, 0.29999999999999999, - 1.2217304763960306 }, - { 1.4136490671013271, 0.69999999999999996, 0.29999999999999999, - 1.3962634015954636 }, - { 1.6011813647733213, 0.69999999999999996, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=0.69999999999999996, nu=0.29999999999999999. -template <typename Tp> -void test164() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data164) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data164[i].k), Tp(data164[i].nu), - Tp(data164[i].phi)); - const Tp f0 = data164[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.69999999999999996, nu=0.40000000000000002. -testcase_ellint_3<double> data165[] = { - { -0.0000000000000000, 0.69999999999999996, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17426474153983226, 0.69999999999999996, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34706817945773732, 0.69999999999999996, 0.40000000000000002, - 0.34906585039886590 }, - { 0.51760452851738159, 0.69999999999999996, 0.40000000000000002, - 0.52359877559829882 }, - { 0.68605801534722766, 0.69999999999999996, 0.40000000000000002, - 0.69813170079773179 }, - { 0.85351339387296532, 0.69999999999999996, 0.40000000000000002, - 0.87266462599716477 }, - { 1.0215297967969537, 0.69999999999999996, 0.40000000000000002, - 1.0471975511965976 }, - { 1.1915051074460528, 0.69999999999999996, 0.40000000000000002, - 1.2217304763960306 }, - { 1.3639821911744707, 0.69999999999999996, 0.40000000000000002, - 1.3962634015954636 }, - { 1.5382162002954762, 0.69999999999999996, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.69999999999999996, nu=0.40000000000000002. -template <typename Tp> -void test165() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data165) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data165[i].k), Tp(data165[i].nu), - Tp(data165[i].phi)); - const Tp f0 = data165[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.69999999999999996, nu=0.50000000000000000. -testcase_ellint_3<double> data166[] = { - { -0.0000000000000000, 0.69999999999999996, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17409065729516093, 0.69999999999999996, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34574489064986091, 0.69999999999999996, 0.50000000000000000, - 0.34906585039886590 }, - { 0.51347361925579793, 0.69999999999999996, 0.50000000000000000, - 0.52359877559829882 }, - { 0.67717079489579290, 0.69999999999999996, 0.50000000000000000, - 0.69813170079773179 }, - { 0.83793902055292280, 0.69999999999999996, 0.50000000000000000, - 0.87266462599716477 }, - { 0.99752863545289705, 0.69999999999999996, 0.50000000000000000, - 1.0471975511965976 }, - { 1.1576240080401499, 0.69999999999999996, 0.50000000000000000, - 1.2217304763960306 }, - { 1.3191464023923762, 0.69999999999999996, 0.50000000000000000, - 1.3962634015954636 }, - { 1.4818433192178544, 0.69999999999999996, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.69999999999999996, nu=0.50000000000000000. -template <typename Tp> -void test166() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data166) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data166[i].k), Tp(data166[i].nu), - Tp(data166[i].phi)); - const Tp f0 = data166[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.69999999999999996, nu=0.59999999999999998. -testcase_ellint_3<double> data167[] = { - { -0.0000000000000000, 0.69999999999999996, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17391719464391611, 0.69999999999999996, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34443927423869031, 0.69999999999999996, 0.59999999999999998, - 0.34906585039886590 }, - { 0.50945473266486074, 0.69999999999999996, 0.59999999999999998, - 0.52359877559829882 }, - { 0.66866056326513823, 0.69999999999999996, 0.59999999999999998, - 0.69813170079773179 }, - { 0.82325830002337352, 0.69999999999999996, 0.59999999999999998, - 0.87266462599716477 }, - { 0.97522808245669357, 0.69999999999999996, 0.59999999999999998, - 1.0471975511965976 }, - { 1.1265300613705282, 0.69999999999999996, 0.59999999999999998, - 1.2217304763960306 }, - { 1.2784066076152003, 0.69999999999999996, 0.59999999999999998, - 1.3962634015954636 }, - { 1.4309994736080540, 0.69999999999999996, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=0.69999999999999996, nu=0.59999999999999998. -template <typename Tp> -void test167() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data167) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data167[i].k), Tp(data167[i].nu), - Tp(data167[i].phi)); - const Tp f0 = data167[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.69999999999999996, nu=0.69999999999999996. -testcase_ellint_3<double> data168[] = { - { -0.0000000000000000, 0.69999999999999996, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17374434963995028, 0.69999999999999996, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34315091562900674, 0.69999999999999996, 0.69999999999999996, - 0.34906585039886590 }, - { 0.50554262375653358, 0.69999999999999996, 0.69999999999999996, - 0.52359877559829882 }, - { 0.66050025406305812, 0.69999999999999996, 0.69999999999999996, - 0.69813170079773179 }, - { 0.80938620118847404, 0.69999999999999996, 0.69999999999999996, - 0.87266462599716477 }, - { 0.95443223855852144, 0.69999999999999996, 0.69999999999999996, - 1.0471975511965976 }, - { 1.0978573207128302, 0.69999999999999996, 0.69999999999999996, - 1.2217304763960306 }, - { 1.2411754575007123, 0.69999999999999996, 0.69999999999999996, - 1.3962634015954636 }, - { 1.3848459188329196, 0.69999999999999996, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=0.69999999999999996, nu=0.69999999999999996. -template <typename Tp> -void test168() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data168) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data168[i].k), Tp(data168[i].nu), - Tp(data168[i].phi)); - const Tp f0 = data168[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.69999999999999996, nu=0.80000000000000004. -testcase_ellint_3<double> data169[] = { - { -0.0000000000000000, 0.69999999999999996, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17357211837335737, 0.69999999999999996, 0.80000000000000004, - 0.17453292519943295 }, - { 0.34187941416012108, 0.69999999999999996, 0.80000000000000004, - 0.34906585039886590 }, - { 0.50173239465478270, 0.69999999999999996, 0.80000000000000004, - 0.52359877559829882 }, - { 0.65266550725988315, 0.69999999999999996, 0.80000000000000004, - 0.69813170079773179 }, - { 0.79624879865249298, 0.69999999999999996, 0.80000000000000004, - 0.87266462599716477 }, - { 0.93497577043296920, 0.69999999999999996, 0.80000000000000004, - 1.0471975511965976 }, - { 1.0713041566930748, 0.69999999999999996, 0.80000000000000004, - 1.2217304763960306 }, - { 1.2069772023255652, 0.69999999999999996, 0.80000000000000004, - 1.3962634015954636 }, - { 1.3427110650397533, 0.69999999999999996, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=0.69999999999999996, nu=0.80000000000000004. -template <typename Tp> -void test169() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data169) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data169[i].k), Tp(data169[i].nu), - Tp(data169[i].phi)); - const Tp f0 = data169[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.69999999999999996, nu=0.90000000000000002. -testcase_ellint_3<double> data170[] = { - { -0.0000000000000000, 0.69999999999999996, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17340049697003634, 0.69999999999999996, 0.90000000000000002, - 0.17453292519943295 }, - { 0.34062438249741556, 0.69999999999999996, 0.90000000000000002, - 0.34906585039886590 }, - { 0.49801946510076878, 0.69999999999999996, 0.90000000000000002, - 0.52359877559829882 }, - { 0.64513432604750487, 0.69999999999999996, 0.90000000000000002, - 0.69813170079773179 }, - { 0.78378145487573758, 0.69999999999999996, 0.90000000000000002, - 0.87266462599716477 }, - { 0.91671799500854634, 0.69999999999999996, 0.90000000000000002, - 1.0471975511965976 }, - { 1.0466193579463123, 0.69999999999999996, 0.90000000000000002, - 1.2217304763960306 }, - { 1.1754218079199146, 0.69999999999999996, 0.90000000000000002, - 1.3962634015954636 }, - { 1.3040500499695911, 0.69999999999999996, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.69999999999999996, nu=0.90000000000000002. -template <typename Tp> -void test170() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data170) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data170[i].k), Tp(data170[i].nu), - Tp(data170[i].phi)); - const Tp f0 = data170[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.5952142720718732e-16 +// mean(f - f_Boost): 4.6351811278100284e-16 +// variance(f - f_Boost): 2.1278339779151204e-31 +// stddev(f - f_Boost): 4.6128450851021651e-16 +const testcase_ellint_3<double> +data160[10] = +{ + { 0.0000000000000000, 0.60000000000000009, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17646850384035848, 0.60000000000000009, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36509041515134105, 0.60000000000000009, 0.90000000000000002, + 0.34906585039886590 }, + { 0.58097838596260631, 0.60000000000000009, 0.90000000000000002, + 0.52359877559829882 }, + { 0.84656453396163722, 0.60000000000000009, 0.90000000000000002, + 0.69813170079773179 }, + { 1.1997828426963724, 0.60000000000000009, 0.90000000000000002, + 0.87266462599716477 }, + { 1.7112436789225605, 0.60000000000000009, 0.90000000000000002, + 1.0471975511965976 }, + { 2.5193168553672312, 0.60000000000000009, 0.90000000000000002, + 1.2217304763960306 }, + { 3.8656670488606690, 0.60000000000000009, 0.90000000000000002, + 1.3962634015954636 }, + { 5.8709993116265604, 0.60000000000000009, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler160 = 2.5000000000000020e-13; + +// Test data for k=0.70000000000000018, nu=0.0000000000000000. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.1569224977685422e-16 +// mean(f - f_Boost): 7.7715611723760953e-17 +// variance(f - f_Boost): 1.6571557210371951e-32 +// stddev(f - f_Boost): 1.2873056051447903e-16 +const testcase_ellint_3<double> +data161[10] = +{ + { 0.0000000000000000, 0.70000000000000018, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17496737466916723, 0.70000000000000018, 0.0000000000000000, + 0.17453292519943295 }, + { 0.35254687535677931, 0.70000000000000018, 0.0000000000000000, + 0.34906585039886590 }, + { 0.53536740275997130, 0.70000000000000018, 0.0000000000000000, + 0.52359877559829882 }, + { 0.72603797651684454, 0.70000000000000018, 0.0000000000000000, + 0.69813170079773179 }, + { 0.92698296348313447, 0.70000000000000018, 0.0000000000000000, + 0.87266462599716477 }, + { 1.1400447527693318, 0.70000000000000018, 0.0000000000000000, + 1.0471975511965976 }, + { 1.3657668117194073, 0.70000000000000018, 0.0000000000000000, + 1.2217304763960306 }, + { 1.6024686895959164, 0.70000000000000018, 0.0000000000000000, + 1.3962634015954636 }, + { 1.8456939983747236, 0.70000000000000018, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler161 = 2.5000000000000020e-13; + +// Test data for k=0.70000000000000018, nu=0.10000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.9552278747527691e-16 +// mean(f - f_Boost): 1.1102230246251565e-16 +// variance(f - f_Boost): 1.3695501826753678e-32 +// stddev(f - f_Boost): 1.1702778228589004e-16 +const testcase_ellint_3<double> +data162[10] = +{ + { 0.0000000000000000, 0.70000000000000018, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17514462737300920, 0.70000000000000018, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35396527997470451, 0.70000000000000018, 0.10000000000000001, + 0.34906585039886590 }, + { 0.54015179589433981, 0.70000000000000018, 0.10000000000000001, + 0.52359877559829882 }, + { 0.73734430854477728, 0.70000000000000018, 0.10000000000000001, + 0.69813170079773179 }, + { 0.94888950796697047, 0.70000000000000018, 0.10000000000000001, + 0.87266462599716477 }, + { 1.1772807959736322, 0.70000000000000018, 0.10000000000000001, + 1.0471975511965976 }, + { 1.4231796401075834, 0.70000000000000018, 0.10000000000000001, + 1.2217304763960306 }, + { 1.6841856799887471, 0.70000000000000018, 0.10000000000000001, + 1.3962634015954636 }, + { 1.9541347343119564, 0.70000000000000018, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler162 = 2.5000000000000020e-13; + +// Test data for k=0.70000000000000018, nu=0.20000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.7430437016285820e-16 +// mean(f - f_Boost): 3.3306690738754695e-17 +// variance(f - f_Boost): 1.3695501826753678e-34 +// stddev(f - f_Boost): 1.1702778228589003e-17 +const testcase_ellint_3<double> +data163[10] = +{ + { 0.0000000000000000, 0.70000000000000018, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17532252613350796, 0.70000000000000018, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35540417596807522, 0.70000000000000018, 0.20000000000000001, + 0.34906585039886590 }, + { 0.54508913033361928, 0.70000000000000018, 0.20000000000000001, + 0.52359877559829882 }, + { 0.74927635777718415, 0.70000000000000018, 0.20000000000000001, + 0.69813170079773179 }, + { 0.97261706337936338, 0.70000000000000018, 0.20000000000000001, + 0.87266462599716477 }, + { 1.2187303976209327, 0.70000000000000018, 0.20000000000000001, + 1.0471975511965976 }, + { 1.4887796709222487, 0.70000000000000018, 0.20000000000000001, + 1.2217304763960306 }, + { 1.7796581281839214, 0.70000000000000018, 0.20000000000000001, + 1.3962634015954636 }, + { 2.0829290325820207, 0.70000000000000018, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler163 = 2.5000000000000020e-13; + +// Test data for k=0.70000000000000018, nu=0.30000000000000004. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.2570807706941696e-16 +// mean(f - f_Boost): 8.8817841970012528e-17 +// variance(f - f_Boost): 1.5582437633995295e-32 +// stddev(f - f_Boost): 1.2482963443828271e-16 +const testcase_ellint_3<double> +data164[10] = +{ + { 0.0000000000000000, 0.70000000000000018, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17550107516328570, 0.70000000000000018, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35686409576571965, 0.70000000000000018, 0.30000000000000004, + 0.34906585039886590 }, + { 0.55018827316513352, 0.70000000000000018, 0.30000000000000004, + 0.52359877559829882 }, + { 0.76189759494390275, 0.70000000000000018, 0.30000000000000004, + 0.69813170079773179 }, + { 0.99844623430885626, 0.70000000000000018, 0.30000000000000004, + 0.87266462599716477 }, + { 1.2652862989039833, 0.70000000000000018, 0.30000000000000004, + 1.0471975511965976 }, + { 1.5647666808691361, 0.70000000000000018, 0.30000000000000004, + 1.2217304763960306 }, + { 1.8932499694938165, 0.70000000000000018, 0.30000000000000004, + 1.3962634015954636 }, + { 2.2392290510988535, 0.70000000000000018, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler164 = 2.5000000000000020e-13; + +// Test data for k=0.70000000000000018, nu=0.40000000000000002. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.3719045096496910e-16 +// mean(f - f_Boost): 1.3600232051658169e-16 +// variance(f - f_Boost): 1.1718213750516114e-32 +// stddev(f - f_Boost): 1.0825069861444829e-16 +const testcase_ellint_3<double> +data165[10] = +{ + { 0.0000000000000000, 0.70000000000000018, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17568027871494424, 0.70000000000000018, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35834559208180261, 0.70000000000000018, 0.40000000000000002, + 0.34906585039886590 }, + { 0.55545885451190613, 0.70000000000000018, 0.40000000000000002, + 0.52359877559829882 }, + { 0.77528120402568113, 0.70000000000000018, 0.40000000000000002, + 0.69813170079773179 }, + { 1.0267241287600322, 0.70000000000000018, 0.40000000000000002, + 0.87266462599716477 }, + { 1.3181380338980246, 0.70000000000000018, 0.40000000000000002, + 1.0471975511965976 }, + { 1.6542840785132087, 0.70000000000000018, 0.40000000000000002, + 1.2217304763960306 }, + { 2.0315595131131823, 0.70000000000000018, 0.40000000000000002, + 1.3962634015954636 }, + { 2.4342502915307880, 0.70000000000000018, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler165 = 2.5000000000000020e-13; + +// Test data for k=0.70000000000000018, nu=0.50000000000000000. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.0277361210295499e-16 +// mean(f - f_Boost): 1.6930901125533636e-16 +// variance(f - f_Boost): 6.3799163752809956e-32 +// stddev(f - f_Boost): 2.5258496343371268e-16 +const testcase_ellint_3<double> +data166[10] = +{ + { 0.0000000000000000, 0.70000000000000018, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17586014108156545, 0.70000000000000018, 0.50000000000000000, + 0.17453292519943295 }, + { 0.35984923894341653, 0.70000000000000018, 0.50000000000000000, + 0.34906585039886590 }, + { 0.56091135606739995, 0.70000000000000018, 0.50000000000000000, + 0.52359877559829882 }, + { 0.78951212635197054, 0.70000000000000018, 0.50000000000000000, + 0.69813170079773179 }, + { 1.0578865732938731, 0.70000000000000018, 0.50000000000000000, + 0.87266462599716477 }, + { 1.3789149005151722, 0.70000000000000018, 0.50000000000000000, + 1.0471975511965976 }, + { 1.7620212286086228, 0.70000000000000018, 0.50000000000000000, + 1.2217304763960306 }, + { 2.2051554347435589, 0.70000000000000018, 0.50000000000000000, + 1.3962634015954636 }, + { 2.6868019968236996, 0.70000000000000018, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler166 = 2.5000000000000020e-13; + +// Test data for k=0.70000000000000018, nu=0.60000000000000009. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.8597454441867134e-16 +// mean(f - f_Boost): 2.5535129566378598e-16 +// variance(f - f_Boost): 2.8561208198482198e-31 +// stddev(f - f_Boost): 5.3442687243889785e-16 +const testcase_ellint_3<double> +data167[10] = +{ + { 0.0000000000000000, 0.70000000000000018, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17604066659721918, 0.70000000000000018, 0.60000000000000009, + 0.17453292519943295 }, + { 0.36137563278353424, 0.70000000000000018, 0.60000000000000009, + 0.34906585039886590 }, + { 0.56655721272747606, 0.70000000000000018, 0.60000000000000009, + 0.52359877559829882 }, + { 0.80468966552978305, 0.70000000000000018, 0.60000000000000009, + 0.69813170079773179 }, + { 1.0924902943683852, 0.70000000000000018, 0.60000000000000009, + 0.87266462599716477 }, + { 1.4499247992499800, 0.70000000000000018, 0.60000000000000009, + 1.0471975511965976 }, + { 1.8953714382113818, 0.70000000000000018, 0.60000000000000009, + 1.2217304763960306 }, + { 2.4323229949248670, 0.70000000000000018, 0.60000000000000009, + 1.3962634015954636 }, + { 3.0314573496746746, 0.70000000000000018, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler167 = 2.5000000000000020e-13; + +// Test data for k=0.70000000000000018, nu=0.70000000000000007. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 8 +// max(|f - f_Boost| / |f_Boost|): 3.2316852368580916e-16 +// mean(f - f_Boost): 7.7715611723760953e-17 +// variance(f - f_Boost): 7.4564398834547797e-34 +// stddev(f - f_Boost): 2.7306482533374340e-17 +const testcase_ellint_3<double> +data168[10] = +{ + { 0.0000000000000000, 0.70000000000000018, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17622185963747933, 0.70000000000000018, 0.70000000000000007, + 0.17453292519943295 }, + { 0.36292539360435261, 0.70000000000000018, 0.70000000000000007, + 0.34906585039886590 }, + { 0.57240892970150015, 0.70000000000000018, 0.70000000000000007, + 0.52359877559829882 }, + { 0.82093084713182629, 0.70000000000000018, 0.70000000000000007, + 0.69813170079773179 }, + { 1.1312609022179871, 0.70000000000000018, 0.70000000000000007, + 0.87266462599716477 }, + { 1.5345768067715795, 0.70000000000000018, 0.70000000000000007, + 1.0471975511965976 }, + { 2.0668847445934424, 0.70000000000000018, 0.70000000000000007, + 1.2217304763960306 }, + { 2.7483444537551245, 0.70000000000000018, 0.70000000000000007, + 1.3962634015954636 }, + { 3.5408408771788569, 0.70000000000000018, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler168 = 2.5000000000000020e-13; + +// Test data for k=0.70000000000000018, nu=0.80000000000000004. +// max(|f - f_Boost|): 1.3322676295501878e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.1198716111867353e-16 +// mean(f - f_Boost): 2.2482016248659419e-16 +// variance(f - f_Boost): 5.4326441655972001e-32 +// stddev(f - f_Boost): 2.3308033305273100e-16 +const testcase_ellint_3<double> +data169[10] = +{ + { 0.0000000000000000, 0.70000000000000018, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17640372461994805, 0.70000000000000018, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36449916621651091, 0.70000000000000018, 0.80000000000000004, + 0.34906585039886590 }, + { 0.57848021800372584, 0.70000000000000018, 0.80000000000000004, + 0.52359877559829882 }, + { 0.83837480968392586, 0.70000000000000018, 0.80000000000000004, + 0.69813170079773179 }, + { 1.1751669030061143, 0.70000000000000018, 0.80000000000000004, + 0.87266462599716477 }, + { 1.6381851899173603, 0.70000000000000018, 0.80000000000000004, + 1.0471975511965976 }, + { 2.3002065924302197, 0.70000000000000018, 0.80000000000000004, + 1.2217304763960306 }, + { 3.2337600665337871, 0.70000000000000018, 0.80000000000000004, + 1.3962634015954636 }, + { 4.4042405729076970, 0.70000000000000018, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler169 = 2.5000000000000020e-13; + +// Test data for k=0.70000000000000018, nu=0.90000000000000002. +// max(|f - f_Boost|): 3.5527136788005009e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 8.5869439826269878e-16 +// mean(f - f_Boost): 7.4384942649885490e-16 +// variance(f - f_Boost): 9.7403930714297352e-31 +// stddev(f - f_Boost): 9.8693429727767263e-16 +const testcase_ellint_3<double> +data170[10] = +{ + { 0.0000000000000000, 0.70000000000000018, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17658626600478800, 0.70000000000000018, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36609762156017206, 0.70000000000000018, 0.90000000000000002, + 0.34906585039886590 }, + { 0.58478615187842409, 0.70000000000000018, 0.90000000000000002, + 0.52359877559829882 }, + { 0.85718862878291846, 0.70000000000000018, 0.90000000000000002, + 0.69813170079773179 }, + { 1.2255385617397643, 0.70000000000000018, 0.90000000000000002, + 0.87266462599716477 }, + { 1.7696521899992941, 0.70000000000000018, 0.90000000000000002, + 1.0471975511965976 }, + { 2.6476314987883507, 0.70000000000000018, 0.90000000000000002, + 1.2217304763960306 }, + { 4.1373434902898083, 0.70000000000000018, 0.90000000000000002, + 1.3962634015954636 }, + { 6.3796094177887763, 0.70000000000000018, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler170 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.0000000000000000. -testcase_ellint_3<double> data171[] = { - { -0.0000000000000000, 0.80000000000000004, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17510154241338902, 0.80000000000000004, 0.0000000000000000, - 0.17453292519943295 }, - { 0.35365068839779390, 0.80000000000000004, 0.0000000000000000, - 0.34906585039886590 }, - { 0.53926804409084561, 0.80000000000000004, 0.0000000000000000, - 0.52359877559829882 }, - { 0.73587926028070383, 0.80000000000000004, 0.0000000000000000, - 0.69813170079773179 }, - { 0.94770942970071170, 0.80000000000000004, 0.0000000000000000, - 0.87266462599716477 }, - { 1.1789022995388239, 0.80000000000000004, 0.0000000000000000, - 1.0471975511965976 }, - { 1.4323027881876009, 0.80000000000000004, 0.0000000000000000, - 1.2217304763960306 }, - { 1.7069629739121674, 0.80000000000000004, 0.0000000000000000, - 1.3962634015954636 }, - { 1.9953027776647296, 0.80000000000000004, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.80000000000000004, nu=0.0000000000000000. -template <typename Tp> -void test171() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data171) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data171[i].k), Tp(data171[i].nu), - Tp(data171[i].phi)); - const Tp f0 = data171[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.5543122344752192e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.7898565163847540e-16 +// mean(f - f_Boost): 2.3869795029440865e-16 +// variance(f - f_Boost): 2.1368406725192426e-31 +// stddev(f - f_Boost): 4.6225974002926564e-16 +const testcase_ellint_3<double> +data171[10] = +{ + { 0.0000000000000000, 0.80000000000000004, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17510154241338899, 0.80000000000000004, 0.0000000000000000, + 0.17453292519943295 }, + { 0.35365068839779396, 0.80000000000000004, 0.0000000000000000, + 0.34906585039886590 }, + { 0.53926804409084550, 0.80000000000000004, 0.0000000000000000, + 0.52359877559829882 }, + { 0.73587926028070372, 0.80000000000000004, 0.0000000000000000, + 0.69813170079773179 }, + { 0.94770942970071170, 0.80000000000000004, 0.0000000000000000, + 0.87266462599716477 }, + { 1.1789022995388236, 0.80000000000000004, 0.0000000000000000, + 1.0471975511965976 }, + { 1.4323027881876012, 0.80000000000000004, 0.0000000000000000, + 1.2217304763960306 }, + { 1.7069629739121677, 0.80000000000000004, 0.0000000000000000, + 1.3962634015954636 }, + { 1.9953027776647294, 0.80000000000000004, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler171 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.10000000000000001. -testcase_ellint_3<double> data172[] = { - { -0.0000000000000000, 0.80000000000000004, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17492468824017166, 0.80000000000000004, 0.10000000000000001, - 0.17453292519943295 }, - { 0.35224443521476911, 0.80000000000000004, 0.10000000000000001, - 0.34906585039886590 }, - { 0.53456851853226961, 0.80000000000000004, 0.10000000000000001, - 0.52359877559829882 }, - { 0.72488875602364944, 0.80000000000000004, 0.10000000000000001, - 0.69813170079773179 }, - { 0.92661354274638952, 0.80000000000000004, 0.10000000000000001, - 0.87266462599716477 }, - { 1.1432651144499077, 0.80000000000000004, 0.10000000000000001, - 1.0471975511965976 }, - { 1.3774479927211429, 0.80000000000000004, 0.10000000000000001, - 1.2217304763960306 }, - { 1.6287092337196041, 0.80000000000000004, 0.10000000000000001, - 1.3962634015954636 }, - { 1.8910755418379521, 0.80000000000000004, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.80000000000000004, nu=0.10000000000000001. -template <typename Tp> -void test172() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data172) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data172[i].k), Tp(data172[i].nu), - Tp(data172[i].phi)); - const Tp f0 = data172[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 8.3898786942190374e-16 +// mean(f - f_Boost): 2.3869795029440865e-16 +// variance(f - f_Boost): 2.9190059990693968e-31 +// stddev(f - f_Boost): 5.4027826155319237e-16 +const testcase_ellint_3<double> +data172[10] = +{ + { 0.0000000000000000, 0.80000000000000004, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17527903952342144, 0.80000000000000004, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35507705313548549, 0.80000000000000004, 0.10000000000000001, + 0.34906585039886590 }, + { 0.54411455987643553, 0.80000000000000004, 0.10000000000000001, + 0.52359877559829882 }, + { 0.74745625666804383, 0.80000000000000004, 0.10000000000000001, + 0.69813170079773179 }, + { 0.97046953684238557, 0.80000000000000004, 0.10000000000000001, + 0.87266462599716477 }, + { 1.2183080025184605, 0.80000000000000004, 0.10000000000000001, + 1.0471975511965976 }, + { 1.4943711151994405, 0.80000000000000004, 0.10000000000000001, + 1.2217304763960306 }, + { 1.7972401309544201, 0.80000000000000004, 0.10000000000000001, + 1.3962634015954636 }, + { 2.1172616484005085, 0.80000000000000004, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler172 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.20000000000000001. -testcase_ellint_3<double> data173[] = { - { -0.0000000000000000, 0.80000000000000004, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17474847286224943, 0.80000000000000004, 0.20000000000000001, - 0.17453292519943295 }, - { 0.35085779529084682, 0.80000000000000004, 0.20000000000000001, - 0.34906585039886590 }, - { 0.53000829263059157, 0.80000000000000004, 0.20000000000000001, - 0.52359877559829882 }, - { 0.71443466027453406, 0.80000000000000004, 0.20000000000000001, - 0.69813170079773179 }, - { 0.90698196872715420, 0.80000000000000004, 0.20000000000000001, - 0.87266462599716477 }, - { 1.1108198200558581, 0.80000000000000004, 0.20000000000000001, - 1.0471975511965976 }, - { 1.3284988909963957, 0.80000000000000004, 0.20000000000000001, - 1.2217304763960306 }, - { 1.5600369318140328, 0.80000000000000004, 0.20000000000000001, - 1.3962634015954636 }, - { 1.8007226661734588, 0.80000000000000004, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.80000000000000004, nu=0.20000000000000001. -template <typename Tp> -void test173() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data173) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data173[i].k), Tp(data173[i].nu), - Tp(data173[i].phi)); - const Tp f0 = data173[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.80000000000000004, nu=0.29999999999999999. -testcase_ellint_3<double> data174[] = { - { -0.0000000000000000, 0.80000000000000004, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17457289217669891, 0.80000000000000004, 0.29999999999999999, - 0.17453292519943295 }, - { 0.34949028801501258, 0.80000000000000004, 0.29999999999999999, - 0.34906585039886590 }, - { 0.52558024362769318, 0.80000000000000004, 0.29999999999999999, - 0.52359877559829882 }, - { 0.70447281740094914, 0.80000000000000004, 0.29999999999999999, - 0.69813170079773179 }, - { 0.88864745641528986, 0.80000000000000004, 0.29999999999999999, - 0.87266462599716477 }, - { 1.0811075819341465, 0.80000000000000004, 0.29999999999999999, - 1.0471975511965976 }, - { 1.2844589654082377, 0.80000000000000004, 0.29999999999999999, - 1.2217304763960306 }, - { 1.4991461361277849, 0.80000000000000004, 0.29999999999999999, - 1.3962634015954636 }, - { 1.7214611048717301, 0.80000000000000004, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=0.80000000000000004, nu=0.29999999999999999. -template <typename Tp> -void test174() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data174) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data174[i].k), Tp(data174[i].nu), - Tp(data174[i].phi)); - const Tp f0 = data174[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.8513740186068518e-16 +// mean(f - f_Boost): 2.8310687127941490e-16 +// variance(f - f_Boost): 2.7528339102381189e-31 +// stddev(f - f_Boost): 5.2467455724840699e-16 +const testcase_ellint_3<double> +data173[10] = +{ + { 0.0000000000000000, 0.80000000000000004, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17545718375086419, 0.80000000000000004, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35652404627248163, 0.80000000000000004, 0.20000000000000001, + 0.34906585039886590 }, + { 0.54911638512920913, 0.80000000000000004, 0.20000000000000001, + 0.52359877559829882 }, + { 0.75967684282131176, 0.80000000000000004, 0.20000000000000001, + 0.69813170079773179 }, + { 0.99513526893543769, 0.80000000000000004, 0.20000000000000001, + 0.87266462599716477 }, + { 1.2622192109995993, 0.80000000000000004, 0.20000000000000001, + 1.0471975511965976 }, + { 1.5654106676347741, 0.80000000000000004, 0.20000000000000001, + 1.2217304763960306 }, + { 1.9029531718534984, 0.80000000000000004, 0.20000000000000001, + 1.3962634015954636 }, + { 2.2624789434186798, 0.80000000000000004, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler173 = 2.5000000000000020e-13; + +// Test data for k=0.80000000000000004, nu=0.30000000000000004. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.2825261583337354e-16 +// mean(f - f_Boost): 2.6367796834847468e-16 +// variance(f - f_Boost): 2.8249350208968825e-31 +// stddev(f - f_Boost): 5.3150117788175054e-16 +const testcase_ellint_3<double> +data174[10] = +{ + { 0.0000000000000000, 0.80000000000000004, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17563597931587369, 0.80000000000000004, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35799220412005128, 0.80000000000000004, 0.30000000000000004, + 0.34906585039886590 }, + { 0.55428253691111318, 0.80000000000000004, 0.30000000000000004, + 0.52359877559829882 }, + { 0.77260647376977365, 0.80000000000000004, 0.30000000000000004, + 0.69813170079773179 }, + { 1.0220015271210958, 0.80000000000000004, 0.30000000000000004, + 0.87266462599716477 }, + { 1.3115965312302671, 0.80000000000000004, 0.30000000000000004, + 1.0471975511965976 }, + { 1.6478518468813512, 0.80000000000000004, 0.30000000000000004, + 1.2217304763960306 }, + { 2.0290458414203481, 0.80000000000000004, 0.30000000000000004, + 1.3962634015954636 }, + { 2.4392042002725693, 0.80000000000000004, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler174 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.40000000000000002. -testcase_ellint_3<double> data175[] = { - { -0.0000000000000000, 0.80000000000000004, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17439794211872178, 0.80000000000000004, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34814144964568972, 0.80000000000000004, 0.40000000000000002, - 0.34906585039886590 }, - { 0.52127776285273075, 0.80000000000000004, 0.40000000000000002, - 0.52359877559829882 }, - { 0.69496411438966599, 0.80000000000000004, 0.40000000000000002, - 0.69813170079773179 }, - { 0.87146878427509589, 0.80000000000000004, 0.40000000000000002, - 0.87266462599716477 }, - { 1.0537579024937762, 0.80000000000000004, 0.40000000000000002, - 1.0471975511965976 }, - { 1.2445534387922637, 0.80000000000000004, 0.40000000000000002, - 1.2217304763960306 }, - { 1.4446769766361993, 0.80000000000000004, 0.40000000000000002, - 1.3962634015954636 }, - { 1.6512267838651289, 0.80000000000000004, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.80000000000000004, nu=0.40000000000000002. -template <typename Tp> -void test175() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data175) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data175[i].k), Tp(data175[i].nu), - Tp(data175[i].phi)); - const Tp f0 = data175[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 8.3462748389836647e-16 +// mean(f - f_Boost): 3.3861802251067273e-16 +// variance(f - f_Boost): 4.3719465706454422e-31 +// stddev(f - f_Boost): 6.6120696991527871e-16 +const testcase_ellint_3<double> +data175[10] = +{ + { 0.0000000000000000, 0.80000000000000004, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17581543047866136, 0.80000000000000004, 0.40000000000000002, + 0.17453292519943295 }, + { 0.35948208343061633, 0.80000000000000004, 0.40000000000000002, + 0.34906585039886590 }, + { 0.55962280893702021, 0.80000000000000004, 0.40000000000000002, + 0.52359877559829882 }, + { 0.78632063889234116, 0.80000000000000004, 0.40000000000000002, + 0.69813170079773179 }, + { 1.0514333069550323, 0.80000000000000004, 0.40000000000000002, + 0.87266462599716477 }, + { 1.3677213138838757, 0.80000000000000004, 0.40000000000000002, + 1.0471975511965976 }, + { 1.7451736773665165, 0.80000000000000004, 0.40000000000000002, + 1.2217304763960306 }, + { 2.1830100424586831, 0.80000000000000004, 0.40000000000000002, + 1.3962634015954636 }, + { 2.6604037035529724, 0.80000000000000004, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler175 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.50000000000000000. -testcase_ellint_3<double> data176[] = { - { -0.0000000000000000, 0.80000000000000004, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17422361866118047, 0.80000000000000004, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34681083254170475, 0.80000000000000004, 0.50000000000000000, - 0.34906585039886590 }, - { 0.51709470815494440, 0.80000000000000004, 0.50000000000000000, - 0.52359877559829882 }, - { 0.68587375344080259, 0.80000000000000004, 0.50000000000000000, - 0.69813170079773179 }, - { 0.85532571852810624, 0.80000000000000004, 0.50000000000000000, - 0.87266462599716477 }, - { 1.0284677391874906, 0.80000000000000004, 0.50000000000000000, - 1.0471975511965976 }, - { 1.2081693942686225, 0.80000000000000004, 0.50000000000000000, - 1.2217304763960306 }, - { 1.3955803006426311, 0.80000000000000004, 0.50000000000000000, - 1.3962634015954636 }, - { 1.5884528947755532, 0.80000000000000004, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.80000000000000004, nu=0.50000000000000000. -template <typename Tp> -void test176() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data176) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data176[i].k), Tp(data176[i].nu), - Tp(data176[i].phi)); - const Tp f0 = data176[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.80000000000000004, nu=0.59999999999999998. -testcase_ellint_3<double> data177[] = { - { -0.0000000000000000, 0.80000000000000004, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17404991781414092, 0.80000000000000004, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34549800443625167, 0.80000000000000004, 0.59999999999999998, - 0.34906585039886590 }, - { 0.51302536167001556, 0.80000000000000004, 0.59999999999999998, - 0.52359877559829882 }, - { 0.67717065003912258, 0.80000000000000004, 0.59999999999999998, - 0.69813170079773179 }, - { 0.84011512421134416, 0.80000000000000004, 0.59999999999999998, - 0.87266462599716477 }, - { 1.0049863847088742, 0.80000000000000004, 0.59999999999999998, - 1.0471975511965976 }, - { 1.1748145941898918, 0.80000000000000004, 0.59999999999999998, - 1.2217304763960306 }, - { 1.3510319699755071, 0.80000000000000004, 0.59999999999999998, - 1.3962634015954636 }, - { 1.5319262547427865, 0.80000000000000004, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=0.80000000000000004, nu=0.59999999999999998. -template <typename Tp> -void test177() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data177) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data177[i].k), Tp(data177[i].nu), - Tp(data177[i].phi)); - const Tp f0 = data177[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.80000000000000004, nu=0.69999999999999996. -testcase_ellint_3<double> data178[] = { - { -0.0000000000000000, 0.80000000000000004, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17387683562442202, 0.80000000000000004, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34420254775101611, 0.80000000000000004, 0.69999999999999996, - 0.34906585039886590 }, - { 0.50906439222143685, 0.80000000000000004, 0.69999999999999996, - 0.52359877559829882 }, - { 0.66882693152688433, 0.80000000000000004, 0.69999999999999996, - 0.69813170079773179 }, - { 0.82574792844091316, 0.80000000000000004, 0.69999999999999996, - 0.87266462599716477 }, - { 0.98310431309490953, 0.80000000000000004, 0.69999999999999996, - 1.0471975511965976 }, - { 1.1440884535113258, 0.80000000000000004, 0.69999999999999996, - 1.2217304763960306 }, - { 1.3103743938952537, 0.80000000000000004, 0.69999999999999996, - 1.3962634015954636 }, - { 1.4806912324625332, 0.80000000000000004, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=0.80000000000000004, nu=0.69999999999999996. -template <typename Tp> -void test178() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data178) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data178[i].k), Tp(data178[i].nu), - Tp(data178[i].phi)); - const Tp f0 = data178[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.0388243828581744e-16 +// mean(f - f_Boost): 3.8580250105724191e-16 +// variance(f - f_Boost): 6.4106456575047741e-31 +// stddev(f - f_Boost): 8.0066507713929764e-16 +const testcase_ellint_3<double> +data176[10] = +{ + { 0.0000000000000000, 0.80000000000000004, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17599554153999472, 0.80000000000000004, 0.50000000000000000, + 0.17453292519943295 }, + { 0.36099426243351540, 0.80000000000000004, 0.50000000000000000, + 0.34906585039886590 }, + { 0.56514786174780673, 0.80000000000000004, 0.50000000000000000, + 0.52359877559829882 }, + { 0.80090697622371010, 0.80000000000000004, 0.50000000000000000, + 0.69813170079773179 }, + { 1.0838891627679339, 0.80000000000000004, 0.50000000000000000, + 0.87266462599716477 }, + { 1.4323506654466280, 0.80000000000000004, 0.50000000000000000, + 1.0471975511965976 }, + { 1.8625761085390575, 0.80000000000000004, 0.50000000000000000, + 1.2217304763960306 }, + { 2.3768757305654766, 0.80000000000000004, 0.50000000000000000, + 1.3962634015954636 }, + { 2.9478781158239746, 0.80000000000000004, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler176 = 2.5000000000000020e-13; + +// Test data for k=0.80000000000000004, nu=0.60000000000000009. +// max(|f - f_Boost|): 3.5527136788005009e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 1.0631099169042069e-15 +// mean(f - f_Boost): 4.8294701571194306e-16 +// variance(f - f_Boost): 1.1633910328160319e-30 +// stddev(f - f_Boost): 1.0786060600682865e-15 +const testcase_ellint_3<double> +data177[10] = +{ + { 0.0000000000000000, 0.80000000000000004, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17617631684170665, 0.80000000000000004, 0.60000000000000009, + 0.17453292519943295 }, + { 0.36252934193666231, 0.80000000000000004, 0.60000000000000009, + 0.34906585039886590 }, + { 0.57086932622945163, 0.80000000000000004, 0.60000000000000009, + 0.52359877559829882 }, + { 0.81646796740150973, 0.80000000000000004, 0.60000000000000009, + 0.69813170079773179 }, + { 1.1199552158519064, 0.80000000000000004, 0.60000000000000009, + 0.87266462599716477 }, + { 1.5079766673336394, 0.80000000000000004, 0.60000000000000009, + 1.0471975511965976 }, + { 2.0082747447038165, 0.80000000000000004, 0.60000000000000009, + 1.2217304763960306 }, + { 2.6315146066775523, 0.80000000000000004, 0.60000000000000009, + 1.3962634015954636 }, + { 3.3418121892288051, 0.80000000000000004, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler177 = 2.5000000000000020e-13; + +// Test data for k=0.80000000000000004, nu=0.70000000000000007. +// max(|f - f_Boost|): 2.2204460492503131e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.6544679145741375e-16 +// mean(f - f_Boost): 3.2751579226442120e-16 +// variance(f - f_Boost): 4.4236851331020672e-31 +// stddev(f - f_Boost): 6.6510789599147505e-16 +const testcase_ellint_3<double> +data178[10] = +{ + { 0.0000000000000000, 0.80000000000000004, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17635776076721221, 0.80000000000000004, 0.70000000000000007, + 0.17453292519943295 }, + { 0.36408794649916976, 0.80000000000000004, 0.70000000000000007, + 0.34906585039886590 }, + { 0.57679992290624138, 0.80000000000000004, 0.70000000000000007, + 0.52359877559829882 }, + { 0.83312441418142813, 0.80000000000000004, 0.70000000000000007, + 0.69813170079773179 }, + { 1.1603958891464856, 0.80000000000000004, 0.70000000000000007, + 0.87266462599716477 }, + { 1.5982855143796213, 0.80000000000000004, 0.70000000000000007, + 1.0471975511965976 }, + { 2.1962484408371821, 0.80000000000000004, 0.70000000000000007, + 1.2217304763960306 }, + { 2.9873281786111869, 0.80000000000000004, 0.70000000000000007, + 1.3962634015954636 }, + { 3.9268876980046397, 0.80000000000000004, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler178 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.80000000000000004. -testcase_ellint_3<double> data179[] = { - { -0.0000000000000000, 0.80000000000000004, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17370436817515206, 0.80000000000000004, 0.80000000000000004, - 0.17453292519943295 }, - { 0.34292405894783395, 0.80000000000000004, 0.80000000000000004, - 0.34906585039886590 }, - { 0.50520682176250087, 0.80000000000000004, 0.80000000000000004, - 0.52359877559829882 }, - { 0.66081751679736189, 0.80000000000000004, 0.80000000000000004, - 0.69813170079773179 }, - { 0.81214672249355102, 0.80000000000000004, 0.80000000000000004, - 0.87266462599716477 }, - { 0.96264481387685574, 0.80000000000000004, 0.80000000000000004, - 1.0471975511965976 }, - { 1.1156611352656258, 0.80000000000000004, 0.80000000000000004, - 1.2217304763960306 }, - { 1.2730756225143889, 0.80000000000000004, 0.80000000000000004, - 1.3962634015954636 }, - { 1.4339837018309474, 0.80000000000000004, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=0.80000000000000004, nu=0.80000000000000004. -template <typename Tp> -void test179() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data179) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data179[i].k), Tp(data179[i].nu), - Tp(data179[i].phi)); - const Tp f0 = data179[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 9.0176949165011079e-16 +// mean(f - f_Boost): 7.0499162063697436e-16 +// variance(f - f_Boost): 1.7230805408026989e-30 +// stddev(f - f_Boost): 1.3126616246400665e-15 +const testcase_ellint_3<double> +data179[10] = +{ + { 0.0000000000000000, 0.80000000000000004, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17653987774203392, 0.80000000000000004, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36567072568046877, 0.80000000000000004, 0.80000000000000004, + 0.34906585039886590 }, + { 0.58295359996558616, 0.80000000000000004, 0.80000000000000004, + 0.52359877559829882 }, + { 0.85101998309176108, 0.80000000000000004, 0.80000000000000004, + 0.69813170079773179 }, + { 1.2062322059736537, 0.80000000000000004, 0.80000000000000004, + 0.87266462599716477 }, + { 1.7090321420917429, 0.80000000000000004, 0.80000000000000004, + 1.0471975511965976 }, + { 2.4529058049405066, 0.80000000000000004, 0.80000000000000004, + 1.2217304763960306 }, + { 3.5368893360106948, 0.80000000000000004, 0.80000000000000004, + 1.3962634015954636 }, + { 4.9246422058196062, 0.80000000000000004, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler179 = 2.5000000000000020e-13; // Test data for k=0.80000000000000004, nu=0.90000000000000002. -testcase_ellint_3<double> data180[] = { - { -0.0000000000000000, 0.80000000000000004, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17353251158533153, 0.80000000000000004, 0.90000000000000002, - 0.17453292519943295 }, - { 0.34166214791545768, 0.80000000000000004, 0.90000000000000002, - 0.34906585039886590 }, - { 0.50144799535130580, 0.80000000000000004, 0.90000000000000002, - 0.52359877559829882 }, - { 0.65311976193814447, 0.80000000000000004, 0.90000000000000002, - 0.69813170079773179 }, - { 0.79924384892320866, 0.80000000000000004, 0.90000000000000002, - 0.87266462599716477 }, - { 0.94345762353365625, 0.80000000000000004, 0.90000000000000002, - 1.0471975511965976 }, - { 1.0892582069219159, 0.80000000000000004, 0.90000000000000002, - 1.2217304763960306 }, - { 1.2387000876610268, 0.80000000000000004, 0.90000000000000002, - 1.3962634015954636 }, - { 1.3911845406776222, 0.80000000000000004, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.80000000000000004, nu=0.90000000000000002. -template <typename Tp> -void test180() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data180) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data180[i].k), Tp(data180[i].nu), - Tp(data180[i].phi)); - const Tp f0 = data180[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.89999999999999991, nu=0.0000000000000000. -testcase_ellint_3<double> data181[] = { - { -0.0000000000000000, 0.89999999999999991, 0.0000000000000000, - 0.0000000000000000 }, - { 0.17525427376115027, 0.89999999999999991, 0.0000000000000000, - 0.17453292519943295 }, - { 0.35492464591297446, 0.89999999999999991, 0.0000000000000000, - 0.34906585039886590 }, - { 0.54388221416157123, 0.89999999999999991, 0.0000000000000000, - 0.52359877559829882 }, - { 0.74797400423532501, 0.89999999999999991, 0.0000000000000000, - 0.69813170079773179 }, - { 0.97463898451966458, 0.89999999999999991, 0.0000000000000000, - 0.87266462599716477 }, - { 1.2334463254523438, 0.89999999999999991, 0.0000000000000000, - 1.0471975511965976 }, - { 1.5355247765594910, 0.89999999999999991, 0.0000000000000000, - 1.2217304763960306 }, - { 1.8882928567775117, 0.89999999999999991, 0.0000000000000000, - 1.3962634015954636 }, - { 2.2805491384227699, 0.89999999999999991, 0.0000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.89999999999999991, nu=0.0000000000000000. -template <typename Tp> -void test181() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data181) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data181[i].k), Tp(data181[i].nu), - Tp(data181[i].phi)); - const Tp f0 = data181[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.89999999999999991, nu=0.10000000000000001. -testcase_ellint_3<double> data182[] = { - { -0.0000000000000000, 0.89999999999999991, 0.10000000000000001, - 0.0000000000000000 }, - { 0.17507714233254659, 0.89999999999999991, 0.10000000000000001, - 0.17453292519943295 }, - { 0.35350932904326521, 0.89999999999999991, 0.10000000000000001, - 0.34906585039886590 }, - { 0.53911129989870987, 0.89999999999999991, 0.10000000000000001, - 0.52359877559829882 }, - { 0.73666644254508407, 0.89999999999999991, 0.10000000000000001, - 0.69813170079773179 }, - { 0.95250736612100184, 0.89999999999999991, 0.10000000000000001, - 0.87266462599716477 }, - { 1.1950199550905591, 0.89999999999999991, 0.10000000000000001, - 1.0471975511965976 }, - { 1.4741687286340848, 0.89999999999999991, 0.10000000000000001, - 1.2217304763960306 }, - { 1.7968678183506053, 0.89999999999999991, 0.10000000000000001, - 1.3962634015954636 }, - { 2.1537868513875282, 0.89999999999999991, 0.10000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.89999999999999991, nu=0.10000000000000001. -template <typename Tp> -void test182() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data182) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data182[i].k), Tp(data182[i].nu), - Tp(data182[i].phi)); - const Tp f0 = data182[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.89999999999999991, nu=0.20000000000000001. -testcase_ellint_3<double> data183[] = { - { -0.0000000000000000, 0.89999999999999991, 0.20000000000000001, - 0.0000000000000000 }, - { 0.17490065089140930, 0.89999999999999991, 0.20000000000000001, - 0.17453292519943295 }, - { 0.35211377590661436, 0.89999999999999991, 0.20000000000000001, - 0.34906585039886590 }, - { 0.53448220334204111, 0.89999999999999991, 0.20000000000000001, - 0.52359877559829882 }, - { 0.72591368943179591, 0.89999999999999991, 0.20000000000000001, - 0.69813170079773179 }, - { 0.93192539780038763, 0.89999999999999991, 0.20000000000000001, - 0.87266462599716477 }, - { 1.1600809679692681, 0.89999999999999991, 0.20000000000000001, - 1.0471975511965976 }, - { 1.4195407225882508, 0.89999999999999991, 0.20000000000000001, - 1.2217304763960306 }, - { 1.7168966476424521, 0.89999999999999991, 0.20000000000000001, - 1.3962634015954636 }, - { 2.0443194576468890, 0.89999999999999991, 0.20000000000000001, - 1.5707963267948966 }, -}; - -// Test function for k=0.89999999999999991, nu=0.20000000000000001. -template <typename Tp> -void test183() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data183) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data183[i].k), Tp(data183[i].nu), - Tp(data183[i].phi)); - const Tp f0 = data183[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.89999999999999991, nu=0.29999999999999999. -testcase_ellint_3<double> data184[] = { - { -0.0000000000000000, 0.89999999999999991, 0.29999999999999999, - 0.0000000000000000 }, - { 0.17472479532647534, 0.89999999999999991, 0.29999999999999999, - 0.17453292519943295 }, - { 0.35073750187374114, 0.89999999999999991, 0.29999999999999999, - 0.34906585039886590 }, - { 0.52998766129466968, 0.89999999999999991, 0.29999999999999999, - 0.52359877559829882 }, - { 0.71566993548699565, 0.89999999999999991, 0.29999999999999999, - 0.69813170079773179 }, - { 0.91271517762560195, 0.89999999999999991, 0.29999999999999999, - 0.87266462599716477 }, - { 1.1281241199843368, 0.89999999999999991, 0.29999999999999999, - 1.0471975511965976 }, - { 1.3704929576917448, 0.89999999999999991, 0.29999999999999999, - 1.2217304763960306 }, - { 1.6461981511487711, 0.89999999999999991, 0.29999999999999999, - 1.3962634015954636 }, - { 1.9486280260314424, 0.89999999999999991, 0.29999999999999999, - 1.5707963267948966 }, -}; - -// Test function for k=0.89999999999999991, nu=0.29999999999999999. -template <typename Tp> -void test184() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data184) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data184[i].k), Tp(data184[i].nu), - Tp(data184[i].phi)); - const Tp f0 = data184[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.89999999999999991, nu=0.40000000000000002. -testcase_ellint_3<double> data185[] = { - { -0.0000000000000000, 0.89999999999999991, 0.40000000000000002, - 0.0000000000000000 }, - { 0.17454957156468839, 0.89999999999999991, 0.40000000000000002, - 0.17453292519943295 }, - { 0.34938003933330430, 0.89999999999999991, 0.40000000000000002, - 0.34906585039886590 }, - { 0.52562093533067444, 0.89999999999999991, 0.40000000000000002, - 0.52359877559829882 }, - { 0.70589461324915681, 0.89999999999999991, 0.40000000000000002, - 0.69813170079773179 }, - { 0.89472658511942849, 0.89999999999999991, 0.40000000000000002, - 0.87266462599716477 }, - { 1.0987419542323438, 0.89999999999999991, 0.40000000000000002, - 1.0471975511965976 }, - { 1.3261349565496301, 0.89999999999999991, 0.40000000000000002, - 1.2217304763960306 }, - { 1.5831293909853761, 0.89999999999999991, 0.40000000000000002, - 1.3962634015954636 }, - { 1.8641114227238347, 0.89999999999999991, 0.40000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.89999999999999991, nu=0.40000000000000002. -template <typename Tp> -void test185() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data185) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data185[i].k), Tp(data185[i].nu), - Tp(data185[i].phi)); - const Tp f0 = data185[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.89999999999999991, nu=0.50000000000000000. -testcase_ellint_3<double> data186[] = { - { -0.0000000000000000, 0.89999999999999991, 0.50000000000000000, - 0.0000000000000000 }, - { 0.17437497557073336, 0.89999999999999991, 0.50000000000000000, - 0.17453292519943295 }, - { 0.34804093691586013, 0.89999999999999991, 0.50000000000000000, - 0.34906585039886590 }, - { 0.52137576320372903, 0.89999999999999991, 0.50000000000000000, - 0.52359877559829882 }, - { 0.69655163996912262, 0.89999999999999991, 0.50000000000000000, - 0.69813170079773179 }, - { 0.87783188683054236, 0.89999999999999991, 0.50000000000000000, - 0.87266462599716477 }, - { 1.0716015959755183, 0.89999999999999991, 0.50000000000000000, - 1.0471975511965976 }, - { 1.2857636916026749, 0.89999999999999991, 0.50000000000000000, - 1.2217304763960306 }, - { 1.5264263913252358, 0.89999999999999991, 0.50000000000000000, - 1.3962634015954636 }, - { 1.7888013241937859, 0.89999999999999991, 0.50000000000000000, - 1.5707963267948966 }, -}; - -// Test function for k=0.89999999999999991, nu=0.50000000000000000. -template <typename Tp> -void test186() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data186) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data186[i].k), Tp(data186[i].nu), - Tp(data186[i].phi)); - const Tp f0 = data186[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.89999999999999991, nu=0.59999999999999998. -testcase_ellint_3<double> data187[] = { - { -0.0000000000000000, 0.89999999999999991, 0.59999999999999998, - 0.0000000000000000 }, - { 0.17420100334657815, 0.89999999999999991, 0.59999999999999998, - 0.17453292519943295 }, - { 0.34671975876122157, 0.89999999999999991, 0.59999999999999998, - 0.34906585039886590 }, - { 0.51724631570707957, 0.89999999999999991, 0.59999999999999998, - 0.52359877559829882 }, - { 0.68760879113743034, 0.89999999999999991, 0.59999999999999998, - 0.69813170079773179 }, - { 0.86192157779698364, 0.89999999999999991, 0.59999999999999998, - 0.87266462599716477 }, - { 1.0464279696166352, 0.89999999999999991, 0.59999999999999998, - 1.0471975511965976 }, - { 1.2488156247094004, 0.89999999999999991, 0.59999999999999998, - 1.2217304763960306 }, - { 1.4750988777188470, 0.89999999999999991, 0.59999999999999998, - 1.3962634015954636 }, - { 1.7211781128919521, 0.89999999999999991, 0.59999999999999998, - 1.5707963267948966 }, -}; - -// Test function for k=0.89999999999999991, nu=0.59999999999999998. -template <typename Tp> -void test187() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data187) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data187[i].k), Tp(data187[i].nu), - Tp(data187[i].phi)); - const Tp f0 = data187[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.89999999999999991, nu=0.69999999999999996. -testcase_ellint_3<double> data188[] = { - { -0.0000000000000000, 0.89999999999999991, 0.69999999999999996, - 0.0000000000000000 }, - { 0.17402765093102210, 0.89999999999999991, 0.69999999999999996, - 0.17453292519943295 }, - { 0.34541608382635131, 0.89999999999999991, 0.69999999999999996, - 0.34906585039886590 }, - { 0.51322715827061693, 0.89999999999999991, 0.69999999999999996, - 0.52359877559829882 }, - { 0.67903717872440283, 0.89999999999999991, 0.69999999999999996, - 0.69813170079773179 }, - { 0.84690113601682671, 0.89999999999999991, 0.69999999999999996, - 0.87266462599716477 }, - { 1.0229914311548416, 0.89999999999999991, 0.69999999999999996, - 1.0471975511965976 }, - { 1.2148329639709381, 0.89999999999999991, 0.69999999999999996, - 1.2217304763960306 }, - { 1.4283586501307799, 0.89999999999999991, 0.69999999999999996, - 1.3962634015954636 }, - { 1.6600480747670936, 0.89999999999999991, 0.69999999999999996, - 1.5707963267948966 }, -}; - -// Test function for k=0.89999999999999991, nu=0.69999999999999996. -template <typename Tp> -void test188() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data188) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data188[i].k), Tp(data188[i].nu), - Tp(data188[i].phi)); - const Tp f0 = data188[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.89999999999999991, nu=0.80000000000000004. -testcase_ellint_3<double> data189[] = { - { -0.0000000000000000, 0.89999999999999991, 0.80000000000000004, - 0.0000000000000000 }, - { 0.17385491439925149, 0.89999999999999991, 0.80000000000000004, - 0.17453292519943295 }, - { 0.34412950523113928, 0.89999999999999991, 0.80000000000000004, - 0.34906585039886590 }, - { 0.50931321668729601, 0.89999999999999991, 0.80000000000000004, - 0.52359877559829882 }, - { 0.67081081392296327, 0.89999999999999991, 0.80000000000000004, - 0.69813170079773179 }, - { 0.83268846097293259, 0.89999999999999991, 0.80000000000000004, - 0.87266462599716477 }, - { 1.0010985015814025, 0.89999999999999991, 0.80000000000000004, - 1.0471975511965976 }, - { 1.1834394045489678, 0.89999999999999991, 0.80000000000000004, - 1.2217304763960306 }, - { 1.3855695891683182, 0.89999999999999991, 0.80000000000000004, - 1.3962634015954636 }, - { 1.6044591960982200, 0.89999999999999991, 0.80000000000000004, - 1.5707963267948966 }, -}; - -// Test function for k=0.89999999999999991, nu=0.80000000000000004. -template <typename Tp> -void test189() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data189) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data189[i].k), Tp(data189[i].nu), - Tp(data189[i].phi)); - const Tp f0 = data189[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} - -// Test data for k=0.89999999999999991, nu=0.90000000000000002. -testcase_ellint_3<double> data190[] = { - { -0.0000000000000000, 0.89999999999999991, 0.90000000000000002, - 0.0000000000000000 }, - { 0.17368278986240138, 0.89999999999999991, 0.90000000000000002, - 0.17453292519943295 }, - { 0.34285962963961397, 0.89999999999999991, 0.90000000000000002, - 0.34906585039886590 }, - { 0.50549974644993312, 0.89999999999999991, 0.90000000000000002, - 0.52359877559829882 }, - { 0.66290623857720876, 0.89999999999999991, 0.90000000000000002, - 0.69813170079773179 }, - { 0.81921183128847164, 0.89999999999999991, 0.90000000000000002, - 0.87266462599716477 }, - { 0.98058481956066368, 0.89999999999999991, 0.90000000000000002, - 1.0471975511965976 }, - { 1.1543223520473569, 0.89999999999999991, 0.90000000000000002, - 1.2217304763960306 }, - { 1.3462119782292934, 0.89999999999999991, 0.90000000000000002, - 1.3962634015954636 }, - { 1.5536420236310944, 0.89999999999999991, 0.90000000000000002, - 1.5707963267948966 }, -}; - -// Test function for k=0.89999999999999991, nu=0.90000000000000002. -template <typename Tp> -void test190() -{ - const Tp eps = std::numeric_limits<Tp>::epsilon(); - Tp max_abs_diff = -Tp(1); - Tp max_abs_frac = -Tp(1); - unsigned int num_datum = sizeof(data190) - / sizeof(testcase_ellint_3<double>); - for (unsigned int i = 0; i < num_datum; ++i) - { - const Tp f = std::tr1::ellint_3(Tp(data190[i].k), Tp(data190[i].nu), - Tp(data190[i].phi)); - const Tp f0 = data190[i].f0; - const Tp diff = f - f0; - if (std::abs(diff) > max_abs_diff) - max_abs_diff = std::abs(diff); - if (std::abs(f0) > Tp(10) * eps - && std::abs(f) > Tp(10) * eps) - { - const Tp frac = diff / f0; - if (std::abs(frac) > max_abs_frac) - max_abs_frac = std::abs(frac); - } - } - VERIFY(max_abs_frac < Tp(2.5000000000000020e-13)); -} +// max(|f - f_Boost|): 4.4408920985006262e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 7.7782721357365268e-16 +// mean(f - f_Boost): 8.9928064994637676e-16 +// variance(f - f_Boost): 1.5485199571025344e-30 +// stddev(f - f_Boost): 1.2443954183066307e-15 +const testcase_ellint_3<double> +data180[10] = +{ + { 0.0000000000000000, 0.80000000000000004, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17672267223433513, 0.80000000000000004, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36727835537196063, 0.80000000000000004, 0.90000000000000002, + 0.34906585039886590 }, + { 0.58934569363716649, 0.80000000000000004, 0.90000000000000002, + 0.52359877559829882 }, + { 0.87032723471138851, 0.80000000000000004, 0.90000000000000002, + 0.69813170079773179 }, + { 1.2588676111323349, 0.80000000000000004, 0.90000000000000002, + 0.87266462599716477 }, + { 1.8498731900660019, 0.80000000000000004, 0.90000000000000002, + 1.0471975511965976 }, + { 2.8368381299300420, 0.80000000000000004, 0.90000000000000002, + 1.2217304763960306 }, + { 4.5674844191654058, 0.80000000000000004, 0.90000000000000002, + 1.3962634015954636 }, + { 7.2263259298637115, 0.80000000000000004, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler180 = 2.5000000000000020e-13; + +// Test data for k=0.90000000000000013, nu=0.0000000000000000. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.3381508715713360e-16 +// mean(f - f_Boost): 5.8286708792820721e-17 +// variance(f - f_Boost): 4.1942474344433133e-34 +// stddev(f - f_Boost): 2.0479861900030756e-17 +const testcase_ellint_3<double> +data181[10] = +{ + { 0.0000000000000000, 0.90000000000000013, 0.0000000000000000, + 0.0000000000000000 }, + { 0.17525427376115027, 0.90000000000000013, 0.0000000000000000, + 0.17453292519943295 }, + { 0.35492464591297446, 0.90000000000000013, 0.0000000000000000, + 0.34906585039886590 }, + { 0.54388221416157123, 0.90000000000000013, 0.0000000000000000, + 0.52359877559829882 }, + { 0.74797400423532512, 0.90000000000000013, 0.0000000000000000, + 0.69813170079773179 }, + { 0.97463898451966446, 0.90000000000000013, 0.0000000000000000, + 0.87266462599716477 }, + { 1.2334463254523440, 0.90000000000000013, 0.0000000000000000, + 1.0471975511965976 }, + { 1.5355247765594915, 0.90000000000000013, 0.0000000000000000, + 1.2217304763960306 }, + { 1.8882928567775128, 0.90000000000000013, 0.0000000000000000, + 1.3962634015954636 }, + { 2.2805491384227707, 0.90000000000000013, 0.0000000000000000, + 1.5707963267948966 }, +}; +const double toler181 = 2.5000000000000020e-13; + +// Test data for k=0.90000000000000013, nu=0.10000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.1500594295134815e-16 +// mean(f - f_Boost): 9.1593399531575410e-17 +// variance(f - f_Boost): 1.0357223256482469e-33 +// stddev(f - f_Boost): 3.2182640128619758e-17 +const testcase_ellint_3<double> +data182[10] = +{ + { 0.0000000000000000, 0.90000000000000013, 0.10000000000000001, + 0.0000000000000000 }, + { 0.17543204932716244, 0.90000000000000013, 0.10000000000000001, + 0.17453292519943295 }, + { 0.35636022898551184, 0.90000000000000013, 0.10000000000000001, + 0.34906585039886590 }, + { 0.54880278898382595, 0.90000000000000013, 0.10000000000000001, + 0.52359877559829882 }, + { 0.75988834774529268, 0.90000000000000013, 0.10000000000000001, + 0.69813170079773179 }, + { 0.99853303003568117, 0.90000000000000013, 0.10000000000000001, + 0.87266462599716477 }, + { 1.2759958823999022, 0.90000000000000013, 0.10000000000000001, + 1.0471975511965976 }, + { 1.6051187364639401, 0.90000000000000013, 0.10000000000000001, + 1.2217304763960306 }, + { 1.9941406879519474, 0.90000000000000013, 0.10000000000000001, + 1.3962634015954636 }, + { 2.4295011187834890, 0.90000000000000013, 0.10000000000000001, + 1.5707963267948966 }, +}; +const double toler182 = 2.5000000000000020e-13; + +// Test data for k=0.90000000000000013, nu=0.20000000000000001. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.9533518431433547e-16 +// mean(f - f_Boost): 1.0269562977782698e-16 +// variance(f - f_Boost): 1.4388836606733082e-32 +// stddev(f - f_Boost): 1.1995347684303728e-16 +const testcase_ellint_3<double> +data183[10] = +{ + { 0.0000000000000000, 0.90000000000000013, 0.20000000000000001, + 0.0000000000000000 }, + { 0.17561047321968409, 0.90000000000000013, 0.20000000000000001, + 0.17453292519943295 }, + { 0.35781659944356109, 0.90000000000000013, 0.20000000000000001, + 0.34906585039886590 }, + { 0.55388150905215283, 0.90000000000000013, 0.20000000000000001, + 0.52359877559829882 }, + { 0.77246874123251441, 0.90000000000000013, 0.20000000000000001, + 0.69813170079773179 }, + { 1.0244466254771925, 0.90000000000000013, 0.20000000000000001, + 0.87266462599716477 }, + { 1.3234824077640801, 0.90000000000000013, 0.20000000000000001, + 1.0471975511965976 }, + { 1.6849848968804240, 0.90000000000000013, 0.20000000000000001, + 1.2217304763960306 }, + { 2.1185749045502278, 0.90000000000000013, 0.20000000000000001, + 1.3962634015954636 }, + { 2.6076835743348417, 0.90000000000000013, 0.20000000000000001, + 1.5707963267948966 }, +}; +const double toler183 = 2.5000000000000020e-13; + +// Test data for k=0.90000000000000013, nu=0.30000000000000004. +// max(|f - f_Boost|): 6.6613381477509392e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 3.9712691025502371e-16 +// mean(f - f_Boost): 6.9388939039072284e-17 +// variance(f - f_Boost): 5.9442282234173945e-34 +// stddev(f - f_Boost): 2.4380787976227090e-17 +const testcase_ellint_3<double> +data184[10] = +{ + { 0.0000000000000000, 0.90000000000000013, 0.30000000000000004, + 0.0000000000000000 }, + { 0.17578954966746221, 0.90000000000000013, 0.30000000000000004, + 0.17453292519943295 }, + { 0.35929429810867447, 0.90000000000000013, 0.30000000000000004, + 0.34906585039886590 }, + { 0.55912757154240822, 0.90000000000000013, 0.30000000000000004, + 0.52359877559829882 }, + { 0.78578314722025389, 0.90000000000000013, 0.30000000000000004, + 0.69813170079773179 }, + { 1.0526941001131365, 0.90000000000000013, 0.30000000000000004, + 0.87266462599716477 }, + { 1.3769682234538601, 0.90000000000000013, 0.30000000000000004, + 1.0471975511965976 }, + { 1.7779437432911240, 0.90000000000000013, 0.30000000000000004, + 1.2217304763960306 }, + { 2.2676509341813635, 0.90000000000000013, 0.30000000000000004, + 1.3962634015954636 }, + { 2.8256506968858517, 0.90000000000000013, 0.30000000000000004, + 1.5707963267948966 }, +}; +const double toler184 = 2.5000000000000020e-13; + +// Test data for k=0.90000000000000013, nu=0.40000000000000002. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.7042235432234642e-16 +// mean(f - f_Boost): 1.8041124150158794e-16 +// variance(f - f_Boost): 8.5834655546147173e-33 +// stddev(f - f_Boost): 9.2646994309662939e-17 +const testcase_ellint_3<double> +data185[10] = +{ + { 0.0000000000000000, 0.90000000000000013, 0.40000000000000002, + 0.0000000000000000 }, + { 0.17596928293938452, 0.90000000000000013, 0.40000000000000002, + 0.17453292519943295 }, + { 0.36079388642472821, 0.90000000000000013, 0.40000000000000002, + 0.34906585039886590 }, + { 0.56455096667115612, 0.90000000000000013, 0.40000000000000002, + 0.52359877559829882 }, + { 0.79990996997869435, 0.90000000000000013, 0.40000000000000002, + 0.69813170079773179 }, + { 1.0836647913872215, 0.90000000000000013, 0.40000000000000002, + 0.87266462599716477 }, + { 1.4378726836091849, 0.90000000000000013, 0.40000000000000002, + 1.0471975511965976 }, + { 1.8880446720682853, 0.90000000000000013, 0.40000000000000002, + 1.2217304763960306 }, + { 2.4505848932025232, 0.90000000000000013, 0.40000000000000002, + 1.3962634015954636 }, + { 3.1000689868578624, 0.90000000000000013, 0.40000000000000002, + 1.5707963267948966 }, +}; +const double toler185 = 2.5000000000000020e-13; + +// Test data for k=0.90000000000000013, nu=0.50000000000000000. +// max(|f - f_Boost|): 8.8817841970012523e-16 at index 7 +// max(|f - f_Boost| / |f_Boost|): 4.3939646155354115e-16 +// mean(f - f_Boost): 1.5820678100908481e-16 +// variance(f - f_Boost): 1.0089970755557622e-32 +// stddev(f - f_Boost): 1.0044884646205561e-16 +const testcase_ellint_3<double> +data186[10] = +{ + { 0.0000000000000000, 0.90000000000000013, 0.50000000000000000, + 0.0000000000000000 }, + { 0.17614967734498183, 0.90000000000000013, 0.50000000000000000, + 0.17453292519943295 }, + { 0.36231594750319435, 0.90000000000000013, 0.50000000000000000, + 0.34906585039886590 }, + { 0.57016256984349567, 0.90000000000000013, 0.50000000000000000, + 0.52359877559829882 }, + { 0.81494025918293422, 0.90000000000000013, 0.50000000000000000, + 0.69813170079773179 }, + { 1.1178482279283477, 0.90000000000000013, 0.50000000000000000, + 0.87266462599716477 }, + { 1.5081455873012106, 0.90000000000000013, 0.50000000000000000, + 1.0471975511965976 }, + { 2.0213599730863998, 0.90000000000000013, 0.50000000000000000, + 1.2217304763960306 }, + { 2.6822467012926832, 0.90000000000000013, 0.50000000000000000, + 1.3962634015954636 }, + { 3.4591069002104686, 0.90000000000000013, 0.50000000000000000, + 1.5707963267948966 }, +}; +const double toler186 = 2.5000000000000020e-13; + +// Test data for k=0.90000000000000013, nu=0.60000000000000009. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 4.4914274070443813e-16 +// mean(f - f_Boost): 3.4694469519536142e-16 +// variance(f - f_Boost): 2.5224926888894056e-31 +// stddev(f - f_Boost): 5.0224423231027804e-16 +const testcase_ellint_3<double> +data187[10] = +{ + { 0.0000000000000000, 0.90000000000000013, 0.60000000000000009, + 0.0000000000000000 }, + { 0.17633073723493825, 0.90000000000000013, 0.60000000000000009, + 0.17453292519943295 }, + { 0.36386108723492810, 0.90000000000000013, 0.60000000000000009, + 0.34906585039886590 }, + { 0.57597424744716241, 0.90000000000000013, 0.60000000000000009, + 0.52359877559829882 }, + { 0.83098051948501150, 0.90000000000000013, 0.60000000000000009, + 0.69813170079773179 }, + { 1.1558706545698916, 0.90000000000000013, 0.60000000000000009, + 0.87266462599716477 }, + { 1.5905576379415669, 0.90000000000000013, 0.60000000000000009, + 1.0471975511965976 }, + { 2.1875186010215084, 0.90000000000000013, 0.60000000000000009, + 1.2217304763960306 }, + { 2.9885767771316853, 0.90000000000000013, 0.60000000000000009, + 1.3962634015954636 }, + { 3.9549939883570238, 0.90000000000000013, 0.60000000000000009, + 1.5707963267948966 }, +}; +const double toler187 = 2.5000000000000020e-13; + +// Test data for k=0.90000000000000013, nu=0.70000000000000007. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 9 +// max(|f - f_Boost| / |f_Boost|): 5.5442489886293633e-16 +// mean(f - f_Boost): 4.3576253716537392e-16 +// variance(f - f_Boost): 2.2187568928205130e-31 +// stddev(f - f_Boost): 4.7103682370070737e-16 +const testcase_ellint_3<double> +data188[10] = +{ + { 0.0000000000000000, 0.90000000000000013, 0.70000000000000007, + 0.0000000000000000 }, + { 0.17651246700160939, 0.90000000000000013, 0.70000000000000007, + 0.17453292519943295 }, + { 0.36542993547358982, 0.90000000000000013, 0.70000000000000007, + 0.34906585039886590 }, + { 0.58199897877674867, 0.90000000000000013, 0.70000000000000007, + 0.52359877559829882 }, + { 0.84815633587352857, 0.90000000000000013, 0.70000000000000007, + 0.69813170079773179 }, + { 1.1985495623872375, 0.90000000000000013, 0.70000000000000007, + 0.87266462599716477 }, + { 1.6892158134027691, 0.90000000000000013, 0.70000000000000007, + 1.0471975511965976 }, + { 2.4029722191094236, 0.90000000000000013, 0.70000000000000007, + 1.2217304763960306 }, + { 3.4201084941340061, 0.90000000000000013, 0.70000000000000007, + 1.3962634015954636 }, + { 4.6985482312992444, 0.90000000000000013, 0.70000000000000007, + 1.5707963267948966 }, +}; +const double toler188 = 2.5000000000000020e-13; + +// Test data for k=0.90000000000000013, nu=0.80000000000000004. +// max(|f - f_Boost|): 1.7763568394002505e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.9362432595976420e-16 +// mean(f - f_Boost): 3.0531133177191805e-16 +// variance(f - f_Boost): 1.1508025840536076e-32 +// stddev(f - f_Boost): 1.0727546709539920e-16 +const testcase_ellint_3<double> +data189[10] = +{ + { 0.0000000000000000, 0.90000000000000013, 0.80000000000000004, + 0.0000000000000000 }, + { 0.17669487107954862, 0.90000000000000013, 0.80000000000000004, + 0.17453292519943295 }, + { 0.36702314729628421, 0.90000000000000013, 0.80000000000000004, + 0.34906585039886590 }, + { 0.58825099711365492, 0.90000000000000013, 0.80000000000000004, + 0.52359877559829882 }, + { 0.86661711422209031, 0.90000000000000013, 0.80000000000000004, + 0.69813170079773179 }, + { 1.2469779109884802, 0.90000000000000013, 0.80000000000000004, + 0.87266462599716477 }, + { 1.8105469760531578, 0.90000000000000013, 0.80000000000000004, + 1.0471975511965976 }, + { 2.6989505165893752, 0.90000000000000013, 0.80000000000000004, + 1.2217304763960306 }, + { 4.0935213267757433, 0.90000000000000013, 0.80000000000000004, + 1.3962634015954636 }, + { 5.9820740813645727, 0.90000000000000013, 0.80000000000000004, + 1.5707963267948966 }, +}; +const double toler189 = 2.5000000000000020e-13; + +// Test data for k=0.90000000000000013, nu=0.90000000000000002. +// max(|f - f_Boost|): 2.6645352591003757e-15 at index 8 +// max(|f - f_Boost| / |f_Boost|): 4.9577148062669782e-16 +// mean(f - f_Boost): 5.9119376061289588e-16 +// variance(f - f_Boost): 1.7340883003959522e-31 +// stddev(f - f_Boost): 4.1642385863395872e-16 +const testcase_ellint_3<double> +data190[10] = +{ + { 0.0000000000000000, 0.90000000000000013, 0.90000000000000002, + 0.0000000000000000 }, + { 0.17687795394604169, 0.90000000000000013, 0.90000000000000002, + 0.17453292519943295 }, + { 0.36864140434751286, 0.90000000000000013, 0.90000000000000002, + 0.34906585039886590 }, + { 0.59474595366817051, 0.90000000000000013, 0.90000000000000002, + 0.52359877559829882 }, + { 0.88654237226056665, 0.90000000000000013, 0.90000000000000002, + 0.69813170079773179 }, + { 1.3026595810616726, 0.90000000000000013, 0.90000000000000002, + 0.87266462599716477 }, + { 1.9653635459278080, 0.90000000000000013, 0.90000000000000002, + 1.0471975511965976 }, + { 3.1451407527189468, 0.90000000000000013, 0.90000000000000002, + 1.2217304763960306 }, + { 5.3745230680316132, 0.90000000000000013, 0.90000000000000002, + 1.3962634015954636 }, + { 8.9942562031858717, 0.90000000000000013, 0.90000000000000002, + 1.5707963267948966 }, +}; +const double toler190 = 2.5000000000000020e-13; + +template<typename Ret, unsigned int Num> + void + test(const testcase_ellint_3<Ret> (&data)[Num], Ret toler) + { + bool test __attribute__((unused)) = true; + const Ret eps = std::numeric_limits<Ret>::epsilon(); + Ret max_abs_diff = -Ret(1); + Ret max_abs_frac = -Ret(1); + unsigned int num_datum = Num; + for (unsigned int i = 0; i < num_datum; ++i) + { + const Ret f = std::tr1::ellint_3(data[i].k, data[i].nu, + data[i].phi); + const Ret f0 = data[i].f0; + const Ret diff = f - f0; + if (std::abs(diff) > max_abs_diff) + max_abs_diff = std::abs(diff); + if (std::abs(f0) > Ret(10) * eps + && std::abs(f) > Ret(10) * eps) + { + const Ret frac = diff / f0; + if (std::abs(frac) > max_abs_frac) + max_abs_frac = std::abs(frac); + } + } + VERIFY(max_abs_frac < toler); + } -int main(int, char**) -{ - test001<double>(); - test002<double>(); - test003<double>(); - test004<double>(); - test005<double>(); - test006<double>(); - test007<double>(); - test008<double>(); - test009<double>(); - test010<double>(); - test011<double>(); - test012<double>(); - test013<double>(); - test014<double>(); - test015<double>(); - test016<double>(); - test017<double>(); - test018<double>(); - test019<double>(); - test020<double>(); - test021<double>(); - test022<double>(); - test023<double>(); - test024<double>(); - test025<double>(); - test026<double>(); - test027<double>(); - test028<double>(); - test029<double>(); - test030<double>(); - test031<double>(); - test032<double>(); - test033<double>(); - test034<double>(); - test035<double>(); - test036<double>(); - test037<double>(); - test038<double>(); - test039<double>(); - test040<double>(); - test041<double>(); - test042<double>(); - test043<double>(); - test044<double>(); - test045<double>(); - test046<double>(); - test047<double>(); - test048<double>(); - test049<double>(); - test050<double>(); - test051<double>(); - test052<double>(); - test053<double>(); - test054<double>(); - test055<double>(); - test056<double>(); - test057<double>(); - test058<double>(); - test059<double>(); - test060<double>(); - test061<double>(); - test062<double>(); - test063<double>(); - test064<double>(); - test065<double>(); - test066<double>(); - test067<double>(); - test068<double>(); - test069<double>(); - test070<double>(); - test071<double>(); - test072<double>(); - test073<double>(); - test074<double>(); - test075<double>(); - test076<double>(); - test077<double>(); - test078<double>(); - test079<double>(); - test080<double>(); - test081<double>(); - test082<double>(); - test083<double>(); - test084<double>(); - test085<double>(); - test086<double>(); - test087<double>(); - test088<double>(); - test089<double>(); - test090<double>(); - test091<double>(); - test092<double>(); - test093<double>(); - test094<double>(); - test095<double>(); - test096<double>(); - test097<double>(); - test098<double>(); - test099<double>(); - test100<double>(); - test101<double>(); - test102<double>(); - test103<double>(); - test104<double>(); - test105<double>(); - test106<double>(); - test107<double>(); - test108<double>(); - test109<double>(); - test110<double>(); - test111<double>(); - test112<double>(); - test113<double>(); - test114<double>(); - test115<double>(); - test116<double>(); - test117<double>(); - test118<double>(); - test119<double>(); - test120<double>(); - test121<double>(); - test122<double>(); - test123<double>(); - test124<double>(); - test125<double>(); - test126<double>(); - test127<double>(); - test128<double>(); - test129<double>(); - test130<double>(); - test131<double>(); - test132<double>(); - test133<double>(); - test134<double>(); - test135<double>(); - test136<double>(); - test137<double>(); - test138<double>(); - test139<double>(); - test140<double>(); - test141<double>(); - test142<double>(); - test143<double>(); - test144<double>(); - test145<double>(); - test146<double>(); - test147<double>(); - test148<double>(); - test149<double>(); - test150<double>(); - test151<double>(); - test152<double>(); - test153<double>(); - test154<double>(); - test155<double>(); - test156<double>(); - test157<double>(); - test158<double>(); - test159<double>(); - test160<double>(); - test161<double>(); - test162<double>(); - test163<double>(); - test164<double>(); - test165<double>(); - test166<double>(); - test167<double>(); - test168<double>(); - test169<double>(); - test170<double>(); - test171<double>(); - test172<double>(); - test173<double>(); - test174<double>(); - test175<double>(); - test176<double>(); - test177<double>(); - test178<double>(); - test179<double>(); - test180<double>(); - test181<double>(); - test182<double>(); - test183<double>(); - test184<double>(); - test185<double>(); - test186<double>(); - test187<double>(); - test188<double>(); - test189<double>(); - test190<double>(); +int +main() +{ + test(data001, toler001); + test(data002, toler002); + test(data003, toler003); + test(data004, toler004); + test(data005, toler005); + test(data006, toler006); + test(data007, toler007); + test(data008, toler008); + test(data009, toler009); + test(data010, toler010); + test(data011, toler011); + test(data012, toler012); + test(data013, toler013); + test(data014, toler014); + test(data015, toler015); + test(data016, toler016); + test(data017, toler017); + test(data018, toler018); + test(data019, toler019); + test(data020, toler020); + test(data021, toler021); + test(data022, toler022); + test(data023, toler023); + test(data024, toler024); + test(data025, toler025); + test(data026, toler026); + test(data027, toler027); + test(data028, toler028); + test(data029, toler029); + test(data030, toler030); + test(data031, toler031); + test(data032, toler032); + test(data033, toler033); + test(data034, toler034); + test(data035, toler035); + test(data036, toler036); + test(data037, toler037); + test(data038, toler038); + test(data039, toler039); + test(data040, toler040); + test(data041, toler041); + test(data042, toler042); + test(data043, toler043); + test(data044, toler044); + test(data045, toler045); + test(data046, toler046); + test(data047, toler047); + test(data048, toler048); + test(data049, toler049); + test(data050, toler050); + test(data051, toler051); + test(data052, toler052); + test(data053, toler053); + test(data054, toler054); + test(data055, toler055); + test(data056, toler056); + test(data057, toler057); + test(data058, toler058); + test(data059, toler059); + test(data060, toler060); + test(data061, toler061); + test(data062, toler062); + test(data063, toler063); + test(data064, toler064); + test(data065, toler065); + test(data066, toler066); + test(data067, toler067); + test(data068, toler068); + test(data069, toler069); + test(data070, toler070); + test(data071, toler071); + test(data072, toler072); + test(data073, toler073); + test(data074, toler074); + test(data075, toler075); + test(data076, toler076); + test(data077, toler077); + test(data078, toler078); + test(data079, toler079); + test(data080, toler080); + test(data081, toler081); + test(data082, toler082); + test(data083, toler083); + test(data084, toler084); + test(data085, toler085); + test(data086, toler086); + test(data087, toler087); + test(data088, toler088); + test(data089, toler089); + test(data090, toler090); + test(data091, toler091); + test(data092, toler092); + test(data093, toler093); + test(data094, toler094); + test(data095, toler095); + test(data096, toler096); + test(data097, toler097); + test(data098, toler098); + test(data099, toler099); + test(data100, toler100); + test(data101, toler101); + test(data102, toler102); + test(data103, toler103); + test(data104, toler104); + test(data105, toler105); + test(data106, toler106); + test(data107, toler107); + test(data108, toler108); + test(data109, toler109); + test(data110, toler110); + test(data111, toler111); + test(data112, toler112); + test(data113, toler113); + test(data114, toler114); + test(data115, toler115); + test(data116, toler116); + test(data117, toler117); + test(data118, toler118); + test(data119, toler119); + test(data120, toler120); + test(data121, toler121); + test(data122, toler122); + test(data123, toler123); + test(data124, toler124); + test(data125, toler125); + test(data126, toler126); + test(data127, toler127); + test(data128, toler128); + test(data129, toler129); + test(data130, toler130); + test(data131, toler131); + test(data132, toler132); + test(data133, toler133); + test(data134, toler134); + test(data135, toler135); + test(data136, toler136); + test(data137, toler137); + test(data138, toler138); + test(data139, toler139); + test(data140, toler140); + test(data141, toler141); + test(data142, toler142); + test(data143, toler143); + test(data144, toler144); + test(data145, toler145); + test(data146, toler146); + test(data147, toler147); + test(data148, toler148); + test(data149, toler149); + test(data150, toler150); + test(data151, toler151); + test(data152, toler152); + test(data153, toler153); + test(data154, toler154); + test(data155, toler155); + test(data156, toler156); + test(data157, toler157); + test(data158, toler158); + test(data159, toler159); + test(data160, toler160); + test(data161, toler161); + test(data162, toler162); + test(data163, toler163); + test(data164, toler164); + test(data165, toler165); + test(data166, toler166); + test(data167, toler167); + test(data168, toler168); + test(data169, toler169); + test(data170, toler170); + test(data171, toler171); + test(data172, toler172); + test(data173, toler173); + test(data174, toler174); + test(data175, toler175); + test(data176, toler176); + test(data177, toler177); + test(data178, toler178); + test(data179, toler179); + test(data180, toler180); + test(data181, toler181); + test(data182, toler182); + test(data183, toler183); + test(data184, toler184); + test(data185, toler185); + test(data186, toler186); + test(data187, toler187); + test(data188, toler188); + test(data189, toler189); + test(data190, toler190); return 0; } diff --git a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/14_ellint_3/pr66689.cc b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/14_ellint_3/pr66689.cc new file mode 100644 index 00000000000..1ee5f4f07f4 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/14_ellint_3/pr66689.cc @@ -0,0 +1,22 @@ + +#include <tr1/cmath> +#include <testsuite_hooks.h> + +void +test01() +{ + const double pi = 3.141592654; + + double Pi1 = std::tr1::ellint_3(0.75, 0.0, pi / 2.0); + VERIFY(std::abs(Pi1 - 1.91099) < 0.00001); + + double Pi2 = std::tr1::ellint_3(0.75, 0.5, pi / 2.0); + VERIFY(std::abs(Pi2 - 2.80011) < 0.00001); +} + +int +main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/15_expint/pr68397.cc b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/15_expint/pr68397.cc new file mode 100644 index 00000000000..60d0b68bad6 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/15_expint/pr68397.cc @@ -0,0 +1,46 @@ +// Copyright (C) 2017 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// PR libstdc++/68397 - std::tr1::expint fails in __expint_En_cont_frac +// for some long double arguments due to low __max_iter value + +#include <tr1/cmath> +#include <testsuite_hooks.h> + +void +test01() +{ + // Answers from Wolfram Alpha. + long double ans_ok = -0.10001943365331651406888645149537315243646135979573L; + long double ans_bomb = -0.10777727809650077516264612749163100483995270163783L; + + long double Ei_ok = std::tr1::expint(-1.500001L); + long double diff_ok = std::abs(Ei_ok - ans_ok); + VERIFY(diff_ok < 1.0e-15L); + + long double Ei_bomb = std::tr1::expint(-1.450001L); + long double diff_bomb = std::abs(Ei_bomb - ans_bomb); + VERIFY(diff_bomb < 1.0e-15L); +} + +int +main() +{ + test01(); + return 0; +} + |