def run(target_dir):
f = join_open(reference_tables_directory, "fpwide.tbl", "r")
tables_wide = collect_tables(f, 0)
f.close()
f = join_open(reference_tables_directory, "fpk.tbl", "r")
tables_k = collect_tables(f, 1)
f.close()
f = join_open(reference_tables_directory, "fpl.tbl", "r")
tables_l = collect_tables(f, 1)
f.close()
tables_combined = combine_tables(tables_wide, tables_k, tables_l)
f = join_open(target_dir, "sasaki.cpp", "w")
print_header(f)
print_ftp_info(f)
print_sasaki_cpp(f, tables_combined)
f.close()
block_size = 12
for i_begin in range(0, len(tables_combined), block_size):
i_end = min(len(tables_combined), i_begin + block_size)
f = join_open(target_dir,
"sasaki_tables_%02d_%02d.cpp" % (i_begin + 1, i_end),
"w")
print_header(f)
print_table_block(f, tables_combined, i_begin, i_end)
f.close()
def one_type(target_dir, subs):
array_type = subs["array_type"]
subs["array_type_plain"] = array_type + "_plain"
subs["ARRAY_TYPE"] = array_type.upper()
f = utils.join_open(target_dir, "%s_reductions.h" % array_type, "w")
utils.write_this_is_auto_generated(f, this)
print >> f, substitute(subs, """
#ifndef SCITBX_ARRAY_FAMILY_${ARRAY_TYPE}_REDUCTIONS_H
#define SCITBX_ARRAY_FAMILY_${ARRAY_TYPE}_REDUCTIONS_H
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include <scitbx/array_family/ref_reductions.h>
#include <scitbx/array_family/${array_type_plain}.h>
namespace scitbx { namespace af {
""")
generate_order(f, subs)
generate_max_index_etc(f, subs)
generate_max_etc(f, subs)
generate_mean_weighted_etc(f, subs)
generate_first_index_etc(f, subs)
print >> f, substitute(subs, """
}} // namespace scitbx::af
#endif // DOXYGEN_SHOULD_SKIP_THIS
#endif // SCITBX_ARRAY_FAMILY_${ARRAY_TYPE}_REDUCTIONS_H
""")
f.close()
def one_type(target_dir, array_type_name):
f = utils.join_open(target_dir, "%s_apply.h" % array_type_name, "w")
utils.write_this_is_auto_generated(f, this)
include_array_type_name = array_type_name
if (array_type_name == "ref"):
include_array_type_name = "versa"
generic_include = "functors"
if (generate_algebras.base_array_type_name(array_type_name) == "tiny"):
generic_include = "operators"
print("""\
#ifndef SCITBX_ARRAY_FAMILY_%s_APPLY_H
#define SCITBX_ARRAY_FAMILY_%s_APPLY_H
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include <scitbx/type_holder.h>
#include <scitbx/array_family/%s.h>
#include <scitbx/array_family/detail/generic_array_%s.h>
namespace scitbx { namespace af {
""" % ((array_type_name.upper(),) * 2 + (
include_array_type_name, generic_include)), file=f)
generate_algebras.generate_unary_apply(f, array_type_name)
print("""}} // namespace scitbx::af
#endif // DOXYGEN_SHOULD_SKIP_THIS
#endif // SCITBX_ARRAY_FAMILY_%s_APPLY_H""" % (array_type_name.upper(),), file=f)
f.close()
def run(target_dir):
tables = collect_tables()
compare_points(tables) # establish that each list of data points is unique
f = join_open(target_dir, "henke.cpp", "w")
print_header(f)
print_ftp_info(f)
print_henke_cpp(f, tables)
f.close()
Z_block = 12
for Z_begin in range(1, len(tables), Z_block):
Z_end = min(len(tables), Z_begin + Z_block)
f = join_open(target_dir,
"henke_tables_%02d_%02d.cpp" % (Z_begin, Z_end - 1), "w")
print_header(f)
print_table_block(f, tables, Z_begin, Z_end)
f.close()
def collect_tables():
nff_files = []
for file in os.listdir(reference_tables_directory):
fn = file.lower().capitalize()
if (fn[-4:] == ".nff"): nff_files.append(file)
tables = [0] * 120
for file in nff_files:
f = join_open(reference_tables_directory, file, "r")
header = f.readline()
table = f.readlines()
f.close()
Symbol = header[1:3].strip()
Z = int(header[7:9])
assert len(Symbol) > 0
assert Symbol[0] in 'abcdefghijklmnopqrstuvwxyz'
assert Symbol[-1] in 'abcdefghijklmnopqrstuvwxyz'
assert Z > 0 and Z < len(tables)
assert tables[Z] == 0
Symbol = Symbol.capitalize()
tables[Z] = (Symbol, table)
Z = tables[1:].index(0) + 1
rest = tables[Z:]
assert rest == [0] * len(rest)
tables = tables[:Z]
return tables
def one_type(target_dir, array_type_name):
f = utils.join_open(target_dir, "%s_apply.h" % array_type_name, "w")
utils.write_this_is_auto_generated(f, this)
include_array_type_name = array_type_name
if (array_type_name == "ref"):
include_array_type_name = "versa"
generic_include = "functors"
if (generate_algebras.base_array_type_name(array_type_name) == "tiny"):
generic_include = "operators"
print >> f, """\
#ifndef SCITBX_ARRAY_FAMILY_%s_APPLY_H
#define SCITBX_ARRAY_FAMILY_%s_APPLY_H
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include <scitbx/type_holder.h>
#include <scitbx/array_family/%s.h>
#include <scitbx/array_family/detail/generic_array_%s.h>
namespace scitbx { namespace af {
""" % ((array_type_name.upper(),) * 2 + (
include_array_type_name, generic_include))
generate_algebras.generate_unary_apply(f, array_type_name)
print >> f, """}} // namespace scitbx::af
#endif // DOXYGEN_SHOULD_SKIP_THIS
#endif // SCITBX_ARRAY_FAMILY_%s_APPLY_H""" % (array_type_name.upper(),)
f.close()
def one_type(target_dir, subs):
array_type = subs["array_type"]
subs["array_type_plain"] = array_type + "_plain"
subs["ARRAY_TYPE"] = array_type.upper()
f = utils.join_open(target_dir, "%s_reductions.h" % array_type, "w")
utils.write_this_is_auto_generated(f, this)
print >> f, substitute(
subs, """
#ifndef SCITBX_ARRAY_FAMILY_${ARRAY_TYPE}_REDUCTIONS_H
#define SCITBX_ARRAY_FAMILY_${ARRAY_TYPE}_REDUCTIONS_H
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include <scitbx/array_family/ref_reductions.h>
#include <scitbx/array_family/${array_type_plain}.h>
namespace scitbx { namespace af {
""")
generate_order(f, subs)
generate_max_index_etc(f, subs)
generate_max_etc(f, subs)
generate_mean_weighted_etc(f, subs)
generate_first_index_etc(f, subs)
print >> f, substitute(
subs, """
}} // namespace scitbx::af
#endif // DOXYGEN_SHOULD_SKIP_THIS
#endif // SCITBX_ARRAY_FAMILY_${ARRAY_TYPE}_REDUCTIONS_H
""")
f.close()
def collect_tables():
nff_files = []
for file in os.listdir(reference_tables_directory):
fn = file.lower().capitalize()
if (fn[-4:] == ".nff"): nff_files.append(file)
tables = [0] * 120
for file in nff_files:
f = join_open(reference_tables_directory, file, "r")
header = f.readline()
table = f.readlines()
f.close()
Symbol = header[1:3].strip()
Z = int(header[7:9])
assert len(Symbol) > 0
assert Symbol[0] in string.lowercase
assert Symbol[-1] in string.lowercase
assert Z > 0 and Z < len(tables)
assert tables[Z] == 0
Symbol = Symbol.capitalize()
tables[Z] = (Symbol, table)
Z = tables[1:].index(0) + 1
rest = tables[Z:]
assert rest == [0] * len(rest)
tables = tables[:Z]
return tables
def run(target_dir):
tables = collect_tables()
compare_points(tables) # establish that each list of data points is unique
f = join_open(target_dir, "henke.cpp", "w")
print_header(f)
print_ftp_info(f)
print_henke_cpp(f, tables)
f.close()
Z_block = 12
for Z_begin in xrange(1, len(tables), Z_block):
Z_end = min(len(tables), Z_begin + Z_block)
f = join_open(
target_dir, "henke_tables_%02d_%02d.cpp" % (Z_begin, Z_end-1), "w")
print_header(f)
print_table_block(f, tables, Z_begin, Z_end)
f.close()
def write(this, target_dir, common_code, full_code):
f = join_open(target_dir, "flex_fwd.h", "w")
write_this_is_auto_generated(f, this)
if (libtbx.env.build_options.write_full_flex_fwd_h):
code = full_code % motivation
else:
code = ""
f.write(common_code % code)
def write(this, target_dir, common_code, full_code):
f = join_open(target_dir, "flex_fwd.h", "w")
write_this_is_auto_generated(f, this)
if (libtbx.env.build_options.write_full_flex_fwd_h):
code = full_code % motivation
else:
code = ""
f.write(common_code % code)
def run(target_dir):
f = join_open(reference_tables_directory, "fpwide.tbl", "r")
tables_wide = collect_tables(f, 0)
f.close()
f = join_open(reference_tables_directory, "fpk.tbl", "r")
tables_k = collect_tables(f, 1)
f.close()
f = join_open(reference_tables_directory, "fpl.tbl", "r")
tables_l = collect_tables(f, 1)
f.close()
tables_combined = combine_tables(tables_wide, tables_k, tables_l)
f = join_open(target_dir, "sasaki.cpp", "w")
print_header(f)
print_ftp_info(f)
print_sasaki_cpp(f, tables_combined)
f.close()
block_size = 12
for i_begin in xrange(0, len(tables_combined), block_size):
i_end = min(len(tables_combined), i_begin + block_size)
f = join_open(target_dir, "sasaki_tables_%02d_%02d.cpp" % (i_begin + 1, i_end), "w")
print_header(f)
print_table_block(f, tables_combined, i_begin, i_end)
f.close()
def run(target_dir):
op_types, result_type = build_pairs()
assert len(op_types) == len(result_type)
if ("--Raw" in sys.argv):
for i, optype in enumerate(op_types):
print("%s + %s = %s" % (optype[0], optype[1], result_type[i]),
file=f)
else:
f = utils.join_open(target_dir, "operator_traits_builtin.h", "w")
utils.write_this_is_auto_generated(f, this)
print("""\
#ifndef SCITBX_ARRAY_FAMILY_OPERATOR_TRAITS_BUILTIN_H
#define SCITBX_ARRAY_FAMILY_OPERATOR_TRAITS_BUILTIN_H
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include <complex>
namespace scitbx { namespace af {
// The default traits: the result type is the type of the lhs argument.
template<typename TypeLHS, typename TypeRHS>
struct binary_operator_traits {
typedef TypeLHS arithmetic;
};
// The remainder of this file defines the traits where the
// result type is the type of the rhs argument.
""",
file=f)
for i, optype in enumerate(op_types):
if (result_type[i]):
print(""" template<>
struct binary_operator_traits<%s, %s > {
typedef %s arithmetic;
};
""" % (optype[0], optype[1], result_type[i]),
file=f)
print("}} // namespace scitbx::af", file=f)
print(file=f)
print("#endif // DOXYGEN_SHOULD_SKIP_THIS", file=f)
print(file=f)
print("#endif // SCITBX_ARRAY_FAMILY_OPERATOR_TRAITS_BUILTIN_H",
file=f)
f.close()
def run(target_dir):
op_types, result_type = build_pairs()
assert len(op_types) == len(result_type)
if ("--Raw" in sys.argv):
for i in xrange(len(op_types)):
print >> f, "%s + %s = %s" % (
op_types[i].lhs, op_types[i].rhs, result_type[i])
else:
f = utils.join_open(target_dir, "operator_traits_builtin.h", "w")
utils.write_this_is_auto_generated(f, this)
print >> f, """\
#ifndef SCITBX_ARRAY_FAMILY_OPERATOR_TRAITS_BUILTIN_H
#define SCITBX_ARRAY_FAMILY_OPERATOR_TRAITS_BUILTIN_H
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include <complex>
namespace scitbx { namespace af {
// The default traits: the result type is the type of the lhs argument.
template<typename TypeLHS, typename TypeRHS>
struct binary_operator_traits {
typedef TypeLHS arithmetic;
};
// The remainder of this file defines the traits where the
// result type is the type of the rhs argument.
"""
for i in xrange(len(op_types)):
if (result_type[i]):
print >> f, """ template<>
struct binary_operator_traits<%s, %s > {
typedef %s arithmetic;
};
""" % (op_types[i].lhs, op_types[i].rhs, result_type[i])
print >> f, "}} // namespace scitbx::af"
print >> f
print >> f, "#endif // DOXYGEN_SHOULD_SKIP_THIS"
print >> f
print >> f, "#endif // SCITBX_ARRAY_FAMILY_OPERATOR_TRAITS_BUILTIN_H"
f.close()
def run(target_dir):
f = utils.join_open(target_dir, "detail/std_imports.h", "w")
utils.write_this_is_auto_generated(f, this)
print("""\
#ifndef SCITBX_ARRAY_FAMILY_STD_IMPORTS_H
#define SCITBX_ARRAY_FAMILY_STD_IMPORTS_H
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include <cmath>
#include <cstdlib>
#include <complex>
namespace scitbx { namespace fn {
""",
file=f)
all_function_names = []
for function_name in (cmath_1arg + cmath_2arg + cstdlib_1arg +
algorithm_2arg + complex_1arg):
if (not function_name in all_function_names):
all_function_names.append(function_name)
for entry in complex_special:
function_name = entry[1]
if (not function_name in all_function_names):
all_function_names.append(function_name)
for function_name in all_function_names:
print(" using std::" + filter_function_name(function_name) + ";",
file=f)
generate_1arg(f)
generate_2arg(f)
print("""
}} // namespace scitbx::af
#endif // DOXYGEN_SHOULD_SKIP_THIS
#endif // SCITBX_ARRAY_FAMILY_STD_IMPORTS_H""",
file=f)
f.close()
def run(target_dir):
f = utils.join_open(target_dir, "detail/operator_functors.h", "w")
utils.write_this_is_auto_generated(f, this)
print >> f, """\
#ifndef SCITBX_ARRAY_FAMILY_OPERATOR_FUNCTORS_H
#define SCITBX_ARRAY_FAMILY_OPERATOR_FUNCTORS_H
namespace scitbx { namespace fn {"""
for op, ftor_name in operator_functor_info.unary_functors.items():
generate_unary(f, ftor_name, op + "x")
for op, ftor_name in operator_functor_info.binary_functors.items():
generate_binary(f, ftor_name, "x " + op + " y")
for op, ftor_name in operator_functor_info.in_place_binary_functors.items():
generate_in_place_binary(f, ftor_name, "x " + op + " y")
print >> f, """
}} // namespace scitbx::fn
#endif // SCITBX_ARRAY_FAMILY_OPERATOR_FUNCTORS_H"""
f.close()
def run(target_dir):
f = utils.join_open(target_dir, "detail/std_imports.h", "w")
utils.write_this_is_auto_generated(f, this)
print >> f, """\
#ifndef SCITBX_ARRAY_FAMILY_STD_IMPORTS_H
#define SCITBX_ARRAY_FAMILY_STD_IMPORTS_H
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include <cmath>
#include <cstdlib>
#include <complex>
namespace scitbx { namespace fn {
"""
all_function_names = []
for function_name in (cmath_1arg + cmath_2arg + cstdlib_1arg
+ algorithm_2arg + complex_1arg):
if (not function_name in all_function_names):
all_function_names.append(function_name)
for entry in complex_special:
function_name = entry[1]
if (not function_name in all_function_names):
all_function_names.append(function_name)
for function_name in all_function_names:
print >> f, " using std::" + filter_function_name(function_name) + ";"
generate_1arg(f)
generate_2arg(f)
print >> f, """
}} // namespace scitbx::af
#endif // DOXYGEN_SHOULD_SKIP_THIS
#endif // SCITBX_ARRAY_FAMILY_STD_IMPORTS_H"""
f.close()
def run(target_dir):
f = utils.join_open(target_dir, "detail/operator_functors.h", "w")
utils.write_this_is_auto_generated(f, this)
print >> f, """\
#ifndef SCITBX_ARRAY_FAMILY_OPERATOR_FUNCTORS_H
#define SCITBX_ARRAY_FAMILY_OPERATOR_FUNCTORS_H
namespace scitbx { namespace fn {"""
for op, ftor_name in operator_functor_info.unary_functors.items():
generate_unary(f, ftor_name, op + "x")
for op, ftor_name in operator_functor_info.binary_functors.items():
generate_binary(f, ftor_name, "x " + op + " y")
for op, ftor_name in operator_functor_info.in_place_binary_functors.items(
):
generate_in_place_binary(f, ftor_name, "x " + op + " y")
print >> f, """
}} // namespace scitbx::fn
#endif // SCITBX_ARRAY_FAMILY_OPERATOR_FUNCTORS_H"""
f.close()
def run(dr):
f = join_open(dr, "reference_table.cpp", "w")
s1md5 = make_md5("sgtbx/direct_space_asu/reference_table.py")
s2md5 = make_md5("sgtbx/direct_space_asu/proto/generate_cpp_asu_table.py")
s3md5 = make_md5("sgtbx/direct_space_asu/short_cuts.py")
print s1md5, '\n', s2md5, '\n', s3md5
print >> f, head1
# comma in print adds one whitespace between parameters
# so it is better to use + to concatanete strings
# to avoid trailing white spaces
print >> f, "////////////////\n" + s1md5 + "\n" + s2md5 + "\n" + s3md5 + "\n////////////////\n"
print >> f, head2
table = "asu_func asu_table[230] = {"
i = 0
for sg in xrange(1, 231):
if (i % 8 == 0):
table += "\n "
func = show_cpp(sg, f)
table += " "
table += func
if i < 229:
table += ","
i += 1
print >> f, "} // end of unnamed namespace\n\n" + table + "\n};\n\n}}}\n"
def run(dr):
f = join_open(dr, "reference_table.cpp", "w")
s1md5 = make_md5("sgtbx/direct_space_asu/reference_table.py")
s2md5 = make_md5("sgtbx/direct_space_asu/proto/generate_cpp_asu_table.py")
s3md5 = make_md5("sgtbx/direct_space_asu/short_cuts.py")
print s1md5, "\n", s2md5, "\n", s3md5
print >> f, head1
# comma in print adds one whitespace between parameters
# so it is better to use + to concatanete strings
# to avoid trailing white spaces
print >> f, "////////////////\n" + s1md5 + "\n" + s2md5 + "\n" + s3md5 + "\n////////////////\n"
print >> f, head2
table = "asu_func asu_table[230] = {"
i = 0
for sg in xrange(1, 231):
if i % 8 == 0:
table += "\n "
func = show_cpp(sg, f)
table += " "
table += func
if i < 229:
table += ","
i += 1
print >> f, "} // end of unnamed namespace\n\n" + table + "\n};\n\n}}}\n"
def one_type(target_dir, array_type_name):
f = utils.join_open(target_dir, "%s_algebra.h" % array_type_name, "w")
utils.write_this_is_auto_generated(f, this)
include_array_type_name = array_type_name
if (array_type_name == "ref"):
include_array_type_name = "versa"
generic_include = "functors"
if (base_array_type_name(array_type_name) == "tiny"):
generic_include = "operators"
print >> f, """\
#ifndef SCITBX_ARRAY_FAMILY_%s_ALGEBRA_H
#define SCITBX_ARRAY_FAMILY_%s_ALGEBRA_H
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include <scitbx/array_family/%s.h>
""" % ((array_type_name.upper(),) * 2 + (include_array_type_name,))
if (array_type_name == "small"):
print >> f, """#if (defined(BOOST_MSVC) && BOOST_MSVC <= 1300) // VC++ 7.0
#define SCITBX_ARRAY_FAMILY_SMALL_ALGEBRA_MIN_N1_N2 N1
#else
#define SCITBX_ARRAY_FAMILY_SMALL_ALGEBRA_MIN_N1_N2 (N1<N2?N1:N2)
#endif
"""
print >> f, """#include <scitbx/array_family/operator_traits_builtin.h>
#include <scitbx/array_family/detail/operator_functors.h>
#include <scitbx/array_family/detail/generic_array_%s.h>
#include <scitbx/array_family/detail/std_imports.h>
#include <scitbx/array_family/misc_functions.h>
namespace scitbx { namespace af {
""" % (generic_include,)
generate_unary_ops(f, array_type_name)
for op_symbol in operator_functor_info.arithmetic_binary_ops:
generate_elementwise_binary_op(f,
array_type_name, "arithmetic", op_symbol)
generate_elementwise_inplace_binary_op(f,
array_type_name, "arithmetic", op_symbol + "=")
for op_symbol in operator_functor_info.logical_binary_ops:
generate_elementwise_binary_op(f,
array_type_name, "logical", op_symbol)
for op_symbol in operator_functor_info.boolean_binary_ops:
generate_elementwise_binary_op(f,
array_type_name, "boolean", op_symbol)
generate_1arg_element_wise(f,
array_type_name,
misc_functions_a
+ generate_std_imports.cmath_1arg
+ generate_std_imports.cstdlib_1arg
+ generate_std_imports.complex_1arg)
generate_2arg_element_wise(f,
array_type_name,
misc_functions_a_a
+ generate_std_imports.cmath_2arg
+ generate_std_imports.algorithm_2arg)
for special_def in generate_std_imports.complex_special:
generate_element_wise_special(f, array_type_name, special_def)
for args in misc_functions_x_x_s:
apply(generate_x_x_s_element_wise, (f, array_type_name) + args)
print >> f, "}} // namespace scitbx::af"
print >> f
print >> f, "#endif // DOXYGEN_SHOULD_SKIP_THIS"
print >> f
print >> f, "#endif // SCITBX_ARRAY_FAMILY_%s_ALGEBRA_H" % (
array_type_name.upper(),)
f.close()
def one_type(target_dir, array_type_name):
f = utils.join_open(target_dir, "%s_algebra.h" % array_type_name, "w")
utils.write_this_is_auto_generated(f, this)
include_array_type_name = array_type_name
if (array_type_name == "ref"):
include_array_type_name = "versa"
generic_include = "functors"
if (base_array_type_name(array_type_name) == "tiny"):
generic_include = "operators"
print("""\
#ifndef SCITBX_ARRAY_FAMILY_%s_ALGEBRA_H
#define SCITBX_ARRAY_FAMILY_%s_ALGEBRA_H
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include <scitbx/array_family/%s.h>
""" % ((array_type_name.upper(), ) * 2 + (include_array_type_name, )),
file=f)
if (array_type_name == "small"):
print("""#if (defined(BOOST_MSVC) && BOOST_MSVC <= 1300) // VC++ 7.0
#define SCITBX_ARRAY_FAMILY_SMALL_ALGEBRA_MIN_N1_N2 N1
#else
#define SCITBX_ARRAY_FAMILY_SMALL_ALGEBRA_MIN_N1_N2 (N1<N2?N1:N2)
#endif
""",
file=f)
print("""#include <scitbx/array_family/operator_traits_builtin.h>
#include <scitbx/array_family/detail/operator_functors.h>
#include <scitbx/array_family/detail/generic_array_%s.h>
#include <scitbx/array_family/detail/std_imports.h>
#include <scitbx/array_family/misc_functions.h>
namespace scitbx { namespace af {
""" % (generic_include, ),
file=f)
generate_unary_ops(f, array_type_name)
for op_symbol in operator_functor_info.arithmetic_binary_ops:
generate_elementwise_binary_op(f, array_type_name, "arithmetic",
op_symbol)
generate_elementwise_inplace_binary_op(f, array_type_name,
"arithmetic", op_symbol + "=")
for op_symbol in operator_functor_info.logical_binary_ops:
generate_elementwise_binary_op(f, array_type_name, "logical",
op_symbol)
for op_symbol in operator_functor_info.boolean_binary_ops:
generate_elementwise_binary_op(f, array_type_name, "boolean",
op_symbol)
generate_1arg_element_wise(
f, array_type_name,
misc_functions_a + generate_std_imports.cmath_1arg +
generate_std_imports.cstdlib_1arg + generate_std_imports.complex_1arg)
generate_2arg_element_wise(
f, array_type_name, misc_functions_a_a +
generate_std_imports.cmath_2arg + generate_std_imports.algorithm_2arg)
for special_def in generate_std_imports.complex_special:
generate_element_wise_special(f, array_type_name, special_def)
for args in misc_functions_x_x_s:
generate_x_x_s_element_wise(*(f, array_type_name) + args)
print("}} // namespace scitbx::af", file=f)
print(file=f)
print("#endif // DOXYGEN_SHOULD_SKIP_THIS", file=f)
print(file=f)
print("#endif // SCITBX_ARRAY_FAMILY_%s_ALGEBRA_H" %
(array_type_name.upper(), ),
file=f)
f.close()
