mmx Namespace Reference

Classes

• class REP_STRUCT
• class alias
• class global_alias_rep
• class basic_alias_rep
• class generic_alias
• struct type_information< alias< C > >
• struct type_information< generic_alias< C > >
• class alias_unary_access_rep
• class alias_binary_access_rep
• struct rep_struct
• struct fixed_value
• struct variable_value
• struct local_value
• struct vector_variant_helper
• struct uniform_threshold
• struct threshold_helper
• struct threshold_helper< C, uniform_threshold< n > >
• struct threshold_helper_1
• struct threshold_helper_1< C, uniform_threshold< n > >
• class cache
• struct boolean_helper
• struct always
• struct never
• struct both_helper
• struct both
• struct different_helper
• struct different_helper< T1, T1 >
• struct different
• struct has
• struct has< generic, Op >
• struct ring_cat
• struct euclidean_ring_cat
• struct field_cat
• struct factorial_cat
• struct elementary_cat
• struct ordering_cat
• struct complex_cat
• struct ball_cat
• class chain_rep
• class chain
• struct binary_helper< chain< C > >
• class compound
• struct binary_helper< compound >
• struct inspector< compound >
• struct xgcd_matrix
• struct invalidator_1_rep
• struct dispatcher_1_rep
• struct dispatcher_1
• struct invalidator_2_rep
• struct dispatcher_2_rep
• struct dispatcher_2
• class document
• struct binary_helper< document >
• class observer_rep
• class observer
• class dynamic_rep
• class dynamic
• class evaluator_rep
• class evaluator
• class exception
• class mutex
• struct mutex_lock
• struct argument_helper
• struct argument_helper< T & >
• struct argument_helper< T * >
• struct argument_helper< const T & >
• struct argument_helper< const T * >
• struct function_0_rep
• struct def_function_0_rep
• struct function_0
• struct function_1_rep
• struct def_function_1_rep
• struct function_1
• struct format_function_helper
• struct format_function_helper< FT, C, C, Fun >
• struct format_function_helper< empty_format, R, C, Fun >
• struct format_function_helper< empty_format, C, C, Fun >
• struct function_2_rep
• struct def_function_2_rep
• struct function_2
• struct function_3_rep
• struct def_function_3_rep
• struct function_3
• struct function_4_rep
• struct def_function_4_rep
• struct function_4
• struct function_5_rep
• struct def_function_5_rep
• struct function_5
• struct function_6_rep
• struct def_function_6_rep
• struct function_6
• struct function_7_rep
• struct def_function_7_rep
• struct function_7
• struct function_8_rep
• struct def_function_8_rep
• struct function_8
• class generic_rep
• class generic
• struct type_information
• struct type_information< generic >
• struct symbolic_type_information
• struct species_type_information
• struct accelerator
• class generic_concrete_rep
• struct as_helper< generic, C >
• struct as_helper< C, generic >
• struct as_helper< generic, generic >
• struct generic_function_rep
• struct generic_function
• struct nil_function_rep
• struct define_type_helper
• class heap_rep
• class heap
• class heap_iterator_rep
• struct binary_helper< heap< C > >
• class instance
• struct constructor_0
• struct constructor_1
• struct constructor_2
• struct constructor_3
• class local_instance_type
• struct unsigned_int_with_size_at_least_helper

  Get int type of size at least s, void if impossible. More...
  

• struct unsigned_int_with_double_size_helper

  Get int with double size. More...
  

• struct signed_of_helper

  Get the corresponding signed integer type. More...
  

• struct signed_of_helper< double >
• struct signed_of_helper< char >
• struct signed_of_helper< signed char >
• struct signed_of_helper< short int >
• struct signed_of_helper< int >
• struct signed_of_helper< long int >
• struct signed_of_helper< long long int >
• struct signed_of_helper< unsigned char >
• struct signed_of_helper< short unsigned int >
• struct signed_of_helper< unsigned int >
• struct signed_of_helper< long unsigned int >
• struct signed_of_helper< long long unsigned int >
• struct unsigned_of_helper

  Get the unsigned corresponding integer type. More...
  

• struct unsigned_of_helper< char >
• struct unsigned_of_helper< signed char >
• struct unsigned_of_helper< short int >
• struct unsigned_of_helper< int >
• struct unsigned_of_helper< long int >
• struct unsigned_of_helper< long long int >
• struct unsigned_of_helper< unsigned char >
• struct unsigned_of_helper< short unsigned int >
• struct unsigned_of_helper< unsigned int >
• struct unsigned_of_helper< long unsigned int >
• struct unsigned_of_helper< long long unsigned int >
• struct is_signed_helper

  Tell if the integer type is signed. More...
  

• struct is_signed_helper< signed char >
• struct is_signed_helper< char >
• struct is_signed_helper< short int >
• struct is_signed_helper< int >
• struct is_signed_helper< long int >
• struct is_signed_helper< long long int >
• struct int_bitsize_helper_rec

  Store the bitsize of abs (p) in field value. More...
  

• struct int_bitsize_helper_rec< uC, 1, x >
• struct int_bitsize_helper_rec< uC, 0, x >
• struct int_bitsize_helper
• class long_int_mul_op
• struct long_int_rshift_op
• struct long_int_lshift_op
• struct long_int_sub_op
• struct long_int_ge_op
• struct int_floor_sqrt_helper
• struct unsigned_int_floor_sqrt_helper
• struct int_gcd_helper
• struct unsigned_int_gcd_helper
• struct int_reconstruct_helper
• struct unsigned_int_reconstruct_helper
• struct unsigned_stdint_of_size_at_least_helper
• struct signed_stdint_of_size_at_least_helper
• struct stdint_of_helper
• class iterator_rep
• class iterator
• struct format< iterator< C > >
• struct binary_helper< iterator< C > >
• class as_iterator_rep
• struct as_helper< iterator< C >, iterator< S > >
• class finite_iterator_rep
• class range_iterator_rep
• class join_iterator_rep
• class lazy_iterator_rep
• class list_rep
• class list
• struct species_type_information< list< C > >
• struct as_helper< list< T >, list< F > >
• class list_iterator_rep
• struct binary_helper< list< C > >
• class literal
• struct binary_helper< literal >
• struct std_memoizer
• struct exact_eq_memoizer
• struct equal_memoizer
• struct memoizer
• struct verbose_as_helper
• struct verbose_as_helper< generic, generic >
• class lift_iterator_rep
• class lift_arg_iterator_rep
• class where_iterator_rep
• class filter_iterator_rep
• class unnest_iterator_rep
• struct Indirect
• class new_table_rep
• class new_table
• struct species_type_information< new_table< C, T, V > >
• struct as_helper< new_table< D, T >, new_table< C, T > >
• class new_entries_iterator_rep
• class new_table_iterator_rep
• struct binary_helper< new_table< C, T, V > >
• struct object_format
• struct unary_op
• struct binary_op
• struct replace_return_op
• struct unary_return_type_helper< replace_return_op< Op, R >, C >
• struct binary_return_type_helper< replace_return_op< Op, R >, C1, C2 >
• struct ternary_return_type_helper< replace_return_op< Op, R >, C1, C2, C3 >
• struct return_op_helper
• struct in_place_op
• struct no_op
• struct id_op
• struct as_op
• struct return_op_helper< as_op, R >
• struct copy_op
• struct clear_op
• struct duplicate_op
• struct fast_op
• struct slow_op
• struct swap_op
• struct flatten_op
• struct unary_return_type_helper< flatten_op, C >
• struct default_as_op
• struct log2_as_op
• struct pi_as_op
• struct euler_as_op
• struct catalan_as_op
• struct smallest_as_op
• struct largest_as_op
• struct accuracy_as_op
• struct imaginary_as_op
• struct nan_as_op
• struct infinity_as_op
• struct maximal_as_op
• struct minimal_as_op
• struct fuzz_as_op
• struct return_op_helper< default_as_op, R >
• struct return_op_helper< log2_as_op, R >
• struct return_op_helper< pi_as_op, R >
• struct return_op_helper< euler_as_op, R >
• struct return_op_helper< catalan_as_op, R >
• struct return_op_helper< smallest_as_op, R >
• struct return_op_helper< largest_as_op, R >
• struct return_op_helper< accuracy_as_op, R >
• struct return_op_helper< imaginary_as_op, R >
• struct return_op_helper< infinity_as_op, R >
• struct return_op_helper< nan_as_op, R >
• struct return_op_helper< maximal_as_op, R >
• struct return_op_helper< minimal_as_op, R >
• struct return_op_helper< fuzz_as_op, R >
• struct hash_op
• struct exact_hash_op
• struct hard_hash_op
• struct zero_op
• struct neg_op
• struct add_op
• struct radd_op
• struct ladd_op
• struct sub_op
• struct rsub_op
• struct lsub_op
• struct mul_op
• struct rmul_op
• struct lmul_op
• struct mul_add_op
• struct rmul_add_op
• struct lmul_add_op
• struct mul_sub_op
• struct square_op
• struct graeffe_op
• struct invert_op
• struct div_op
• struct rdiv_op
• struct ldiv_op
• struct quo_op
• struct pquo_op
• struct rquo_op
• struct rem_op
• struct prem_op
• struct rrem_op
• struct lshift2_op
• struct rshift2_op
• struct lshiftz_op
• struct rshiftz_op
• struct incexp2_op
• struct decexp2_op
• struct or_op
• struct and_op
• struct gcd_op
• struct lcm_op
• struct xgcd_op
• struct hard_eq_op
• struct hard_neq_op
• struct hard_less_op
• struct hard_gtr_op
• struct exact_eq_op
• struct exact_neq_op
• struct equal_op
• struct unequal_op
• struct less_op
• struct lesseq_op
• struct gtr_op
• struct gtreq_op
• struct binary_return_type_helper< hard_eq_op, C, C >
• struct binary_return_type_helper< hard_neq_op, C, C >
• struct binary_return_type_helper< exact_eq_op, C, C >
• struct binary_return_type_helper< exact_neq_op, C, C >
• struct binary_return_type_helper< equal_op, C, C >
• struct binary_return_type_helper< unequal_op, C, C >
• struct binary_return_type_helper< less_op, C, C >
• struct binary_return_type_helper< lesseq_op, C, C >
• struct binary_return_type_helper< gtr_op, C, C >
• struct binary_return_type_helper< gtreq_op, C, C >
• struct min_op
• struct max_op
• struct inf_op
• struct sup_op
• struct abs_op
• struct abs_as_op
• struct return_op_helper< abs_as_op, R >
• struct sign_op
• struct sqrt_op
• struct cbrt_op
• struct hypot_op
• struct exp_op
• struct exp2_op
• struct exp10_op
• struct log_op
• struct log2_op
• struct log10_op
• struct pow_op
• struct lpow_op
• struct trig_op
• struct cos_op
• struct sin_op
• struct tan_op
• struct acos_op
• struct asin_op
• struct atan_op
• struct atan2_op
• struct cosh_op
• struct sinh_op
• struct tanh_op
• struct acosh_op
• struct asinh_op
• struct atanh_op
• struct gamma_op
• struct zeta_op
• struct erf_op
• struct is_finite_op
• struct is_infinite_op
• struct is_fuzz_op
• struct is_nan_op
• struct is_reliable_op
• struct and_is_finite_op
• struct or_is_infinite_op
• struct or_is_fuzz_op
• struct or_is_nan_op
• struct unary_return_type_helper< is_finite_op, C >
• struct unary_return_type_helper< is_infinite_op, C >
• struct unary_return_type_helper< is_fuzz_op, C >
• struct unary_return_type_helper< is_nan_op, C >
• struct unary_return_type_helper< and_is_finite_op, C >
• struct unary_return_type_helper< or_is_infinite_op, C >
• struct unary_return_type_helper< or_is_fuzz_op, C >
• struct unary_return_type_helper< or_is_nan_op, C >
• struct exponent_op
• struct max_exponent_op
• struct unary_return_type_helper< exponent_op, C >
• struct unary_return_type_helper< max_exponent_op, C >
• struct magnitude_op
• struct max_magnitude_op
• struct unary_return_type_helper< magnitude_op, C >
• struct unary_return_type_helper< max_magnitude_op, C >
• struct precision_op
• struct min_precision_op
• struct unary_return_type_helper< precision_op, C >
• struct unary_return_type_helper< min_precision_op, C >
• struct change_precision_op
• struct rounding_error_op
• struct additive_error_op
• struct multiplicative_error_op
• struct elementary_error_op
• struct floor_op
• struct trunc_op
• struct ceil_op
• struct round_op
• struct gaussian_op
• struct polar_op
• struct binary_return_type_helper< polar_op, C, C >
• struct Re_op
• struct Im_op
• struct unary_return_type_helper< Im_op, C >
• struct arg_op
• struct unary_return_type_helper< arg_op, C >
• struct conj_op
• struct times_i_op
• struct over_i_op
• struct ball_op
• struct center_op
• struct radius_op
• struct interval_op
• struct lower_op
• struct unary_return_type_helper< lower_op, C >
• struct upper_op
• struct unary_return_type_helper< upper_op, C >
• struct sharpen_op
• struct blur_op
• struct included_op
• struct numerator_op
• struct denominator_op
• struct evaluate_op
• struct lift_op
• struct project_op
• struct reconstruct_op
• struct truncate_op
• struct complete_op
• struct derive_op
• struct xderive_op
• struct integrate_op
• struct integrate_init_op
• struct compose_op
• struct reverse_op
• struct append_op
• struct solve_vector_lde_op
• struct solve_matrix_lde_op
• struct is_infinitesimal_op
• struct is_non_infinitesimal_op
• struct is_bounded_op
• struct is_non_bounded_op
• struct is_infinitely_large_op
• struct is_non_infinitely_large_op
• struct is_constant_op
• struct is_non_constant_op
• struct smaller_equal_op
• struct not_smaller_equal_op
• struct smaller_op
• struct not_smaller_op
• struct larger_equal_op
• struct not_larger_equal_op
• struct larger_op
• struct not_larger_op
• struct common_part_op
• struct dominant_part_op
• struct remainder_part_op
• struct infinitesimal_part_op
• struct non_infinitesimal_part_op
• struct bounded_part_op
• struct non_bounded_part_op
• struct infinite_part_op
• struct non_infinite_part_op
• struct constant_part_op
• struct non_constant_part_op
• struct access_op
• struct mv_inject_op
• struct mv_project_op
• class pair
• struct binary_helper< pair< C1, C2 > >
• struct parse_instance
• class port_rep
• class port
• struct void_binary_helper
• struct binary_helper
• struct binary_helper< generic >
• struct binary_helper< char >
• struct binary_helper< uchar >
• struct binary_helper< short >
• struct binary_helper< ushort >
• struct binary_helper< int >
• struct binary_helper< nat >
• struct binary_helper< long >
• struct binary_helper< ulong >
• struct binary_helper< float >
• struct binary_helper< double >
• struct binary_helper< bool >
• struct binary_helper< string >
• struct binary_helper< syntactic >
• struct binary_helper< exception >
• struct format_binary_helper
• struct format_binary_helper< empty_format, T >
• struct binary_helper< format< T > >
• class posix_port_rep
• class primitive_rep
• class primitive
• struct generic_converter
• struct generic_converter< generic >
• class routine_rep
• class routine
• class nullary_routine_rep< void >
• class unary_routine_rep
• class unary_routine_rep< void, S1 >
• class binary_routine_rep
• class binary_routine_rep< void, S1, S2 >
• class ternary_routine_rep
• class ternary_routine_rep< void, S1, S2, S3 >
• class quaternary_routine_rep
• class quaternary_routine_rep< void, S1, S2, S3, S4 >
• class quintary_routine_rep
• class quintary_routine_rep< void, S1, S2, S3, S4, S5 >
• class row_tuple
• struct as_helper< row_tuple< T >, row_tuple< F > >
• class source_position
• class source_location
• struct hard_eq_sparse_vector
• struct exact_eq_sparse_vector
• class sparse_vector_rep
• class sparse_vector
• struct binary_helper< sparse_vector< C, T, V > >
• class storage_rep
• class storage
• class string_rep
• class string
• class symbol_rep
• class symbol
• struct symbolic_type_information< symbol< string > >
• struct symbolic_type_information< symbol< vector< C > > >
• struct binary_helper< symbol< C, V > >
• class syntactic
• struct hard_eq_table
• struct exact_eq_table
• struct equal_table
• class table_rep
• class table
• struct species_type_information< table< C, T, V > >
• struct as_helper< table< D, T >, table< C, T > >
• class entries_iterator_rep
• class table_iterator_rep
• struct binary_helper< table< C, T, V > >
• class task_rep
• class task
• class triple
• struct binary_helper< triple< C1, C2, C3 > >
• class tuple
• struct as_helper< tuple< T >, tuple< F > >
• struct type_information< tuple< C > >
• struct unary_return_type_helper
• struct binary_return_type_helper
• struct ternary_return_type_helper
• struct unary_return_type_helper< abs_op, generic >
• struct unary_return_type_helper< abs_op, syntactic >
• struct unary_return_type_helper< Re_op, generic >
• struct unary_return_type_helper< Re_op, syntactic >
• struct unary_return_type_helper< center_op, generic >
• struct unary_return_type_helper< center_op, syntactic >
• struct unary_return_type_helper< radius_op, generic >
• struct unary_return_type_helper< radius_op, syntactic >
• struct unary_return_type_helper< numerator_op, generic >
• struct unary_return_type_helper< numerator_op, syntactic >
• struct unary_return_type_helper< denominator_op, generic >
• struct unary_return_type_helper< denominator_op, syntactic >
• struct unary_return_type_helper< lift_op, generic >
• struct unary_return_type_helper< lift_op, syntactic >
• struct unary_return_type_helper< project_op, generic >
• struct unary_return_type_helper< project_op, syntactic >
• struct unary_return_type_helper< reconstruct_op, generic >
• struct unary_return_type_helper< reconstruct_op, syntactic >
• struct binary_return_type_helper< truncate_op, generic, nat >
• struct binary_return_type_helper< truncate_op, syntactic, nat >
• struct unary_return_type_helper< complete_op, generic >
• struct unary_return_type_helper< complete_op, syntactic >
• struct binary_return_type_helper< evaluate_op, generic, generic >
• struct binary_return_type_helper< evaluate_op, syntactic, syntactic >
• struct unary_return_type_helper< radius_op, C >
• struct binary_return_type_helper< gaussian_op, C, C >
• struct default_radius_type_helper
• class unknown_as_vector_type
• class unknown_as_matrix_type
• struct coefficient1_type_helper
• struct coefficient2_type_helper
• struct coefficient3_type_helper
• struct scalar_type_helper
• struct monomial_type_helper
• struct as_vector_type_helper
• struct as_matrix_type_helper
• struct no_format
• struct empty_format
• struct format
• struct encapsulate1
• struct encapsulate2
• struct unary_format
• struct unary_format_helper
• struct unary_format_helper< empty_format >
• struct binary_format
• struct binary_format_helper
• struct binary_format_helper< empty_format, empty_format >
• struct ternary_format
• struct ternary_format_helper
• struct ternary_format_helper< empty_format, empty_format, empty_format >
• struct promote_scalar_helper
• struct promote_scalar_helper< empty_format, F, T >
• struct formatted_new_helper
• struct formatted_new_helper< empty_format, T >
• struct format_unary_map_helper
• struct format_unary_map_helper< Op, FT, C, C >
• struct format_unary_map_helper< Op, empty_format, R, C >
• struct format_unary_map_helper< Op, empty_format, C, C >
• struct format_binary_map_scalar_helper
• struct format_binary_map_scalar_helper< Op, FT, C1, C1, C2 >
• struct format_binary_map_scalar_helper< Op, empty_format, R, C1, C2 >
• struct format_binary_map_scalar_helper< Op, empty_format, C1, C1, C2 >
• struct format_binary_map_helper
• struct format_binary_map_helper< Op, FT, C1, C1, C2 >
• struct format_binary_map_helper< Op, empty_format, R, C1, C2 >
• struct format_binary_map_helper< Op, empty_format, C1, C1, C2 >
• struct as_helper
• struct format_as_helper
• struct format_as_helper< FT, T, T >
• struct format_as_helper< empty_format, T, F >
• struct format_as_helper< empty_format, T, T >
• struct as_helper< format< T >, format< F > >
• struct vector_as_helper
• struct fast_helper
• struct unary_return_type_helper< lift_op, C >
• struct lift_helper
• struct project_helper
• struct inspector
• struct rounding_helper
• struct with_rounding
• struct make_ball_helper
• struct make_interval_helper
• struct projective_helper
• class vector_rep
• class vector
• struct format< vector< T1, X2 > >
• struct coefficient1_type_helper< vector< T1, X2 > >
• struct scalar_type_helper< vector< C, V > >
• struct unary_return_type_helper< abs_op, vector< C, V > >
• struct unary_return_type_helper< Re_op, vector< C, V > >
• struct unary_return_type_helper< center_op, vector< C, V > >
• struct unary_return_type_helper< radius_op, vector< C, V > >
• struct unary_return_type_helper< lift_op, vector< C, V > >
• struct unary_return_type_helper< project_op, vector< C, V > >
• struct unary_return_type_helper< reconstruct_op, vector< C, V > >
• struct binary_return_type_helper< truncate_op, vector< C, V >, nat >
• struct unary_return_type_helper< complete_op, vector< C, V > >
• struct binary_return_type_helper< evaluate_op, vector< C, V >, K >
• struct rounding_helper< vector< C, V > >
• struct species_type_information< vector< C, V > >
• struct fast_helper< vector< C, V > >
• struct as_helper< vector< T, TV >, vector< F, FV > >
• struct vector_as_helper< vector< C, V > >
• struct vector_fixed
• struct implementation< vector_defaults, V, vector_fixed< W, S > >
• struct implementation< F, V, vector_fixed< W, S > >
• class vector_rep< C, vector_fixed< V, S > >
• class vector_iterator_rep
• struct binary_helper< vector< C, V > >
• struct lift_helper< vector< C, V > >
• struct project_helper< vector< C, V > >
• struct vector_naive
• struct vector_defaults
• struct implementation< vector_defaults, V, vector_naive >
• struct vector_allocate
• struct implementation< vector_allocate, V, vector_naive >
• struct vector_abstractions
• struct implementation< vector_abstractions, V, vector_naive >
• struct vector_abstractions_stride
• struct implementation< vector_abstractions_stride, V, vector_naive >
• struct vector_linear
• struct implementation< vector_linear, V, vector_naive >
• struct sort_op_pair_wrapper
• class composite_port_rep
• class cpp_printer
• class output_observer_rep
• class updater_rep
• class updater
• class argument_observer_rep
• class result_observer_rep
• class file_port_rep
• class formatting_port_rep
• class generic_object_rep
• class mmx_printer
• class pipe_port_rep
• class error_port_rep
• class basic_primitive_rep
• class routine_primitive_rep
• class identity_routine_rep
• class composed_routine_rep
• class change_signature_routine_rep
• class default_routine_rep
• class integrate_routine_rep
• class socket_port_rep
• struct gen_eq_op
• struct gen_eq_table
• class disk_storage_rep
• class output_string_port_rep
• class input_string_port_rep
• class input_output_string_port_rep
• struct sum_less_op
• struct product_less_op
• struct system_instance
• struct loop_task_rep
• struct vector_sort_leq_op

Typedefs

• typedef void * void_ptr
• typedef char * char_ptr
• typedef unsigned int nat
• typedef unsigned char uchar
• typedef unsigned short ushort
• typedef unsigned int uint
• typedef unsigned long ulong
• typedef long int xint
• typedef unsigned long int xnat
• typedef routine * vec_routine
• typedef long int double_int
• typedef pow_op rpow_op
• typedef char * charp
• typedef const char * const_charp
• typedef generic(* unary_generic )(const generic &)

Enumerations

• enum print_format {
    blank, stroke, indent, unindent,
    reset_indent, cr, lf, hrule,
    flush_now, black_foreground, red_foreground, green_foreground,
    yellow_foreground, blue_foreground, magenta_foreground, cyan_foreground,
    white_foreground, black_background, red_background, green_background,
    yellow_background, blue_background, magenta_background, cyan_background,
    white_background, bold, underline, blink,
    reset_attributes
  }

  Special objects that affect output when printed.

  More...
  

• enum mmx_rounding { MMX_ROUND_NEAR, MMX_ROUND_ZERO, MMX_ROUND_UP, MMX_ROUND_DOWN }
• enum print_controls {
    LF, INDENT, UNINDENT, LF,
    INDENT, VARINDENT, UNINDENT
  }
• enum print_controls {
    LF, INDENT, UNINDENT, LF,
    INDENT, VARINDENT, UNINDENT
  }

Functions

• INDIRECT_IMPL_1 (alias, alias_rep, typename C, C) template< typename C > inline syntactic flatten(const alias< C > &a)
• template<typename C > alias< C > new_alias (const C &c)
• template<typename C > C get_alias (const alias< C > &a)
• template<typename C > C & open_alias (const alias< C > &a)
• template<typename C > void close_alias (const alias< C > &a)
• template<typename C > C set_alias (const alias< C > &a, const C &c)
• WRAP_INDIRECT_IMPL (template< typename C > inline, alias< C >) template< typename C > struct binary_helper< alias< C > >
• template<typename C > alias< C > global_alias (C &c)
• template<typename C > syntactic flatten (const generic_alias< C > &a)
• template<typename C > generic_alias< C > new_genalias (const alias< generic > &a)
• template<typename C > alias< generic > generalize_genalias (const generic_alias< C > &a)
• template<typename C > C get_genalias (const generic_alias< C > &a)
• template<typename C > generic set_genalias (const generic_alias< C > &a, const generic &c)
• WRAP_WRAPPED_IMPL (template< typename C > inline, generic_alias< C >) template< typename C > class incarnate_alias_rep
• template<typename C > alias< C > incarnate_genalias (const generic_alias< C > &a)
• void alias_type_info (nat &id, int &mode)
• void alias_specializer (nat id, routine &r)
• void alias_getter (nat id, routine &r)
• void alias_setter (nat id, routine &r)
• generic specialize_alias (const generic &a)
• generic get_alias (const generic &a)
• generic set_alias (const generic &a, const generic &val)
• bool is_alias_type (nat id)
• nat alias_to_scalar (nat id)
• nat scalar_to_alias (nat id)
• nat new_alias_type_id (nat id)
• nat new_generic_alias_type_id (nat id)
• template<typename C , typename R , typename A > alias< C > alias_access (const alias< R > &r, const A &a)
• template<typename C , typename R , typename A , typename B > alias< C > alias_access (const alias< R > &r, const A &a, const B &b)
• template<typename R , typename A > void alias_reset (const alias< R > &r, const A &a)
• template<typename R , typename A > alias< R > alias_write (const alias< R > &r, const A &a)
• template<typename R , typename A , typename B > void alias_glue (const alias< R > &r, const A &a, const B &b)
• template<typename X , typename R , typename A , typename B , typename C > alias< X > alias_tuple_access (const alias< R > &r, const A &a, const B &b, const C &c)
• template<typename R , typename A , typename B , typename C > void alias_tuple_reset (const alias< R > &r, const A &a, const B &b, const C &c)
• void noop ()
• template<typename C > C copy (const C &x)
• template<typename C > nat as_hash (const C *p)
• nat hash (char c)
• nat hash (signed char c)
• nat hash (unsigned char c)
• nat hash (short int c)
• nat hash (short unsigned int c)
• nat hash (int c)
• nat hash (unsigned int c)
• nat hash (long int c)
• nat hash (long unsigned int c)
• nat hash (long long int c)
• nat hash (long long unsigned int c)
• nat hash (const float &x)
• nat hash (const double &x)
• template<typename C > nat hash (C *p)
• nat exact_hash (char c)
• nat exact_hash (signed char c)
• nat exact_hash (unsigned char c)
• nat exact_hash (short int c)
• nat exact_hash (short unsigned int c)
• nat exact_hash (int c)
• nat exact_hash (unsigned int c)
• nat exact_hash (long int c)
• nat exact_hash (long unsigned int c)
• nat exact_hash (long long int c)
• nat exact_hash (long long unsigned int c)
• nat exact_hash (const float &x)
• nat exact_hash (const double &x)
• template<typename C > nat exact_hash (C *p)
• bool exact_eq (char c1, char c2)
• bool exact_eq (signed char c1, signed char c2)
• bool exact_eq (unsigned char c1, unsigned char c2)
• bool exact_eq (short int c1, short int c2)
• bool exact_eq (short unsigned int c1, short unsigned int c2)
• bool exact_eq (int c1, int c2)
• bool exact_eq (unsigned int c1, unsigned int c2)
• bool exact_eq (long int c1, long int c2)
• bool exact_eq (long unsigned int c1, long unsigned int c2)
• bool exact_eq (long long int c1, long long int c2)
• bool exact_eq (long long unsigned int c1, long long unsigned int c2)
• bool exact_eq (float x, float y)
• bool exact_eq (double x, double y)
• template<typename C > bool exact_eq (C *p1, C *p2)
• bool exact_neq (char c1, char c2)
• bool exact_neq (signed char c1, signed char c2)
• bool exact_neq (unsigned char c1, unsigned char c2)
• bool exact_neq (short int c1, short int c2)
• bool exact_neq (short unsigned int c1, short unsigned int c2)
• bool exact_neq (int c1, int c2)
• bool exact_neq (unsigned int c1, unsigned int c2)
• bool exact_neq (long int c1, long int c2)
• bool exact_neq (long unsigned int c1, long unsigned int c2)
• bool exact_neq (long long int c1, long long int c2)
• bool exact_neq (long long unsigned int c1, long long unsigned int c2)
• bool exact_neq (float x, float y)
• bool exact_neq (double x, double y)
• template<typename C > bool exact_neq (C *p1, C *p2)
• template<typename C > nat hard_hash (const C &x)
• template<typename C > bool hard_eq (const C &x, const C &y)
• template<typename C > bool hard_neq (const C &x, const C &y)
• template<typename C > bool hard_less (const C &x, const C &y)
• template<typename C > bool hard_gtr (const C &x, const C &y)
• template<typename C , typename T > nat hash (const cache< C, T > &c)
• template<typename C , typename T > nat exact_hash (const cache< C, T > &c)
• template<typename C , typename T > nat hard_hash (const cache< C, T > &c)
• template<typename C , typename T > bool operator== (const cache< C, T > &c1, const cache< C, T > &c2)
• template<typename C , typename T > bool operator!= (const cache< C, T > &c1, const cache< C, T > &c2)
• template<typename C , typename T > bool exact_eq (const cache< C, T > &c1, const cache< C, T > &c2)
• template<typename C , typename T > bool exact_neq (const cache< C, T > &c1, const cache< C, T > &c2)
• template<typename C , typename T > bool hard_eq (const cache< C, T > &c1, const cache< C, T > &c2)
• template<typename C , typename T > bool hard_neq (const cache< C, T > &c1, const cache< C, T > &c2)
• template<typename C , typename T > syntactic flatten (const cache< C, T > &c)
• template<typename C , typename T > nat N (const cache< C, T > &c)
• template<typename C , typename T > double complexity (const cache< C, T > &c)
• template<typename C , typename T > nat discrete_complexity (const cache< C, T > &c)
• template<typename C , typename T > void inside_set (const cache< C, T > &c, const T &x, const C &v)
• template<typename C , typename T > void reset (cache< C, T > &c, const T &x)
• template<typename C , typename T > bool contains (const cache< C, T > &c, const T &x)
• template<typename C , typename T > C read (const cache< C, T > &c, const T &x)
• template<typename C , typename T > iterator< T > entries (const cache< C, T > &c)
• template<typename C , typename T > cache< C, T > append (const cache< C, T > &t, const cache< C, T > &u)
• template<typename T , typename C > cache< C, T > make_cache_1 (const format< T > &fm1, const format< C > &fm2)
• template<typename T , typename C > cache< C, T > make_cache_2 (const C &init, const format< T > &fm)
• template<typename T , typename C > cache< C, T > make_cache_3 (const vector< pair< T, C > > &v)
• template<typename T , typename C > cache< C, T > make_cache_4 (const C &init, const vector< pair< T, C > > &v)
• template<typename C > chain< C > left (const chain< C > &c)
• template<typename C > C middle (const chain< C > &c)
• template<typename C > chain< C > right (const chain< C > &c)
• template<typename C > bool is_nil (const chain< C > &c)
• template<typename C > nat N (const chain< C > &c)
• template<typename C > chain< C > balance_left (const chain< C > &c)
• template<typename C > chain< C > balance_right (const chain< C > &c)
• template<typename C > chain< C > operator* (const chain< C > &l, const chain< C > &r)
• DEFINE_UNARY_FORMAT_1 (chain) template< typename C > inline format< C > CF(const chain< C > &l)
• template<typename C > chain_rep< C > * inside (const chain< C > &x)
• template<typename C > nat hard_hash (const chain< C > &x)
• template<typename C > bool hard_eq (const chain< C > &x, const chain< C > &y)
• template<typename C > bool hard_neq (const chain< C > &x, const chain< C > &y)
• template<typename C > iterator< C > iterate (const chain< C > &c)
• template<typename C > syntactic flatten (const chain< C > &c)
• template<typename C > chain< C > copy (const chain< C > &c)
• template<typename C > chain< C > reverse (const chain< C > &c)
• template<typename C > C car (const chain< C > &c)
• template<typename C > C cAr (const chain< C > &c)
• template<typename Op , typename C > nat unary_hash (const chain< C > &c)
• template<typename Op , typename C > bool binary_test (const chain< C > &c1, const chain< C > &c2)
• TRUE_IDENTITY_OP_SUGAR (template< typename C >, chain< C >) EXACT_IDENTITY_OP_SUGAR(template< typename C >
• template<typename C > chain< C > chain< C > shift_left (const chain< C > &c)
• template<typename C > chain< C > shift_right (const chain< C > &c)
• template<typename C > chain< C > cdr (const chain< C > &c)
• template<typename C > chain< C > cDr (const chain< C > &c)
• template<typename C > chain< C > range (const chain< C > &c, nat start, nat end)
• template<typename S1 , typename D , typename Fun > chain< D > map (const Fun &fun, const chain< S1 > &c1, const format< D > &fm)
• nat hash (const compound &c)
• nat exact_hash (const compound &c)
• nat hard_hash (const compound &c)
• bool operator== (const compound &c1, const compound &c2)
• bool operator!= (const compound &c1, const compound &c2)
• bool exact_eq (const compound &c1, const compound &c2)
• bool exact_neq (const compound &c1, const compound &c2)
• bool hard_eq (const compound &c1, const compound &c2)
• bool hard_neq (const compound &c1, const compound &c2)
• vector< generic > compound_to_vector (const generic &g)
• generic vector_to_compound (const vector< generic > &v)
• syntactic flatten (const compound &c)
• string as_cpp (const generic &g)
• string flatten_as_cpp (const generic &g)
• string cpp_identifier (const string &s)
• template<typename T , typename F > T as (const F &x)
• template<typename T , typename F > T promote (const F &x, const T &y)
• template<typename F > bool promote (const F &x, const bool &)
• template<typename F > char promote (const F &x, const char &)
• template<typename F > signed char promote (const F &x, const signed char &)
• template<typename F > unsigned char promote (const F &x, const unsigned char &)
• template<typename F > int promote (const F &x, const int &)
• template<typename F > unsigned int promote (const F &x, const unsigned int &)
• template<typename F > long int promote (const F &x, const long int &)
• template<typename F > unsigned long int promote (const F &x, const unsigned long int &)
• template<typename F > long long int promote (const F &x, const long long int &)
• template<typename F > unsigned long long int promote (const F &x, const unsigned long long int &)
• template<typename F > float promote (const F &x, const float &)
• template<typename F > double promote (const F &x, const double &)
• template<typename C > bool is_zero (const C &x)
• template<typename C > bool is_exact_zero (const C &x)
• char copy (char c)
• signed char copy (signed char c)
• unsigned char copy (unsigned char c)
• short int copy (short int c)
• short unsigned int copy (short unsigned int c)
• int copy (int c)
• unsigned int copy (unsigned int c)
• long int copy (long int c)
• long unsigned int copy (long unsigned int c)
• long long int copy (long long int c)
• long long unsigned int copy (long long unsigned int c)
• float copy (float c)
• double copy (double c)
• template<typename C > void * copy (C *p)
• template<typename C > C duplicate (const C &x)
• template<typename C > void clear (C &x)
• template<typename C , typename D > C & operator+= (C &x, const D &y)
• template<typename C , typename D > C & operator-= (C &x, const D &y)
• template<typename C , typename D > C & operator*= (C &x, const D &y)
• template<typename C , typename D > C & operator/= (C &x, const D &y)
• template<typename C , typename D > C quo (const C &x, const D &y)
• template<typename C , typename D > C rem (const C &x, const D &y)
• template<typename C > C skew_div (const C &x, const C &y, bool left=false)
• template<typename C > C skew_quo (const C &x, const C &y, bool left=false)
• template<typename C > C skew_rem (const C &x, const C &y, bool left=false)
• template<typename C , typename S > C lshift2 (const C &x, const S &y)
• template<typename C > C lshift2 (const C &x)
• template<typename C , typename S > void lshift2_assign (C &x, const S &y)
• template<typename C , typename S > void lshift2 (C &x, const C &y, const S &z)
• template<typename C , typename S > C rshift2 (const C &x, const S &y)
• template<typename C > C rshift2 (const C &x)
• template<typename C , typename S > void rshift2_assign (C &x, const S &y)
• template<typename C , typename S > void rshift2 (C &x, const C &y, const S &z)
• template<typename C , typename S > C lshiftz (const C &x, const S &y)
• template<typename C > C lshiftz (const C &x)
• template<typename C , typename S > void lshiftz_assign (C &x, const S &y)
• template<typename C , typename S > void lshiftz (C &x, const C &y, const S &z)
• template<typename C , typename S > C rshiftz (const C &x, const S &y)
• template<typename C > C rshiftz (const C &x)
• template<typename C , typename S > void rshiftz_assign (C &x, const S &y=1)
• template<typename C , typename S > void rshiftz (C &x, const C &y, const S &z)
• template<typename C , typename S > C incexp2 (const C &x, const S &y)
• template<typename C > C incexp2 (const C &x)
• template<typename C , typename S > void incexp2_assign (C &x, const S &y)
• template<typename C , typename S > void incexp2 (C &x, const C &y, const S &z)
• template<typename C , typename S > C decexp2 (const C &x, const S &y)
• template<typename C > C decexp2 (const C &x)
• template<typename C , typename S > void decexp2_assign (C &x, const S &y)
• template<typename C , typename S > void decexp2 (C &x, const C &y, const S &z)
• template<typename C > int sign (const C &x)
• template<> int sign (const unsigned char &x)
• template<> int sign (const short unsigned int &x)
• template<> int sign (const unsigned int &x)
• template<> int sign (const long unsigned int &x)
• template<> int sign (const long long unsigned int &x)
• template<typename C > int compare (const C &x, const C &y)
• template<> int compare (const unsigned char &x, const unsigned char &y)
• template<> int compare (const short unsigned int &x, const short unsigned int &y)
• template<> int compare (const unsigned int &x, const unsigned int &y)
• template<> int compare (const long unsigned int &x, const long unsigned int &y)
• template<> int compare (const long long unsigned int &x, const long long unsigned int &y)
• template<typename C > C abs (const C &x)
• template<> unsigned char abs (const unsigned char &x)
• template<> short unsigned int abs (const short unsigned int &x)
• template<> unsigned int abs (const unsigned int &x)
• template<> long unsigned int abs (const long unsigned int &x)
• template<> long long unsigned int abs (const long long unsigned int &x)
• template<typename C > C min (const C &x, const C &y)
• template<typename C > C max (const C &x, const C &y)
• template<typename C > C inf (const C &x, const C &y)
• template<typename C > C sup (const C &x, const C &y)
• template<typename C > C square (const C &x)
• template<typename C > C invert (const C &x)
• template<typename C > bool is_invertible (const C &x)
• template<typename C > C binpow (const C &i, const nat &n)
• template<typename C > C powint (const C &i, const int &n)
• template<typename C , typename ZZ > C sympow (const C &c, const ZZ &i)
• template<typename C > C hypot (const C &x, const C &y)
• template<typename C > C atan2 (const C &y, const C &x)
• template<typename C > C cosh (const C &x)
• template<typename C > C sinh (const C &x)
• template<typename C > C tanh (const C &x)
• template<typename C > C acosh (const C &x)
• template<typename C > C asinh (const C &x)
• template<typename C > C atanh (const C &x)
• template<typename C > bool is_finite (const C &x)
• template<typename C > bool is_infinite (const C &x)
• template<typename C > bool is_fuzz (const C &x)
• template<typename C > bool is_nan (const C &x)
• template<typename C > bool is_reliable (const C &x)
• template<typename C > double magnitude (const C &x)
• template<typename C > C change_precision (const C &x, xnat)
• template<typename C > C sharpen (const C &x)
• template<typename C , typename D > C blur (const C &x, const D &y)
• template<typename C > C Re (const C &x)
• template<typename C > C Im (const C &x)
• template<typename C > C conj (const C &x)
• template<typename T , typename V > T derive (const T &f, const V &v, nat n)
• template<typename C > C common_part (const C &x, const C &y)
• template<typename C > bool always_false (const C &x)
• template<typename C > bool always_true (const C &x)
• template<typename C > void swap (C &x, C &y)
• template<typename C > const C & read_only (const C &c)
• void set_default (int &x)
• void set_default (nat &x)
• void set_default (long int &x)
• void set_default (long unsigned int &x)
• void set_maximal (int &x)
• void set_minimal (int &x)
• void set_maximal (nat &x)
• void set_minimal (nat &x)
• void set_maximal (long int &x)
• void set_minimal (long int &x)
• void set_maximal (long unsigned int &x)
• void set_minimal (long unsigned int &x)
• void set_default (double &x)
• void set_nan (double &x)
• void set_maximal (double &x)
• void set_minimal (double &x)
• void set_infinity (double &x)
• void set_fuzz (double &x)
• void set_smallest (double &x)
• void set_largest (double &x)
• void set_accuracy (double &x)
• void set_log2 (double &x)
• void set_pi (double &x)
• void set_euler (double &x)
• double times_infinity (const double &x)
• double square (const double &x)
• double invert (const double &x)
• double sqrt (const double &x)
• double exp (const double &x)
• double exp2 (const double &x)
• double log (const double &x)
• double log2 (const double &x)
• double cos (const double &x)
• double sin (const double &x)
• double tan (const double &x)
• double cosh (const double &x)
• double sinh (const double &x)
• double tanh (const double &x)
• double acos (const double &x)
• double asin (const double &x)
• double atan (const double &x)
• double hypot (const double &x, const double &y)
• double atan2 (const double &y, const double &x)
• double pow (const double &x, const double &y)
• double pow (const double &x, const int &y)
• double pow (const int &x, const double &y)
• template<typename S > double incexp2 (const double &x, const S &y)
• double incexp2 (const double &x)
• template<typename S > void incexp2_assign (double &x, const S &y)
• template<typename S > void incexp2 (double &, const double &, const S &)
• template<typename S > double decexp2 (const double &x, const S &y)
• double decexp2 (const double &x)
• template<typename S > void decexp2_assign (double &x, const S &y)
• template<typename S > void decexp2 (double &, const double &, const S &)
• double floor (const double &x)
• double trunc (const double &x)
• double ceil (const double &x)
• double round (const double &x)
• template<typename R > function_0< void > invalidator_1 (const function_0< void > &p2, R **t2, int *ol, int *nl)
• template<typename R > function_0< void > invalidator_2 (const function_0< void > &p2, R **t2, int *ol1, int *ol2, int *nl1, int *nl2)
• generic as_generic (const document &g)
• document as_document (const generic &g)
• nat hash (const document &c)
• nat exact_hash (const document &c)
• nat hard_hash (const document &c)
• bool operator== (const document &c1, const document &c2)
• bool operator!= (const document &c1, const document &c2)
• bool exact_eq (const document &c1, const document &c2)
• bool exact_neq (const document &c1, const document &c2)
• bool hard_eq (const document &c1, const document &c2)
• bool hard_neq (const document &c1, const document &c2)
• syntactic flatten (const document &d)
• document make_text (const generic &x)
• document make_text (const document &x)
• document make_math (const generic &x)
• document make_math (const document &x)
• document make_row (const vector< document > &v)
• document make_inline (const vector< document > &v)
• document make_block (const vector< document > &v)
• document make_texmacs (const string &x, const vector< document > &v)
• document make_texmacs (const literal &x, const vector< document > &v)
• double sec (const double &x)
• double csc (const double &x)
• double cot (const double &x)
• double sech (const double &x)
• double csch (const double &x)
• double coth (const double &x)
• double acosh (const double &x)
• double asinh (const double &x)
• double atanh (const double &x)
• bool is_finite (const double &x)
• bool is_infinite (const double &x)
• bool is_fuzz (const double &x)
• bool is_nan (const double &x)
• bool is_reliable (const double &x)
• xnat precision (const double &x)
• double change_precision (const double &x, xnat prec)
• double next_above (const double &x)
• double next_below (const double &x)
• double rounding_error (const double &x)
• double additive_error (const double &x)
• template<> double magnitude (const double &x)
• xint exponent (const double &x)
• int as_int (const double &x)
• double as_double (const double &x)
• double int_as_double (const int &x)
• double uniform_deviate (const double &lo, const double &hi)
• observer_rep * inside (const observer &x)
• template<> nat hard_hash (const observer &x)
• template<> bool hard_eq (const observer &x, const observer &y)
• template<> bool hard_neq (const observer &x, const observer &y)
• nat exact_hash (const observer &x)
• bool exact_eq (const observer &x, const observer &y)
• bool exact_neq (const observer &x, const observer &y)
• nat hash (const observer &x)
• bool operator== (const observer &x, const observer &y)
• bool operator!= (const observer &x, const observer &y)
• dynamic_rep * inside (const dynamic &x)
• template<> nat hard_hash (const dynamic &x)
• template<> bool hard_eq (const dynamic &x, const dynamic &y)
• template<> bool hard_neq (const dynamic &x, const dynamic &y)
• syntactic flatten (const dynamic &g)
• generic contents (const dynamic &d)
• void assign (const dynamic &d, const generic &val)
• void message (const dynamic &d, const generic &msg)
• void attach (const dynamic &d, const observer &o)
• nat exact_hash (const dynamic &x)
• bool exact_eq (const dynamic &x, const dynamic &y)
• bool exact_neq (const dynamic &x, const dynamic &y)
• nat hash (const dynamic &x)
• bool operator== (const dynamic &x, const dynamic &y)
• bool operator!= (const dynamic &x, const dynamic &y)
• evaluator_rep * inside (const evaluator &x)
• template<> nat hard_hash (const evaluator &x)
• template<> bool hard_eq (const evaluator &x, const evaluator &y)
• template<> bool hard_neq (const evaluator &x, const evaluator &y)
• void select_evaluator (const evaluator &ev)
• void restore_evaluator ()
• nat hash (const exception &e)
• nat exact_hash (const exception &e)
• nat hard_hash (const exception &e)
• bool operator== (const exception &e1, const exception &e2)
• bool operator!= (const exception &e1, const exception &e2)
• bool exact_eq (const exception &e1, const exception &e2)
• bool exact_neq (const exception &e1, const exception &e2)
• bool hard_eq (const exception &e1, const exception &e2)
• bool hard_neq (const exception &e1, const exception &e2)
• syntactic flatten (const exception &e)
• generic std_exception (const string &msg, const generic &where)
• generic std_exception (const string &msg, const generic &a, const generic &w)
• generic user_exception (const vector< generic > &msg, const generic &where)
• generic wrong_nr_args (const generic &where)
• generic type_mismatch (const generic &expect, const generic &where)
• generic trace_push (const generic &exc, const generic &where)
• generic trace_pull (const generic &exc)
• generic trace_top (const generic &exc)
• generic trace_bottom (const generic &exc, nat n=1)
• bool has_trace (const generic &exc)
• exception as_exception (const generic &x)

  Make an exception from x.
  

• volatile void fatal_error (char *message, char *routine, char *file)

  Print message coming from routine in file. Exit with 1.
  

• string cpp_demangle (const char *name)
• void * safe_malloc (register size_t sz)
• void safe_free (register void *ptr)
• void * enlarge_malloc (register size_t sz)
• void * mmx_malloc_thread_unsafe (register size_t sz)
• void mmx_free_thread_unsafe (register void *ptr, register size_t sz)
• void * mmx_realloc_thread_unsafe (register void *old_ptr, register size_t old_sz, register size_t new_sz)
• void * mmx_malloc_thread_safe (size_t new_size)
• void * mmx_realloc_thread_safe (void *ptr, size_t old_size, size_t new_size)
• void mmx_free_thread_safe (void *ptr, size_t old_size)
• void * mmx_malloc (size_t sz)
• void * mmx_realloc (void *ptr, size_t old_size, size_t new_size)
• void mmx_free (void *ptr, size_t old_size)
• template<typename C > C * mmx_new (nat n)
• template<typename C , typename T1 > C * mmx_new (nat n, const T1 &a1)
• template<typename C , typename T1 , typename T2 > C * mmx_new (nat n, const T1 &a1, const T2 &a2)
• template<typename C > void mmx_delete (C *Ptr, nat n)
• template<typename C > C * mmx_new_one ()
• template<typename C , typename T1 > C * mmx_new_one (const T1 &a1)
• template<typename C > void mmx_delete_one (C *ptr)
• template<typename C > C * mmx_classical_new (nat n)
• template<typename C > void mmx_classical_delete (C *Ptr)
• size_t mmx_used_bytes ()
• template<typename T > syntactic flatten_type ()
• template<typename D > function_0_rep< D > * inside (const function_0< D > &f)
• template<typename D > syntactic flatten (const function_0< D > &f)
• template<typename D > nat hard_hash (const function_0< D > &f)
• template<typename D > bool hard_eq (const function_0< D > &f, const function_0< D > &g)
• template<typename D > bool hard_neq (const function_0< D > &f, const function_0< D > &g)
• template<typename D > nat exact_hash (const function_0< D > &x)
• template<typename D > bool exact_eq (const function_0< D > &x, const function_0< D > &y)
• template<typename D > bool exact_neq (const function_0< D > &x, const function_0< D > &y)
• template<typename D > nat hash (const function_0< D > &x)
• template<typename D > bool operator== (const function_0< D > &x, const function_0< D > &y)
• template<typename D > bool operator!= (const function_0< D > &x, const function_0< D > &y)
• template<typename D > bool is_nil (const function_0< D > &f)
• template<typename D , typename S1 > function_1_rep< D, S1 > * inside (const function_1< D, S1 > &f)
• template<typename D , typename S1 > syntactic flatten (const function_1< D, S1 > &f)
• template<typename D , typename S1 > nat hard_hash (const function_1< D, S1 > &f)
• template<typename D , typename S1 > bool hard_eq (const function_1< D, S1 > &f, const function_1< D, S1 > &g)
• template<typename D , typename S1 > bool hard_neq (const function_1< D, S1 > &f, const function_1< D, S1 > &g)
• template<typename D , typename S1 > nat exact_hash (const function_1< D, S1 > &x)
• template<typename D , typename S1 > bool exact_eq (const function_1< D, S1 > &x, const function_1< D, S1 > &y)
• template<typename D , typename S1 > bool exact_neq (const function_1< D, S1 > &x, const function_1< D, S1 > &y)
• template<typename D , typename S1 > nat hash (const function_1< D, S1 > &x)
• template<typename D , typename S1 > bool operator== (const function_1< D, S1 > &x, const function_1< D, S1 > &y)
• template<typename D , typename S1 > bool operator!= (const function_1< D, S1 > &x, const function_1< D, S1 > &y)
• template<typename D , typename S1 > bool is_nil (const function_1< D, S1 > &f)
• template<typename C , typename R > format< R > map (const function_1< R, typename argument_helper< C >::arg_type > &fun, const format< C > &fm)
• template<typename C , typename R > format< R > map (R(*fun)(const C &), const format< C > &fm)
• template<typename D , typename S1 , typename S2 > function_2_rep< D, S1, S2 > * inside (const function_2< D, S1, S2 > &f)
• template<typename D , typename S1 , typename S2 > syntactic flatten (const function_2< D, S1, S2 > &f)
• template<typename D , typename S1 , typename S2 > nat hard_hash (const function_2< D, S1, S2 > &f)
• template<typename D , typename S1 , typename S2 > bool hard_eq (const function_2< D, S1, S2 > &f, const function_2< D, S1, S2 > &g)
• template<typename D , typename S1 , typename S2 > bool hard_neq (const function_2< D, S1, S2 > &f, const function_2< D, S1, S2 > &g)
• template<typename D , typename S1 , typename S2 > nat exact_hash (const function_2< D, S1, S2 > &x)
• template<typename D , typename S1 , typename S2 > bool exact_eq (const function_2< D, S1, S2 > &x, const function_2< D, S1, S2 > &y)
• template<typename D , typename S1 , typename S2 > bool exact_neq (const function_2< D, S1, S2 > &x, const function_2< D, S1, S2 > &y)
• template<typename D , typename S1 , typename S2 > nat hash (const function_2< D, S1, S2 > &x)
• template<typename D , typename S1 , typename S2 > bool operator== (const function_2< D, S1, S2 > &x, const function_2< D, S1, S2 > &y)
• template<typename D , typename S1 , typename S2 > bool operator!= (const function_2< D, S1, S2 > &x, const function_2< D, S1, S2 > &y)
• template<typename D , typename S1 , typename S2 > bool is_nil (const function_2< D, S1, S2 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 > function_3_rep< D, S1, S2, S3 > * inside (const function_3< D, S1, S2, S3 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 > syntactic flatten (const function_3< D, S1, S2, S3 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 > nat hard_hash (const function_3< D, S1, S2, S3 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 > bool hard_eq (const function_3< D, S1, S2, S3 > &f, const function_3< D, S1, S2, S3 > &g)
• template<typename D , typename S1 , typename S2 , typename S3 > bool hard_neq (const function_3< D, S1, S2, S3 > &f, const function_3< D, S1, S2, S3 > &g)
• template<typename D , typename S1 , typename S2 , typename S3 > nat exact_hash (const function_3< D, S1, S2, S3 > &x)
• template<typename D , typename S1 , typename S2 , typename S3 > bool exact_eq (const function_3< D, S1, S2, S3 > &x, const function_3< D, S1, S2, S3 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 > bool exact_neq (const function_3< D, S1, S2, S3 > &x, const function_3< D, S1, S2, S3 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 > nat hash (const function_3< D, S1, S2, S3 > &x)
• template<typename D , typename S1 , typename S2 , typename S3 > bool operator== (const function_3< D, S1, S2, S3 > &x, const function_3< D, S1, S2, S3 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 > bool operator!= (const function_3< D, S1, S2, S3 > &x, const function_3< D, S1, S2, S3 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 > bool is_nil (const function_3< D, S1, S2, S3 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > function_4_rep< D, S1, S2, S3,
  S4 > * inside (const function_4< D, S1, S2, S3, S4 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > syntactic flatten (const function_4< D, S1, S2, S3, S4 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > nat hard_hash (const function_4< D, S1, S2, S3, S4 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > bool hard_eq (const function_4< D, S1, S2, S3, S4 > &f, const function_4< D, S1, S2, S3, S4 > &g)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > bool hard_neq (const function_4< D, S1, S2, S3, S4 > &f, const function_4< D, S1, S2, S3, S4 > &g)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > nat exact_hash (const function_4< D, S1, S2, S3, S4 > &x)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > bool exact_eq (const function_4< D, S1, S2, S3, S4 > &x, const function_4< D, S1, S2, S3, S4 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > bool exact_neq (const function_4< D, S1, S2, S3, S4 > &x, const function_4< D, S1, S2, S3, S4 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > nat hash (const function_4< D, S1, S2, S3, S4 > &x)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > bool operator== (const function_4< D, S1, S2, S3, S4 > &x, const function_4< D, S1, S2, S3, S4 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > bool operator!= (const function_4< D, S1, S2, S3, S4 > &x, const function_4< D, S1, S2, S3, S4 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > bool is_nil (const function_4< D, S1, S2, S3, S4 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > function_5_rep< D, S1, S2, S3,
  S4, S5 > * inside (const function_5< D, S1, S2, S3, S4, S5 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > syntactic flatten (const function_5< D, S1, S2, S3, S4, S5 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > nat hard_hash (const function_5< D, S1, S2, S3, S4, S5 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > bool hard_eq (const function_5< D, S1, S2, S3, S4, S5 > &f, const function_5< D, S1, S2, S3, S4, S5 > &g)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > bool hard_neq (const function_5< D, S1, S2, S3, S4, S5 > &f, const function_5< D, S1, S2, S3, S4, S5 > &g)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > nat exact_hash (const function_5< D, S1, S2, S3, S4, S5 > &x)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > bool exact_eq (const function_5< D, S1, S2, S3, S4, S5 > &x, const function_5< D, S1, S2, S3, S4, S5 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > bool exact_neq (const function_5< D, S1, S2, S3, S4, S5 > &x, const function_5< D, S1, S2, S3, S4, S5 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > nat hash (const function_5< D, S1, S2, S3, S4, S5 > &x)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > bool operator== (const function_5< D, S1, S2, S3, S4, S5 > &x, const function_5< D, S1, S2, S3, S4, S5 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > bool operator!= (const function_5< D, S1, S2, S3, S4, S5 > &x, const function_5< D, S1, S2, S3, S4, S5 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > bool is_nil (const function_5< D, S1, S2, S3, S4, S5 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 > function_6_rep< D, S1, S2, S3,
  S4, S5, S6 > * inside (const function_6< D, S1, S2, S3, S4, S5, S6 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 > syntactic flatten (const function_6< D, S1, S2, S3, S4, S5, S6 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 > nat hard_hash (const function_6< D, S1, S2, S3, S4, S5, S6 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 > bool hard_eq (const function_6< D, S1, S2, S3, S4, S5, S6 > &f, const function_6< D, S1, S2, S3, S4, S5, S6 > &g)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 > bool hard_neq (const function_6< D, S1, S2, S3, S4, S5, S6 > &f, const function_6< D, S1, S2, S3, S4, S5, S6 > &g)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 > nat exact_hash (const function_6< D, S1, S2, S3, S4, S5, S6 > &x)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 > bool exact_eq (const function_6< D, S1, S2, S3, S4, S5, S6 > &x, const function_6< D, S1, S2, S3, S4, S5, S6 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 > bool exact_neq (const function_6< D, S1, S2, S3, S4, S5, S6 > &x, const function_6< D, S1, S2, S3, S4, S5, S6 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 > nat hash (const function_6< D, S1, S2, S3, S4, S5, S6 > &x)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 > bool operator== (const function_6< D, S1, S2, S3, S4, S5, S6 > &x, const function_6< D, S1, S2, S3, S4, S5, S6 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 > bool operator!= (const function_6< D, S1, S2, S3, S4, S5, S6 > &x, const function_6< D, S1, S2, S3, S4, S5, S6 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 > bool is_nil (const function_6< D, S1, S2, S3, S4, S5, S6 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 > function_7_rep< D, S1, S2, S3,
  S4, S5, S6, S7 > * inside (const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 > syntactic flatten (const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 > nat hard_hash (const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 > bool hard_eq (const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &f, const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &g)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 > bool hard_neq (const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &f, const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &g)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 > nat exact_hash (const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &x)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 > bool exact_eq (const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &x, const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 > bool exact_neq (const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &x, const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 > nat hash (const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &x)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 > bool operator== (const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &x, const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 > bool operator!= (const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &x, const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 > bool is_nil (const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 , typename S8 > function_8_rep< D, S1, S2, S3,
  S4, S5, S6, S7, S8 > * inside (const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 , typename S8 > syntactic flatten (const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 , typename S8 > nat hard_hash (const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &f)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 , typename S8 > bool hard_eq (const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &f, const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &g)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 , typename S8 > bool hard_neq (const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &f, const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &g)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 , typename S8 > nat exact_hash (const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &x)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 , typename S8 > bool exact_eq (const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &x, const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 , typename S8 > bool exact_neq (const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &x, const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 , typename S8 > nat hash (const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &x)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 , typename S8 > bool operator== (const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &x, const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 , typename S8 > bool operator!= (const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &x, const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &y)
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 , typename S6 , typename S7 , typename S8 > bool is_nil (const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &f)
• generic gen_vec ()
• generic gen_vec (const generic &g1)
• generic gen_vec (const generic &g1, const generic &g2)
• generic gen_vec (const generic &g1, const generic &g2, const generic &g3)
• generic vector_access (const generic &g, nat i)
• template<typename C > generic binary_disassemble (const C &x)
• template<typename C > void binary_write (const port &out, const C &x)
• template<typename C > port operator<< (const port &out, const C &x)
• void write (const port &p, const char *s, nat n)
• void write (const port &p, const string &s)
• generic_rep * inside (const generic &x)
• template<> nat hard_hash (const generic &x)
• template<> bool hard_eq (const generic &x, const generic &y)
• template<> bool hard_neq (const generic &x, const generic &y)
• nat type (const generic &g)
• nat symbolic_type (const generic &g)
• nat species_type (const generic &g)
• nat N (const generic &g)
• nat gen_hash (const generic &g)
• nat exact_hash (const generic &g)
• nat hash (const generic &g)
• bool gen_eq (const generic &g1, const generic &g2)
• bool gen_neq (const generic &g1, const generic &g2)
• nat new_type_id ()
• nat new_type_id (const char *)
• template<typename T > nat global_type_id ()
• nat binary_id (nat id1, nat id2)
• template<typename C > bool is (const generic &x)
• bool same_type (const generic &x1, const generic &x2)
• vector< generic > all_type_names ()
• void define_type_sub (const generic &name, nat id)
• nat type_id (const generic &name)
• generic type_name (nat id)
• generic type_name (const generic &g)
• template<typename C > nat type_id ()
• template<typename C > generic type_name ()
• bool is_vector (const generic &x)
• bool is_list (const generic &x)
• bool is_table (const generic &x)
• bool generic_is_boolean (const generic &g)
• bool generic_is_int (const generic &g)
• bool generic_is_double (const generic &g)
• bool generic_is_string (const generic &g)
• generic lit (const char *s)
• generic lit (const string &s)
• generic gen (const generic &x1, const vector< generic > &v)
• generic gen ()
• generic gen (const generic &x1)
• generic gen (const generic &x1, const string &x2)
• generic gen (const generic &x1, const generic &x2)
• generic gen (const generic &x1, const generic &x2, const generic &x3)
• generic gen (const generic &x1, const generic &x2, const generic &x3, const generic &x4)
• generic gen (const generic &x1, const generic &x2, const generic &x3, const generic &x4, const generic &x5)
• generic gen (const generic &x1, const generic &x2, const generic &x3, const generic &x4, const generic &x5, const generic &x6)
• generic void_value ()
• generic comma ()
• generic comma (const generic &x1, const generic &x2)
• generic xgen (const generic &f, const generic &args)
• generic xaccess (const generic &f, const generic &args)
• generic xtuple (const generic &args)
• generic xsqtuple (const generic &args)
• generic xrow (const generic &args)
• generic access (const generic &f, const generic &x)
• generic access (const generic &f, const generic &x, const generic &y)
• generic access (const generic &f, const vector< generic > &x)
• generic as_object (const generic &v, nat tp_id)
• generic as_object (const generic &v, const generic &tp)
• generic as_generic (const generic &obj, nat tp_id)
• generic as_generic (const generic &obj, const generic &tp)
• generic range (const generic &g, nat start, nat end)
• generic append (const generic &g1, const generic &g2)
• generic cons (const generic &g1, const generic &g2)
• generic cons (const generic &g1, const generic &g2, const generic &g3)
• generic car (const generic &g)
• generic cdr (const generic &g)
• bool is_func (const generic &g, const char *f)
• bool is_func (const generic &g, const char *f, nat n)
• bool is_func (const generic &g, const generic &f)
• bool is_func (const generic &g, const generic &f, nat n)
• nat size (const generic &g)
• int big_small_compare (const generic &g1, const generic &g2)
• int small_big_compare (const generic &g1, const generic &g2)
• generic convert (const generic &from, const generic &to)
• void set_default (generic &x)
• void set_smallest (generic &x)
• void set_largest (generic &x)
• void set_accuracy (generic &x)
• void set_pi (generic &x)
• void set_log2 (generic &x)
• void set_euler (generic &x)
• void set_catalan (generic &x)
• void set_imaginary (generic &x)
• void set_nan (generic &x)
• void set_fuzz (generic &x)
• void set_infinity (generic &x)
• void set_maximal (generic &x)
• void set_minimal (generic &x)
• generic operator- (const generic &x1)
• generic square (const generic &x1)
• generic invert (const generic &x1)
• generic operator+ (const generic &x1, const generic &x2)
• generic operator- (const generic &x1, const generic &x2)
• generic operator* (const generic &x1, const generic &x2)
• generic operator/ (const generic &x1, const generic &x2)
• generic operator+ (const generic &x1, const int &x2)
• generic operator- (const generic &x1, const int &x2)
• generic operator* (const generic &x1, const int &x2)
• generic operator/ (const generic &x1, const int &x2)
• generic operator+ (const int &x1, const generic &x2)
• generic operator- (const int &x1, const generic &x2)
• generic operator* (const int &x1, const generic &x2)
• generic operator/ (const int &x1, const generic &x2)
• generic sqrt (const generic &x1)
• generic exp (const generic &x1)
• generic log (const generic &x1)
• generic cos (const generic &x1)
• generic sin (const generic &x1)
• generic tan (const generic &x1)
• generic acos (const generic &x1)
• generic asin (const generic &x1)
• generic atan (const generic &x1)
• generic cosh (const generic &x1)
• generic sinh (const generic &x1)
• generic tanh (const generic &x1)
• generic acosh (const generic &x1)
• generic asinh (const generic &x1)
• generic atanh (const generic &x1)
• generic hypot (const generic &x1, const generic &x2)
• generic atan2 (const generic &x1, const generic &x2)
• generic pow (const generic &x1, const generic &x2)
• generic pow (const generic &x1, const int &x2)
• generic pow (const int &x1, const generic &x2)
• bool operator== (const generic &x1, const generic &x2)
• bool operator!= (const generic &x1, const generic &x2)
• bool operator== (const generic &x1, const int &x2)
• bool operator!= (const generic &x1, const int &x2)
• bool operator== (const int &x1, const generic &x2)
• bool operator!= (const int &x1, const generic &x2)
• bool exact_eq (const generic &x1, const generic &x2)
• bool exact_neq (const generic &x1, const generic &x2)
• bool exact_eq (const generic &x1, const int &x2)
• bool exact_neq (const generic &x1, const int &x2)
• bool exact_eq (const int &x1, const generic &x2)
• bool exact_neq (const int &x1, const generic &x2)
• bool is_exact_zero (const generic &g1)
• bool operator< (const generic &x1, const generic &x2)
• bool operator<= (const generic &x1, const generic &x2)
• bool operator> (const generic &x1, const generic &x2)
• bool operator>= (const generic &x1, const generic &x2)
• bool operator< (const generic &x1, const int &x2)
• bool operator<= (const generic &x1, const int &x2)
• bool operator> (const generic &x1, const int &x2)
• bool operator>= (const generic &x1, const int &x2)
• bool operator< (const int &x1, const generic &x2)
• bool operator<= (const int &x1, const generic &x2)
• bool operator> (const int &x1, const generic &x2)
• bool operator>= (const int &x1, const generic &x2)
• generic derive (const generic &x1)
• generic integrate (const generic &x1)
• generic derive (const generic &x1, const generic &x2)
• generic integrate (const generic &x1, const generic &x2)
• generic construct (const int &i)
• generic construct (const nat &i)
• generic construct (const double &x)
• generic construct (const float &x)
• generic construct (const generic &x)
• generic eval (const generic &x)
• generic apply (const generic &f, const generic &x)
• generic apply (const generic &f, const generic &x, const generic &y)
• generic apply (const generic &f, const generic &x, const generic &y, const generic &z)
• generic apply (const generic &f, const vector< generic > &x)
• generic quo (const generic &x1, const generic &x2)
• generic rem (const generic &x1, const generic &x2)
• generic numerator (const generic &x)
• generic denominator (const generic &x)
• generic gcd (const generic &x1, const generic &x2)
• generic lcm (const generic &x1, const generic &x2)
• xgcd_matrix< generic > xgcd (const generic &x1, const generic &x2)
• generic pow (const generic &x1, const nat &x2)
• generic pow (const nat &x1, const generic &x2)
• generic trig (const generic &x1)
• generic min (const generic &x1, const generic &x2)
• generic max (const generic &x1, const generic &x2)
• generic abs (const generic &x1)
• generic arg (const generic &x1)
• generic Re (const generic &x1)
• generic Im (const generic &x1)
• generic conj (const generic &x1)
• generic gaussian (const generic &x1, const generic &x2)
• generic polar (const generic &x1, const generic &x2)
• generic floor (const generic &x)
• generic trunc (const generic &x)
• generic ceil (const generic &x)
• generic round (const generic &x)
• generic prime (const generic &x1)
• generic substitute (const generic &x1, const generic &x2)
• generic compose (const generic &x1, const generic &x2)
• generic dilate (const generic &x1, const generic &x2)
• generic solve (const generic &x1, const generic &x2)
• generic sqrt_init (const generic &x, const generic &c)
• generic log_init (const generic &x, const generic &c)
• generic acos_init (const generic &x, const generic &c)
• generic asin_init (const generic &x, const generic &c)
• generic atan_init (const generic &x, const generic &c)
• generic integrate_init (const generic &x, const generic &c)
• generic solve_lde_init (const generic &x, const generic &c)
• generic change_precision (const generic &x, xnat p)
• xnat precision (const generic &x)
• generic next_above (const generic &x)
• generic next_below (const generic &x)
• generic rounding_error (const generic &x)
• generic additive_error (const generic &x)
• generic multiplicative_error (const generic &x)
• generic elementary_error (const generic &x)
• xint exponent (const generic &x)
• double magnitude (const generic &x)
• generic incexp2 (const generic &x1, const xint &x2)
• generic decexp2 (const generic &x1, const xint &x2)
• generic operator<< (const generic &x1, const generic &x2)
• generic operator>> (const generic &x1, const generic &x2)
• generic lshiftz (const generic &x1, const generic &x2)
• generic rshiftz (const generic &x1, const generic &x2)
• generic operator| (const generic &x1, const generic &x2)
• generic operator& (const generic &x1, const generic &x2)
• generic lres (const generic &x1, const generic &x2)
• generic rres (const generic &x1, const generic &x2)
• generic uniform (const generic &x1, const generic &x2)
• generic specialize (const generic &x1, const generic &x2)
• generic center (const generic &x1)
• generic radius (const generic &x1)
• generic sharpen (const generic &x1)
• generic blur (const generic &x1, const generic &x2)
• void fill_out (vec_routine &v, nat &n, nat i, const routine &r)
• template<typename C > generic as_generic (const C &c)
• template<typename C > void set_as (generic &r, const C &x)
• template<typename C > void set_as (C &r, const generic &x)
• void set_as (generic &r, const generic &x)
• WRAP_INDIRECT_IMPL (inline, generic_function) inline generic_function
• generic_function_rep * inside (const generic_function &x)
• template<> nat hard_hash (const generic_function &x)
• template<> bool hard_eq (const generic_function &x, const generic_function &y)
• template<> bool hard_neq (const generic_function &x, const generic_function &y)
• syntactic flatten (const generic_function &fun)
• vector< nat > signature (const generic_function &fun)
• bool is_nil (const generic_function &f)
• void define_prerequisites ()
• void register_glue (const string &, void(*)(void))
• void call_glue (const string &)
• nat accelerate_number ()
• template<typename C > void accelerate_initialize ()
• template<typename C , typename S1 > void accelerate_converter (const generic &name, C(*f)(const S1 &))
• template<typename C , typename S > void accelerate_converter (const generic &, C(*)(const alias< S > &))
• template<typename C , typename S > void accelerate_converter (const generic &, C(*)(const generic_alias< S > &))
• template<typename S > void accelerate_converter (const generic &, int(*)(const S &))
• template<typename S > void accelerate_converter (const generic &, int(*)(const alias< S > &))
• template<typename S > void accelerate_converter (const generic &, int(*)(const generic_alias< S > &))
• template<typename C , typename S1 > void accelerate (const generic &name, C(*f)(const S1 &))
• template<typename C > void accelerate (const generic &name, C(*f)(const C &))
• template<typename C , typename S1 , typename S2 > void accelerate (const generic &, C(*)(const S1 &, const S2 &))
• template<typename C > void accelerate (const generic &name, C(*f)(const C &, const C &))
• template<typename C > void accelerate (const generic &name, bool(*f)(const C &, const C &))
• void accelerate (const generic &, bool(*)(const bool &, const bool &))
• template<typename D > void define_constant (const generic &name, const D &x)
• template<typename D > void define_constructor (generic(*fun)(const D &))
• void define_primitive (const generic &name, generic(*fun)(const generic &))
• template<typename D > void define (const generic &name, D(*fun)())
• template<typename D , typename S1 > void define (const generic &name, D(*fun)(const S1 &))
• template<typename D , typename S1 , typename S2 > void define (const generic &name, D(*fun)(const S1 &, const S2 &))
• template<typename D , typename S1 , typename S2 , typename S3 > void define (const generic &name, D(*fun)(const S1 &, const S2 &, const S3 &))
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > void define (const generic &name, D(*fun)(const S1 &, const S2 &, const S3 &, const S4 &))
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > void define (const generic &name, D(*fun)(const S1 &, const S2 &, const S3 &, const S4 &, const S5 &))
• template<typename C , typename S1 > void define_converter (const generic &name, C(*f)(const S1 &), nat p)
• template<typename C > void define_type (const generic &name)
• template<typename C > heap< C > copy (const heap< C > &h)
• template<typename C > void set_top (heap< C > &h, const C &x)
• template<typename C > C get_top (const heap< C > &h)
• template<typename C > void push (heap< C > &h, const C &x)
• template<typename C > C pull (heap< C > &h)
• template<typename C > nat N (const heap< C > &h)
• template<typename C > heap_rep< C > * inside (const heap< C > &x)
• template<typename C > nat hard_hash (const heap< C > &x)
• template<typename C > bool hard_eq (const heap< C > &x, const heap< C > &y)
• template<typename C > bool hard_neq (const heap< C > &x, const heap< C > &y)
• template<typename C > heap< C > & operator<< (heap< C > &h, const C &x)
• template<typename C > heap< C > & operator>> (heap< C > &h, C &x)
• template<typename C > iterator< C > iterate (const heap< C > &h)
• template<typename Op , typename C > nat unary_hash (const heap< C > &HH)
• template<typename Op , typename C > bool binary_test (const heap< C > &h1b, const heap< C > &h2b)
• template<typename C > nat hash (const heap< C > &x)
• template<typename C > bool operator== (const heap< C > &x, const heap< C > &y)
• template<typename C > bool operator!= (const heap< C > &x, const heap< C > &y)
• template<typename C > nat exact_hash (const heap< C > &x)
• template<typename C > bool exact_eq (const heap< C > &x, const heap< C > &y)
• template<typename C > bool exact_neq (const heap< C > &x, const heap< C > &y)
• template<typename C > syntactic flatten (const heap< C > &h)
• WRAP_WRAPPED_IMPL (template< typename Cat, nat Nr >, instance< Cat, Nr >)
• WRAP_PRINT_IMPL (template< typename Cat, nat Nr >, instance< Cat, Nr >)
• WRAP_BINARY_IMPL (template< typename Cat, nat Nr >, instance< Cat, Nr >, generic,"Ins","Ins") template< typename Cat
• template<typename Dest , typename Src > Dest view_as (const Src &src)
• template<typename Dest , typename Src > Dest & view_as (Src &src)
• template<typename Cat , nat Nr> bool operator== (const instance< Cat, Nr > &x, const int &i)
• template<typename Cat , nat Nr> bool operator!= (const instance< Cat, Nr > &x, const int &i)
• template<typename Cat , nat Nr> bool operator< (const instance< Cat, Nr > &x, const int &i)
• template<typename Cat , nat Nr> bool operator> (const instance< Cat, Nr > &x, const int &i)
• template<typename Cat , nat Nr> bool operator<= (const instance< Cat, Nr > &x, const int &i)
• template<typename Cat , nat Nr> bool operator>= (const instance< Cat, Nr > &x, const int &i)
• bool is_int (const double_int &x)
• int as_int (const double_int &x)
• void set_maximal (long long int &x)
• void set_minimal (long long int &x)
• void set_maximal (long long unsigned int &x)
• void set_minimal (long long unsigned int &x)
• nat log_2 (nat p)
• nat next_power_of_two (nat p)
• bool is_power_of_two (nat p)
• nat log_3 (nat p)
• nat next_power_of_three (nat p)
• template<typename C > static nat bit_size (const C &p)

  Return the bitsize of abs (p).
  

• signed char floor_sqrt (const signed char &x)
• short int floor_sqrt (const short int &x)
• int floor_sqrt (const int &x)
• long int floor_sqrt (const long int &x)
• long long int floor_sqrt (const long long int &x)
• unsigned char floor_sqrt (const unsigned char &x)
• unsigned short int floor_sqrt (const unsigned short int &x)
• unsigned int floor_sqrt (const unsigned int &x)
• unsigned long int floor_sqrt (const unsigned long int &x)
• unsigned long long int floor_sqrt (const unsigned long long int &x)
• bool divides (const signed char &n, const signed char &m)
• signed char rem (const signed char &n, const signed char &m, signed char &q)
• signed char quo (const signed char &n, const signed char &m)
• signed char rem (const signed char &n, const signed char &m)
• bool divides (const short int &n, const short int &m)
• short int rem (const short int &n, const short int &m, short int &q)
• short int quo (const short int &n, const short int &m)
• short int rem (const short int &n, const short int &m)
• bool divides (const int &n, const int &m)
• int rem (const int &n, const int &m, int &q)
• int quo (const int &n, const int &m)
• int rem (const int &n, const int &m)
• bool divides (const long int &n, const long int &m)
• long int rem (const long int &n, const long int &m, long int &q)
• long int quo (const long int &n, const long int &m)
• long int rem (const long int &n, const long int &m)
• bool divides (const long long int &n, const long long int &m)
• long long int rem (const long long int &n, const long long int &m, long long int &q)
• long long int quo (const long long int &n, const long long int &m)
• long long int rem (const long long int &n, const long long int &m)
• bool divides (const unsigned char &n, const unsigned char &m)
• unsigned char rem (const unsigned char &n, const unsigned char &m)
• unsigned char quo (const unsigned char &n, const unsigned char &m)
• unsigned char rem (const unsigned char &n, const unsigned char &m, unsigned char &q)
• bool divides (const unsigned short int &n, const unsigned short int &m)
• unsigned short int rem (const unsigned short int &n, const unsigned short int &m)
• unsigned short int quo (const unsigned short int &n, const unsigned short int &m)
• unsigned short int rem (const unsigned short int &n, const unsigned short int &m, unsigned short int &q)
• bool divides (const unsigned int &n, const unsigned int &m)
• unsigned int rem (const unsigned int &n, const unsigned int &m)
• unsigned int quo (const unsigned int &n, const unsigned int &m)
• unsigned int rem (const unsigned int &n, const unsigned int &m, unsigned int &q)
• bool divides (const unsigned long int &n, const unsigned long int &m)
• unsigned long int rem (const unsigned long int &n, const unsigned long int &m)
• unsigned long int quo (const unsigned long int &n, const unsigned long int &m)
• unsigned long int rem (const unsigned long int &n, const unsigned long int &m, unsigned long int &q)
• bool divides (const unsigned long long int &n, const unsigned long long int &m)
• unsigned long long int rem (const unsigned long long int &n, const unsigned long long int &m)
• unsigned long long int quo (const unsigned long long int &n, const unsigned long long int &m)
• unsigned long long int rem (const unsigned long long int &n, const unsigned long long int &m, unsigned long long int &q)
• signed char gcd (const signed char a, const signed char b)
• signed char gcd (const signed char a, const signed char b, signed char &co_a)
• signed char gcd (const signed char a, const signed char b, signed char &co_a, signed char &co_b)
• short int gcd (const short int a, const short int b)
• short int gcd (const short int a, const short int b, short int &co_a)
• short int gcd (const short int a, const short int b, short int &co_a, short int &co_b)
• int gcd (const int a, const int b)
• int gcd (const int a, const int b, int &co_a)
• int gcd (const int a, const int b, int &co_a, int &co_b)
• long int gcd (const long int a, const long int b)
• long int gcd (const long int a, const long int b, long int &co_a)
• long int gcd (const long int a, const long int b, long int &co_a, long int &co_b)
• long long int gcd (const long long int a, const long long int b)
• long long int gcd (const long long int a, const long long int b, long long int &co_a)
• long long int gcd (const long long int a, const long long int b, long long int &co_a, long long int &co_b)
• unsigned char gcd (const unsigned char a, const unsigned char b)
• unsigned short int gcd (const unsigned short int a, const unsigned short int b)
• unsigned int gcd (const unsigned int a, const unsigned int b)
• unsigned long int gcd (const unsigned long int a, const unsigned long int b)
• unsigned long long int gcd (const unsigned long long int a, const unsigned long long int b)
• bool reconstruct (signed char &n, signed char &d, const signed char &u, const signed char &m, const signed char &N, const signed char &D)
• bool reconstruct (signed char &n, signed char &d, const signed char &u, const signed char &m)
• bool reconstruct (signed short int &n, signed short int &d, const signed short int &u, const signed short int &m, const signed short int &N, const signed short int &D)
• bool reconstruct (signed short int &n, signed short int &d, const signed short int &u, const signed short int &m)
• bool reconstruct (signed int &n, signed int &d, const signed int &u, const signed int &m, const signed int &N, const signed int &D)
• bool reconstruct (signed int &n, signed int &d, const signed int &u, const signed int &m)
• bool reconstruct (signed long int &n, signed long int &d, const signed long int &u, const signed long int &m, const signed long int &N, const signed long int &D)
• bool reconstruct (signed long int &n, signed long int &d, const signed long int &u, const signed long int &m)
• bool reconstruct (signed long long int &n, signed long long int &d, const signed long long int &u, const signed long long int &m, const signed long long int &N, const signed long long int &D)
• bool reconstruct (signed long long int &n, signed long long int &d, const signed long long int &u, const signed long long int &m)
• bool reconstruct (signed_of_helper< unsigned char >::type &n, signed_of_helper< unsigned char >::type &d, const unsigned char &u, const unsigned char &m, const unsigned char &N, const unsigned char &D)
• bool reconstruct (signed_of_helper< unsigned char >::type &n, signed_of_helper< unsigned char >::type &d, const unsigned char &u, const unsigned char &m)
• bool reconstruct (signed_of_helper< unsigned short int >::type &n, signed_of_helper< unsigned short int >::type &d, const unsigned short int &u, const unsigned short int &m, const unsigned short int &N, const unsigned short int &D)
• bool reconstruct (signed_of_helper< unsigned short int >::type &n, signed_of_helper< unsigned short int >::type &d, const unsigned short int &u, const unsigned short int &m)
• bool reconstruct (signed_of_helper< unsigned int >::type &n, signed_of_helper< unsigned int >::type &d, const unsigned int &u, const unsigned int &m, const unsigned int &N, const unsigned int &D)
• bool reconstruct (signed_of_helper< unsigned int >::type &n, signed_of_helper< unsigned int >::type &d, const unsigned int &u, const unsigned int &m)
• bool reconstruct (signed_of_helper< unsigned long int >::type &n, signed_of_helper< unsigned long int >::type &d, const unsigned long int &u, const unsigned long int &m, const unsigned long int &N, const unsigned long int &D)
• bool reconstruct (signed_of_helper< unsigned long int >::type &n, signed_of_helper< unsigned long int >::type &d, const unsigned long int &u, const unsigned long int &m)
• bool reconstruct (signed_of_helper< unsigned long long int >::type &n, signed_of_helper< unsigned long long int >::type &d, const unsigned long long int &u, const unsigned long long int &m, const unsigned long long int &N, const unsigned long long int &D)
• bool reconstruct (signed_of_helper< unsigned long long int >::type &n, signed_of_helper< unsigned long long int >::type &d, const unsigned long long int &u, const unsigned long long int &m)
• bool shell_terminal_input (string &in)
• void shell_texmacs_initialize (void)
• bool shell_texmacs_input (string &in)
• void shell_texmacs_output (const generic &g, const generic &t)
• void shell_save_history ()
• void shell_load_history ()
• void shell_save_session ()
• vector< string > shell_load_session ()
• void batch_mode_initialize ()
• template<typename C > bool busy (const iterator< C > &it)
• template<typename C > bool done (const iterator< C > &it)
• template<typename C > bool init (const iterator< C > &it)
• template<typename C > nat hash (const iterator< C > &it)
• template<typename C > nat exact_hash (const iterator< C > &it)
• template<typename C > iterator< C > copy (const iterator< C > &it)
• template<typename C > iterator_rep< C > * inside (const iterator< C > &x)
• template<typename C > nat hard_hash (const iterator< C > &x)
• template<typename C > bool hard_eq (const iterator< C > &x, const iterator< C > &y)
• template<typename C > bool hard_neq (const iterator< C > &x, const iterator< C > &y)
• template<typename C > format< C > CF (const iterator< C > &it)
• template<typename C > format< iterator< C > > get_format (const iterator< C > &it)
• template<typename C > iterator< C > get_sample (const format< iterator< C > > &fm)
• template<typename C > syntactic flatten (const syntactic &fun, const iterator< C > &it)
• template<typename C > syntactic flatten (const iterator< C > &it)
• template<typename Op , typename C > nat unary_hash (const iterator< C > &it)
• template<typename Op , typename C > bool binary_test (const iterator< C > &it1b, const iterator< C > &it2b)
• template<typename C > bool exact_eq (const iterator< C > &x, const iterator< C > &y)
• template<typename C > bool exact_neq (const iterator< C > &x, const iterator< C > &y)
• template<typename C > bool operator== (const iterator< C > &x, const iterator< C > &y)
• template<typename C > bool operator!= (const iterator< C > &x, const iterator< C > &y)
• template<typename T , typename F > void set_as (iterator< T > &r, const iterator< F > &x)
• template<typename C > iterator< C > seq (const C &c1)
• template<typename C > iterator< C > seq (const C &c1, const C &c2)
• template<typename C > iterator< C > seq (const C &c1, const C &c2, const C &c3)
• template<typename C > iterator< C > seq (const C &c1, const C &c2, const C &c3, const C &c4)
• template<typename C > iterator< C > seq (const C &c1, const C &c2, const C &c3, const C &c4, const C &c5)
• template<typename C > iterator< C > seq (const C &c1, const C &c2, const C &c3, const C &c4, const C &c5, const C &c6)
• template<typename C > iterator< C > range_iterator (const C &start, const C &end, const C &step=outplace_set_as< C >(1), bool strict=true)
• template<typename S , typename T > iterator< S > strict_range (const S &start, const T &end)
• template<typename S , typename T > iterator< S > natural_range (const S &start, const T &end)
• template<typename S , typename T > iterator< S > downwards_range (const S &start, const T &end)
• template<typename C > iterator< C > operator* (const iterator< C > &it1, const iterator< C > &it2)
• template<typename C , typename T > iterator< C > lazy_iterator (const T &x, const format< C > &fm)
• template<typename Op , typename C > C big (const iterator< C > &it)
• template<typename C > C big_add (const iterator< C > &it)
• template<typename C > C big_mul (const iterator< C > &it)
• template<typename C > C big_or (const iterator< C > &it)
• template<typename C > C big_and (const iterator< C > &it)
• template<typename C > C big_min (const iterator< C > &it)
• template<typename C > C big_max (const iterator< C > &it)
• generic parse_lisp (const string &s, bool unquote_flag=false)
• string as_lisp (const generic &g, bool quote_flag=true)
• string flatten_as_lisp (const generic &g)
• template<typename C > list< C > cons (const C &c, const list< C > &l)

  Return a new list with head and tail l.
  

• template<typename C > const C & car (const list< C > &l)

  Return the head of l.
  

• template<typename C > C & car (list< C > &l)

  Return the head of l.
  

• template<typename C > const list< C > & cdr (const list< C > &l)

  Return the tail of l.
  

• template<typename C > list< C > & cdr (list< C > &l)

  Return the tail of l.
  

• template<typename C > bool is_nil (const list< C > &l)

  Return true iff is empty.
  

• DEFINE_UNARY_FORMAT_1 (list) template< typename C > inline format< C > CF(const list< C > &l)
• template<typename C > list_rep< C > * inside (const list< C > &x)
• template<typename C > nat hard_hash (const list< C > &x)
• template<typename C > bool hard_eq (const list< C > &x, const list< C > &y)
• template<typename C > bool hard_neq (const list< C > &x, const list< C > &y)
• template<typename C > const C & read_car (const list< C > &l)

  The same as car.
  

• template<typename C > const list< C > & read_cdr (const list< C > &l)

  The same as cdr.
  

• template<typename C > bool is_atom (const list< C > &l)

  Return true iff l has length 1.
  

• template<typename C > nat N (const list< C > &l)

  Return the number of elements in l.
  

• template<typename C > const C & read (const list< C > &l, nat i)

  The same as l[i].
  

• template<typename T , typename F > void set_as (list< T > &r, const vector< F > &l)
• template<typename C , typename T > void set_as (list< C > &r, const T &x)
• template<typename C > iterator< C > iterate (const list< C > &l)
• template<typename Op , typename C > nat unary_hash (const list< C > &ll)
• template<typename Op , typename C > bool binary_test (const list< C > &l1, const list< C > &l2)
• template<typename C > nat hash (const list< C > &x)
• template<typename C > bool operator== (const list< C > &x, const list< C > &y)
• template<typename C > bool operator!= (const list< C > &x, const list< C > &y)
• template<typename C > nat exact_hash (const list< C > &x)
• template<typename C > bool exact_eq (const list< C > &x, const list< C > &y)
• template<typename C > bool exact_neq (const list< C > &x, const list< C > &y)
• template<typename C > syntactic flatten (const list< C > &l)
• template<typename C > list< C > copy (const list< C > &l)
• template<typename C > list< C > append (const list< C > &l1, const list< C > &l2)

  Return a list comprising all the elements of l1 and l2.
  

• template<typename C > list< C > operator* (const list< C > &l1, const list< C > &l2)
• template<typename C > list< C > reverse (const list< C > &ll)

  Return the reversed list of l.
  

• template<typename C > list< C > range (const list< C > &l, nat start, nat end)

  Return a copy of the sublist of l from positions start to end.
  

• template<typename C > list< C > insert (const list< C > &l, const C &x)
• template<typename C > int find (const list< C > &l, const C &x)
• template<typename C > bool contains (const list< C > &l, const C &x)
• template<typename S1 , typename D , typename Fun > list< D > map (const Fun &fun, const list< S1 > &l1, const format< D > &fm)
• template<typename C > void split (const list< C > &l, nat n, list< C > &head, list< C > &tail)

  head := copy (l[0..n-1]), tail := copy (l[n..N (l)-1]).
  

• template<typename C > list< C > merge (const list< C > &head, const list< C > &tail, int(*cmp)(const C &, const C &))

  Merge head and tail that are supposed to be ordered increasingly wrt cmp.
  

• template<typename C > list< C > sort (const list< C > &l, int(*cmp)(const C &, const C &))

  Sort l increasingly wrt to cmp. cmp (x, y) < 0 iff x < y, cmp (x, y) = 0 iff x = y, cmp (x, y) > 0 iff x > y.
  

• nat hash (const literal &c)
• nat exact_hash (const literal &c)
• nat hard_hash (const literal &c)
• bool operator== (const literal &c1, const literal &c2)
• bool operator!= (const literal &c1, const literal &c2)
• bool exact_eq (const literal &c1, const literal &c2)
• bool exact_neq (const literal &c1, const literal &c2)
• bool hard_eq (const literal &c1, const literal &c2)
• bool hard_neq (const literal &c1, const literal &c2)
• template<typename C > C make_literal (const literal &lit)
• string literal_to_string (const generic &g)
• syntactic flatten (const literal &s)
• bool is_literal_string (const literal &l)
• bool is_literal_int (const literal &l)
• bool is_literal_double (const literal &l)
• string as_literal_string (const literal &l)
• int as_literal_int (const literal &l)
• double as_literal_double (const literal &l)
• string as_math (const generic &g)
• template<typename C > string flatten_as_math (const C &x)
• void texmacs_command (const string &cmd)
• string texmacs_flush_commands ()
• void texmacs_dynamic_event (const string &id, const generic &val)
• string as_texmacs_scheme (const generic &g)
• string flatten_as_tm (const generic &g)
• string flatten_as_tm (const generic &g, const string &style)
• template<typename C > string flatten_as_texmacs_scheme (const C &x)
• void mmc_initialize (int argc, char **argv)
• void mmc_terminate ()
• void mmc_exit (const int &status)
• vector< string > mmc_load_directory (const string &name)
• void mmc_save (const string &name, const string &s)
• string mmc_load (const string &name)
• generic mmc_parse (const string &file_name)
• generic mmc_parse (const string &s, const string &input_name)
• generic mmc_unliteral (const generic &x)
• exception mmc_exception (const string &message, const generic &where)
• string as_string (const exception &e)
• nat hash_combine (nat i, nat j)
• template<typename C , typename R > C promote (R *rep)
• template<typename T > syntactic flatten_as_syntactic (const T &x)
• literal string_as_literal (const string &s)
• compound vector_as_compound (const vector< generic > &l)
• compound literal_apply (const literal &f, const vector< generic > &v)
• compound compound_apply (const compound &f, const vector< generic > &v)
• compound generic_apply (const generic &f, const vector< generic > &v)
• vector< generic > generic_components (const generic &g)
• vector< generic > generic_arguments (const generic &g)
• bool generic_is_literal (const generic &g)
• bool generic_is_compound (const generic &g)
• bool generic_is_vector_generic (const generic &g)
• bool generic_is_table_generic (const generic &g)
• string generic_as_string (const generic &g)
• literal generic_as_literal (const generic &g)
• vector< generic > generic_as_vector (const generic &g)
• int generic_size (const generic &g)
• generic generic_type (const generic &g)
• template<typename T > generic any_as_generic (const T &t)
• template<typename T , typename U > U concrete_to_abstract (const T &g)
• template<typename T > T generic_as_any (const generic &g)
• template<typename T , typename U > U abstract_to_concrete (const T &g)
• template<typename T > vector< T > vector_new (const vector< T > &v)
• template<typename T > int vector_length (const vector< T > &v)
• template<typename T > vector< T > vector_nil ()
• template<typename T > vector< T > vector_nil (const format< T > &fm)
• template<typename T > vector< T > vector_cons (const T &x, const vector< T > &v)
• template<typename T > vector< T > vector_append (const vector< T > &v1, const vector< T > &v2)
• template<typename T > vector< T > vector_append (const vector< T > &v, const T &x)
• template<typename T > vector< T > & vector_lessless (vector< T > &v1, const vector< T > &v2)
• template<typename T > T vector_read (const vector< T > &v, const int &i)
• template<typename T > T & vector_write (vector< T > &v, const int &i)
• template<typename T > vector< T > vector_range (const vector< T > &v, const int &i, const int &j)
• template<typename T > bool vector_is_nil (const vector< T > &v)
• template<typename T > bool vector_is_atom (const vector< T > &v)
• template<typename T > vector< T > vector_reverse (const vector< T > &v)
• template<typename T > int vector_find (const vector< T > &v, const T &x)
• template<typename T > bool vector_contains (const vector< T > &v, const T &x)
• template<typename T > vector< T > vector_insert (const vector< T > &v, const T &x)
• template<typename T , typename U > vector< U > vector_lift (const vector< T > &v)
• template<typename T > vector< generic > vector_lift_to_generic (const vector< T > &v)
• template<typename S1 , typename D > vector< D > vector_lift (const function_1< D, typename argument_helper< S1 >::arg_type > &fun, const vector< S1 > &v1)
• template<typename S1 , typename D > vector< D > vector_lift (D(*fun)(const S1 &), const vector< S1 > &v1)
• template<typename S1 , typename D > vector< D > vector_lift (const function_1< D, typename argument_helper< S1 >::arg_type > &fun, const vector< S1 > &v1, const format< D > &fm)
• template<typename S1 , typename D > vector< D > vector_lift (D(*fun)(const S1 &), const vector< S1 > &v1, const format< D > &fm)
• template<typename D > table< D, generic > table_new (const D &x)
• template<typename D > int table_size (const table< D, generic > &t)
• template<typename D > iterator< generic > table_explode (const table< D, generic > &t)
• template<typename D > bool table_contains (const table< D, generic > &t, const generic &x)
• template<typename D > void table_reset (table< D, generic > &t, const generic &x)
• template<typename D > D table_read (const table< D, generic > &t, const generic &x)
• template<typename D > D & table_write (table< D, generic > &t, const generic &x)
• template<typename D > void table_set (const table< D, generic > &t, const generic &x, const D &v)
• template<typename D > bool table_contains (const table< D, generic > &t, const generic &x, const generic &y)
• template<typename D > void table_reset (const table< D, generic > &t, const generic &x, const generic &y)
• template<typename D > D table_read (const table< D, generic > &t, const generic &x, const generic &y)
• template<typename D > D & table_write (table< D, generic > &t, const generic &x, const generic &y)
• template<typename D > void table_set (const table< D, generic > &t, const generic &x, const generic &y, const D &v)
• template<typename T > bool iterator_busy (const iterator< T > &it)
• template<typename T > T iterator_current (const iterator< T > &it)
• template<typename T > void iterator_increase (const iterator< T > &it)
• template<typename T > vector< T > iterator_explode (const iterator< T > &it)
• template<typename S , typename T > iterator< S > iterator_strict_range (const S &start, const T &end)
• template<typename S , typename T > iterator< S > iterator_natural_range (const S &start, const T &end)
• template<typename S , typename T > iterator< S > iterator_downwards_range (const S &start, const T &end)
• template<typename T > iterator< T > iterator_nil ()
• template<typename T > iterator< T > iterator_nil (const format< T > &fm)
• template<typename T > iterator< T > iterator_cons (const T &c, const iterator< T > &tail)
• template<typename T > iterator< T > iterator_append (const iterator< T > &head, const iterator< T > &tail)
• template<typename T , typename U > iterator< U > iterator_lift (const iterator< T > &it)
• template<typename T > iterator< T > iterator_lift_from_generic (const iterator< generic > &it)
• template<typename T > iterator< T > iterator_lift_from_generic (const iterator< generic > &it, const format< T > &fm)
• template<typename T , typename U > iterator< U > iterator_lift (const function_1< U, typename argument_helper< T >::arg_type > &fun, const iterator< T > &it)
• template<typename T , typename U > iterator< U > iterator_lift (const function_1< U, typename argument_helper< T >::arg_type > &fun, const iterator< T > &it, const format< U > &fm)
• template<typename T , typename U > vector< U > iterator_lift_vector (const function_1< U, typename argument_helper< T >::arg_type > &fun, const iterator< T > &it)
• template<typename T , typename U > vector< U > iterator_lift_vector (const function_1< U, typename argument_helper< T >::arg_type > &fun, const iterator< T > &it, const format< U > &fm)
• template<typename T , typename U > iterator< U > vector_lift_iterator (const function_1< U, typename argument_helper< T >::arg_type > &fun, const vector< T > &v)
• template<typename T , typename U > iterator< U > vector_lift_iterator (const function_1< U, typename argument_helper< T >::arg_type > &fun, const vector< T > &v, const format< U > &fm)
• template<typename T , typename U > iterator< U > map (const function_1< U, typename argument_helper< T >::arg_type > &fun, const iterator< T > &it, const format< U > &fm)
• template<typename T , typename U > iterator< U > iterator_where (const function_1< U, typename argument_helper< T >::arg_type > &fun, const iterator< T > &it)
• template<typename T , typename U > iterator< U > iterator_where (const function_1< U, typename argument_helper< T >::arg_type > &fun, const iterator< T > &it, const format< U > &fm)
• template<typename T > iterator< T > iterator_filter (const function_1< bool, typename argument_helper< T >::arg_type > &cond, const iterator< T > &it)
• template<typename T > iterator< T > iterator_filter (const function_1< bool, typename argument_helper< T >::arg_type > &cond, const iterator< T > &it, const format< T > &fm)
• template<typename T , typename U > iterator< U > iterator_cond_where (const function_1< U, typename argument_helper< T >::arg_type > &fun, const iterator< T > &it, const function_1< bool, typename argument_helper< T >::arg_type > &cond)
• template<typename T , typename U > iterator< U > iterator_cond_where (const function_1< U, typename argument_helper< T >::arg_type > &fun, const iterator< T > &it, const function_1< bool, typename argument_helper< T >::arg_type > &cond, const format< T > &fmT, const format< U > &fmU)
• template<typename T > iterator< T > iterator_unnest (const iterator< iterator< T > > &it)
• template<typename T , typename U > pair< T, U > make_pair (const T &x, const U &y)
• template<typename T , typename U1 , typename U2 > syntactic flatten (const pair< T, pair< U1, U2 > > &p)
• template<typename T1 , typename T2 , typename U > syntactic flatten (const pair< pair< T1, T2 >, U > &p)
• template<typename T1 , typename T2 , typename U1 , typename U2 > syntactic flatten (const pair< pair< T1, T2 >, pair< U1, U2 > > &p)
• template<typename R > R * access (Indirect< R > &x)
• template<typename R > bool operator== (const Indirect< R > &x, const Indirect< R > &y)
• template<typename R > bool operator!= (const Indirect< R > &x, const Indirect< R > &y)
• template<typename R > bool exact_eq (const Indirect< R > &x, const Indirect< R > &y)
• template<typename R > bool exact_neq (const Indirect< R > &x, const Indirect< R > &y)
• template<typename R > bool hard_eq (const Indirect< R > &x, const Indirect< R > &y)
• template<typename R > bool hard_neq (const Indirect< R > &x, const Indirect< R > &y)
• template<typename R > nat hash (const Indirect< R > &x)
• template<typename R > nat exact_hash (const Indirect< R > &x)
• template<typename R > nat hard_hash (const Indirect< R > &x)
• template<typename R > syntactic flatten (const Indirect< R > &x)
• int mmx_lex (generic *lval, parse_instance *obj)
• generic mmx_parse (const string &file_name, nat input_number, const string &s, list< generic > &errors)
• generic mmx_parse (const string &file_name, const string &s)
• string as_mmx (const generic &g)
• string flatten_as_mmx (const generic &g)
• string output_as_mmx (const generic &g)
• string string_as_mmx (const string &s)
• generic texmacs_expand (const generic &g)
• template<typename C , typename T , typename V > C & I (new_table< C, T, V > &t)
• template<typename C , typename T , typename V > const C & I (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > const C & read_I (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > nat N (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > void simplify (new_table< C, T, V > &t)
• template<typename C , typename T , typename V > bool operator== (const new_table< C, T, V > &t1, const new_table< C, T, V > &t2)
• template<typename T > T * mmx_new_uninitialized (nat i)
• template<typename T > void mmx_delete_uninitialized (T *mem, nat i)
• template<typename T > T * mmx_new_at (T *pos)
• template<typename T > void mmx_delete_at (T *pos)
• template<typename C , typename T , typename V > new_table_rep< C, T, V > * inside (const new_table< C, T, V > &x)
• template<typename C , typename T , typename V > nat hard_hash (const new_table< C, T, V > &x)
• template<typename C , typename T , typename V > bool hard_eq (const new_table< C, T, V > &x, const new_table< C, T, V > &y)
• template<typename C , typename T , typename V > bool hard_neq (const new_table< C, T, V > &x, const new_table< C, T, V > &y)
• DEFINE_BINARY_FORMAT_3 (new_table) STYPE_TO_TYPE(template< typename C
• template<typename C , typename T , typename V > format< C > CF1 (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > format< T > CF2 (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V , typename K > const C & read (const new_table< C, T, V > &t, const K &x)
• template<typename C , typename T , typename V , typename K > void reset (new_table< C, T, V > &t, const K &x)
• template<typename C , typename T , typename V , typename K > bool contains (const new_table< C, T, V > &t, const K &x)
• template<typename C , typename T , typename V , typename K > void inside_set (const new_table< C, T, V > &t, const K &x, const C &v)
• template<typename C , typename T , typename V > const C & read (const new_table< C, T, V > &t, const T &x)
• template<typename C , typename T , typename V > void reset (new_table< C, T, V > &t, const T &x)
• template<typename C , typename T , typename V > bool contains (const new_table< C, T, V > &t, const T &x)
• template<typename C , typename T , typename V > void inside_set (const new_table< C, T, V > &t, const T &x, const C &v)
• template<typename C , typename T , typename V > iterator< T > entries (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > iterator< pair< T, C > > iterate (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > syntactic flatten (const new_table< C, T, V > &t)
• template<typename Op , typename C , typename T , typename V > nat unary_hash (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > copy (const new_table< C, T, V > &t)
• template<typename Op , typename C , typename T , typename V > new_table< C, T, V > unary_map (const new_table< C, T, V > &t)
• template<typename Op , typename C , typename T , typename V > new_table< C, T, V > binary_map (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename Op , typename C , typename T , typename V , typename X > new_table< C, T, V > binary_map_scalar (const new_table< C, T, V > &t, const X &x)
• template<typename Op , typename C , typename T , typename V > new_table< C, T, V > & unary_set (new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename Op , typename C , typename T , typename V , typename X > new_table< C, T, V > & unary_set_scalar (new_table< C, T, V > &t, const X &x)
• template<typename Op , typename C , typename T , typename V > bool binary_test (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename Op , typename C , typename T , typename V , typename X > bool binary_test_scalar (const new_table< C, T, V > &t, const X &c)
• template<typename Op , typename C , typename T , typename V > C big (const new_table< C, T, V > &t)
• template<typename Op , typename C , typename T , typename V > new_table< C, T, V > binary_combine (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename Op , typename C , typename T , typename V > new_table< C, T, V > unary_filter (const new_table< C, T, V > &t)
• template<typename T1 , typename C1 , typename T2 , typename C2 , typename Fun1 , typename Fun2 > new_table< C2, T2 > map (const Fun1 &funT, const Fun2 &funC, const new_table< C1, T1 > &t, const format< T2 > &fmT, const format< C2 > &fmC)
• template<typename C , typename T , typename V > new_table< C, T, V > duplicate (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > operator- (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > operator+ (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator+ (const new_table< C, T, V > &t, const C &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator+ (const C &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator- (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator- (const new_table< C, T, V > &t, const C &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator- (const C &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator* (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator/ (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > quo (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > rem (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator| (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator& (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > inf (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > sup (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V , typename K > new_table< C, T, V > operator* (const new_table< C, T, V > &t, const K &sc)
• template<typename C , typename T , typename V , typename K > new_table< C, T, V > operator* (const K &sc, const new_table< C, T, V > &t)
• template<typename C , typename T , typename V , typename K > new_table< C, T, V > operator/ (const new_table< C, T, V > &t, const K &sc)
• template<typename C , typename T , typename V , typename K > new_table< C, T, V > operator/ (const K &sc, const new_table< C, T, V > &t)
• template<typename C , typename T , typename V , typename K > new_table< C, T, V > quo (const new_table< C, T, V > &t, const K &sc)
• template<typename C , typename T , typename V , typename K > new_table< C, T, V > rem (const new_table< C, T, V > &t, const K &sc)
• template<typename C , typename T , typename V > new_table< C, T, V > operator+= (new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator-= (new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator*= (new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator/= (new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator|= (new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > operator&= (new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V , typename K > new_table< C, T, V > & operator*= (new_table< C, T, V > &t, const K &sc)
• template<typename C , typename T , typename V , typename K > new_table< C, T, V > & operator/= (new_table< C, T, V > &t, const K &sc)
• template<typename C , typename T , typename V > bool operator<= (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > bool operator>= (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V , typename K > bool operator== (const new_table< C, T, V > &t, const K &c)
• template<typename C , typename T , typename V , typename K > bool operator<= (const new_table< C, T, V > &t, const K &c)
• template<typename C , typename T , typename V , typename K > bool operator>= (const new_table< C, T, V > &t, const K &c)
• template<typename C , typename T , typename V > nat hash (const new_table< C, T, V > &x)
• template<typename C , typename T , typename V > bool operator!= (const new_table< C, T, V > &x, const new_table< C, T, V > &y)
• template<typename C , typename T , typename V > nat exact_hash (const new_table< C, T, V > &x)
• template<typename C , typename T , typename V > bool exact_eq (const new_table< C, T, V > &x, const new_table< C, T, V > &y)
• template<typename C , typename T , typename V > bool exact_neq (const new_table< C, T, V > &x, const new_table< C, T, V > &y)
• template<typename C , typename T , typename V > new_table< C, T, V > operator+ (const new_table< C, T, V > &x, const int &y)
• template<typename C , typename T , typename V > new_table< C, T, V > operator+ (const int &x, const new_table< C, T, V > &y)
• template<typename C , typename T , typename V > new_table< C, T, V > operator- (const new_table< C, T, V > &x, const int &y)
• template<typename C , typename T , typename V > new_table< C, T, V > operator- (const int &x, const new_table< C, T, V > &y)
• template<typename C , typename T , typename V > bool operator< (const new_table< C, T, V > &x, const new_table< C, T, V > &y)
• template<typename C , typename T , typename V > bool operator> (const new_table< C, T, V > &x, const new_table< C, T, V > &y)
• template<typename C , typename T , typename V > new_table< C, T, V > sqrt (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > exp (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > log (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > cos (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > sin (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > tan (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > acos (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > asin (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > atan (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > pow (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > pow (const new_table< C, T, V > &t, const int &u)
• template<typename C , typename T , typename V > new_table< C, T, V > pow (const int &u, const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_add (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_mul (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_or (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_and (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_min (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_max (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_inf (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_sup (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > bool is_finite (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > bool is_nan (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > bool is_infinite (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > bool is_fuzz (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > bool is_reliable (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > sharpen (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V , typename K > new_table< C, T, V > blur (const new_table< C, T, V > &t, const K &x)
• template<typename C , typename T , typename V > new_table< T, C, V > reverse (const new_table< C, T, V > &t)
• template<typename C , typename T , typename V > new_table< C, T, V > & operator<< (new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > append (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > common (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename C , typename T , typename V > new_table< C, T, V > difference (const new_table< C, T, V > &t, const new_table< C, T, V > &u)
• template<typename T , typename C > new_table< C, T > make_mmx_new_table (const format< T > &fm1, const format< C > &fm2)
• template<typename T , typename C > new_table< C, T > make_mmx_new_table (const C &init, const format< T > &fm)
• template<typename T , typename C > new_table< C, T > make_mmx_new_table (const vector< pair< T, C > > &v)
• template<typename T , typename C > new_table< C, T > make_mmx_new_table (const C &init, const vector< pair< T, C > > &v)
• template<typename C > bool ttable_contains (const new_table< C, generic > &t, const generic &a, const generic &b, const vector< generic > &c)
• template<typename C > C ttable_access (const new_table< C, generic > &t, const generic &a, const generic &b, const vector< generic > &c)
• template<typename C > C & ttable_access (new_table< C, generic > &t, const generic &a, const generic &b, const vector< generic > &c)
• template<typename C > void ttable_reset (new_table< C, generic > &t, const generic &a, const generic &b, const vector< generic > &c)
• template<typename T > T neg_operator (const T &x)
• template<typename T > T add_operator (const T &x, const T &y)
• template<typename T > T sub_operator (const T &x, const T &y)
• template<typename T > T mul_operator (const T &x, const T &y)
• template<typename T > T div_operator (const T &x, const T &y)
• template<typename T > bool equal_operator (const T &x, const T &y)
• template<typename T > bool unequal_operator (const T &x, const T &y)
• template<typename T > bool less_operator (const T &x, const T &y)
• template<typename T > bool lesseq_operator (const T &x, const T &y)
• template<typename T > bool gtr_operator (const T &x, const T &y)
• template<typename T > bool gtreq_operator (const T &x, const T &y)
• template<typename R > void neg (R &x)
• template<typename R , typename C1 > void neg (R &x, const C1 &y1)
• template<typename R , typename C1 , typename C2 > void add (R &x, const C1 &y1, const C2 &y2)
• template<typename R , typename C1 , typename C2 > void sub (R &x, const C1 &y1, const C2 &y2)
• template<typename R , typename C1 , typename C2 > void mul (R &x, const C1 &y1, const C2 &y2)
• template<typename R , typename C1 , typename C2 > void div (R &x, const C1 &y1, const C2 &y2)
• template<typename R , typename C1 , typename C2 > void mul_add (R &x, const C1 &y1, const C2 &y2)
• template<typename R , typename C1 , typename C2 > void mul_sub (R &x, const C1 &y1, const C2 &y2)
• DEFINE_BINARY_FORMAT_2 (pair) template< typename C1
• C2 C1 car (const pair< C1, C2 > &p)
• template<typename C1 , typename C2 > C2 cdr (const pair< C1, C2 > &p)
• template<typename C1 , typename C2 > format< C1 > CF1 (const pair< C1, C2 > &p)
• template<typename C1 , typename C2 > format< C2 > CF2 (const pair< C1, C2 > &p)
• template<typename Op , typename C1 , typename C2 > nat unary_hash (const pair< C1, C2 > &p)
• template<typename Op , typename C1 , typename C2 > bool binary_test (const pair< C1, C2 > &p1, const pair< C1, C2 > &p2)
• template<typename C1 , typename C2 > nat hash (const pair< C1, C2 > &x)
• template<typename C1 , typename C2 > bool operator== (const pair< C1, C2 > &x, const pair< C1, C2 > &y)
• template<typename C1 , typename C2 > bool operator!= (const pair< C1, C2 > &x, const pair< C1, C2 > &y)
• template<typename C1 , typename C2 > nat exact_hash (const pair< C1, C2 > &x)
• template<typename C1 , typename C2 > bool exact_eq (const pair< C1, C2 > &x, const pair< C1, C2 > &y)
• template<typename C1 , typename C2 > bool exact_neq (const pair< C1, C2 > &x, const pair< C1, C2 > &y)
• template<typename C1 , typename C2 > nat hard_hash (const pair< C1, C2 > &x)
• template<typename C1 , typename C2 > bool hard_eq (const pair< C1, C2 > &x, const pair< C1, C2 > &y)
• template<typename C1 , typename C2 > bool hard_neq (const pair< C1, C2 > &x, const pair< C1, C2 > &y)
• template<typename C1 , typename C2 > pair< C1, C2 > operator* (const pair< C1, C2 > &p1, const pair< C1, C2 > &p2)
• template<typename C1 , typename C2 > syntactic flatten (const pair< C1, C2 > &p)
• template<typename C1 , typename T1 , typename C2 , typename T2 , typename Fun1 , typename Fun2 > pair< C2, T2 > map (const Fun1 &funT, const Fun2 &funC, const pair< C1, T1 > &p, const format< C2 > &fmC, const format< T2 > &fmT)
• port_rep * inside (const port &x)
• template<> nat hard_hash (const port &x)
• template<> bool hard_eq (const port &x, const port &y)
• template<> bool hard_neq (const port &x, const port &y)
• nat exact_hash (const port &x)
• bool exact_eq (const port &x, const port &y)
• bool exact_neq (const port &x, const port &y)
• nat hash (const port &x)
• bool operator== (const port &x, const port &y)
• bool operator!= (const port &x, const port &y)
• syntactic flatten (const port &p)
• port input_string_port (const string &s)
• port output_string_port (string &s)
• port input_output_string_port (string &s)
• port input_file_port (const string &name)
• port output_file_port (const string &name)
• port input_output_file_port (const string &name)
• port socket_server_port (const string &host, int port)
• port socket_client_port (const string &host, int port)
• port pipe_port (const string &cmd)
• port composite_port (const vector< port > &ps)
• port composite_port (const vector< port > &ps, const vector< string > &names)
• port formatting_port (const port &p)
• port error_port (const string &message)
• bool is_input_port (const port &p)
• bool is_output_port (const port &p)
• bool error_flag (const port &p)
• string error_message (const port &p)
• bool busy (const port &p)
• nat can_write (const port &p)
• nat can_read (const port &p)
• void read (const port &p, char *s, nat n)
• string read (const port &p, nat n)
• void flush (const port &p)
• bool wait (const port &p, int msec)
• port accept (const port &p)
• port component (const port &p, const string &name)
• nat wait_port_event (int msecs)
• port operator<< (const port &out, const string &s)
• port operator<< (const port &out, const charp &s)
• port operator<< (const port &out, const const_charp &s)
• port operator<< (const port &out, const char &c)
• port operator<< (const port &out, const print_format &fm)
• port operator>> (const port &in, char &c)
• template<typename C > C binary_assemble (const generic &x)
• template<typename C > C binary_read (const port &in)
• template<typename C > nat binary_size (const C &x)
• template<typename C > generic binary_access (const C &x, nat i)
• template<typename C > port binary_ll (const port &out, const C &x)
• template<typename C > port binary_rr (const port &in, C &x)
• void attach_generic_binary_assembler (const generic &, unary_generic)
• generic binary_type_generic (const generic &g)
• generic binary_disassemble_generic (const generic &g)
• generic binary_assemble_generic (const generic &tp, const generic &val)
• template<typename T > generic binary_assemble_generic_via (const generic &x)
• template<typename T > void attach_generic_binary_assembler ()
• void attach_generic_binary_reader (const string &, unary_generic)
• void binary_write_generic (const port &out, const generic &g)
• generic binary_read_generic (const port &in)
• template<typename T > generic binary_read_generic (const generic &in)
• template<typename T > void attach_generic_binary_reader ()
• generic generic_disassemble (const generic &x)
• generic generic_assemble (const generic &x)
• primitive_rep * inside (const primitive &x)
• template<> nat hard_hash (const primitive &x)
• template<> bool hard_eq (const primitive &x, const primitive &y)
• template<> bool hard_neq (const primitive &x, const primitive &y)
• bool is_nil (const primitive &fun)
• syntactic flatten (const primitive &fun)
• template<typename T > T make_concrete (const generic &x)
• template<typename T > generic make_abstract (const T &x)
• routine_rep * inside (const routine &x)
• template<> nat hard_hash (const routine &x)
• template<> bool hard_eq (const routine &x, const routine &y)
• template<> bool hard_neq (const routine &x, const routine &y)
• bool is_nil (const routine &fun)
• syntactic flatten (const routine &fun)
• WRAP_INDIRECT_IMPL (inline, routine) inline generic eval(const routine &f
• template<typename D > routine nullary_routine (const generic &name, D(*fun)())
• template<typename D , typename S1 > routine unary_routine (const generic &name, D(*fun)(const S1 &))
• template<typename D , typename S1 , typename S2 > routine binary_routine (const generic &name, D(*f)(const S1 &, const S2 &))
• template<typename D , typename S1 , typename S2 , typename S3 > routine ternary_routine (const generic &name, D(*f)(const S1 &, const S2 &, const S3 &))
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 > routine quaternary_routine (const generic &name, D(*f)(const S1 &, const S2 &, const S3 &, const S4 &))
• template<typename D , typename S1 , typename S2 , typename S3 , typename S4 , typename S5 > routine quintary_routine (const generic &name, D(*f)(const S1 &, const S2 &, const S3 &, const S4 &, const S5 &))
• routine identity_routine (const vector< nat > &sig)
• routine compose (const routine &fun, const vector< routine > &args)
• routine compose (const routine &fun, const routine &arg)
• routine change_signature (const routine &r, const vector< nat > &sig)
• routine default_routine (const generic &name)
• routine integrate (const routine &fun)
• template<typename C > nat N (const row_tuple< C > &t)
• WRAP_INDIRECT_IMPL (template< typename C > inline, row_tuple< C >) template< typename C > syntactic flatten(const row_tuple< C > &t)
• WRAP_BINARY_IMPL_1 (template< typename C >, row_tuple< C >, generic,"Rtu","Row_tuple", C) template< typename C > row_tuple< C > as_row_tuple(const vector< C > &a)
• template<typename C > vector< C > as_vector (const row_tuple< C > &t)
• template<typename S1 , typename D > row_tuple< D > map (const function_1< D, typename argument_helper< S1 >::arg_type > &fun, const row_tuple< S1 > &v1, const format< D > &fm)
• source_position min (const source_position &p1, const source_position &p2)
• source_position max (const source_position &p1, const source_position &p2)
• bool is_nil (const source_location &l)
• syntactic flatten (const source_location &l)
• void store_interactive_number (nat n)
• nat get_interactive_number (void)
• void store_interactive_source (const string &data, nat n=get_interactive_number())
• string get_interactive_source (nat i)
• void store_file_source (const string &file_name, const string &data)
• string get_file_source (const string &file_name)
• string get_source (const string &file_name, nat input_number, nat line)
• void source_insert (const generic &g, const source_location &l)
• void source_delete (const generic &g)
• generic source_link (const generic &g, const generic &h, const generic &kind)
• generic source_extend (const generic &g1, const generic &g2)
• generic source_assign (const generic &g1, const generic &g2)
• generic source_extend (const generic &g1, const generic &g2, const generic &g3)
• void source_locate (const generic &g, source_location &l)
• source_location source_locate (const generic &g)
• bool source_has_exact (const generic &g)
• bool source_exists (const generic &g)
• string source_file (const generic &g)
• int source_line (const generic &g, const bool &last)
• int source_column (const generic &g, const bool &last)
• string source_begin (const generic &g)
• string source_end (const generic &g)
• string source_string (const generic &g)
• string source_string_unindented (const generic &g)
• string source_underlined (const generic &g)
• string source_error (const string &msg, const generic &where)
• string source_exception (const exception &e)
• template<typename C , typename T , typename V > nat N (const sparse_vector< C, T, V > &v)
• template<typename C , typename T , typename V > sparse_vector_rep< C, T, V > * inside (const sparse_vector< C, T, V > &x)
• template<typename C , typename T , typename V > nat hard_hash (const sparse_vector< C, T, V > &x)
• template<typename C , typename T , typename V > bool hard_eq (const sparse_vector< C, T, V > &x, const sparse_vector< C, T, V > &y)
• template<typename C , typename T , typename V > bool hard_neq (const sparse_vector< C, T, V > &x, const sparse_vector< C, T, V > &y)
• template<typename C , typename T , typename V > syntactic flatten (const sparse_vector< C, T, V > &v)
• template<typename Op , typename C , typename T , typename V > nat unary_hash (const sparse_vector< C, T, V > &v)
• template<typename Op , typename C , typename T , typename V > bool binary_test (const sparse_vector< C, T, V > &v1, const sparse_vector< C, T, V > &v2)
• template<typename C , typename T , typename V > nat hash (const sparse_vector< C, T, V > &x)
• template<typename C , typename T , typename V > bool operator== (const sparse_vector< C, T, V > &x, const sparse_vector< C, T, V > &y)
• template<typename C , typename T , typename V > bool operator!= (const sparse_vector< C, T, V > &x, const sparse_vector< C, T, V > &y)
• template<typename C , typename T , typename V > nat exact_hash (const sparse_vector< C, T, V > &x)
• template<typename C , typename T , typename V > bool exact_eq (const sparse_vector< C, T, V > &x, const sparse_vector< C, T, V > &y)
• template<typename C , typename T , typename V > bool exact_neq (const sparse_vector< C, T, V > &x, const sparse_vector< C, T, V > &y)
• template<typename Op , typename C , typename T , typename V > sparse_vector< C, T, V > unary_map (const sparse_vector< C, T, V > &v)
• template<typename C , typename T , typename V > sparse_vector< C, T, V > operator- (const sparse_vector< C, T, V > &t)
• template<typename Op , typename C , typename T , typename V > sparse_vector< C, T, V > binary_map (const sparse_vector< C, T, V > &v1, const sparse_vector< C, T, V > &v2)
• template<typename Op , typename C , typename T , typename V > sparse_vector< C, T, V > binary_map_optimized (const sparse_vector< C, T, V > &v1, const sparse_vector< C, T, V > &v2)
• template<typename C , typename T , typename V > sparse_vector< C, T, V > operator+ (const sparse_vector< C, T, V > &t, const sparse_vector< C, T, V > &u)
• template<typename C , typename T , typename V > sparse_vector< C, T, V > operator- (const sparse_vector< C, T, V > &t, const sparse_vector< C, T, V > &u)
• template<typename C , typename T , typename V > sparse_vector< C, T, V > operator* (const sparse_vector< C, T, V > &t, const sparse_vector< C, T, V > &u)
• template<typename C , typename T , typename V > sparse_vector< C, T, V > sup (const sparse_vector< C, T, V > &t, const sparse_vector< C, T, V > &u)
• template<typename C , typename T , typename V > sparse_vector< C, T, V > inf (const sparse_vector< C, T, V > &t, const sparse_vector< C, T, V > &u)
• template<typename Op , typename C , typename T , typename V > sparse_vector< C, T, V > binary_map_scalar (const sparse_vector< C, T, V > &v, const C &x)
• template<typename C , typename T , typename V > sparse_vector< C, T, V > operator* (const sparse_vector< C, T, V > &t, const C &sc)
• template<typename C , typename T , typename V > sparse_vector< C, T, V > operator* (const C &sc, const sparse_vector< C, T, V > &t)
• template<typename C , typename T , typename V > sparse_vector< C, T, V > operator/ (const sparse_vector< C, T, V > &t, const C &sc)
• template<typename C , typename T , typename V > sparse_vector< C, T, V > operator/ (const C &sc, const sparse_vector< C, T, V > &t)
• template<typename Mul , typename C , typename T , typename V > sparse_vector< C, T, V > _mul_add (const sparse_vector< C, T, V > &v1, const sparse_vector< C, T, V > &v2, const C &x)
• template<typename C , typename T , typename V > sparse_vector< C, T, V > sparse_mul_add (const sparse_vector< C, T, V > &v1, const sparse_vector< C, T, V > &v2, const C &x)
• template<typename C , typename M > sparse_vector< C, symbol< M >
  , hard_eq_sparse_vector > make_formal_vector (const C &c, const M &m)
• template<typename C , typename M > C get_co (const sparse_vector< C, symbol< M >, hard_eq_sparse_vector > &v, nat i)
• template<typename C , typename M > M get_mo (const sparse_vector< C, symbol< M >, hard_eq_sparse_vector > &v, nat i)
• storage_rep * inside (const storage &x)
• template<> nat hard_hash (const storage &x)
• template<> bool hard_eq (const storage &x, const storage &y)
• template<> bool hard_neq (const storage &x, const storage &y)
• nat exact_hash (const storage &x)
• bool exact_eq (const storage &x, const storage &y)
• bool exact_neq (const storage &x, const storage &y)
• nat hash (const storage &x)
• bool operator== (const storage &x, const storage &y)
• bool operator!= (const storage &x, const storage &y)
• syntactic flatten (const storage &st)
• storage disk_storage ()
• storage disk_storage (const string &root)

  Create storage which will be stored on disk in ~/.mathemagix/cache.
  

• storage cached_storage (const storage &st)

  Create storage which will be stored on disk in the directory root.
  

• void write (const storage &st, const string &var, const string &val)

  Wrap storage st such that values will be read at most once from server.
  

• string read (const storage &st, const string &var)

  Set variable var to val on storage st.
  

• void lock (const storage &st, const string &var)

  Read variable var from storage st.
  

• void unlock (const storage &st, const string &var)

  Lock variable var on storage st.
  

• storage get_branch (const storage &st, const string &br)

  Unlock variable var on storage st.
  

• bool has_branch (const storage &st, const string &br)

  Get branch br from storage st and create one if the branch does not exist.
  

• string get_file (const storage &st, const string &orig)

  Check whether the storage st admits a branch br.
  

• bool has_file (const storage &st, const string &orig)

  Get a shadow name for a file orig on the storage, with the same extension.
  

• vector< string > retrieve_data (const storage &st)

  Check whether the storage admits a shadow for the file orig.
  

• vector< string > retrieve_branches (const storage &st)

  Retrieve all variables for storage st.
  

• vector< string > retrieve_files (const storage &st)

  Retrieve all branches for storage st.
  

• vector< generic > retrieve_data_bis (const storage &st)

  Retrieve all files for storage st.
  

• vector< generic > retrieve_branches_bis (const storage &st)

  Retrieve all variables for storage st.
  

• vector< generic > retrieve_files_bis (const storage &st)

  Retrieve all branches for storage st.
  

• string_rep * inside (const string &x)
• template<> nat hard_hash (const string &x)
• template<> bool hard_eq (const string &x, const string &y)
• template<> bool hard_neq (const string &x, const string &y)
• nat exact_hash (const string &x)
• bool exact_eq (const string &x, const string &y)
• bool exact_neq (const string &x, const string &y)
• template<> string duplicate (const string &s)
• char * inside (const string &s, nat pos)
• void mem_copy (char *d, char *s, nat n)
• string as_string (int i)
• string as_string (unsigned int i)
• string as_string (void *ptr)
• string as_string (short int i)
• string as_string (short unsigned int i)
• string as_string (signed char i)
• string as_string (unsigned char i)
• string as_string (long int i)
• string as_string (long unsigned int i)
• string as_string (long long int i)
• string as_string (long long unsigned int i)
• string as_string (float x)
• string as_string (double x)
• string as_string (long double x)
• string as_string_hexa (ulong i)
• int as_int (const string &s)
• double as_double (const string &s)
• string charcode_as_string (int i)
• int string_as_charcode (const string &s)
• bool is_integer_string (const string &s)
• bool is_floating_string (const string &s)
• template<typename C > void numeric_to_string (const C &x, string &s)
• template<typename C > bool string_to_numeric (const string &s, C &val)
• template<> void numeric_to_string (const float &x, string &s)
• template<> void numeric_to_string (const double &x, string &s)
• template<> void numeric_to_string (const long double &x, string &s)
• template<> bool string_to_numeric (const string &s, float &val)
• template<> bool string_to_numeric (const string &s, double &val)
• template<> bool string_to_numeric (const string &s, long double &val)
• template<typename C > bool is_numeric_string (const string &s)
• template<typename C > string numeric_as_string (const C &x)
• template<typename C > C string_as_numeric (const string &s)
• bool operator< (const string &s, const string &t)
• bool operator<= (const string &s, const string &t)
• bool operator> (const string &s, const string &t)
• bool operator>= (const string &s, const string &t)
• char * as_charp (const string &s)
• void free_charp (char *s)

  Free memory allocated within as_charp.
  

• string escape (const string &s)

  Replace "\n", "\t", and "\b" respectively by "\\n", "\\t", and "\\b".
  

• string unescape (const string &s)

  Replace "\\n", "\\t", and "\\b" respectively by "\n", "\t", and "\b".
  

• bool is_quoted (const string &s)

  Add around s.
  

• string quote (const string &s)

  Check whether @ s is quoted.
  

• string unquote (const string &s)

  Remove all the "..." and /"..."/ around s.
  

• string locase (const string &s)

  Replace upcases by locases.
  

• string upcase (const string &s)

  Replace locases by upcases.
  

• string locase_first (const string &s)

  Replace upcase by locase for first letter.
  

• string upcase_first (const string &s)

  Replace locase by upcase for first letter.
  

• bool starts (const string &s, const string &what)

  Tell if s starts with what.
  

• bool ends (const string &s, const string &what)

  Tell if s ends with what.
  

• string replace (const string &s, const string &what, const string &by)

  Replace all the occurences of what by in s.
  

• int search_forwards (const string &s, const string &what, const int &pos)

  Search first occurrence of @ in @ after @ or @-1@.
  

• int search_backwards (const string &s, const string &what, const int &pos)

  Search first occurrence of @ in @ before @ or @-1@.
  

• string reverse (const string &s)

  Reverse the order of the characters in s.
  

• vector< string > tokenize (const string &s, const string &sep, bool keep=false)

  Cut into pieces, using as a separator.
  

• string recompose (const vector< string > &v, const string &sep, bool last=true)

  Reconstruct string from pieces in using as a separator.
  

• template<typename C , typename V > nat hash (const symbol< C, V > &s)
• template<typename C , typename V > bool operator== (const symbol< C, V > &s1, const symbol< C, V > &s2)
• template<typename C , typename V > bool operator!= (const symbol< C, V > &s1, const symbol< C, V > &s2)
• template<typename C , typename V > nat exact_hash (const symbol< C, V > &s)
• template<typename C , typename V > bool exact_eq (const symbol< C, V > &s1, const symbol< C, V > &s2)
• template<typename C , typename V > bool exact_neq (const symbol< C, V > &s1, const symbol< C, V > &s2)
• template<typename C , typename V > symbol_rep< C, V > * inside (const symbol< C, V > &x)
• template<typename C , typename V > nat hard_hash (const symbol< C, V > &x)
• template<typename C , typename V > bool hard_eq (const symbol< C, V > &x, const symbol< C, V > &y)
• template<typename C , typename V > bool hard_neq (const symbol< C, V > &x, const symbol< C, V > &y)
• template<typename C > nat hash (const symbol< C, equal_table > &s)
• template<typename C > bool operator== (const symbol< C, equal_table > &s1, const symbol< C, equal_table > &s2)
• template<typename C > bool operator!= (const symbol< C, equal_table > &s1, const symbol< C, equal_table > &s2)
• template<typename C , typename V > void show_symbol_entries ()
• template<typename C > nat number_entries ()
• template<typename C > double complexity_entries ()
• template<typename C > nat discrete_complexity_entries ()
• template<typename C , typename V > syntactic flatten (const symbol< C, V > &s)
• generic as_generic (const syntactic &g)
• syntactic as_syntactic (const generic &g)
• nat hash (const syntactic &c)
• nat exact_hash (const syntactic &c)
• nat hard_hash (const syntactic &c)
• bool operator== (const syntactic &c1, const syntactic &c2)
• bool operator!= (const syntactic &c1, const syntactic &c2)
• bool exact_eq (const syntactic &c1, const syntactic &c2)
• bool exact_neq (const syntactic &c1, const syntactic &c2)
• bool hard_eq (const syntactic &c1, const syntactic &c2)
• bool hard_neq (const syntactic &c1, const syntactic &c2)
• syntactic flatten (const syntactic &g)
• bool is_atom (const syntactic &g)
• string as_string (const syntactic &g)
• bool is_func (const syntactic &g, const char *f)
• bool is_func (const syntactic &g, const char *f, nat n)
• bool is_func (const syntactic &g, const syntactic &f)
• bool is_func (const syntactic &g, const syntactic &f, nat n)
• bool is_func (const syntactic &g, const generic &f)
• bool is_func (const syntactic &g, const generic &f, nat n)
• syntactic access (const syntactic &g, const syntactic &i)
• syntactic access (const syntactic &g, const syntactic &i, const syntactic &j)
• vector< syntactic > components (const syntactic &g)
• vector< syntactic > arguments (const syntactic &g)
• syntactic syn (const syntactic &f)
• syntactic syn (const syntactic &f, const syntactic &a1)
• syntactic syn (const syntactic &f, const syntactic &a1, const syntactic &a2)
• syntactic syn (const syntactic &f, const syntactic &a1, const syntactic &a2, const syntactic &a3)
• syntactic syn (const syntactic &f, const syntactic &a1, const syntactic &a2, const syntactic &a3, const syntactic &a4)
• syntactic syn (const syntactic &f, const vector< syntactic > &a)
• syntactic syn (const char *f)
• syntactic syn (const char *f, const syntactic &a1)
• syntactic syn (const char *f, const syntactic &a1, const syntactic &a2)
• syntactic syn (const char *f, const syntactic &a1, const syntactic &a2, const syntactic &a3)
• syntactic syn (const char *f, const syntactic &a1, const syntactic &a2, const syntactic &a3, const syntactic &a4)
• syntactic syn (const char *f, const vector< syntactic > &a)
• syntactic syn (const generic &f)
• syntactic syn (const generic &f, const syntactic &a1)
• syntactic syn (const generic &f, const syntactic &a1, const syntactic &a2)
• syntactic syn (const generic &f, const syntactic &a1, const syntactic &a2, const syntactic &a3)
• syntactic syn (const generic &f, const syntactic &a1, const syntactic &a2, const syntactic &a3, const syntactic &a4)
• syntactic syn (const generic &f, const vector< syntactic > &a)
• syntactic apply (const syntactic &f)
• syntactic apply (const syntactic &f, const syntactic &a1)
• syntactic apply (const syntactic &f, const syntactic &a1, const syntactic &a2)
• syntactic apply (const syntactic &f, const syntactic &a1, const syntactic &a2, const syntactic &a3)
• syntactic apply (const syntactic &f, const syntactic &a1, const syntactic &a2, const syntactic &a3, const syntactic &a4)
• syntactic apply (const syntactic &f, const syntactic &a1, const syntactic &a2, const syntactic &a3, const syntactic &a4, const syntactic &a5)
• syntactic apply (const syntactic &f, const syntactic &a1, const syntactic &a2, const syntactic &a3, const syntactic &a4, const syntactic &a5, const syntactic &a6)
• syntactic apply (const syntactic &f, const vector< syntactic > &a)
• syntactic apply (const char *f)
• syntactic apply (const char *f, const syntactic &a1)
• syntactic apply (const char *f, const syntactic &a1, const syntactic &a2)
• syntactic apply (const char *f, const syntactic &a1, const syntactic &a2, const syntactic &a3)
• syntactic apply (const char *f, const syntactic &a1, const syntactic &a2, const syntactic &a3, const syntactic &a4)
• syntactic apply (const char *f, const syntactic &a1, const syntactic &a2, const syntactic &a3, const syntactic &a4, const syntactic &a5)
• syntactic apply (const char *f, const syntactic &a1, const syntactic &a2, const syntactic &a3, const syntactic &a4, const syntactic &a5, const syntactic &a6)
• syntactic apply (const char *f, const vector< syntactic > &a)
• syntactic apply (const generic &f)
• syntactic apply (const generic &f, const syntactic &a1)
• syntactic apply (const generic &f, const syntactic &a1, const syntactic &a2)
• syntactic apply (const generic &f, const syntactic &a1, const syntactic &a2, const syntactic &a3)
• syntactic apply (const generic &f, const syntactic &a1, const syntactic &a2, const syntactic &a3, const syntactic &a4)
• syntactic apply (const generic &f, const syntactic &a1, const syntactic &a2, const syntactic &a3, const syntactic &a4, const syntactic &a5)
• syntactic apply (const generic &f, const syntactic &a1, const syntactic &a2, const syntactic &a3, const syntactic &a4, const syntactic &a5, const syntactic &a6)
• syntactic apply (const generic &f, const vector< syntactic > &a)
• void set_default (syntactic &x)
• void set_smallest (syntactic &x)
• void set_largest (syntactic &x)
• void set_accuracy (syntactic &x)
• void set_pi (syntactic &x)
• void set_log2 (syntactic &x)
• void set_euler (syntactic &x)
• void set_catalan (syntactic &x)
• void set_imaginary (syntactic &x)
• void set_nan (syntactic &x)
• void set_fuzz (syntactic &x)
• void set_infinity (syntactic &x)
• void set_maximal (syntactic &x)
• void set_minimal (syntactic &x)
• bool set_frac_flag (bool new_val)
• syntactic migrate_negate (const syntactic &g, nat maximal)
• syntactic operator- (const syntactic &g)
• syntactic square (const syntactic &g)
• syntactic invert (const syntactic &g)
• syntactic operator+ (const syntactic &g1, const syntactic &g2)
• syntactic operator- (const syntactic &g1, const syntactic &g2)
• syntactic operator* (const syntactic &g1, const syntactic &g2)
• syntactic operator/ (const syntactic &g1, const syntactic &g2)
• syntactic gcd (const syntactic &g1, const syntactic &g2)
• syntactic lcm (const syntactic &g1, const syntactic &g2)
• syntactic xgcd (const syntactic &g1, const syntactic &g2)
• syntactic ordered_sum (const vector< syntactic > &v)
• syntactic ordered_product (const vector< syntactic > &v)
• bool operator< (const syntactic &x, const syntactic &y)
• bool operator<= (const syntactic &x, const syntactic &y)
• bool operator> (const syntactic &x, const syntactic &y)
• bool operator>= (const syntactic &x, const syntactic &y)
• syntactic sqrt (const syntactic &g)
• syntactic exp (const syntactic &g)
• syntactic log (const syntactic &g)
• syntactic cos (const syntactic &g)
• syntactic sin (const syntactic &g)
• syntactic tan (const syntactic &g)
• syntactic acos (const syntactic &g)
• syntactic asin (const syntactic &g)
• syntactic atan (const syntactic &g)
• syntactic cosh (const syntactic &g)
• syntactic sinh (const syntactic &g)
• syntactic tanh (const syntactic &g)
• syntactic acosh (const syntactic &g)
• syntactic asinh (const syntactic &g)
• syntactic atanh (const syntactic &g)
• syntactic pow (const syntactic &g1, const syntactic &g2)
• syntactic pow (const syntactic &g1, const int &g2)
• syntactic pow (const int &g1, const syntactic &g2)
• syntactic hypot (const syntactic &g1, const syntactic &g2)
• syntactic atan2 (const syntactic &g1, const syntactic &g2)
• syntactic trig (const syntactic &g)
• syntactic Re (const syntactic &g1)
• syntactic Im (const syntactic &g1)
• syntactic abs (const syntactic &g1)
• syntactic arg (const syntactic &g1)
• syntactic conj (const syntactic &g1)
• syntactic gaussian (const syntactic &g1, const syntactic &g2)
• syntactic polar (const syntactic &g1, const syntactic &g2)
• syntactic center (const syntactic &g1)
• syntactic radius (const syntactic &g1)
• syntactic numerator (const syntactic &x)
• syntactic denominator (const syntactic &x)
• syntactic operator<< (const syntactic &x1, const syntactic &x2)
• syntactic operator>> (const syntactic &x1, const syntactic &x2)
• syntactic lshiftz (const syntactic &g, const syntactic &sh)
• syntactic rshiftz (const syntactic &g, const syntactic &sh)
• syntactic derive (const syntactic &g)
• syntactic derive (const syntactic &g, const syntactic &v)
• syntactic xderive (const syntactic &g)
• syntactic xderive (const syntactic &g, const syntactic &v)
• syntactic integrate (const syntactic &g)
• syntactic integrate (const syntactic &g, const syntactic &v)
• syntactic sqrt_init (const syntactic &x, const syntactic &c)
• syntactic log_init (const syntactic &x, const syntactic &c)
• syntactic acos_init (const syntactic &x, const syntactic &c)
• syntactic asin_init (const syntactic &x, const syntactic &c)
• syntactic atan_init (const syntactic &x, const syntactic &c)
• syntactic integrate_init (const syntactic &x, const syntactic &c)
• syntactic integrate_init (const syntactic &g, const syntactic &v, const syntactic &c)
• syntactic solve_lde_init (const syntactic &x, const syntactic &c)
• syntactic inject (const syntactic &x, const syntactic &y, const syntactic &z)
• syntactic project (const syntactic &x, const syntactic &y)
• bool operator== (const vector< syntactic > &v, const vector< syntactic > &w)
• bool operator!= (const vector< syntactic > &v, const vector< syntactic > &w)
• bool exact_eq (const vector< syntactic > &v, const vector< syntactic > &w)
• bool exact_new (const vector< syntactic > &v, const vector< syntactic > &w)
• template<typename C > syntactic flatten (C *const &x)
• syntactic flatten (const bool &b)
• syntactic flatten (const char &i)
• syntactic flatten (const signed char &i)
• syntactic flatten (const unsigned char &i)
• syntactic flatten (const short int &i)
• syntactic flatten (const short unsigned int &i)
• syntactic flatten (const int &i)
• syntactic flatten (const unsigned int &i)
• syntactic flatten (const long int &i)
• syntactic flatten (const long unsigned int &i)
• syntactic flatten (const long long int &i)
• syntactic flatten (const long long unsigned int &i)
• syntactic flatten (const float &x)
• syntactic flatten (const double &x)
• syntactic flatten (const long double &x)
• syntactic flatten (const char *const &s)
• syntactic flatten (const string &s)
• string get_env (const string &var)
• int set_env (const string &var, const string &value)
• string get_pid ()
• int system (const string &s)
• void init_system ()
• string user_dir ()
• string prefix_dir ()
• string sysconf_dir ()
• string load_path ()
• string eval_system (const string &s)
• int exec (const vector< string > &v)
• bool file_test (const string &file_name, const string &attrs)
• bool file_exists (const string &file_name)
• bool file_is_file (const string &file_name)
• bool file_is_directory (const string &file_name)
• bool file_is_script (const string &file_name)
• double file_last_modified (const string &file_name)
• string decode_name (const string &name)
• string canonical_name (const string &name)
• string path_name (const string &file_path, const string &file_name)
• string get_directory (const string &name)
• string strip_directory (const string &name)
• string get_extension (const string &name)
• string strip_extension (const string &name)
• string relative_name (const string &base, const string &name)
• string resolve_name (const string &base, const string &name)
• string follow_link (const string &name, const bool &recurse)
• bool load (const string &file_name, string &s)
• bool load (const string &fp, const string &file_name, string &s)
• bool save (const string &file_name, const string &s)
• bool load_directory (const string &name, vector< string > &s)
• bool mkdir (const string &orig_name)
• string dl_suffix ()
• string dl_option ()
• bool dl_exists (const string &name)
• bool dl_linked (const string &name)
• void dl_link (const string &name, const string &init)
• void dl_link (const string &name)
• void include (const string &name)
• template<typename C , typename T , typename V > C & I (table< C, T, V > &t)
• template<typename C , typename T , typename V > const C & I (const table< C, T, V > &t)
• template<typename C , typename T , typename V > const C & read_I (const table< C, T, V > &t)
• template<typename C , typename T , typename V > nat N (const table< C, T, V > &t)
• template<typename C , typename T , typename V > void simplify (table< C, T, V > &t)
• template<typename C , typename T , typename V > bool operator== (const table< C, T, V > &t1, const table< C, T, V > &t2)
• template<typename C , typename T , typename V > table_rep< C, T, V > * inside (const table< C, T, V > &x)
• template<typename C , typename T , typename V > nat hard_hash (const table< C, T, V > &x)
• template<typename C , typename T , typename V > bool hard_eq (const table< C, T, V > &x, const table< C, T, V > &y)
• template<typename C , typename T , typename V > bool hard_neq (const table< C, T, V > &x, const table< C, T, V > &y)
• DEFINE_BINARY_FORMAT_3 (table) STYPE_TO_TYPE(template< typename C
• template<typename C , typename T , typename V > format< C > CF1 (const table< C, T, V > &t)
• template<typename C , typename T , typename V > format< T > CF2 (const table< C, T, V > &t)
• template<typename C , typename T , typename V , typename K > const C & read (const table< C, T, V > &t, const K &x)
• template<typename C , typename T , typename V , typename K > void reset (table< C, T, V > &t, const K &x)
• template<typename C , typename T , typename V , typename K > bool contains (const table< C, T, V > &t, const K &x)
• template<typename C , typename T , typename V , typename K > void inside_set (const table< C, T, V > &t, const K &x, const C &v)
• template<typename C , typename T , typename V > const C & read (const table< C, T, V > &t, const T &x)
• template<typename C , typename T , typename V > void reset (table< C, T, V > &t, const T &x)
• template<typename C , typename T , typename V > bool contains (const table< C, T, V > &t, const T &x)
• template<typename C , typename T , typename V > void inside_set (const table< C, T, V > &t, const T &x, const C &v)
• template<typename C , typename T , typename V > double complexity (const table< C, T, V > &t)
• template<typename C , typename T , typename V > nat discrete_complexity (const table< C, T, V > &t)
• template<typename C , typename T , typename V > iterator< T > entries (const table< C, T, V > &t)
• template<typename C , typename T , typename V > iterator< pair< T, C > > iterate (const table< C, T, V > &t)
• template<typename C , typename T , typename V > syntactic flatten (const table< C, T, V > &t)
• template<typename Op , typename C , typename T , typename V > nat unary_hash (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > copy (const table< C, T, V > &t)
• template<typename Op , typename C , typename T , typename V > table< C, T, V > unary_map (const table< C, T, V > &t)
• template<typename Op , typename C , typename T , typename V > table< C, T, V > binary_map (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename Op , typename C , typename T , typename V , typename X > table< C, T, V > binary_map_scalar (const table< C, T, V > &t, const X &x)
• template<typename Op , typename C , typename T , typename V > table< C, T, V > & unary_set (table< C, T, V > &t, const table< C, T, V > &u)
• template<typename Op , typename C , typename T , typename V , typename X > table< C, T, V > & unary_set_scalar (table< C, T, V > &t, const X &x)
• template<typename Op , typename C , typename T , typename V > bool binary_test (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename Op , typename C , typename T , typename V , typename X > bool binary_test_scalar (const table< C, T, V > &t, const X &c)
• template<typename Op , typename C , typename T , typename V > C big (const table< C, T, V > &t)
• template<typename Op , typename C , typename T , typename V > table< C, T, V > binary_combine (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename Op , typename C , typename T , typename V > table< C, T, V > unary_filter (const table< C, T, V > &t)
• template<typename T1 , typename C1 , typename T2 , typename C2 , typename Fun1 , typename Fun2 > table< C2, T2 > map (const Fun1 &funT, const Fun2 &funC, const table< C1, T1 > &t, const format< T2 > &fmT, const format< C2 > &fmC)
• template<typename C , typename T , typename V > table< C, T, V > duplicate (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > operator- (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > operator+ (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > operator+ (const table< C, T, V > &t, const C &u)
• template<typename C , typename T , typename V > table< C, T, V > operator+ (const C &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > operator- (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > operator- (const table< C, T, V > &t, const C &u)
• template<typename C , typename T , typename V > table< C, T, V > operator- (const C &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > operator* (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > operator/ (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > quo (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > rem (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > operator| (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > operator& (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > inf (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > sup (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V , typename K > table< C, T, V > operator* (const table< C, T, V > &t, const K &sc)
• template<typename C , typename T , typename V , typename K > table< C, T, V > operator* (const K &sc, const table< C, T, V > &t)
• template<typename C , typename T , typename V , typename K > table< C, T, V > operator/ (const table< C, T, V > &t, const K &sc)
• template<typename C , typename T , typename V , typename K > table< C, T, V > operator/ (const K &sc, const table< C, T, V > &t)
• template<typename C , typename T , typename V , typename K > table< C, T, V > quo (const table< C, T, V > &t, const K &sc)
• template<typename C , typename T , typename V , typename K > table< C, T, V > rem (const table< C, T, V > &t, const K &sc)
• template<typename C , typename T , typename V > table< C, T, V > operator+= (table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > operator-= (table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > operator*= (table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > operator/= (table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > operator|= (table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > operator&= (table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V , typename K > table< C, T, V > & operator*= (table< C, T, V > &t, const K &sc)
• template<typename C , typename T , typename V , typename K > table< C, T, V > & operator/= (table< C, T, V > &t, const K &sc)
• template<typename C , typename T , typename V > bool operator<= (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > bool operator>= (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V , typename K > bool operator== (const table< C, T, V > &t, const K &c)
• template<typename C , typename T , typename V , typename K > bool operator<= (const table< C, T, V > &t, const K &c)
• template<typename C , typename T , typename V , typename K > bool operator>= (const table< C, T, V > &t, const K &c)
• template<typename C , typename T , typename V > nat hash (const table< C, T, V > &x)
• template<typename C , typename T , typename V > bool operator!= (const table< C, T, V > &x, const table< C, T, V > &y)
• template<typename C , typename T , typename V > nat exact_hash (const table< C, T, V > &x)
• template<typename C , typename T , typename V > bool exact_eq (const table< C, T, V > &x, const table< C, T, V > &y)
• template<typename C , typename T , typename V > bool exact_neq (const table< C, T, V > &x, const table< C, T, V > &y)
• template<typename C , typename T , typename V > table< C, T, V > operator+ (const table< C, T, V > &x, const int &y)
• template<typename C , typename T , typename V > table< C, T, V > operator+ (const int &x, const table< C, T, V > &y)
• template<typename C , typename T , typename V > table< C, T, V > operator- (const table< C, T, V > &x, const int &y)
• template<typename C , typename T , typename V > table< C, T, V > operator- (const int &x, const table< C, T, V > &y)
• template<typename C , typename T , typename V > bool operator< (const table< C, T, V > &x, const table< C, T, V > &y)
• template<typename C , typename T , typename V > bool operator> (const table< C, T, V > &x, const table< C, T, V > &y)
• template<typename C , typename T , typename V > table< C, T, V > sqrt (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > exp (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > log (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > cos (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > sin (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > tan (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > acos (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > asin (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > atan (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > pow (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > pow (const table< C, T, V > &t, const int &u)
• template<typename C , typename T , typename V > table< C, T, V > pow (const int &u, const table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_add (const table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_mul (const table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_or (const table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_and (const table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_min (const table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_max (const table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_inf (const table< C, T, V > &t)
• template<typename C , typename T , typename V > C big_sup (const table< C, T, V > &t)
• template<typename C , typename T , typename V > bool is_finite (const table< C, T, V > &t)
• template<typename C , typename T , typename V > bool is_nan (const table< C, T, V > &t)
• template<typename C , typename T , typename V > bool is_infinite (const table< C, T, V > &t)
• template<typename C , typename T , typename V > bool is_fuzz (const table< C, T, V > &t)
• template<typename C , typename T , typename V > bool is_reliable (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > sharpen (const table< C, T, V > &t)
• template<typename C , typename T , typename V , typename K > table< C, T, V > blur (const table< C, T, V > &t, const K &x)
• template<typename C , typename T , typename V > table< T, C, V > reverse (const table< C, T, V > &t)
• template<typename C , typename T , typename V > table< C, T, V > & operator<< (table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > append (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > common (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename C , typename T , typename V > table< C, T, V > difference (const table< C, T, V > &t, const table< C, T, V > &u)
• template<typename T , typename C > table< C, T > make_mmx_table (const format< T > &fm1, const format< C > &fm2)
• template<typename T , typename C > table< C, T > make_mmx_table (const C &init, const format< T > &fm)
• template<typename T , typename C > table< C, T > make_mmx_table (const vector< pair< T, C > > &v)
• template<typename T , typename C > table< C, T > make_mmx_table (const C &init, const vector< pair< T, C > > &v)
• template<typename T , typename C > T get_key (const pair< T, C > &p)
• template<typename T , typename C > C get_value (const pair< T, C > &p)
• template<typename C > bool ttable_contains (const table< C, generic > &t, const generic &a, const generic &b, const vector< generic > &c)
• template<typename C > C ttable_access (const table< C, generic > &t, const generic &a, const generic &b, const vector< generic > &c)
• template<typename C > C & ttable_access (table< C, generic > &t, const generic &a, const generic &b, const vector< generic > &c)
• template<typename C > void ttable_reset (table< C, generic > &t, const generic &a, const generic &b, const vector< generic > &c)
• task_rep * inside (const task &x)
• template<> nat hard_hash (const task &x)
• template<> bool hard_eq (const task &x, const task &y)
• template<> bool hard_neq (const task &x, const task &y)
• void threads_initialize (nat n)
• void threads_terminate ()
• void threads_execute (task *ts, nat n)
• void threads_simple_loop (nat nr_instances, nat nr_iterations)
• int threads_get_number ()
• void threads_set_number (const int &n)
• int get_number_cores ()
• nat mmx_time ()

  Relative time of day.
  

• double mmx_var_time ()
• string mmx_time_unit ()
• nat mmx_user_time ()

  User time of the current process and its terminated children.
  

• string mmx_user_time_unit ()
• xnat mmx_cpu_time ()

  Number of cycles of the cpu.
  

• string mmx_cpu_time_unit ()
• DEFINE_TERNARY_FORMAT_3 (triple) template< typename C1
• C3 C1 first (const triple< C1, C2, C3 > &t)
• template<typename C1 , typename C2 , typename C3 > C2 second (const triple< C1, C2, C3 > &t)
• template<typename C1 , typename C2 , typename C3 > C3 third (const triple< C1, C2, C3 > &t)
• template<typename C1 , typename C2 , typename C3 > format< C1 > CF1 (const triple< C1, C2, C3 > &t)
• template<typename C1 , typename C2 , typename C3 > format< C2 > CF2 (const triple< C1, C2, C3 > &t)
• template<typename C1 , typename C2 , typename C3 > format< C3 > CF3 (const triple< C1, C2, C3 > &t)
• template<typename Op , typename C1 , typename C2 , typename C3 > nat unary_hash (const triple< C1, C2, C3 > &t)
• template<typename Op , typename C1 , typename C2 , typename C3 > bool binary_test (const triple< C1, C2, C3 > &t1, const triple< C1, C2, C3 > &t2)
• template<typename C1 , typename C2 , typename C3 > nat hash (const triple< C1, C2, C3 > &x)
• template<typename C1 , typename C2 , typename C3 > bool operator== (const triple< C1, C2, C3 > &x, const triple< C1, C2, C3 > &y)
• template<typename C1 , typename C2 , typename C3 > bool operator!= (const triple< C1, C2, C3 > &x, const triple< C1, C2, C3 > &y)
• template<typename C1 , typename C2 , typename C3 > nat exact_hash (const triple< C1, C2, C3 > &x)
• template<typename C1 , typename C2 , typename C3 > bool exact_eq (const triple< C1, C2, C3 > &x, const triple< C1, C2, C3 > &y)
• template<typename C1 , typename C2 , typename C3 > bool exact_neq (const triple< C1, C2, C3 > &x, const triple< C1, C2, C3 > &y)
• template<typename C1 , typename C2 , typename C3 > nat hard_hash (const triple< C1, C2, C3 > &x)
• template<typename C1 , typename C2 , typename C3 > bool hard_eq (const triple< C1, C2, C3 > &x, const triple< C1, C2, C3 > &y)
• template<typename C1 , typename C2 , typename C3 > bool hard_neq (const triple< C1, C2, C3 > &x, const triple< C1, C2, C3 > &y)
• template<typename C1 , typename C2 , typename C3 > syntactic flatten (const triple< C1, C2, C3 > &t)
• WRAP_INDIRECT_IMPL (template< typename C > inline, tuple< C >) template< typename C > inline nat N(const tuple< C > &t)
• template<typename C > syntactic flatten (const tuple< C > &t)
• WRAP_BINARY_IMPL_1 (template< typename C >, tuple< C >, generic,"Tu","Tuple", C) template< typename C > tuple< C > as_tuple(const vector< C > &a)
• template<typename C > vector< C > as_vector (const tuple< C > &t)
• template<typename C > iterator< C > iterate (const tuple< C > &t)
• nat new_tuple_type_id (nat id)
• void tuple_type_info (nat &id, bool &mode)
• bool is_tuple_type (nat id)
• nat tuple_to_scalar (nat id)
• template<typename C > format< C > copy (const format< C > &x)
• template<typename C > bool operator== (const format< C > &x, const format< C > &y)
• template<typename C > bool operator!= (const format< C > &x, const format< C > &y)
• template<typename C > bool exact_eq (const format< C > &x, const format< C > &y)
• template<typename C > bool exact_neq (const format< C > &x, const format< C > &y)
• template<typename C > bool hard_eq (const format< C > &x, const format< C > &y)
• template<typename C > bool hard_neq (const format< C > &x, const format< C > &y)
• template<typename C > nat hash (const format< C > &x)
• template<typename C > nat exact_hash (const format< C > &x)
• template<typename C > nat hard_hash (const format< C > &x)
• template<typename C > syntactic flatten (const format< C > &x)
• template<typename C > format< C > get_format (const C &x)
• template<typename C > C get_sample (const format< C > &fm)
• template<typename C > format< typename
  coefficient1_type_helper< C >
  ::val > get_format1 (const format< C > &fm)
• template<typename C > format< typename
  coefficient2_type_helper< C >
  ::val > get_format2 (const format< C > &fm)
• template<typename F , typename T > scalar_type_helper< T >::val promote_scalar (const F &x, const T &y)
• template<typename T > scalar_type_helper< T >::val zero_scalar (const T &y)
• template<typename T > T * mmx_formatted_new (nat l, const format< T > &fm)
• template<typename Op , typename C > format< typename
  unary_return_type_helper< Op,
  C >::RET > unary_map (const format< C > &fm)
• template<typename Op , typename C1 , typename C2 > format< typename
  binary_return_type_helper< Op,
  C1, C2 >::RET > binary_map_scalar (const format< C1 > &fm, const C2 &x)
• template<typename Op , typename C1 , typename C2 > format< typename
  binary_return_type_helper< Op,
  C1, C2 >::RET > binary_map (const format< C1 > &fm1, const format< C2 > &fm2)
• template<typename T , typename F > void set_as (T &r, const F &x)
• template<typename T , typename F > T outplace_set_as (const F &x)
• template<typename T , typename F > T promote (const F &x, const format< T > &fm)
• template<typename T > fast_helper< T >::fast_type fast (const T &x)
• template<typename T > T slow (const typename fast_helper< T >::fast_type &x)
• template<typename T , typename F > T slow_as (const F &x)
• template<typename T > format< typename fast_helper
  < T >::fast_type > fast (const format< T > &fm)
• template<typename T > format< T > slow (const format< typename fast_helper< T >::fast_type > &fm)
• template<typename T , typename F > format< T > slow_as (const format< F > &fm)
• template<typename C > unary_return_type_helper
  < lift_op, C >::RET lift (const C &x)
• template<typename C , typename R > void set_lift (R &y, const C &x)
• template<typename C > format< typename
  unary_return_type_helper
  < lift_op, C >::RET > lift (const format< C > &fm)
• template<typename C > unary_return_type_helper
  < project_op, C >::RET project (const C &x)
• template<typename C , typename R > void set_project (R &y, const C &x)
• template<typename C > format< typename
  unary_return_type_helper
  < project_op, C >::RET > project (const format< C > &fm)
• template<typename T > void set_zero (T &x)
• template<typename T > void set_one (T &x)
• template<typename T > void set_true (T &x)
• template<typename T > void set_false (T &x)
• template<typename T > void set_default (T &x)
• template<typename T > void set_pi (T &x)
• template<typename T > void set_nan (T &x)
• template<typename T > void set_imaginary (T &x)
• template<typename T > void set_accuracy (T &x)
• template<typename T > void set_infinity (T &x)
• template<typename T > void set_smallest (T &x)
• template<typename T > void set_largest (T &x)
• template<typename T > void set_maximal (T &x)
• template<typename T > void set_minimal (T &x)
• void set_default (bool &x)
• template<typename C > C zero_cst ()
• template<typename C > C one_cst ()
• template<typename C > C default_cst ()
• template<typename C > C pi_cst ()
• template<typename C > C log2_cst ()
• template<typename C > C euler_cst ()
• template<typename C > C catalan_cst ()
• template<typename C > C imaginary_cst ()
• template<typename C > C nan_cst ()
• template<typename C > C fuzz_cst ()
• template<typename C > C smallest_cst ()
• template<typename C > C largest_cst ()
• template<typename C > C accuracy_cst ()
• template<typename C > C infinity_cst ()
• template<typename C > C maximal_cst ()
• template<typename C > C minimal_cst ()
• template<typename C > C default_cst (const format< C > &fm)
• template<typename C > C pi_cst (const format< C > &fm)
• template<typename C > C log2_cst (const format< C > &fm)
• template<typename C > C euler_cst (const format< C > &fm)
• template<typename C > C catalan_cst (const format< C > &fm)
• template<typename C > C imaginary_cst (const format< C > &fm)
• template<typename C > C nan_cst (const format< C > &fm)
• template<typename C > C fuzz_cst (const format< C > &fm)
• template<typename C > C smallest_cst (const format< C > &fm)
• template<typename C > C largest_cst (const format< C > &fm)
• template<typename C > C accuracy_cst (const format< C > &fm)
• template<typename C > C infinity_cst (const format< C > &fm)
• template<typename C > C maximal_cst (const format< C > &fm)
• template<typename C > C minimal_cst (const format< C > &fm)
• template<typename M > void raw_write (M &m, const char *p, nat n)
• template<typename M > void raw_read (M &m, const char *p, nat n)
• template<typename M > void raw_write_length (M &m, nat l)
• template<typename M > void raw_read_length (M &m, nat &l)
• template<typename C > unary_return_type_helper
  < abs_op, C >::RET rounding_error (const C &x)
• template<typename C > unary_return_type_helper
  < abs_op, C >::RET additive_error (const C &x)
• template<typename C > unary_return_type_helper
  < abs_op, C >::RET multiplicative_error (const C &x)
• template<typename C > unary_return_type_helper
  < abs_op, C >::RET elementary_error (const C &x)
• template<typename B , typename C , typename R > B make_ball (const C &c, const R &r)
• template<typename C > C center (const C &x)
• template<typename C > unary_return_type_helper
  < abs_op, C >::RET radius (const C &x)
• template<typename C > unary_return_type_helper
  < abs_op, C >::RET abs_down (const C &x)
• template<typename C > unary_return_type_helper
  < abs_op, C >::RET abs_up (const C &x)
• template<typename C > unary_return_type_helper
  < abs_op, C >::RET bnd_down (const C &x)
• template<typename C > unary_return_type_helper
  < abs_op, C >::RET bnd_up (const C &x)
• template<typename B , typename C > B make_interval (const C &l, const C &r)
• template<typename C > C lower (const C &x)
• template<typename C > C upper (const C &x)
• template<typename C , typename V > nat N (const vector< C, V > &v)
• template<typename C , typename V > C * seg (vector< C, V > &v)
• template<typename C , typename V > const C * seg (const vector< C, V > &v)
• template<typename C , typename V > C * seg_inside (const vector< C, V > &v)
• template<typename C , typename V > bool is_a_scalar (const vector< C, V > &v)
• template<typename C , typename V > bool is_non_scalar (const vector< C, V > &v)
• template<typename C , typename V > vector_rep< C, V > * inside (const vector< C, V > &x)
• template<typename C , typename V > nat hard_hash (const vector< C, V > &x)
• template<typename C , typename V > bool hard_eq (const vector< C, V > &x, const vector< C, V > &y)
• template<typename C , typename V > bool hard_neq (const vector< C, V > &x, const vector< C, V > &y)
• template<typename C , typename V > format< C > CF (const vector< C, V > &v)
• template<typename C , typename V > const C & read (const vector< C, V > &v, nat i)
• template<typename C , typename V , typename C2 , typename V2 > vector< C, V > extend (const vector< C, V > &v, const vector< C2, V2 > &w)
• template<typename C , typename V > bool is_nil (const vector< C, V > &v)
• template<typename C , typename V > bool is_atom (const vector< C, V > &v)
• template<typename T , typename F , typename TV , typename FV > void set_as (vector< T, TV > &r, const vector< F, FV > &v)
• template<typename C , typename V , typename T > void set_as (vector< C, V > &r, const T &x)
• vector< generic > abstract_vector (const generic &conc)
• generic concrete_vector (const vector< generic > &abst, const generic &conc)
• template<typename C , typename V , typename S > nat N (const vector< C, vector_fixed< V, S > > &v)
• template<typename C , typename V , typename S > bool is_a_scalar (const vector< C, vector_fixed< V, S > > &v)
• template<typename C , typename V , typename S > bool is_non_scalar (const vector< C, vector_fixed< V, S > > &v)
• template<typename C > vector< C > vec ()
• template<typename C > vector< C > vec (const format< C > &fm)
• template<typename C > vector< C > vec (const C &c1)
• template<typename C > vector< C > vec (const C &c1, const C &c2)
• template<typename C > vector< C > vec (const C &c1, const C &c2, const C &c3)
• template<typename C > vector< C > vec (const C &c1, const C &c2, const C &c3, const C &c4)
• template<typename C > vector< C > vec (const C &c1, const C &c2, const C &c3, const C &c4, const C &c5)
• template<typename C > vector< C > vec (const C &c1, const C &c2, const C &c3, const C &c4, const C &c5, const C &c6)
• template<typename C > vector< C > vec (const C &c1, const C &c2, const C &c3, const C &c4, const C &c5, const C &c6, const C &c7)
• template<typename C > vector< C > vec (const C &c1, const C &c2, const C &c3, const C &c4, const C &c5, const C &c6, const C &c7, const C &c8)
• template<typename C > vector< C > fill (nat n)
• template<typename C > vector< C > fill (nat n, const format< C > &fm)
• template<typename C > vector< C > fill (const C &c, nat n)
• template<typename C , typename V > iterator< C > iterate (const vector< C, V > &v)
• template<typename C , typename V > syntactic flatten (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > range (const vector< C, V > &v, nat start, nat end)
• template<typename C , typename V > vector< C, V > extract_mod (const vector< C, V > &v, nat k, nat p)
• template<typename C , typename V > vector< C, V > extract (const vector< C, V > &v, vector< nat > e)
• template<typename C , typename V > vector< C, V > remove (const vector< C, V > &v, vector< nat > e)
• template<typename C , typename V > C car (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > cdr (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > append (const vector< C, V > &v, const C &c)
• template<typename C , typename V > vector< C, V > append (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > cons (const C &c, const vector< C, V > &v)
• template<typename C , typename V > void inside_append (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > reverse (const vector< C, V > &v)
• template<typename C , typename V > int find (const vector< C, V > &v, const C &x)
• template<typename C , typename V > bool contains (const vector< C, V > &v, const C &x)
• template<typename C , typename V > vector< C, V > insert (const vector< C, V > &v, const C &x)
• template<typename C , typename V > vector< C, V > insert (const vector< C, V > &v, const C &x, nat pos)
• template<typename C , typename V , typename W > vector< C, V > insert (const vector< C, V > &v, const vector< C, V > &x, const vector< nat, W > &pos)
• template<typename Op , typename C , typename V > nat unary_hash (const vector< C, V > &v)
• template<typename Op , typename C , typename V > vector< typename
  unary_return_type_helper< Op,
  C >::RET, V > unary_map (const vector< C, V > &v)
• template<typename Op , typename C1 , typename C2 , typename V > vector< typename
  binary_return_type_helper< Op,
  C1, C2 >::RET, V > binary_map (const vector< C1, V > &v, const vector< C2, V > &w)
• template<typename Op , typename C , typename V , typename X > vector< typename
  binary_return_type_helper< Op,
  C, X >::RET, V > binary_map_scalar (const vector< C, V > &v, const X &x)
• template<typename Op , typename C , typename V > vector< C, V > & nullary_set (vector< C, V > &v)
• template<typename Op , typename T , typename C , typename V > vector< T, V > & unary_set (vector< T, V > &v, const vector< C, V > &w)
• template<typename Op , typename T , typename V , typename X > vector< T, V > & unary_set_scalar (vector< T, V > &v, const X &x)
• template<typename Op , typename C1 , typename C2 , typename V > bool binary_test (const vector< C1, V > &v, const vector< C2, V > &w)
• template<typename Op , typename C , typename V , typename X > bool binary_test_scalar (const vector< C, V > &v, const X &c)
• template<typename Op , typename C , typename V > unary_return_type_helper< Op,
  C >::RET big (const vector< C, V > &v)
• template<typename Op , typename C , typename V > unary_return_type_helper< Op,
  C >::RET big_dicho (const vector< C, V > &v)
• template<typename S1 , typename D > vector< D > map (const function_1< D, typename argument_helper< S1 >::arg_type > &fun, const vector< S1 > &v1)
• template<typename S1 , typename D > vector< D > map (D(*fun)(const S1 &), const vector< S1 > &v1)
• template<typename S1 , typename D , typename Fun > vector< D > map (const Fun &fun, const vector< S1 > &v1, const format< D > &fm)
• template<typename S1 , typename S2 , typename D > vector< D > map (const function_2< D, typename argument_helper< S1 >::arg_type, typename argument_helper< S2 >::arg_type > &fun, const vector< S1 > &v1, const vector< S2 > &v2)
• template<typename S1 , typename S2 , typename D > vector< D > map (D(*fun)(const S1 &, const S2 &), const vector< S1 > &v1, const vector< S2 > &v2)
• template<typename S1 , typename S2 , typename D , typename Fun > vector< D > map (const Fun &fun, const vector< S1 > &v1, const vector< S2 > &v2, const format< D > &fm)
• template<typename S1 , typename S2 , typename S3 , typename D > vector< D > map (const function_3< D, typename argument_helper< S1 >::arg_type, typename argument_helper< S2 >::arg_type, typename argument_helper< S3 >::arg_type > &fun, const vector< S1 > &v1, const vector< S2 > &v2, const vector< S3 > &v3)
• template<typename S1 , typename S2 , typename S3 , typename D , typename Fun > vector< D > map (const Fun &fun, const vector< S1 > &v1, const vector< S2 > &v2, const vector< S3 > &v3, const format< D > &fm)
• template<typename S1 , typename Fun > void foreach (const Fun &fun, const vector< S1 > &v1)
• template<typename S1 , typename S2 , typename Fun > void foreach (const Fun &fun, const vector< S1 > &v1, const vector< S2 > &v2)
• template<typename S1 , typename S2 , typename S3 , typename Fun > void foreach (const Fun &fun, const vector< S1 > &v1, const vector< S2 > &v2, const vector< S3 > &v3)
• template<typename C , typename V > void set_default (vector< C, V > &v)
• template<typename C , typename V > void set_pi (vector< C, V > &v)
• template<typename C , typename V > void set_log2 (vector< C, V > &v)
• template<typename C , typename V > void set_euler (vector< C, V > &v)
• template<typename C , typename V > void set_catalan (vector< C, V > &v)
• template<typename C , typename V > void set_imaginary (vector< C, V > &v)
• template<typename C , typename V > void set_nan (vector< C, V > &v)
• template<typename C , typename V > void set_fuzz (vector< C, V > &v)
• template<typename C , typename V > void set_smallest (vector< C, V > &v)
• template<typename C , typename V > void set_largest (vector< C, V > &v)
• template<typename C , typename V > void set_accuracy (vector< C, V > &v)
• template<typename C , typename V > void set_infinity (vector< C, V > &v)
• template<typename C , typename V > void set_maximal (vector< C, V > &v)
• template<typename C , typename V > void set_minimal (vector< C, V > &v)
• template<typename C , typename V > vector< C, V > copy (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > duplicate (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > operator- (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > operator+ (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > operator+ (const C &v, const vector< C, V > &w)
• template<typename V > vector< int, V > operator+ (const int &v, const vector< int, V > &w)
• template<typename C , typename V > vector< C, V > operator+ (const vector< C, V > &w, const C &v)
• template<typename V > vector< int, V > operator+ (const vector< int, V > &w, const int &v)
• template<typename C , typename V > vector< C, V > operator- (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > operator- (const vector< C, V > &v, const C &w)
• template<typename V > vector< int, V > operator- (const vector< int, V > &v, const int &w)
• template<typename C , typename V > vector< C, V > operator- (const C &v, const vector< C, V > &w)
• template<typename V > vector< int, V > operator- (const int &v, const vector< int, V > &w)
• template<typename C , typename V > vector< C, V > operator* (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > operator/ (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > quo (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > rem (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > operator* (const vector< C, V > &v, const C &c)
• template<typename V > vector< int, V > operator* (const vector< int, V > &v, const int &c)
• template<typename C , typename V > vector< C, V > operator* (const C &c, const vector< C, V > &v)
• template<typename V > vector< int, V > operator* (const int &c, const vector< int, V > &v)
• template<typename C , typename V > vector< C, V > operator/ (const vector< C, V > &v, const C &c)
• template<typename V > vector< int, V > operator/ (const vector< int, V > &v, const int &c)
• template<typename C , typename V > vector< C, V > operator/ (const C &c, const vector< C, V > &v)
• template<typename V > vector< int, V > operator/ (const int &c, const vector< int, V > &v)
• template<typename C , typename V > vector< C, V > quo (const vector< C, V > &v, const C &c)
• template<typename C , typename V > vector< C, V > rem (const vector< C, V > &v, const C &c)
• template<typename C , typename V > vector< C, V > operator| (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > operator& (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > & operator+= (vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > & operator-= (vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > & operator*= (vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > & operator/= (vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > & operator*= (vector< C, V > &v, const C &c)
• template<typename C , typename V > vector< C, V > & operator/= (vector< C, V > &v, const C &c)
• template<typename C , typename V > vector< C, V > inf (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > sup (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > bool operator<= (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > bool operator>= (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > bool operator== (const vector< C, V > &v, const C &c)
• template<typename C , typename V > bool operator!= (const vector< C, V > &v, const C &c)
• template<typename C , typename V > bool operator<= (const vector< C, V > &v, const C &c)
• template<typename C , typename V > bool operator< (const vector< C, V > &v, const C &c)
• template<typename C , typename V > bool operator>= (const vector< C, V > &v, const C &c)
• template<typename C , typename V > bool operator> (const vector< C, V > &v, const C &c)
• template<typename C , typename V > bool operator== (const C &c, const vector< C, V > &v)
• template<typename C , typename V > bool operator!= (const C &c, const vector< C, V > &v)
• template<typename C , typename V > bool operator< (const C &c, const vector< C, V > &v)
• template<typename C , typename V > bool operator> (const C &c, const vector< C, V > &v)
• template<typename C , typename V > bool operator<= (const C &c, const vector< C, V > &v)
• template<typename C , typename V > bool operator>= (const C &c, const vector< C, V > &v)
• template<typename C , typename V > nat hash (const vector< C, V > &x)
• template<typename C , typename V > bool operator== (const vector< C, V > &x, const vector< C, V > &y)
• template<typename C , typename V > bool operator!= (const vector< C, V > &x, const vector< C, V > &y)
• template<typename C , typename V > nat exact_hash (const vector< C, V > &x)
• template<typename C , typename V > bool exact_eq (const vector< C, V > &x, const vector< C, V > &y)
• template<typename C , typename V > bool exact_neq (const vector< C, V > &x, const vector< C, V > &y)
• template<typename C , typename V > bool operator< (const vector< C, V > &x, const vector< C, V > &y)
• template<typename C , typename V > bool operator> (const vector< C, V > &x, const vector< C, V > &y)
• template<typename C , typename V > vector< C, V > operator+ (const vector< C, V > &x, const int &y)
• template<typename C , typename V > vector< C, V > operator+ (const int &x, const vector< C, V > &y)
• template<typename C , typename V > vector< C, V > operator- (const vector< C, V > &x, const int &y)
• template<typename C , typename V > vector< C, V > operator- (const int &x, const vector< C, V > &y)
• template<typename C , typename V > vector< C, V > operator* (const vector< C, V > &x, const int &y)
• template<typename C , typename V > vector< C, V > operator* (const int &x, const vector< C, V > &y)
• template<typename C , typename V > vector< C, V > operator/ (const vector< C, V > &x, const int &y)
• template<typename C , typename V > vector< C, V > operator/ (const int &x, const vector< C, V > &y)
• template<typename C , typename V > bool operator== (const vector< C, V > &x, const int &y)
• template<typename C , typename V > bool operator!= (const vector< C, V > &x, const int &y)
• template<typename C , typename V > bool exact_eq (const vector< C, V > &x, const int &y)
• template<typename C , typename V > bool exact_neq (const vector< C, V > &x, const int &y)
• template<typename C , typename V > bool operator< (const vector< C, V > &x, const int &y)
• template<typename C , typename V > bool operator<= (const vector< C, V > &x, const int &y)
• template<typename C , typename V > bool operator> (const vector< C, V > &x, const int &y)
• template<typename C , typename V > bool operator>= (const vector< C, V > &x, const int &y)
• template<typename V > bool operator== (const vector< int, V > &v, const int &c)
• template<typename V > bool operator!= (const vector< int, V > &v, const int &c)
• template<typename V > bool operator<= (const vector< int, V > &v, const int &c)
• template<typename V > bool operator< (const vector< int, V > &v, const int &c)
• template<typename V > bool operator>= (const vector< int, V > &v, const int &c)
• template<typename V > bool operator> (const vector< int, V > &v, const int &c)
• template<typename C , typename V > vector< C, V > sqrt (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > exp (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > log (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > cos (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > sin (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > tan (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > acos (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > asin (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > atan (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > pow (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > vector< C, V > pow (const vector< C, V > &v, const C &w)
• template<typename C , typename V > vector< C, V > pow (const C &w, const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > pow (const vector< C, V > &v, const int &w)
• template<typename C , typename V > vector< C, V > pow (const int &w, const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > derive (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > integrate (const vector< C, V > &v)
• template<typename C , typename V , typename K , typename W > vector< C, V > integrate_init (const vector< C, V > &v, const vector< K, W > &w)
• template<typename C , typename V , typename X > vector< C, V > derive (const vector< C, V > &v, const X &x)
• template<typename C , typename V , typename X > vector< C, V > integrate (const vector< C, V > &v, const X &x)
• template<typename C , typename V > C big_add (const vector< C, V > &v)
• template<typename C , typename V > C big_mul (const vector< C, V > &v)
• template<typename C , typename V > C big_or (const vector< C, V > &v)
• template<typename C , typename V > C big_and (const vector< C, V > &v)
• template<typename C , typename V > C big_min (const vector< C, V > &v)
• template<typename C , typename V > C big_max (const vector< C, V > &v)
• template<typename C , typename V > C big_inf (const vector< C, V > &v)
• template<typename C , typename V > C big_sup (const vector< C, V > &v)
• template<typename C , typename V > vector< typename
  unary_return_type_helper
  < reconstruct_op, C >::RET > reconstruct (const vector< C, V > &v)
• template<typename C , typename V , typename W > bool is_reconstructible (const vector< C, V > &v, vector< typename unary_return_type_helper< reconstruct_op, C >::RET, W > &w)
• template<typename C , typename V , typename K > vector< typename
  binary_return_type_helper
  < evaluate_op, C, K >::RET > evaluate (const vector< C, V > &v, const K &x)
• template<typename C , typename V , typename K , typename W > bool is_evaluable (const vector< C, V > &v, const K &a, vector< typename binary_return_type_helper< evaluate_op, C, K >::RET, W > &w)
• template<typename C , typename V > vector< typename
  binary_return_type_helper
  < truncate_op, C,nat >::RET > truncate (const vector< C, V > &v, nat n)
• template<typename C , typename V > vector< typename
  unary_return_type_helper
  < complete_op, C >::RET > complete (const vector< C, V > &v)
• template<typename C , typename V > bool is_finite (const vector< C, V > &v)
• template<typename C , typename V > bool is_nan (const vector< C, V > &v)
• template<typename C , typename V > bool is_infinite (const vector< C, V > &v)
• template<typename C , typename V > bool is_fuzz (const vector< C, V > &v)
• template<typename C , typename V > bool is_reliable (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > change_precision (const vector< C, V > &v, xnat p)
• template<typename C , typename V > xnat precision (const vector< C, V > &v)
• template<typename C , typename V > xint exponent (const vector< C, V > &v)
• template<typename C , typename V > double magnitude (const vector< C, V > &v)
• template<typename C , typename V > vector< typename
  unary_return_type_helper
  < abs_op, C >::RET, V > abs (const vector< C, V > &v)
• template<typename C , typename V > vector< typename
  unary_return_type_helper
  < Re_op, C >::RET, V > Re (const vector< C, V > &v)
• template<typename C , typename V > vector< typename
  unary_return_type_helper
  < Re_op, C >::RET, V > Im (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > conj (const vector< C, V > &v)
• template<typename C , typename V > vector< typename
  unary_return_type_helper
  < center_op, C >::RET, V > center (const vector< C, V > &v)
• template<typename C , typename V > vector< typename
  unary_return_type_helper
  < radius_op, C >::RET, V > radius (const vector< C, V > &v)
• template<typename C , typename V > vector< typename
  unary_return_type_helper
  < center_op, C >::RET, V > lower (const vector< C, V > &v)
• template<typename C , typename V > vector< typename
  unary_return_type_helper
  < center_op, C >::RET, V > upper (const vector< C, V > &v)
• template<typename C , typename V > vector< C, V > sharpen (const vector< C, V > &v)
• template<typename C , typename V , typename K > vector< C, V > blur (const vector< C, V > &v, const K &x)
• template<typename C , typename V , typename C2 , typename V2 > vector< C, V > blur (const vector< C, V > &v, const vector< C2, V2 > &w)
• template<typename C , typename V > bool included (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C , typename V > C dot (const vector< C, V > &v, const vector< C, V > &w)
• template<typename C > vector< C > cos_sin (const C &x)
• template<typename C > vector< C > trig (const vector< C > &v)
• template<typename C , typename V > nat aligned_size (nat n)
• template<typename C > nat default_aligned_size (nat n)
• template<typename Op , typename T > static void sort_sub (vector< T > &a, int start, int end, vector< T > &merge_buf)
• template<typename Op , typename T > void sort_leq (vector< T > &v)
• template<typename T > void sort (vector< T > &v)
• template<typename Op , typename T > void sort_leq (vector< T > &v, vector< nat > &sigma)
• template<typename T > void sort (vector< T > &v, vector< nat > &sigma)
• generic CPP_APPLY (".()")
• generic CPP_ACCESS (".[]")
• generic CPP_AND ("and")
• generic CPP_ARROW ("->")
• generic CPP_ASSIGN (":=")
• generic CPP_BEGIN ("begin")
• generic CPP_BITWISE_AND ("/\\")
• generic CPP_BITWISE_OR ("\\/")
• generic CPP_BITWISE_XOR ("xor")
• generic CPP_BRACKETS ("()")
• generic CPP_BREAK ("break")
• generic CPP_CAST (":>")
• generic CPP_CATCH ("catch")
• generic CPP_COMPLEMENT ("~")
• generic CPP_CONST ("const")
• generic CPP_CONSTRUCT ("construct")
• generic CPP_CONSTRUCTOR ("constructor")
• generic CPP_CONTINUE ("continue")
• generic CPP_DEFINE ("==")
• generic CPP_DELETE ("delete")
• generic CPP_DESTRUCTOR ("destructor")
• generic CPP_DO ("do")
• generic CPP_DOT (".")
• generic CPP_ELSE ("else")
• generic CPP_EQUAL ("=")
• generic CPP_EXIT ("exit")
• generic CPP_EXTERN ("extern")
• generic CPP_FOR ("for")
• generic CPP_GTR (">")
• generic CPP_GTREQ (">=")
• generic CPP_GTRGTR (">>")
• generic CPP_GTRGTREQ (">>=")
• generic CPP_IF ("if")
• generic CPP_INHERIT ("inherit")
• generic CPP_INITIALIZE ("initialize")
• generic CPP_INLINE ("inline")
• generic CPP_LESS ("<")
• generic CPP_LESSEQ ("<=")
• generic CPP_LESSLESS ("<<")
• generic CPP_LESSLESSEQ ("<<=")
• generic CPP_MINUS ("-")
• generic CPP_MINUS_ASSIGN ("-=")
• generic CPP_MOD ("%")
• generic CPP_MOD_ASSIGN ("%=")
• generic CPP_NAMESPACE ("namespace")
• generic CPP_NEW ("new")
• generic CPP_NOT ("!")
• generic CPP_OR ("or")
• generic CPP_OVER ("/")
• generic CPP_OVER_ASSIGN ("/=")
• generic CPP_PLUS ("+")
• generic CPP_PLUS_ASSIGN ("+=")
• generic CPP_POSTDEC (".--")
• generic CPP_POSTINC (".++")
• generic CPP_PREDEC ("--.")
• generic CPP_PREINC ("++.")
• generic CPP_PUBLIC ("public")
• generic CPP_RETURN ("return")
• generic CPP_SCOPE ("::")
• generic CPP_SPECIALIZE ("specialize")
• generic CPP_STATIC ("static")
• generic CPP_STRUCT ("struct")
• generic CPP_SWITCH ("switch")
• generic CPP_TEMPLATE ("template")
• generic CPP_THROW ("raise")
• generic CPP_TIMES ("*")
• generic CPP_TIMES_ASSIGN ("*=")
• generic CPP_TRY ("try")
• generic CPP_TYPE (":")
• generic CPP_TYPEDEF ("typedef")
• generic CPP_UNALIAS ("unalias")
• generic CPP_UNEQUAL ("!=")
• generic CPP_UNFUNCTION ("unfunction")
• generic CPP_UNPOINTER ("unpointer")
• generic CPP_USING ("using")
• generic CPP_VERBATIM ("verbatim")
• generic CPP_VIRTUAL ("virtual")
• generic CPP_WHILE ("while")
• generic CPP_XOR ("^^")
• generic cAr (const vector< generic > &a)
• vector< generic > cDr (const vector< generic > &a)
• static table< string, string > opname_table ()
• static string & operator<< (string &out, print_controls pc)
• static string & operator<< (string &out, const char *s)
• static string & operator<< (string &out, const generic &g)
• syntactic flatten (const cpp_printer &p)
• nat hash (const cpp_printer &p)
• static bool is_function_type (const generic &g)
• static bool is_applicable (const generic &g)
• static string dl_find (const string &name)
• static table< bool, string > & dl_linked_table ()
• void(*) embedded_link (const string &name)
• generic documentify (const string &s)
• vector< generic > as_generics (const vector< document > &v)
• vector< document > as_documents (const vector< generic > &v)
• document make_document (const vector< document > &v, bool block=false)
• void detach (const observer &o)
• void(*) dynamic_event (const string &id, const generic &val)
• string unique_identifier (const dynamic &g)
• observer output_observer (dynamic_rep *arg)
• void destroy (const updater &u)
• updater_rep * inside (const updater &x)
• template<> nat hard_hash (const updater &x)
• template<> bool hard_eq (const updater &x, const updater &y)
• template<> bool hard_neq (const updater &x, const updater &y)
• observer argument_observer (dynamic_rep *arg, const updater &u)
• observer result_observer (dynamic_rep *arg, const updater &u)
• generic apply (const routine &fun, const vector< dynamic > &args)
• nat trace_depth (const generic &exc)
• size_t mmx_compute_free (void *ptr)
• void mmx_mem_info ()
• static void get_lock (FILE *f, int kind)
• static void release_lock (FILE *f)
• static port output_file_port (FILE *f, bool close_flag, bool lock, const string &name)
• static port input_file_port (FILE *f, bool close_flag, bool lock, const string &name)
• static port input_output_file_port (FILE *f, bool cf, bool lock, const string &name)
• bool supports_color ()
• generic vector_size (const generic &g)
• generic duplicate (const generic &x1)
• syntactic flatten (const generic &g)
• void xgen_sub (vector< generic > &v, const generic &g)
• bool as_bool (const generic &g)
• nat define_user_type (const generic &name)
• nat get_user_type (const generic &name)
• static bool object_equal (const generic &x, const generic &y)
• static bool object_unequal (const generic &x, const generic &y)
• static syntactic object_flatten (const generic &x)
• static generic object_alias (const generic &x)
• static generic object_get_alias (const generic &x)
• static generic object_set_alias (const generic &x, const generic &y)
• static generic object_specialize_alias (const alias< generic > &x)
• static alias< generic > object_generalize_alias (const generic &x)
• generic var_flatten (const generic &g)
• bool is_numeric (const string &s)
• static int compare_numeric (const string &s1, const string &s2)
• static int compare (const generic &g1, const generic &g2, const int &dir)
• static int compare_sub (const generic &g1, const generic &g2, const int &direction)
• int compare_N (const generic &g1, const generic &g2)
• int compare_P (const generic &g1, const generic &g2)
• bool fall_back_equal (const generic &x, const generic &y)
• static bool fall_back_unequal (const generic &x, const generic &y)
• void register_glue (const string &s, void(*f)())
• generic GEN_ASSUME ("assume")
• generic GEN_AUTOFOLD ("autofold")
• generic GEN_BEGIN ("begin")
• generic GEN_BREAK ("break")
• generic GEN_CASE ("case")
• generic GEN_CATCH ("catch")
• generic GEN_CATEGORY ("category")
• generic GEN_CLASS ("class")
• generic GEN_CONSTANT ("constant")
• generic GEN_CONSTRUCTOR ("constructor")
• generic GEN_CONTINUE ("continue")
• generic GEN_DESTRUCTOR ("destructor")
• generic GEN_DO ("do")
• generic GEN_ELSE ("else")
• generic GEN_ERROR ("error")
• generic GEN_EXISTS ("exists")
• generic GEN_EXPORT ("export")
• generic GEN_EXTERN ("extern")
• generic GEN_FOR ("for")
• generic GEN_FORALL ("forall")
• generic GEN_FOREIGN ("foreign")
• generic GEN_GENERATE ("generate")
• generic GEN_IF ("if")
• generic GEN_IMPORT ("import")
• generic GEN_IN ("in")
• generic GEN_INFIX ("infix")
• generic GEN_INLINE ("inline")
• generic GEN_INPLACE ("inplace")
• generic GEN_INTERN ("intern")
• generic GEN_KEYWORD ("keyword")
• generic GEN_LAMBDA ("lambda")
• generic GEN_LITERAL_FLOATING ("literal_floating")
• generic GEN_LITERAL_INTEGER ("literal_integer")
• generic GEN_LITERAL_STRING ("literal_string")
• generic GEN_LOOP ("loop")
• generic GEN_MATCH ("match")
• generic GEN_METHOD ("method")
• generic GEN_MODULE ("module")
• generic GEN_MUTABLE ("mutable")
• generic GEN_OPERATOR ("operator")
• generic GEN_OUTLINE ("outline")
• generic GEN_PATTERN ("pattern")
• generic GEN_PENALTY ("penalty")
• generic GEN_POSTFIX ("postfix")
• generic GEN_PREFER ("prefer")
• generic GEN_PREFIX ("prefix")
• generic GEN_PRIVATE ("private")
• generic GEN_PUBLIC ("public")
• generic GEN_RAISE ("raise")
• generic GEN_RETURN ("return")
• generic GEN_STEP ("step")
• generic GEN_THIS ("this")
• generic GEN_TRY ("try")
• generic GEN_UNTIL ("until")
• generic GEN_WHILE ("while")
• generic GEN_YIELD ("yield")
• generic GEN_DEFINE ("==")
• generic GEN_ASSIGN (":=")
• generic GEN_PLUS_ASSIGN ("+=")
• generic GEN_MINUS_ASSIGN ("-=")
• generic GEN_TIMES_ASSIGN ("*=")
• generic GEN_OVER_ASSIGN ("/=")
• generic GEN_DEFINE_MACRO ("==>")
• generic GEN_ASSIGN_MACRO (":=>")
• generic GEN_LESSLESS ("<<")
• generic GEN_LESSLESSEQ ("<<=")
• generic GEN_GTRGTR (">>")
• generic GEN_GTRGTREQ (">>=")
• generic GEN_IMPLIES ("=>")
• generic GEN_EQUIV ("<=>")
• generic GEN_OR ("\\/")
• generic GEN_SEQOR ("or")
• generic GEN_XOR ("xor")
• generic GEN_AND ("/\\")
• generic GEN_SEQAND ("and")
• generic GEN_EQUAL ("=")
• generic GEN_UNEQUAL ("!=")
• generic GEN_LESS ("<")
• generic GEN_LESSEQ ("<=")
• generic GEN_GTR (">")
• generic GEN_GTREQ (">=")
• generic GEN_HAS ("has")
• generic GEN_TYPE (":")
• generic GEN_VARTYPE ("::")
• generic GEN_TRANSTYPE (":>")
• generic GEN_VARTRANSTYPE ("::>")
• generic GEN_CONVERTS ("~>")
• generic GEN_INTO ("->")
• generic GEN_MAPSTO (":->")
• generic GEN_RANGE ("..")
• generic GEN_TO ("to")
• generic GEN_DOWNTO ("downto")
• generic GEN_PLUS ("+")
• generic GEN_TIMES ("*")
• generic GEN_OVER ("/")
• generic GEN_DIV ("div")
• generic GEN_QUO ("quo")
• generic GEN_MOD ("mod")
• generic GEN_REM ("rem")
• generic GEN_COMPOSE ("@")
• generic GEN_APPEND ("><")
• generic GEN_SIZE ("#")
• generic GEN_NOT ("!")
• generic GEN_MINUS ("-")
• generic GEN_POWER ("^")
• generic GEN_FILL ("^^")
• generic GEN_EXPLODE ("@")
• generic GEN_FACTORIAL (".!")
• generic GEN_PRIME (".'")
• generic GEN_BACKPRIME (".`")
• generic GEN_STAR (".*")
• generic GEN_HAT (".^")
• generic GEN_TILDA (".~")
• generic GEN_DOT (".")
• generic GEN_APPLY (".()")
• generic GEN_ACCESS (".[]")
• generic GEN_TUPLE ("()")
• generic GEN_SQTUPLE ("[]")
• generic GEN_ROW ("(.)")
• generic GEN_COMMA (",")
• generic GEN_SEMICOLON (";")
• generic GEN_WHERE ("|")
• generic GEN_VWHERE ("||")
• generic GEN_BACKQUOTE ("`")
• generic GEN_QUOTE ("'")
• generic GEN_CATALAN ("mathcatalan")
• generic GEN_D ("mathd")
• generic GEN_DELTA ("delta")
• generic GEN_E ("mathe")
• generic GEN_EULER ("matheuler")
• generic GEN_SMALLEST ("smallest")
• generic GEN_LARGEST ("largest")
• generic GEN_ACCURACY ("accuracy")
• generic GEN_FALSE ("false")
• generic GEN_FUZZ ("Fuzz")
• generic GEN_I ("mathi")
• generic GEN_INFINITY ("Infty")
• generic GEN_LOG2_AS ("set_log2")
• generic GEN_NAN ("NaN")
• generic GEN_NIL ("nil")
• generic GEN_PARTIAL ("partial")
• generic GEN_PI ("mathpi")
• generic GEN_TRUE ("true")
• generic GEN_HARD_HASH ("hard_hash")
• generic GEN_HARD_EQ ("hard_eq")
• generic GEN_HARD_NEQ ("hard_neq")
• generic GEN_HARD_LESS ("hard_less")
• generic GEN_HARD_GTR ("hard_gtr")
• generic GEN_EXACT_HASH ("exact_hash")
• generic GEN_EXACT_EQ ("exact_eq")
• generic GEN_EXACT_NEQ ("exact_neq")
• generic GEN_HASH ("hash")
• generic GEN_FLATTEN ("flatten")
• generic GEN_DUPLICATE ("duplicate")
• generic GEN_FAST ("fast")
• generic GEN_SLOW ("slow")
• generic GEN_MUL_ADD ("mul_add")
• generic GEN_MUL_SUB ("mul_sub")
• generic GEN_SQUARE ("square")
• generic GEN_GRAEFFE ("graeffe")
• generic GEN_INVERT ("invert")
• generic GEN_NUMERATOR ("numerator")
• generic GEN_DENOMINATOR ("denominator")
• generic GEN_GCD ("gcd")
• generic GEN_LCM ("lcm")
• generic GEN_XGCD ("xgcd")
• generic GEN_SQRT ("sqrt")
• generic GEN_EXP ("exp")
• generic GEN_EXP2 ("exp2")
• generic GEN_EXP10 ("exp10")
• generic GEN_LOG ("log")
• generic GEN_LOG2 ("log2")
• generic GEN_LOG10 ("log10")
• generic GEN_COS ("cos")
• generic GEN_SIN ("sin")
• generic GEN_TAN ("tan")
• generic GEN_ARCCOS ("arccos")
• generic GEN_ARCSIN ("arcsin")
• generic GEN_ARCTAN ("arctan")
• generic GEN_CH ("ch")
• generic GEN_SH ("sh")
• generic GEN_TH ("th")
• generic GEN_ARGCH ("argch")
• generic GEN_ARGSH ("argsh")
• generic GEN_ARGTH ("argth")
• generic GEN_HYPOT ("hypot")
• generic GEN_ARCTAN2 ("arctan2")
• generic GEN_CBRT ("cbrt")
• generic GEN_GAMMA ("gamma")
• generic GEN_ZETA ("zeta")
• generic GEN_ERF ("erf")
• generic GEN_MIN ("min")
• generic GEN_MAX ("max")
• generic GEN_ABS ("abs")
• generic GEN_ARG ("arg")
• generic GEN_RE ("Re")
• generic GEN_IM ("Im")
• generic GEN_CONJ ("conj")
• generic GEN_TIMES_I ("times_i")
• generic GEN_OVER_I ("over_i")
• generic GEN_BALL ("ball")
• generic GEN_CENTER ("center")
• generic GEN_RADIUS ("radius")
• generic GEN_INTERVAL ("interval")
• generic GEN_LOWER ("lower")
• generic GEN_UPPER ("upper")
• generic GEN_SHARPEN ("sharpen")
• generic GEN_BLUR ("blur")
• generic GEN_INCLUDED ("included")
• generic GEN_LIFT ("lift")
• generic GEN_RECONSTRUCT ("reconstruct")
• generic GEN_PROJECT ("project")
• generic GEN_TRUNCATE ("truncate")
• generic GEN_COMPLETE ("complete")
• generic GEN_EVALUATE ("evaluate")
• generic GEN_CHANGE_PRECISION ("change_precision")
• generic GEN_PRECISION ("precision")
• generic GEN_NEXT_ABOVE ("next_above")
• generic GEN_NEXT_BELOW ("next_below")
• generic GEN_ROUNDING_ERROR ("rounding_error")
• generic GEN_ADDITIVE_ERROR ("additive_error")
• generic GEN_MULTIPLICATIVE_ERROR ("multiplicative_error")
• generic GEN_ELEMENTARY_ERROR ("elementary_error")
• generic GEN_EXPONENT ("exponent")
• generic GEN_MAGNITUDE ("magnitude")
• generic GEN_FLOOR ("floor")
• generic GEN_TRUNC ("trunc")
• generic GEN_CEIL ("ceil")
• generic GEN_ROUND ("round")
• generic GEN_GAUSSIAN ("gaussian")
• generic GEN_POLAR ("polar")
• generic GEN_CACHED_DERIVE ("%derive")
• generic GEN_DERIVE ("derive")
• generic GEN_DERIVATIVE ("derivative")
• generic GEN_GRAD ("grad")
• generic GEN_XDERIVE ("xderive")
• generic GEN_INTEGRATE ("integrate")
• generic GEN_INTEGRATE_INIT ("integrate_init")
• generic GEN_REVERSE ("reverse")
• generic GEN_SUBSTITUTE ("substitute")
• generic GEN_SOLVE ("solve")
• generic GEN_NOOP ("noop")
• generic GEN_ALIAS_TYPE ("Alias")
• generic GEN_BOOLEAN_TYPE ("Boolean")
• generic GEN_COMPOUND_TYPE ("Compound")
• generic GEN_CROSS_TYPE ("Cross")
• generic GEN_DOUBLE_TYPE ("Double")
• generic GEN_FLOATING_TYPE ("Floating")
• generic GEN_FUNCTION_TYPE ("Function")
• generic GEN_GENERATOR_TYPE ("Generator")
• generic GEN_GENERIC_TYPE ("Generic")
• generic GEN_GENERIC_ALIAS_TYPE ("Generic_alias")
• generic GEN_INT_TYPE ("Int")
• generic GEN_INTEGER_TYPE ("Integer")
• generic GEN_LITERAL_TYPE ("Literal")
• generic GEN_MACRO_TYPE ("Macro")
• generic GEN_RATIONAL_TYPE ("Rational")
• generic GEN_ROUTINE_TYPE ("Routine")
• generic GEN_SINGLE_TYPE ("Single")
• generic GEN_SYMBOL_TYPE ("Symbol")
• generic GEN_THIS_TYPE ("This")
• generic GEN_TUPLE_TYPE ("Tuple")
• generic GEN_TYPE_TYPE ("Type")
• generic GEN_UNSPECIFIED_TYPE ("Unspecified")
• generic GEN_VOID_TYPE ("Void")
• generic GEN_COERCE_TYPE ("Coerce")
• generic GEN_ALIAS ("alias")
• generic GEN_ALL_TYPES ("all_types")
• generic GEN_CACHE_CONVERTER ("cache/converter")
• generic GEN_CACHE_CONVERTERS ("cache/converters")
• generic GEN_CACHE_PENALTY ("cache/penalty")
• generic GEN_CAST ("cast")
• generic GEN_CLASS_NAME ("class/name")
• generic GEN_CLASS_MODE ("class/mode")
• generic GEN_CLASS_ENCAPSULATION ("class/encapsulation")
• generic GEN_CLASS_ACCESS ("class/access")
• generic GEN_CLASS_FIELDS ("class/fields")
• generic GEN_CLASS_EXPORT ("class/export")
• generic GEN_CLOSURE ("closure")
• generic GEN_CONVERT (":>")
• generic GEN_CONVERTER ("converter")
• generic GEN_CONVERTERS ("converters")
• generic GEN_DOWNGRADE ("downgrade")
• generic GEN_EMPTY ("")
• generic GEN_EQUALIZE_GROUPED ("equalize_grouped")
• generic GEN_EXPECTED ("expected")
• generic GEN_GLOBAL ("global")
• generic GEN_IDENTITY ("identity")
• generic GEN_LIST ("list")
• generic GEN_LOCAL ("local")
• generic GEN_MACRO ("macro")
• generic GEN_NEW ("new")
• generic GEN_REWRITE ("rewrite")
• generic GEN_SPECIALIZE_ALIAS ("specialize_alias")
• generic GEN_SPECIALIZE ("specialize")
• generic GEN_TRANSITIVE ("transitive")
• generic GEN_TYPE_NAME ("type_name")
• generic GEN_TYPE_ID ("type_id")
• generic GEN_UNALIAS ("unalias")
• generic GEN_UPGRADE ("upgrade")
• generic GEN_VIA_TUPLE ("via_tuple")
• generic GEN_EXCEPTION ("exception")
• generic GEN_BACKTRACE ("backtrace")
• generic GEN_COERCE ("coerce")
• static generic parse_lisp (const string &s, nat &pos, bool unquote_flag, bool fun_flag)
• static void as_lisp (string &out, const generic &g, bool quote_flag, bool fun_flag)
• static table< string, string,
  exact_eq_table > math_symbol_table ()
• static void as_math (string &out, const generic &g)
• static string strip_preamble (const string &s)
• static bool test_keyword (const char *k, parse_instance *obj)
• generic concat (const vector< generic > &v)
• generic concat ()
• generic concat (const generic &g1, const generic &g2)
• generic concat (const generic &g1, const generic &g2, const generic &g3)
• generic concat (const generic &g1, const generic &g2, const generic &g3, const generic &g4)
• generic infix (const generic &g, const generic &op, const generic &h)
• generic bigop (const generic &op, const vector< generic > &v)
• generic bracket (const generic &l, const generic &g, const generic &r)
• generic postfix (const generic &g, const generic &op)
• generic prefix (const generic &op, const generic &g)
• generic operate (const generic &g, const generic &h)
• generic keyword (const generic &g)
• generic keyword (const generic &op, const generic &g)
• generic hlist (const vector< generic > &v)
• generic vlist (const vector< generic > &v)
• generic indented (const vector< generic > &v)
• static void init (table< generic, generic > &t, const generic &key, const generic &val)
• static table< generic, generic > mmx_symbol_table ()
• static void serialize (string &(obj->lex_string), const generic &g)
• static string serialize (const generic &g)
• static bool is_C0 (const generic &g)
• static generic un_try_catch (const generic &g)
• static void collect (vector< generic > &v, const generic &g, nat depth)
• static vector< generic > collect (const generic &g)
• generic print_mmx (const generic &g)
• string string_as_mmx (const string &(obj->lex_string))
• string as_texmacs_snippet (const generic &g)
• generic add_modes (const generic &g, int mode)
• generic add_modes (const generic &g, int mode, int new_mode)
• static table< generic, generic > texmacs_symbol_table ()
• bool is_infix (const generic &g, const generic &op)
• generic unbracket (const generic &g)
• bool ((((const generic &g)>='0')&&((const generic &g)<='9'))||(((const generic &g)>='A')&&((const generic &g)<='Z'))||(((const generic &g)>='a')&&((const generic &g)<='z'))||(((const generic &g)=='_')||((const generic &g)=='?')||((const generic &g)=='$')))
• void concat_append (vector< generic > &v, const generic &g)
• generic as_texmacs (const generic &g)
• generic replace_lf (const generic &g)
• static void texmacs_to_scheme (string &(obj->lex_string), const generic &g)
• static string spaces (nat indent)
• static void write (string &r, const string &(obj->lex_string))
• static void scheme_to_tm (string &(obj->lex_string), const generic &g, int indent)
• static string as_snippet (const generic &g)
• port pipe_port (nat kind, nat fd, nat pid, const string &cmd, const string &role)
• port error_port (const string &(obj->lex_string))
• vector< generic > type_name (const vector< nat > &ids)
• port socket_port (const string &host, int pnr, int role, int fd)
• string repeated (const string &(obj->lex_string), nat(obj->lex_length))
• nat get_indentation (const string &(obj->lex_string))
• string add_indentation (const string &(obj->lex_string), int delta)
• void store_interactive_number (nat(obj->lex_length))
• void store_interactive_source (const string &data, nat(obj->lex_length))
• static string get_interactive_source (nat i, nat l)
• static string get_file_source (const string &file_name, nat(obj->lex_line))
• string get_source (const string &file_name, nat i)
• string get_source (const string &file_name, nat i, nat(obj->lex_line))
• table< source_location,
  generic, gen_eq_table > & source_locs ()
• static string underlined (const string &file_name, const nat &(obj->lex_length), const source_position &b, const source_position &e)
• string backtrace (const generic &g)
• static port connect_to_server ()
• storage disk_storage (const port &server, const string &root)
• nat hash (const string &(obj->lex_string))
• char * as_charp (const string &(obj->lex_string))
• void free_charp (char *(obj->lex_string))
• int as_int (const string &(obj->lex_string))
• double as_double (const string &(obj->lex_string))
• bool is_integer_string (const string &(obj->lex_string))
• bool is_floating_string (const string &(obj->lex_string))
• template<typename C > void floating_to_string (const C &val, string &(obj->lex_string), const char *fm)
• template<typename C > void string_to_floating (const string &(obj->lex_string), C &val, const char *fm)
• template<> void numeric_to_string (const float &x, string &(obj->lex_string))
• template<> void numeric_to_string (const double &x, string &(obj->lex_string))
• template<> void numeric_to_string (const long double &x, string &(obj->lex_string))
• template<> bool string_to_numeric (const string &(obj->lex_string), float &x)
• template<> bool string_to_numeric (const string &(obj->lex_string), double &x)
• template<> bool string_to_numeric (const string &(obj->lex_string), long double &x)
• bool starts (const string &(obj->lex_string), const string &what)
• bool ends (const string &(obj->lex_string), const string &what)
• string copy (const string &(obj->lex_string))
• string operator* (const string &s1, const string &s2)
• static bool is_locase (register char c)
• static bool is_upcase (register char c)
• string upcase (const string &(obj->lex_string))
• string locase (const string &(obj->lex_string))
• string upcase_first (const string &(obj->lex_string))
• string locase_first (const string &(obj->lex_string))
• string escape (const string &(obj->lex_string))
• string unescape (const string &(obj->lex_string))
• bool is_quoted (const string &(obj->lex_string))
• string quote (const string &(obj->lex_string))
• string unquote (const string &(obj->lex_string))
• static bool reads (const string &(obj->lex_string), nat(obj->lex_pos), const string &what)
• string replace (const string &(obj->lex_string), const string &what, const string &by)
• int search_forwards (const string &(obj->lex_string), const string &what, const int &(obj->lex_pos))
• int search_backwards (const string &(obj->lex_string), const string &what, const int &(obj->lex_pos))
• string reverse (const string &(obj->lex_string))
• vector< string > tokenize (const string &(obj->lex_string), const string &sep, bool keep)
• port output_string_port (string &(obj->lex_string))
• port input_string_port (const string &(obj->lex_string))
• port input_output_string_port (string &(obj->lex_string))
• syntactic apply (const vector< syntactic > &v)
• bool is_func (const syntactic &g, const char *f, nat(obj->lex_length))
• bool is_func (const syntactic &g, const syntactic &f, nat(obj->lex_length))
• bool is_func (const syntactic &g, const generic &f, nat(obj->lex_length))
• static void signed_decompose (const syntactic &g, syntactic &abs_g, int &sgn_g)
• static syntactic migrate_sub (const syntactic &g, const syntactic &h)
• static syntactic migrate_sub (const syntactic &g, nat found)
• bool is_numeric (const string &(obj->lex_string))
• bool exact_neq (const vector< syntactic > &v, const vector< syntactic > &w)
• syntactic & the_series_var ()
• syntactic & the_polynomial_var ()
• syntactic flatten (const char *const &(obj->lex_string))
• syntactic flatten (const string &(obj->lex_string))
• string command_dir ()
• string global_path ()
• bool var_load (const string &file_name, string &(obj->lex_string))
• bool var_load (const string &file_path, const string &file_name, string &(obj->lex_string))
• bool var_mkdir (const string &name)
• bool var_rm (const string &name)
• string var_pwd ()
• static bool is_absolute_name (const string &name)
• static string _from_dos_to_unix (const string &x)
• int system (const string &(obj->lex_string))
• string eval_system (const string &(obj->lex_string))
• static bool get_attributes (const string &name, struct stat *buf)
• static string recursive_search_name (const string &dir, const string &name, bool is_dir)
• static string semi_recursive_search_name (const string &dir, const string &name)
• static string ancestor_search_name (const string &dir, const string &name)
• bool load (const string &orig_file_name, string &(obj->lex_string))
• bool load (const string &file_path, const string &file_name, string &(obj->lex_string))
• bool save (const string &orig_file_name, const string &(obj->lex_string))
• static bool read_line (string prompt, string &sline)
• static char * duplicate (char *(obj->lex_string))
• static char * completion_generator (const char *text, int state)
• static char ** complete (const char *text, int(obj->lex_start), int end)
• static int passive_newline (int a, int b)
• static int active_newline (int a, int b)
• static void output_completion (const string &text, const list< string > &matches2)
• static void complete (const string &text)
• static bool parse_char (const string &text, char c, nat &(obj->lex_pos))
• static bool parse_blanks (const string &text, nat &(obj->lex_pos))
• static bool parse_nat (const string &text, nat &(obj->lex_pos), nat &out)
• static bool parse_identifier (const string &text, const string &id, nat &(obj->lex_pos))
• static bool parse_string (const string &text, nat &(obj->lex_pos), string &out)
• static bool parse_completion_request (const string &text, nat &(obj->lex_pos), string &(obj->lex_string), nat &p)
• static void handle_completion_request (const string &request)
• bool shell_texmacs_input (string &(obj->lex_line))
• void threads_initialize (nat(obj->lex_length))
• void threads_set_number (const int &(obj->lex_length))
• void init_threads ()
• void term_threads ()
• void threads_execute (task *ts, nat(obj->lex_length))
• void glue_basix_table_generic ()
• void glue_basix_vector_generic ()
• void glue_compound ()
• void glue_document ()
• void glue_double ()
• void glue_dynamic ()
• void glue_expression ()
• void glue_generic ()
• void glue_int ()
• void glue_list_generic ()
• void glue_list_map ()
• void glue_literal ()
• void glue_port ()
• void glue_routine ()
• void glue_storage ()
• void glue_string ()
• void glue_syntactic ()
• void glue_vector_map ()
• void glue_basix ()
• static pair< generic, generic > GLUE_1 (const generic &arg_1, const generic &arg_2)
• static generic GLUE_2 (const pair< generic, generic > &arg_1)
• static generic GLUE_3 (const pair< generic, generic > &arg_1)
• static bool GLUE_4 (const generic &arg_1)
• static table< generic, generic > GLUE_5 (const generic &arg_1)
• static table< generic, generic > GLUE_6 (const tuple< pair< generic, generic > > &arg_1)
• static iterator< generic > GLUE_7 (const table< generic, generic > &arg_1)
• static int GLUE_8 (const table< generic, generic > &arg_1)
• static int GLUE_9 (const table< generic, generic > &arg_1)
• static bool GLUE_10 (const table< generic, generic > &arg_1, const generic &arg_2)
• static generic GLUE_11 (const table< generic, generic > &arg_1, const generic &arg_2)
• static alias< generic > GLUE_12 (const alias< table< generic, generic > > &arg_1, const generic &arg_2)
• static void GLUE_13 (const alias< table< generic, generic > > &arg_1, const generic &arg_2)
• static void GLUE_14 (const table< generic, generic > &arg_1, const generic &arg_2, const generic &arg_3)
• static table< generic, generic > GLUE_15 (const table< generic, generic > &arg_1)
• static table< generic, generic > GLUE_16 (const table< generic, generic > &arg_1, const table< generic, generic > &arg_2)
• static alias< table< generic,
  generic > > GLUE_17 (const alias< table< generic, generic > > &arg_1, const table< generic, generic > &arg_2)
• static bool GLUE_18 (const table< generic, generic > &arg_1, const generic &arg_2, const generic &arg_3, const tuple< generic > &arg_4)
• static generic GLUE_19 (const table< generic, generic > &arg_1, const generic &arg_2, const generic &arg_3, const tuple< generic > &arg_4)
• static alias< generic > GLUE_20 (const alias< table< generic, generic > > &arg_1, const generic &arg_2, const generic &arg_3, const tuple< generic > &arg_4)
• static void GLUE_21 (const alias< table< generic, generic > > &arg_1, const generic &arg_2, const generic &arg_3, const tuple< generic > &arg_4)
• static bool GLUE_1 (const generic &arg_1)
• static vector< generic > GLUE_2 (const tuple< generic > &arg_1)
• static vector< generic > GLUE_3 (const tuple< generic > &arg_1)
• static iterator< generic > GLUE_4 (const vector< generic > &arg_1)
• static int GLUE_5 (const vector< generic > &arg_1)
• static generic GLUE_6 (const vector< generic > &arg_1, const int &arg_2)
• static alias< generic > GLUE_7 (const alias< vector< generic > > &arg_1, const int &arg_2)
• static vector< generic > GLUE_8 (const vector< generic > &arg_1, const int &arg_2, const int &arg_3)
• static vector< generic > GLUE_9 (const vector< generic > &arg_1)
• static vector< generic > GLUE_10 (const vector< generic > &arg_1, const vector< generic > &arg_2)
• static alias< vector< generic > > GLUE_11 (const alias< vector< generic > > &arg_1, const vector< generic > &arg_2)
• static vector< generic > GLUE_12 (const generic &arg_1, const vector< generic > &arg_2)
• static generic GLUE_13 (const vector< generic > &arg_1)
• static vector< generic > GLUE_14 (const vector< generic > &arg_1)
• static bool GLUE_15 (const vector< generic > &arg_1)
• static bool GLUE_16 (const vector< generic > &arg_1)
• static vector< generic > GLUE_17 (const vector< generic > &arg_1, const generic &arg_2)
• static int GLUE_18 (const vector< generic > &arg_1, const generic &arg_2)
• static bool GLUE_19 (const vector< generic > &arg_1, const generic &arg_2)
• static generic GLUE_2 (const compound &arg_1, const tuple< generic > &arg_2)
• static vector< generic > GLUE_5 (const compound &arg_1)
• static int GLUE_6 (const compound &arg_1)
• static generic GLUE_7 (const compound &arg_1, const int &arg_2)
• static vector< generic > GLUE_8 (const compound &arg_1)
• static vector< generic > GLUE_9 (const compound &arg_1)
• static document GLUE_2 (const document &arg_1)
• static generic GLUE_3 (const document &arg_1)
• static document GLUE_4 (const string &arg_1)
• static document GLUE_5 (const string &arg_1, const tuple< document > &arg_2)
• static document GLUE_6 (const literal &arg_1, const tuple< document > &arg_2)
• static document GLUE_7 (const generic &arg_1)
• static document GLUE_8 (const document &arg_1)
• static document GLUE_9 (const generic &arg_1)
• static document GLUE_10 (const document &arg_1)
• static document GLUE_11 (const tuple< document > &arg_1)
• static document GLUE_12 (const tuple< document > &arg_1)
• static document GLUE_13 (const tuple< document > &arg_1)
• static double GLUE_1 (const literal &arg_1)
• static double GLUE_2 (const int &arg_1)
• static int GLUE_3 (const double &arg_1)
• static string GLUE_5 (const double &arg_1)
• static double GLUE_6 (const double &arg_1, const double &arg_2)
• static double GLUE_7 (const double &arg_1)
• static double GLUE_8 (const double &arg_1)
• static double GLUE_9 (const double &arg_1, const double &arg_2)
• static double GLUE_10 (const double &arg_1, const double &arg_2)
• static double GLUE_11 (const double &arg_1, const double &arg_2)
• static double GLUE_12 (const double &arg_1, const double &arg_2)
• static double GLUE_13 (const double &arg_1)
• static double GLUE_14 (const double &arg_1, const double &arg_2)
• static double GLUE_15 (const double &arg_1)
• static double GLUE_16 (const double &arg_1)
• static double GLUE_17 (const double &arg_1)
• static double GLUE_18 (const double &arg_1)
• static double GLUE_19 (const double &arg_1)
• static double GLUE_20 (const double &arg_1)
• static double GLUE_21 (const double &arg_1)
• static double GLUE_22 (const double &arg_1)
• static bool GLUE_23 (const double &arg_1, const double &arg_2)
• static bool GLUE_24 (const double &arg_1, const double &arg_2)
• static bool GLUE_25 (const double &arg_1, const double &arg_2)
• static bool GLUE_26 (const double &arg_1, const double &arg_2)
• static bool GLUE_27 (const double &arg_1, const double &arg_2)
• static bool GLUE_28 (const double &arg_1, const double &arg_2)
• static int GLUE_29 (const double &arg_1)
• static double GLUE_30 (const double &arg_1)
• static double GLUE_31 (const double &arg_1, const double &arg_2)
• static double GLUE_32 (const double &arg_1, const double &arg_2)
• static double GLUE_33 (const double &arg_1, const double &arg_2)
• static double GLUE_34 (const double &arg_1, const double &arg_2)
• static double GLUE_35 (const double &arg_1)
• static double GLUE_36 (const double &arg_1)
• static double GLUE_37 (const double &arg_1)
• static double GLUE_38 (const double &arg_1)
• static bool GLUE_39 (const double &arg_1)
• static bool GLUE_40 (const double &arg_1)
• static bool GLUE_41 (const double &arg_1)
• static double GLUE_42 (const double &arg_1)
• static int GLUE_43 (const double &arg_1)
• static double GLUE_44 (const double &arg_1, const int &arg_2)
• static double GLUE_45 (const double &arg_1)
• static double GLUE_46 (const double &arg_1)
• static int GLUE_47 (const double &arg_1)
• static double GLUE_48 (const double &arg_1)
• static double GLUE_49 (const double &arg_1, const int &arg_2)
• static double GLUE_50 (const double &arg_1, const int &arg_2)
• static double GLUE_51 (const double &arg_1)
• static double GLUE_52 (const double &arg_1)
• static double GLUE_53 (const double &arg_1)
• static double GLUE_54 (const double &arg_1)
• static generic GLUE_2 (const dynamic &arg_1)
• static dynamic GLUE_3 (const routine &arg_1, const tuple< dynamic > &arg_2)
• static void GLUE_4 (const dynamic &arg_1, const generic &arg_2)
• static void GLUE_5 (const string &arg_1, const generic &arg_2)
• static bool GLUE_2 (const generic &arg_1)
• static bool GLUE_3 (const generic &arg_1)
• static generic GLUE_4 (const string &arg_1, const bool &arg_2)
• static string GLUE_5 (const generic &arg_1, const bool &arg_2)
• static string GLUE_6 (const generic &arg_1)
• static int GLUE_2 (const string &arg_1)
• static string GLUE_3 (const int &arg_1)
• static string GLUE_4 (const int &arg_1)
• static int GLUE_5 (const int &arg_1)
• static int GLUE_6 (const int &arg_1)
• static int GLUE_7 (const int &arg_1, const int &arg_2)
• static int GLUE_8 (const int &arg_1, const int &arg_2)
• static int GLUE_9 (const int &arg_1, const int &arg_2)
• static int GLUE_10 (const int &arg_1, const int &arg_2)
• static int GLUE_11 (const int &arg_1, const int &arg_2)
• static int GLUE_12 (const int &arg_1, const int &arg_2)
• static bool GLUE_13 (const int &arg_1, const int &arg_2)
• static bool GLUE_14 (const int &arg_1, const int &arg_2)
• static bool GLUE_15 (const int &arg_1, const int &arg_2)
• static bool GLUE_16 (const int &arg_1, const int &arg_2)
• static bool GLUE_17 (const int &arg_1, const int &arg_2)
• static bool GLUE_18 (const int &arg_1, const int &arg_2)
• static int GLUE_19 (const int &arg_1)
• static int GLUE_20 (const int &arg_1)
• static int GLUE_21 (const int &arg_1, const int &arg_2)
• static int GLUE_22 (const int &arg_1, const int &arg_2)
• static int GLUE_23 (const int &arg_1, const int &arg_2)
• static int GLUE_24 (const int &arg_1, const int &arg_2)
• static int GLUE_25 (const int &arg_1, const int &arg_2)
• static int GLUE_26 (const int &arg_1, const int &arg_2)
• static int GLUE_27 (const int &arg_1, const int &arg_2)
• static int GLUE_28 (const int &arg_1)
• static bool GLUE_29 (const int &arg_1, const int &arg_2)
• static int GLUE_30 ()
• static iterator< generic > GLUE_3 (const list< generic > &arg_1)
• static int GLUE_4 (const list< generic > &arg_1)
• static generic GLUE_5 (const list< generic > &arg_1, const int &arg_2)
• static alias< generic > GLUE_6 (const alias< list< generic > > &arg_1, const int &arg_2)
• static list< generic > GLUE_7 (const list< generic > &arg_1, const int &arg_2, const int &arg_3)
• static list< generic > GLUE_8 (const list< generic > &arg_1)
• static list< generic > GLUE_9 (const list< generic > &arg_1, const list< generic > &arg_2)
• static list< generic > GLUE_10 (const generic &arg_1, const list< generic > &arg_2)
• static generic GLUE_11 (const list< generic > &arg_1)
• static list< generic > GLUE_12 (const list< generic > &arg_1)
• static bool GLUE_13 (const list< generic > &arg_1)
• static bool GLUE_14 (const list< generic > &arg_1)
• static list< generic > GLUE_15 (const list< generic > &arg_1, const generic &arg_2)
• static int GLUE_16 (const list< generic > &arg_1, const generic &arg_2)
• static bool GLUE_17 (const list< generic > &arg_1, const generic &arg_2)
• template<typename T > vector< T > as_vector (const list< T > &l)
• static generic rebuild (const list< generic > &l)
• list< generic > list_map_1 (const routine &fun, const list< generic > &l)
• list< generic > list_map_2 (const routine &fun, const list< generic > &l1, const list< generic > &l2)
• list< generic > list_map_n (const routine &fun, const vector< list< generic > > &a)
• generic list_map (const generic &f, const tuple< list< generic > > &t)
• generic list_foreach (const generic &f, const tuple< list< generic > > &t)
• generic list_append_several (const tuple< list< generic > > &t)
• generic list_apply (const generic &f, const list< generic > &l2)
• static int generic_compare (const generic &x, const generic &y)
• list< generic > list_sort (const list< generic > &l, const generic &f)
• static generic GLUE_2 (const literal &arg_1, const tuple< generic > &arg_2)
• static generic GLUE_3 (const literal &arg_1, const tuple< generic > &arg_2)
• static string GLUE_5 (const literal &arg_1)
• static port GLUE_1 (const string &arg_1)
• static port GLUE_3 (const string &arg_1)
• static port GLUE_4 (const string &arg_1, const int &arg_2)
• static port GLUE_5 (const string &arg_1, const int &arg_2)
• static port GLUE_6 (const string &arg_1)
• static port GLUE_7 (const tuple< port > &arg_1)
• static port GLUE_8 (const string &arg_1)
• static bool GLUE_9 (const port &arg_1)
• static bool GLUE_10 (const port &arg_1)
• static bool GLUE_11 (const port &arg_1)
• static string GLUE_12 (const port &arg_1)
• static bool GLUE_13 (const port &arg_1)
• static int GLUE_14 (const port &arg_1)
• static int GLUE_15 (const port &arg_1)
• static void GLUE_16 (const port &arg_1, const string &arg_2)
• static string GLUE_17 (const port &arg_1, const int &arg_2)
• static void GLUE_18 (const port &arg_1)
• static bool GLUE_19 (const port &arg_1, const int &arg_2)
• static port GLUE_20 (const port &arg_1)
• static port GLUE_21 (const port &arg_1, const string &arg_2)
• static int GLUE_22 (const int &arg_1)
• static port GLUE_23 (const port &arg_1, const generic &arg_2)
• static port GLUE_24 (const port &arg_1, const string &arg_2)
• static port GLUE_25 (const port &arg_1, const print_format &arg_2)
• static generic GLUE_26 (const generic &arg_1)
• static generic GLUE_27 (const generic &arg_1)
• static void GLUE_28 (const port &arg_1, const generic &arg_2)
• static generic GLUE_29 (const port &arg_1)
• static vector< routine > GLUE_1 (const tuple< routine > &arg_1)
• static vector< routine > GLUE_2 (const tuple< routine > &arg_1)
• static iterator< generic > GLUE_3 (const vector< routine > &arg_1)
• static int GLUE_4 (const vector< routine > &arg_1)
• static routine GLUE_5 (const vector< routine > &arg_1, const int &arg_2)
• static alias< routine > GLUE_6 (const alias< vector< routine > > &arg_1, const int &arg_2)
• static vector< routine > GLUE_7 (const vector< routine > &arg_1, const int &arg_2, const int &arg_3)
• static vector< routine > GLUE_8 (const vector< routine > &arg_1)
• static vector< routine > GLUE_9 (const vector< routine > &arg_1, const vector< routine > &arg_2)
• static alias< vector< routine > > GLUE_10 (const alias< vector< routine > > &arg_1, const vector< routine > &arg_2)
• static vector< routine > GLUE_11 (const routine &arg_1, const vector< routine > &arg_2)
• static routine GLUE_12 (const vector< routine > &arg_1)
• static vector< routine > GLUE_13 (const vector< routine > &arg_1)
• static bool GLUE_14 (const vector< routine > &arg_1)
• static bool GLUE_15 (const vector< routine > &arg_1)
• static vector< routine > GLUE_16 (const vector< routine > &arg_1, const routine &arg_2)
• static int GLUE_17 (const vector< routine > &arg_1, const routine &arg_2)
• static bool GLUE_18 (const vector< routine > &arg_1, const routine &arg_2)
• static vector< generic > GLUE_19 (const vector< routine > &arg_1)
• static storage GLUE_1 ()
• static storage GLUE_3 (const storage &arg_1)
• static void GLUE_4 (const storage &arg_1, const string &arg_2, const string &arg_3)
• static string GLUE_5 (const storage &arg_1, const string &arg_2)
• static void GLUE_6 (const storage &arg_1, const string &arg_2)
• static void GLUE_7 (const storage &arg_1, const string &arg_2)
• static storage GLUE_8 (const storage &arg_1, const string &arg_2)
• static bool GLUE_9 (const storage &arg_1, const string &arg_2)
• static string GLUE_10 (const storage &arg_1, const string &arg_2)
• static bool GLUE_11 (const storage &arg_1, const string &arg_2)
• static vector< generic > GLUE_12 (const storage &arg_1)
• static vector< generic > GLUE_13 (const storage &arg_1)
• static vector< generic > GLUE_14 (const storage &arg_1)
• static string GLUE_3 (const string &arg_1, const int &arg_2, const int &arg_3)
• static string GLUE_4 (const string &arg_1, const string &arg_2)
• static string GLUE_5 (const string &arg_1, const string &arg_2)
• static alias< string > GLUE_6 (const alias< string > &arg_1, const string &arg_2)
• static bool GLUE_7 (const string &arg_1, const string &arg_2)
• static bool GLUE_8 (const string &arg_1, const string &arg_2)
• static bool GLUE_9 (const string &arg_1, const string &arg_2)
• static bool GLUE_10 (const string &arg_1, const string &arg_2)
• static bool GLUE_11 (const string &arg_1, const string &arg_2)
• static bool GLUE_12 (const string &arg_1, const string &arg_2)
• static string GLUE_13 (const string &arg_1, const string &arg_2, const string &arg_3)
• static int GLUE_14 (const string &arg_1, const string &arg_2, const int &arg_3)
• static int GLUE_15 (const string &arg_1, const string &arg_2, const int &arg_3)
• static string GLUE_16 (const string &arg_1)
• static string GLUE_17 (const string &arg_1)
• static string GLUE_18 (const string &arg_1)
• static string GLUE_19 (const string &arg_1)
• static string GLUE_20 (const string &arg_1)
• static string GLUE_21 (const string &arg_1)
• static int GLUE_23 (const string &arg_1)
• static generic GLUE_3 (const syntactic &arg_1)
• static string GLUE_4 (const syntactic &arg_1)
• static syntactic GLUE_6 (const syntactic &arg_1)
• static syntactic GLUE_7 (const syntactic &arg_1, const syntactic &arg_2)
• static syntactic GLUE_8 (const syntactic &arg_1, const syntactic &arg_2, const syntactic &arg_3)
• static syntactic GLUE_9 (const syntactic &arg_1)
• static syntactic GLUE_10 (const syntactic &arg_1)
• static syntactic GLUE_11 (const syntactic &arg_1, const syntactic &arg_2)
• static syntactic GLUE_12 (const syntactic &arg_1, const syntactic &arg_2)
• static syntactic GLUE_13 (const syntactic &arg_1, const syntactic &arg_2)
• static syntactic GLUE_14 (const syntactic &arg_1, const syntactic &arg_2)
• static syntactic GLUE_15 (const syntactic &arg_1, const syntactic &arg_2)
• static bool GLUE_16 (const bool &arg_1)
• static syntactic GLUE_17 (const tuple< syntactic > &arg_1)
• static syntactic GLUE_18 (const tuple< syntactic > &arg_1)
• static bool GLUE_19 (const syntactic &arg_1, const syntactic &arg_2)
• static bool GLUE_20 (const syntactic &arg_1, const syntactic &arg_2)
• static bool GLUE_21 (const syntactic &arg_1, const syntactic &arg_2)
• static bool GLUE_22 (const syntactic &arg_1, const syntactic &arg_2)
• static generic rebuild (const vector< generic > &v)
• vector< generic > vector_map_1 (const routine &fun, const vector< generic > &v)
• vector< generic > vector_map_2 (const routine &fun, const vector< generic > &v1, const vector< generic > &v2)
• vector< generic > vector_map_n (const routine &fun, const vector< vector< generic > > &a)
• generic vector_map (const generic &f, const tuple< vector< generic > > &t)
• generic vector_foreach (const generic &f, const tuple< vector< generic > > &t)
• generic vector_append_several (const tuple< vector< generic > > &t)
• generic vector_apply (const generic &f, const vector< generic > &a)
• vector< generic > vector_sort (const vector< generic > &v)
• vector< generic > vector_sort_leq (const vector< generic > &v, const generic &f)

• exception error_message (const char *msg)

  Make an exception from msg.
  

• exception error_message (const string &msg)

Variables

• int mmx_argc
• char ** mmx_argv
• generic CPP_ACCESS
• generic CPP_ALIAS
• generic CPP_AND
• generic CPP_APPLY
• generic CPP_ARROW
• generic CPP_ASSIGN
• generic CPP_BEGIN
• generic CPP_BITWISE_AND
• generic CPP_BITWISE_OR
• generic CPP_BITWISE_XOR
• generic CPP_BOOL
• generic CPP_BRACKETS
• generic CPP_BREAK
• generic CPP_CAST
• generic CPP_CATCH
• generic CPP_CLASS
• generic CPP_COMPLEMENT
• generic CPP_CONST
• generic CPP_CONSTRUCT
• generic CPP_CONSTRUCTOR
• generic CPP_CONTINUE
• generic CPP_DELETE
• generic CPP_DESTRUCTOR
• generic CPP_DIV
• generic CPP_DO
• generic CPP_DOT
• generic CPP_ELSE
• generic CPP_EQUAL
• generic CPP_EXIT
• generic CPP_EXTERN
• generic CPP_FOR
• generic CPP_GTR
• generic CPP_GTREQ
• generic CPP_GTRGTR
• generic CPP_IF
• generic CPP_INHERIT
• generic CPP_INITIALIZE
• generic CPP_INLINE
• generic CPP_INT
• generic CPP_LESS
• generic CPP_LESSEQ
• generic CPP_LESSLESS
• generic CPP_MINUS
• generic CPP_MINUS_ASSIGN
• generic CPP_MOD
• generic CPP_MOD_ASSIGN
• generic CPP_NAMESPACE
• generic CPP_NEW
• generic CPP_NOT
• generic CPP_OR
• generic CPP_OSTREAM
• generic CPP_OVER
• generic CPP_OVER_ASSIGN
• generic CPP_PLUS
• generic CPP_PLUS_ASSIGN
• generic CPP_POINTER
• generic CPP_POSTDEC
• generic CPP_POSTINC
• generic CPP_PREDEC
• generic CPP_PREINC
• generic CPP_PUBLIC
• generic CPP_RETURN
• generic CPP_SCOPE
• generic CPP_SPECIALIZE
• generic CPP_STATIC
• generic CPP_STRING
• generic CPP_STRUCT
• generic CPP_SWITCH
• generic CPP_TEMPLATE
• generic CPP_TIMES
• generic CPP_TIMES_ASSIGN
• generic CPP_THROW
• generic CPP_TRY
• generic CPP_TYPE
• generic CPP_TYPEDEF
• generic CPP_UNALIAS
• generic CPP_UNEQUAL
• generic CPP_UNFUNCTION
• generic CPP_UNPOINTER
• generic CPP_USING
• generic CPP_VERBATIM
• generic CPP_VIRTUAL
• generic CPP_VOID
• generic CPP_WHILE
• generic CPP_XOR
• void(* dynamic_event )(const string &id, const generic &val) = NULL
• evaluator current_ev
• mutex memory_lock
• static const bool threads_active = false
• char alloc_table [(256+sizeof(void *))]
• char * alloc_mem = NULL
• size_t alloc_remains = 0
• nat allocated = 0
• nat fast_chunks = 0
• nat large_uses = 0
• port mmout = formatting_port (output_file_port (stdout, false, false, "mmout"))
• port mmerr = formatting_port (output_file_port (stderr, false, false, "mmerr"))
• bool booting_done
• generic GEN_CONVERT
• generic GEN_ASSUME
• generic GEN_AUTOFOLD
• generic GEN_BEGIN
• generic GEN_BREAK
• generic GEN_CASE
• generic GEN_CATCH
• generic GEN_CATEGORY
• generic GEN_CLASS
• generic GEN_CONSTANT
• generic GEN_CONSTRUCTOR
• generic GEN_CONTINUE
• generic GEN_DESTRUCTOR
• generic GEN_DO
• generic GEN_ELSE
• generic GEN_ERROR
• generic GEN_EXISTS
• generic GEN_EXPORT
• generic GEN_EXTERN
• generic GEN_FOR
• generic GEN_FORALL
• generic GEN_FOREIGN
• generic GEN_GENERATE
• generic GEN_IF
• generic GEN_IMPORT
• generic GEN_IN
• generic GEN_INFIX
• generic GEN_INLINE
• generic GEN_INPLACE
• generic GEN_INTERN
• generic GEN_KEYWORD
• generic GEN_LAMBDA
• generic GEN_LITERAL_FLOATING
• generic GEN_LITERAL_INTEGER
• generic GEN_LITERAL_STRING
• generic GEN_LOOP
• generic GEN_MATCH
• generic GEN_METHOD
• generic GEN_MODULE
• generic GEN_MUTABLE
• generic GEN_OPERATOR
• generic GEN_OUTLINE
• generic GEN_PATTERN
• generic GEN_PENALTY
• generic GEN_POSTFIX
• generic GEN_PREFER
• generic GEN_PREFIX
• generic GEN_PRIVATE
• generic GEN_PUBLIC
• generic GEN_RAISE
• generic GEN_RETURN
• generic GEN_STEP
• generic GEN_THIS
• generic GEN_TRY
• generic GEN_UNTIL
• generic GEN_WHILE
• generic GEN_YIELD
• generic GEN_DEFINE
• generic GEN_ASSIGN
• generic GEN_PLUS_ASSIGN
• generic GEN_MINUS_ASSIGN
• generic GEN_TIMES_ASSIGN
• generic GEN_OVER_ASSIGN
• generic GEN_DEFINE_MACRO
• generic GEN_ASSIGN_MACRO
• generic GEN_LESSLESS
• generic GEN_LESSLESSEQ
• generic GEN_GTRGTR
• generic GEN_GTRGTREQ
• generic GEN_IMPLIES
• generic GEN_EQUIV
• generic GEN_OR
• generic GEN_SEQOR
• generic GEN_XOR
• generic GEN_AND
• generic GEN_SEQAND
• generic GEN_EQUAL
• generic GEN_UNEQUAL
• generic GEN_LESS
• generic GEN_LESSEQ
• generic GEN_GTR
• generic GEN_GTREQ
• generic GEN_HAS
• generic GEN_TYPE
• generic GEN_VARTYPE
• generic GEN_TRANSTYPE
• generic GEN_VARTRANSTYPE
• generic GEN_CONVERTS
• generic GEN_INTO
• generic GEN_MAPSTO
• generic GEN_RANGE
• generic GEN_TO
• generic GEN_DOWNTO
• generic GEN_PLUS
• generic GEN_TIMES
• generic GEN_OVER
• generic GEN_DIV
• generic GEN_QUO
• generic GEN_REM
• generic GEN_MOD
• generic GEN_COMPOSE
• generic GEN_APPEND
• generic GEN_SIZE
• generic GEN_NOT
• generic GEN_MINUS
• generic GEN_POWER
• generic GEN_FILL
• generic GEN_EXPLODE
• generic GEN_FACTORIAL
• generic GEN_PRIME
• generic GEN_BACKPRIME
• generic GEN_STAR
• generic GEN_HAT
• generic GEN_TILDA
• generic GEN_DOT
• generic GEN_APPLY
• generic GEN_ACCESS
• generic GEN_TUPLE
• generic GEN_SQTUPLE
• generic GEN_ROW
• generic GEN_COMMA
• generic GEN_SEMICOLON
• generic GEN_WHERE
• generic GEN_VWHERE
• generic GEN_BACKQUOTE
• generic GEN_QUOTE
• generic GEN_CATALAN
• generic GEN_D
• generic GEN_DELTA
• generic GEN_E
• generic GEN_EULER
• generic GEN_SMALLEST
• generic GEN_LARGEST
• generic GEN_ACCURACY
• generic GEN_FALSE
• generic GEN_FUZZ
• generic GEN_I
• generic GEN_INFINITY
• generic GEN_LOG2_AS
• generic GEN_NAN
• generic GEN_NIL
• generic GEN_PARTIAL
• generic GEN_PI
• generic GEN_TRUE
• generic GEN_HARD_HASH
• generic GEN_HARD_EQ
• generic GEN_HARD_NEQ
• generic GEN_HARD_LESS
• generic GEN_HARD_GTR
• generic GEN_EXACT_HASH
• generic GEN_EXACT_EQ
• generic GEN_EXACT_NEQ
• generic GEN_HASH
• generic GEN_FLATTEN
• generic GEN_DUPLICATE
• generic GEN_FAST
• generic GEN_SLOW
• generic GEN_MUL_ADD
• generic GEN_MUL_SUB
• generic GEN_SQUARE
• generic GEN_GRAEFFE
• generic GEN_INVERT
• generic GEN_NUMERATOR
• generic GEN_DENOMINATOR
• generic GEN_GCD
• generic GEN_LCM
• generic GEN_XGCD
• generic GEN_SQRT
• generic GEN_EXP
• generic GEN_EXP2
• generic GEN_EXP10
• generic GEN_LOG
• generic GEN_LOG2
• generic GEN_LOG10
• generic GEN_COS
• generic GEN_SIN
• generic GEN_TAN
• generic GEN_ARCCOS
• generic GEN_ARCSIN
• generic GEN_ARCTAN
• generic GEN_CH
• generic GEN_SH
• generic GEN_TH
• generic GEN_ARGCH
• generic GEN_ARGSH
• generic GEN_ARGTH
• generic GEN_HYPOT
• generic GEN_ARCTAN2
• generic GEN_CBRT
• generic GEN_GAMMA
• generic GEN_ZETA
• generic GEN_ERF
• generic GEN_MIN
• generic GEN_MAX
• generic GEN_INF
• generic GEN_SUP
• generic GEN_ABS
• generic GEN_SIGN
• generic GEN_ARG
• generic GEN_RE
• generic GEN_IM
• generic GEN_CONJ
• generic GEN_TIMES_I
• generic GEN_OVER_I
• generic GEN_BALL
• generic GEN_CENTER
• generic GEN_RADIUS
• generic GEN_INTERVAL
• generic GEN_LOWER
• generic GEN_UPPER
• generic GEN_SHARPEN
• generic GEN_BLUR
• generic GEN_INCLUDED
• generic GEN_LIFT
• generic GEN_PROJECT
• generic GEN_RECONSTRUCT
• generic GEN_TRUNCATE
• generic GEN_COMPLETE
• generic GEN_EVALUATE
• generic GEN_CHANGE_PRECISION
• generic GEN_PRECISION
• generic GEN_NEXT_ABOVE
• generic GEN_NEXT_BELOW
• generic GEN_ROUNDING_ERROR
• generic GEN_ADDITIVE_ERROR
• generic GEN_MULTIPLICATIVE_ERROR
• generic GEN_ELEMENTARY_ERROR
• generic GEN_EXPONENT
• generic GEN_MAGNITUDE
• generic GEN_FLOOR
• generic GEN_TRUNC
• generic GEN_CEIL
• generic GEN_ROUND
• generic GEN_GAUSSIAN
• generic GEN_POLAR
• generic GEN_CACHED_DERIVE
• generic GEN_DERIVE
• generic GEN_DERIVATIVE
• generic GEN_GRAD
• generic GEN_XDERIVE
• generic GEN_INTEGRATE
• generic GEN_INTEGRATE_INIT
• generic GEN_REVERSE
• generic GEN_SUBSTITUTE
• generic GEN_SOLVE
• generic GEN_NOOP
• generic GEN_ALIAS_TYPE
• generic GEN_BOOLEAN_TYPE
• generic GEN_COMPOUND_TYPE
• generic GEN_CROSS_TYPE
• generic GEN_DOUBLE_TYPE
• generic GEN_FLOATING_TYPE
• generic GEN_FUNCTION_TYPE
• generic GEN_GENERATOR_TYPE
• generic GEN_GENERIC_TYPE
• generic GEN_GENERIC_ALIAS_TYPE
• generic GEN_INT_TYPE
• generic GEN_INTEGER_TYPE
• generic GEN_LITERAL_TYPE
• generic GEN_MACRO_TYPE
• generic GEN_RATIONAL_TYPE
• generic GEN_ROUTINE_TYPE
• generic GEN_SINGLE_TYPE
• generic GEN_SYMBOL_TYPE
• generic GEN_THIS_TYPE
• generic GEN_TUPLE_TYPE
• generic GEN_TYPE_TYPE
• generic GEN_UNSPECIFIED_TYPE
• generic GEN_VOID_TYPE
• generic GEN_COERCE_TYPE
• generic GEN_ALIAS
• generic GEN_ALL_TYPES
• generic GEN_CACHE_CONVERTER
• generic GEN_CACHE_CONVERTERS
• generic GEN_CACHE_PENALTY
• generic GEN_CAST
• generic GEN_CLASS_NAME
• generic GEN_CLASS_MODE
• generic GEN_CLASS_ENCAPSULATION
• generic GEN_CLASS_ACCESS
• generic GEN_CLASS_FIELDS
• generic GEN_CLASS_EXPORT
• generic GEN_CLOSURE
• generic GEN_CONVERTER
• generic GEN_CONVERTERS
• generic GEN_DOWNGRADE
• generic GEN_EMPTY
• generic GEN_EQUALIZE_GROUPED
• generic GEN_EXPECTED
• generic GEN_GLOBAL
• generic GEN_IDENTITY
• generic GEN_LIST
• generic GEN_LOCAL
• generic GEN_MACRO
• generic GEN_NEW
• generic GEN_REWRITE
• generic GEN_SPECIALIZE_ALIAS
• generic GEN_SPECIALIZE
• generic GEN_TRANSITIVE
• generic GEN_TYPE_NAME
• generic GEN_TYPE_ID
• generic GEN_UNALIAS
• generic GEN_UPGRADE
• generic GEN_VIA_TUPLE
• generic GEN_EXCEPTION
• generic GEN_BACKTRACE
• generic GEN_COERCE
• const int int_plus_infinity = (int) (((nat) (-1)) >> 1)
• const int int_minus_infinity = (int) ((((nat) (-1)) >> 1) + 1)
• const int int_size = sizeof (int)
• const int long_int_size = sizeof (long int)
• bool script_mode = false
• bool quiet_mode = false
• bool debug_mode = false
• bool type_mode = false
• bool time_mode = false
• bool texmacs_mode = false
• nat history_size = 100
• bool completion_mode = true
• bool batch_mode = false
• list< string > identifiers_for_completion
• table< generic, generic > strings_for_completion
• string shell_mmx_prompt = "mmx-prompt"
• vector< string > mmc_args
• bool new_lambda_style
• bool mmx_abbreviate_coerce = true
• bool new_convert_style
• const nat hibit_mask = ((nat) 1) << 31
• T
• V
• scalar_type
• new_table< C, T, V >
• C
• bool math_mode = false
• bool color_mode = false
• port mmin = input_file_port (stdin , false, false, "mmin")
• char * command_name = NULL
• void(* embedded_link )(const string &name) = NULL
• table< C, T, V >
• nat threads_number = 1
• C2
• generic CPP_ALIAS_TYPE ("Alias")
• generic CPP_ARRAY_TYPE ("Array")
• generic CPP_BOOL_TYPE ("Boolean")
• generic CPP_CHAR_TYPE ("Char")
• generic CPP_CLASS_TYPE ("Type")
• generic CPP_COMMA (",")
• generic CPP_CONST_METHOD ("const_method")
• generic CPP_EXTERN_C ("extern_C")
• generic CPP_FRIEND ("friend")
• generic CPP_FUNCTION_TYPE ("Function")
• generic CPP_GOTO ("goto")
• generic CPP_INT_TYPE ("Int")
• generic CPP_LABEL ("label")
• generic CPP_MACRO ("cpp_macro")
• generic CPP_MMX_APPLICATION_TYPE ("Mmx_application")
• generic CPP_POINTER_TYPE ("Pointer")
• generic CPP_POWER ("^")
• generic CPP_SEMICOLON (";")
• generic CPP_STRING_TYPE ("String")
• generic CPP_TYPE_CONSTRUCTOR ("type_constructor")
• generic CPP_VOID_TYPE ("Void")
• static nat indentation_level = 0
• bool ev_lock = false
• list< evaluator > stack_ev
• table< int, int > out_count (0)
• table< int, int > in_count (0)
• static table< generic, string > binary_readers
• static table< void(*)(), string > glue_table )()
• void(* compiler_initialize )(void) = NULL
• void(* compiler_terminate )(void) = NULL
• static string texmacs_pending = ""
• nat backtrace_depth = 8
• static vector< vector< string > > interactive_sources
• static table< vector< string >
  , string > file_sources
• string(* as_string_hook )(double x) = NULL
• static bool frac_flag = false
• nat the_series_prec = 10
• nat the_series_zt = 25
• bool the_series_expr = false
• static const char path_sep = ':'
• system_instance system_inst
• static bool fed
• static routine current_comparison

---

Typedef Documentation

typedef char* char_ptr

Definition at line 60 of file defaults.hpp.

typedef char* charp

Definition at line 129 of file port.hpp.

typedef const char* const_charp

Definition at line 130 of file port.hpp.

typedef long int double_int

Definition at line 31 of file int.hpp.

typedef unsigned int nat

Definition at line 49 of file fast_new.hpp.

typedef pow_op rpow_op

Definition at line 1301 of file operators.hpp.

typedef unsigned char uchar

Definition at line 50 of file fast_new.hpp.

typedef unsigned int uint

Definition at line 52 of file fast_new.hpp.

typedef unsigned long ulong

Definition at line 53 of file fast_new.hpp.

typedef generic(* unary_generic)(const generic &)

Definition at line 256 of file port.hpp.

typedef unsigned short ushort

Definition at line 51 of file fast_new.hpp.

typedef routine* vec_routine

Definition at line 487 of file generic.hpp.

typedef void* void_ptr

Definition at line 59 of file defaults.hpp.

typedef long int xint

Definition at line 59 of file fast_new.hpp.

typedef unsigned long int xnat

Definition at line 60 of file fast_new.hpp.

---

Enumeration Type Documentation

enum mmx_rounding

Enumerator:

MMX_ROUND_NEAR
MMX_ROUND_ZERO
MMX_ROUND_UP
MMX_ROUND_DOWN

Definition at line 1029 of file type_props.hpp.

                  {
  MMX_ROUND_NEAR,
  MMX_ROUND_ZERO,
  MMX_ROUND_UP,
  MMX_ROUND_DOWN
};

enum print_controls

Enumerator:

LF
INDENT
UNINDENT
LF
INDENT
VARINDENT
UNINDENT

Definition at line 85 of file mmx_printer.cpp.

{ LF, INDENT, VARINDENT, UNINDENT };

enum print_controls

Enumerator:

LF
INDENT
UNINDENT
LF
INDENT
VARINDENT
UNINDENT

Definition at line 191 of file cpp_printer.cpp.

{ LF, INDENT, UNINDENT };

enum print_format

Special objects that affect output when printed.

Enumerator:

blank	Set one indentation to two spaces.
stroke	Set one indentation to "| ".
indent	Increment indentation.
unindent	Decrement indentation.
reset_indent	Reset indentation to zero.
cr	Carriage return.
lf	Line feed and indent the new line.
hrule	Output 80 consecutive dashes.
flush_now	Flush the buffer.
black_foreground
red_foreground
green_foreground
yellow_foreground
blue_foreground
magenta_foreground
cyan_foreground
white_foreground
black_background
red_background
green_background
yellow_background
blue_background
magenta_background
cyan_background
white_background
bold
underline
blink
reset_attributes

Definition at line 38 of file basix.hpp.

                  {
  blank,         
  stroke,        
  indent,        
  unindent,      
  reset_indent,  
  cr,            
  lf,            
  hrule,         
  flush_now,      

  black_foreground,
  red_foreground,
  green_foreground,
  yellow_foreground,
  blue_foreground,
  magenta_foreground,
  cyan_foreground,
  white_foreground,

  black_background,
  red_background,
  green_background,
  yellow_background,
  blue_background,
  magenta_background,
  cyan_background,
  white_background,

  bold,
  underline,
  blink,

  reset_attributes
};

---

Function Documentation

static string mmx::_from_dos_to_unix

(

const string &

x

)

[static]

Definition at line 61 of file system.cpp.

Referenced by command_dir(), decode_name(), global_path(), load_path(), path_name(), prefix_dir(), sysconf_dir(), user_dir(), var_load(), and var_pwd().

                                    {
  return x;
}

sparse_vector<C,T,V> mmx::_mul_add	(	const sparse_vector< C, T, V > &	v1,
		const sparse_vector< C, T, V > &	v2,
		const C &	x
	)			[inline]

Definition at line 313 of file sparse_vector.hpp.

References C, exact_eq(), n, N(), Pair, set_zero(), and Sparse_vector.

                                                                        {
  // v1 + x * v2
  typedef typename V::val_op Eq;
  typedef typename V::l_op Less;
  static C zero; set_zero (zero);
  if (exact_eq (x, zero)) return v1;
  nat i1, i2, n1= N(v1), n2= N(v2), j, n= n1 + n2;
  Pair* r= mmx_new<Pair > (n);
  for (i1= i2= j= 0; i1 < n1 && i2 < n2; ) {
    if (Less::op (v1[i1].x1, v2[i2].x1)) {
      r[j++]= v1[i1]; i1++;
    }
    else if (Less::op (v2[i2].x1, v1[i1].x1)) {
      r[j++]= Pair (v2[i2].x1, Mul::op (x, v2[i2].x2)); i2++;
    }
    else {
      Pair e (v2[i2].x1, v1[i1].x2 + Mul::op (x, v2[i2].x2));
      i1++; i2++; if (Eq::not_op (e.x2, zero)) r[j++]= e;
    }
  }
  while (i1 < n1) {
    r[j++]= Pair (v1[i1].x1, v1[i1].x2); i1++;
  }
  while (i2 < n2) {
    r[j++]= Pair (v2[i2].x1,  Mul::op (x, v2[i2].x2)); i2++;
  }
  return Sparse_vector (r, j, n);
}

vector<typename unary_return_type_helper<abs_op, C >::RET,V> mmx::abs

(

const vector< C, V > &

v

)

[inline]

Definition at line 1340 of file vector.hpp.

{ return unary_map<abs_op> (v); }

syntactic abs

(

const syntactic &

g1

)

Definition at line 452 of file syntactic.cpp.

References GEN_ABS, and syn().

{ return syn (GEN_ABS, g1); }

generic abs

(

const generic &

x1

)

Definition at line 730 of file generic.cpp.

References current_ev, and GEN_ABS.

                                {
  return current_ev->apply (GEN_ABS, x1); }

long long unsigned int mmx::abs

(

const long long unsigned int &

x

)

[inline]

Definition at line 474 of file defaults.hpp.

{ return x; }

long unsigned int mmx::abs

(

const long unsigned int &

x

)

[inline]

Definition at line 471 of file defaults.hpp.

{ return x; }    

unsigned int mmx::abs

(

const unsigned int &

x

)

[inline]

Definition at line 468 of file defaults.hpp.

{ return x; }    

short unsigned int mmx::abs

(

const short unsigned int &

x

)

[inline]

Definition at line 465 of file defaults.hpp.

{ return x; }    

unsigned char mmx::abs

(

const unsigned char &

x

)

[inline]

Definition at line 462 of file defaults.hpp.

{ return x; }    

C mmx::abs

(

const C &

x

)

[inline]

Definition at line 459 of file defaults.hpp.

Referenced by abs_down(), abs_op::Abs_type(), abs_up(), additive_error(), atan2(), bit_size(), GLUE_20(), GLUE_30(), abs_as_op::op(), abs_op::op(), pow(), unsigned_int_reconstruct_helper< U >::reconstruct(), int_reconstruct_helper< I >::reconstruct(), rounding_error(), abs_as_op::set_op(), and abs_op::set_op().

{ return x>=0? x: -x; }

unary_return_type_helper<abs_op, C >::RET mmx::abs_down

(

const C &

x

)

[inline]

Definition at line 1096 of file type_props.hpp.

References abs().

{ return abs (x); }

unary_return_type_helper<abs_op, C >::RET mmx::abs_up

(

const C &

x

)

[inline]

Definition at line 1098 of file type_props.hpp.

References abs().

{ return abs (x); }

U mmx::abstract_to_concrete

(

const T &

g

)

[inline]

Definition at line 192 of file mmc_glue.hpp.

                                  {
  return generic_as_any<U> (g);
}

vector<generic> mmx::abstract_vector

(

const generic &

conc

)

[inline]

Definition at line 299 of file vector.hpp.

                                      {
  return as<vector<generic> > (conc->make_abstract_vector ());
}

void mmx::accelerate	(	const generic &	,
		bool(*)(const bool &, const bool &)
	)			[inline]

Definition at line 163 of file glue.hpp.

{}

void mmx::accelerate	(	const generic &	name,
		bool(*)(const C &, const C &)	f
	)			[inline]

Definition at line 150 of file glue.hpp.

References ACC_GTR, ACC_GTREQ, ACC_LESS, ACC_LESSEQ, binary_routine(), GEN_GTR, GEN_GTREQ, GEN_LESS, and GEN_LESSEQ.

                                                                 {
  routine fun= binary_routine (name, f);
  if (name == GEN_LESS)
    Acc::set_apply (ACC_LESS, fun);
  else if (name == GEN_LESSEQ)
    Acc::set_apply (ACC_LESSEQ, fun);
  else if (name == GEN_GTR)
    Acc::set_apply (ACC_GTR, fun);
  else if (name == GEN_GTREQ)
    Acc::set_apply (ACC_GTREQ, fun);
}

void mmx::accelerate	(	const generic &	name,
		C(*)(const C &, const C &)	f
	)			[inline]

Definition at line 131 of file glue.hpp.

References ACC_ADD, ACC_ATAN2, ACC_DIV, ACC_HYPOT, ACC_MUL, ACC_POW, ACC_SUB, binary_routine(), GEN_ARCTAN2, GEN_HYPOT, GEN_MINUS, GEN_OVER, GEN_PLUS, GEN_POWER, and GEN_TIMES.

                                                              {
  routine fun= binary_routine (name, f);
  if (name == GEN_PLUS)
    Acc::set_apply (ACC_ADD, fun);
  else if (name == GEN_MINUS)
    Acc::set_apply (ACC_SUB, fun);
  else if (name == GEN_TIMES)
    Acc::set_apply (ACC_MUL, fun);
  else if (name == GEN_OVER)
    Acc::set_apply (ACC_DIV, fun);
  else if (name == GEN_HYPOT)
    Acc::set_apply (ACC_HYPOT, fun);
  else if (name == GEN_ARCTAN2)
    Acc::set_apply (ACC_ATAN2, fun);
  else if (name == GEN_POWER)
    Acc::set_apply (ACC_POW, fun);
}

void mmx::accelerate	(	const generic &	,
		C(*)(const S1 &, const S2 &)
	)			[inline]

Definition at line 128 of file glue.hpp.

{}

void mmx::accelerate	(	const generic &	name,
		C(*)(const C &)	f
	)			[inline]

Definition at line 83 of file glue.hpp.

References ACC_ACOS, ACC_ACOSH, ACC_ASIN, ACC_ASINH, ACC_ATAN, ACC_ATANH, ACC_COS, ACC_COSH, ACC_DERIVE, ACC_EXP, ACC_INTEGRATE, ACC_INVERT, ACC_LOG, ACC_NEGATE, ACC_SIN, ACC_SINH, ACC_SQRT, ACC_SQUARE, ACC_TAN, ACC_TANH, GEN_ARCCOS, GEN_ARCSIN, GEN_ARCTAN, GEN_ARGCH, GEN_ARGSH, GEN_ARGTH, GEN_CH, GEN_COS, GEN_DERIVE, GEN_EXP, GEN_INTEGRATE, GEN_INVERT, GEN_LOG, GEN_MINUS, GEN_SH, GEN_SIN, GEN_SQRT, GEN_SQUARE, GEN_TAN, GEN_TH, and unary_routine().

                                                    {
  routine fun= unary_routine (name, f);
  if (name == GEN_MINUS)
    Acc::set_apply (ACC_NEGATE, fun);
  else if (name == GEN_SQUARE)
    Acc::set_apply (ACC_SQUARE, fun);
  else if (name == GEN_INVERT)
    Acc::set_apply (ACC_INVERT, fun);
  else if (name == GEN_SQRT)
    Acc::set_apply (ACC_SQRT, fun);
  else if (name == GEN_EXP)
    Acc::set_apply (ACC_EXP, fun);
  else if (name == GEN_LOG)
    Acc::set_apply (ACC_LOG, fun);
  else if (name == GEN_COS)
    Acc::set_apply (ACC_COS, fun);
  else if (name == GEN_SIN)
    Acc::set_apply (ACC_SIN, fun);
  else if (name == GEN_TAN)
    Acc::set_apply (ACC_TAN, fun);
  else if (name == GEN_CH)
    Acc::set_apply (ACC_COSH, fun);
  else if (name == GEN_SH)
    Acc::set_apply (ACC_SINH, fun);
  else if (name == GEN_TH)
    Acc::set_apply (ACC_TANH, fun);
  else if (name == GEN_ARCCOS)
    Acc::set_apply (ACC_ACOS, fun);
  else if (name == GEN_ARCSIN)
    Acc::set_apply (ACC_ASIN, fun);
  else if (name == GEN_ARCTAN)
    Acc::set_apply (ACC_ATAN, fun);
  else if (name == GEN_ARGCH)
    Acc::set_apply (ACC_ACOSH, fun);
  else if (name == GEN_ARGSH)
    Acc::set_apply (ACC_ASINH, fun);
  else if (name == GEN_ARGTH)
    Acc::set_apply (ACC_ATANH, fun);
  else if (name == GEN_DERIVE)
    Acc::set_apply (ACC_DERIVE, fun);
  else if (name == GEN_INTEGRATE)
    Acc::set_apply (ACC_INTEGRATE, fun);
}

void mmx::accelerate	(	const generic &	name,
		C(*)(const S1 &)	f
	)			[inline]

Definition at line 77 of file glue.hpp.

References accelerate_converter(), and GEN_CAST.

Referenced by define().

                                                     {
  if (name == GEN_CAST)
    accelerate_converter (name, f);
}

void mmx::accelerate_converter	(	const generic &	,
		int(*)(const generic_alias< S > &)
	)			[inline]

Definition at line 74 of file glue.hpp.

{}

void mmx::accelerate_converter	(	const generic &	,
		int(*)(const alias< S > &)
	)			[inline]

Definition at line 72 of file glue.hpp.

{}

void mmx::accelerate_converter	(	const generic &	,
		int(*)(const S &)
	)			[inline]

Definition at line 70 of file glue.hpp.

{}

void mmx::accelerate_converter	(	const generic &	,
		C(*)(const generic_alias< S > &)
	)			[inline]

Definition at line 68 of file glue.hpp.

{}

void mmx::accelerate_converter	(	const generic &	,
		C(*)(const alias< S > &)
	)			[inline]

Definition at line 66 of file glue.hpp.

{}

void mmx::accelerate_converter	(	const generic &	name,
		C(*)(const S1 &)	f
	)			[inline]

Definition at line 56 of file glue.hpp.

References gen(), GEN_INTO, and unary_routine().

Referenced by accelerate(), and define_converter().

                                                               {
  (void) name;
  accelerate_initialize<C> ();
  accelerate_initialize<S1> ();
  generic con= gen (GEN_INTO, type_name<S1> (), type_name<C> ());
  routine fun= unary_routine (con, f);
  Acc::set_construct (accelerator<S1>::id, fun);
}

void mmx::accelerate_initialize

(

)

[inline]

Definition at line 50 of file glue.hpp.

References accelerate_number().

                         {
  if (Acc::id == ((nat) (-1)))
    Acc::id= accelerate_number ();
}

nat accelerate_number

(

)

Definition at line 99 of file glue.cpp.

Referenced by accelerate_initialize().

                     {
  static nat nr_ids= 0;
  return nr_ids++;
}

port mmx::accept

(

const port &

p

)

[inline]

Definition at line 119 of file port.hpp.

References inside().

Referenced by GLUE_20().

                                   {
  return inside (p)->accept (); }

syntactic access	(	const syntactic &	g,
		const syntactic &	i,
		const syntactic &	j
	)

Definition at line 509 of file syntactic.cpp.

References GEN_ACCESS, and syn().

                                                                              {
  return syn (GEN_ACCESS, g, i, j); }

syntactic access	(	const syntactic &	g,
		const syntactic &	i
	)

Definition at line 507 of file syntactic.cpp.

References GEN_ACCESS, and syn().

                                                          {
  return syn (GEN_ACCESS, g, i); }

R* mmx::access

(

Indirect< R > &

x

)

[inline]

Definition at line 752 of file mmc_glue.hpp.

References Indirect< R >::rep.

                                       {
  return x.rep; }

generic access	(	const generic &	f,
		const vector< generic > &	x
	)

Definition at line 185 of file generic.cpp.

References append(), GEN_ACCESS, and vector_to_compound().

                                                               {
  vector<generic> v= vec<generic> (generic (GEN_ACCESS), g);
  return vector_to_compound (append (v, args)); }

generic access	(	const generic &	f,
		const generic &	x,
		const generic &	y
	)

Definition at line 183 of file generic.cpp.

References gen(), and GEN_ACCESS.

                                                                      {
  return gen (GEN_ACCESS, g, x, y); }

generic access	(	const generic &	f,
		const generic &	x
	)

Definition at line 181 of file generic.cpp.

References gen(), and GEN_ACCESS.

Referenced by binary_access(), trig_op::diff_op(), and binary_helper< generic >::disassemble().

                                                    {
  return gen (GEN_ACCESS, g, x); }

C mmx::accuracy_cst

(

const format< C > &

fm

)

[inline]

Definition at line 951 of file type_props.hpp.

References C, promote(), and set_accuracy().

                                   {
  C r= promote (0, fm); set_accuracy (r); return r; }

C mmx::accuracy_cst

(

)

[inline]

Definition at line 912 of file type_props.hpp.

References C, and set_accuracy().

{ C r; set_accuracy (r); return r; }

vector<C,V> mmx::acos

(

const vector< C, V > &

v

)

[inline]

Definition at line 1183 of file vector.hpp.

{ return unary_map<acos_op> (v); }

table<C,T,V> mmx::acos

(

const table< C, T, V > &

t

)

[inline]

Definition at line 704 of file table.hpp.

{ return unary_map<acos_op> (t); }

syntactic acos

(

const syntactic &

g

)

Definition at line 433 of file syntactic.cpp.

References GEN_ARCCOS, and syn().

{ return syn (GEN_ARCCOS, g); }

new_table<C,T,V> mmx::acos

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 775 of file new_table.hpp.

{ return unary_map<acos_op> (t); }

generic acos

(

const generic &

x1

)

Definition at line 463 of file generic.cpp.

References ACC_ACOS, ACC_UNARY, current_ev, and GEN_ARCCOS.

                         {
  ACC_UNARY (ACC_ACOS, x1);
  return current_ev->apply (GEN_ARCCOS, x1);
}

double acos

(

const double &

x

)

[inline]

Definition at line 55 of file double.hpp.

Referenced by acos_op::op(), and acos_op::set_op().

{ return std::acos (x); }

syntactic acos_init	(	const syntactic &	x,
		const syntactic &	c
	)

Definition at line 493 of file syntactic.cpp.

References syn().

                                                             {
  return syn ("acos_init", x, c); }

generic acos_init	(	const generic &	x,
		const generic &	c
	)

Definition at line 806 of file generic.cpp.

References current_ev.

Referenced by acos_op::op_init().

                                                         {
  return current_ev->apply ("acos_init", x1, x2); }

syntactic acosh

(

const syntactic &

g

)

Definition at line 439 of file syntactic.cpp.

References GEN_ARGCH, and syn().

{ return syn (GEN_ARGCH, g); }

generic acosh

(

const generic &

x1

)

Definition at line 499 of file generic.cpp.

References ACC_ACOSH, ACC_UNARY, log(), sqrt(), and square().

                          {
  ACC_UNARY (ACC_ACOSH, x1);
  return log (x1 + sqrt (square (x1) - 1));
}

double mmx::acosh

(

const double &

x

)

[inline]

Definition at line 71 of file double.hpp.

{ return std::isfinite (x); }

C mmx::acosh

(

const C &

x

)

[inline]

Definition at line 595 of file defaults.hpp.

References log(), promote(), sqrt(), and square().

Referenced by acosh_op::op(), and acosh_op::set_op().

                                                 {
  return log (x + sqrt (square (x) - promote (1, x))); }

static int mmx::active_newline	(	int	a,
		int	b
	)			[static]

Definition at line 294 of file terminal_interface.cpp.

References fed.

Referenced by shell_terminal_input().

                             {
  (void) a;
  (void) b;
  rl_crlf ();
  rl_on_new_line ();
  fed = true;
  rl_done = 1;
  return 0;
}

void mmx::add	(	R &	x,
		const C1 &	y1,
		const C2 &	y2
	)			[inline]

Definition at line 54 of file operators.hpp.

Referenced by ladd_op::set_op(), radd_op::set_op(), and add_op::set_op().

{ x= y1 + y2; }

string add_indentation	(	const string &	obj->lex_string,
		int	delta
	)

Definition at line 644 of file string.cpp.

References ASSERT, min(), N(), recompose(), repeated(), and tokenize().

Referenced by source_string_unindented().

                                             {
  if (delta == 0) return s;
  vector<string> v= tokenize (s, "\n");
  for (nat i=0; i<N(v); i++)
    if (delta > 0) v[i]= repeated (" ", delta) * v[i];
    else {
      int l= min (-delta, (int) N(v[i]));
      ASSERT (v[i] (0, l) == repeated (" ", l), "insufficient indentation");
      v[i]= v[i] (l, N(v[i]));
    }
  return recompose (v, "\n", N(s) != 0 && s[N(s) - 1] == '\n');
}

generic mmx::add_modes	(	const generic &	g,
		int	mode,
		int	new_mode
	)

Definition at line 65 of file mmx_texmacs.cpp.

References add_modes(), gen(), and is_func().

                                                     {
  // mmerr << as_lisp (g) << ", " << mode << ", " << new_mode << "\n";
  generic r= add_modes (g, new_mode);
  if (is_func (r, "$concat", 1)) r= r[1];
  if (mode == new_mode) return r;
  else if (is_func (r, "$math", 1)) return r;
  else if (is_func (r, "$text", 1)) return r;
  else if (new_mode == 1) return gen ("$math", r);
  else if (new_mode == 2) return gen ("$text", r);
  else return r;
}

generic add_modes	(	const generic &	g,
		int	mode
	)

Definition at line 78 of file mmx_texmacs.cpp.

References compound_to_vector(), copy(), is_func(), N(), and vector_to_compound().

Referenced by add_modes(), as_texmacs_scheme(), and as_texmacs_snippet().

                                       {
  // mmerr << as_lisp (g) << ", " << mode << "\n";
  if (!is<compound> (g) || !is<literal> (g[0])) return g;
  if (is_func (g, "$math", 1)) return add_modes (g[1], mode, 1);
  if (is_func (g, "$text", 1)) return add_modes (g[1], mode, 2);
  if (is_func (g, "$inmath", 1)) return add_modes (g[1], 1);
  if (is_func (g, "$intext", 1)) return add_modes (g[1], 2);
  vector<generic> v= copy (compound_to_vector (g));
  for (nat i=1; i<N(v); i++) v[i]= add_modes (v[i], mode);
  return vector_to_compound (v);
}

T mmx::add_operator	(	const T &	x,
		const T &	y
	)			[inline]

Definition at line 31 of file operators.hpp.

{ return x+y; }

unary_return_type_helper<abs_op, C >::RET mmx::additive_error

(

const C &

x

)

[inline]

Definition at line 1071 of file type_props.hpp.

References rounding_error().

                                                                    {
  return rounding_error (x); }

generic additive_error

(

const generic &

x

)

Definition at line 774 of file generic.cpp.

References current_ev, and GEN_ADDITIVE_ERROR.

                                          {
  return current_ev->apply (GEN_ADDITIVE_ERROR, x); }

double mmx::additive_error

(

const double &

x

)

[inline]

Definition at line 90 of file double.hpp.

References abs().

Referenced by additive_error_op::Abs_type(), GLUE_52(), and additive_error_op::set_op().

                                               {
  return ldexp (nextafter (abs (x), HUGE_VAL), -50); }

alias<C> mmx::alias_access	(	const alias< R > &	r,
		const A &	a,
		const B &	b
	)			[inline]

Definition at line 260 of file alias.hpp.

                                                         {
  return new alias_binary_access_rep<C,R,A,B> (r, a, b);
}

alias<C> mmx::alias_access	(	const alias< R > &	r,
		const A &	a
	)			[inline]

Definition at line 241 of file alias.hpp.

                                             {
  return new alias_unary_access_rep<C,R,A> (r, a);
}

void alias_getter	(	nat	id,
		routine &	r
	)

Definition at line 68 of file alias.cpp.

References is_nil(), and read().

Referenced by define_type_helper< C >::def_type(), define_user_type(), and get_alias().

                                  {
  static table<routine,nat> t;
  if (is_nil (r)) r= read (t, id);
  else t[id]= r;
}

void mmx::alias_glue	(	const alias< R > &	r,
		const A &	a,
		const B &	b
	)			[inline]

Definition at line 278 of file alias.hpp.

                                                       {
  glue (r->open (), a, b);
  r->close ();
}

void mmx::alias_reset	(	const alias< R > &	r,
		const A &	a
	)			[inline]

Definition at line 265 of file alias.hpp.

References reset().

Referenced by alias_tuple_reset(), and GLUE_13().

                                            {
  reset (r->open (), a);
  r->close ();
}

void alias_setter	(	nat	id,
		routine &	r
	)

Definition at line 82 of file alias.cpp.

References is_nil(), and read().

Referenced by define_type_helper< C >::def_type(), define_user_type(), and set_alias().

                                  {
  static table<routine,nat> t;
  if (is_nil (r)) r= read (t, id);
  else t[id]= r;
}

void alias_specializer	(	nat	id,
		routine &	r
	)

Definition at line 53 of file alias.cpp.

References is_nil(), and read().

Referenced by define_type_helper< C >::def_type(), define_user_type(), and specialize_alias().

                                       {
  static table<routine,nat> t;
  if (is_nil (r)) r= read (t, id);
  else t[id]= r;
}

nat mmx::alias_to_scalar

(

nat

id

)

[inline]

Definition at line 189 of file alias.hpp.

References alias_type_info().

                         {
  int mode= 0;
  alias_type_info (id, mode);
  return id;
}

alias<X> mmx::alias_tuple_access	(	const alias< R > &	r,
		const A &	a,
		const B &	b,
		const C &	c
	)			[inline]

Definition at line 285 of file alias.hpp.

References cons().

                                                                           {
  return alias_access<X> (r, cons (a, (cons (b, c))));
}

void mmx::alias_tuple_reset	(	const alias< R > &	r,
		const A &	a,
		const B &	b,
		const C &	c
	)			[inline]

Definition at line 291 of file alias.hpp.

References alias_reset(), and cons().

Referenced by GLUE_21().

                                                                          {
  alias_reset (r, cons (a, cons (b, c)));
}

void alias_type_info	(	nat &	id,
		int &	mode
	)

Definition at line 19 of file alias.cpp.

References ERROR, new_type_id(), and read().

Referenced by alias_to_scalar(), is_alias_type(), new_alias_type_id(), new_generic_alias_type_id(), and scalar_to_alias().

                                     {
  static table<nat,nat> t (0);
  static table<nat,nat> u (0);
  static table<nat,nat> v (0);
  if (mode == 0) {
    mode= t->contains (id)? 1: 0;
    id= read (t, id);
  }
  else if (mode == 1) {
    mode= u->contains (id)? 1: 0;
    id= read (u, id);
  }
  else if (mode == 2) {
    if (u->contains (id)) id= u[id];
    else {
      nat new_id= new_type_id ();
      t[new_id]= id;
      u[id]= new_id;
      id= new_id;
    }
  }
  else if (mode == 3) {
    if (v->contains (id)) id= v[id];
    else {
      nat new_id= new_type_id ();
      t[new_id]= id;
      v[id]= new_id;
      id= new_id;
    }
  }
  else ERROR ("wrong mode");
}

alias<R> mmx::alias_write	(	const alias< R > &	r,
		const A &	a
	)			[inline]

Definition at line 271 of file alias.hpp.

Referenced by GLUE_10(), GLUE_11(), GLUE_17(), and GLUE_6().

                                            {
  r->open () << a;
  r->close ();
  return r;
}

nat mmx::aligned_size

(

nat

n

)

[inline]

Definition at line 70 of file vector_naive.hpp.

                     {
  typedef implementation<vector_allocate,V> Vec;
  return Vec::template vec_aligned_size<C> (n);
}

vector< generic > all_type_names

(

)

Definition at line 59 of file glue.cpp.

References as(), current_ev, gen(), and GEN_ALL_TYPES.

Referenced by define_type_sub().

                  {
  generic ret;
  if (current_ev->get (gen (GEN_ALL_TYPES), ret))
    return as<vector<generic> > (ret);
  return vec<generic> ();
}

bool mmx::always_false

(

const C &

x

)

[inline]

Definition at line 745 of file defaults.hpp.

                          {
  (void) x; return false;
}

bool mmx::always_true

(

const C &

x

)

[inline]

Definition at line 750 of file defaults.hpp.

                         {
  (void) x; return true;
}

static string mmx::ancestor_search_name	(	const string &	dir,
		const string &	name
	)			[static]

Definition at line 661 of file system.cpp.

References get_directory(), semi_recursive_search_name(), starts(), and var_pwd().

Referenced by resolve_name().

                                                             {
  //mmout << "Ancestor search " << dir << ", " << name << "\n";
  string sname= semi_recursive_search_name (dir, name);
  if (sname != "") return sname;
  if (dir == "" || dir == ".") {
    string pdir= get_directory (var_pwd ());
    if (!starts (pdir, "/")) return "";
    return ancestor_search_name (pdir, name);
  }
  if (dir == "/") return "";
  return ancestor_search_name (get_directory (dir), name);
}

generic mmx::any_as_generic

(

const T &

t

)

[inline]

Definition at line 177 of file mmc_glue.hpp.

References as_helper< T, F >::cv().

                            {
  return as_helper<generic,T>::cv (t);
}

vector<C,V> mmx::append	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 637 of file vector.hpp.

References ASSERT, C, CF(), copy(), is_non_scalar(), N(), n, seg(), and Vector.

                                          {
  typedef implementation<vector_linear,V> Vec;
  ASSERT (is_non_scalar (v) && is_non_scalar (w),
          "non-scalar vectors expected");
  nat n= N(v), p= N(w);
  nat l= aligned_size<C,V> (n+p);
  C* a= mmx_formatted_new<C> (l, CF(v));
  Vec::copy (a, seg (v), n);
  Vec::copy (a+n, seg (w), p);
  return Vector (a, n+p, l, CF(v));
}

vector<C,V> mmx::append	(	const vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 625 of file vector.hpp.

References ASSERT, C, CF(), copy(), is_non_scalar(), N(), n, seg(), and Vector.

                                     {
  typedef implementation<vector_linear,V> Vec;
  ASSERT (is_non_scalar (v), "non-scalar vector expected");
  nat n= N(v);
  nat l= aligned_size<C,V> (n+1);
  C* a= mmx_formatted_new<C> (l, CF(v));
  a[n]= c;
  Vec::copy (a, seg (v), n);
  return Vector (a, n+1, l, CF(v));
}

table<C,T,V> mmx::append	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 765 of file table.hpp.

References busy(), CF2(), entries(), I(), and Table.

                                        {
  Table r (I (u), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    r[*it]= t[*it];
  for (iterator<T> it= entries (u); busy (it); ++it)
    r[*it]= u[*it];
  return r;
}

new_table<C,T,V> mmx::append	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 836 of file new_table.hpp.

References busy(), CF2(), entries(), I(), and Table.

                                        {
  Table r (I (u), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    r[*it]= t[*it];
  for (iterator<T> it= entries (u); busy (it); ++it)
    r[*it]= u[*it];
  return r;
}

list<C> mmx::append	(	const list< C > &	l1,
		const list< C > &	l2
	)			[inline]

Return a list comprising all the elements of l1 and l2.

Definition at line 283 of file list.hpp.

References append(), car(), cdr(), cons(), copy(), and is_nil().

                                        {
  if (is_nil (l1)) return copy (l2);
  return cons (car (l1), append (cdr (l1), l2));
}

generic append	(	const generic &	g1,
		const generic &	g2
	)

Definition at line 29 of file generic_utils.cpp.

References append(), compound_to_vector(), and vector_to_compound().

                                              {
  return vector_to_compound (append (compound_to_vector (g1),
                                     compound_to_vector (g2)));
}

cache<C,T> mmx::append	(	const cache< C, T > &	t,
		const cache< C, T > &	u
	)			[inline]

Definition at line 78 of file cache.hpp.

References Cache.

Referenced by access(), append(), cons(), detach(), GLUE_10(), GLUE_16(), GLUE_9(), insert(), append_op::op(), operator*(), append_op::set_op(), and vector_append().

                                                          {
  return Cache (append (*t, *u)); }

syntactic mmx::apply

(

const vector< syntactic > &

v

)

Definition at line 29 of file syntactic.cpp.

References as_string(), as_syntactic(), N(), pow(), s, vector_to_compound(), and VERIFY.

                                   {
  VERIFY (N(v) != 0, "non-empty vector expected");
  if (is<literal> (*v[0])) {
    string s= as_string (as<literal> (*v[0]));
    if (N(s) == 1) {
      if (s[0] == '-' && N(v) == 2) return -v[1];
      if (s[0] == '+' && N(v) == 3) return v[1] + v[2];
      if (s[0] == '-' && N(v) == 3) return v[1] - v[2];
      if (s[0] == '*' && N(v) == 3) return v[1] * v[2];
      if (s[0] == '/' && N(v) == 3) return v[1] / v[2];
      if (s[0] == '^' && N(v) == 3) return pow (v[1], v[2]);
    }
  }
  return as_syntactic (vector_to_compound (*((vector<generic>*) (void*) &v)));
}

generic mmx::apply	(	const routine &	fun,
		const vector< dynamic > &	args
	)

Definition at line 178 of file dynamic.cpp.

References N().

                                                        {
  vector<generic> a= fill<generic> (N (args));
  for (nat i= 0; i<N(a); i++)
    a[i]= args[i]->val;
  generic r= fun->apply (a);
  return r;
}

syntactic mmx::apply	(	const generic &	f,
		const vector< syntactic > &	a
	)			[inline]

Definition at line 209 of file syntactic.hpp.

References apply(), and as_syntactic().

                                                                      {
  return apply (as_syntactic (f), a); }

syntactic mmx::apply	(	const generic &	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3,
		const syntactic &	a4,
		const syntactic &	a5,
		const syntactic &	a6
	)			[inline]

Definition at line 204 of file syntactic.hpp.

References apply(), and as_syntactic().

                                                                  {
  return apply (as_syntactic (f), a1, a2, a3, a4, a5, a6); }

syntactic mmx::apply	(	const generic &	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3,
		const syntactic &	a4,
		const syntactic &	a5
	)			[inline]

Definition at line 199 of file syntactic.hpp.

References apply(), and as_syntactic().

                                             {
  return apply (as_syntactic (f), a1, a2, a3, a4, a5); }

syntactic mmx::apply	(	const generic &	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3,
		const syntactic &	a4
	)			[inline]

Definition at line 195 of file syntactic.hpp.

References apply(), and as_syntactic().

                                                                  {
  return apply (as_syntactic (f), a1, a2, a3, a4); }

syntactic mmx::apply	(	const generic &	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3
	)			[inline]

Definition at line 192 of file syntactic.hpp.

References apply(), and as_syntactic().

                                                                  {
  return apply (as_syntactic (f), a1, a2, a3); }

syntactic mmx::apply	(	const generic &	f,
		const syntactic &	a1,
		const syntactic &	a2
	)			[inline]

Definition at line 189 of file syntactic.hpp.

References apply(), and as_syntactic().

                                             {
  return apply (as_syntactic (f), a1, a2); }

syntactic mmx::apply	(	const generic &	f,
		const syntactic &	a1
	)			[inline]

Definition at line 187 of file syntactic.hpp.

References apply(), and as_syntactic().

                                                               {
  return apply (as_syntactic (f), a1); }

syntactic mmx::apply

(

const generic &

f

)

[inline]

Definition at line 185 of file syntactic.hpp.

References apply(), and as_syntactic().

                                          {
  return apply (as_syntactic (f)); }

syntactic mmx::apply	(	const char *	f,
		const vector< syntactic > &	a
	)			[inline]

Definition at line 182 of file syntactic.hpp.

References apply().

                                                                   {
  return apply (syntactic (f), a); }

syntactic mmx::apply	(	const char *	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3,
		const syntactic &	a4,
		const syntactic &	a5,
		const syntactic &	a6
	)			[inline]

Definition at line 177 of file syntactic.hpp.

References apply().

                                                                  {
  return apply (syntactic (f), a1, a2, a3, a4, a5, a6); }

syntactic mmx::apply	(	const char *	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3,
		const syntactic &	a4,
		const syntactic &	a5
	)			[inline]

Definition at line 172 of file syntactic.hpp.

References apply().

                                             {
  return apply (syntactic (f), a1, a2, a3, a4, a5); }

syntactic mmx::apply	(	const char *	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3,
		const syntactic &	a4
	)			[inline]

Definition at line 168 of file syntactic.hpp.

References apply().

                                                                  {
  return apply (syntactic (f), a1, a2, a3, a4); }

syntactic mmx::apply	(	const char *	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3
	)			[inline]

Definition at line 165 of file syntactic.hpp.

References apply().

                                                                  {
  return apply (syntactic (f), a1, a2, a3); }

syntactic mmx::apply	(	const char *	f,
		const syntactic &	a1,
		const syntactic &	a2
	)			[inline]

Definition at line 162 of file syntactic.hpp.

References apply().

                                             {
  return apply (syntactic (f), a1, a2); }

syntactic mmx::apply	(	const char *	f,
		const syntactic &	a1
	)			[inline]

Definition at line 160 of file syntactic.hpp.

References apply().

                                                            {
  return apply (syntactic (f), a1); }

syntactic mmx::apply

(

const char *

f

)

[inline]

Definition at line 158 of file syntactic.hpp.

References apply().

                                       {
  return apply (syntactic (f)); }

syntactic apply	(	const syntactic &	f,
		const vector< syntactic > &	a
	)

Definition at line 69 of file syntactic.cpp.

References apply(), and cons().

                                                                 {
  return apply (cons (f, a)); }

syntactic apply	(	const syntactic &	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3,
		const syntactic &	a4,
		const syntactic &	a5,
		const syntactic &	a6
	)

Definition at line 64 of file syntactic.cpp.

References apply(), and vec().

                                                           {
  return apply (vec (f, a1, a2, a3, a4, a5, a6)); }

syntactic apply	(	const syntactic &	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3,
		const syntactic &	a4,
		const syntactic &	a5
	)

Definition at line 59 of file syntactic.cpp.

References apply(), and vec().

                                      {
  return apply (vec (f, a1, a2, a3, a4, a5)); }

syntactic apply	(	const syntactic &	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3,
		const syntactic &	a4
	)

Definition at line 55 of file syntactic.cpp.

References apply(), and vec().

                                                           {
  return apply (vec (f, a1, a2, a3, a4)); }

syntactic apply	(	const syntactic &	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3
	)

Definition at line 52 of file syntactic.cpp.

References apply(), and vec().

                                                           {
  return apply (vec (f, a1, a2, a3)); }

syntactic apply	(	const syntactic &	f,
		const syntactic &	a1,
		const syntactic &	a2
	)

Definition at line 49 of file syntactic.cpp.

References apply(), and vec().

                                      {
  return apply (vec (f, a1, a2)); }

syntactic apply	(	const syntactic &	f,
		const syntactic &	a1
	)

Definition at line 47 of file syntactic.cpp.

References apply(), and vec().

                                                          {
  return apply (vec (f, a1)); }

syntactic apply

(

const syntactic &

f

)

Definition at line 45 of file syntactic.cpp.

References apply(), and vec().

                                     {
  return apply (vec (f)); }

generic apply	(	const generic &	f,
		const vector< generic > &	x
	)

Definition at line 274 of file generic.cpp.

References current_ev.

                                                              {
  return current_ev->apply (g, args); }

generic apply	(	const generic &	f,
		const generic &	x,
		const generic &	y,
		const generic &	z
	)

Definition at line 271 of file generic.cpp.

References current_ev, and vec().

                                                   {
  return current_ev->apply (g, vec (x, y, z)); }

generic apply	(	const generic &	f,
		const generic &	x,
		const generic &	y
	)

Definition at line 269 of file generic.cpp.

References current_ev.

                                                                     {
  return current_ev->apply (g, x, y); }

generic apply	(	const generic &	f,
		const generic &	x
	)

Definition at line 267 of file generic.cpp.

References current_ev.

Referenced by generic_concrete_rep< C >::acc_apply(), composed_routine_rep::apply(), identity_routine_rep::apply(), apply(), binary_routine_rep< void, S1, S2 >::apply(), binary_routine_rep< D, S1, S2 >::apply(), unary_routine_rep< void, S1 >::apply(), unary_routine_rep< D, S1 >::apply(), nullary_routine_rep< void >::apply(), flatten(), object_flatten(), included_op::op(), sign_op::op(), gtreq_op::op(), gtr_op::op(), lesseq_op::op(), less_op::op(), unequal_op::op(), equal_op::op(), exact_neq_op::op(), exact_eq_op::op(), hard_neq_op::op(), hard_eq_op::op(), in_place_op< Op >::op(), and rebuild().

                                                   {
  return current_ev->apply (g, x); }

syntactic arg

(

const syntactic &

g1

)

Definition at line 453 of file syntactic.cpp.

References GEN_ARG, and syn().

{ return syn (GEN_ARG, g1); }

generic arg

(

const generic &

x1

)

Definition at line 732 of file generic.cpp.

References current_ev, and GEN_ARG.

Referenced by arg_op::op(), arg_op::Real_type(), arg_op::set_op(), and vector_map_n().

                                {
  return current_ev->apply (GEN_ARG, x1); }

observer mmx::argument_observer	(	dynamic_rep *	arg,
		const updater &	u
	)

Definition at line 152 of file dynamic.cpp.

Referenced by dynamic::dynamic().

                                                       {
  return observer (new argument_observer_rep (arg, u));
}

vector< syntactic > arguments

(

const syntactic &

g

)

Definition at line 93 of file syntactic.cpp.

References cdr(), and components().

Referenced by flatten().

                               {
  return cdr (components (g));
}

T as

(

const F &

x

)

[inline]

Definition at line 704 of file type_props.hpp.

Referenced by all_type_names(), default_routine(), generic_object_rep::expression(), object_get_alias(), object_set_alias(), specialize_alias(), and vector_size().

                {
  return as_helper<T,F>::cv (x);
}

bool mmx::as_bool

(

const generic &

g

)

[inline]

Definition at line 293 of file generic.cpp.

Referenced by operator<(), operator<=(), operator==(), operator>(), and operator>=().

                                       {
  return is<bool> (g) && as<bool> (g); }

char* mmx::as_charp

(

const string &

obj->lex_string

)

Definition at line 74 of file string.cpp.

References mmx_malloc(), and N().

                           {
  nat i, n= N(s);
  char* r= (char*) mmx_malloc (n+1);
  for (i=0; i<n; i++) r[i]= s[i];
  r[i]= '\0';
  return r;
}

char* mmx::as_charp

(

const string &

s

)

Return a pointer to a copy of s. The allocated memory must be freed with free_charp.

Referenced by completion_generator(), dl_link(), exec(), file_exists(), file_is_script(), follow_link(), get_attributes(), get_env(), input_file_port(), input_output_file_port(), load_directory(), output_file_port(), read_line(), set_env(), shell_load_history(), shell_save_history(), shell_terminal_input(), socket_client_port(), system(), var_mkdir(), and var_rm().

string as_cpp

(

const generic &

g

)

Definition at line 1286 of file cpp_printer.cpp.

References inside(), N(), and cpp_printer::pp().

Referenced by flatten_as_cpp().

                          {
  cpp_printer pp;
  pp.pp (g);
  while (N (pp.out) > 0 && pp.out [N (pp.out) - 1] == '\n')
    inside (pp.out) -> resize (N (pp.out) - 1);
  return pp.out;
}

document mmx::as_document

(

const generic &

g

)

[inline]

Definition at line 47 of file document.hpp.

Referenced by as_documents(), binary_helper< document >::assemble(), make_document(), make_math(), make_row(), make_texmacs(), make_text(), and binary_helper< document >::read().

{ return document (g); }

vector<document> mmx::as_documents

(

const vector< generic > &

v

)

Definition at line 38 of file document.cpp.

References as_document(), and N().

Referenced by make_document().

                                        {
  vector<document> r= fill<document> (N(v));
  for (nat i=0; i<N(v); i++) r[i]= as_document (v[i]);
  return r;
}

double mmx::as_double

(

const string &

obj->lex_string

)

Definition at line 180 of file string.cpp.

References max(), and N().

                            {
  double x;
  char buffer[100];
  strncpy (buffer, s->a, 99);
  buffer[max(N(s),(nat) 99)]= '\0';
  sscanf (buffer, "%lf", &x);
  return x;
}

double mmx::as_double

(

const string &

s

)

double mmx::as_double

(

const double &

x

)

[inline]

Definition at line 123 of file double.hpp.

Referenced by mmc_unliteral().

{ return x; }

exception as_exception

(

const generic &

x

)

[final]

Make an exception from x.

Definition at line 39 of file basix.cpp.

                                {
  return exception (x);
}

generic mmx::as_generic

(

const syntactic &

g

)

[inline]

Definition at line 45 of file syntactic.hpp.

{ return *g; }

generic mmx::as_generic

(

const C &

c

)

[inline]

Definition at line 568 of file generic.hpp.

References construct().

                        {
  return construct (new generic_concrete_rep<C> (c));
}

generic as_generic	(	const generic &	obj,
		const generic &	tp
	)

Definition at line 216 of file generic_object.cpp.

References ASSERT, get_user_type(), and type().

                                                 {
  ASSERT (type (g) == get_user_type (tp), "type mismatch");
  return ((generic_object_rep*) inspect (g)) -> rep;
};

generic as_generic	(	const generic &	obj,
		nat	tp_id
	)

Definition at line 210 of file generic_object.cpp.

References ASSERT, and type().

                                         {
  ASSERT (type (g) == tp_id, "type mismatch");
  return ((generic_object_rep*) inspect (g)) -> rep;
};

generic mmx::as_generic

(

const document &

g

)

[inline]

Definition at line 46 of file document.hpp.

Referenced by as_generics(), as_lisp(), as_math(), flatten(), flatten_as_cpp(), flatten_as_lisp(), flatten_as_math(), flatten_as_mmx(), flatten_as_texmacs_scheme(), flatten_as_tm(), GLUE_3(), different< T1, T2 >::lazy_value(), make_document(), make_math(), make_text(), object_flatten(), object_generalize_alias(), object_get_alias(), object_set_alias(), product_less_op::op(), sum_less_op::op(), trig_op::op(), operator<(), operator<=(), operator>(), operator>=(), output_as_mmx(), texmacs_dynamic_event(), and var_flatten().

{ return *g; }

vector<generic> mmx::as_generics

(

const vector< document > &

v

)

Definition at line 31 of file document.cpp.

References as_generic(), and N().

Referenced by make_row(), and make_texmacs().

                                        {
  vector<generic> r= fill<generic> (N(v));
  for (nat i=0; i<N(v); i++) r[i]= as_generic (v[i]);
  return r;
}

nat mmx::as_hash

(

const C *

p

)

[inline]

Definition at line 182 of file basix.hpp.

Referenced by exact_hash(), hard_hash(), and hash().

                                                     {
  return ((nat) ((uintptr_t) ((void*) p))) >> 3; }

int mmx::as_int

(

const string &

obj->lex_string

)

Definition at line 137 of file string.cpp.

References N().

                         {
  int i=0, n=N(s), val=0;
  if (n==0) return 0;
  if (s[0]=='-') i++;
  while (i<n) {
    if (s[i]<'0') break;
    if (s[i]>'9') break;
    val *= 10;
    val += (int) (s[i]-'0');
    i++;
  }
  if (s[0]=='-') val=-val;
  return val;
}

int mmx::as_int

(

const string &

s

)

int mmx::as_int

(

const double_int &

x

)

[inline]

Definition at line 36 of file int.hpp.

                                        {
  return (int) x; }

int mmx::as_int

(

const double &

x

)

[inline]

Definition at line 122 of file double.hpp.

Referenced by GLUE_3(), mmc_unliteral(), and parse_nat().

{ return (int) x; }

static void mmx::as_lisp	(	string &	out,
		const generic &	g,
		bool	quote_flag,
		bool	fun_flag
	)			[static]

Definition at line 19 of file lisp_printer.cpp.

References as_generic(), as_lisp(), flatten(), literal_to_string(), N(), n, and quote().

                                                                        {
  if (is<literal> (g)) {
    if (quote_flag && !fun_flag) out << quote (literal_to_string (g));
    else out << literal_to_string (g);
  }
  else if (is<compound> (g)) {
    nat i, n= N (g);
    out << "(";
    if (n>0) as_lisp (out, g[0], quote_flag, true);
    for (i=1; i<n; i++) {
      out << " ";
      as_lisp (out, g[i], quote_flag, false);
    }
    out << ")";
  }
  else {
    generic f= as_generic (flatten (g));
    as_lisp (out, f, quote_flag, fun_flag);
  }
}

string as_lisp	(	const generic &	g,
		bool	quote_flag = true
	)

Definition at line 41 of file lisp_printer.cpp.

Referenced by as_lisp(), flatten_as_lisp(), and GLUE_5().

                                            {
  string out;
  as_lisp (out, g, quote_flag, false);
  return out;
}

double as_literal_double

(

const literal &

l

)

Definition at line 72 of file literal.cpp.

                                     {
  return string_as_numeric<double> (*l);
}

int as_literal_int

(

const literal &

l

)

Definition at line 67 of file literal.cpp.

                                  {
  return string_as_numeric<int> (*l);
}

string as_literal_string

(

const literal &

l

)

Definition at line 62 of file literal.cpp.

References unquote().

                                     {
  return unquote (*l);
}

static void mmx::as_math	(	string &	out,
		const generic &	g
	)			[static]

Definition at line 135 of file math_printer.cpp.

References as_generic(), as_math(), exact_eq(), flatten(), GEN_ROW, GEN_SQTUPLE, literal_to_string(), math_symbol_table(), n, N(), and s.

                                        {
  static table<string, string, exact_eq_table> t (math_symbol_table ());
  if (is<literal> (g)) {
    string tmp;
    string s (literal_to_string (g));
    if (t->get (s, tmp))
      out << tmp;
    else if (N(s) > 0 && s[0]>='0' && s[0] <= '9')
      out << "\"" << s << "\"";
    else
      out << s;
  }
  else if (is<compound> (g)) {
    nat i, n= N (g);
    out << "(";
    if (n>0) {
      if (exact_eq (g[0], GEN_SQTUPLE) && n>1 &&
          is<compound> (g[1]) && exact_eq (g[1][0], GEN_ROW))
        out << "matrix";
      else as_math (out, g[0]);
    }
    for (i=1; i<n; i++) {
      out << " ";
      as_math (out, g[i]);
    }
    out << ")";
  }
  else {
    generic f= as_generic (flatten (g));
    as_math (out, f);
  }
}

string as_math

(

const generic &

g

)

Definition at line 169 of file math_printer.cpp.

Referenced by as_math(), and flatten_as_math().

                           {
  string out;
  as_math (out, g);
  return out;
}

string as_mmx

(

const generic &

g

)

Definition at line 963 of file mmx_printer.cpp.

References print_mmx(), and serialize().

Referenced by flatten_as_mmx(), and output_as_mmx().

                          {
  return serialize (print_mmx (g));
}

generic as_object	(	const generic &	v,
		const generic &	tp
	)

Definition at line 205 of file generic_object.cpp.

References get_user_type().

                                                {
  return new generic_object_rep (g, get_user_type (tp));
};

generic as_object	(	const generic &	v,
		nat	tp_id
	)

Definition at line 200 of file generic_object.cpp.

Referenced by generic_object_rep::duplicate_me(), generic_object_rep::expression(), object_alias(), and object_specialize_alias().

                                        {
  return new generic_object_rep (g, tp_id);
};

static string mmx::as_snippet

(

const generic &

g

)

[static]

Definition at line 578 of file mmx_texmacs.cpp.

References as_texmacs(), print_mmx(), replace_lf(), and texmacs_to_scheme().

Referenced by flatten_as_tm().

                              {
  string  r= "";
  generic h= print_mmx (g);
  generic m= h;//add_modes (h, 0, 1);
  generic t= as_texmacs (m);
  generic l= replace_lf (t);
  texmacs_to_scheme (r, l);
  return r;
}

string as_string

(

const syntactic &

g

)

Definition at line 26 of file syntactic.cpp.

References literal_to_string().

{ return literal_to_string (*g); }

string as_string

(

long double

x

)

Definition at line 173 of file string.cpp.

                          {
  char buffer[64];
  sprintf (buffer, "%Lf", x);
  return string (buffer);
}

string as_string

(

double

x

)

Definition at line 163 of file string.cpp.

References as_string_hook.

                     {
  if (as_string_hook != NULL)
    return as_string_hook (x);
  if (x == 0.0) return "0";
  char buffer[32];
  sprintf (buffer, "%1.12g", x);
  return string (buffer);
}

string as_string

(

float

x

)

Definition at line 153 of file string.cpp.

                    {
  if (x == 0.0) return "0";
  char buffer[32];
  sprintf (buffer, "%1.3e", x);
  return string (buffer);
}

string as_string

(

long long unsigned int

i

)

Definition at line 130 of file string.cpp.

                                     {
  char buffer[100];
  sprintf (buffer, "%llu", i);
  return string (buffer);
}

string as_string

(

long long int

i

)

Definition at line 123 of file string.cpp.

                            {
  char buffer[100];
  sprintf (buffer, "%lld", i);
  return string (buffer);
}

string as_string

(

long unsigned int

i

)

Definition at line 116 of file string.cpp.

                                {
  char buffer[100];
  sprintf (buffer, "%lu", i);
  return string (buffer);
}

string as_string

(

long int

i

)

Definition at line 109 of file string.cpp.

                       {
  char buffer[100];
  sprintf (buffer, "%ld", i);
  return string (buffer);
}

string mmx::as_string

(

unsigned char

i

)

[inline]

Definition at line 128 of file string.hpp.

References as_string().

                                          {
  return as_string ((unsigned int) i); }

string mmx::as_string

(

signed char

i

)

[inline]

Definition at line 126 of file string.hpp.

References as_string().

                                        {
  return as_string ((int) i); }

string mmx::as_string

(

short unsigned int

i

)

[inline]

Definition at line 124 of file string.hpp.

References as_string().

                                               {
  return as_string ((unsigned int) i); }

string mmx::as_string

(

short int

i

)

[inline]

Definition at line 122 of file string.hpp.

References as_string().

                                      {
  return as_string ((int) i); }

string as_string

(

void *

ptr

)

Definition at line 88 of file string.cpp.

                      {
  char buffer[100];
  sprintf (buffer, "0x%lx", (unsigned long) ptr);
  return string (buffer);
}

string as_string

(

unsigned int

i

)

Definition at line 102 of file string.cpp.

                           {
  char buffer[100];
  sprintf (buffer, "%u", i);
  return string (buffer);
}

string as_string

(

int

i

)

Definition at line 95 of file string.cpp.

                  {
  char buffer[100];
  sprintf (buffer, "%d", i);
  return string (buffer);
}

string as_string

(

const exception &

e

)

Definition at line 110 of file mmc_glue.cpp.

References source_exception().

Referenced by apply(), composed_routine_rep::apply(), as_string(), composite_port(), flatten(), generic_as_string(), get_pid(), GLUE_3(), GLUE_4(), GLUE_5(), hard_eq(), hard_hash(), hard_neq(), literal_to_string(), make_literal(), make_texmacs(), mmc_unliteral(), product_less_op::op(), sum_less_op::op(), serialize(), shell_terminal_input(), shell_texmacs_input(), signed_decompose(), socket_client_port(), source_begin(), source_end(), source_error(), source_file(), unique_identifier(), and binary_helper< literal >::write().

                               {
  return source_exception (e);
}

string mmx::as_string_hexa

(

ulong

i

)

[inline]

Definition at line 138 of file string.hpp.

Referenced by GLUE_4().

                                       {
  static char buf[sizeof(ulong)*2+1];
  snprintf (buf, sizeof(buf), "%lx", i);
  return buf; }

syntactic mmx::as_syntactic

(

const generic &

g

)

[inline]

Definition at line 46 of file syntactic.hpp.

Referenced by apply(), binary_helper< syntactic >::assemble(), flatten(), flatten_type(), GLUE_1(), trig_op::op(), binary_helper< syntactic >::read(), set_accuracy(), set_catalan(), set_euler(), set_fuzz(), set_imaginary(), set_infinity(), set_largest(), set_log2(), set_maximal(), set_minimal(), set_nan(), set_pi(), set_smallest(), syn(), and WRAP_INDIRECT_IMPL().

{ return syntactic (g); }

generic mmx::as_texmacs

(

const generic &

g

)

Definition at line 243 of file mmx_texmacs.cpp.

References cdr(), compound_to_vector(), concat_append(), contains(), ERROR, gen(), GEN_MINUS, GEN_PLUS, is_alpha, is_func(), literal_to_string(), N(), s, starts(), texmacs_symbol_table(), unbracket(), and vec().

Referenced by as_snippet(), as_texmacs_scheme(), and as_texmacs_snippet().

                              {
  if (is<literal> (g)) {
    if (g == "$lf") return gen ("$lf");
    if (g == "$cr") return gen ("$cr");
    if (g == "$spc") return gen (" ");
    static table<generic,generic> t= texmacs_symbol_table ();
    generic h= g;
    if (contains (t, h)) h= t[h];
    if (!is<literal> (h)) return h;
    string s= literal_to_string (h);
    if (starts (s, "tm$"))
      return generic ("<" * s (3, N(s)) * ">");
    string r;
    for (nat i=0; i<N(s); i++)
      if (s[i] == '<') r << "<less>";
      else if (s[i] == '>') r << "<gtr>";
      else r << s[i];
    return r;
  }
  else if (is_func (g, "$concat")) {
    vector<generic> v;
    for (nat i=1; i<N(g); i++)
      concat_append (v, as_texmacs (g[i]));
    if (N(v) == 0) return generic ("");
    else if (N(v) == 1) return v[0];
    else return gen ("$concat", v);
  }
  else if (is_func (g, "$keyword", 1))
    return as_texmacs (gen ("$strong", g[1]));
  else if (is_func (g, "$keyword", 2))
    return as_texmacs (gen ("$concat", gen ("$strong", g[1]), "$spc", g[2]));
  else if (is_func (g, "$bracket", 3))
    return as_texmacs (gen ("$around*", g[1], g[2], g[3]));
  else if (is_func (g, "$prefix", 2)) {
    if (g[1] == "'" || g[1] == "`")
      return as_texmacs (gen ("$concat", gen ("$lprime", g[1]), g[2]));
    else return as_texmacs (gen ("$concat", g[1], g[2]));
  }
  else if (is_func (g, "$postfix", 2)) {
    if (g[2] == "'" || g[2] == "`")
      return as_texmacs (gen ("$concat", g[1], gen ("$lprime", g[2])));
    else return as_texmacs (gen ("$concat", g[1], g[2]));
  }
  else if (is_func (g, "$infix", 3)) {
    if (g[2] == "/")
      return as_texmacs (gen ("$frac", unbracket (g[1]), unbracket (g[3])));
    else if (g[2] == "^")
      return as_texmacs (gen ("$concat",
                              g[1], gen ("$rsup", unbracket (g[3]))));
    else if (g[2] == "|" || g[2] == "||")
      return as_texmacs (gen ("$concat", g[1], gen ("$mid", g[2]), g[3]));
    else {
      generic op= as_texmacs (g[2]);
      if (is_alpha (op))
        op= gen ("$concat", "$spc", gen ("$strong", op), "$spc");
      return as_texmacs (gen ("$concat", g[1], g[2], g[3]));
    }
  }
  else if (is_func (g, "$bigop") && N(g) >= 3) {
    vector<generic> v;
    if (g[1] == GEN_PLUS && is_func (g[2], GEN_MINUS, 1))
      v << generic ("-") << g[2][1];
    else v << g[2];
    for (nat i=3; i<N(g); i++) {
      if (g[1] == GEN_PLUS && is_func (g[i], GEN_MINUS, 1))
        v << generic ("-") << g[i][1];
      else
        v << g[1] << g[i];
    }
    return as_texmacs (gen ("$concat", v));
  }
  else if (is_func (g, "$operate", 2)) {
    if (is_func (g[2], "$bracket", 3) && g[2][1] == "[")
      return as_texmacs (gen ("$concat",
                              g[1], gen ("$rsub", unbracket (g[2]))));
    else return as_texmacs (gen ("$concat", g[1], g[2]));
  }
  else if (is_func (g, "$hlist")) {
    if (N(g) == 1) return generic ("");
    vector<generic> v= vec (g[1]);
    for (nat i=2; i<N(g); i++) v << generic (",") << g[i];
    return as_texmacs (gen ("$concat", v));
  }
  else if (is_func (g, "$vlist")) {
    vector<generic> v;
    for (nat i=1; i<N(g); i++)
      if (is_func (g[i], "$hlist"))
        v << gen ("$row", cdr (compound_to_vector (g[i])));
    if (N(v) == 0) return generic ("");
    return as_texmacs (gen ("$tabular*", gen ("$table", v)));
  }
  else if (is_func (g, "$indent")) {
    vector<generic> v;
    for (nat i=1; i<N(g); i++)
      concat_append (v, as_texmacs (g[i]));
    return gen ("$concat", gen ("$indent", gen ("$concat", v)), gen ("$lf"));
  }
  else if (is_func (g, "$text", 1))
    return gen ("$text", as_texmacs (g[1]));
  else if (is_func (g, "$math", 1))
    return gen ("$math", as_texmacs (g[1]));
  else if (is_func (g, "$dynamic"))
    return gen ("$locus", gen ("$id", as_texmacs (g[1])), as_texmacs (g[2]));
  else if (is<compound> (g)) {
    vector<generic> v;
    for (nat i=1; i<N(g); i++)
      v << as_texmacs (g[i]);
    return gen (g[0], v);
  }
  else ERROR ("not implemented");
}

string as_texmacs_scheme

(

const generic &

g

)

Definition at line 477 of file mmx_texmacs.cpp.

References add_modes(), as_texmacs(), print_mmx(), replace_lf(), and texmacs_to_scheme().

Referenced by flatten_as_texmacs_scheme().

                                     {
  string  r= "(document ";
  generic h= print_mmx (g);
  generic m= add_modes (h, 0, 1);
  generic t= as_texmacs (m);
  generic l= replace_lf (t);
  texmacs_to_scheme (r, l);
  r << ")";
  return r;
}

string as_texmacs_snippet

(

const generic &

g

)

Definition at line 466 of file mmx_texmacs.cpp.

References add_modes(), as_texmacs(), print_mmx(), replace_lf(), and texmacs_to_scheme().

Referenced by texmacs_dynamic_event().

                                      {
  string  r= "";
  generic h= print_mmx (g);
  generic m= add_modes (h, 0, 1);
  generic t= as_texmacs (m);
  generic l= replace_lf (t);
  texmacs_to_scheme (r, l);
  return r;
}

vector<T> mmx::as_vector

(

const list< T > &

l

)

[inline]

Definition at line 21 of file glue_list_map.cpp.

References car(), cdr(), is_nil(), and N().

                             {
  vector<T> a (fill<T> (N (l)));
  list<T> it= l;
  for (nat i= 0; !is_nil (it); it= cdr (it), i++)
    a[i]= car (it);
  return a;
}

vector<C> mmx::as_vector

(

const tuple< C > &

t

)

[inline]

Definition at line 67 of file tuple.hpp.

References N(), and n.

                           {
  nat i, n= N(t);
  vector<C> a= fill<C> (n);
  for (i=0; i<n; i++)
    a[i]= t[i];
  return a;
}

vector<C> mmx::as_vector

(

const row_tuple< C > &

t

)

[inline]

Definition at line 69 of file row_tuple.hpp.

References N(), and n.

Referenced by inspector< compound >::access(), compound_to_vector(), solve_vector_lde_op::diff_op(), flatten(), GLUE_1(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_3(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), hard_eq(), hard_hash(), hard_neq(), iterate(), inspector< compound >::length(), and map().

                               {
  nat i, n= N(t);
  vector<C> a= fill<C> (n);
  for (i=0; i<n; i++)
    a[i]= t[i];
  return a;
}

vector<C,V> mmx::asin

(

const vector< C, V > &

v

)

[inline]

Definition at line 1184 of file vector.hpp.

{ return unary_map<asin_op> (v); }

table<C,T,V> mmx::asin

(

const table< C, T, V > &

t

)

[inline]

Definition at line 705 of file table.hpp.

{ return unary_map<asin_op> (t); }

syntactic asin

(

const syntactic &

g

)

Definition at line 434 of file syntactic.cpp.

References GEN_ARCSIN, and syn().

{ return syn (GEN_ARCSIN, g); }

new_table<C,T,V> mmx::asin

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 776 of file new_table.hpp.

{ return unary_map<asin_op> (t); }

generic asin

(

const generic &

x1

)

Definition at line 469 of file generic.cpp.

References ACC_ASIN, ACC_UNARY, current_ev, and GEN_ARCSIN.

                         {
  ACC_UNARY (ACC_ASIN, x1);
  return current_ev->apply (GEN_ARCSIN, x1);
}

double asin

(

const double &

x

)

[inline]

Definition at line 56 of file double.hpp.

Referenced by asin_op::op(), and asin_op::set_op().

{ return std::asin (x); }

syntactic asin_init	(	const syntactic &	x,
		const syntactic &	c
	)

Definition at line 495 of file syntactic.cpp.

References syn().

                                                             {
  return syn ("asin_init", x, c); }

generic asin_init	(	const generic &	x,
		const generic &	c
	)

Definition at line 808 of file generic.cpp.

References current_ev.

Referenced by asin_op::op_init().

                                                         {
  return current_ev->apply ("asin_init", x1, x2); }

syntactic asinh

(

const syntactic &

g

)

Definition at line 440 of file syntactic.cpp.

References GEN_ARGSH, and syn().

{ return syn (GEN_ARGSH, g); }

generic asinh

(

const generic &

x1

)

Definition at line 505 of file generic.cpp.

References ACC_ASINH, ACC_UNARY, log(), sqrt(), and square().

                          {
  ACC_UNARY (ACC_ASINH, x1);
  return log (x1 + sqrt (square (x1) + 1));
}

double mmx::asinh

(

const double &

x

)

[inline]

Definition at line 71 of file double.hpp.

{ return std::isfinite (x); }

C mmx::asinh

(

const C &

x

)

[inline]

Definition at line 597 of file defaults.hpp.

References log(), promote(), sqrt(), and square().

Referenced by asinh_op::op(), and asinh_op::set_op().

                                                 {
  return log (x + sqrt (square (x) + promote (1, x))); }

void assign	(	const dynamic &	d,
		const generic &	val
	)

Definition at line 33 of file dynamic.cpp.

References inside(), and N().

Referenced by GLUE_4(), and updater_rep::update().

                                              {
  if (val == d->val) return;
  inside (d) -> val= val;
  for (nat i=0; i<N(d->obs); i++)
    d->obs[i]->modify ();
}

vector<C,V> mmx::atan

(

const vector< C, V > &

v

)

[inline]

Definition at line 1185 of file vector.hpp.

{ return unary_map<atan_op> (v); }

table<C,T,V> mmx::atan

(

const table< C, T, V > &

t

)

[inline]

Definition at line 706 of file table.hpp.

{ return unary_map<atan_op> (t); }

syntactic atan

(

const syntactic &

g

)

Definition at line 435 of file syntactic.cpp.

References GEN_ARCTAN, and syn().

{ return syn (GEN_ARCTAN, g); }

new_table<C,T,V> mmx::atan

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 777 of file new_table.hpp.

{ return unary_map<atan_op> (t); }

generic atan

(

const generic &

x1

)

Definition at line 475 of file generic.cpp.

References ACC_ATAN, ACC_UNARY, current_ev, and GEN_ARCTAN.

                         {
  ACC_UNARY (ACC_ATAN, x1);
  return current_ev->apply (GEN_ARCTAN, x1);
}

double atan

(

const double &

x

)

[inline]

Definition at line 57 of file double.hpp.

Referenced by atan2(), atan_op::op(), atan_op::set_op(), and set_pi().

{ return std::atan (x); }

syntactic atan2	(	const syntactic &	g1,
		const syntactic &	g2
	)

Definition at line 447 of file syntactic.cpp.

References GEN_ARCTAN2, and syn().

                                                           {
  return syn (GEN_ARCTAN2, g1, g2); }

generic atan2	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 523 of file generic.cpp.

References abs(), ACC_ATAN2, ACC_BINARY, atan(), and sign().

                                           {
  ACC_BINARY (ACC_ATAN2, x, y);
  if (x > 0) return atan (y/x);
  else if (y == 0)
    return x == 0? generic (0): generic (-4) * atan (generic (1));
  else if (x == 0)
    return generic (2 * sign (y)) * atan (generic (1));
  else return sign (y) * (4 * atan (generic (1)) - atan (abs (y/x)));
}

double atan2	(	const double &	y,
		const double &	x
	)			[inline]

Definition at line 60 of file double.hpp.

References atan2().

                                                       {
  return std::atan2 (y, x); }

C mmx::atan2	(	const C &	y,
		const C &	x
	)			[inline]

Definition at line 577 of file defaults.hpp.

References abs(), atan(), promote(), and sign().

Referenced by atan2(), atan2_op::op(), and atan2_op::set_op().

                                                      {
  if (!(x <= promote (0, x)))
    return atan (y/x);
  else if (y == promote (0, x))
    return x == promote (0, x)?
           promote (0, x): promote (-4, x) * atan (promote (1, x));
  else if (x == promote (0, x))
    return promote (2 * sign (y), x) * atan (promote (1, x));
  else
    return promote (sign (y), x) *
           (promote (4, x) * atan (promote (1, x)) - atan (abs (y/x))); }

syntactic atan_init	(	const syntactic &	x,
		const syntactic &	c
	)

Definition at line 497 of file syntactic.cpp.

References syn().

                                                             {
  return syn ("atan_init", x, c); }

generic atan_init	(	const generic &	x,
		const generic &	c
	)

Definition at line 810 of file generic.cpp.

References current_ev.

Referenced by atan_op::op_init().

                                                         {
  return current_ev->apply ("atan_init", x1, x2); }

syntactic atanh

(

const syntactic &

g

)

Definition at line 441 of file syntactic.cpp.

References GEN_ARGTH, and syn().

{ return syn (GEN_ARGTH, g); }

generic atanh

(

const generic &

x1

)

Definition at line 511 of file generic.cpp.

References ACC_ATANH, ACC_UNARY, and log().

                          {
  ACC_UNARY (ACC_ATANH, x1);
  return log ((1 + x1) / (1 - x1)) / 2;
}

double mmx::atanh

(

const double &

x

)

[inline]

Definition at line 71 of file double.hpp.

{ return std::isfinite (x); }

C mmx::atanh

(

const C &

x

)

[inline]

Definition at line 599 of file defaults.hpp.

References log(), and promote().

Referenced by atanh_op::op(), and atanh_op::set_op().

                                                 {
  return log ((promote (1, x) + x) / (promote (1, x) - x)) / promote (2, x); }

void attach	(	const dynamic &	d,
		const observer &	o
	)

Definition at line 47 of file dynamic.cpp.

References inside().

Referenced by dynamic::dynamic(), and flatten().

                                             {
  inside (d) -> obs << o;
}

void mmx::attach_generic_binary_assembler

(

)

[inline]

Definition at line 269 of file port.hpp.

References attach_generic_binary_assembler().

                                   {
  attach_generic_binary_assembler (binary_helper<T>::full_type_name (),
                                   binary_assemble_generic_via<T>);
}

void attach_generic_binary_assembler	(	const generic &	tp,
		unary_generic	r
	)

Definition at line 72 of file generic.cpp.

References current_ev, gen(), and unary_routine().

Referenced by attach_generic_binary_assembler().

                                                                     {
  if (!is<string> (tp) || as<string> (tp) != "?")
    current_ev->set (gen ("assembler", tp),
                     as<generic> (unary_routine ("binary_assembler", r)));
}

void mmx::attach_generic_binary_reader

(

)

[inline]

Definition at line 284 of file port.hpp.

References attach_generic_binary_reader().

                                {
  attach_generic_binary_reader (binary_helper<T>::short_type_name (),
                                binary_read_generic<T>);
}

void attach_generic_binary_reader	(	const string &	s,
		unary_generic	r
	)

Definition at line 99 of file generic.cpp.

References binary_readers, and unary_routine().

Referenced by attach_generic_binary_reader().

                                                                {
  if (s != "?")
    binary_readers[s]= as<generic> (unary_routine ("binary_reader", r));
}

string mmx::backtrace

(

const generic &

g

)

Definition at line 354 of file source_track.cpp.

References has_trace(), source_exception(), trace_pull(), and trace_top().

Referenced by source_exception().

                             {
  if (has_trace (g))
    return backtrace (trace_pull (g)) * backtrace (trace_top (g));
  else return source_exception (as<exception> (g));
}

chain< C > balance_left

(

const chain< C > &

c

)

[inline]

Definition at line 260 of file chain.hpp.

References balance_right(), Chain, is_nil(), left(), middle(), N(), right(), and shift_left().

Referenced by balance_right(), cdr(), and operator*().

                              {
  // Ensure that #left(c) >= #right(c)
  switch (N(c)) {
  case 0:
  case 1:
    return c;
  case 2:
    if (is_nil (right (c))) return c;
    return Chain (Chain (middle (c)), middle (right (c)), Chain ());
  case 3:
    return c;
  default:
    if (N (left (c)) >= N (right (c))) return c;
    else {
      Chain aux= balance_right (right (c));
      return shift_left (Chain (left (c), middle (c), aux));
    }
  }
}

chain< C > balance_right

(

const chain< C > &

c

)

[inline]

Definition at line 281 of file chain.hpp.

References balance_left(), Chain, is_nil(), left(), middle(), N(), right(), and shift_right().

Referenced by balance_left(), cDr(), and operator*().

                               {
  // Ensure that #left(c) <= #right(c)
  switch (N(c)) {
  case 0:
  case 1:
    return c;
  case 2:
    if (is_nil (left (c))) return c;
    return Chain (Chain (), middle (left (c)), Chain (middle (c)));
  case 3:
    return c;
  default:
    if (N (left (c)) <= N (right (c))) return c;
    else {
      Chain aux= balance_left (left (c));
      return shift_right (Chain (aux, middle (c), right (c)));
    }
  }
}

void batch_mode_initialize

(

)

Definition at line 61 of file terminal_interface.cpp.

References batch_mode, and texmacs_mode.

                         {
  batch_mode = !isatty(STDIN_FILENO) && !texmacs_mode;
}

unary_return_type_helper< Op , C >::RET mmx::big

(

const vector< C, V > &

v

)

[inline]

Definition at line 871 of file vector.hpp.

References ASSERT, CF(), is_non_scalar(), N(), and seg().

                           {
  typedef implementation<vector_linear,V> Vec;
  ASSERT (is_non_scalar (v), "non scalar vector expected");
  return Vec::template vec_unary_big<Op> (seg (v), N(v), CF(v));
}

C mmx::big

(

const table< C, T, V > &

t

)

[inline]

Definition at line 563 of file table.hpp.

References busy(), C, done(), and entries().

                     {
  iterator<T> it= entries (t);
  if (done (it)) return Op::template neutral<C> ();
  C r= t[*it];
  for (++it; busy (it); ++it)
    Op::set_op (r, t[*it]);
  return r;
}

C mmx::big

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 634 of file new_table.hpp.

References busy(), C, done(), and entries().

                     {
  iterator<T> it= entries (t);
  if (done (it)) return Op::template neutral<C> ();
  C r= t[*it];
  for (++it; busy (it); ++it)
    Op::set_op (r, t[*it]);
  return r;
}

C mmx::big

(

const iterator< C > &

it

)

[inline]

Definition at line 445 of file iterator.hpp.

References busy(), C, CF(), done(), and get_sample().

                         {
  if (done (it)) {
    C r= get_sample (CF (it));
    Op::set_neutral (r);
    return r;
  }
  C r= *it;
  for (++it; busy (it); ++it)
    Op::set_op (r, *it);
  return r;
}

C mmx::big_add

(

const vector< C, V > &

v

)

[inline]

Definition at line 1212 of file vector.hpp.

{ return big<add_op> (v); }

C mmx::big_add

(

const table< C, T, V > &

t

)

[inline]

Definition at line 715 of file table.hpp.

{ return big<add_op> (t); }

C mmx::big_add

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 786 of file new_table.hpp.

{ return big<add_op> (t); }

C mmx::big_add

(

const iterator< C > &

it

)

[inline]

Definition at line 457 of file iterator.hpp.

{ return big<add_op> (it); }

C mmx::big_and

(

const vector< C, V > &

v

)

[inline]

Definition at line 1215 of file vector.hpp.

{ return big<and_op> (v); }

C mmx::big_and

(

const table< C, T, V > &

t

)

[inline]

Definition at line 718 of file table.hpp.

{ return big<and_op> (t); }

C mmx::big_and

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 789 of file new_table.hpp.

{ return big<and_op> (t); }

C mmx::big_and

(

const iterator< C > &

it

)

[inline]

Definition at line 460 of file iterator.hpp.

{ return big<and_op> (it); }

unary_return_type_helper< Op , C >::RET mmx::big_dicho

(

const vector< C, V > &

v

)

[inline]

Definition at line 878 of file vector.hpp.

References ASSERT, CF(), is_non_scalar(), N(), and seg().

                                 {
  typedef implementation<vector_linear,V> Vec;
  ASSERT (is_non_scalar (v), "non scalar vector expected");
  return Vec::template vec_unary_big_dicho<Op> (seg (v), N(v), CF(v));
}

C mmx::big_inf

(

const vector< C, V > &

v

)

[inline]

Definition at line 1218 of file vector.hpp.

{ return big<inf_op> (v); }

C mmx::big_inf

(

const table< C, T, V > &

t

)

[inline]

Definition at line 721 of file table.hpp.

{ return big<inf_op> (t); }

C mmx::big_inf

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 792 of file new_table.hpp.

{ return big<inf_op> (t); }

C mmx::big_max

(

const vector< C, V > &

v

)

[inline]

Definition at line 1217 of file vector.hpp.

{ return big<max_op> (v); }

C mmx::big_max

(

const table< C, T, V > &

t

)

[inline]

Definition at line 720 of file table.hpp.

{ return big<max_op> (t); }

C mmx::big_max

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 791 of file new_table.hpp.

{ return big<max_op> (t); }

C mmx::big_max

(

const iterator< C > &

it

)

[inline]

Definition at line 462 of file iterator.hpp.

{ return big<max_op> (it); }

C mmx::big_min

(

const vector< C, V > &

v

)

[inline]

Definition at line 1216 of file vector.hpp.

{ return big<min_op> (v); }

C mmx::big_min

(

const table< C, T, V > &

t

)

[inline]

Definition at line 719 of file table.hpp.

{ return big<min_op> (t); }

C mmx::big_min

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 790 of file new_table.hpp.

{ return big<min_op> (t); }

C mmx::big_min

(

const iterator< C > &

it

)

[inline]

Definition at line 461 of file iterator.hpp.

{ return big<min_op> (it); }

C mmx::big_mul

(

const vector< C, V > &

v

)

[inline]

Definition at line 1213 of file vector.hpp.

{ return big<mul_op> (v); }

C mmx::big_mul

(

const table< C, T, V > &

t

)

[inline]

Definition at line 716 of file table.hpp.

{ return big<mul_op> (t); }

C mmx::big_mul

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 787 of file new_table.hpp.

{ return big<mul_op> (t); }

C mmx::big_mul

(

const iterator< C > &

it

)

[inline]

Definition at line 458 of file iterator.hpp.

{ return big<mul_op> (it); }

C mmx::big_or

(

const vector< C, V > &

v

)

[inline]

Definition at line 1214 of file vector.hpp.

{ return big< or_op> (v); }

C mmx::big_or

(

const table< C, T, V > &

t

)

[inline]

Definition at line 717 of file table.hpp.

{ return big< or_op> (t); }

C mmx::big_or

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 788 of file new_table.hpp.

{ return big< or_op> (t); }

C mmx::big_or

(

const iterator< C > &

it

)

[inline]

Definition at line 459 of file iterator.hpp.

{ return big<or_op > (it); }

int big_small_compare	(	const generic &	g1,
		const generic &	g2
	)

Definition at line 176 of file generic_utils.cpp.

References compare().

Referenced by product_less_op::op(), and sum_less_op::op().

                                                         {
  return compare (g1, g2, -1);
}

C mmx::big_sup

(

const vector< C, V > &

v

)

[inline]

Definition at line 1219 of file vector.hpp.

{ return big<sup_op> (v); }

C mmx::big_sup

(

const table< C, T, V > &

t

)

[inline]

Definition at line 722 of file table.hpp.

{ return big<sup_op> (t); }

C mmx::big_sup

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 793 of file new_table.hpp.

{ return big<sup_op> (t); }

generic mmx::bigop	(	const generic &	op,
		const vector< generic > &	v
	)			[inline]

Definition at line 131 of file mmx_printer.cpp.

References cons(), and gen().

                                                                   {
  return gen ("$bigop", cons (op, v)); }

generic mmx::binary_access	(	const C &	x,
		nat	i
	)			[inline]

Definition at line 213 of file port.hpp.

References access().

                                  {
  return binary_helper<C>::access (x, i);
}

C binary_assemble

(

const generic &

x

)

[inline]

Definition at line 223 of file port.hpp.

Referenced by binary_helper< compound >::assemble().

                                   {
  return binary_helper<C>::assemble (x);
}

generic binary_assemble_generic	(	const generic &	tp,
		const generic &	val
	)

Definition at line 89 of file generic.cpp.

References ASSERT, current_ev, gen(), and mmerr.

Referenced by binary_helper< generic >::assemble().

                                                                {
  if (!current_ev->contains (gen ("assembler", tp)))
    mmerr << "val= " << val << "\n";
  ASSERT (current_ev->contains (gen ("assembler", tp)),
          "unsupported type for generic binary assemble");
  routine r= as<routine> (current_ev->get (gen ("assembler", tp)));
  return r->apply (val);
}

generic mmx::binary_assemble_generic_via

(

const generic &

x

)

[inline]

Definition at line 264 of file port.hpp.

                                               {
  return as<generic> (binary_assemble<T> (x));
} 

table<C,T,V> mmx::binary_combine	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 573 of file table.hpp.

References busy(), entries(), simplify(), and Table.

                                                {
  Table r (Op::template neutral<C> ());
  for (iterator<T> it1= entries (t); busy (it1); ++it1)
    for (iterator<T> it2= entries (u); busy (it2); ++it2)
      Op::set_op (r[Op::rhs_op::op (*it1, *it2)], t[*it1], u[*it2]);
  simplify (r);
  return r;
}

new_table<C,T,V> mmx::binary_combine	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 644 of file new_table.hpp.

References busy(), entries(), simplify(), and Table.

                                                {
  Table r (Op::template neutral<C> ());
  for (iterator<T> it1= entries (t); busy (it1); ++it1)
    for (iterator<T> it2= entries (u); busy (it2); ++it2)
      Op::set_op (r[Op::rhs_op::op (*it1, *it2)], t[*it1], u[*it2]);
  simplify (r);
  return r;
}

generic binary_disassemble

(

const C &

x

)

[inline]

Definition at line 218 of file port.hpp.

Referenced by generic_concrete_rep< C >::binary_disassemble(), and binary_helper< format< T > >::disassemble().

                                {
  return binary_helper<C>::disassemble (x);
}

generic binary_disassemble_generic

(

const generic &

g

)

Definition at line 84 of file generic.cpp.

Referenced by binary_helper< generic >::access().

                                              {
  return g->binary_disassemble ();
}

nat mmx::binary_id	(	nat	id1,
		nat	id2
	)			[inline]

Definition at line 178 of file generic.hpp.

{ return id1 ^ (0x10115 * id2); }

port mmx::binary_ll	(	const port &	out,
		const C &	x
	)			[inline]

Definition at line 238 of file port.hpp.

References write().

                                        {
  binary_helper<C>::write (out, x);
  return out;
}

vector<typename binary_return_type_helper< Op , C1 , C2 >::RET,V> mmx::binary_map	(	const vector< C1, V > &	v,
		const vector< C2, V > &	w
	)			[inline]

Definition at line 780 of file vector.hpp.

References ASSERT, Binary_return_type, C2, CF(), extend(), is_a_scalar(), is_non_scalar(), N(), n, vector< C, V >::scalar(), seg(), and T.

                                                          {
  typedef implementation<vector_linear,V> Vec;
  typedef Binary_return_type(Op,C1,C2) T;
  format<T> fm= binary_map<Op> (CF(v), CF(w));
  if (is_a_scalar (v) || is_a_scalar (w)) {
    if (is_non_scalar (v)) return binary_map<Op> (v, extend (w, v));
    if (is_non_scalar (w)) return binary_map<Op> (extend (v, w), w);
    return vector<T,V> (Op::op (v.scalar(), w.scalar()));
  }
  nat n= N(v);
  ASSERT (N(w) == n, "lengths don't match");
  nat l= aligned_size<T,V> (n);
  T* r= mmx_formatted_new<T> (l, fm);
  Vec::template vec_binary<Op> (r, seg (v), seg (w), n);
  return vector<T,V> (r, n, l, fm);
}

format<typename binary_return_type_helper< Op , C1 , C2 >::RET > mmx::binary_map	(	const format< C1 > &	fm1,
		const format< C2 > &	fm2
	)			[inline]

Definition at line 686 of file type_props.hpp.

References Binary_return_type, and C2.

                                                          {
  typedef Binary_return_type(Op,C1,C2) R;
  typedef typename format<R>::FT FT;
  return format_binary_map_helper<Op,FT,R,C1,C2>::op (fm1, fm2);
}

table<C,T,V> mmx::binary_map	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 505 of file table.hpp.

References busy(), CF2(), entries(), I(), simplify(), and Table.

                                            {
  Table r (Op::op (I(t), I(u)), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    r[*it]= Op::op (t[*it], u[*it]);
  for (iterator<T> it= entries (u); busy (it); ++it)
    if (!(t->contains (*it)))
      r[*it]= Op::op (t[*it], u[*it]);
  simplify (r);
  return r;
}

sparse_vector<C,T,V> mmx::binary_map	(	const sparse_vector< C, T, V > &	v1,
		const sparse_vector< C, T, V > &	v2
	)			[inline]

Definition at line 197 of file sparse_vector.hpp.

References C, n, N(), Pair, set_zero(), and Sparse_vector.

                                                              {
  typedef typename V::val_op Eq;
  typedef typename V::l_op Less;
  static C zero; set_zero (zero);
  nat i1, i2, n1= N(v1), n2= N(v2), j, n= n1 + n2;
  Pair* r= mmx_new<Pair > (n);
  for (i1= i2= j= 0; i1 < n1 && i2 < n2; ) {
    if (Less::op (v1[i1].x1, v2[i2].x1)) {
      Pair e (v1[i1].x1, Op::op (v1[i1].x2, zero));
      i1++; if (Eq::not_op (e.x2, zero)) r[j++]= e;
    }
    else if (Less::op (v2[i2].x1, v1[i1].x1)) {
      Pair e (v2[i2].x1, Op::op (zero, v2[i2].x2));
      i2++; if (Eq::not_op (e.x2, zero)) r[j++]= e;
    }
    else {
      Pair e (v2[i2].x1, Op::op (v1[i1].x2, v2[i2].x2));
      i1++; i2++; if (Eq::not_op (e.x2, zero)) r[j++]= e;
    }
  }
  while (i1 < n1) {
    Pair e (v1[i1].x1, Op::op (v1[i1].x2, zero));
    i1++; if (Eq::not_op (e.x2, zero)) r[j++]= e;
  }
  while (i2 < n2) {
    Pair e (v2[i2].x1, Op::op (zero, v2[i2].x2));
    i2++; if (Eq::not_op (e.x2, zero)) r[j++]= e;
  }
  return Sparse_vector (r, j, n);
}

new_table<C,T,V> mmx::binary_map	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 576 of file new_table.hpp.

References busy(), CF2(), entries(), I(), simplify(), and Table.

                                            {
  Table r (Op::op (I(t), I(u)), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    r[*it]= Op::op (t[*it], u[*it]);
  for (iterator<T> it= entries (u); busy (it); ++it)
    if (!(t->contains (*it)))
      r[*it]= Op::op (t[*it], u[*it]);
  simplify (r);
  return r;
}

sparse_vector<C,T,V> mmx::binary_map_optimized	(	const sparse_vector< C, T, V > &	v1,
		const sparse_vector< C, T, V > &	v2
	)			[inline]

Definition at line 229 of file sparse_vector.hpp.

References C, n, N(), Pair, set_zero(), and Sparse_vector.

                                                                        {
  // With optimizations for addition and subtraction
  typedef typename V::val_op Eq;
  typedef typename V::l_op Less;
  static C zero; set_zero (zero);
  nat i1, i2, n1= N(v1), n2= N(v2), j, n= n1 + n2;
  Pair* r= mmx_new<Pair > (n);
  for (i1= i2= j= 0; i1 < n1 && i2 < n2; ) {
    if (Less::op (v1[i1].x1, v2[i2].x1)) {
      typedef typename Op::lop Lop;
      r[j++]= Pair (v1[i1].x1, Lop::op (v1[i1].x2)); i1++;
    }
    else if (Less::op (v2[i2].x1, v1[i1].x1)) {
      typedef typename Op::rop Rop;
      r[j++]= Pair (v2[i2].x1, Rop::op (v2[i2].x2)); i2++;
    }
    else {
      Pair e (v2[i2].x1, Op::op (v1[i1].x2, v2[i2].x2));
      i1++; i2++; if (Eq::not_op (e.x2, zero)) r[j++]= e;
    }
  }
  while (i1 < n1) {
    typedef typename Op::lop Lop;
    r[j++]= Pair (v1[i1].x1, Lop::op (v1[i1].x2)); i1++;
  }
  while (i2 < n2) {
    typedef typename Op::rop Rop;
    r[j++]= Pair (v2[i2].x1, Rop::op (v2[i2].x2)); i2++;
  }
  return Sparse_vector (r, j, n);
}

vector<typename binary_return_type_helper< Op , C , X >::RET,V> mmx::binary_map_scalar	(	const vector< C, V > &	v,
		const X &	x
	)			[inline]

Definition at line 799 of file vector.hpp.

References Binary_return_type, C, CF(), is_a_scalar(), N(), n, vector< C, V >::scalar(), seg(), and T.

                                                     {
  typedef implementation<vector_linear,V> Vec;
  typedef Binary_return_type(Op,C,X) T;
  format<T> fm= binary_map_scalar<C> (CF(v), x);
  if (is_a_scalar (v)) return vector<T,V> (Op::op (v.scalar(), x));
  nat n= N(v);
  nat l= aligned_size<T,V> (n);
  T* r= mmx_formatted_new<T> (l, fm);
  Vec::template vec_binary_scalar<Op> (r, seg (v), x, n);
  return vector<T,V> (r, n, l, fm);
}

format<typename binary_return_type_helper< Op , C1 , C2 >::RET > mmx::binary_map_scalar	(	const format< C1 > &	fm,
		const C2 &	x
	)			[inline]

Definition at line 654 of file type_props.hpp.

References Binary_return_type, and C2.

                                                      {
  typedef Binary_return_type(Op,C1,C2) R;
  typedef typename format<R>::FT FT;
  return format_binary_map_scalar_helper<Op,FT,R,C1,C2>::op (fm, x);
}

table<C,T,V> mmx::binary_map_scalar	(	const table< C, T, V > &	t,
		const X &	x
	)			[inline]

Definition at line 517 of file table.hpp.

References busy(), CF2(), entries(), I(), simplify(), and Table.

                                               {
  Table r (Op::op (I(t), x), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    r[*it]= Op::op (t[*it], x);
  simplify (r);
  return r;
}

sparse_vector<C,T,V> mmx::binary_map_scalar	(	const sparse_vector< C, T, V > &	v,
		const C &	x
	)			[inline]

Definition at line 283 of file sparse_vector.hpp.

References C, N(), n, Pair, set_zero(), and Sparse_vector.

                                                       {
  typedef typename V::val_op Eq;
  static C zero; set_zero (zero);
  nat i, j, n= N(v);
  Pair* r= mmx_new<Pair > (n);
  for (i=0, j=0; i<n; i++) {
    Pair e (v[i].x1, Op::op (v[i].x2, x));
    if (Eq::not_op (e.x2, zero)) r[j++]= e;
  }
  return Sparse_vector (r, j, n);
}

new_table<C,T,V> mmx::binary_map_scalar	(	const new_table< C, T, V > &	t,
		const X &	x
	)			[inline]

Definition at line 588 of file new_table.hpp.

References busy(), CF2(), entries(), I(), simplify(), and Table.

                                               {
  Table r (Op::op (I(t), x), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    r[*it]= Op::op (t[*it], x);
  simplify (r);
  return r;
}

C binary_read

(

const port &

in

)

[inline]

Definition at line 233 of file port.hpp.

References read().

Referenced by binary_helper< compound >::read().

                             {
  return binary_helper<C>::read (in);
}

generic mmx::binary_read_generic

(

const generic &

in

)

[inline]

Definition at line 279 of file port.hpp.

                                        {
  return as<generic> (binary_read<T> (as<port> (in)));
} 

generic binary_read_generic

(

const port &

in

)

Definition at line 110 of file generic.cpp.

References ASSERT, binary_readers, mmerr, and read().

Referenced by GLUE_29(), and binary_helper< generic >::read().

                                     {
  string name;
  char buf[1];
  while (true) {
    mmx::read (in, buf, 1);
    if (buf[0] == ':') break;
    name << buf[0];
  }
  if (!binary_readers->contains (name))
    mmerr << "name= " << name << "\n";
  ASSERT (binary_readers->contains (name),
          "unsupported type for generic binary read");
  routine r= as<routine> (binary_readers[name]);
  return r->apply (as<generic> (in));
}

routine mmx::binary_routine	(	const generic &	name,
		D(*)(const S1 &, const S2 &)	f
	)			[inline]

Definition at line 267 of file routine.hpp.

Referenced by accelerate(), define_type_helper< C >::def_type(), define(), and define_user_type().

                                                                    {
  return new binary_routine_rep<D,S1,S2> (name, f);
}

port mmx::binary_rr	(	const port &	in,
		C &	x
	)			[inline]

Definition at line 244 of file port.hpp.

References read().

                                 {
  x= binary_helper<C>::read (in);
  return in;
}

nat mmx::binary_size

(

const C &

x

)

[inline]

Definition at line 208 of file port.hpp.

References size().

                         {
  return binary_helper<C>::size (x);
}

bool mmx::binary_test	(	const vector< C1, V > &	v,
		const vector< C2, V > &	w
	)			[inline]

Definition at line 851 of file vector.hpp.

References extend(), is_a_scalar(), is_non_scalar(), N(), n, vector< C, V >::scalar(), and seg().

                                                           {
  typedef implementation<vector_linear,V> Vec;
  if (is_a_scalar (v) || is_a_scalar (w)) {
    if (is_non_scalar (v)) return binary_test<Op> (v, extend (w, v));
    if (is_non_scalar (w)) return binary_test<Op> (extend (v, w), w);
    return Op::op (v.scalar(), w.scalar());
  }
  nat n= N(v);
  if (N(w) != n) return false;
  return Vec::template vec_binary_test<Op> (seg (v), seg (w), n);
}

bool mmx::binary_test	(	const triple< C1, C2, C3 > &	t1,
		const triple< C1, C2, C3 > &	t2
	)			[inline]

Definition at line 54 of file triple.hpp.

                                                 {
  return Op::op (t1.x1,t2.x1) && Op::op(t1.x2, t2.x2) && Op::op(t1.x3, t2.x3);
}

bool mmx::binary_test	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 545 of file table.hpp.

References busy(), entries(), and I().

                                             {
  if (Op::not_op (I(t), I(u))) return false;
  for (iterator<T> it= entries (t); busy (it); ++it)
    if (Op::not_op (t[*it], u[*it])) return false;
  for (iterator<T> it= entries (u); busy (it); ++it)
    if (!t->contains (*it) && Op::not_op (t[*it], u[*it])) return false;
  return true;
}

bool mmx::binary_test	(	const sparse_vector< C, T, V > &	v1,
		const sparse_vector< C, T, V > &	v2
	)			[inline]

Definition at line 159 of file sparse_vector.hpp.

References N().

                                                               {
  nat n1= N(v1), n2= N(v2);
  if (n1 != n2) return false;
  for (nat i=0; i<n1; i++)
    if (!Op::op (v1[i], v2[i]))
      return false;
  return true;
}

bool mmx::binary_test	(	const pair< C1, C2 > &	p1,
		const pair< C1, C2 > &	p2
	)			[inline]

Definition at line 49 of file pair.hpp.

                                             {
  return Op::op (p1.x1, p2.x1) && Op::op (p1.x2, p2.x2);
}

bool mmx::binary_test	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 616 of file new_table.hpp.

References busy(), entries(), and I().

                                             {
  if (Op::not_op (I(t), I(u))) return false;
  for (iterator<T> it= entries (t); busy (it); ++it)
    if (Op::not_op (t[*it], u[*it])) return false;
  for (iterator<T> it= entries (u); busy (it); ++it)
    if (!t->contains (*it) && Op::not_op (t[*it], u[*it])) return false;
  return true;
}

bool mmx::binary_test	(	const list< C > &	l1,
		const list< C > &	l2
	)			[inline]

Definition at line 222 of file list.hpp.

References is_nil(), read_car(), and read_cdr().

                                             {
  if (is_nil (l1) || is_nil (l2)) return is_nil (l1) && is_nil (l2);
  return Op::op (read_car (l1), read_car (l2)) &&
         binary_test<Op> (read_cdr (l1), read_cdr (l2));
}

bool mmx::binary_test	(	const iterator< C > &	it1b,
		const iterator< C > &	it2b
	)			[inline]

Definition at line 170 of file iterator.hpp.

References ERROR.

                                                         {
  (void) it1b; (void) it2b;
  ERROR ("invalid test on iterators");
  return false;
  /*
  Iterator it1= copy (it1b), it2= copy (it2b);
  while (busy (it1) && busy (it2)) {
    if (Op::not_op (*it1, *it2)) return false;
    ++it1; ++it2;
  }
  return done (it1) && done (it2);
  */
}

bool mmx::binary_test	(	const heap< C > &	h1b,
		const heap< C > &	h2b
	)			[inline]

Definition at line 235 of file heap.hpp.

References copy(), Heap, N(), and pull().

                                               {
  if (N(h1b) != N(h2b)) return false;
  Heap h1= copy (h1b), h2= copy (h2b);
  while (N(h1) > 0)
    if (Op::not_op (pull (h1), pull (h2))) return false;
  return true;
}

bool mmx::binary_test	(	const chain< C > &	c1,
		const chain< C > &	c2
	)			[inline]

Definition at line 230 of file chain.hpp.

References left(), middle(), N(), and right().

                                               {
  if (N (c1) != N (c2)) return false;
  if (N (c1) == 0) return true;
  return binary_test<Op> (left (c1), left(c2)) &&
    Op::op (middle (c1), middle (c2)) &&
    binary_test<Op> (right (c1), right(c2));
}

bool mmx::binary_test_scalar	(	const vector< C, V > &	v,
		const X &	c
	)			[inline]

Definition at line 864 of file vector.hpp.

References is_a_scalar(), N(), vector< C, V >::scalar(), and seg().

                                                      {
  typedef implementation<vector_linear,V> Vec;
  if (is_a_scalar (v)) return Op::op (v.scalar(), c);
  return Vec::template vec_binary_test_scalar<Op> (seg (v), c, N(v));
}

bool mmx::binary_test_scalar	(	const table< C, T, V > &	t,
		const X &	c
	)			[inline]

Definition at line 555 of file table.hpp.

References busy(), entries(), and I().

                                                {
  if (Op::not_op (I(t), c)) return false;
  for (iterator<T> it= entries (t); busy (it); ++it)
    if (Op::not_op (t[*it], c)) return false;
  return true;
}

bool mmx::binary_test_scalar	(	const new_table< C, T, V > &	t,
		const X &	c
	)			[inline]

Definition at line 626 of file new_table.hpp.

References busy(), entries(), and I().

                                                {
  if (Op::not_op (I(t), c)) return false;
  for (iterator<T> it= entries (t); busy (it); ++it)
    if (Op::not_op (t[*it], c)) return false;
  return true;
}

generic binary_type_generic

(

const generic &

g

)

Definition at line 79 of file generic.cpp.

Referenced by binary_helper< generic >::access().

                                       {
  return g->binary_type ();
}

void binary_write	(	const port &	out,
		const C &	x
	)			[inline]

Definition at line 228 of file port.hpp.

References write().

Referenced by generic_concrete_rep< C >::binary_write().

                                           {
  binary_helper<C>::write (out, x);
}

void binary_write_generic	(	const port &	out,
		const generic &	g
	)

Definition at line 105 of file generic.cpp.

Referenced by GLUE_28(), and binary_helper< generic >::write().

                                                         {
  g->binary_write (out);
}

C mmx::binpow	(	const C &	i,
		const nat &	n
	)			[inline]

Definition at line 540 of file defaults.hpp.

References C, promote(), and square().

Referenced by prem_op::op(), and powint().

                                  {
  // FIXME: how to merge with pow?
  if (n <= 1) return n==0? promote (1, i): i;
  C j= square (binpow (i, n >> 1));
  if ((n&1) == 0) return j;
  else return i * j;
}

static nat mmx::bit_size

(

const C &

p

)

[inline, static]

Return the bitsize of abs (p).

Definition at line 309 of file int.hpp.

References abs(), C, and s.

                      {
  typedef typename unsigned_of_helper<C>::type uC;
  if (p == 0) return 0;
  uC up = abs (p);
  nat s = 0;
  nat k = 4 * sizeof(C);
  uC mask = ((uC) -1) << k;
  while (k != 0) {
    if (up & mask) { up >>= k; s += k; }
    k >>= 1;
    mask >>= k;
  }
  return up == 0 ? s : s + 1;
}

vector<C,V> mmx::blur	(	const vector< C, V > &	v,
		const vector< C2, V2 > &	w
	)			[inline]

Definition at line 1358 of file vector.hpp.

                                               {
  return binary_map<blur_op> (v, w); }

vector<C,V> mmx::blur	(	const vector< C, V > &	v,
		const K &	x
	)			[inline]

Definition at line 1355 of file vector.hpp.

                                                       {
  return binary_map_scalar<blur_op> (v, x); }

table<C,T,V> mmx::blur	(	const table< C, T, V > &	t,
		const K &	x
	)			[inline]

Definition at line 741 of file table.hpp.

                                                     {
  return binary_map_scalar<blur_op> (t, x); }

new_table<C,T,V> mmx::blur	(	const new_table< C, T, V > &	t,
		const K &	x
	)			[inline]

Definition at line 812 of file new_table.hpp.

                                                     {
  return binary_map_scalar<blur_op> (t, x); }

generic blur	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 827 of file generic.cpp.

References current_ev.

                                                    {
  return current_ev->apply ("blur", x1, x2); }

C mmx::blur	(	const C &	x,
		const D &	y
	)			[inline]

Definition at line 709 of file defaults.hpp.

Referenced by blur_op::op(), and blur_op::set_op().

                                                                        {
  (void) y; return x; }

unary_return_type_helper<abs_op, C >::RET mmx::bnd_down

(

const C &

x

)

[inline]

Definition at line 1100 of file type_props.hpp.

{ return as<Abs_type(C) > (x); }

unary_return_type_helper<abs_op, C >::RET mmx::bnd_up

(

const C &

x

)

[inline]

Definition at line 1102 of file type_props.hpp.

{ return as<Abs_type(C) > (x); }

mmx::bool

(

(((const generic &g)>='0')&&((const generic &g)<='9'))||(((const generic &g)>='A')&&((const generic &g)<='Z'))||(((const generic &g)>='a')&&((const generic &g)<='z'))||(((const generic &g)=='_')||((const generic &g)=='?')||((const generic &g)=='$'))

)

Definition at line 211 of file mmx_texmacs.cpp.

References literal_to_string(), N(), and s.

                            {
  if (!is<literal> (g)) return false;
  string s= literal_to_string (g);
  for (nat i=0; i<N(s); i++)
    if ((s[i] < 'a' || s[i] > 'z') &&
        (s[i] < 'A' || s[i] > 'Z'))
      return false;
  return true;
}

generic mmx::bracket	(	const generic &	l,
		const generic &	g,
		const generic &	r
	)			[inline]

Definition at line 133 of file mmx_printer.cpp.

References gen().

Referenced by mmx_printer::pp_E0().

                                                                              {
  return gen ("$bracket", l, g, r); }

bool mmx::busy

(

const port &

p

)

[inline]

Definition at line 101 of file port.hpp.

References inside().

                                 {
  return inside (p)->busy (); }

bool busy

(

const iterator< C > &

it

)

[inline]

Definition at line 97 of file iterator.hpp.

Referenced by append(), big(), binary_combine(), binary_map(), binary_map_scalar(), binary_test(), binary_test_scalar(), composite_port_rep::busy(), chain< C >::chain(), common(), copy(), as_helper< table< D, T >, table< C, T > >::cv(), as_helper< new_table< D, T >, new_table< C, T > >::cv(), difference(), binary_helper< table< C, T, V > >::disassemble(), binary_helper< new_table< C, T, V > >::disassemble(), flatten(), GLUE_13(), heap< C >::heap(), as_iterator_rep< C, S >::is_busy(), iterator_busy(), list< cleaner >::list(), map(), new_table< C, T, V >::new_table(), operator<<(), raw_read(), reverse(), shell_texmacs_input(), table< D, pair< S1, S2 >, table_variant >::table(), unary_filter(), unary_hash(), unary_map(), unary_set(), unary_set_scalar(), vector< observer >::vector(), wait_port_event(), binary_helper< table< C, T, V > >::write(), and binary_helper< new_table< C, T, V > >::write().

{ return it.rep->is_busy (); }

storage cached_storage

(

const storage &

st

)

Create storage which will be stored on disk in the directory root.

Definition at line 183 of file storage.cpp.

Referenced by GLUE_3().

                                   {
  return st;
}

void call_glue

(

const string &

s

)

Definition at line 117 of file glue.cpp.

References contains(), ERROR, and glue_table.

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_dynamic(), glue_expression(), glue_list_generic(), glue_list_map(), glue_literal(), glue_port(), glue_routine(), glue_storage(), glue_string(), glue_syntactic(), and glue_vector_map().

                                 {
  if (! contains (glue_table (), s))
    ERROR ("Can not find glued function " * s);
  (glue_table () [s]) ();
}

nat mmx::can_read

(

const port &

p

)

[inline]

Definition at line 105 of file port.hpp.

References inside().

Referenced by composite_port_rep::can_read(), GLUE_15(), composite_port_rep::read(), and var_load().

                                    {
  return inside (p)->can_read (); }

nat mmx::can_write

(

const port &

p

)

[inline]

Definition at line 103 of file port.hpp.

References inside().

Referenced by composite_port_rep::can_write(), and GLUE_14().

                                     {
  return inside (p)->can_write (); }

string canonical_name

(

const string &

name

)

Definition at line 356 of file system.cpp.

References ends(), get_directory(), and N().

Referenced by path_name(), recursive_search_name(), relative_name(), and semi_recursive_search_name().

                                    {
  //mmout << "canonical_name: " << name << lf;
  for (int i= N(name)-1; i>=0; i--)
    if (name[i] == '/') {
      nat j=i;
      while (j>0 && name[j-1] == '/') j--;
      string pre = canonical_name (name (0, j));
      string post= name (i+1, N(name));
      if (pre == "") return "/" * post;
      else if (pre == ".") return post;
      else if (post == ".") return pre;
      else if (ends (pre, "..") && post == "..") return pre * "/" * post;
      else if (post == "..") return get_directory (pre);
      else return pre * "/" * post;
    }
  return name;
}

generic mmx::cAr

(

const vector< generic > &

a

)

[inline]

Definition at line 131 of file cpp_printer.cpp.

References N().

                               {
  if (N(a) == 0)
    return generic ();
  return a[N(a)-1];
}

C mmx::car

(

const vector< C, V > &

v

)

[inline]

Definition at line 621 of file vector.hpp.

{ return v[0]; }

C2 C1 mmx::car

(

const pair< C1, C2 > &

p

)

[inline]

Definition at line 37 of file pair.hpp.

{ return p.x1; }

C & car

(

list< C > &

l

)

[inline]

Return the head of l.

Return a copy of car (l) for write access.

Definition at line 144 of file list.hpp.

{ l.secure(); return l.rep->item; }

const C & car

(

const list< C > &

l

)

[inline]

Return the head of l.

Definition at line 140 of file list.hpp.

{ return l.rep->item; }

generic car

(

const generic &

g

)

Definition at line 46 of file generic_utils.cpp.

                       {
  return g[0];
}

C mmx::cAr

(

const chain< C > &

c

)

[inline]

Definition at line 214 of file chain.hpp.

References ASSERT, is_nil(), middle(), and right().

Referenced by operator*().

                     {
  ASSERT (!is_nil (c), "non-empty chain expected");
  if (is_nil (right (c))) return middle (c);
  return cAr (right (c));
}

C mmx::car

(

const chain< C > &

c

)

[inline]

Definition at line 207 of file chain.hpp.

References ASSERT, is_nil(), left(), and middle().

Referenced by append(), as_vector(), complete(), completion_generator(), contains(), copy(), as_helper< list< T >, list< F > >::cv(), binary_helper< list< C > >::disassemble(), find(), GLUE_11(), GLUE_12(), GLUE_13(), insert(), list_map_1(), list_map_2(), list_map_n(), map(), merge(), sort_op_pair_wrapper< Op >::not_op(), sort_op_pair_wrapper< Op >::op(), operator*(), output_completion(), range(), read_car(), table_rep< C, T, V >::set(), set_as(), sort_leq(), split(), and binary_helper< list< C > >::write().

                     {
  ASSERT (!is_nil (c), "non-empty chain expected");
  if (is_nil (left (c))) return middle (c);
  return car (left (c));
}

C mmx::catalan_cst

(

const format< C > &

fm

)

[inline]

Definition at line 933 of file type_props.hpp.

References C, promote(), and set_catalan().

                                  {
  C r= promote (0, fm); set_catalan (r); return r; }

C mmx::catalan_cst

(

)

[inline]

Definition at line 900 of file type_props.hpp.

References C, and set_catalan().

{ C r; set_catalan (r); return r; }

vector<generic> mmx::cDr

(

const vector< generic > &

a

)

[inline]

Definition at line 138 of file cpp_printer.cpp.

References N(), and range().

                               {
  if (N(a) == 0)
    return a;
  return range (a,0,N(a)-1);
}

vector<C,V> mmx::cdr

(

const vector< C, V > &

v

)

[inline]

Definition at line 622 of file vector.hpp.

References N(), and range().

{ return range (v, 1, N(v)); }

C2 mmx::cdr

(

const pair< C1, C2 > &

p

)

[inline]

Definition at line 38 of file pair.hpp.

{ return p.x2; }

list< C > & cdr

(

list< C > &

l

)

[inline]

Return the tail of l.

Return a copy of cdr (l) for write access.

Definition at line 149 of file list.hpp.

{ l.secure(); return l.rep->next; }

const list< C > & cdr

(

const list< C > &

l

)

[inline]

Return the tail of l.

Definition at line 145 of file list.hpp.

{ return l.rep->next; }

generic cdr

(

const generic &

g

)

Definition at line 51 of file generic_utils.cpp.

References compound_to_vector(), N(), range(), and vector_to_compound().

                       {
  return vector_to_compound (range (compound_to_vector (g), 1, N(g)));
}

chain<C> mmx::cDr

(

const chain< C > &

c

)

[inline]

Definition at line 310 of file chain.hpp.

References ASSERT, balance_right(), Chain, is_nil(), left(), middle(), N(), and right().

Referenced by operator*().

                     {
  ASSERT (!is_nil (c), "non-empty chain expected");
  if (N (c) == 1) return Chain ();
  if (2 * N (right (c)) <= N (left (c))) return cDr (balance_right (c));
  return Chain (left (c), middle (c), cDr (right (c)));
}

chain<C> mmx::cdr

(

const chain< C > &

c

)

[inline]

Definition at line 302 of file chain.hpp.

References ASSERT, balance_left(), Chain, is_nil(), left(), middle(), N(), and right().

Referenced by append(), routine_primitive_rep::apply(), arguments(), as_texmacs(), as_vector(), complete(), completion_generator(), contains(), copy(), as_helper< list< T >, list< F > >::cv(), binary_helper< list< C > >::disassemble(), find(), flatten(), generic_arguments(), GLUE_12(), GLUE_13(), GLUE_14(), insert(), is_atom(), list_map(), list_map_1(), list_map_2(), list_map_n(), make_document(), map(), merge(), N(), operator*(), output_completion(), range(), read_cdr(), table_rep< C, T, V >::reset(), scheme_to_tm(), table_rep< C, T, V >::set(), set_as(), table_rep< C, T, V >::simplify(), sort_leq(), split(), un_try_catch(), WRAP_INDIRECT_IMPL(), and binary_helper< list< C > >::write().

                     {
  ASSERT (!is_nil (c), "non-empty chain expected");
  if (N (c) == 1) return Chain ();
  if (2 * N (left (c)) <= N (right (c))) return cdr (balance_left (c));
  return Chain (cdr (left (c)), middle (c), right (c));
}

generic ceil

(

const generic &

x

)

Definition at line 753 of file generic.cpp.

References current_ev, and GEN_CEIL.

                                {
  return current_ev->apply (GEN_CEIL, x); }

double ceil

(

const double &

x

)

[inline]

Definition at line 131 of file double.hpp.

Referenced by ceil_op::op(), and ceil_op::set_op().

{ return std::ceil (x); }

vector<typename unary_return_type_helper<center_op, C >::RET,V> mmx::center

(

const vector< C, V > &

v

)

[inline]

Definition at line 1345 of file vector.hpp.

                                            {
  return unary_map<center_op> (v); }

C mmx::center

(

const C &

x

)

[inline]

Definition at line 1092 of file type_props.hpp.

{ return x; }

syntactic center

(

const syntactic &

g1

)

Definition at line 460 of file syntactic.cpp.

References GEN_CENTER, and syn().

{ return syn (GEN_CENTER, g1); }

generic center

(

const generic &

x1

)

Definition at line 821 of file generic.cpp.

References current_ev.

Referenced by center_op::Center_type(), and center_op::set_op().

                                   {
  return current_ev->apply ("center", x1); }  

format<C> mmx::CF

(

const vector< C, V > &

v

)

[inline]

Definition at line 211 of file vector.hpp.

{ return v->tfm (); }

format<C> mmx::CF

(

const iterator< C > &

it

)

[inline]

Definition at line 101 of file iterator.hpp.

Referenced by append(), big(), big_dicho(), binary_map(), binary_map_scalar(), cons(), as_helper< vector< T, TV >, vector< F, FV > >::cv(), as_helper< iterator< C >, iterator< S > >::cv(), fast_helper< vector< C, V > >::dd(), dot(), extract(), extract_mod(), get_format(), insert(), is_evaluable(), is_reconstructible(), make_cache_3(), make_mmx_new_table(), make_mmx_table(), map(), project_helper< vector< C, V > >::op(), lift_helper< vector< C, V > >::op(), promote_scalar_helper< FT, F, T >::op(), range(), reverse(), set_as(), project_helper< vector< C, V > >::set_op(), lift_helper< vector< C, V > >::set_op(), sort_leq(), unary_map(), fast_helper< vector< C, V > >::uu(), vector< observer >::vector(), and binary_helper< vector< C, V > >::write().

{ return it->tfm (); }

format<C1> mmx::CF1

(

const triple< C1, C2, C3 > &

t

)

[inline]

Definition at line 43 of file triple.hpp.

References get_format().

{ return get_format (t.x1); }

format<C> mmx::CF1

(

const table< C, T, V > &

t

)

[inline]

Definition at line 162 of file table.hpp.

{ return t->tfm1 (); }

format<C1> mmx::CF1

(

const pair< C1, C2 > &

p

)

[inline]

Definition at line 39 of file pair.hpp.

References get_format().

{ return get_format (p.x1); }

format<C> mmx::CF1

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 184 of file new_table.hpp.

Referenced by reverse().

{ return t->tfm1 (); }

format<C2> mmx::CF2

(

const triple< C1, C2, C3 > &

t

)

[inline]

Definition at line 44 of file triple.hpp.

References get_format().

{ return get_format (t.x2); }

format<T> mmx::CF2

(

const table< C, T, V > &

t

)

[inline]

Definition at line 163 of file table.hpp.

{ return t->tfm2 (); }

format<C2> mmx::CF2

(

const pair< C1, C2 > &

p

)

[inline]

Definition at line 40 of file pair.hpp.

References get_format().

{ return get_format (p.x2); }

format<T> mmx::CF2

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 185 of file new_table.hpp.

Referenced by append(), binary_map(), binary_map_scalar(), common(), copy(), as_helper< table< D, T >, table< C, T > >::cv(), as_helper< new_table< D, T >, new_table< C, T > >::cv(), difference(), reverse(), unary_map(), binary_helper< table< C, T, V > >::write(), and binary_helper< new_table< C, T, V > >::write().

{ return t->tfm2 (); }

format<C3> mmx::CF3

(

const triple< C1, C2, C3 > &

t

)

[inline]

Definition at line 45 of file triple.hpp.

References get_format().

{ return get_format (t.x3); }

vector<C,V> mmx::change_precision	(	const vector< C, V > &	v,
		xnat	p
	)			[inline]

Definition at line 1326 of file vector.hpp.

                                                              {
  return binary_map_scalar<change_precision_op> (v, p); }

generic change_precision	(	const generic &	x,
		xnat	p
	)

Definition at line 762 of file generic.cpp.

References current_ev, and GEN_CHANGE_PRECISION.

                                                    {
  return current_ev->apply (GEN_CHANGE_PRECISION, x, as<generic> ((int) p)); }

double mmx::change_precision	(	const double &	x,
		xnat	prec
	)			[inline]

Definition at line 84 of file double.hpp.

References ASSERT.

                                                            {
  ASSERT (prec == 51, "invalid precision"); return x; }

C mmx::change_precision	(	const C &	x,
		xnat
	)			[inline]

Definition at line 705 of file defaults.hpp.

Referenced by GLUE_44(), change_precision_op::op(), and change_precision_op::set_op().

                                                                  {
  return x; }

routine change_signature	(	const routine &	r,
		const vector< nat > &	sig
	)

Definition at line 201 of file routine.cpp.

Referenced by define_user_type().

                                                            {
  return new change_signature_routine_rep (r, sig);
}

string mmx::charcode_as_string

(

int

i

)

[inline]

Definition at line 144 of file string.hpp.

Referenced by GLUE_22(), and read_line().

                                         {
  return string ((char) i); }

void mmx::clear

(

C &

x

)

[inline]

Definition at line 167 of file defaults.hpp.

References promote().

Referenced by clear_op::set_op().

{ x= promote (0, x); }

void mmx::close_alias

(

const alias< C > &

a

)

[inline]

Definition at line 58 of file alias.hpp.

Referenced by alias_binary_access_rep< C, R, A, B >::close(), and alias_unary_access_rep< C, R, A >::close().

{ a->close (); }

static vector<generic> mmx::collect

(

const generic &

g

)

[static]

Definition at line 794 of file mmx_printer.cpp.

References collect(), GEN_MINUS, GEN_PLUS, is_func(), and N().

                           {
  vector<generic> v;
  collect (v, g, 0);
  vector<generic> w;
  for (nat i=0; i<N(v); i++)
    if (is_func (v[i], GEN_PLUS, 2) || is_func (v[i], GEN_MINUS, 2))
      w << collect (v[i]);
    else w << v[i];
  return w;
}

static void mmx::collect	(	vector< generic > &	v,
		const generic &	g,
		nat	depth
	)			[static]

Definition at line 780 of file mmx_printer.cpp.

References gen(), GEN_MINUS, GEN_PLUS, and is_func().

Referenced by collect().

                                                          {
  if (depth >= 16384) v << g;
  else if (is_func (g, GEN_PLUS, 2)) {
    collect (v, g[1], depth+1);
    collect (v, g[2], depth+1);
  }
  else if (is_func (g, GEN_MINUS, 2)) {
    collect (v, g[1], depth+1);
    v << gen (GEN_MINUS, g[2]);
  }
  else v << g;
}

generic comma	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 171 of file generic.cpp.

References gen(), and GEN_COMMA.

                                                     {
  return gen (GEN_COMMA, g1, g2); }

generic comma

(

)

Definition at line 169 of file generic.cpp.

References gen(), and GEN_COMMA.

Referenced by trig_op::op(), trig(), and xaccess().

                 {
  return gen (generic (GEN_COMMA)); }

string command_dir

(

)

Definition at line 196 of file system.cpp.

References _from_dos_to_unix(), command_name, and get_directory().

Referenced by global_path(), and prefix_dir().

               {
  return get_directory (_from_dos_to_unix (string (command_name)));
}

table<C,T,V> mmx::common	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 775 of file table.hpp.

References busy(), CF2(), entries(), I(), and Table.

                                        {
  Table r (I (t), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    if (V::val_op::op (u[*it], t[*it]))
      r[*it]= t[*it];
  return r;
}

new_table<C,T,V> mmx::common	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 846 of file new_table.hpp.

References busy(), CF2(), entries(), I(), and Table.

                                        {
  Table r (I (t), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    if (V::val_op::op (u[*it], t[*it]))
      r[*it]= t[*it];
  return r;
}

C mmx::common_part	(	const C &	x,
		const C &	y
	)			[inline]

Definition at line 735 of file defaults.hpp.

References promote().

Referenced by common_part_op::op().

                                     {
  if (x == y) return x;
  else return promote (0, x);
}

static int compare	(	const generic &	g1,
		const generic &	g2,
		const int &	dir
	)			[static]

Definition at line 162 of file generic_utils.cpp.

References compare_N(), compare_P(), and MEMOIZE_BINARY.

                                                               {
  // NOTE: the splitting into two cases should not be necessary.
  // We do it in order to avoid an internal compiler error...
  if (dir < 0) {
    MEMOIZE_BINARY (std_memoizer,int,generic,generic,compare_N,g1,g2,
                   compare_N (g1, g2));
  }
  else {
    MEMOIZE_BINARY (std_memoizer,int,generic,generic,compare_P,g1,g2,
                   compare_P (g1, g2));
  }
}

int mmx::compare	(	const long long unsigned int &	x,
		const long long unsigned int &	y
	)			[inline]

Definition at line 449 of file defaults.hpp.

                                          {
  if (x < y) return -1;
  if (x > y) return  1;
  return 0;
}

int mmx::compare	(	const long unsigned int &	x,
		const long unsigned int &	y
	)			[inline]

Definition at line 442 of file defaults.hpp.

                                                                 {
  if (x < y) return -1;
  if (x > y) return  1;
  return 0;
}

int mmx::compare	(	const unsigned int &	x,
		const unsigned int &	y
	)			[inline]

Definition at line 435 of file defaults.hpp.

                                                       {
  if (x < y) return -1;
  if (x > y) return  1;
  return 0;
}

int mmx::compare	(	const short unsigned int &	x,
		const short unsigned int &	y
	)			[inline]

Definition at line 428 of file defaults.hpp.

                                                                   {
  if (x < y) return -1;
  if (x > y) return  1;
  return 0;
}

int mmx::compare	(	const unsigned char &	x,
		const unsigned char &	y
	)			[inline]

Definition at line 421 of file defaults.hpp.

                                                         {
  if (x < y) return -1;
  if (x > y) return  1;
  return 0;
}

int mmx::compare	(	const C &	x,
		const C &	y
	)			[inline]

Definition at line 416 of file defaults.hpp.

References sign().

Referenced by big_small_compare(), compare_sub(), and small_big_compare().

                                 {
  return sign (x-y);
}

int mmx::compare_N	(	const generic &	g1,
		const generic &	g2
	)

Definition at line 156 of file generic_utils.cpp.

References compare_sub().

Referenced by compare().

                                                     {
  return compare_sub (g1, g2, -1); }

static int mmx::compare_numeric	(	const string &	s1,
		const string &	s2
	)			[static]

Definition at line 112 of file generic_utils.cpp.

References N().

Referenced by compare_sub().

                                                     {
  if (s1[0] == '-' && s2[0] != '-') return -1;
  if (s1[0] != '-' && s2[0] == '-') return 1;
  if (s1[0] == '-' && s2[0] == '-')
    return -compare_numeric (s1 (1, N (s1)), s2 (1, N(s2)));
  if (N(s1) < N(s2)) return -1;
  if (N(s1) > N(s2)) return 1;
  if (s1 < s2) return -1;
  if (s1 > s2) return 1;
  return 0;
}

int mmx::compare_P	(	const generic &	g1,
		const generic &	g2
	)

Definition at line 158 of file generic_utils.cpp.

References compare_sub().

Referenced by compare().

                                                     {
  return compare_sub (g1, g2, 1); }

static int mmx::compare_sub	(	const generic &	g1,
		const generic &	g2,
		const int &	direction
	)			[static]

Definition at line 127 of file generic_utils.cpp.

References compare(), compare_numeric(), is_numeric(), literal_to_string(), N(), size(), and var_flatten().

Referenced by compare_N(), and compare_P().

                                                                         {
  nat s1= size (g1), s2= size (g2);
  if (s1 < s2) return -direction;
  if (s1 > s2) return direction;
  if (is<literal> (g1) && is<literal> (g2)) {
    string l1= literal_to_string (g1), l2= literal_to_string (g2);
    if (is_numeric (l1) && !is_numeric (l2)) return -direction;
    if (is_numeric (l2) && !is_numeric (l1)) return direction;
    if (is_numeric (l1) && is_numeric (l2))
      return direction * compare_numeric (l1, l2);
    if (l1 < l2) return -1;
    if (l1 > l2) return 1;
    return 0;
  }
  if (is<literal> (g1) && is<compound> (g2)) return -direction;
  if (is<compound> (g1) && is<literal> (g2)) return direction;
  if (is<compound> (g1) && is<compound> (g2)) {
    nat i, n1= N (g1), n2= N (g2);
    if (n1 < n2) return -direction;
    if (n1 > n2) return direction;
    for (i=0; i<n1; i++) {
      int c= compare (g1[i], g2[i], direction);
      if (c != 0) return c;
    }
    return 0;
  }
  return compare (var_flatten (g1), var_flatten (g2), direction);
}

static void mmx::complete

(

const string &

text

)

[static]

Definition at line 42 of file texmacs_interface.cpp.

References car(), cdr(), cons(), entries(), identifiers_for_completion, is_nil(), N(), output_completion(), starts(), and strings_for_completion.

                              {
  list<string> matches, tomatch;
  string name;
  tomatch = identifiers_for_completion
      * as<list<string> > (list<generic> (entries (strings_for_completion)));
  while (!is_nil (tomatch)) {
    name = car (tomatch);
    tomatch = cdr (tomatch);
    if (starts (name, text))
      matches = cons (name (N(text), N(name)), matches);
  }
  output_completion (text, matches);
}

static char** mmx::complete	(	const char *	text,
		int(obj->lex_start)	,
		int	end
	)			[static]

Definition at line 262 of file terminal_interface.cpp.

References completion_generator().

                                                {
  char **matches;

#if defined(RL_VERSION_MAJOR) && RL_VERSION_MAJOR >= 4
  rl_completion_append_character = '\0';
#endif
  matches = (char **)NULL;
  matches = rl_completion_matches(text, completion_generator);
  return (matches);
}

vector<typename unary_return_type_helper<complete_op, C >::RET> mmx::complete

(

const vector< C, V > &

v

)

[inline]

Definition at line 1303 of file vector.hpp.

Referenced by complete_op::Complete_type(), handle_completion_request(), complete_op::set_op(), and shell_terminal_input().

                                                 {
  return as<Completed_vector> (unary_map<complete_op> (v)); }

static char* mmx::completion_generator	(	const char *	text,
		int	state
	)			[static]

Definition at line 210 of file terminal_interface.cpp.

References as_charp(), car(), cdr(), dot(), duplicate(), entries(), free_charp(), identifiers_for_completion, is_nil(), and strings_for_completion.

Referenced by complete().

                                                   {
  static nat text_len;
  static list<string> current_list;
  iterator<string> iter;
  string name;
  char *tmp, *copiedname;
  /* If this is a new word to complete, initialize now.  This includes
     saving the length of TEXT for efficiency, and initializing the index
     variable to 0. */
  if (!state) {
    rl_special_prefixes = "$";
    current_list = identifiers_for_completion
      * as<list<string> > (list<generic> (entries (strings_for_completion)));
    text_len = strlen (text);
  }
  
  /* Return the next name which partially matches from the command list. */
  while (!is_nil(current_list)) {
    name = car (current_list);
    current_list = cdr (current_list);
    tmp = as_charp (name);
    if (strncmp (tmp, text, text_len) == 0) {
      // Alloc memory for copiedname with malloc
      copiedname = duplicate (tmp);
      free_charp (tmp);
      // Readline frees the strings when it has finished with them.
      return copiedname;
    }
    else { // Completion of members of a class, such as z.re
      int dot;
      for (dot= text_len-1; dot>=0 && text[dot] != '.'; dot--);
      if (dot >= 0 && strncmp (text + dot, tmp, text_len - dot) == 0) {
        char* r= (char*) malloc (dot + strlen (tmp) + 1);
        strncpy (r, text, dot);
        strcpy  (r + dot, tmp);
        free_charp (tmp);
        return r;
      }
      else free_charp (tmp);
    }
  }

  /* If no names matched, then return NULL. */
  return ((char *)NULL);
}

double mmx::complexity

(

const table< C, T, V > &

t

)

[inline]

Definition at line 185 of file table.hpp.

                                               {
  return t->complexity (); }

double mmx::complexity

(

const cache< C, T > &

c

)

[inline]

Definition at line 63 of file cache.hpp.

Referenced by symbol_rep< vector< generic >, exact_eq_table >::complexity_entries().

                                               {
  return complexity (*c); }

double mmx::complexity_entries

(

)

[inline]

Definition at line 138 of file symbol.hpp.

References symbol_rep< C, V >::complexity_entries().

                                                  {
  return symbol_rep<C>::complexity_entries (); }

port component	(	const port &	p,
		const string &	name
	)

Definition at line 107 of file port.cpp.

References inside().

Referenced by GLUE_21().

                                                   {
  return inside (p)->component (name); }

vector< syntactic > components

(

const syntactic &

g

)

Definition at line 86 of file syntactic.cpp.

References N().

Referenced by arguments().

                                {
  vector<syntactic> v= fill<syntactic> (N(g));
  for (nat i=0; i<N(g); i++) v[i]= g[i];
  return v;
}

routine mmx::compose	(	const routine &	fun,
		const routine &	arg
	)			[inline]

Definition at line 441 of file routine.hpp.

References compose(), and vec().

                                                                {
  return compose (fun, vec (arg)); }

routine compose	(	const routine &	fun,
		const vector< routine > &	args
	)

Definition at line 166 of file routine.cpp.

References exact_eq(), exact_neq(), GEN_IDENTITY, and N().

                                                          {
  // WARNING: the signature of the result is not necessarily correct
  // when simplifying with "fake identity functions", but that does not
  // matter for the application to overloading
  if (exact_eq (fun->name, GEN_IDENTITY) && N(args) == 1)
    return args [0];
  for (nat i=0; i<N(args); i++) {
    if (exact_neq (args[i]->name, GEN_IDENTITY))
      return new composed_routine_rep (fun, args);
  }
  return fun;
}

generic compose	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 698 of file generic.cpp.

References current_ev, and GEN_COMPOSE.

Referenced by compose(), reverse_op::diff_op(), compose_op::diff_op(), compose_op::op(), and compose_op::set_op().

                                                       {
  return current_ev->apply (GEN_COMPOSE, x1, x2); }

port composite_port	(	const vector< port > &	ps,
		const vector< string > &	names
	)

Definition at line 129 of file composite_port.cpp.

References ASSERT, and N().

                                                                     {
  ASSERT (N(ps) == N(names), "lengths do not match");
  return (port_rep*) new composite_port_rep (ps, names);
}

port composite_port

(

const vector< port > &

ps

)

Definition at line 135 of file composite_port.cpp.

References as_string(), N(), and n.

Referenced by GLUE_7(), and pipe_port().

                                        {
  nat i, n= N(ps);
  vector<string> names= fill<string> (n);
  for (i=0; i<n; i++) names[i]= as_string (i);
  return composite_port (ps, names);
}

compound mmx::compound_apply	(	const compound &	f,
		const vector< generic > &	v
	)			[inline]

Definition at line 75 of file mmc_glue.hpp.

References cons().

                                                             {
  return compound (cons (as<generic> (f), v));
}

vector< generic > compound_to_vector

(

const generic &

g

)

Definition at line 17 of file compound.cpp.

References as_vector().

Referenced by add_modes(), append(), routine_primitive_rep::apply(), as_texmacs(), cdr(), concat_append(), cons(), flatten(), generic_components(), list_map(), make_document(), range(), scheme_to_tm(), texmacs_to_scheme(), un_try_catch(), vector_map(), and WRAP_INDIRECT_IMPL().

                                      {
  return as_vector (as<compound> (g));
}

generic mmx::concat	(	const generic &	g1,
		const generic &	g2,
		const generic &	g3,
		const generic &	g4
	)			[inline]

Definition at line 125 of file mmx_printer.cpp.

References gen().

                                                             {
  return gen ("$concat", g1, g2, g3, g4); }

generic mmx::concat	(	const generic &	g1,
		const generic &	g2,
		const generic &	g3
	)			[inline]

Definition at line 122 of file mmx_printer.cpp.

References gen().

                                          {
  return gen ("$concat", g1, g2, g3); }

generic mmx::concat	(	const generic &	g1,
		const generic &	g2
	)			[inline]

Definition at line 120 of file mmx_printer.cpp.

References gen().

                                                             {
  return gen ("$concat", g1, g2); }

generic mmx::concat

(

)

[inline]

Definition at line 118 of file mmx_printer.cpp.

References gen().

                         {
  return gen ("$concat"); }

generic mmx::concat

(

const vector< generic > &

v

)

[inline]

Definition at line 116 of file mmx_printer.cpp.

References gen().

                                                 {
  return gen ("$concat", v); }

void mmx::concat_append	(	vector< generic > &	v,
		const generic &	g
	)

Definition at line 222 of file mmx_texmacs.cpp.

References compound_to_vector(), gen(), is_func(), literal_to_string(), and N().

Referenced by as_texmacs().

                                                     {
  if (g == "");
  else if (is_func (g, "$concat")) {
    vector<generic> w= compound_to_vector (g);
    for (nat i=1; i<N(w); i++) concat_append (v, w[i]);
  }
  else if (N(v) == 0) v << g;
  else if (is<literal> (v[N(v)-1]) && is<literal> (g))
    v[N(v)-1]= generic (literal_to_string (v[N(v)-1]) * literal_to_string (g));
  else if (is_func (v[N(v)-1], "$lprime", 1) && is_func (g, "$lprime", 1)) {
    generic p (literal_to_string (v[N(v)-1][1]) * literal_to_string (g[1]));
    v[N(v)-1]= gen ("$lprime", p);
  }
  else if (is_func (v[N(v)-1], "$rprime", 1) && is_func (g, "$rprime", 1)) {
    generic p (literal_to_string (v[N(v)-1][1]) * literal_to_string (g[1]));
    v[N(v)-1]= gen ("$rprime", p);
  }
  else v << g;
}

U mmx::concrete_to_abstract

(

const T &

g

)

[inline]

Definition at line 182 of file mmc_glue.hpp.

                                  {
  return any_as_generic<T> (g);
}

generic mmx::concrete_vector	(	const vector< generic > &	abst,
		const generic &	conc
	)			[inline]

Definition at line 304 of file vector.hpp.

                                                                   {
  return conc->make_concrete_vector (as<generic> (abst));
}

vector<C,V> mmx::conj

(

const vector< C, V > &

v

)

[inline]

Definition at line 1343 of file vector.hpp.

{ return unary_map<conj_op> (v); }

syntactic conj

(

const syntactic &

g1

)

Definition at line 454 of file syntactic.cpp.

References GEN_CONJ, and syn().

{ return syn (GEN_CONJ, g1); }

generic conj

(

const generic &

x1

)

Definition at line 738 of file generic.cpp.

References current_ev, and GEN_CONJ.

                                 {
  return current_ev->apply (GEN_CONJ, x1); }

C mmx::conj

(

const C &

x

)

[inline]

Definition at line 718 of file defaults.hpp.

Referenced by conj_op::op(), and conj_op::set_op().

{ return x; }

static port connect_to_server

(

)

[static]

Definition at line 57 of file storage.cpp.

References ASSERT, error_flag(), file_exists(), path_name(), socket_client_port(), system(), and wait_port_event().

                     {
  port server= socket_client_port ("localhost", 3124);
  if (error_flag (server)) {
    ASSERT (file_exists (path_name ("$PATH", "storage_server")),
            "storage server cannot be started");
    system ("storage_server&");
    nat pause= 1;
    while (error_flag (server)) {
      (void) wait_port_event (pause);
      server= socket_client_port ("localhost", 3124);
      pause *= 2;
      ASSERT (pause < 5000, 
              "storage server cannot be started");
    }
  }
  binary_write<string> (server, "connect");
  return server;
}

vector<C,V> mmx::cons	(	const C &	c,
		const vector< C, V > &	v
	)			[inline]

Definition at line 650 of file vector.hpp.

References ASSERT, C, CF(), copy(), is_non_scalar(), N(), n, seg(), and Vector.

                                   {
  typedef implementation<vector_linear,V> Vec;
  ASSERT (is_non_scalar (v), "non-scalar vector expected");
  nat n= N(v);
  nat l= aligned_size<C,V> (n+1);
  C* a= mmx_formatted_new<C> (l, CF(v));
  a[0]= c;
  Vec::copy (a+1, seg (v), n);
  return Vector (a, n+1, l, CF(v));
}

list< C > cons	(	const C &	c,
		const list< C > &	l
	)			[inline]

Return a new list with head and tail l.

Definition at line 139 of file list.hpp.

References List.

{ return List (c, l); }

generic cons	(	const generic &	g1,
		const generic &	g2,
		const generic &	g3
	)

Definition at line 40 of file generic_utils.cpp.

References append(), compound_to_vector(), and vector_to_compound().

                                                               {
  return vector_to_compound (append (vec<generic> (g1, g2),
                                     compound_to_vector (g3)));
}

generic cons	(	const generic &	g1,
		const generic &	g2
	)

Definition at line 35 of file generic_utils.cpp.

References compound_to_vector(), and vector_to_compound().

Referenced by alias_tuple_access(), alias_tuple_reset(), append(), apply(), default_routine_rep::apply(), binary_helper< list< C > >::assemble(), bigop(), complete(), compound_apply(), copy(), as_helper< list< T >, list< F > >::cv(), gen(), generic_apply(), GLUE_10(), GLUE_11(), GLUE_12(), insert(), list_map_1(), list_map_2(), list_map_n(), literal_apply(), map(), merge(), range(), binary_helper< list< C > >::read(), table_rep< C, T, V >::resize(), reverse(), select_evaluator(), table_rep< C, T, V >::set(), set_as(), split(), ttable_access(), ttable_contains(), ttable_reset(), and vector_cons().

                                            {
  return vector_to_compound (cons (g1, compound_to_vector (g2)));
}

generic construct

(

const generic &

x

)

Definition at line 214 of file generic.cpp.

References current_ev.

                             {
  return current_ev->construct (x);
}

generic construct

(

const float &

x

)

Definition at line 209 of file generic.cpp.

References current_ev.

                           {
  return current_ev->construct (as<generic> ((double) x));
}

generic construct

(

const double &

x

)

Definition at line 204 of file generic.cpp.

References current_ev.

                            {
  return current_ev->construct (as<generic> (x));
}

generic construct

(

const nat &

i

)

Definition at line 199 of file generic.cpp.

References current_ev.

                         {
  return current_ev->construct (as<generic> ((int) i));
}

generic construct

(

const int &

i

)

Definition at line 194 of file generic.cpp.

References current_ev.

Referenced by generic_concrete_rep< C >::acc_construct(), and as_generic().

                         {
  return current_ev->construct (as<generic> (i));
}

bool mmx::contains	(	const vector< C, V > &	v,
		const C &	x
	)			[inline]

Definition at line 713 of file vector.hpp.

References find(), and N().

                                       {
  return find (v, x) < ((int) N(v));
}

bool mmx::contains	(	const table< C, T, V > &	t,
		const T &	x
	)			[inline]

Definition at line 180 of file table.hpp.

                                                       {
  return t->contains (x); }

bool mmx::contains	(	const table< C, T, V > &	t,
		const K &	x
	)			[inline]

Definition at line 169 of file table.hpp.

                                                        {
  return t->contains (as<T> (x)); }

bool mmx::contains	(	const new_table< C, T, V > &	t,
		const T &	x
	)			[inline]

Definition at line 202 of file new_table.hpp.

                                                       {
  return t->contains (x); }

bool mmx::contains	(	const new_table< C, T, V > &	t,
		const K &	x
	)			[inline]

Definition at line 191 of file new_table.hpp.

                                                        {
  return t->contains (as<T> (x)); }

bool mmx::contains	(	const list< C > &	l,
		const C &	x
	)			[inline]

Definition at line 327 of file list.hpp.

References car(), cdr(), and is_nil().

                                     {
  if (is_nil (l)) return false;
  else return car (l) == x || contains<C> (cdr (l), x);
}

bool mmx::contains	(	const cache< C, T > &	c,
		const T &	x
	)			[inline]

Definition at line 72 of file cache.hpp.

Referenced by as_texmacs(), call_glue(), dl_link(), dl_linked(), GLUE_10(), GLUE_17(), GLUE_18(), GLUE_19(), insert(), new_type_id(), serialize(), source_has_exact(), source_link(), source_locate(), and ttable_contains().

                                                       {
  return contains (*c, x); }

generic mmx::contents

(

const dynamic &

d

)

[inline]

Definition at line 90 of file dynamic.hpp.

References inside().

Referenced by GLUE_2(), and shell_save_session().

{ return inside (d) -> val; }

generic convert	(	const generic &	from,
		const generic &	to
	)

Definition at line 286 of file generic.cpp.

References current_ev, GEN_CONVERT, is_nil(), same_type(), and type_name().

                                                 {
  if (same_type (from, to)) return from;
  routine* cv= to->acc_construct (from->acc_id ());
  if (cv != NULL && !is_nil (*cv)) return (*cv) (from);
  return current_ev->apply (GEN_CONVERT, from, type_name (to));
}

string mmx::copy

(

const string &

obj->lex_string

)

Definition at line 362 of file string.cpp.

References N(), and string::rep.

                       {
  register nat i, n= N(s);
  string r (n);
  for (i=0; i<n; i++) r.rep->a[i]= s.rep->a[i];
  return r;
}

vector<C,V> mmx::copy

(

const vector< C, V > &

v

)

[inline]

Definition at line 1043 of file vector.hpp.

                                   {
  return unary_map<id_op> (v); }

format<C> mmx::copy

(

const format< C > &

x

)

[inline]

Definition at line 206 of file type_props.hpp.

{ return format<C> (x); }

table<C,T,V> mmx::copy

(

const table< C, T, V > &

t

)

[inline]

Definition at line 488 of file table.hpp.

References busy(), CF2(), entries(), I(), and Table.

                      {
  Table r (I(t), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    r[*it]= t[*it];
  return r;
}

new_table<C,T,V> mmx::copy

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 559 of file new_table.hpp.

References busy(), CF2(), entries(), I(), and Table.

                      {
  Table r (I(t), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    r[*it]= t[*it];
  return r;
}

list<C> mmx::copy

(

const list< C > &

l

)

[inline]

Definition at line 276 of file list.hpp.

References car(), cdr(), cons(), and is_nil().

                     {
  if (is_nil (l)) return l;
  return cons (car (l), cdr (l));
}

iterator< C > copy

(

const iterator< C > &

it

)

[inline]

Definition at line 100 of file iterator.hpp.

{ return it.rep->clone (); }

heap< C > copy

(

const heap< C > &

h

)

[inline]

Definition at line 247 of file heap.hpp.

References C, and Heap.

                     {
  C* b= mmx_new<C> (h->l);
  for (nat i=0; i<h->n; i++) b[i]= h->a[i];
  return Heap (b, h->n, h->l, h->compare);
}

void* mmx::copy

(

C *

p

)

[inline]

Definition at line 165 of file defaults.hpp.

{ return p; }

double mmx::copy

(

double

c

)

[inline]

Definition at line 163 of file defaults.hpp.

{ return c; }

float mmx::copy

(

float

c

)

[inline]

Definition at line 162 of file defaults.hpp.

{ return c; }

long long unsigned int mmx::copy

(

long long unsigned int

c

)

[inline]

Definition at line 160 of file defaults.hpp.

{ return c; }

long long int mmx::copy

(

long long int

c

)

[inline]

Definition at line 159 of file defaults.hpp.

{ return c; }

long unsigned int mmx::copy

(

long unsigned int

c

)

[inline]

Definition at line 158 of file defaults.hpp.

{ return c; }

long int mmx::copy

(

long int

c

)

[inline]

Definition at line 157 of file defaults.hpp.

{ return c; }

unsigned int mmx::copy

(

unsigned int

c

)

[inline]

Definition at line 156 of file defaults.hpp.

{ return c; }

int mmx::copy

(

int

c

)

[inline]

Definition at line 155 of file defaults.hpp.

{ return c; }

short unsigned int mmx::copy

(

short unsigned int

c

)

[inline]

Definition at line 154 of file defaults.hpp.

{ return c; }

short int mmx::copy

(

short int

c

)

[inline]

Definition at line 153 of file defaults.hpp.

{ return c; }

unsigned char mmx::copy

(

unsigned char

c

)

[inline]

Definition at line 152 of file defaults.hpp.

{ return c; }

signed char mmx::copy

(

signed char

c

)

[inline]

Definition at line 151 of file defaults.hpp.

{ return c; }

char mmx::copy

(

char

c

)

[inline]

Definition at line 150 of file defaults.hpp.

{ return c; }

chain<C> mmx::copy

(

const chain< C > &

c

)

[inline]

Definition at line 195 of file chain.hpp.

References Chain, is_nil(), left(), middle(), and right().

                      {
  if (is_nil (c)) return c;
  return Chain (left (c), middle (c), right (c));
}

C mmx::copy

(

const C &

x

)

[inline]

Definition at line 178 of file basix.hpp.

Referenced by add_modes(), append(), binary_test(), composed_routine_rep::composed_routine_rep(), cons(), duplicate(), inside_append(), locase_first(), copy_op::op(), vector< C, V >::operator<<(), ordered_product(), ordered_sum(), range(), vector_rep< observer, V >::resize(), list< C >::secure(), chain< C >::secure(), copy_op::set_op(), unary_hash(), upcase_first(), vector< observer >::vector(), vector_sort(), vector_sort_leq(), and binary_helper< heap< C > >::write().

                                         {
  assert (false); // object should really be copied before access
  return x; }

vector<C,V> mmx::cos

(

const vector< C, V > &

v

)

[inline]

Definition at line 1180 of file vector.hpp.

{ return unary_map<cos_op> (v); }

table<C,T,V> mmx::cos

(

const table< C, T, V > &

t

)

[inline]

Definition at line 701 of file table.hpp.

{ return unary_map<cos_op> (t); }

syntactic cos

(

const syntactic &

g

)

Definition at line 430 of file syntactic.cpp.

References GEN_COS, and syn().

{ return syn (GEN_COS, g); }

new_table<C,T,V> mmx::cos

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 772 of file new_table.hpp.

{ return unary_map<cos_op> (t); }

generic cos

(

const generic &

x1

)

Definition at line 445 of file generic.cpp.

References ACC_COS, ACC_UNARY, current_ev, and GEN_COS.

                        {
  ACC_UNARY (ACC_COS, x1);
  return current_ev->apply (GEN_COS, x1);
}

double cos

(

const double &

x

)

[inline]

Definition at line 49 of file double.hpp.

Referenced by cos_sin(), tan_op::diff_op(), sin_op::diff_op(), cos_op::op(), trig_op::op(), cos_op::op_init(), cos_op::set_op(), and trig().

{ return std::cos (x); }

vector<C> mmx::cos_sin

(

const C &

x

)

[inline]

Definition at line 1407 of file vector.hpp.

References cos(), sin(), and vec().

Referenced by tan_op::def(), sin_op::def(), and cos_op::def().

                                                    {
  return vec (cos (x), sin (x)); }

syntactic cosh

(

const syntactic &

g

)

Definition at line 436 of file syntactic.cpp.

References GEN_CH, and syn().

{ return syn (GEN_CH, g); }

generic cosh

(

const generic &

x1

)

Definition at line 481 of file generic.cpp.

References ACC_COSH, ACC_UNARY, and exp().

                         {
  ACC_UNARY (ACC_COSH, x1);
  return (exp (x1) + exp (-x1)) / 2;
}

double cosh

(

const double &

x

)

[inline]

Definition at line 52 of file double.hpp.

References cosh().

{ return std::cosh (x); }

C mmx::cosh

(

const C &

x

)

[inline]

Definition at line 589 of file defaults.hpp.

References exp(), and promote().

Referenced by cosh(), tanh_op::diff_op(), sinh_op::diff_op(), cosh_op::op(), cosh_op::op_init(), and cosh_op::set_op().

                                                {
  return (exp (x) + exp (-x)) / promote (2, x); }

double mmx::cot

(

const double &

x

)

[inline]

Definition at line 69 of file double.hpp.

{ return std::isfinite (x); }

double mmx::coth

(

const double &

x

)

[inline]

Definition at line 70 of file double.hpp.

{ return std::isfinite (x); }

generic mmx::CPP_ACCESS

(

"."

[]

)

generic mmx::CPP_AND

(

"and"

)

generic mmx::CPP_APPLY

(

".()"

)

generic mmx::CPP_ARROW

(

"->"

)

generic mmx::CPP_ASSIGN

(

)

generic mmx::CPP_BEGIN

(

"begin"

)

generic mmx::CPP_BITWISE_AND

(

"/\\"

)

generic mmx::CPP_BITWISE_OR

(

"\\/"

)

generic mmx::CPP_BITWISE_XOR

(

"xor"

)

generic mmx::CPP_BRACKETS

(

"()"

)

generic mmx::CPP_BREAK

(

"break"

)

generic mmx::CPP_CAST	(	":	,
		"
	)

generic mmx::CPP_CATCH

(

"catch"

)

generic mmx::CPP_COMPLEMENT

(

"~"

)

generic mmx::CPP_CONST

(

"const"

)

generic mmx::CPP_CONSTRUCT

(

"construct"

)

generic mmx::CPP_CONSTRUCTOR

(

"constructor"

)

generic mmx::CPP_CONTINUE

(

"continue"

)

generic mmx::CPP_DEFINE

(

)

generic mmx::CPP_DELETE

(

"delete"

)

string cpp_demangle

(

const char *

name

)

Definition at line 303 of file cpp_printer.cpp.

References ASSERT, and size().

Referenced by flatten().

                                      {
  size_t size= 4096;
  char* buf= (char*) malloc (size);
  int status;
  char* res= abi::__cxa_demangle (name, buf, &size, &status);
  string ans (res); free ((void*) res);
  ASSERT (status==0, "invalid C++ type name");
  return ans;
}

generic mmx::CPP_DESTRUCTOR

(

"destructor"

)

generic mmx::CPP_DO

(

"do"

)

generic mmx::CPP_DOT

(

"."

)

generic mmx::CPP_ELSE

(

"else"

)

generic mmx::CPP_EQUAL

(

)

generic mmx::CPP_EXIT

(

"exit"

)

generic mmx::CPP_EXTERN

(

"extern"

)

generic mmx::CPP_FOR

(

"for"

)

generic mmx::CPP_GTR	(	"	,
		"
	)

generic mmx::CPP_GTREQ

(

">="

)

generic mmx::CPP_GTRGTR

(

">>"

)

generic mmx::CPP_GTRGTREQ

(

)

Referenced by opname_table().

string cpp_identifier

(

const string &

s

)

Definition at line 1234 of file cpp_printer.cpp.

References N().

                                 {
  bool ok= true;
  for (nat i=0; i<N(s); i++) {
    if (s[i] >= 'a' && s[i] <= 'z') ok= false;
    if (s[i] >= 'A' && s[i] <= 'Z') ok= false;
    if (s[i] >= '0' && s[i] <= '9') ok= false;
    if (s[i] == '#' || s[i] == '?' ||
        s[i] == '.' || s[i] == '@' ||
        s[i] == ':' || s[i] == '$')
      ok= false;
  }
  if (ok) return s;

  string r;
  for (nat i=0; i<N(s); i++)
    switch (s[i]) {
    case '#' : r << "SH"; break;
    case '$' : r << "SS"; break;
    case '?' : r << "PR"; break;
    case '.' : r << "DO"; break;
    case '@' : r << "OA"; break;
    case ':' : r << "SC"; break;
    case '+' : r << "PP"; break;
    case '-' : r << "MM"; break;
    case '*' : r << "TT"; break;
    case '/' : r << "DD"; break;
    case '<' : r << "LT"; break;
    case '=' : r << "EE"; break;
    case '>' : r << "GT"; break;
    case '!' : r << "NO"; break;
    case '(' : r << "LB"; break;
    case ')' : r << "RB"; break;
    case '[' : r << "LQ"; break;
    case '\\': r << "BS"; break;
    case ']' : r << "RQ"; break;
    case '^' : r << "PW"; break;
    case '~' : r << "EQ"; break;
    default: r << s[i]; break;
    }
  return r;
}

generic mmx::CPP_IF

(

"if"

)

generic mmx::CPP_INHERIT

(

"inherit"

)

generic mmx::CPP_INITIALIZE

(

"initialize"

)

generic mmx::CPP_INLINE

(

"inline"

)

generic mmx::CPP_LESS

(

)

generic mmx::CPP_LESSEQ

(

"<="

)

generic mmx::CPP_LESSLESS

(

"<<"

)

generic mmx::CPP_LESSLESSEQ

(

)

Referenced by opname_table().

generic mmx::CPP_MINUS

(

"-"

)

generic mmx::CPP_MINUS_ASSIGN

(

)

generic mmx::CPP_MOD

(

"%"

)

generic mmx::CPP_MOD_ASSIGN

(

)

generic mmx::CPP_NAMESPACE

(

"namespace"

)

generic mmx::CPP_NEW

(

"new"

)

generic mmx::CPP_NOT

(

"!"

)

generic mmx::CPP_OR

(

"or"

)

generic mmx::CPP_OVER

(

"/"

)

generic mmx::CPP_OVER_ASSIGN

(

)

generic mmx::CPP_PLUS

(

"+"

)

generic mmx::CPP_PLUS_ASSIGN

(

)

generic mmx::CPP_POSTDEC

(

".--"

)

generic mmx::CPP_POSTINC

(

".++"

)

generic mmx::CPP_PREDEC

(

"--."

)

generic mmx::CPP_PREINC

(

"++."

)

generic mmx::CPP_PUBLIC

(

"public"

)

generic mmx::CPP_RETURN

(

"return"

)

generic mmx::CPP_SCOPE

(

"::"

)

generic mmx::CPP_SPECIALIZE

(

"specialize"

)

generic mmx::CPP_STATIC

(

"static"

)

generic mmx::CPP_STRUCT

(

"struct"

)

generic mmx::CPP_SWITCH

(

"switch"

)

generic mmx::CPP_TEMPLATE

(

"template"

)

generic mmx::CPP_THROW

(

"raise"

)

generic mmx::CPP_TIMES

(

"*"

)

generic mmx::CPP_TIMES_ASSIGN

(

)

generic mmx::CPP_TRY

(

"try"

)

generic mmx::CPP_TYPE

(

":"

)

generic mmx::CPP_TYPEDEF

(

"typedef"

)

generic mmx::CPP_UNALIAS

(

"unalias"

)

generic mmx::CPP_UNEQUAL

(

)

generic mmx::CPP_UNFUNCTION

(

"unfunction"

)

generic mmx::CPP_UNPOINTER

(

"unpointer"

)

generic mmx::CPP_USING

(

"using"

)

generic mmx::CPP_VERBATIM

(

"verbatim"

)

generic mmx::CPP_VIRTUAL

(

"virtual"

)

generic mmx::CPP_WHILE

(

"while"

)

generic mmx::CPP_XOR

(

"^^"

)

double mmx::csc

(

const double &

x

)

[inline]

Definition at line 69 of file double.hpp.

{ return std::isfinite (x); }

double mmx::csch

(

const double &

x

)

[inline]

Definition at line 70 of file double.hpp.

{ return std::isfinite (x); }

generic decexp2	(	const generic &	x1,
		const xint &	x2
	)

Definition at line 791 of file generic.cpp.

References current_ev.

                                                    {
  return current_ev->apply ("decrease_exponent", x1, as<generic> ((int) x2)); }

void decexp2	(	double &	x,
		const double &	y,
		const S &	z
	)			[inline]

Definition at line 116 of file double.hpp.

{ x= ldexp (y, -z); }

double decexp2

(

const double &

x

)

[inline]

Definition at line 112 of file double.hpp.

{ return ldexp (x, -1); }

double decexp2	(	const double &	x,
		const S &	y
	)			[inline]

Definition at line 110 of file double.hpp.

{ return ldexp (x, -y); }

void mmx::decexp2	(	C &	x,
		const C &	y,
		const S &	z
	)			[inline]

Definition at line 338 of file defaults.hpp.

{ x= y >> z; }

C mmx::decexp2

(

const C &

x

)

[inline]

Definition at line 334 of file defaults.hpp.

{ return decexp2<C,xint> (x, 1); }

C mmx::decexp2	(	const C &	x,
		const S &	y
	)			[inline]

Definition at line 332 of file defaults.hpp.

Referenced by GLUE_50(), decexp2_op::op(), set_accuracy(), decexp2_op::set_op(), and make_interval_helper< B, C >::val().

{ return x >> y; }

void decexp2_assign	(	double &	x,
		const S &	y
	)			[inline]

Definition at line 114 of file double.hpp.

{ x= ldexp (x, -y); }

void mmx::decexp2_assign	(	C &	x,
		const S &	y
	)			[inline]

Definition at line 336 of file defaults.hpp.

Referenced by decexp2_op::set_op().

{ x >>= y; }

string decode_name

(

const string &

name

)

Definition at line 320 of file system.cpp.

References _from_dos_to_unix(), get_env(), N(), and starts().

Referenced by eval_system(), file_exists(), follow_link(), get_attributes(), input_file_port(), input_output_file_port(), load(), load_directory(), mkdir(), output_file_port(), and save().

                                 {
  if (name == "~") return _from_dos_to_unix (get_env ("HOME"));
  if (starts (name, "~/"))
    return _from_dos_to_unix (get_env ("HOME")) * "/" * name (2, N(name));
  if (starts (name, "$")) {
    nat i;
    for (i=0; i<N(name); i++)
      if (name[i] == '/') break;
    string r= _from_dos_to_unix (get_env (name (1, i)));
    if (i == N(name)) return r;
    return r * "/" * name (i+1, N(name));
  }
  return name;
}

nat mmx::default_aligned_size

(

nat

n

)

[inline]

Definition at line 76 of file vector_naive.hpp.

References V.

                             {
  typedef typename vector_variant_helper<C>::VV V;
  typedef implementation<vector_allocate,V> Vec;
  return aligned_size<C,V> (n);
}

C mmx::default_cst

(

const format< C > &

fm

)

[inline]

Definition at line 921 of file type_props.hpp.

References C, get_sample(), and set_default().

                                  {
  C r= get_sample (fm); set_default (r); return r; }

C mmx::default_cst

(

)

[inline]

Definition at line 892 of file type_props.hpp.

References C, and set_default().

Referenced by make_cache_1(), make_cache_3(), make_mmx_new_table(), and make_mmx_table().

{ C r; set_default (r); return r; }

routine default_routine

(

const generic &

name

)

Definition at line 218 of file routine.cpp.

References as(), get_alias(), and is().

Referenced by list_apply(), list_map(), list_sort(), vector_apply(), vector_map(), and vector_sort_leq().

                                      {
  if (is<routine> (name))
    return as<routine> (name);
  if (is<alias<routine> > (name))
    return get_alias (as<alias<routine> > (name));
  return new default_routine_rep (name);
}

void mmx::define	(	const generic &	name,
		D(*)(const S1 &, const S2 &, const S3 &, const S4 &, const S5 &)	fun
	)			[inline]

Definition at line 217 of file glue.hpp.

References current_ev, and quintary_routine().

                                                              {
  current_ev->overload (name, as<generic> (quintary_routine (name, fun)));
}

void mmx::define	(	const generic &	name,
		D(*)(const S1 &, const S2 &, const S3 &, const S4 &)	fun
	)			[inline]

Definition at line 209 of file glue.hpp.

References current_ev, and quaternary_routine().

                                                   {
  current_ev->overload (name, as<generic> (quaternary_routine (name, fun)));
}

void mmx::define	(	const generic &	name,
		D(*)(const S1 &, const S2 &, const S3 &)	fun
	)			[inline]

Definition at line 203 of file glue.hpp.

References current_ev, and ternary_routine().

                                                                         {
  current_ev->overload (name, as<generic> (ternary_routine (name, fun)));
}

void mmx::define	(	const generic &	name,
		D(*)(const S1 &, const S2 &)	fun
	)			[inline]

Definition at line 196 of file glue.hpp.

References accelerate(), binary_routine(), and current_ev.

                                                              {
  current_ev->overload (name, as<generic> (binary_routine (name, fun)));
  accelerate (name, fun);
}

void mmx::define	(	const generic &	name,
		D(*)(const S1 &)	fun
	)			[inline]

Definition at line 190 of file glue.hpp.

References accelerate(), current_ev, and unary_routine().

                                                   {
  current_ev->overload (name, as<generic> (unary_routine (name, fun)));
  accelerate (name, fun);
}

void mmx::define	(	const generic &	name,
		D(*)()	fun
	)			[inline]

Definition at line 185 of file glue.hpp.

References current_ev, and nullary_routine().

Referenced by define_type_helper< C >::def_type(), glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_double(), glue_dynamic(), glue_expression(), glue_int(), glue_list_generic(), glue_list_map(), glue_literal(), glue_port(), glue_routine(), glue_storage(), glue_string(), glue_syntactic(), and glue_vector_map().

                                          {
  current_ev->overload (name, as<generic> (nullary_routine (name, fun)));
}

mmx::DEFINE_BINARY_FORMAT_2

(

pair

)

mmx::DEFINE_BINARY_FORMAT_3

(

table

)

mmx::DEFINE_BINARY_FORMAT_3

(

new_table

)

void mmx::define_constant	(	const generic &	name,
		const D &	x
	)			[inline]

Definition at line 170 of file glue.hpp.

References current_ev.

                                                  {
  current_ev->set (name, as<generic> (x));
}

void mmx::define_constructor

(

generic(*)(const D &)

fun

)

[inline]

Definition at line 175 of file glue.hpp.

References current_ev, GEN_NEW, and unary_routine().

                                               {
  current_ev->overload (GEN_NEW, as<generic> (unary_routine (GEN_NEW, fun)));
}

void mmx::define_converter	(	const generic &	name,
		C(*)(const S1 &)	f,
		nat	p
	)			[inline]

Definition at line 223 of file glue.hpp.

References accelerate_converter(), current_ev, gen(), GEN_INTO, and unary_routine().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_document(), glue_double(), glue_list_generic(), glue_routine(), and glue_syntactic().

                                                                  {
  generic con= gen (GEN_INTO, type_name<S1> (), type_name<C> ());
  routine fun= unary_routine (con, f);
  current_ev->overload (name, as<generic> (fun), p);
  accelerate_converter (name, f);
}

void define_prerequisites

(

)

Definition at line 39 of file glue.cpp.

References fall_back_equal(), fall_back_unequal(), GEN_BOOLEAN_TYPE, GEN_COMPOUND_TYPE, GEN_DOUBLE_TYPE, GEN_EQUAL, GEN_FALSE, GEN_GENERIC_TYPE, GEN_INT_TYPE, GEN_LITERAL_TYPE, GEN_MACRO_TYPE, GEN_ROUTINE_TYPE, GEN_TRUE, and GEN_UNEQUAL.

                        {
  define_type<generic> (GEN_GENERIC_TYPE);
  define_type<bool> (GEN_BOOLEAN_TYPE);
  define_type<int> (GEN_INT_TYPE);
  define_type<double> (GEN_DOUBLE_TYPE);
  define_type<literal> (GEN_LITERAL_TYPE);
  define_type<compound> (GEN_COMPOUND_TYPE);
  define_type<routine> (GEN_ROUTINE_TYPE);
  define_type<primitive> (GEN_MACRO_TYPE);
  define_constant<bool> (GEN_FALSE, false);
  define_constant<bool> (GEN_TRUE, true);
  define<bool,generic,generic> (GEN_EQUAL, fall_back_equal);
  define<bool,generic,generic> (GEN_UNEQUAL, fall_back_unequal);
}

void mmx::define_primitive	(	const generic &	name,
		generic(*)(const generic &)	fun
	)			[inline]

Definition at line 180 of file glue.hpp.

References current_ev.

                                                                        {
  current_ev->set (name, as<generic> (primitive (name, fun)));
}

mmx::DEFINE_TERNARY_FORMAT_3

(

triple

)

void mmx::define_type

(

const generic &

name

)

[inline]

Definition at line 292 of file glue.hpp.

References define_type_helper< C >::def_default(), and define_type_helper< C >::def_type().

                                  {
  define_type_helper<C>::def_type (name);
  define_type_helper<C>::def_default ();
}

void define_type_sub	(	const generic &	name,
		nat	id
	)

Definition at line 67 of file glue.cpp.

References all_type_names(), current_ev, gen(), GEN_ALL_TYPES, GEN_TYPE_ID, GEN_TYPE_NAME, is_alias_type(), and is_tuple_type().

Referenced by define_type_helper< C >::def_type(), and define_user_type().

                                              {
  current_ev->set (gen (GEN_TYPE_NAME, as<generic> (id)), name);
  current_ev->set (gen (GEN_TYPE_ID, name), as<generic> (id));
  if (!is_tuple_type (id) && !is_alias_type (id)) {
    vector<generic> all_types= all_type_names ();
    all_types << name;
    current_ev->set (gen (GEN_ALL_TYPES), as<generic> (all_types));
  }
}

mmx::DEFINE_UNARY_FORMAT_1

(

list

)

const

Definition at line 100 of file list.hpp.

                                      {
  return l.tfm (); }

mmx::DEFINE_UNARY_FORMAT_1

(

chain

)

const

Definition at line 91 of file chain.hpp.

References Format.

                                       {
  return (Format) l; }

nat define_user_type

(

const generic &

name

)

Definition at line 104 of file generic_object.cpp.

References alias_getter(), alias_setter(), alias_specializer(), binary_routine(), change_signature(), current_ev, define_type_sub(), gen(), GEN_ALIAS, GEN_ALIAS_TYPE, GEN_EQUAL, GEN_FLATTEN, GEN_GENERIC_TYPE, GEN_INTO, GEN_REWRITE, GEN_SPECIALIZE, GEN_TUPLE_TYPE, GEN_UNALIAS, GEN_UNEQUAL, new_alias_type_id(), new_tuple_type_id(), new_type_id(), object_alias(), object_equal(), object_flatten(), object_generalize_alias(), object_get_alias(), object_set_alias(), object_specialize_alias(), object_unequal(), PENALTY_INCLUSION, and unary_routine().

Referenced by get_user_type().

                                       {
  nat id= new_type_id ();
  nat alias_id= new_alias_type_id (id);
  nat tuple_id= new_tuple_type_id (id);
  define_type_sub (name, id);
  define_type_sub (gen (GEN_ALIAS_TYPE, name), alias_id);
  define_type_sub (gen (GEN_TUPLE_TYPE, name), tuple_id);

  {
    vector<nat> sig= vec<nat> (alias_id, id);
    routine r = unary_routine (GEN_ALIAS, object_alias);
    routine r2= change_signature (r, sig);
    current_ev->overload (GEN_ALIAS, as<generic> (r2), PENALTY_INCLUSION);
  }

  {
    vector<nat> sig= vec<nat> (id, alias_id);
    routine r = unary_routine (GEN_UNALIAS, object_get_alias);
    routine r2= change_signature (r, sig);
    alias_getter (alias_id, r2);  
  }

  {
    vector<nat> sig= vec<nat> (id, alias_id, id);
    routine r = binary_routine (GEN_UNALIAS, object_set_alias);
    routine r2= change_signature (r, sig);
    alias_setter (alias_id, r2);  
  }

  {
    vector<nat> sig= vec<nat> (alias_id, type_id<alias<generic> > ());
    routine r = unary_routine (GEN_SPECIALIZE, object_specialize_alias);
    routine r2= change_signature (r, sig);
    alias_specializer (id, r2);
  }

  {
    vector<nat> sig= vec<nat> (id, alias_id);
    generic cv= gen (GEN_INTO, name, gen (GEN_ALIAS_TYPE, name));
    routine r = unary_routine (cv, object_get_alias);
    routine r2= change_signature (r, sig);
    current_ev->overload (GEN_REWRITE, as<generic> (r2), PENALTY_INCLUSION);
  }

  {
    vector<nat> sig= vec<nat> (type_id<alias<generic> > (), alias_id);
    generic cv= gen (GEN_INTO, gen (GEN_ALIAS_TYPE, GEN_GENERIC_TYPE),
                               gen (GEN_ALIAS_TYPE, name));
    routine r = unary_routine (cv, object_generalize_alias);
    routine r2= change_signature (r, sig);
    current_ev->overload (GEN_REWRITE, as<generic> (r2), PENALTY_INCLUSION);
  }

  {
    vector<nat> sig= vec<nat> (type_id<bool> (), id, id);
    routine r = binary_routine (GEN_EQUAL, object_equal);
    routine r2= change_signature (r, sig);
    current_ev->overload (GEN_EQUAL, as<generic> (r2), PENALTY_INCLUSION);
  }

  {
    vector<nat> sig= vec<nat> (type_id<bool> (), id, id);
    routine r = binary_routine (GEN_UNEQUAL, object_unequal);
    routine r2= change_signature (r, sig);
    current_ev->overload (GEN_UNEQUAL, as<generic> (r2), PENALTY_INCLUSION);
  }

  {
    vector<nat> sig= vec<nat> (type_id<syntactic> (), id);
    routine r = unary_routine (GEN_FLATTEN, object_flatten);
    routine r2= change_signature (r, sig);
    current_ev->overload (GEN_FLATTEN, as<generic> (r2), PENALTY_INCLUSION);
  }

  return id;
}

syntactic denominator

(

const syntactic &

x

)

Definition at line 464 of file syntactic.cpp.

References GEN_DENOMINATOR, and syn().

                                            {
  return syn (GEN_DENOMINATOR, g1); }

generic denominator

(

const generic &

x

)

Definition at line 715 of file generic.cpp.

References current_ev, and GEN_DENOMINATOR.

Referenced by denominator_op::Denominator_type(), denominator_op::op(), and denominator_op::set_op().

                                       {
  return current_ev->apply (GEN_DENOMINATOR, x); }

vector<C,V> mmx::derive	(	const vector< C, V > &	v,
		const X &	x
	)			[inline]

Definition at line 1206 of file vector.hpp.

                                     {
  return binary_map_scalar<derive_op> (v, x); }

vector<C,V> mmx::derive

(

const vector< C, V > &

v

)

[inline]

Definition at line 1198 of file vector.hpp.

                                     {
  return unary_map<derive_op> (v); }

syntactic derive	(	const syntactic &	g,
		const syntactic &	v
	)

Definition at line 478 of file syntactic.cpp.

References GEN_DERIVE, and syn().

                                                          {
  return syn (GEN_DERIVE, g, v); }

syntactic derive

(

const syntactic &

g

)

Definition at line 476 of file syntactic.cpp.

References GEN_DERIVE, and syn().

                                      {
  return syn (GEN_DERIVE, g); }

generic derive	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 682 of file generic.cpp.

References ACC_BINARY_SCALAR, ACC_DERIVE_WRT, current_ev, derive(), GEN_CACHED_DERIVE, and MEMOIZE_BINARY.

                                             {
  ACC_BINARY_SCALAR (ACC_DERIVE_WRT, x1, v);
  MEMOIZE_BINARY (std_memoizer,generic,generic,generic,derive,x1,v,
                  current_ev->apply (GEN_CACHED_DERIVE, x1, v));
}

generic derive

(

const generic &

x1

)

Definition at line 670 of file generic.cpp.

References ACC_DERIVE, ACC_UNARY, current_ev, and GEN_CACHED_DERIVE.

                           {
  ACC_UNARY (ACC_DERIVE, x1);
  return current_ev->apply (GEN_CACHED_DERIVE, x1);
}

T mmx::derive	(	const T &	f,
		const V &	v,
		nat	n
	)			[inline]

Definition at line 725 of file defaults.hpp.

Referenced by sqrt_op::def(), derive(), trig_op::diff_op(), reverse_op::diff_op(), compose_op::diff_op(), atanh_op::diff_op(), asinh_op::diff_op(), acosh_op::diff_op(), tanh_op::diff_op(), sinh_op::diff_op(), cosh_op::diff_op(), atan_op::diff_op(), asin_op::diff_op(), acos_op::diff_op(), tan_op::diff_op(), sin_op::diff_op(), cos_op::diff_op(), log_op::diff_op(), exp_op::diff_op(), sqrt_op::diff_op(), ldiv_op::diff_op(), rdiv_op::diff_op(), div_op::diff_op(), invert_op::diff_op(), square_op::diff_op(), lmul_op::diff_op(), rmul_op::diff_op(), mul_op::diff_op(), sub_op::diff_op(), add_op::diff_op(), neg_op::diff_op(), derive_op::op(), and derive_op::set_op().

                                       {
  if (n == 0) return f;
  else return derive (derive (f, v, n-1), v);
}

void destroy

(

const updater &

u

)

Definition at line 208 of file dynamic.cpp.

References detach(), inside(), and N().

Referenced by result_observer_rep::destroy(), argument_observer_rep::destroy(), and dynamic_rep::~dynamic_rep().

                           {
  for (nat i=0; i<N(u->obs); i++) detach (u->obs[i]);
  inside (u) -> args = vector<dynamic> ();
  inside (u) -> obs  = vector<observer> ();
}

void mmx::detach

(

const observer &

o

)

Definition at line 52 of file dynamic.cpp.

References append(), ERROR, hard_eq(), N(), and range().

Referenced by destroy().

                           {
  vector<observer>& obs= o->ref->obs;
  for (nat i=0; i<N(obs); i++)
    if (hard_eq (obs[i], o)) {
      obs= append (range (obs, 0, i), range (obs, i+1, N(obs)));
      return;
    }
  ERROR ("observer not attached");
}

table<C,T,V> mmx::difference	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 784 of file table.hpp.

References busy(), CF2(), entries(), I(), and Table.

                                            {
  Table r (I (t), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    if (!V::val_op::op (u[*it], t[*it]))
      r[*it]= t[*it];
  return r;
}

new_table<C,T,V> mmx::difference	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 855 of file new_table.hpp.

References busy(), CF2(), entries(), I(), and Table.

                                            {
  Table r (I (t), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    if (!V::val_op::op (u[*it], t[*it]))
      r[*it]= t[*it];
  return r;
}

generic dilate	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 700 of file generic.cpp.

References current_ev.

                                                      {
  return current_ev->apply ("dilate", x1, x2); }

nat mmx::discrete_complexity

(

const table< C, T, V > &

t

)

[inline]

Definition at line 187 of file table.hpp.

                                                     {
  return (nat) t->complexity (); }

nat mmx::discrete_complexity

(

const cache< C, T > &

c

)

[inline]

Definition at line 65 of file cache.hpp.

Referenced by GLUE_9().

                                                     {
  return discrete_complexity (*c); }

nat mmx::discrete_complexity_entries

(

)

[inline]

Definition at line 141 of file symbol.hpp.

References symbol_rep< C, V >::complexity_entries().

                                                        {
  return (nat) symbol_rep<C>::complexity_entries (); }

storage mmx::disk_storage	(	const port &	server,
		const string &	root
	)

Definition at line 87 of file storage.cpp.

                                                      {
  return (storage_rep*) new disk_storage_rep (server, root);
}

storage disk_storage

(

const string &

root

)

Create storage which will be stored on disk in ~/.mathemagix/cache.

Definition at line 82 of file storage.cpp.

                                  {
  return (storage_rep*) new disk_storage_rep (root);
}

storage disk_storage

(

)

Definition at line 77 of file storage.cpp.

References user_dir().

Referenced by disk_storage_rep::get_branch(), and GLUE_1().

                {
  return (storage_rep*) new disk_storage_rep (user_dir () * "/cache");
}

void mmx::div	(	R &	x,
		const C1 &	y1,
		const C2 &	y2
	)			[inline]

Definition at line 60 of file operators.hpp.

Referenced by ldiv_op::set_op(), rdiv_op::set_op(), and div_op::set_op().

{ x= y1 / y2; }

T mmx::div_operator	(	const T &	x,
		const T &	y
	)			[inline]

Definition at line 34 of file operators.hpp.

{ return x/y; }

bool mmx::divides	(	const unsigned long long int &	n,
		const unsigned long long int &	m
	)			[inline]

Definition at line 574 of file int.hpp.

{

bool mmx::divides	(	const unsigned long int &	n,
		const unsigned long int &	m
	)			[inline]

Definition at line 573 of file int.hpp.

{

bool mmx::divides	(	const unsigned int &	n,
		const unsigned int &	m
	)			[inline]

Definition at line 572 of file int.hpp.

{

bool mmx::divides	(	const unsigned short int &	n,
		const unsigned short int &	m
	)			[inline]

Definition at line 571 of file int.hpp.

{

bool mmx::divides	(	const unsigned char &	n,
		const unsigned char &	m
	)			[inline]

Definition at line 570 of file int.hpp.

{

bool mmx::divides	(	const long long int &	n,
		const long long int &	m
	)			[inline]

Definition at line 561 of file int.hpp.

{ return (m % n) == 0; } \

bool mmx::divides	(	const long int &	n,
		const long int &	m
	)			[inline]

Definition at line 560 of file int.hpp.

{ return (m % n) == 0; } \

bool mmx::divides	(	const int &	n,
		const int &	m
	)			[inline]

Definition at line 559 of file int.hpp.

{ return (m % n) == 0; } \

bool mmx::divides	(	const short int &	n,
		const short int &	m
	)			[inline]

Definition at line 558 of file int.hpp.

{ return (m % n) == 0; } \

bool mmx::divides	(	const signed char &	n,
		const signed char &	m
	)			[inline]

Definition at line 557 of file int.hpp.

Referenced by GLUE_29().

{ return (m % n) == 0; } \

bool dl_exists

(

const string &

name

)

Definition at line 62 of file dlink.cpp.

References dl_find().

                               {
#ifdef BASIX_ENABLE_EMBEDDED
  (void) name;
  return true;
#else
  return dl_find (name) != "";
#endif
}

static string mmx::dl_find

(

const string &

name

)

[static]

Definition at line 40 of file dlink.cpp.

References path_name(), and prefix_dir().

Referenced by dl_exists(), and dl_link().

                             {
  string lib;
  string pdir = prefix_dir () * "/lib";
#if defined(__MINGW__) || defined(__MINGW32__)
  lib= path_name ("$LTDL_LIBRARY_PATH;$LD_LIBRARY_PATH;$PATH;$MMX_LOAD_PATH;"
                  * pdir, "libmmx" * name * "-0.dll"); // FIXME?
  if (lib != "") return lib;
#else
  lib= path_name ("$LTDL_LIBRARY_PATH:$LD_LIBRARY_PATH:$DYLD_LIBRARY_PATH:"
                  * pdir, "libmmx" * name * ".la");
  if (lib != "") return lib;
  lib= path_name ("$LTDL_LIBRARY_PATH:$LD_LIBRARY_PATH:$MMX_LOAD_PATH:"
                  * pdir, "libmmx" * name * ".so");
  if (lib != "") return lib;
  lib= path_name ("$LTDL_LIBRARY_PATH:$DYLD_LIBRARY_PATH:$MMX_LOAD_PATH:"
                  * pdir, "libmmx" * name * ".dylib");
  if (lib != "") return lib;
#endif
  return "";
}

void dl_link

(

const string &

name

)

Definition at line 123 of file dlink.cpp.

References dl_link().

                             {
  dl_link (name, "define_" * name);
}

void dl_link	(	const string &	name,
		const string &	init
	)

Definition at line 85 of file dlink.cpp.

References as_charp(), contains(), dl_find(), dl_linked_table(), done(), embedded_link, ERROR, error_message(), and free_charp().

Referenced by dl_link().

                                                 {
  table<bool,string>& done= dl_linked_table ();
  if (contains (done, name)) return;
#ifdef BASIX_ENABLE_EMBEDDED
  if (embedded_link != NULL)
    embedded_link (name);
#else
  //mmout << "Linking " << name << "\n";
  string lib= dl_find (name);
  if (lib == "") ERROR ("library " * name * " not in library path");
  if (lt_dlinit () != 0) ERROR ("lt_dlinit failed for " * name);

  //mmout << "Opening " << lib << "\n";
  char* _lib = as_charp (lib);
  lt_dlhandle handle= lt_dlopen (_lib);
  free_charp (_lib);
  if (handle == NULL) {
    //mmerr << lt_dlerror () << lf; 
    throw mmx::error_message (string (lt_dlerror ()));
  }

  //mmout << "Searching " << init << "\n";
  char* _init= as_charp (init);
  lt_ptr ptr = lt_dlsym (handle, _init);
  free_charp (_init);
  if (ptr == NULL) {
    //mmerr << lt_dlerror () << lf;
    throw mmx::error_message (string (lt_dlerror ()));
  }

  //mmout << "Initializing " << name << "\n";
  void (**define_glue) (void)= (void (**) (void)) ptr;
  (*define_glue) ();
#endif
  done[name]= true;
}

bool dl_linked

(

const string &

name

)

Definition at line 78 of file dlink.cpp.

References contains(), and dl_linked_table().

                               {
  return contains (dl_linked_table (), name);
}

static table<bool,string>& mmx::dl_linked_table

(

)

[static]

Definition at line 72 of file dlink.cpp.

Referenced by dl_link(), and dl_linked().

                   {
  static table<bool,string> t (false);
  return t;
}

string dl_option

(

)

Definition at line 31 of file dlink.cpp.

             {
#ifdef __APPLE__ // also to be used for BSD system
  return " -dynamiclib";
#else
  return " -shared";
#endif
}

string dl_suffix

(

)

Definition at line 20 of file dlink.cpp.

             {
#if defined( __APPLE__) // also to be used for BSD system
  return "dylib";
#elif defined(__MINGW__) || defined(__MINGW32__)
  return "dll";
#else
  return "so";
#endif
}

generic mmx::documentify

(

const string &

s

)

Definition at line 18 of file document.cpp.

References gen(), N(), and tokenize().

                              {
  vector<string> v= tokenize (s, "\n");
  if (N(v) == 0) return gen ("$concat");
  if (N(v) == 1) return generic (v[0]);
  vector<generic> r= vec<generic> (v[0]);
  for (nat i=1; i<N(v); i++) r << generic ("$lf") << generic (v[i]);
  return gen ("$concat", r);
}

bool done

(

const iterator< C > &

it

)

[inline]

Definition at line 98 of file iterator.hpp.

Referenced by big(), dl_link(), glue_basix(), glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_double(), glue_dynamic(), glue_expression(), glue_generic(), glue_int(), glue_list_generic(), glue_list_map(), glue_literal(), glue_port(), glue_routine(), glue_storage(), glue_string(), glue_syntactic(), and glue_vector_map().

{ return it.rep->is_done (); }

C mmx::dot	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1400 of file vector.hpp.

References ASSERT, CF(), is_non_scalar(), N(), and seg().

Referenced by completion_generator().

                                              {
  typedef implementation<vector_linear,V> Vec;
  ASSERT (is_non_scalar (v) && is_non_scalar (w),
          "non-scalar vectors expected");
  ASSERT (N(v) == N(w), "lengths don't match");
  return Vec::inn_prod (seg (v), seg (w), N(v), CF (v)); }

iterator<S> mmx::downwards_range	(	const S &	start,
		const T &	end
	)			[inline]

Definition at line 371 of file iterator.hpp.

References range_iterator().

                                               {
  return range_iterator (start, outplace_set_as<S> (end),
                         outplace_set_as<S> (-1), false);
}

static char* mmx::duplicate

(

char *

obj->lex_string

)

[static]

Definition at line 199 of file terminal_interface.cpp.

                    {
  // strdup does not work on some platforms.
  char* r= (char*) malloc (strlen (s) + 1);
  strcpy (r, s);
  return r;
}

generic mmx::duplicate

(

const generic &

x1

)

Definition at line 131 of file generic.cpp.

                              {
  return x1->duplicate_me ();
}

vector<C,V> mmx::duplicate

(

const vector< C, V > &

v

)

[inline]

Definition at line 1045 of file vector.hpp.

                                        {
  return unary_map<duplicate_op> (v); }

table<C,T,V> mmx::duplicate

(

const table< C, T, V > &

t

)

[inline]

Definition at line 611 of file table.hpp.

                                             {
  return unary_map<duplicate_op,C,T,V> (t); }

string mmx::duplicate

(

const string &

s

)

[inline]

Definition at line 108 of file string.hpp.

References copy().

{ return copy (s); }

new_table<C,T,V> mmx::duplicate

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 682 of file new_table.hpp.

                                             {
  return unary_map<duplicate_op,C,T,V> (t); }

C mmx::duplicate

(

const C &

x

)

[inline]

Definition at line 166 of file defaults.hpp.

Referenced by completion_generator(), generic_object_rep::duplicate_me(), generic_concrete_rep< C >::duplicate_me(), duplicate_op::op(), and duplicate_op::set_op().

{ return x; }

void(*) mmx::dynamic_event	(	const string &	id,
		const generic &	val
	)

unary_return_type_helper<abs_op, C >::RET mmx::elementary_error

(

const C &

x

)

[inline]

Definition at line 1075 of file type_props.hpp.

References rounding_error().

                                                                      {
  return rounding_error (x); }

generic elementary_error

(

const generic &

x

)

Definition at line 778 of file generic.cpp.

References current_ev, and GEN_ELEMENTARY_ERROR.

Referenced by elementary_error_op::Abs_type(), GLUE_54(), and elementary_error_op::set_op().

                                            {
  return current_ev->apply (GEN_ELEMENTARY_ERROR, x); }

void(*) mmx::embedded_link

(

const string &

name

)

bool mmx::ends	(	const string &	obj->lex_string,
		const string &	what
	)

Definition at line 349 of file string.cpp.

References N(), and s.

                                           {
  return N(s) >= N(what) && s (N(s) - N(what), N(s)) == what;
}

bool mmx::ends	(	const string &	s,
		const string &	what
	)

Tell if s ends with what.

Referenced by canonical_name(), GLUE_12(), scheme_to_tm(), unquote(), and write().

void * enlarge_malloc

(

register size_t

sz

)

Definition at line 51 of file fast_new.cpp.

References alloc_mem, alloc_remains, fast_chunks, MMX_ALLOC_PTR, MMX_BLOCK_SIZE, MMX_IND, and safe_malloc().

Referenced by mmx_malloc_thread_unsafe().

                                    {
  if (alloc_remains<sz) {
    alloc_mem    = (char *) safe_malloc (MMX_BLOCK_SIZE);
    alloc_remains= MMX_BLOCK_SIZE - 16;
    fast_chunks++;
  }
  register void* ptr= alloc_mem;
  if ((sz&15) == 0 && (((nat) ((uintptr_t) ptr)) & 15) != 0) {
    // NOTE: force 16 byte alignment for sizes which are multiples of 16
    nat sz2= 16 - (((nat) ((uintptr_t) ptr)) & 15);
    MMX_IND (ptr)       = MMX_ALLOC_PTR (sz2);
    MMX_ALLOC_PTR (sz2) = ptr;
    alloc_mem      += sz2;
    alloc_remains  -= sz2;
    ptr             = alloc_mem;
  }
  alloc_mem    += sz;
  alloc_remains-= sz;
  return ptr;
}

iterator<T> mmx::entries

(

const table< C, T, V > &

t

)

[inline]

Definition at line 380 of file table.hpp.

                         {
  return iterator<T> (new entries_iterator_rep<C,T,V> (t));
}

iterator<T> mmx::entries

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 453 of file new_table.hpp.

                         {
  return iterator<T> (new entries_iterator_rep<C,T,V> (t));
}

iterator<T> mmx::entries

(

const cache< C, T > &

c

)

[inline]

Definition at line 76 of file cache.hpp.

Referenced by append(), big(), binary_combine(), binary_map(), binary_map_scalar(), binary_test(), binary_test_scalar(), common(), complete(), completion_generator(), copy(), as_helper< table< D, T >, table< C, T > >::cv(), as_helper< new_table< D, T >, new_table< C, T > >::cv(), difference(), GLUE_7(), map(), operator<<(), reverse(), shell_terminal_input(), table_explode(), unary_filter(), unary_map(), unary_set(), unary_set_scalar(), wait_port_event(), binary_helper< table< C, T, V > >::write(), and binary_helper< new_table< C, T, V > >::write().

                                                 {
  return entries (*c); }

bool mmx::equal_operator	(	const T &	x,
		const T &	y
	)			[inline]

Definition at line 36 of file operators.hpp.

{ return x==y; }

bool mmx::error_flag

(

const port &

p

)

[inline]

Definition at line 98 of file port.hpp.

References inside().

Referenced by connect_to_server(), composite_port_rep::error_flag(), composite_port_rep::error_message(), GLUE_11(), save(), and var_load().

                                       {
  return inside (p)->error_flag (); }

string error_message

(

const port &

p

)

Definition at line 105 of file port.cpp.

References inside().

                                     {
  return inside (p)->error_message (); }

exception error_message

(

const string &

msg

)

[final]

Definition at line 49 of file basix.cpp.

                                  {
  return exception (msg, generic ("C++ code"));
}

exception error_message

(

const char *

msg

)

[final]

Make an exception from msg.

Definition at line 44 of file basix.cpp.

Referenced by dl_link(), composite_port_rep::error_message(), and GLUE_12().

                                {
  return exception (msg, generic ("C++ code"));
}

port mmx::error_port

(

const string &

obj->lex_string

)

Definition at line 128 of file port.cpp.

                             {
  return (port_rep*) new error_port_rep (s);
}

port mmx::error_port

(

const string &

message

)

Referenced by socket_port_rep::accept(), GLUE_8(), input_file_port(), input_output_file_port(), output_file_port(), socket_client_port(), and socket_server_port().

string mmx::escape

(

const string &

obj->lex_string

)

Definition at line 478 of file string.cpp.

References N().

                         {
  int i, n= N(s);
  string r;
  for (i=0; i<n; i++)
    if ((s[i] == '\\') || (s[i] == '\"')) r << '\\' << s[i];
    else if (s[i] == '\b') r << "\\b";
    else if (s[i] == '\t') r << "\\t";
    else if (s[i] == '\n') r << "\\n";
    else if (s[i] == '\r') r << "\\r";
    else r << s[i];
  return r;
}

string mmx::escape

(

const string &

s

)

Replace "\n", "\t", and "\b" respectively by "\\n", "\\t", and "\\b".

Referenced by quote().

C mmx::euler_cst

(

const format< C > &

fm

)

[inline]

Definition at line 930 of file type_props.hpp.

References C, promote(), and set_euler().

                                {
  C r= promote (0, fm); set_euler (r); return r; }

C mmx::euler_cst

(

)

[inline]

Definition at line 898 of file type_props.hpp.

References C, and set_euler().

{ C r; set_euler (r); return r; }

generic eval

(

const generic &

x

)

Definition at line 219 of file generic.cpp.

References current_ev.

Referenced by include(), and rebuild().

                        {
  return current_ev->eval (x);
}

string mmx::eval_system

(

const string &

obj->lex_string

)

Definition at line 273 of file system.cpp.

References ASSERT, decode_name(), init_system(), N(), system(), user_dir(), var_load(), and var_rm().

                              {
  init_system ();
  string temp= user_dir () * "/tmp/eval_system";
  system (s * " > " * temp);
  string r;
  bool flag= var_load (temp, r);
  ASSERT (var_rm (decode_name ("rm " * temp)),
          "Cannot remove file eval_system");
  if (flag) return "";
  while ((N(r)>0) && (r[N(r)-1] == '\n')) r= r (0, N(r)-1);
  return r;
}

string mmx::eval_system

(

const string &

s

)

Referenced by prefix_dir(), and sysconf_dir().

vector<typename binary_return_type_helper<evaluate_op, C , K >::RET> mmx::evaluate	(	const vector< C, V > &	v,
		const K &	x
	)			[inline]

Definition at line 1285 of file vector.hpp.

Referenced by evaluate_op::set_op().

                                                              {
  return as<Evaluated_vector> (binary_map_scalar<evaluate_op> (v, x)); }

bool mmx::exact_eq	(	const vector< C, V > &	x,
		const int &	y
	)			[inline]

Definition at line 1155 of file vector.hpp.

{

bool mmx::exact_eq	(	const vector< C, V > &	x,
		const vector< C, V > &	y
	)			[inline]

Definition at line 1152 of file vector.hpp.

{

bool mmx::exact_eq	(	const format< C > &	x,
		const format< C > &	y
	)			[inline]

Definition at line 215 of file type_props.hpp.

{ return true; }

bool mmx::exact_eq	(	const triple< C1, C2, C3 > &	x,
		const triple< C1, C2, C3 > &	y
	)			[inline]

Definition at line 59 of file triple.hpp.

{

bool mmx::exact_eq	(	const table< C, T, V > &	x,
		const table< C, T, V > &	y
	)			[inline]

Definition at line 694 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

bool exact_eq	(	const vector< syntactic > &	v,
		const vector< syntactic > &	w
	)

Definition at line 532 of file syntactic.cpp.

References exact_eq(), exact_neq(), is_a_scalar(), N(), and vector< C, V >::scalar().

                                                                       {
  if (is_a_scalar (v))
    return is_a_scalar (w) && exact_eq (v.scalar (), w.scalar ());
  if (N(v) != N(w)) return false;
  for (nat i=0; i<N(v); i++)
    if (exact_neq (v[i], w[i])) return false;
  return true;
}

bool mmx::exact_eq	(	const syntactic &	c1,
		const syntactic &	c2
	)			[inline]

Definition at line 54 of file syntactic.hpp.

References exact_eq().

                                                                {
  return exact_eq (*c1, *c2); }

bool exact_eq	(	const symbol< C, V > &	s1,
		const symbol< C, V > &	s2
	)			[inline]

Definition at line 112 of file symbol.hpp.

                                                               {
  return s1.rep == s2.rep; }

bool mmx::exact_eq	(	const string &	x,
		const string &	y
	)			[inline]

Definition at line 107 of file string.hpp.

{ return copy (s); }

bool mmx::exact_eq	(	const storage &	x,
		const storage &	y
	)			[inline]

Definition at line 55 of file storage.hpp.

{ return "storage"; }

bool mmx::exact_eq	(	const sparse_vector< C, T, V > &	x,
		const sparse_vector< C, T, V > &	y
	)			[inline]

Definition at line 169 of file sparse_vector.hpp.

{

bool mmx::exact_eq	(	const port &	x,
		const port &	y
	)			[inline]

Definition at line 63 of file port.hpp.

{ return p->expression (); }

bool mmx::exact_eq	(	const pair< C1, C2 > &	x,
		const pair< C1, C2 > &	y
	)			[inline]

Definition at line 54 of file pair.hpp.

{

bool mmx::exact_eq	(	const new_table< C, T, V > &	x,
		const new_table< C, T, V > &	y
	)			[inline]

Definition at line 765 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

bool mmx::exact_eq	(	const Indirect< R > &	x,
		const Indirect< R > &	y
	)			[inline]

Definition at line 758 of file mmc_glue.hpp.

References Indirect< R >::rep.

                                                                       {
  return x.rep == y.rep; }

bool mmx::exact_eq	(	const literal &	c1,
		const literal &	c2
	)			[inline]

Definition at line 48 of file literal.hpp.

References exact_eq().

                                                            {
  return exact_eq (as_symbol (c1), as_symbol (c2)); }

bool mmx::exact_eq	(	const list< C > &	x,
		const list< C > &	y
	)			[inline]

Definition at line 229 of file list.hpp.

{

bool mmx::exact_eq	(	const iterator< C > &	x,
		const iterator< C > &	y
	)			[inline]

Definition at line 184 of file iterator.hpp.

: public Iterator_rep {

bool mmx::exact_eq	(	const heap< C > &	x,
		const heap< C > &	y
	)			[inline]

Definition at line 244 of file heap.hpp.

{

bool exact_eq	(	const int &	x1,
		const generic &	x2
	)

Definition at line 615 of file generic.cpp.

References exact_eq().

                                                 {
  return exact_eq (x2, x1); }

bool exact_eq	(	const generic &	x1,
		const int &	x2
	)

Definition at line 601 of file generic.cpp.

References is_nil().

                                            {
  if (is<int> (x1)) return as<int> (x1) == x2;
  else {
    routine* cv= x1->acc_construct (accelerator<int>::id);
    if (cv != NULL && !is_nil (*cv))
      return x1 -> is_exact_eq ((*cv) (as<generic> (x2)));
  }
  return false;
}

bool exact_eq	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 586 of file generic.cpp.

References is_nil(), and same_type().

                                                {
  if (same_type (x1, x2))
    return x1->is_exact_eq (x2);
  else {
    routine* cv= x1->acc_construct (x2->acc_id ());
    if (cv != NULL && !is_nil (*cv))
      return x1 -> is_exact_eq ((*cv) (x2));
    cv= x2->acc_construct (x1->acc_id ());
    if (cv != NULL && !is_nil (*cv))
      return (*cv) (x1) -> is_exact_eq (x2);
  }
  return false;
}

bool mmx::exact_eq	(	const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &	x,
		const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &	y
	)			[inline]

Definition at line 613 of file function.hpp.

{

bool mmx::exact_eq	(	const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &	x,
		const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &	y
	)			[inline]

Definition at line 553 of file function.hpp.

{

bool mmx::exact_eq	(	const function_6< D, S1, S2, S3, S4, S5, S6 > &	x,
		const function_6< D, S1, S2, S3, S4, S5, S6 > &	y
	)			[inline]

Definition at line 493 of file function.hpp.

{

bool mmx::exact_eq	(	const function_5< D, S1, S2, S3, S4, S5 > &	x,
		const function_5< D, S1, S2, S3, S4, S5 > &	y
	)			[inline]

Definition at line 434 of file function.hpp.

{

bool mmx::exact_eq	(	const function_4< D, S1, S2, S3, S4 > &	x,
		const function_4< D, S1, S2, S3, S4 > &	y
	)			[inline]

Definition at line 375 of file function.hpp.

{

bool mmx::exact_eq	(	const function_3< D, S1, S2, S3 > &	x,
		const function_3< D, S1, S2, S3 > &	y
	)			[inline]

Definition at line 316 of file function.hpp.

{

bool mmx::exact_eq	(	const function_2< D, S1, S2 > &	x,
		const function_2< D, S1, S2 > &	y
	)			[inline]

Definition at line 257 of file function.hpp.

{

bool mmx::exact_eq	(	const function_1< D, S1 > &	x,
		const function_1< D, S1 > &	y
	)			[inline]

Definition at line 157 of file function.hpp.

{

bool mmx::exact_eq	(	const function_0< D > &	x,
		const function_0< D > &	y
	)			[inline]

Definition at line 101 of file function.hpp.

{

bool mmx::exact_eq	(	const exception &	e1,
		const exception &	e2
	)			[inline]

Definition at line 43 of file exception.hpp.

References exact_eq().

                                                                {
  return exact_eq (*e1, *e2); }

bool mmx::exact_eq	(	const dynamic &	x,
		const dynamic &	y
	)			[inline]

Definition at line 95 of file dynamic.hpp.

bool mmx::exact_eq	(	const observer &	x,
		const observer &	y
	)			[inline]

Definition at line 58 of file dynamic.hpp.

: public rep_struct {

bool mmx::exact_eq	(	const document &	c1,
		const document &	c2
	)			[inline]

Definition at line 55 of file document.hpp.

References exact_eq().

                                                              {
  return exact_eq (*c1, *c2); }

bool mmx::exact_eq	(	const compound &	c1,
		const compound &	c2
	)			[inline]

Definition at line 53 of file compound.hpp.

References exact_eq().

                                                              {
  return exact_eq (as_symbol (c1), as_symbol (c2)); }

bool mmx::exact_eq	(	const cache< C, T > &	c1,
		const cache< C, T > &	c2
	)			[inline]

Definition at line 46 of file cache.hpp.

References hard_eq().

                                                             {
  return hard_eq (*c1, *c2); }

bool mmx::exact_eq	(	C *	p1,
		C *	p2
	)			[inline]

Definition at line 245 of file basix.hpp.

{ return p1 == p2; }

bool mmx::exact_eq	(	double	x,
		double	y
	)			[inline]

Definition at line 244 of file basix.hpp.

{ return x == y; }

bool mmx::exact_eq	(	float	x,
		float	y
	)			[inline]

Definition at line 243 of file basix.hpp.

{ return x == y; }

bool mmx::exact_eq	(	long long unsigned int	c1,
		long long unsigned int	c2
	)			[inline]

Definition at line 240 of file basix.hpp.

                                                                            {
  return c1 == c2; }

bool mmx::exact_eq	(	long long int	c1,
		long long int	c2
	)			[inline]

Definition at line 239 of file basix.hpp.

{ return c1 == c2; }

bool mmx::exact_eq	(	long unsigned int	c1,
		long unsigned int	c2
	)			[inline]

Definition at line 237 of file basix.hpp.

                                                                  {
  return c1 == c2; }

bool mmx::exact_eq	(	long int	c1,
		long int	c2
	)			[inline]

Definition at line 236 of file basix.hpp.

{ return c1 == c2; }

bool mmx::exact_eq	(	unsigned int	c1,
		unsigned int	c2
	)			[inline]

Definition at line 235 of file basix.hpp.

{ return c1 == c2; }

bool mmx::exact_eq	(	int	c1,
		int	c2
	)			[inline]

Definition at line 234 of file basix.hpp.

{ return c1 == c2; }

bool mmx::exact_eq	(	short unsigned int	c1,
		short unsigned int	c2
	)			[inline]

Definition at line 232 of file basix.hpp.

                                                                    {
  return c1 == c2; }

bool mmx::exact_eq	(	short int	c1,
		short int	c2
	)			[inline]

Definition at line 231 of file basix.hpp.

{ return c1 == c2; }

bool mmx::exact_eq	(	unsigned char	c1,
		unsigned char	c2
	)			[inline]

Definition at line 230 of file basix.hpp.

{ return c1 == c2; }

bool mmx::exact_eq	(	signed char	c1,
		signed char	c2
	)			[inline]

Definition at line 229 of file basix.hpp.

{ return c1 == c2; }

bool mmx::exact_eq	(	char	c1,
		char	c2
	)			[inline]

Definition at line 228 of file basix.hpp.

Referenced by _mul_add(), as_math(), compose(), exact_eq(), exact_neq(), fall_back_equal(), gcd(), hard_eq(), generic_object_rep::is_exact_eq(), generic_concrete_rep< C >::is_exact_eq(), is_exact_zero(), is_func(), lcm(), exact_neq_op::not_op(), product_less_op::op(), exact_eq_op::op(), operator*(), operator+(), operator-(), operator/(), operator==(), pow(), xgcd(), and xgen_sub().

{ return c1 == c2; }

nat mmx::exact_hash

(

const vector< C, V > &

x

)

[inline]

Definition at line 1152 of file vector.hpp.

{

nat mmx::exact_hash

(

const format< C > &

x

)

[inline]

Definition at line 230 of file type_props.hpp.

{ return 0; }

nat mmx::exact_hash

(

const triple< C1, C2, C3 > &

x

)

[inline]

Definition at line 59 of file triple.hpp.

{

nat mmx::exact_hash

(

const table< C, T, V > &

x

)

[inline]

Definition at line 694 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

nat mmx::exact_hash

(

const syntactic &

c

)

[inline]

Definition at line 48 of file syntactic.hpp.

References exact_hash().

{ return exact_hash (*c); }

nat exact_hash

(

const symbol< C, V > &

s

)

[inline]

Definition at line 110 of file symbol.hpp.

References as_hash().

                                             {
  return as_hash (s.rep); }

nat mmx::exact_hash

(

const string &

x

)

[inline]

Definition at line 107 of file string.hpp.

{ return copy (s); }

nat mmx::exact_hash

(

const storage &

x

)

[inline]

Definition at line 55 of file storage.hpp.

{ return "storage"; }

nat mmx::exact_hash

(

const sparse_vector< C, T, V > &

x

)

[inline]

Definition at line 169 of file sparse_vector.hpp.

{

nat mmx::exact_hash

(

const port &

x

)

[inline]

Definition at line 63 of file port.hpp.

{ return p->expression (); }

nat mmx::exact_hash

(

const pair< C1, C2 > &

x

)

[inline]

Definition at line 54 of file pair.hpp.

{

nat mmx::exact_hash

(

const new_table< C, T, V > &

x

)

[inline]

Definition at line 765 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

nat mmx::exact_hash

(

const Indirect< R > &

x

)

[inline]

Definition at line 768 of file mmc_glue.hpp.

References as_hash(), and Indirect< R >::rep.

                                                  {
  return as_hash (x.rep); }

nat mmx::exact_hash

(

const literal &

c

)

[inline]

Definition at line 42 of file literal.hpp.

References exact_hash().

{ return exact_hash (as_symbol (c)); }

nat mmx::exact_hash

(

const list< C > &

x

)

[inline]

Definition at line 229 of file list.hpp.

{

nat exact_hash

(

const iterator< C > &

it

)

[inline]

Definition at line 184 of file iterator.hpp.

: public Iterator_rep {

nat mmx::exact_hash

(

const heap< C > &

x

)

[inline]

Definition at line 244 of file heap.hpp.

{

nat mmx::exact_hash

(

const generic &

g

)

[inline]

Definition at line 160 of file generic.hpp.

                                         {
  return g->get_exact_hash_value (); }

nat mmx::exact_hash

(

const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &

x

)

[inline]

Definition at line 613 of file function.hpp.

{

nat mmx::exact_hash

(

const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &

x

)

[inline]

Definition at line 553 of file function.hpp.

{

nat mmx::exact_hash

(

const function_6< D, S1, S2, S3, S4, S5, S6 > &

x

)

[inline]

Definition at line 493 of file function.hpp.

{

nat mmx::exact_hash

(

const function_5< D, S1, S2, S3, S4, S5 > &

x

)

[inline]

Definition at line 434 of file function.hpp.

{

nat mmx::exact_hash

(

const function_4< D, S1, S2, S3, S4 > &

x

)

[inline]

Definition at line 375 of file function.hpp.

{

nat mmx::exact_hash

(

const function_3< D, S1, S2, S3 > &

x

)

[inline]

Definition at line 316 of file function.hpp.

{

nat mmx::exact_hash

(

const function_2< D, S1, S2 > &

x

)

[inline]

Definition at line 257 of file function.hpp.

{

nat mmx::exact_hash

(

const function_1< D, S1 > &

x

)

[inline]

Definition at line 157 of file function.hpp.

{

nat mmx::exact_hash

(

const function_0< D > &

x

)

[inline]

Definition at line 101 of file function.hpp.

{

nat mmx::exact_hash

(

const exception &

e

)

[inline]

Definition at line 37 of file exception.hpp.

References exact_hash().

{ return exact_hash (*e); }

nat mmx::exact_hash

(

const dynamic &

x

)

[inline]

Definition at line 95 of file dynamic.hpp.

nat mmx::exact_hash

(

const observer &

x

)

[inline]

Definition at line 58 of file dynamic.hpp.

: public rep_struct {

nat mmx::exact_hash

(

const document &

c

)

[inline]

Definition at line 49 of file document.hpp.

References exact_hash().

{ return exact_hash (*c); }

nat mmx::exact_hash

(

const compound &

c

)

[inline]

Definition at line 45 of file compound.hpp.

References exact_hash().

                                          {
  return exact_hash (as_symbol (c)); }

nat mmx::exact_hash

(

const cache< C, T > &

c

)

[inline]

Definition at line 40 of file cache.hpp.

References hard_hash().

{ return hard_hash (*c); }

nat mmx::exact_hash

(

C *

p

)

[inline]

Definition at line 226 of file basix.hpp.

References as_hash().

{ return as_hash (p); }

nat mmx::exact_hash

(

const double &

x

)

[inline]

Definition at line 223 of file basix.hpp.

References n.

                                        {
  union { nat n; double d; } u;
  u.d= x; return u.n; }

nat mmx::exact_hash

(

const float &

x

)

[inline]

Definition at line 221 of file basix.hpp.

                                       {
return (*((nat*) ((void*) &x))) & 0xffffffff; }

nat mmx::exact_hash

(

long long unsigned int

c

)

[inline]

Definition at line 218 of file basix.hpp.

                                                 {
  nat h = (nat) ((c >> (4 * sizeof (long int))) >> (4 * sizeof (long int)));
  return (h<<1) ^ (h<<5) ^ (h>>27) ^ ((nat) c); }

nat mmx::exact_hash

(

long long int

c

)

[inline]

Definition at line 215 of file basix.hpp.

                                        {
  nat h = (nat) ((c >> (4 * sizeof (long int))) >> (4 * sizeof (long int)));
  return (h<<1) ^ (h<<5) ^ (h>>27) ^ ((nat) c); }

nat mmx::exact_hash

(

long unsigned int

c

)

[inline]

Definition at line 214 of file basix.hpp.

{ return (nat) c; }

nat mmx::exact_hash

(

long int

c

)

[inline]

Definition at line 213 of file basix.hpp.

{ return (nat) c; }

nat mmx::exact_hash

(

unsigned int

c

)

[inline]

Definition at line 212 of file basix.hpp.

{ return (nat) c; }

nat mmx::exact_hash

(

int

c

)

[inline]

Definition at line 211 of file basix.hpp.

{ return (nat) c; }

nat mmx::exact_hash

(

short unsigned int

c

)

[inline]

Definition at line 210 of file basix.hpp.

{ return (nat) c; }

nat mmx::exact_hash

(

short int

c

)

[inline]

Definition at line 209 of file basix.hpp.

{ return (nat) c; }

nat mmx::exact_hash

(

unsigned char

c

)

[inline]

Definition at line 208 of file basix.hpp.

{ return (nat) c; }

nat mmx::exact_hash

(

signed char

c

)

[inline]

Definition at line 207 of file basix.hpp.

{ return (nat) c; }

nat mmx::exact_hash

(

char

c

)

[inline]

Definition at line 206 of file basix.hpp.

Referenced by exact_hash(), generic_object_rep::get_exact_hash_value(), generic_concrete_rep< C >::get_exact_hash_value(), hard_hash(), hash(), exact_neq_op::hash_op(), exact_eq_op::hash_op(), and exact_hash_op::op().

{ return (nat) c; }

bool mmx::exact_neq	(	const vector< syntactic > &	v,
		const vector< syntactic > &	w
	)

Definition at line 541 of file syntactic.cpp.

References exact_eq().

                                                                        {
  return !exact_eq (v, w);
}

bool mmx::exact_neq	(	const vector< C, V > &	x,
		const int &	y
	)			[inline]

Definition at line 1155 of file vector.hpp.

{

bool mmx::exact_neq	(	const vector< C, V > &	x,
		const vector< C, V > &	y
	)			[inline]

Definition at line 1152 of file vector.hpp.

{

bool mmx::exact_neq	(	const format< C > &	x,
		const format< C > &	y
	)			[inline]

Definition at line 218 of file type_props.hpp.

{ return false; }

bool mmx::exact_neq	(	const triple< C1, C2, C3 > &	x,
		const triple< C1, C2, C3 > &	y
	)			[inline]

Definition at line 59 of file triple.hpp.

{

bool mmx::exact_neq	(	const table< C, T, V > &	x,
		const table< C, T, V > &	y
	)			[inline]

Definition at line 694 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

bool mmx::exact_neq	(	const syntactic &	c1,
		const syntactic &	c2
	)			[inline]

Definition at line 56 of file syntactic.hpp.

References exact_neq().

                                                                 {
  return exact_neq (*c1, *c2); }

bool exact_neq	(	const symbol< C, V > &	s1,
		const symbol< C, V > &	s2
	)			[inline]

Definition at line 114 of file symbol.hpp.

                                                                {
  return s1.rep != s2.rep; }

bool mmx::exact_neq	(	const string &	x,
		const string &	y
	)			[inline]

Definition at line 107 of file string.hpp.

{ return copy (s); }

bool mmx::exact_neq	(	const storage &	x,
		const storage &	y
	)			[inline]

Definition at line 55 of file storage.hpp.

{ return "storage"; }

bool mmx::exact_neq	(	const sparse_vector< C, T, V > &	x,
		const sparse_vector< C, T, V > &	y
	)			[inline]

Definition at line 169 of file sparse_vector.hpp.

{

bool mmx::exact_neq	(	const port &	x,
		const port &	y
	)			[inline]

Definition at line 63 of file port.hpp.

{ return p->expression (); }

bool mmx::exact_neq	(	const pair< C1, C2 > &	x,
		const pair< C1, C2 > &	y
	)			[inline]

Definition at line 54 of file pair.hpp.

{

bool mmx::exact_neq	(	const new_table< C, T, V > &	x,
		const new_table< C, T, V > &	y
	)			[inline]

Definition at line 765 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

bool mmx::exact_neq	(	const Indirect< R > &	x,
		const Indirect< R > &	y
	)			[inline]

Definition at line 760 of file mmc_glue.hpp.

References Indirect< R >::rep.

                                                                        {
  return x.rep != y.rep; }

bool mmx::exact_neq	(	const literal &	c1,
		const literal &	c2
	)			[inline]

Definition at line 50 of file literal.hpp.

References exact_neq().

                                                             {
  return exact_neq (as_symbol (c1), as_symbol (c2)); }

bool mmx::exact_neq	(	const list< C > &	x,
		const list< C > &	y
	)			[inline]

Definition at line 229 of file list.hpp.

{

bool mmx::exact_neq	(	const iterator< C > &	x,
		const iterator< C > &	y
	)			[inline]

Definition at line 184 of file iterator.hpp.

: public Iterator_rep {

bool mmx::exact_neq	(	const heap< C > &	x,
		const heap< C > &	y
	)			[inline]

Definition at line 244 of file heap.hpp.

{

bool exact_neq	(	const int &	x1,
		const generic &	x2
	)

Definition at line 617 of file generic.cpp.

References exact_neq().

                                                  {
  return exact_neq (x2, x1); }

bool exact_neq	(	const generic &	x1,
		const int &	x2
	)

Definition at line 613 of file generic.cpp.

References exact_eq().

                                                  {
  return !exact_eq (x1, x2); }

bool exact_neq	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 611 of file generic.cpp.

References exact_eq().

                                                      {
  return !exact_eq (x1, x2); }

bool mmx::exact_neq	(	const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &	x,
		const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &	y
	)			[inline]

Definition at line 613 of file function.hpp.

{

bool mmx::exact_neq	(	const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &	x,
		const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &	y
	)			[inline]

Definition at line 553 of file function.hpp.

{

bool mmx::exact_neq	(	const function_6< D, S1, S2, S3, S4, S5, S6 > &	x,
		const function_6< D, S1, S2, S3, S4, S5, S6 > &	y
	)			[inline]

Definition at line 493 of file function.hpp.

{

bool mmx::exact_neq	(	const function_5< D, S1, S2, S3, S4, S5 > &	x,
		const function_5< D, S1, S2, S3, S4, S5 > &	y
	)			[inline]

Definition at line 434 of file function.hpp.

{

bool mmx::exact_neq	(	const function_4< D, S1, S2, S3, S4 > &	x,
		const function_4< D, S1, S2, S3, S4 > &	y
	)			[inline]

Definition at line 375 of file function.hpp.

{

bool mmx::exact_neq	(	const function_3< D, S1, S2, S3 > &	x,
		const function_3< D, S1, S2, S3 > &	y
	)			[inline]

Definition at line 316 of file function.hpp.

{

bool mmx::exact_neq	(	const function_2< D, S1, S2 > &	x,
		const function_2< D, S1, S2 > &	y
	)			[inline]

Definition at line 257 of file function.hpp.

{

bool mmx::exact_neq	(	const function_1< D, S1 > &	x,
		const function_1< D, S1 > &	y
	)			[inline]

Definition at line 157 of file function.hpp.

{

bool mmx::exact_neq	(	const function_0< D > &	x,
		const function_0< D > &	y
	)			[inline]

Definition at line 101 of file function.hpp.

{

bool mmx::exact_neq	(	const exception &	e1,
		const exception &	e2
	)			[inline]

Definition at line 45 of file exception.hpp.

References exact_neq().

                                                                 {
  return exact_neq (*e1, *e2); }

bool mmx::exact_neq	(	const dynamic &	x,
		const dynamic &	y
	)			[inline]

Definition at line 95 of file dynamic.hpp.

bool mmx::exact_neq	(	const observer &	x,
		const observer &	y
	)			[inline]

Definition at line 58 of file dynamic.hpp.

: public rep_struct {

bool mmx::exact_neq	(	const document &	c1,
		const document &	c2
	)			[inline]

Definition at line 57 of file document.hpp.

References exact_neq().

                                                               {
  return exact_neq (*c1, *c2); }

bool mmx::exact_neq	(	const compound &	c1,
		const compound &	c2
	)			[inline]

Definition at line 55 of file compound.hpp.

References exact_neq().

                                                               {
  return exact_neq (as_symbol (c1), as_symbol (c2)); }

bool mmx::exact_neq	(	const cache< C, T > &	c1,
		const cache< C, T > &	c2
	)			[inline]

Definition at line 48 of file cache.hpp.

References hard_neq().

                                                              {
  return hard_neq (*c1, *c2); }

bool mmx::exact_neq	(	C *	p1,
		C *	p2
	)			[inline]

Definition at line 264 of file basix.hpp.

{ return p1 != p2; }

bool mmx::exact_neq	(	double	x,
		double	y
	)			[inline]

Definition at line 263 of file basix.hpp.

{ return x != y; }

bool mmx::exact_neq	(	float	x,
		float	y
	)			[inline]

Definition at line 262 of file basix.hpp.

{ return x != y; }

bool mmx::exact_neq	(	long long unsigned int	c1,
		long long unsigned int	c2
	)			[inline]

Definition at line 259 of file basix.hpp.

                                                                             {
  return c1 != c2; }

bool mmx::exact_neq	(	long long int	c1,
		long long int	c2
	)			[inline]

Definition at line 258 of file basix.hpp.

{ return c1 != c2; }

bool mmx::exact_neq	(	long unsigned int	c1,
		long unsigned int	c2
	)			[inline]

Definition at line 256 of file basix.hpp.

                                                                   {
  return c1 != c2; }

bool mmx::exact_neq	(	long int	c1,
		long int	c2
	)			[inline]

Definition at line 255 of file basix.hpp.

{ return c1 != c2; }

bool mmx::exact_neq	(	unsigned int	c1,
		unsigned int	c2
	)			[inline]

Definition at line 254 of file basix.hpp.

{ return c1 != c2; }

bool mmx::exact_neq	(	int	c1,
		int	c2
	)			[inline]

Definition at line 253 of file basix.hpp.

{ return c1 != c2; }

bool mmx::exact_neq	(	short unsigned int	c1,
		short unsigned int	c2
	)			[inline]

Definition at line 251 of file basix.hpp.

                                                                     {
  return c1 != c2; }

bool mmx::exact_neq	(	short int	c1,
		short int	c2
	)			[inline]

Definition at line 250 of file basix.hpp.

{ return c1 != c2; }

bool mmx::exact_neq	(	unsigned char	c1,
		unsigned char	c2
	)			[inline]

Definition at line 249 of file basix.hpp.

{ return c1 != c2; }

bool mmx::exact_neq	(	signed char	c1,
		signed char	c2
	)			[inline]

Definition at line 248 of file basix.hpp.

{ return c1 != c2; }

bool mmx::exact_neq	(	char	c1,
		char	c2
	)			[inline]

Definition at line 247 of file basix.hpp.

Referenced by compose(), exact_eq(), exact_neq(), fall_back_unequal(), hard_neq(), exact_eq_op::not_op(), exact_neq_op::op(), operator!=(), and shell_texmacs_output().

{ return c1 != c2; }

bool mmx::exact_new	(	const vector< syntactic > &	v,
		const vector< syntactic > &	w
	)

int exec

(

const vector< string > &

v

)

Definition at line 287 of file system.cpp.

References as_charp(), ASSERT, N(), and n.

                               {
  nat n= N(v);
  ASSERT (n>0, "at least one argument expected");
  typedef char* charp;
  charp _v[n+1];
  for (nat i=0; i<n; i++)
    _v[i]= as_charp (v[i]);
  _v[n]= NULL;
#if defined(__MINGW__) || defined(__MINGW32__)
  return _execvp (_v[0], _v);
#else
  return execvp (_v[0], _v);
#endif
  // NOTE: strings in _v never deallocated
}

vector<C,V> mmx::exp

(

const vector< C, V > &

v

)

[inline]

Definition at line 1178 of file vector.hpp.

{ return unary_map<exp_op> (v); }

table<C,T,V> mmx::exp

(

const table< C, T, V > &

t

)

[inline]

Definition at line 699 of file table.hpp.

{ return unary_map<exp_op> (t); }

syntactic exp

(

const syntactic &

g

)

Definition at line 428 of file syntactic.cpp.

References GEN_EXP, and syn().

{ return syn (GEN_EXP, g); }

new_table<C,T,V> mmx::exp

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 770 of file new_table.hpp.

{ return unary_map<exp_op> (t); }

generic exp

(

const generic &

x1

)

Definition at line 433 of file generic.cpp.

References ACC_EXP, ACC_UNARY, current_ev, and GEN_EXP.

                        {
  ACC_UNARY (ACC_EXP, x1);
  return current_ev->apply (GEN_EXP, x1);
}

double exp

(

const double &

x

)

[inline]

Definition at line 45 of file double.hpp.

Referenced by cosh(), exp_op::op(), exp_op::op_init(), polar(), exp_op::set_op(), sinh(), and tanh().

{ return std::exp (x); }

double exp2

(

const double &

x

)

[inline]

Definition at line 46 of file double.hpp.

Referenced by exp2_op::op(), and exp2_op::set_op().

{ return ::exp2 (x); }

xint mmx::exponent

(

const vector< C, V > &

v

)

[inline]

Definition at line 1331 of file vector.hpp.

                                            {
  return big<max_exponent_op> (v); }

xint exponent

(

const generic &

x

)

Definition at line 781 of file generic.cpp.

References ASSERT, current_ev, and GEN_EXPONENT.

                                 {
  generic r= current_ev->apply (GEN_EXPONENT, x);
  ASSERT (is<int> (r), "Int return value expected");
  return as<int> (r); }

xint mmx::exponent

(

const double &

x

)

[inline]

Definition at line 94 of file double.hpp.

References max().

Referenced by GLUE_47(), magnitude(), exponent_op::op(), max_exponent_op::set_op(), and exponent_op::set_op().

                                       {
  return (xint) max (-10000.0, logb (x)); }

vector<C,V> mmx::extend	(	const vector< C, V > &	v,
		const vector< C2, V2 > &	w
	)			[inline]

Definition at line 221 of file vector.hpp.

References is_a_scalar(), is_non_scalar(), N(), Vector, and VERIFY.

Referenced by binary_map(), binary_test(), unary_set(), and vector_map_2().

                                                 {
  VERIFY (is_a_scalar (v), "scalar vector expected");
  VERIFY (is_non_scalar (w), "non-scalar vector expected");
  return Vector (v.scalar(), N(w)); }

vector<C,V> mmx::extract	(	const vector< C, V > &	v,
		vector< nat >	e
	)			[inline]

Definition at line 599 of file vector.hpp.

References C, CF(), N(), and Vector.

                                         {
  nat l= aligned_size<C,V> (N(e));
  C* r= mmx_formatted_new<C> (l, CF(v));
  for (nat i=0; i<N(e); i++)
    if (e[i] < N(v)) r[i]= v[e[i]];
  return Vector (r, N(e), l, CF(v));
}

vector<C,V> mmx::extract_mod	(	const vector< C, V > &	v,
		nat	k,
		nat	p
	)			[inline]

Definition at line 590 of file vector.hpp.

References C, CF(), N(), n, and Vector.

                                            {
  nat n= (N(v) - k + p - 1) / p;
  nat l= aligned_size<C,V> (n);
  C* r= mmx_formatted_new<C> (l, CF(v));
  for (nat i=0; i<n; i++) r[i]= v[i*p+k];
  return Vector (r, n, l, CF(v));
}

bool mmx::fall_back_equal	(	const generic &	x,
		const generic &	y
	)

Definition at line 29 of file glue.cpp.

References exact_eq().

Referenced by define_prerequisites().

                                                     {
  return exact_eq (x, y);
}

static bool mmx::fall_back_unequal	(	const generic &	x,
		const generic &	y
	)			[static]

Definition at line 34 of file glue.cpp.

References exact_neq().

Referenced by define_prerequisites().

                                                       {
  return exact_neq (x, y);
}

format<typename fast_helper< T >::fast_type > mmx::fast

(

const format< T > &

fm

)

[inline]

Definition at line 797 of file type_props.hpp.

References fast(), get_format(), and get_sample().

                           {
  return get_format (fast (get_sample (fm)));
}

fast_helper< T >::fast_type mmx::fast

(

const T &

x

)

[inline]

Definition at line 782 of file type_props.hpp.

Referenced by fast_helper< vector< C, V > >::dd(), fast(), fast_op::Fast_type(), and fast_op::set_op().

                  {
  return fast_helper<T>::dd (x);
}

volatile void fatal_error	(	char *	message,
		char *	routine,
		char *	file
	)

Print message coming from routine in file. Exit with 1.

Definition at line 31 of file basix.cpp.

References mmout.

                                                       {
  mmout << "\nFatal error: " << message
        << "\n             in '" << routine
        << "' in file '" << file << "'\n";
  exit (1);
}

bool file_exists

(

const string &

file_name

)

Definition at line 336 of file system.cpp.

References as_charp(), decode_name(), and free_charp().

Referenced by connect_to_server(), init_system(), path_name(), prefix_dir(), recursive_search_name(), resolve_name(), semi_recursive_search_name(), var_mkdir(), and var_rm().

                                 {
  //printf ("file_exists: %s\n", S(name));
  string name_s= decode_name (name);
  char* temp= as_charp (name_s);
  FILE* f= fopen (temp, "r");
  if (f != NULL) {
    fclose (f);
    free_charp (temp);
    return true;
  }
  DIR* d= opendir (temp);
  free_charp (temp);
  if (d != NULL) {
    closedir (d);
    return true;
  }
  return false;
}

bool file_is_directory

(

const string &

file_name

)

Definition at line 599 of file system.cpp.

References file_test().

Referenced by recursive_search_name(), and semi_recursive_search_name().

{ return file_test (name, "d"); }

bool file_is_file

(

const string &

file_name

)

Definition at line 598 of file system.cpp.

References file_test().

Referenced by recursive_search_name(), and semi_recursive_search_name().

{ return file_test (name, "f"); }

bool file_is_script

(

const string &

file_name

)

Definition at line 408 of file system.cpp.

References as_charp(), free_charp(), and starts().

                                         {
  char* _file_name= as_charp (file_name);
  FILE* f= fopen (_file_name, "r");
  free_charp (_file_name);
  if (f == NULL) return false;
  char c;
  string s= string ("");
  while ((c = fgetc (f)) != EOF && c != '\n') s << c;
  fclose (f);
  return starts (s, "#!/usr/bin/env mmx-light");

  /*
  port f= input_file_port (file_name);
  if (error_flag (f)) return false;
  char c;
  string s= "";
  while (can_read (f) > 0) {
    f >> c;
    if (c == '\n') break;
    s << c;
  }
  return starts (s, "#!/usr/bin/env mmx-light");
  */
}

double file_last_modified

(

const string &

file_name

)

Definition at line 540 of file system.cpp.

References ERROR, get_attributes(), and mmerr.

                                        {
  struct stat u_stat;
  if (get_attributes (name, &u_stat)) {
    mmerr << "name= " << name << "\n";
    ERROR ("could not stat file");
  }
  return (double) u_stat.st_mtime;
}

bool file_test	(	const string &	file_name,
		const string &	attrs
	)

Definition at line 497 of file system.cpp.

References get_attributes(), N(), and n.

Referenced by file_is_directory(), and file_is_file().

                                                     {
  if (filter == "") return true;
  struct stat buf;
  if (get_attributes (name, &buf)) return false;
  int i, n= N (filter);
  for (i=0; i<n; i++)
    switch (filter [i]) {
      // FIXME: should check user id and group id for r, w and x
    case 'f':
      if (!S_ISREG (buf.st_mode)) return false;
      break;
    case 'd':
      if (!S_ISDIR (buf.st_mode)) return false;
      break;
    case 'r':
#ifndef __MINGW32__
      if ((buf.st_mode & (S_IRUSR | S_IRGRP | S_IROTH)) == 0) return false;
#else
      if ((buf.st_mode & 292) == 0) return false;
#endif
      break;
    case 'w':
#ifndef __MINGW32__
      if ((buf.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH)) == 0) return false;
#else
      if ((buf.st_mode & 146) == 0) return false;
#endif
      break;
    case 'x':
#ifdef OS_WIN32
      if (suffix(name) == "bat") break;
#endif
#ifndef __MINGW32__
      if ((buf.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) == 0) return false;
#else
      if ((buf.st_mode & 73) == 0) return false;
#endif
      break;
    }
  return true;
}

vector<C> mmx::fill	(	const C &	c,
		nat	n
	)			[inline]

Definition at line 488 of file vector.hpp.

References C, Format, and get_format().

                         {
  Format fm= get_format (c);
  nat l= default_aligned_size<C> (n);
  C* a= mmx_formatted_new<C> (l, fm);
  for (nat i=0; i<n; i++) a[i]= c;
  return vector<C> (a, n, l, fm);
}

vector<C> mmx::fill	(	nat	n,
		const format< C > &	fm
	)			[inline]

Definition at line 481 of file vector.hpp.

References C.

                               {
  nat l= default_aligned_size<C> (n);
  C* a= mmx_formatted_new<C> (l, fm);
  return vector<C> (a, n, l, fm);
}

vector<C> mmx::fill

(

nat

n

)

[inline]

Definition at line 473 of file vector.hpp.

References C, and Format.

Referenced by is_evaluable(), and is_reconstructible().

             {
  Format fm;
  nat l= default_aligned_size<C> (n);
  C* a= mmx_formatted_new<C> (l, fm);
  return vector<C> (a, n, l, fm);
}

void fill_out	(	vec_routine &	v,
		nat &	n,
		nat	i,
		const routine &	r
	)

Definition at line 347 of file generic.cpp.

Referenced by accelerator< C >::set_apply(), and accelerator< C >::set_construct().

                                                           {
  if (i >= n) {
    nat      new_n= (nat) (1.2 * ((double) (i + 2)));
    routine* new_v= mmx_new<routine> (new_n, routine ());
    for (nat j=0; j<n; j++) new_v[j]= v[j];
    if (v != NULL) mmx_delete<routine> (v, n);
    n= new_n;
    v= new_v;
  }
  v[i]= r;
}

int mmx::find	(	const vector< C, V > &	v,
		const C &	x
	)			[inline]

Definition at line 705 of file vector.hpp.

References N(), and n.

                                   {
  nat i, n=N(v);
  for (i=0; i<n; i++)
    if (v[i] == x) return (int) i;
  return (int) i;
}

int mmx::find	(	const list< C > &	l,
		const C &	x
	)			[inline]

Definition at line 321 of file list.hpp.

References car(), cdr(), and is_nil().

Referenced by contains(), GLUE_16(), GLUE_17(), and GLUE_18().

                                 {
  if (is_nil (l) || car (l) == x) return 0;
  else return find<C> (cdr (l), x) + 1;
}

C3 C1 mmx::first

(

const triple< C1, C2, C3 > &

t

)

[inline]

Type Constraints

Definition at line 40 of file triple.hpp.

{ return t.x1; }

syntactic mmx::flatten

(

const string &

obj->lex_string

)

Definition at line 597 of file syntactic.cpp.

References quote(), and syn().

                                    {
  return syn ("$text", syntactic (quote (s))); }

syntactic mmx::flatten

(

const char *const &

obj->lex_string

)

Definition at line 595 of file syntactic.cpp.

References quote(), and syn().

                                          {
  return syn ("$text", syntactic (quote (s))); }

syntactic mmx::flatten

(

const generic &

g

)

Definition at line 136 of file generic.cpp.

References flatten(), and MEMOIZE_UNARY.

                           {
  MEMOIZE_UNARY (std_memoizer,syntactic,generic,flatten,g,
                 g->expression());
}

syntactic mmx::flatten

(

const cpp_printer &

p

)

[inline]

Definition at line 288 of file cpp_printer.cpp.

                               {
  return "#cpp_printer<>";
}

syntactic mmx::flatten

(

const vector< C, V > &

v

)

[inline]

Definition at line 524 of file vector.hpp.

References apply(), flatten(), GEN_SQTUPLE, is_a_scalar(), N(), and n.

                          {
  if (is_a_scalar (v)) return flatten (v.scalar());
  nat i, n= N(v);
  vector<syntactic> r= fill <syntactic> (n);
  for (i=0; i<n; i++)
    r[i]= flatten (v[i]);
  return apply (GEN_SQTUPLE, r);
}

syntactic mmx::flatten

(

const format< C > &

x

)

[inline]

Definition at line 236 of file type_props.hpp.

References apply(), cpp_demangle(), flatten(), and lit().

                             {
  string name= cpp_demangle (typeid (format<C>).name ());
  return apply (flatten (lit (name))); }

syntactic mmx::flatten

(

const tuple< C > &

t

)

[inline]

Definition at line 46 of file tuple.hpp.

References cdr(), compound_to_vector(), flatten(), gen(), and GEN_TUPLE.

                         {
  return flatten (gen (GEN_TUPLE, cdr (compound_to_vector (*t))));
}

syntactic mmx::flatten

(

const triple< C1, C2, C3 > &

t

)

[inline]

Definition at line 63 of file triple.hpp.

References apply(), flatten(), and GEN_SQTUPLE.

                          {
  return apply (GEN_SQTUPLE, flatten (t.x1), flatten (t.x2), flatten (t.x3));
}

syntactic mmx::flatten

(

const table< C, T, V > &

t

)

[inline]

Definition at line 423 of file table.hpp.

References apply(), busy(), flatten(), and iterate().

                         {
  vector<syntactic> v;
  for (iterator<pair<T,C> > it= iterate (t); busy (it); ++it)
    v << apply ("~>", flatten ((*it).x1), flatten ((*it).x2));
  return apply ("table", v);
}

syntactic mmx::flatten

(

const string &

s

)

syntactic mmx::flatten

(

const char *const &

s

)

syntactic flatten

(

const long double &

x

)

Definition at line 593 of file syntactic.cpp.

References as_string().

                                         {
  return syntactic (as_string (x)); }

syntactic flatten

(

const double &

x

)

Definition at line 591 of file syntactic.cpp.

References as_string().

                                    {
  return syntactic (as_string (x)); }

syntactic flatten

(

const float &

x

)

Definition at line 589 of file syntactic.cpp.

References as_string().

                                   {
  return syntactic (as_string (x)); }

syntactic flatten

(

const long long unsigned int &

i

)

Definition at line 587 of file syntactic.cpp.

References as_string().

                                                    {
  return syntactic (as_string (i)); }

syntactic flatten

(

const long long int &

i

)

Definition at line 585 of file syntactic.cpp.

References as_string().

                                           {
  return syntactic (as_string (i)); }

syntactic flatten

(

const long unsigned int &

i

)

Definition at line 583 of file syntactic.cpp.

References as_string().

                                               {
  return syntactic (as_string (i)); }

syntactic flatten

(

const long int &

i

)

Definition at line 581 of file syntactic.cpp.

References as_string().

                                      {
  return syntactic (as_string (i)); }

syntactic flatten

(

const unsigned int &

i

)

Definition at line 579 of file syntactic.cpp.

References as_string().

                                          {
  return syntactic (as_string (i)); }

syntactic flatten

(

const int &

i

)

Definition at line 577 of file syntactic.cpp.

References as_string().

                                 {
  return syntactic (as_string (i)); }

syntactic flatten

(

const short unsigned int &

i

)

Definition at line 575 of file syntactic.cpp.

References as_string().

                                                {
  return syntactic (as_string (i)); }

syntactic flatten

(

const short int &

i

)

Definition at line 573 of file syntactic.cpp.

References as_string().

                                       {
  return syntactic (as_string (i)); }

syntactic flatten

(

const unsigned char &

i

)

Definition at line 571 of file syntactic.cpp.

References as_string().

                                           {
  return syntactic (as_string (i)); }

syntactic flatten

(

const signed char &

i

)

Definition at line 569 of file syntactic.cpp.

References as_string().

                                         {
  return syntactic (as_string (i)); }

syntactic flatten

(

const char &

i

)

Definition at line 567 of file syntactic.cpp.

References as_string().

                                  {
  return syntactic (as_string (i)); }

syntactic flatten

(

const bool &

b

)

Definition at line 565 of file syntactic.cpp.

                                  {
  return b? syntactic ("true"): syntactic ("false"); }

syntactic mmx::flatten

(

C *const &

x

)

[inline]

Definition at line 325 of file syntactic.hpp.

References as_string().

                       {
  return as_string ((void*) x);
}

syntactic mmx::flatten

(

const syntactic &

g

)

[inline]

Definition at line 62 of file syntactic.hpp.

{ return g; }

syntactic mmx::flatten

(

const symbol< C, V > &

s

)

[inline]

Definition at line 144 of file symbol.hpp.

References apply(), and flatten().

                                                {
  return apply ("symbol", flatten (*s)); }

syntactic mmx::flatten

(

const storage &

st

)

[inline]

Definition at line 57 of file storage.hpp.

{ return "storage"; }

syntactic mmx::flatten

(

const sparse_vector< C, T, V > &

v

)

[inline]

Definition at line 105 of file sparse_vector.hpp.

References apply(), flatten(), and N().

                                 {
  vector<syntactic> r;
  for (nat i=0; i<N(v); i++)
    r << flatten (v[i]);
  return apply ("sparse_vector", r);
}

syntactic mmx::flatten

(

const source_location &

l

)

[inline]

Definition at line 97 of file source_track.hpp.

References source_location::begin, source_position::column, source_location::end, source_location::file_name, flatten(), gen(), GEN_TUPLE, source_location::input_number, source_position::line, and source_location::obj.

                                   {
  return flatten (gen (GEN_TUPLE, l.obj, l.file_name, l.input_number,
                       gen (GEN_TUPLE, l.begin.line, l.begin.column),
                       gen (GEN_TUPLE, l.end.line, l.end.column)));
}

syntactic mmx::flatten

(

const routine &

fun

)

[inline]

Definition at line 100 of file routine.hpp.

References as_syntactic(), GEN_NIL, and is_nil().

                                              {
  if (is_nil (fun)) return as_syntactic (GEN_NIL);
  else return as_syntactic (fun->name); }

syntactic mmx::flatten

(

const primitive &

fun

)

[inline]

Definition at line 47 of file primitive.hpp.

References as_syntactic(), GEN_NIL, and is_nil().

                                                {
  if (is_nil (fun)) return as_syntactic (GEN_NIL);
  else return as_syntactic (fun->name); }

syntactic mmx::flatten

(

const port &

p

)

[inline]

Definition at line 66 of file port.hpp.

{ return p->expression (); }

syntactic mmx::flatten

(

const pair< C1, C2 > &

p

)

[inline]

Definition at line 63 of file pair.hpp.

References apply(), flatten(), and GEN_SQTUPLE.

                        {
  return apply (GEN_SQTUPLE, flatten (p.x1), flatten (p.x2));
}

syntactic mmx::flatten

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 494 of file new_table.hpp.

References apply(), busy(), flatten(), and iterate().

                         {
  vector<syntactic> v;
  for (iterator<pair<T,C> > it= iterate (t); busy (it); ++it)
    v << apply ("~>", flatten ((*it).x1), flatten ((*it).x2));
  return apply ("table", v);
}

syntactic mmx::flatten

(

const Indirect< R > &

x

)

[inline]

Definition at line 772 of file mmc_glue.hpp.

                                                     {
  return syntactic ("category"); }

syntactic mmx::flatten

(

const pair< pair< T1, T2 >, pair< U1, U2 > > &

p

)

[inline]

Definition at line 725 of file mmc_glue.hpp.

References apply(), arguments(), flatten(), and GEN_SQTUPLE.

                                                  {
  vector<syntactic> args;
  args << arguments (flatten (p.x1));
  args << arguments (flatten (p.x2));
  return apply (GEN_SQTUPLE, args);
}

syntactic mmx::flatten

(

const pair< pair< T1, T2 >, U > &

p

)

[inline]

Definition at line 717 of file mmc_glue.hpp.

References apply(), arguments(), flatten(), and GEN_SQTUPLE.

                                        {
  vector<syntactic> args;
  args << arguments (flatten (p.x1));
  args << flatten (p.x2);
  return apply (GEN_SQTUPLE, args);
}

syntactic mmx::flatten

(

const pair< T, pair< U1, U2 > > &

p

)

[inline]

Definition at line 709 of file mmc_glue.hpp.

References apply(), arguments(), flatten(), and GEN_SQTUPLE.

                                        {
  vector<syntactic> args;
  args << flatten (p.x1);
  args << arguments (flatten (p.x2));
  return apply (GEN_SQTUPLE, args);
}

syntactic flatten

(

const literal &

s

)

Definition at line 21 of file literal.cpp.

References as_syntactic().

                           {
  return as_syntactic (as<generic> (s));
}

syntactic mmx::flatten

(

const list< C > &

l

)

[inline]

Definition at line 236 of file list.hpp.

References apply(), flatten(), GEN_SQTUPLE, is_nil(), List, read_car(), and read_cdr().

                        {
  vector<syntactic> v;
  List counter= l;
  while (!is_nil (counter)) {
    v << flatten (read_car (counter));
    counter= read_cdr (counter);
  }
  return apply (GEN_SQTUPLE, v);
}

syntactic mmx::flatten

(

const iterator< C > &

it

)

[inline]

Definition at line 137 of file iterator.hpp.

References flatten().

                             {
  return flatten ("iterator", it);
  // NOTE: when C involves the generic type, then traversal of the iterator
  // is a non trivial operations which may cause trouble (like in 1..10)
  // Indeed, the traveral may require operations like < on generic which
  // are not defined in the output evaluator.
  // return flatten (generic ("iterator"), it);
  // (void) it; return "iterator";
}

syntactic mmx::flatten	(	const syntactic &	fun,
		const iterator< C > &	it
	)			[inline]

Definition at line 129 of file iterator.hpp.

References apply(), busy(), and flatten().

                                                   {
  vector<syntactic> v;
  for (; busy (it); ++it)
    v << flatten (*it);
  return apply (fun, v);
}

syntactic mmx::flatten

(

const heap< C > &

h

)

[inline]

Definition at line 254 of file heap.hpp.

References flatten(), and iterate().

                        {
  return flatten (syntactic ("heap"), iterate (h));
}

syntactic mmx::flatten

(

const generic_function &

fun

)

[inline]

Definition at line 49 of file generic_function.hpp.

                                                       {
  return fun -> Flatten (); }

syntactic mmx::flatten

(

const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &

f

)

[inline]

Definition at line 605 of file function.hpp.

                                                  {
  return "function"; }

syntactic mmx::flatten

(

const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &

f

)

[inline]

Definition at line 545 of file function.hpp.

                                                  {
  return "function"; }

syntactic mmx::flatten

(

const function_6< D, S1, S2, S3, S4, S5, S6 > &

f

)

[inline]

Definition at line 485 of file function.hpp.

                                                  {
  return "function"; }

syntactic mmx::flatten

(

const function_5< D, S1, S2, S3, S4, S5 > &

f

)

[inline]

Definition at line 426 of file function.hpp.

                                                  {
  return "function"; }

syntactic mmx::flatten

(

const function_4< D, S1, S2, S3, S4 > &

f

)

[inline]

Definition at line 367 of file function.hpp.

                                                  {
  return "function"; }

syntactic mmx::flatten

(

const function_3< D, S1, S2, S3 > &

f

)

[inline]

Definition at line 308 of file function.hpp.

                                                  {
  return "function"; }

syntactic mmx::flatten

(

const function_2< D, S1, S2 > &

f

)

[inline]

Definition at line 248 of file function.hpp.

References apply().

                                                  {
  return apply ("function",
                flatten_type<S1> (), flatten_type<S2> (), flatten_type<D> ()); }

syntactic mmx::flatten

(

const function_1< D, S1 > &

f

)

[inline]

Definition at line 149 of file function.hpp.

References apply().

                                                  {
  return apply ("function", flatten_type<S1> (), flatten_type<D> ()); }

syntactic mmx::flatten

(

const function_0< D > &

f

)

[inline]

Definition at line 93 of file function.hpp.

References apply().

                                                  {
  return apply ("function", flatten_type<D> ()); }

syntactic mmx::flatten

(

const exception &

e

)

[inline]

Definition at line 52 of file exception.hpp.

References flatten().

{ return flatten (*e); }

syntactic flatten

(

const dynamic &

g

)

Definition at line 90 of file dynamic.cpp.

References apply(), attach(), flatten(), inside(), N(), output_observer(), OUTPUT_OBSERVER, and unique_identifier().

                           {
  syntactic r=
    apply ("$dynamic", syntactic (unique_identifier (g)), flatten (g->val));
  for (nat i=0; i<N(g->obs); i++)
    if (g->obs[i]->observer_type () == OUTPUT_OBSERVER)
      return r;
  attach (g, output_observer (inside (g)));
  inside (g) -> ref_count++;  // never destroy printed dynamic objects
  return r;
}

syntactic mmx::flatten

(

const document &

d

)

[inline]

Definition at line 68 of file document.hpp.

References as_generic(), as_syntactic(), and gen().

                                             {
  return as_syntactic (gen ("$text", as_generic (d))); }

syntactic flatten

(

const compound &

c

)

Definition at line 27 of file compound.cpp.

References as_generic(), as_syntactic(), as_vector(), flatten(), N(), n, and vector_to_compound().

                            {
  const vector<generic> v= as_vector (c);
  nat i, n= N(v);
  vector<generic> w= fill<generic> (n);
  for (i=0; i<n; i++)
    w[i]= as_generic (flatten (v[i]));
  return as_syntactic (vector_to_compound (w));
}

syntactic mmx::flatten

(

const chain< C > &

c

)

[inline]

Definition at line 151 of file chain.hpp.

References flatten(), and iterate().

                         {
  return flatten (syntactic ("chain"), iterate (c));
}

syntactic mmx::flatten

(

const cache< C, T > &

c

)

[inline]

Definition at line 55 of file cache.hpp.

References flatten().

{ return flatten (*c); }

syntactic mmx::flatten

(

const generic_alias< C > &

a

)

[inline]

Definition at line 129 of file alias.hpp.

Referenced by as_lisp(), as_math(), generic_object_rep::expression(), formatting_port_rep::expression(), composite_port_rep::expression(), generic_concrete_rep< C >::expression(), flatten(), flatten_as_cpp(), flatten_as_lisp(), flatten_as_math(), flatten_as_mmx(), flatten_as_syntactic(), flatten_as_texmacs_scheme(), flatten_as_tm(), GLUE_5(), define_type_helper< C >::helper_flatten(), INDIRECT_IMPL_1(), object_flatten(), flatten_op::op(), output_as_mmx(), pow(), flatten_op::set_op(), texmacs_dynamic_event(), and var_flatten().

{ return flatten (*a); }

string flatten_as_cpp

(

const generic &

g

)

Definition at line 1295 of file cpp_printer.cpp.

References as_cpp(), as_generic(), and flatten().

Referenced by GLUE_7().

                                  {
  generic f= as_generic (flatten (g));
  return as_cpp (f);
}

string flatten_as_lisp

(

const generic &

g

)

Definition at line 48 of file lisp_printer.cpp.

References as_generic(), as_lisp(), and flatten().

                                   {
  generic f= as_generic (flatten (g));
  return as_lisp (f);
}

string mmx::flatten_as_math

(

const C &

x

)

[inline]

Definition at line 28 of file math_syntax.hpp.

References as_generic(), as_math(), and flatten().

                             {
  return as_math (as_generic (flatten (x)));
}

string flatten_as_mmx

(

const generic &

g

)

Definition at line 968 of file mmx_printer.cpp.

References as_generic(), as_mmx(), and flatten().

Referenced by GLUE_6(), and std_exception().

                                  {
  generic f= as_generic (flatten (g));
  return as_mmx (f);
}

syntactic mmx::flatten_as_syntactic

(

const T &

x

)

[inline]

Definition at line 53 of file mmc_glue.hpp.

References flatten().

{ return flatten (x); }

string mmx::flatten_as_texmacs_scheme

(

const C &

x

)

[inline]

Definition at line 40 of file math_syntax.hpp.

References as_generic(), as_texmacs_scheme(), and flatten().

Referenced by output_as_mmx(), and shell_texmacs_output().

                                       {
  return as_texmacs_scheme (as_generic (flatten (x)));
}

string flatten_as_tm	(	const generic &	g,
		const string &	style
	)

Definition at line 599 of file mmx_texmacs.cpp.

References as_generic(), as_snippet(), flatten(), gen(), is_func(), parse_lisp(), and scheme_to_tm().

                                                      {
  string r;
  generic g= as_generic (flatten (x));
  g= parse_lisp (as_snippet (g), true);
  if (is_func (g, "text", 1)) g= g[1];
  if (!is_func (g, "document")) g= gen ("document", g);
  g= gen ("document", gen ("TeXmacs", string ("1.0.7.8")),
          gen ("style", style), gen ("body", g));
  scheme_to_tm (r, g, 0);
  return r;
}

string flatten_as_tm

(

const generic &

g

)

Definition at line 589 of file mmx_texmacs.cpp.

References as_generic(), as_snippet(), flatten(), is_func(), parse_lisp(), and scheme_to_tm().

                                 {
  string r;
  generic g= as_generic (flatten (x));
  g= parse_lisp (as_snippet (g), true);
  if (is_func (g, "text", 1)) g= g[1];
  scheme_to_tm (r, g, 0);
  return r;
}

syntactic mmx::flatten_type

(

)

[inline]

Definition at line 19 of file function.hpp.

References as_syntactic(), and type_name().

                                                      {
  return as_syntactic (type_name (type_information<T>::id)); }

void mmx::floating_to_string	(	const C &	val,
		string &	obj->lex_string,
		const char *	fm
	)			[inline]

Definition at line 220 of file string.cpp.

Referenced by numeric_to_string().

                                                             {
  char buffer[40];
  sprintf (buffer, fm, val);
  s << string (buffer);
}

generic floor

(

const generic &

x

)

Definition at line 749 of file generic.cpp.

References current_ev, and GEN_FLOOR.

                                 {
  return current_ev->apply (GEN_FLOOR, x); }

double floor

(

const double &

x

)

[inline]

Definition at line 129 of file double.hpp.

Referenced by floor_op::op(), round(), and floor_op::set_op().

{ return std::floor (x); }

unsigned long long int mmx::floor_sqrt

(

const unsigned long long int &

x

)

[inline]

Definition at line 504 of file int.hpp.

{ return (m % n) == 0; } \

unsigned long int mmx::floor_sqrt

(

const unsigned long int &

x

)

[inline]

Definition at line 503 of file int.hpp.

{ return (m % n) == 0; } \

unsigned int mmx::floor_sqrt

(

const unsigned int &

x

)

[inline]

Definition at line 502 of file int.hpp.

{ return (m % n) == 0; } \

unsigned short int mmx::floor_sqrt

(

const unsigned short int &

x

)

[inline]

Definition at line 501 of file int.hpp.

{ return (m % n) == 0; } \

unsigned char mmx::floor_sqrt

(

const unsigned char &

x

)

[inline]

Definition at line 500 of file int.hpp.

{ return (m % n) == 0; } \

long long int mmx::floor_sqrt

(

const long long int &

x

)

[inline]

Definition at line 480 of file int.hpp.

{

long int mmx::floor_sqrt

(

const long int &

x

)

[inline]

Definition at line 479 of file int.hpp.

{

int mmx::floor_sqrt

(

const int &

x

)

[inline]

Definition at line 478 of file int.hpp.

{

short int mmx::floor_sqrt

(

const short int &

x

)

[inline]

Definition at line 477 of file int.hpp.

{

signed char mmx::floor_sqrt

(

const signed char &

x

)

[inline]

Definition at line 476 of file int.hpp.

Referenced by GLUE_28().

{

void mmx::flush

(

const port &

p

)

[inline]

Definition at line 115 of file port.hpp.

References inside().

Referenced by composite_port_rep::flush(), and GLUE_18().

                                  {
  inside (p)->flush (); }

string follow_link	(	const string &	name,
		const bool &	recurse
	)

Definition at line 581 of file system.cpp.

References as_charp(), decode_name(), free_charp(), and n.

                                                      {
  char buf[1024];
  string name_s= decode_name (name);
  char* temp= as_charp (name_s);
  int n= readlink (temp, buf, 1024);
  free_charp (temp);
  if (n >= 0 && n < 1024) {
    string r (buf, n);
    if (recurse) return follow_link (r, true);
    else return r;
  }
  else {
    if (recurse) return name;
    else return "";
  }
}

void mmx::foreach	(	const Fun &	fun,
		const vector< S1 > &	v1,
		const vector< S2 > &	v2,
		const vector< S3 > &	v3
	)			[inline]

Definition at line 1012 of file vector.hpp.

References ASSERT, is_non_scalar(), and N().

                                                                           {
  ASSERT (is_non_scalar (v1) && is_non_scalar (v2) && is_non_scalar (v3),
          "non-scalar vectors expected");
  ASSERT (N(v1) == N(v2) && N(v2) == N(v3), "vectors of unequal lengths");
  for (nat i=0; i<N(v1); i++) fun (v1[i], v2[i], v3[i]);
}

void mmx::foreach	(	const Fun &	fun,
		const vector< S1 > &	v1,
		const vector< S2 > &	v2
	)			[inline]

Definition at line 1004 of file vector.hpp.

References ASSERT, is_non_scalar(), and N().

                                                                     {
  ASSERT (is_non_scalar (v1) && is_non_scalar (v2),
          "non-scalar vectors expected");
  ASSERT (N(v1) == N(v2), "vectors of unequal lengths");
  for (nat i=0; i<N(v1); i++) fun (v1[i], v2[i]);
}

void mmx::foreach	(	const Fun &	fun,
		const vector< S1 > &	v1
	)			[inline]

Definition at line 998 of file vector.hpp.

References ASSERT, is_non_scalar(), and N().

                                               {
  ASSERT (is_non_scalar (v1), "non-scalar vector expected");
  for (nat i=0; i<N(v1); i++) fun (v1[i]);
}

port formatting_port

(

const port &

p

)

Definition at line 186 of file formatting_port.cpp.

Referenced by read_line().

                                {
  return (port_rep*) new formatting_port_rep (p);
}

void mmx::free_charp

(

char *

obj->lex_string

)

Definition at line 83 of file string.cpp.

References mmx_free().

                     {
  mmx_free (s, strlen (s) + 1);
}

void mmx::free_charp

(

char *

s

)

Free memory allocated within as_charp.

Referenced by completion_generator(), dl_link(), file_exists(), file_is_script(), follow_link(), get_attributes(), get_env(), input_file_port(), input_output_file_port(), load_directory(), output_file_port(), read_line(), set_env(), shell_load_history(), shell_save_history(), shell_terminal_input(), socket_client_port(), system(), var_mkdir(), and var_rm().

C mmx::fuzz_cst

(

const format< C > &

fm

)

[inline]

Definition at line 942 of file type_props.hpp.

References C, promote(), and set_fuzz().

                               {
  C r= promote (0, fm); set_fuzz (r); return r; }

C mmx::fuzz_cst

(

)

[inline]

Definition at line 906 of file type_props.hpp.

References C, and set_fuzz().

{ C r; set_fuzz (r); return r; }

syntactic gaussian	(	const syntactic &	g1,
		const syntactic &	g2
	)

Definition at line 455 of file syntactic.cpp.

References Imaginary.

                                                              {
  return g1 + g2 * Imaginary (syntactic); }

generic gaussian	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 740 of file generic.cpp.

References Imaginary.

Referenced by gaussian_op::op().

                                                        {
  return x1 + x2 * Imaginary (generic); }

syntactic gcd	(	const syntactic &	g1,
		const syntactic &	g2
	)

Definition at line 402 of file syntactic.cpp.

References exact_eq(), GEN_GCD, and syn().

                                                         {
  if (exact_eq (g1, 0)) return g2;
  if (exact_eq (g2, 0)) return g1;
  return syn (GEN_GCD, g1, g2);
}

unsigned long long int mmx::gcd	(	const unsigned long long int	a,
		const unsigned long long int	b
	)			[inline]

Definition at line 706 of file int.hpp.

{

unsigned long int mmx::gcd	(	const unsigned long int	a,
		const unsigned long int	b
	)			[inline]

Definition at line 705 of file int.hpp.

{

unsigned int mmx::gcd	(	const unsigned int	a,
		const unsigned int	b
	)			[inline]

Definition at line 704 of file int.hpp.

{

unsigned short int mmx::gcd	(	const unsigned short int	a,
		const unsigned short int	b
	)			[inline]

Definition at line 703 of file int.hpp.

{

unsigned char mmx::gcd	(	const unsigned char	a,
		const unsigned char	b
	)			[inline]

Definition at line 702 of file int.hpp.

{

long long int mmx::gcd	(	const long long int	a,
		const long long int	b,
		long long int &	co_a,
		long long int &	co_b
	)			[inline]

Definition at line 695 of file int.hpp.

{                                       \

long long int mmx::gcd	(	const long long int	a,
		const long long int	b,
		long long int &	co_a
	)			[inline]

Definition at line 695 of file int.hpp.

{                                       \

long long int mmx::gcd	(	const long long int	a,
		const long long int	b
	)			[inline]

Definition at line 695 of file int.hpp.

{                                       \

long int mmx::gcd	(	const long int	a,
		const long int	b,
		long int &	co_a,
		long int &	co_b
	)			[inline]

Definition at line 694 of file int.hpp.

{                                       \

long int mmx::gcd	(	const long int	a,
		const long int	b,
		long int &	co_a
	)			[inline]

Definition at line 694 of file int.hpp.

{                                       \

long int mmx::gcd	(	const long int	a,
		const long int	b
	)			[inline]

Definition at line 694 of file int.hpp.

{                                       \

int mmx::gcd	(	const int	a,
		const int	b,
		int &	co_a,
		int &	co_b
	)			[inline]

Definition at line 693 of file int.hpp.

{                                       \

int mmx::gcd	(	const int	a,
		const int	b,
		int &	co_a
	)			[inline]

Definition at line 693 of file int.hpp.

{                                       \

int mmx::gcd	(	const int	a,
		const int	b
	)			[inline]

Definition at line 693 of file int.hpp.

{                                       \

short int mmx::gcd	(	const short int	a,
		const short int	b,
		short int &	co_a,
		short int &	co_b
	)			[inline]

Definition at line 692 of file int.hpp.

{                                       \

short int mmx::gcd	(	const short int	a,
		const short int	b,
		short int &	co_a
	)			[inline]

Definition at line 692 of file int.hpp.

{                                       \

short int mmx::gcd	(	const short int	a,
		const short int	b
	)			[inline]

Definition at line 692 of file int.hpp.

{                                       \

signed char mmx::gcd	(	const signed char	a,
		const signed char	b,
		signed char &	co_a,
		signed char &	co_b
	)			[inline]

Definition at line 691 of file int.hpp.

{                                       \

signed char mmx::gcd	(	const signed char	a,
		const signed char	b,
		signed char &	co_a
	)			[inline]

Definition at line 691 of file int.hpp.

{                                       \

signed char mmx::gcd	(	const signed char	a,
		const signed char	b
	)			[inline]

Definition at line 691 of file int.hpp.

{                                       \

generic gcd	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 717 of file generic.cpp.

References current_ev, and GEN_GCD.

Referenced by gcd_op::op(), unsigned_int_reconstruct_helper< U >::reconstruct(), int_reconstruct_helper< I >::reconstruct(), and gcd_op::set_op().

                                                   {
  return current_ev->apply (GEN_GCD, x1, x2); }

generic gen	(	const generic &	x1,
		const generic &	x2,
		const generic &	x3,
		const generic &	x4,
		const generic &	x5,
		const generic &	x6
	)

Definition at line 100 of file compound.cpp.

                                           {
  return as<generic> (compound (vec<generic> (x1, x2, x3, x4, x5, x6)));
}

generic gen	(	const generic &	x1,
		const generic &	x2,
		const generic &	x3,
		const generic &	x4,
		const generic &	x5
	)

Definition at line 94 of file compound.cpp.

                                                              {
  return as<generic> (compound (vec<generic> (x1, x2, x3, x4, x5)));
}

generic gen	(	const generic &	x1,
		const generic &	x2,
		const generic &	x3,
		const generic &	x4
	)

Definition at line 88 of file compound.cpp.

                                           {
  return as<generic> (compound (vec<generic> (x1, x2, x3, x4)));
}

generic gen	(	const generic &	x1,
		const generic &	x2,
		const generic &	x3
	)

Definition at line 83 of file compound.cpp.

                                                              {
  return as<generic> (compound (vec<generic> (x1, x2, x3)));
}

generic gen	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 73 of file compound.cpp.

                                           {
  return as<generic> (compound (vec<generic> (x1, x2)));
}

generic gen	(	const generic &	x1,
		const string &	x2
	)

Definition at line 78 of file compound.cpp.

                                          {
  return as<generic> (compound (vec<generic> (x1, generic (x2))));
}

generic gen

(

const generic &

x1

)

Definition at line 68 of file compound.cpp.

                        {
  return as<generic> (compound (vec<generic> (x1)));
}

generic gen

(

)

Definition at line 63 of file compound.cpp.

       {
  return as<generic> (compound (vec<generic> ()));
}

generic gen	(	const generic &	x1,
		const vector< generic > &	v
	)

Definition at line 58 of file compound.cpp.

References cons().

Referenced by accelerate_converter(), access(), add_modes(), all_type_names(), evaluator_rep::apply(), as_texmacs(), attach_generic_binary_assembler(), bigop(), binary_assemble_generic(), bracket(), collect(), comma(), concat(), concat_append(), define_type_helper< C >::def_type(), define_converter(), define_type_sub(), define_user_type(), documentify(), flatten(), flatten_as_tm(), binary_helper< vector< C, V > >::full_type_name(), binary_helper< triple< C1, C2, C3 > >::full_type_name(), binary_helper< table< C, T, V > >::full_type_name(), binary_helper< symbol< C, V > >::full_type_name(), binary_helper< sparse_vector< C, T, V > >::full_type_name(), binary_helper< format< T > >::full_type_name(), binary_helper< pair< C1, C2 > >::full_type_name(), binary_helper< new_table< C, T, V > >::full_type_name(), binary_helper< list< C > >::full_type_name(), binary_helper< iterator< C > >::full_type_name(), binary_helper< heap< C > >::full_type_name(), binary_helper< chain< C > >::full_type_name(), routine_rep::function_type(), glue_basix_table_generic(), glue_basix_vector_generic(), glue_list_generic(), glue_routine(), hlist(), include(), indented(), infix(), keyword(), has< T, Op >::lazy_value(), both< T1, T2 >::lazy_value(), list_foreach(), make_document(), make_math(), make_row(), make_texmacs(), make_text(), sum_less_op::op(), sign_op::op(), operate(), postfix(), prefix(), replace_lf(), std_exception(), syn(), table_contains(), table_read(), table_reset(), table_set(), table_write(), texmacs_expand(), trace_pull(), trace_push(), trace_top(), type_id(), type_name(), un_try_catch(), user_exception(), vector_foreach(), vlist(), void_value(), and WRAP_INDIRECT_IMPL().

                                                  {
  return as<generic> (compound (cons (x1, v)));
}

generic mmx::GEN_ABS

(

"abs"

)

generic mmx::GEN_ACCESS

(

"."

[]

)

generic mmx::GEN_ACCURACY

(

"accuracy"

)

generic mmx::GEN_ADDITIVE_ERROR

(

"additive_error"

)

generic mmx::GEN_ALIAS

(

"alias"

)

generic mmx::GEN_ALIAS_TYPE

(

"Alias"

)

generic mmx::GEN_ALL_TYPES

(

"all_types"

)

generic mmx::GEN_AND

(

"/\\"

)

generic mmx::GEN_APPEND

(

"

)

generic mmx::GEN_APPLY

(

".()"

)

generic mmx::GEN_ARCCOS

(

"arccos"

)

generic mmx::GEN_ARCSIN

(

"arcsin"

)

generic mmx::GEN_ARCTAN

(

"arctan"

)

generic mmx::GEN_ARCTAN2

(

"arctan2"

)

generic mmx::GEN_ARG

(

"arg"

)

generic mmx::GEN_ARGCH

(

"argch"

)

generic mmx::GEN_ARGSH

(

"argsh"

)

generic mmx::GEN_ARGTH

(

"argth"

)

generic mmx::GEN_ASSIGN

(

)

generic mmx::GEN_ASSIGN_MACRO	(	":	,
		"
	)

generic mmx::GEN_ASSUME

(

"assume"

)

generic mmx::GEN_AUTOFOLD

(

"autofold"

)

generic mmx::GEN_BACKPRIME

(

".`"

)

generic mmx::GEN_BACKQUOTE

(

"`"

)

generic mmx::GEN_BACKTRACE

(

"backtrace"

)

generic mmx::GEN_BALL

(

"ball"

)

generic mmx::GEN_BEGIN

(

"begin"

)

generic mmx::GEN_BLUR

(

"blur"

)

generic mmx::GEN_BOOLEAN_TYPE

(

"Boolean"

)

generic mmx::GEN_BREAK

(

"break"

)

generic mmx::GEN_CACHE_CONVERTER

(

"cache/converter"

)

generic mmx::GEN_CACHE_CONVERTERS

(

"cache/converters"

)

generic mmx::GEN_CACHE_PENALTY

(

"cache/penalty"

)

generic mmx::GEN_CACHED_DERIVE

(

"%derive"

)

generic mmx::GEN_CASE

(

"case"

)

generic mmx::GEN_CAST

(

"cast"

)

generic mmx::GEN_CATALAN

(

"mathcatalan"

)

generic mmx::GEN_CATCH

(

"catch"

)

generic mmx::GEN_CATEGORY

(

"category"

)

generic mmx::GEN_CBRT

(

"cbrt"

)

generic mmx::GEN_CEIL

(

"ceil"

)

generic mmx::GEN_CENTER

(

"center"

)

generic mmx::GEN_CH

(

"ch"

)

generic mmx::GEN_CHANGE_PRECISION

(

"change_precision"

)

generic mmx::GEN_CLASS

(

"class"

)

generic mmx::GEN_CLASS_ACCESS

(

"class/access"

)

generic mmx::GEN_CLASS_ENCAPSULATION

(

"class/encapsulation"

)

generic mmx::GEN_CLASS_EXPORT

(

"class/export"

)

generic mmx::GEN_CLASS_FIELDS

(

"class/fields"

)

generic mmx::GEN_CLASS_MODE

(

"class/mode"

)

generic mmx::GEN_CLASS_NAME

(

"class/name"

)

generic mmx::GEN_CLOSURE

(

"closure"

)

generic mmx::GEN_COERCE

(

"coerce"

)

generic mmx::GEN_COERCE_TYPE

(

"Coerce"

)

generic mmx::GEN_COMMA	(	"	,
		"
	)

generic mmx::GEN_COMPLETE

(

"complete"

)

generic mmx::GEN_COMPOSE

(

"@"

)

generic mmx::GEN_COMPOUND_TYPE

(

"Compound"

)

generic mmx::GEN_CONJ

(

"conj"

)

generic mmx::GEN_CONSTANT

(

"constant"

)

generic mmx::GEN_CONSTRUCTOR

(

"constructor"

)

generic mmx::GEN_CONTINUE

(

"continue"

)

generic mmx::GEN_CONVERT	(	":	,
		"
	)

generic mmx::GEN_CONVERTER

(

"converter"

)

generic mmx::GEN_CONVERTERS

(

"converters"

)

generic mmx::GEN_CONVERTS	(	"~	,
		"
	)

generic mmx::GEN_COS

(

"cos"

)

generic mmx::GEN_CROSS_TYPE

(

"Cross"

)

generic mmx::GEN_D

(

"mathd"

)

generic mmx::GEN_DEFINE

(

)

generic mmx::GEN_DEFINE_MACRO	(	"	= =,
		"
	)

generic mmx::GEN_DELTA

(

"delta"

)

generic mmx::GEN_DENOMINATOR

(

"denominator"

)

generic mmx::GEN_DERIVATIVE

(

"derivative"

)

generic mmx::GEN_DERIVE

(

"derive"

)

generic mmx::GEN_DESTRUCTOR

(

"destructor"

)

generic mmx::GEN_DIV

(

"div"

)

generic mmx::GEN_DO

(

"do"

)

generic mmx::GEN_DOT

(

"."

)

generic mmx::GEN_DOUBLE_TYPE

(

"Double"

)

generic mmx::GEN_DOWNGRADE

(

"downgrade"

)

generic mmx::GEN_DOWNTO

(

"downto"

)

generic mmx::GEN_DUPLICATE

(

"duplicate"

)

generic mmx::GEN_E

(

"mathe"

)

generic mmx::GEN_ELEMENTARY_ERROR

(

"elementary_error"

)

generic mmx::GEN_ELSE

(

"else"

)

generic mmx::GEN_EMPTY

(

""

)

bool mmx::gen_eq	(	const generic &	g1,
		const generic &	g2
	)			[inline]

Definition at line 164 of file generic.hpp.

Referenced by gen_eq_op::op().

                                                          {
  return g1->is_hard_eq (g2); }

generic mmx::GEN_EQUAL

(

)

generic mmx::GEN_EQUALIZE_GROUPED

(

"equalize_grouped"

)

generic mmx::GEN_EQUIV	(	"<=	,
		"
	)

generic mmx::GEN_ERF

(

"erf"

)

generic mmx::GEN_ERROR

(

"error"

)

generic mmx::GEN_EULER

(

"matheuler"

)

generic mmx::GEN_EVALUATE

(

"evaluate"

)

generic mmx::GEN_EXACT_EQ

(

"exact_eq"

)

generic mmx::GEN_EXACT_HASH

(

"exact_hash"

)

generic mmx::GEN_EXACT_NEQ

(

"exact_neq"

)

generic mmx::GEN_EXCEPTION

(

"exception"

)

generic mmx::GEN_EXISTS

(

"exists"

)

generic mmx::GEN_EXP

(

"exp"

)

generic mmx::GEN_EXP10

(

"exp10"

)

generic mmx::GEN_EXP2

(

"exp2"

)

generic mmx::GEN_EXPECTED

(

"expected"

)

generic mmx::GEN_EXPLODE

(

"@"

)

generic mmx::GEN_EXPONENT

(

"exponent"

)

generic mmx::GEN_EXPORT

(

"export"

)

generic mmx::GEN_EXTERN

(

"extern"

)

generic mmx::GEN_FACTORIAL

(

".!"

)

generic mmx::GEN_FALSE

(

"false"

)

generic mmx::GEN_FAST

(

"fast"

)

generic mmx::GEN_FILL

(

"^^"

)

generic mmx::GEN_FLATTEN

(

"flatten"

)

generic mmx::GEN_FLOATING_TYPE

(

"Floating"

)

generic mmx::GEN_FLOOR

(

"floor"

)

generic mmx::GEN_FOR

(

"for"

)

generic mmx::GEN_FORALL

(

"forall"

)

generic mmx::GEN_FOREIGN

(

"foreign"

)

generic mmx::GEN_FUNCTION_TYPE

(

"Function"

)

generic mmx::GEN_FUZZ

(

"Fuzz"

)

generic mmx::GEN_GAMMA

(

"gamma"

)

generic mmx::GEN_GAUSSIAN

(

"gaussian"

)

generic mmx::GEN_GCD

(

"gcd"

)

generic mmx::GEN_GENERATE

(

"generate"

)

generic mmx::GEN_GENERATOR_TYPE

(

"Generator"

)

generic mmx::GEN_GENERIC_ALIAS_TYPE

(

"Generic_alias"

)

generic mmx::GEN_GENERIC_TYPE

(

"Generic"

)

generic mmx::GEN_GLOBAL

(

"global"

)

generic mmx::GEN_GRAD

(

"grad"

)

generic mmx::GEN_GRAEFFE

(

"graeffe"

)

generic mmx::GEN_GTR	(	"	,
		"
	)

generic mmx::GEN_GTREQ

(

">="

)

generic mmx::GEN_GTRGTR

(

">>"

)

generic mmx::GEN_GTRGTREQ

(

)

generic mmx::GEN_HARD_EQ

(

"hard_eq"

)

generic mmx::GEN_HARD_GTR

(

"hard_gtr"

)

generic mmx::GEN_HARD_HASH

(

"hard_hash"

)

generic mmx::GEN_HARD_LESS

(

"hard_less"

)

generic mmx::GEN_HARD_NEQ

(

"hard_neq"

)

generic mmx::GEN_HAS

(

"has"

)

generic mmx::GEN_HASH

(

"hash"

)

nat mmx::gen_hash

(

const generic &

g

)

[inline]

Definition at line 158 of file generic.hpp.

Referenced by gen_eq_op::hash_op().

                                       {
  return g->get_hard_hash_value (); }

generic mmx::GEN_HAT

(

".^"

)

generic mmx::GEN_HYPOT

(

"hypot"

)

generic mmx::GEN_I

(

"mathi"

)

generic mmx::GEN_IDENTITY

(

"identity"

)

generic mmx::GEN_IF

(

"if"

)

generic mmx::GEN_IM

(

"Im"

)

generic mmx::GEN_IMPLIES	(	"	,
		"
	)

generic mmx::GEN_IMPORT

(

"import"

)

generic mmx::GEN_IN

(

"in"

)

generic mmx::GEN_INCLUDED

(

"included"

)

generic mmx::GEN_INFINITY

(

"Infty"

)

generic mmx::GEN_INFIX

(

"infix"

)

generic mmx::GEN_INLINE

(

"inline"

)

generic mmx::GEN_INPLACE

(

"inplace"

)

generic mmx::GEN_INT_TYPE

(

"Int"

)

generic mmx::GEN_INTEGER_TYPE

(

"Integer"

)

generic mmx::GEN_INTEGRATE

(

"integrate"

)

generic mmx::GEN_INTEGRATE_INIT

(

"integrate_init"

)

generic mmx::GEN_INTERN

(

"intern"

)

generic mmx::GEN_INTERVAL

(

"interval"

)

generic mmx::GEN_INTO

(

"->"

)

generic mmx::GEN_INVERT

(

"invert"

)

generic mmx::GEN_KEYWORD

(

"keyword"

)

generic mmx::GEN_LAMBDA

(

"lambda"

)

generic mmx::GEN_LARGEST

(

"largest"

)

generic mmx::GEN_LCM

(

"lcm"

)

generic mmx::GEN_LESS

(

)

generic mmx::GEN_LESSEQ

(

"<="

)

generic mmx::GEN_LESSLESS

(

"<<"

)

generic mmx::GEN_LESSLESSEQ

(

)

generic mmx::GEN_LIFT

(

"lift"

)

generic mmx::GEN_LIST

(

"list"

)

generic mmx::GEN_LITERAL_FLOATING

(

"literal_floating"

)

generic mmx::GEN_LITERAL_INTEGER

(

"literal_integer"

)

generic mmx::GEN_LITERAL_STRING

(

"literal_string"

)

generic mmx::GEN_LITERAL_TYPE

(

"Literal"

)

generic mmx::GEN_LOCAL

(

"local"

)

generic mmx::GEN_LOG

(

"log"

)

generic mmx::GEN_LOG10

(

"log10"

)

generic mmx::GEN_LOG2

(

"log2"

)

generic mmx::GEN_LOG2_AS

(

"set_log2"

)

generic mmx::GEN_LOOP

(

"loop"

)

generic mmx::GEN_LOWER

(

"lower"

)

generic mmx::GEN_MACRO

(

"macro"

)

generic mmx::GEN_MACRO_TYPE

(

"Macro"

)

generic mmx::GEN_MAGNITUDE

(

"magnitude"

)

generic mmx::GEN_MAPSTO

(

":->"

)

generic mmx::GEN_MATCH

(

"match"

)

generic mmx::GEN_MAX

(

"max"

)

generic mmx::GEN_METHOD

(

"method"

)

generic mmx::GEN_MIN

(

"min"

)

generic mmx::GEN_MINUS

(

"-"

)

generic mmx::GEN_MINUS_ASSIGN

(

)

generic mmx::GEN_MOD

(

"mod"

)

generic mmx::GEN_MODULE

(

"module"

)

generic mmx::GEN_MUL_ADD

(

"mul_add"

)

generic mmx::GEN_MUL_SUB

(

"mul_sub"

)

generic mmx::GEN_MULTIPLICATIVE_ERROR

(

"multiplicative_error"

)

generic mmx::GEN_MUTABLE

(

"mutable"

)

generic mmx::GEN_NAN

(

"NaN"

)

bool mmx::gen_neq	(	const generic &	g1,
		const generic &	g2
	)			[inline]

Definition at line 166 of file generic.hpp.

Referenced by gen_eq_op::not_op().

                                                           {
  return !g1->is_hard_eq (g2); }

generic mmx::GEN_NEW

(

"new"

)

generic mmx::GEN_NEXT_ABOVE

(

"next_above"

)

generic mmx::GEN_NEXT_BELOW

(

"next_below"

)

generic mmx::GEN_NIL

(

"nil"

)

generic mmx::GEN_NOOP

(

"noop"

)

generic mmx::GEN_NOT

(

"!"

)

generic mmx::GEN_NUMERATOR

(

"numerator"

)

generic mmx::GEN_OPERATOR

(

"operator"

)

generic mmx::GEN_OR

(

"\\/"

)

generic mmx::GEN_OUTLINE

(

"outline"

)

generic mmx::GEN_OVER

(

"/"

)

generic mmx::GEN_OVER_ASSIGN

(

)

generic mmx::GEN_OVER_I

(

"over_i"

)

generic mmx::GEN_PARTIAL

(

"partial"

)

generic mmx::GEN_PATTERN

(

"pattern"

)

generic mmx::GEN_PENALTY

(

"penalty"

)

generic mmx::GEN_PI

(

"mathpi"

)

generic mmx::GEN_PLUS

(

"+"

)

generic mmx::GEN_PLUS_ASSIGN

(

)

generic mmx::GEN_POLAR

(

"polar"

)

generic mmx::GEN_POSTFIX

(

"postfix"

)

generic mmx::GEN_POWER

(

"^"

)

generic mmx::GEN_PRECISION

(

"precision"

)

generic mmx::GEN_PREFER

(

"prefer"

)

generic mmx::GEN_PREFIX

(

"prefix"

)

generic mmx::GEN_PRIME

(

".'"

)

generic mmx::GEN_PRIVATE

(

"private"

)

generic mmx::GEN_PROJECT

(

"project"

)

generic mmx::GEN_PUBLIC

(

"public"

)

generic mmx::GEN_QUO

(

"quo"

)

generic mmx::GEN_QUOTE

(

"'"

)

generic mmx::GEN_RADIUS

(

"radius"

)

generic mmx::GEN_RAISE

(

"raise"

)

generic mmx::GEN_RANGE

(

".."

)

generic mmx::GEN_RATIONAL_TYPE

(

"Rational"

)

generic mmx::GEN_RE

(

"Re"

)

generic mmx::GEN_RECONSTRUCT

(

"reconstruct"

)

generic mmx::GEN_REM

(

"rem"

)

generic mmx::GEN_RETURN

(

"return"

)

generic mmx::GEN_REVERSE

(

"reverse"

)

generic mmx::GEN_REWRITE

(

"rewrite"

)

generic mmx::GEN_ROUND

(

"round"

)

generic mmx::GEN_ROUNDING_ERROR

(

"rounding_error"

)

generic mmx::GEN_ROUTINE_TYPE

(

"Routine"

)

generic mmx::GEN_ROW

(

"(.)"

)

generic mmx::GEN_SEMICOLON

(

";"

)

generic mmx::GEN_SEQAND

(

"and"

)

generic mmx::GEN_SEQOR

(

"or"

)

generic mmx::GEN_SH

(

"sh"

)

generic mmx::GEN_SHARPEN

(

"sharpen"

)

generic mmx::GEN_SIN

(

"sin"

)

generic mmx::GEN_SINGLE_TYPE

(

"Single"

)

generic mmx::GEN_SIZE

(

"#"

)

generic mmx::GEN_SLOW

(

"slow"

)

generic mmx::GEN_SMALLEST

(

"smallest"

)

generic mmx::GEN_SOLVE

(

"solve"

)

generic mmx::GEN_SPECIALIZE

(

"specialize"

)

generic mmx::GEN_SPECIALIZE_ALIAS

(

"specialize_alias"

)

generic mmx::GEN_SQRT

(

"sqrt"

)

generic mmx::GEN_SQTUPLE

(

""

[]

)

generic mmx::GEN_SQUARE

(

"square"

)

generic mmx::GEN_STAR

(

".*"

)

generic mmx::GEN_STEP

(

"step"

)

generic mmx::GEN_SUBSTITUTE

(

"substitute"

)

generic mmx::GEN_SYMBOL_TYPE

(

"Symbol"

)

generic mmx::GEN_TAN

(

"tan"

)

generic mmx::GEN_TH

(

"th"

)

generic mmx::GEN_THIS

(

"this"

)

generic mmx::GEN_THIS_TYPE

(

"This"

)

generic mmx::GEN_TILDA

(

".~"

)

generic mmx::GEN_TIMES

(

"*"

)

generic mmx::GEN_TIMES_ASSIGN

(

)

generic mmx::GEN_TIMES_I

(

"times_i"

)

generic mmx::GEN_TO

(

"to"

)

generic mmx::GEN_TRANSITIVE

(

"transitive"

)

generic mmx::GEN_TRANSTYPE	(	":	,
		"
	)

generic mmx::GEN_TRUE

(

"true"

)

generic mmx::GEN_TRUNC

(

"trunc"

)

generic mmx::GEN_TRUNCATE

(

"truncate"

)

generic mmx::GEN_TRY

(

"try"

)

generic mmx::GEN_TUPLE

(

"()"

)

generic mmx::GEN_TUPLE_TYPE

(

"Tuple"

)

generic mmx::GEN_TYPE

(

":"

)

generic mmx::GEN_TYPE_ID

(

"type_id"

)

generic mmx::GEN_TYPE_NAME

(

"type_name"

)

generic mmx::GEN_TYPE_TYPE

(

"Type"

)

generic mmx::GEN_UNALIAS

(

"unalias"

)

generic mmx::GEN_UNEQUAL

(

)

generic mmx::GEN_UNSPECIFIED_TYPE

(

"Unspecified"

)

generic mmx::GEN_UNTIL

(

"until"

)

generic mmx::GEN_UPGRADE

(

"upgrade"

)

generic mmx::GEN_UPPER

(

"upper"

)

generic mmx::GEN_VARTRANSTYPE	(	"::	,
		"
	)

generic mmx::GEN_VARTYPE

(

"::"

)

generic gen_vec	(	const generic &	g1,
		const generic &	g2,
		const generic &	g3
	)

Definition at line 63 of file generic.cpp.

                                                                          {
  return as<generic> (vec<generic> (g1, g2, g3)); }

generic gen_vec	(	const generic &	g1,
		const generic &	g2
	)

Definition at line 61 of file generic.cpp.

                                                       {
  return as<generic> (vec<generic> (g1, g2)); }

generic gen_vec

(

const generic &

g1

)

Definition at line 59 of file generic.cpp.

                                    {
  return as<generic> (vec<generic> (g1)); }

generic gen_vec

(

)

Definition at line 57 of file generic.cpp.

Referenced by binary_helper< triple< C1, C2, C3 > >::disassemble(), binary_helper< generic >::disassemble(), binary_helper< pair< C1, C2 > >::disassemble(), binary_helper< list< C > >::disassemble(), and binary_helper< chain< C > >::disassemble().

                   {
  return as<generic> (vec<generic> ()); }

generic mmx::GEN_VIA_TUPLE

(

"via_tuple"

)

generic mmx::GEN_VOID_TYPE

(

"Void"

)

generic mmx::GEN_VWHERE

(

"||"

)

generic mmx::GEN_WHERE

(

"|"

)

generic mmx::GEN_WHILE

(

"while"

)

generic mmx::GEN_XDERIVE

(

"xderive"

)

generic mmx::GEN_XGCD

(

"xgcd"

)

generic mmx::GEN_XOR

(

"xor"

)

generic mmx::GEN_YIELD

(

"yield"

)

generic mmx::GEN_ZETA

(

"zeta"

)

alias<generic> mmx::generalize_genalias

(

const generic_alias< C > &

a

)

[inline]

Definition at line 132 of file alias.hpp.

                                                                        {
  return *a; }

compound mmx::generic_apply	(	const generic &	f,
		const vector< generic > &	v
	)			[inline]

Definition at line 84 of file mmc_glue.hpp.

References cons().

                                                           {
  return compound (cons (f, v));
}

vector<generic> mmx::generic_arguments

(

const generic &

g

)

[inline]

Definition at line 94 of file mmc_glue.hpp.

References cdr(), and generic_components().

                                     {
  return cdr (generic_components (g));
}

T mmx::generic_as_any

(

const generic &

g

)

[inline]

Definition at line 187 of file mmc_glue.hpp.

References verbose_as_helper< T, F >::cv().

                                  {
  return verbose_as_helper<T,generic>::cv (g);
}

literal mmx::generic_as_literal

(

const generic &

g

)

[inline]

Definition at line 126 of file mmc_glue.hpp.

References ASSERT.

                                      {
  ASSERT (is<literal> (g), "literal expected");
  return as<literal> (g);
}

string mmx::generic_as_string

(

const generic &

g

)

[inline]

Definition at line 119 of file mmc_glue.hpp.

References as_string(), and ASSERT.

                                     {
  ASSERT (is<string> (g) || is<literal> (g), "string or literal expected");
  if (is<string> (g)) return as<string> (g);
  else return as_string (as<literal> (g));
}

vector<generic> mmx::generic_as_vector

(

const generic &

g

)

[inline]

Definition at line 132 of file mmc_glue.hpp.

References ASSERT, and is().

                                     {
  ASSERT (is<vector<generic> > (g), "vector expected");
  return as<vector<generic> > (g);
}

generic mmx::generic_assemble

(

const generic &

x

)

[inline]

Definition at line 311 of file port.hpp.

Referenced by GLUE_26().

                                                   {
  return binary_assemble<generic> (x); }

static int mmx::generic_compare	(	const generic &	x,
		const generic &	y
	)			[static]

Definition at line 117 of file glue_list_map.cpp.

References current_comparison.

Referenced by list_sort().

                                                     {
  bool b= as<bool> (current_comparison->apply (x, y));
  return b? -1: 1;
}

vector<generic> mmx::generic_components

(

const generic &

g

)

[inline]

Definition at line 89 of file mmc_glue.hpp.

References compound_to_vector().

Referenced by generic_arguments().

                                      {
  return compound_to_vector (g);
}

generic mmx::generic_disassemble

(

const generic &

x

)

[inline]

Definition at line 309 of file port.hpp.

Referenced by GLUE_27().

                                                      {
  return binary_disassemble<generic> (x); }

bool mmx::generic_is_boolean

(

const generic &

g

)

[inline]

Definition at line 226 of file generic.hpp.

                                                  {
  return is<bool> (g); }

bool mmx::generic_is_compound

(

const generic &

g

)

[inline]

Definition at line 104 of file mmc_glue.hpp.

                                       {
  return is<compound> (g);
}

bool mmx::generic_is_double

(

const generic &

g

)

[inline]

Definition at line 230 of file generic.hpp.

Referenced by GLUE_3().

                                                 {
  return is<double> (g); }

bool mmx::generic_is_int

(

const generic &

g

)

[inline]

Definition at line 228 of file generic.hpp.

Referenced by GLUE_2().

                                              {
  return is<int> (g); }

bool mmx::generic_is_literal

(

const generic &

g

)

[inline]

Definition at line 99 of file mmc_glue.hpp.

                                      {
  return is<literal> (g);
}

bool mmx::generic_is_string

(

const generic &

g

)

[inline]

Definition at line 232 of file generic.hpp.

                                                 {
  return is<string> (g); }

bool mmx::generic_is_table_generic

(

const generic &

g

)

[inline]

Definition at line 114 of file mmc_glue.hpp.

                                            {
  return is<table<generic,generic> > (g);
}

bool mmx::generic_is_vector_generic

(

const generic &

g

)

[inline]

Definition at line 109 of file mmc_glue.hpp.

                                             {
  return is<vector<generic> > (g);
}

int mmx::generic_size

(

const generic &

g

)

[inline]

Definition at line 138 of file mmc_glue.hpp.

References N().

                                {
  return (int) N(g);
}

generic mmx::generic_type

(

const generic &

g

)

generic get_alias

(

const generic &

a

)

Definition at line 75 of file alias.cpp.

References alias_getter(), and type().

                             {
  routine r;
  alias_getter (type (a), r);
  return r->apply (a);
}

C mmx::get_alias

(

const alias< C > &

a

)

[inline]

Definition at line 56 of file alias.hpp.

Referenced by default_routine(), generic_object_rep::expression(), alias_binary_access_rep< C, R, A, B >::get(), alias_unary_access_rep< C, R, A >::get(), object_get_alias(), object_specialize_alias(), and specialize_alias().

{ return a->get (); }

static bool mmx::get_attributes	(	const string &	name,
		struct stat *	buf
	)			[static]

Definition at line 487 of file system.cpp.

References as_charp(), decode_name(), and free_charp().

Referenced by file_last_modified(), and file_test().

                                                      {
  string name_s= decode_name (name);
  bool flag;
  char* temp= as_charp (name_s);
  flag= stat (temp, buf);
  free_charp (temp);
  return flag;
}

storage mmx::get_branch	(	const storage &	st,
		const string &	br
	)			[inline]

Unlock variable var on storage st.

Definition at line 79 of file storage.hpp.

Referenced by GLUE_8().

                                                                {
  return st->get_branch (br); }

C mmx::get_co	(	const sparse_vector< C, symbol< M >, hard_eq_sparse_vector > &	v,
		nat	i
	)			[inline]

Definition at line 358 of file sparse_vector.hpp.

                                                                          {
  return v[i].x2;
}

string get_directory

(

const string &

name

)

Definition at line 434 of file system.cpp.

References N().

Referenced by ancestor_search_name(), canonical_name(), command_dir(), prefix_dir(), recursive_search_name(), and resolve_name().

                                   {
  for (int i= N(name)-1; i>=1; i--)
    if (name[i]=='/')
      return name (0, i);
  if (N(name) > 0 && name[0] == '/') return "/";
  return ".";
}

string get_env

(

const string &

var

)

Definition at line 71 of file system.cpp.

References as_charp(), free_charp(), and var_pwd().

Referenced by decode_name(), global_path(), load_path(), path_name(), prefix_dir(), supports_color(), sysconf_dir(), user_dir(), var_load(), and var_pwd().

                            {
#if defined(__MINGW__) || defined(__MINGW32__)
  if (var == "PWD") return var_pwd ();
#endif
  char* _var= as_charp (var);
  char* _ret= getenv (_var);
  free_charp (_var);
  if (_ret == NULL) return "";
  string ret (_ret);
  return ret;
  // do not delete _ret !
}

string get_extension

(

const string &

name

)

Definition at line 462 of file system.cpp.

References N().

                                   {
  for (int i= N(name)-1; i>=0; i--)
    if (name[i]=='.')
      return name (i+1, N(name));
    else if (name[i]=='/')
      return "";
  return "";
}

string mmx::get_file	(	const storage &	st,
		const string &	orig
	)			[inline]

Check whether the storage st admits a branch br.

Definition at line 85 of file storage.hpp.

Referenced by GLUE_10().

                                                               {
  return st->get_file (orig); }

static string mmx::get_file_source	(	const string &	file_name,
		nat(obj->lex_line)
	)			[static]

Definition at line 76 of file source_track.cpp.

References ASSERT, file_sources, N(), and read().

                                                    {
  if (!file_sources->contains (file_name)) return "";
  ASSERT (line < N (read (file_sources, file_name)), "source out of range");
  return read (file_sources, file_name) [line];
}

string get_file_source

(

const string &

file_name

)

Definition at line 71 of file source_track.cpp.

References file_sources, and recompose().

Referenced by get_source().

                                          {
  return recompose (file_sources [file_name], "\n");
}

format<C> mmx::get_format

(

const C &

x

)

[inline]

Definition at line 241 of file type_props.hpp.

                        {
  return typename format<C>::FT (x);
}

format< iterator<C> > mmx::get_format

(

const iterator< C > &

it

)

[inline]

Definition at line 115 of file iterator.hpp.

References CF().

Referenced by binary_helper< format< T > >::assemble(), CF1(), CF2(), CF3(), format_as_helper< FT, T, F >::cv(), fast(), fill(), iterate(), iterator< C >::iterator(), lift(), format_binary_map_helper< Op, FT, R, C1, C2 >::op(), format_binary_map_scalar_helper< Op, FT, R, C1, C2 >::op(), format_unary_map_helper< Op, FT, R, C >::op(), format_function_helper< FT, R, C, Fun >::op(), project(), format_binary_helper< FT, T >::read(), seq(), set_default(), slow(), slow_as(), vec(), and vector< observer >::vector().

                                {
  return format<Iterator > (CF (it));
}

format<typename coefficient1_type_helper< C >::val > mmx::get_format1

(

const format< C > &

fm

)

[inline]

Definition at line 251 of file type_props.hpp.

References empty_format::format1().

                                  {
  return format<Coefficient1_type(C) > (fm.format1 ());
}

format<typename coefficient2_type_helper< C >::val > mmx::get_format2

(

const format< C > &

fm

)

[inline]

Definition at line 256 of file type_props.hpp.

References empty_format::format2().

Referenced by make_cache_3(), make_mmx_new_table(), and make_mmx_table().

                                  {
  return format<Coefficient2_type(C) > (fm.format2 ());
}

C mmx::get_genalias

(

const generic_alias< C > &

a

)

[inline]

Definition at line 134 of file alias.hpp.

Referenced by WRAP_WRAPPED_IMPL().

                                                    {
  return as<C> ((*a)->get ()); }

nat get_indentation

(

const string &

obj->lex_string

)

Definition at line 630 of file string.cpp.

References min(), N(), and tokenize().

Referenced by source_string_unindented().

                                  {
  if (N(s) == 0) return 0;
  vector<string> v= tokenize (s, "\n");
  nat r= ((nat) -1);
  for (nat y=0; y<N(v); y++)
    for (nat x=0; x<N(v[y]); x++)
      if (v[y][x] != ' ') {
        r= min (r, x);
        break;
      }
  return r;
}

nat get_interactive_number

(

void

)

Definition at line 40 of file source_track.cpp.

References interactive_sources, and N().

Referenced by shell_save_session(), shell_terminal_input(), and store_interactive_source().

                              {
  return N(interactive_sources) ;
}

static string mmx::get_interactive_source	(	nat	i,
		nat	l
	)			[static]

Definition at line 59 of file source_track.cpp.

References ASSERT, interactive_sources, and N().

                                      {
  ASSERT (i < N (interactive_sources), "source out of range");
  ASSERT (l < N (interactive_sources[i]), "source out of range");
  return interactive_sources[i][l];
}

string get_interactive_source

(

nat

i

)

Definition at line 53 of file source_track.cpp.

References ASSERT, interactive_sources, N(), and recompose().

Referenced by get_source(), and shell_save_session().

                               {
  ASSERT (i < N (interactive_sources), "source out of range");
  return recompose (interactive_sources[i], '\n');
}

T mmx::get_key

(

const pair< T, C > &

p

)

[inline]

Definition at line 819 of file table.hpp.

References pair< C1, C2 >::x1.

Referenced by GLUE_2().

{ return p.x1; }

static void mmx::get_lock	(	FILE *	f,
		int	kind
	)			[static]

Definition at line 33 of file file_port.cpp.

Referenced by file_port_rep::file_port_rep().

                             {
#if !(defined(__MINGW__) || defined(__MINGW32__))
  struct flock fl;
  int fd= fileno (f);
  fl.l_type   = kind == 2? F_RDLCK: F_WRLCK;
  fl.l_whence = SEEK_SET;
  fl.l_start  = 0;
  fl.l_len    = 0;
  fl.l_pid    = getpid ();
  fcntl (fd, F_SETLKW, &fl);
  //mmout << "Locked " << fd << lf;
#endif
}

M mmx::get_mo	(	const sparse_vector< C, symbol< M >, hard_eq_sparse_vector > &	v,
		nat	i
	)			[inline]

Definition at line 363 of file sparse_vector.hpp.

                                                                          {
  return *v[i].x1;
}

int get_number_cores

(

)

Definition at line 234 of file threads.cpp.

                    {
#ifdef __linux__ // also to be used for Solaris, AIX, ...
  int nr1= sysconf (_SC_NPROCESSORS_ONLN);
  if (nr1 >= 1) return nr1;
#endif

#ifdef __APPLE__ // also to be used for BSD system
  int mib[2] = { CTL_HW, HW_AVAILCPU };
  //int mib[2] = { CTL_HW, HW_NCPU };
  int nr2;
  size_t len;
  len = sizeof (nr2);
  sysctl (mib, 2, &nr2, &len, NULL, 0);
  if (nr2 >= 1) return nr2;
#endif

#ifdef __WINDOW__upcoming
  SYSTEM_INFO sysinfo;
  GetSystemInfo( &sysinfo );
  int nr3= sysinfo.dwNumberOfProcessors;
  if (nr3 >= 1) return nr3;
#endif

#ifdef __HPUX__upcoming
  int nr4= mpctl (MPC_GETNUMSPUS, NULL, NULL);
  if (nr4 >= 1) return nr4;
#endif

#ifdef __IRIX__upcoming
  int nr5= sysconf (_SC_NPROC_ONLN);
  if (nr5 >= 1) return nr5;
#endif

  return 1;
}

string get_pid

(

)

Definition at line 105 of file system.cpp.

References as_string().

           {
  return as_string (getpid ());
}

C mmx::get_sample

(

const format< C > &

fm

)

[inline]

Definition at line 246 of file type_props.hpp.

References format< C >::sample().

                                 {
  return fm.sample ();
}

iterator<C> mmx::get_sample

(

const format< iterator< C > > &

fm

)

[inline]

Definition at line 120 of file iterator.hpp.

References Format, and Iterator.

Referenced by big(), format_as_helper< FT, T, F >::cv(), default_cst(), binary_helper< format< T > >::disassemble(), fast(), lift(), format_binary_map_helper< Op, FT, R, C1, C2 >::op(), format_binary_map_scalar_helper< Op, FT, R, C1, C2 >::op(), format_unary_map_helper< Op, FT, R, C >::op(), formatted_new_helper< FT, T >::op(), format_function_helper< FT, R, C, Fun >::op(), project(), promote(), set_default(), project_helper< vector< C, V > >::set_op(), lift_helper< vector< C, V > >::set_op(), slow(), slow_as(), implementation< vector_abstractions, V, vector_naive >::vec_binary_big(), implementation< vector_abstractions, V, vector_naive >::vec_unary_big(), implementation< vector_abstractions, V, vector_naive >::vec_unary_big_dicho(), and format_binary_helper< FT, T >::write().

                                         {
  return Iterator ((Format) fm);
}

string mmx::get_source	(	const string &	file_name,
		nat	i,
		nat(obj->lex_line)
	)

Definition at line 89 of file source_track.cpp.

References get_file_source(), and get_interactive_source().

                                                      {
  if (file_name == "") return get_interactive_source (i, line);
  return get_file_source (file_name, line);
}

string mmx::get_source	(	const string &	file_name,
		nat	i
	)

Definition at line 83 of file source_track.cpp.

References get_file_source(), and get_interactive_source().

                                            {
  if (file_name == "") return get_interactive_source (i);
  return get_file_source (file_name);
}

string mmx::get_source	(	const string &	file_name,
		nat	input_number,
		nat	line
	)

Referenced by source_string(), source_string_unindented(), and underlined().

C get_top

(

const heap< C > &

h

)

[inline]

Definition at line 187 of file heap.hpp.

Referenced by heap_iterator_rep< C >::current().

                                      {
  return h.rep->Get_top (); }

nat get_user_type

(

const generic &

name

)

Definition at line 182 of file generic_object.cpp.

References define_user_type(), GEN_ALIAS_TYPE, GEN_GENERIC_ALIAS_TYPE, GEN_TUPLE_TYPE, is_func(), and type_id().

Referenced by as_generic(), and as_object().

                                    {
  nat r= type_id (name);
  if (r == 1) {
    generic tp= name;
    if (is_func (tp, GEN_TUPLE_TYPE, 1)) tp= tp[1];
    if (is_func (tp, GEN_ALIAS_TYPE, 1)) tp= tp[1];
    if (is_func (tp, GEN_GENERIC_ALIAS_TYPE, 1)) tp= tp[1];
    define_user_type (tp);
    r= type_id (name);
  }
  return r;
}

C mmx::get_value

(

const pair< T, C > &

p

)

[inline]

Definition at line 822 of file table.hpp.

References pair< C1, C2 >::x2.

Referenced by GLUE_3().

{ return p.x2; }

alias<C> mmx::global_alias

(

C &

c

)

[inline]

Definition at line 87 of file alias.hpp.

                    {
  return new global_alias_rep<C> (c);
}

string global_path

(

)

Definition at line 201 of file system.cpp.

References _from_dos_to_unix(), command_dir(), get_env(), and path_sep.

               {
  string p = _from_dos_to_unix (get_env ("PATH"));
  return command_dir () * string (path_sep) * p;
}

nat mmx::global_type_id

(

)

[inline]

Definition at line 177 of file generic.hpp.

References new_type_id(), and T.

{ return new_type_id (typeid (T ()).name()); }  

static storage mmx::GLUE_1

(

)

[static]

Definition at line 13 of file glue_storage.cpp.

References disk_storage().

            {
    return disk_storage ();
  }

static vector<routine> mmx::GLUE_1

(

const tuple< routine > &

arg_1

)

[static]

Definition at line 13 of file glue_routine.cpp.

References as_vector().

                                       {
    return vector<routine > (as_vector (arg_1));
  }

static port mmx::GLUE_1

(

const string &

arg_1

)

[static]

Definition at line 12 of file glue_port.cpp.

References input_string_port().

                               {
    return input_string_port (arg_1);
  }

static double mmx::GLUE_1

(

const literal &

arg_1

)

[static]

Definition at line 10 of file glue_int.cpp.

References int_literal.

                                {
    return int_literal (arg_1);
  }

static bool mmx::GLUE_1

(

const generic &

arg_1

)

[static]

Definition at line 24 of file glue_syntactic.cpp.

References as_syntactic().

                                {
    return as_syntactic (arg_1);
  }

static pair<generic, generic> mmx::GLUE_1	(	const generic &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 12 of file glue_basix_table_generic.cpp.

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_double(), glue_dynamic(), glue_expression(), glue_int(), glue_list_generic(), glue_literal(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                                      {
    return pair<generic, generic > (arg_1, arg_2);
  }

static syntactic mmx::GLUE_10

(

const syntactic &

arg_1

)

[static]

Definition at line 69 of file glue_syntactic.cpp.

References square().

                                   {
    return square (arg_1);
  }

static bool mmx::GLUE_10	(	const string &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 57 of file glue_string.cpp.

                                                     {
    return arg_1 >= arg_2;
  }

static string mmx::GLUE_10	(	const storage &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 58 of file glue_storage.cpp.

References get_file().

                                                      {
    return get_file (arg_1, arg_2);
  }

static alias<vector<routine> > mmx::GLUE_10	(	const alias< vector< routine > > &	arg_1,
		const vector< routine > &	arg_2
	)			[static]

Definition at line 58 of file glue_routine.cpp.

References alias_write().

                                                                               {
    return alias_write (arg_1, arg_2);
  }

static bool mmx::GLUE_10

(

const port &

arg_1

)

[static]

Definition at line 57 of file glue_port.cpp.

References is_input_port().

                              {
    return is_input_port (arg_1);
  }

static list<generic> mmx::GLUE_10	(	const generic &	arg_1,
		const list< generic > &	arg_2
	)			[static]

Definition at line 57 of file glue_list_generic.cpp.

References cons().

                                                             {
    return cons (arg_1, arg_2);
  }

static int mmx::GLUE_10	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 55 of file glue_int.cpp.

                                               {
    return arg_1 / arg_2;
  }

static double mmx::GLUE_10	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 55 of file glue_double.cpp.

                                                     {
    return arg_1 - arg_2;
  }

static document mmx::GLUE_10

(

const document &

arg_1

)

[static]

Definition at line 70 of file glue_document.cpp.

References make_math().

                                  {
    return make_math (arg_1);
  }

static vector<generic> mmx::GLUE_10	(	const vector< generic > &	arg_1,
		const vector< generic > &	arg_2
	)			[static]

Definition at line 57 of file glue_basix_vector_generic.cpp.

References append().

                                                                       {
    return append (arg_1, arg_2);
  }

static bool mmx::GLUE_10	(	const table< generic, generic > &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 57 of file glue_basix_table_generic.cpp.

References contains().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_document(), glue_double(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                                                           {
    return contains (arg_1, arg_2);
  }

static syntactic mmx::GLUE_11	(	const syntactic &	arg_1,
		const syntactic &	arg_2
	)			[static]

Definition at line 74 of file glue_syntactic.cpp.

                                                           {
    return arg_1 + arg_2;
  }

static bool mmx::GLUE_11	(	const string &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 62 of file glue_string.cpp.

References starts().

                                                     {
    return starts (arg_1, arg_2);
  }

static bool mmx::GLUE_11	(	const storage &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 63 of file glue_storage.cpp.

References has_file().

                                                      {
    return has_file (arg_1, arg_2);
  }

static vector<routine> mmx::GLUE_11	(	const routine &	arg_1,
		const vector< routine > &	arg_2
	)			[static]

Definition at line 63 of file glue_routine.cpp.

References cons().

                                                               {
    return cons (arg_1, arg_2);
  }

static bool mmx::GLUE_11

(

const port &

arg_1

)

[static]

Definition at line 62 of file glue_port.cpp.

References error_flag().

                              {
    return error_flag (arg_1);
  }

static generic mmx::GLUE_11

(

const list< generic > &

arg_1

)

[static]

Definition at line 62 of file glue_list_generic.cpp.

References car().

                                       {
    return car (arg_1);
  }

static int mmx::GLUE_11	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 60 of file glue_int.cpp.

References quo().

                                               {
    return quo (arg_1, arg_2);
  }

static double mmx::GLUE_11	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 60 of file glue_double.cpp.

                                                     {
    return arg_1 * arg_2;
  }

static document mmx::GLUE_11

(

const tuple< document > &

arg_1

)

[static]

Definition at line 75 of file glue_document.cpp.

References as_vector(), and make_inline().

                                         {
    return make_inline (as_vector (arg_1));
  }

static alias<vector<generic> > mmx::GLUE_11	(	const alias< vector< generic > > &	arg_1,
		const vector< generic > &	arg_2
	)			[static]

Definition at line 62 of file glue_basix_vector_generic.cpp.

References alias_write().

                                                                               {
    return alias_write (arg_1, arg_2);
  }

static generic mmx::GLUE_11	(	const table< generic, generic > &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 62 of file glue_basix_table_generic.cpp.

References read().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_document(), glue_double(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                                                           {
    return read (arg_1, arg_2);
  }

static syntactic mmx::GLUE_12	(	const syntactic &	arg_1,
		const syntactic &	arg_2
	)			[static]

Definition at line 79 of file glue_syntactic.cpp.

                                                           {
    return arg_1 - arg_2;
  }

static bool mmx::GLUE_12	(	const string &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 67 of file glue_string.cpp.

References ends().

                                                     {
    return ends (arg_1, arg_2);
  }

static vector<generic> mmx::GLUE_12

(

const storage &

arg_1

)

[static]

Definition at line 68 of file glue_storage.cpp.

References retrieve_data_bis().

                                 {
    return retrieve_data_bis (arg_1);
  }

static routine mmx::GLUE_12

(

const vector< routine > &

arg_1

)

[static]

Definition at line 68 of file glue_routine.cpp.

References car().

                                         {
    return car (arg_1);
  }

static string mmx::GLUE_12

(

const port &

arg_1

)

[static]

Definition at line 67 of file glue_port.cpp.

References error_message().

                              {
    return error_message (arg_1);
  }

static list<generic> mmx::GLUE_12

(

const list< generic > &

arg_1

)

[static]

Definition at line 67 of file glue_list_generic.cpp.

References cdr().

                                       {
    return cdr (arg_1);
  }

static int mmx::GLUE_12	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 65 of file glue_int.cpp.

References rem().

                                               {
    return rem (arg_1, arg_2);
  }

static double mmx::GLUE_12	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 65 of file glue_double.cpp.

                                                     {
    return arg_1 / arg_2;
  }

static document mmx::GLUE_12

(

const tuple< document > &

arg_1

)

[static]

Definition at line 80 of file glue_document.cpp.

References as_vector(), and make_block().

                                         {
    return make_block (as_vector (arg_1));
  }

static vector<generic> mmx::GLUE_12	(	const generic &	arg_1,
		const vector< generic > &	arg_2
	)			[static]

Definition at line 67 of file glue_basix_vector_generic.cpp.

References cons().

                                                               {
    return cons (arg_1, arg_2);
  }

static alias<generic> mmx::GLUE_12	(	const alias< table< generic, generic > > &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 67 of file glue_basix_table_generic.cpp.

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_document(), glue_double(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                                                                   {
    return alias_access<generic > (arg_1, arg_2);
  }

static syntactic mmx::GLUE_13	(	const syntactic &	arg_1,
		const syntactic &	arg_2
	)			[static]

Definition at line 84 of file glue_syntactic.cpp.

                                                           {
    return arg_1 * arg_2;
  }

static string mmx::GLUE_13	(	const string &	arg_1,
		const string &	arg_2,
		const string &	arg_3
	)			[static]

Definition at line 72 of file glue_string.cpp.

References replace().

                                                                          {
    return replace (arg_1, arg_2, arg_3);
  }

static vector<generic> mmx::GLUE_13

(

const storage &

arg_1

)

[static]

Definition at line 73 of file glue_storage.cpp.

References retrieve_branches_bis().

                                 {
    return retrieve_branches_bis (arg_1);
  }

static vector<routine> mmx::GLUE_13

(

const vector< routine > &

arg_1

)

[static]

Definition at line 73 of file glue_routine.cpp.

References cdr().

                                         {
    return cdr (arg_1);
  }

static bool mmx::GLUE_13

(

const port &

arg_1

)

[static]

Definition at line 72 of file glue_port.cpp.

References busy().

                              {
    return busy (arg_1);
  }

static bool mmx::GLUE_13

(

const list< generic > &

arg_1

)

[static]

Definition at line 72 of file glue_list_generic.cpp.

References is_nil().

                                       {
    return is_nil (arg_1);
  }

static bool mmx::GLUE_13	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 70 of file glue_int.cpp.

                                               {
    return arg_1 == arg_2;
  }

static double mmx::GLUE_13

(

const double &

arg_1

)

[static]

Definition at line 70 of file glue_double.cpp.

References mmx_sqrt.

                                {
    return mmx_sqrt (arg_1);
  }

static document mmx::GLUE_13

(

const tuple< document > &

arg_1

)

[static]

Definition at line 85 of file glue_document.cpp.

References as_vector(), and make_row().

                                         {
    return make_row (as_vector (arg_1));
  }

static generic mmx::GLUE_13

(

const vector< generic > &

arg_1

)

[static]

Definition at line 72 of file glue_basix_vector_generic.cpp.

References car().

                                         {
    return car (arg_1);
  }

static void mmx::GLUE_13	(	const alias< table< generic, generic > > &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 72 of file glue_basix_table_generic.cpp.

References alias_reset().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_document(), glue_double(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                                                                   {
    alias_reset (arg_1, arg_2);
  }

static syntactic mmx::GLUE_14	(	const syntactic &	arg_1,
		const syntactic &	arg_2
	)			[static]

Definition at line 89 of file glue_syntactic.cpp.

                                                           {
    return arg_1 / arg_2;
  }

static int mmx::GLUE_14	(	const string &	arg_1,
		const string &	arg_2,
		const int &	arg_3
	)			[static]

Definition at line 77 of file glue_string.cpp.

References search_forwards().

                                                                       {
    return search_forwards (arg_1, arg_2, arg_3);
  }

static vector<generic> mmx::GLUE_14

(

const storage &

arg_1

)

[static]

Definition at line 78 of file glue_storage.cpp.

References retrieve_files_bis().

                                 {
    return retrieve_files_bis (arg_1);
  }

static bool mmx::GLUE_14

(

const vector< routine > &

arg_1

)

[static]

Definition at line 78 of file glue_routine.cpp.

References is_nil().

                                         {
    return is_nil (arg_1);
  }

static int mmx::GLUE_14

(

const port &

arg_1

)

[static]

Definition at line 77 of file glue_port.cpp.

References can_write().

                              {
    return can_write (arg_1);
  }

static bool mmx::GLUE_14

(

const list< generic > &

arg_1

)

[static]

Definition at line 77 of file glue_list_generic.cpp.

References is_atom().

                                       {
    return is_atom (arg_1);
  }

static bool mmx::GLUE_14	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 75 of file glue_int.cpp.

                                               {
    return arg_1 != arg_2;
  }

static double mmx::GLUE_14	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 75 of file glue_double.cpp.

References mmx_pow.

                                                     {
    return mmx_pow (arg_1, arg_2);
  }

static vector<generic> mmx::GLUE_14

(

const vector< generic > &

arg_1

)

[static]

Definition at line 77 of file glue_basix_vector_generic.cpp.

References cdr().

                                         {
    return cdr (arg_1);
  }

static void mmx::GLUE_14	(	const table< generic, generic > &	arg_1,
		const generic &	arg_2,
		const generic &	arg_3
	)			[static]

Definition at line 77 of file glue_basix_table_generic.cpp.

References inside_set().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_double(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                                                                                 {
    inside_set (arg_1, arg_2, arg_3);
  }

static syntactic mmx::GLUE_15	(	const syntactic &	arg_1,
		const syntactic &	arg_2
	)			[static]

Definition at line 94 of file glue_syntactic.cpp.

References pow().

                                                           {
    return pow (arg_1, arg_2);
  }

static int mmx::GLUE_15	(	const string &	arg_1,
		const string &	arg_2,
		const int &	arg_3
	)			[static]

Definition at line 82 of file glue_string.cpp.

References search_backwards().

                                                                       {
    return search_backwards (arg_1, arg_2, arg_3);
  }

static bool mmx::GLUE_15

(

const vector< routine > &

arg_1

)

[static]

Definition at line 83 of file glue_routine.cpp.

References is_atom().

                                         {
    return is_atom (arg_1);
  }

static int mmx::GLUE_15

(

const port &

arg_1

)

[static]

Definition at line 82 of file glue_port.cpp.

References can_read().

                              {
    return can_read (arg_1);
  }

static list<generic> mmx::GLUE_15	(	const list< generic > &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 82 of file glue_list_generic.cpp.

References insert().

                                                             {
    return insert (arg_1, arg_2);
  }

static bool mmx::GLUE_15	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 80 of file glue_int.cpp.

                                               {
    return arg_1 < arg_2;
  }

static double mmx::GLUE_15

(

const double &

arg_1

)

[static]

Definition at line 80 of file glue_double.cpp.

References mmx_exp.

                                {
    return mmx_exp (arg_1);
  }

static bool mmx::GLUE_15

(

const vector< generic > &

arg_1

)

[static]

Definition at line 82 of file glue_basix_vector_generic.cpp.

References is_nil().

                                         {
    return is_nil (arg_1);
  }

static table< generic , generic > mmx::GLUE_15

(

const table< generic, generic > &

arg_1

)

[static]

Definition at line 82 of file glue_basix_table_generic.cpp.

References reverse().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_double(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_string(), and glue_syntactic().

                                                     {
    return reverse (arg_1);
  }

static bool mmx::GLUE_16

(

const bool &

arg_1

)

[static]

Definition at line 99 of file glue_syntactic.cpp.

References set_frac_flag().

                              {
    return set_frac_flag (arg_1);
  }

static string mmx::GLUE_16

(

const string &

arg_1

)

[static]

Definition at line 87 of file glue_string.cpp.

References upcase().

                                {
    return upcase (arg_1);
  }

static vector<routine> mmx::GLUE_16	(	const vector< routine > &	arg_1,
		const routine &	arg_2
	)			[static]

Definition at line 88 of file glue_routine.cpp.

References insert().

                                                               {
    return insert (arg_1, arg_2);
  }

static void mmx::GLUE_16	(	const port &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 87 of file glue_port.cpp.

References write().

                                                   {
    write (arg_1, arg_2);
  }

static int mmx::GLUE_16	(	const list< generic > &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 87 of file glue_list_generic.cpp.

References find().

                                                             {
    return find (arg_1, arg_2);
  }

static bool mmx::GLUE_16	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 85 of file glue_int.cpp.

                                               {
    return arg_1 <= arg_2;
  }

static double mmx::GLUE_16

(

const double &

arg_1

)

[static]

Definition at line 85 of file glue_double.cpp.

References mmx_log.

                                {
    return mmx_log (arg_1);
  }

static bool mmx::GLUE_16

(

const vector< generic > &

arg_1

)

[static]

Definition at line 87 of file glue_basix_vector_generic.cpp.

References is_atom().

                                         {
    return is_atom (arg_1);
  }

static table< generic , generic > mmx::GLUE_16	(	const table< generic, generic > &	arg_1,
		const table< generic, generic > &	arg_2
	)			[static]

Definition at line 87 of file glue_basix_table_generic.cpp.

References append().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_double(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_string(), and glue_syntactic().

                                                                                               {
    return append (arg_1, arg_2);
  }

static syntactic mmx::GLUE_17

(

const tuple< syntactic > &

arg_1

)

[static]

Definition at line 104 of file glue_syntactic.cpp.

References as_vector(), and ordered_sum().

                                          {
    return ordered_sum (as_vector (arg_1));
  }

static string mmx::GLUE_17

(

const string &

arg_1

)

[static]

Definition at line 92 of file glue_string.cpp.

References locase().

                                {
    return locase (arg_1);
  }

static int mmx::GLUE_17	(	const vector< routine > &	arg_1,
		const routine &	arg_2
	)			[static]

Definition at line 93 of file glue_routine.cpp.

References find().

                                                               {
    return find (arg_1, arg_2);
  }

static string mmx::GLUE_17	(	const port &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 92 of file glue_port.cpp.

References read().

                                                {
    return read (arg_1, arg_2);
  }

static bool mmx::GLUE_17	(	const list< generic > &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 92 of file glue_list_generic.cpp.

References contains().

                                                             {
    return contains (arg_1, arg_2);
  }

static bool mmx::GLUE_17	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 90 of file glue_int.cpp.

                                               {
    return arg_1 > arg_2;
  }

static double mmx::GLUE_17

(

const double &

arg_1

)

[static]

Definition at line 90 of file glue_double.cpp.

References mmx_cos.

                                {
    return mmx_cos (arg_1);
  }

static vector<generic> mmx::GLUE_17	(	const vector< generic > &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 92 of file glue_basix_vector_generic.cpp.

References insert().

                                                               {
    return insert (arg_1, arg_2);
  }

static alias<table< generic , generic > > mmx::GLUE_17	(	const alias< table< generic, generic > > &	arg_1,
		const table< generic, generic > &	arg_2
	)			[static]

Definition at line 92 of file glue_basix_table_generic.cpp.

References alias_write().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_double(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_string(), and glue_syntactic().

                                                                                                       {
    return alias_write (arg_1, arg_2);
  }

static syntactic mmx::GLUE_18

(

const tuple< syntactic > &

arg_1

)

[static]

Definition at line 109 of file glue_syntactic.cpp.

References as_vector(), and ordered_product().

                                          {
    return ordered_product (as_vector (arg_1));
  }

static string mmx::GLUE_18

(

const string &

arg_1

)

[static]

Definition at line 97 of file glue_string.cpp.

References upcase_first().

                                {
    return upcase_first (arg_1);
  }

static bool mmx::GLUE_18	(	const vector< routine > &	arg_1,
		const routine &	arg_2
	)			[static]

Definition at line 98 of file glue_routine.cpp.

References contains().

                                                               {
    return contains (arg_1, arg_2);
  }

static void mmx::GLUE_18

(

const port &

arg_1

)

[static]

Definition at line 97 of file glue_port.cpp.

References flush().

                              {
    flush (arg_1);
  }

static bool mmx::GLUE_18	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 95 of file glue_int.cpp.

                                               {
    return arg_1 >= arg_2;
  }

static double mmx::GLUE_18

(

const double &

arg_1

)

[static]

Definition at line 95 of file glue_double.cpp.

References mmx_sin.

                                {
    return mmx_sin (arg_1);
  }

static int mmx::GLUE_18	(	const vector< generic > &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 97 of file glue_basix_vector_generic.cpp.

References find().

                                                               {
    return find (arg_1, arg_2);
  }

static bool mmx::GLUE_18	(	const table< generic, generic > &	arg_1,
		const generic &	arg_2,
		const generic &	arg_3,
		const tuple< generic > &	arg_4
	)			[static]

Definition at line 97 of file glue_basix_table_generic.cpp.

References as_vector(), and ttable_contains().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_double(), glue_int(), glue_port(), glue_routine(), glue_string(), and glue_syntactic().

                                                                                                                              {
    return ttable_contains (arg_1, arg_2, arg_3, as_vector (arg_4));
  }

static bool mmx::GLUE_19	(	const syntactic &	arg_1,
		const syntactic &	arg_2
	)			[static]

Definition at line 114 of file glue_syntactic.cpp.

                                                           {
    return arg_1 < arg_2;
  }

static string mmx::GLUE_19

(

const string &

arg_1

)

[static]

Definition at line 102 of file glue_string.cpp.

References locase_first().

                                {
    return locase_first (arg_1);
  }

static vector<generic> mmx::GLUE_19

(

const vector< routine > &

arg_1

)

[static]

Definition at line 103 of file glue_routine.cpp.

                                         {
    return as<vector<generic> > (arg_1);
  }

static bool mmx::GLUE_19	(	const port &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 102 of file glue_port.cpp.

References mmx_wait.

                                                {
    return mmx_wait (arg_1, arg_2);
  }

static int mmx::GLUE_19

(

const int &

arg_1

)

[static]

Definition at line 100 of file glue_int.cpp.

References sign().

                             {
    return sign (arg_1);
  }

static double mmx::GLUE_19

(

const double &

arg_1

)

[static]

Definition at line 100 of file glue_double.cpp.

References mmx_tan.

                                {
    return mmx_tan (arg_1);
  }

static bool mmx::GLUE_19	(	const vector< generic > &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 102 of file glue_basix_vector_generic.cpp.

References contains().

                                                               {
    return contains (arg_1, arg_2);
  }

static generic mmx::GLUE_19	(	const table< generic, generic > &	arg_1,
		const generic &	arg_2,
		const generic &	arg_3,
		const tuple< generic > &	arg_4
	)			[static]

Definition at line 102 of file glue_basix_table_generic.cpp.

References as_vector(), and ttable_access().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_double(), glue_int(), glue_port(), glue_routine(), glue_string(), and glue_syntactic().

                                                                                                                              {
    return ttable_access (arg_1, arg_2, arg_3, as_vector (arg_4));
  }

static vector<routine> mmx::GLUE_2

(

const tuple< routine > &

arg_1

)

[static]

Definition at line 18 of file glue_routine.cpp.

References as_vector().

                                       {
    return vector<routine > (as_vector (arg_1));
  }

static generic mmx::GLUE_2	(	const literal &	arg_1,
		const tuple< generic > &	arg_2
	)			[static]

Definition at line 21 of file glue_literal.cpp.

References as_vector(), and gen_literal_apply.

                                                             {
    return gen_literal_apply (arg_1, as_vector (arg_2));
  }

static int mmx::GLUE_2

(

const string &

arg_1

)

[static]

Definition at line 17 of file glue_string.cpp.

References N().

                               {
    return N (arg_1);
  }

static bool mmx::GLUE_2

(

const generic &

arg_1

)

[static]

Definition at line 27 of file glue_expression.cpp.

References generic_is_int().

                                {
    return generic_is_int (arg_1);
  }

static generic mmx::GLUE_2

(

const dynamic &

arg_1

)

[static]

Definition at line 18 of file glue_dynamic.cpp.

References contents().

                                {
    return contents (arg_1);
  }

static double mmx::GLUE_2

(

const int &

arg_1

)

[static]

Definition at line 29 of file glue_syntactic.cpp.

                            {
    return syntactic (arg_1);
  }

static document mmx::GLUE_2

(

const document &

arg_1

)

[static]

Definition at line 30 of file glue_document.cpp.

                                 {
    return document (arg_1);
  }

static generic mmx::GLUE_2	(	const compound &	arg_1,
		const tuple< generic > &	arg_2
	)			[static]

Definition at line 26 of file glue_compound.cpp.

References as_vector(), and gen_compound_apply.

                                                              {
    return gen_compound_apply (arg_1, as_vector (arg_2));
  }

static vector<generic> mmx::GLUE_2

(

const tuple< generic > &

arg_1

)

[static]

Definition at line 17 of file glue_list_generic.cpp.

References as_vector().

                                       {
    return list<generic > (as_vector (arg_1));
  }

static generic mmx::GLUE_2

(

const pair< generic, generic > &

arg_1

)

[static]

Definition at line 17 of file glue_basix_table_generic.cpp.

References get_key().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_double(), glue_dynamic(), glue_expression(), glue_int(), glue_list_generic(), glue_literal(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                               {
    return get_key (arg_1);
  }

static bool mmx::GLUE_20	(	const syntactic &	arg_1,
		const syntactic &	arg_2
	)			[static]

Definition at line 119 of file glue_syntactic.cpp.

                                                           {
    return arg_1 <= arg_2;
  }

static string mmx::GLUE_20

(

const string &

arg_1

)

[static]

Definition at line 107 of file glue_string.cpp.

References quote().

                                {
    return quote (arg_1);
  }

static port mmx::GLUE_20

(

const port &

arg_1

)

[static]

Definition at line 107 of file glue_port.cpp.

References accept().

                              {
    return accept (arg_1);
  }

static int mmx::GLUE_20

(

const int &

arg_1

)

[static]

Definition at line 105 of file glue_int.cpp.

References abs().

                             {
    return abs (arg_1);
  }

static double mmx::GLUE_20

(

const double &

arg_1

)

[static]

Definition at line 105 of file glue_double.cpp.

References mmx_acos.

                                {
    return mmx_acos (arg_1);
  }

static alias<generic> mmx::GLUE_20	(	const alias< table< generic, generic > > &	arg_1,
		const generic &	arg_2,
		const generic &	arg_3,
		const tuple< generic > &	arg_4
	)			[static]

Definition at line 107 of file glue_basix_table_generic.cpp.

References as_vector().

Referenced by glue_basix_table_generic(), glue_double(), glue_int(), glue_port(), glue_string(), and glue_syntactic().

                                                                                                                                      {
    return alias_tuple_access<generic > (arg_1, arg_2, arg_3, as_vector (arg_4));
  }

static bool mmx::GLUE_21	(	const syntactic &	arg_1,
		const syntactic &	arg_2
	)			[static]

Definition at line 124 of file glue_syntactic.cpp.

                                                           {
    return arg_1 > arg_2;
  }

static string mmx::GLUE_21

(

const string &

arg_1

)

[static]

Definition at line 112 of file glue_string.cpp.

References unquote().

                                {
    return unquote (arg_1);
  }

static port mmx::GLUE_21	(	const port &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 112 of file glue_port.cpp.

References component().

                                                   {
    return component (arg_1, arg_2);
  }

static int mmx::GLUE_21	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 110 of file glue_int.cpp.

References min().

                                               {
    return min (arg_1, arg_2);
  }

static double mmx::GLUE_21

(

const double &

arg_1

)

[static]

Definition at line 110 of file glue_double.cpp.

References mmx_asin.

                                {
    return mmx_asin (arg_1);
  }

static void mmx::GLUE_21	(	const alias< table< generic, generic > > &	arg_1,
		const generic &	arg_2,
		const generic &	arg_3,
		const tuple< generic > &	arg_4
	)			[static]

Definition at line 112 of file glue_basix_table_generic.cpp.

References alias_tuple_reset(), and as_vector().

Referenced by glue_basix_table_generic(), glue_double(), glue_int(), glue_port(), glue_string(), and glue_syntactic().

                                                                                                                                      {
    alias_tuple_reset (arg_1, arg_2, arg_3, as_vector (arg_4));
  }

static bool mmx::GLUE_22	(	const syntactic &	arg_1,
		const syntactic &	arg_2
	)			[static]

Definition at line 129 of file glue_syntactic.cpp.

                                                           {
    return arg_1 >= arg_2;
  }

static int mmx::GLUE_22

(

const int &

arg_1

)

[static]

Definition at line 117 of file glue_string.cpp.

References charcode_as_string().

                             {
    return charcode_as_string (arg_1);
  }

static int mmx::GLUE_22	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 115 of file glue_int.cpp.

References max().

                                               {
    return max (arg_1, arg_2);
  }

static double mmx::GLUE_22

(

const double &

arg_1

)

[static]

Definition at line 115 of file glue_double.cpp.

References mmx_atan.

Referenced by glue_double(), glue_int(), glue_port(), glue_string(), and glue_syntactic().

                                {
    return mmx_atan (arg_1);
  }

static int mmx::GLUE_23

(

const string &

arg_1

)

[static]

Definition at line 122 of file glue_string.cpp.

References string_as_charcode().

                                {
    return string_as_charcode (arg_1);
  }

static port mmx::GLUE_23	(	const port &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 122 of file glue_port.cpp.

                                                    {
    return arg_1 << arg_2;
  }

static int mmx::GLUE_23	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 120 of file glue_int.cpp.

References min().

                                               {
    return min (arg_1, arg_2);
  }

static bool mmx::GLUE_23	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 120 of file glue_double.cpp.

Referenced by glue_double(), glue_int(), glue_port(), and glue_string().

                                                     {
    return arg_1 == arg_2;
  }

static port mmx::GLUE_24	(	const port &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 127 of file glue_port.cpp.

                                                   {
    return arg_1 << arg_2;
  }

static int mmx::GLUE_24	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 125 of file glue_int.cpp.

References max().

                                               {
    return max (arg_1, arg_2);
  }

static bool mmx::GLUE_24	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 125 of file glue_double.cpp.

Referenced by glue_double(), glue_int(), and glue_port().

                                                     {
    return arg_1 != arg_2;
  }

static port mmx::GLUE_25	(	const port &	arg_1,
		const print_format &	arg_2
	)			[static]

Definition at line 132 of file glue_port.cpp.

                                                         {
    return arg_1 << arg_2;
  }

static int mmx::GLUE_25	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 130 of file glue_int.cpp.

                                               {
    return arg_1 & arg_2;
  }

static bool mmx::GLUE_25	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 130 of file glue_double.cpp.

Referenced by glue_double(), glue_int(), and glue_port().

                                                     {
    return arg_1 < arg_2;
  }

static generic mmx::GLUE_26

(

const generic &

arg_1

)

[static]

Definition at line 137 of file glue_port.cpp.

References generic_assemble().

                                 {
    return generic_assemble (arg_1);
  }

static int mmx::GLUE_26	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 135 of file glue_int.cpp.

                                               {
    return arg_1 | arg_2;
  }

static bool mmx::GLUE_26	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 135 of file glue_double.cpp.

Referenced by glue_double(), glue_int(), and glue_port().

                                                     {
    return arg_1 <= arg_2;
  }

static generic mmx::GLUE_27

(

const generic &

arg_1

)

[static]

Definition at line 142 of file glue_port.cpp.

References generic_disassemble().

                                 {
    return generic_disassemble (arg_1);
  }

static int mmx::GLUE_27	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 140 of file glue_int.cpp.

                                               {
    return arg_1 ^ arg_2;
  }

static bool mmx::GLUE_27	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 140 of file glue_double.cpp.

Referenced by glue_double(), glue_int(), and glue_port().

                                                     {
    return arg_1 > arg_2;
  }

static void mmx::GLUE_28	(	const port &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 147 of file glue_port.cpp.

References binary_write_generic().

                                                    {
    binary_write_generic (arg_1, arg_2);
  }

static int mmx::GLUE_28

(

const int &

arg_1

)

[static]

Definition at line 145 of file glue_int.cpp.

References floor_sqrt().

                             {
    return floor_sqrt (arg_1);
  }

static bool mmx::GLUE_28	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 145 of file glue_double.cpp.

Referenced by glue_double(), glue_int(), and glue_port().

                                                     {
    return arg_1 >= arg_2;
  }

static generic mmx::GLUE_29

(

const port &

arg_1

)

[static]

Definition at line 152 of file glue_port.cpp.

References binary_read_generic().

                              {
    return binary_read_generic (arg_1);
  }

static bool mmx::GLUE_29	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 150 of file glue_int.cpp.

References divides().

                                               {
    return divides (arg_1, arg_2);
  }

static int mmx::GLUE_29

(

const double &

arg_1

)

[static]

Definition at line 150 of file glue_double.cpp.

References sign().

Referenced by glue_double(), glue_int(), and glue_port().

                                {
    return sign (arg_1);
  }

static generic mmx::GLUE_3

(

const syntactic &

arg_1

)

[static]

Definition at line 34 of file glue_syntactic.cpp.

References as_generic().

                                  {
    return as_generic (arg_1);
  }

static string mmx::GLUE_3	(	const string &	arg_1,
		const int &	arg_2,
		const int &	arg_3
	)			[static]

Definition at line 22 of file glue_string.cpp.

                                                                   {
    return arg_1 (arg_2, arg_3);
  }

static storage mmx::GLUE_3

(

const storage &

arg_1

)

[static]

Definition at line 23 of file glue_storage.cpp.

References cached_storage().

                                {
    return cached_storage (arg_1);
  }

static iterator<generic> mmx::GLUE_3

(

const vector< routine > &

arg_1

)

[static]

Definition at line 23 of file glue_routine.cpp.

References iterate().

                                        {
    return as<iterator<generic> > (iterate (arg_1));
  }

static port mmx::GLUE_3

(

const string &

arg_1

)

[static]

Definition at line 22 of file glue_port.cpp.

References output_file_port().

                               {
    return output_file_port (arg_1);
  }

static generic mmx::GLUE_3	(	const literal &	arg_1,
		const tuple< generic > &	arg_2
	)			[static]

Definition at line 26 of file glue_literal.cpp.

References as_vector(), and gen_literal_access.

                                                             {
    return gen_literal_access (arg_1, as_vector (arg_2));
  }

static iterator<generic> mmx::GLUE_3

(

const list< generic > &

arg_1

)

[static]

Definition at line 22 of file glue_list_generic.cpp.

References iterate().

                                      {
    return iterate (arg_1);
  }

static string mmx::GLUE_3

(

const int &

arg_1

)

[static]

Definition at line 20 of file glue_int.cpp.

References as_string().

                            {
    return as_string (arg_1);
  }

static bool mmx::GLUE_3

(

const generic &

arg_1

)

[static]

Definition at line 32 of file glue_expression.cpp.

References generic_is_double().

                                {
    return generic_is_double (arg_1);
  }

static dynamic mmx::GLUE_3	(	const routine &	arg_1,
		const tuple< dynamic > &	arg_2
	)			[static]

Definition at line 23 of file glue_dynamic.cpp.

References as_vector().

                                                             {
    return dynamic (arg_1, as_vector (arg_2));
  }

static int mmx::GLUE_3

(

const double &

arg_1

)

[static]

Definition at line 20 of file glue_double.cpp.

References as_int().

                               {
    return as_int (arg_1);
  }

static generic mmx::GLUE_3

(

const document &

arg_1

)

[static]

Definition at line 35 of file glue_document.cpp.

References as_generic().

                                 {
    return as_generic (arg_1);
  }

static vector<generic> mmx::GLUE_3

(

const tuple< generic > &

arg_1

)

[static]

Definition at line 31 of file glue_compound.cpp.

References as_vector().

                                       {
    return compound (as_vector (arg_1));
  }

static generic mmx::GLUE_3

(

const pair< generic, generic > &

arg_1

)

[static]

Definition at line 22 of file glue_basix_table_generic.cpp.

References get_value().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_double(), glue_dynamic(), glue_expression(), glue_int(), glue_list_generic(), glue_literal(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                               {
    return get_value (arg_1);
  }

static int mmx::GLUE_30

(

)

[static]

Definition at line 155 of file glue_int.cpp.

             {
    return rand ();
  }

static double mmx::GLUE_30

(

const double &

arg_1

)

[static]

Definition at line 155 of file glue_double.cpp.

References abs().

Referenced by glue_double(), and glue_int().

                                {
    return abs (arg_1);
  }

static double mmx::GLUE_31	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 160 of file glue_double.cpp.

References min().

Referenced by glue_double().

                                                     {
    return min (arg_1, arg_2);
  }

static double mmx::GLUE_32	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 165 of file glue_double.cpp.

References max().

Referenced by glue_double().

                                                     {
    return max (arg_1, arg_2);
  }

static double mmx::GLUE_33	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 170 of file glue_double.cpp.

References min().

Referenced by glue_double().

                                                     {
    return min (arg_1, arg_2);
  }

static double mmx::GLUE_34	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 175 of file glue_double.cpp.

References max().

Referenced by glue_double().

                                                     {
    return max (arg_1, arg_2);
  }

static double mmx::GLUE_35

(

const double &

arg_1

)

[static]

Definition at line 180 of file glue_double.cpp.

References mmx_floor.

Referenced by glue_double().

                                {
    return mmx_floor (arg_1);
  }

static double mmx::GLUE_36

(

const double &

arg_1

)

[static]

Definition at line 185 of file glue_double.cpp.

References mmx_ceil.

Referenced by glue_double().

                                {
    return mmx_ceil (arg_1);
  }

static double mmx::GLUE_37

(

const double &

arg_1

)

[static]

Definition at line 190 of file glue_double.cpp.

References mmx_trunc.

Referenced by glue_double().

                                {
    return mmx_trunc (arg_1);
  }

static double mmx::GLUE_38

(

const double &

arg_1

)

[static]

Definition at line 195 of file glue_double.cpp.

References mmx_round.

Referenced by glue_double().

                                {
    return mmx_round (arg_1);
  }

static bool mmx::GLUE_39

(

const double &

arg_1

)

[static]

Definition at line 200 of file glue_double.cpp.

References is_finite().

Referenced by glue_double().

                                {
    return is_finite (arg_1);
  }

static string mmx::GLUE_4

(

const syntactic &

arg_1

)

[static]

Definition at line 39 of file glue_syntactic.cpp.

References as_string().

                                  {
    return as_string (arg_1);
  }

static string mmx::GLUE_4	(	const string &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 27 of file glue_string.cpp.

                                                    {
    return arg_1 * arg_2;
  }

static void mmx::GLUE_4	(	const storage &	arg_1,
		const string &	arg_2,
		const string &	arg_3
	)			[static]

Definition at line 28 of file glue_storage.cpp.

References write().

                                                                          {
    write (arg_1, arg_2, arg_3);
  }

static int mmx::GLUE_4

(

const vector< routine > &

arg_1

)

[static]

Definition at line 28 of file glue_routine.cpp.

References N().

                                        {
    return N (arg_1);
  }

static port mmx::GLUE_4	(	const string &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 27 of file glue_port.cpp.

References socket_server_port().

                                                 {
    return socket_server_port (arg_1, arg_2);
  }

static int mmx::GLUE_4

(

const list< generic > &

arg_1

)

[static]

Definition at line 27 of file glue_list_generic.cpp.

References N().

                                      {
    return N (arg_1);
  }

static string mmx::GLUE_4

(

const int &

arg_1

)

[static]

Definition at line 25 of file glue_int.cpp.

References as_string_hexa().

                            {
    return as_string_hexa (arg_1);
  }

static generic mmx::GLUE_4	(	const string &	arg_1,
		const bool &	arg_2
	)			[static]

Definition at line 37 of file glue_expression.cpp.

References parse_lisp().

                                                  {
    return parse_lisp (arg_1, arg_2);
  }

static void mmx::GLUE_4	(	const dynamic &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 28 of file glue_dynamic.cpp.

References assign().

                                                      {
    assign (arg_1, arg_2);
  }

static document mmx::GLUE_4

(

const string &

arg_1

)

[static]

Definition at line 31 of file glue_literal.cpp.

                               {
    return literal (arg_1);
  }

static iterator<generic> mmx::GLUE_4

(

const vector< generic > &

arg_1

)

[static]

Definition at line 36 of file glue_compound.cpp.

                                        {
    return compound (arg_1);
  }

static bool mmx::GLUE_4

(

const generic &

arg_1

)

[static]

Definition at line 27 of file glue_basix_table_generic.cpp.

References is_table().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_double(), glue_dynamic(), glue_expression(), glue_int(), glue_list_generic(), glue_literal(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                {
    return is_table (arg_1);
  }

static bool mmx::GLUE_40

(

const double &

arg_1

)

[static]

Definition at line 205 of file glue_double.cpp.

References is_infinite().

Referenced by glue_double().

                                {
    return is_infinite (arg_1);
  }

static bool mmx::GLUE_41

(

const double &

arg_1

)

[static]

Definition at line 210 of file glue_double.cpp.

References is_nan().

Referenced by glue_double().

                                {
    return is_nan (arg_1);
  }

static double mmx::GLUE_42

(

const double &

arg_1

)

[static]

Definition at line 215 of file glue_double.cpp.

References times_infinity().

Referenced by glue_double().

                                {
    return times_infinity (arg_1);
  }

static int mmx::GLUE_43

(

const double &

arg_1

)

[static]

Definition at line 220 of file glue_double.cpp.

References precision().

Referenced by glue_double().

                                {
    return precision (arg_1);
  }

static double mmx::GLUE_44	(	const double &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 225 of file glue_double.cpp.

References change_precision().

Referenced by glue_double().

                                                  {
    return change_precision (arg_1, arg_2);
  }

static double mmx::GLUE_45

(

const double &

arg_1

)

[static]

Definition at line 230 of file glue_double.cpp.

References next_above().

Referenced by glue_double().

                                {
    return next_above (arg_1);
  }

static double mmx::GLUE_46

(

const double &

arg_1

)

[static]

Definition at line 235 of file glue_double.cpp.

References next_below().

Referenced by glue_double().

                                {
    return next_below (arg_1);
  }

static int mmx::GLUE_47

(

const double &

arg_1

)

[static]

Definition at line 240 of file glue_double.cpp.

References exponent().

Referenced by glue_double().

                                {
    return exponent (arg_1);
  }

static double mmx::GLUE_48

(

const double &

arg_1

)

[static]

Definition at line 245 of file glue_double.cpp.

References magnitude().

Referenced by glue_double().

                                {
    return magnitude (arg_1);
  }

static double mmx::GLUE_49	(	const double &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 250 of file glue_double.cpp.

References incexp2().

Referenced by glue_double().

                                                  {
    return incexp2 (arg_1, arg_2);
  }

static string mmx::GLUE_5	(	const string &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 32 of file glue_string.cpp.

                                                    {
    return arg_1 * arg_2;
  }

static string mmx::GLUE_5	(	const storage &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 33 of file glue_storage.cpp.

References read().

                                                     {
    return read (arg_1, arg_2);
  }

static routine mmx::GLUE_5	(	const vector< routine > &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 33 of file glue_routine.cpp.

                                                          {
    return arg_1[arg_2];
  }

static port mmx::GLUE_5	(	const string &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 32 of file glue_port.cpp.

References socket_client_port().

                                                 {
    return socket_client_port (arg_1, arg_2);
  }

static string mmx::GLUE_5

(

const literal &

arg_1

)

[static]

Definition at line 36 of file glue_literal.cpp.

                                {
    return *arg_1;
  }

static generic mmx::GLUE_5	(	const list< generic > &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 32 of file glue_list_generic.cpp.

                                                        {
    return arg_1[arg_2];
  }

static int mmx::GLUE_5

(

const int &

arg_1

)

[static]

Definition at line 30 of file glue_int.cpp.

                            {
    return -arg_1;
  }

static string mmx::GLUE_5	(	const generic &	arg_1,
		const bool &	arg_2
	)			[static]

Definition at line 42 of file glue_expression.cpp.

References as_lisp().

                                                   {
    return as_lisp (arg_1, arg_2);
  }

static void mmx::GLUE_5	(	const string &	arg_1,
		const generic &	arg_2
	)			[static]

Definition at line 33 of file glue_dynamic.cpp.

References dynamic_event.

                                                     {
    dynamic_event (arg_1, arg_2);
  }

static string mmx::GLUE_5

(

const double &

arg_1

)

[static]

Definition at line 30 of file glue_double.cpp.

References as_string().

                               {
    return as_string (arg_1);
  }

static document mmx::GLUE_5	(	const string &	arg_1,
		const tuple< document > &	arg_2
	)			[static]

Definition at line 45 of file glue_document.cpp.

References as_vector(), and make_texmacs().

                                                             {
    return make_texmacs (arg_1, as_vector (arg_2));
  }

static vector<generic> mmx::GLUE_5

(

const compound &

arg_1

)

[static]

Definition at line 41 of file glue_compound.cpp.

References as_vector().

                                 {
    return as_vector (arg_1);
  }

static int mmx::GLUE_5

(

const vector< generic > &

arg_1

)

[static]

Definition at line 32 of file glue_basix_vector_generic.cpp.

References N().

                                        {
    return N (arg_1);
  }

static table< generic , generic > mmx::GLUE_5

(

const generic &

arg_1

)

[static]

Definition at line 44 of file glue_syntactic.cpp.

References flatten().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_double(), glue_dynamic(), glue_expression(), glue_int(), glue_list_generic(), glue_literal(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                {
    return flatten (arg_1);
  }

static double mmx::GLUE_50	(	const double &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 255 of file glue_double.cpp.

References decexp2().

Referenced by glue_double().

                                                  {
    return decexp2 (arg_1, arg_2);
  }

static double mmx::GLUE_51

(

const double &

arg_1

)

[static]

Definition at line 260 of file glue_double.cpp.

References rounding_error().

Referenced by glue_double().

                                {
    return rounding_error (arg_1);
  }

static double mmx::GLUE_52

(

const double &

arg_1

)

[static]

Definition at line 265 of file glue_double.cpp.

References additive_error().

Referenced by glue_double().

                                {
    return additive_error (arg_1);
  }

static double mmx::GLUE_53

(

const double &

arg_1

)

[static]

Definition at line 270 of file glue_double.cpp.

References multiplicative_error().

Referenced by glue_double().

                                {
    return multiplicative_error (arg_1);
  }

static double mmx::GLUE_54

(

const double &

arg_1

)

[static]

Definition at line 275 of file glue_double.cpp.

References elementary_error().

Referenced by glue_double().

                                {
    return elementary_error (arg_1);
  }

static syntactic mmx::GLUE_6

(

const syntactic &

arg_1

)

[static]

Definition at line 49 of file glue_syntactic.cpp.

References syntactic_apply.

                                  {
    return syntactic_apply (arg_1);
  }

static alias<string> mmx::GLUE_6	(	const alias< string > &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 37 of file glue_string.cpp.

References alias_write().

                                                           {
    return alias_write (arg_1, arg_2);
  }

static void mmx::GLUE_6	(	const storage &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 38 of file glue_storage.cpp.

References lock().

                                                     {
    lock (arg_1, arg_2);
  }

static alias<routine> mmx::GLUE_6	(	const alias< vector< routine > > &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 38 of file glue_routine.cpp.

                                                                  {
    return alias_access<routine > (arg_1, arg_2);
  }

static port mmx::GLUE_6

(

const string &

arg_1

)

[static]

Definition at line 37 of file glue_port.cpp.

References pipe_port().

                               {
    return pipe_port (arg_1);
  }

static alias<generic> mmx::GLUE_6	(	const alias< list< generic > > &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 37 of file glue_list_generic.cpp.

                                                                {
    return alias_access<generic > (arg_1, arg_2);
  }

static int mmx::GLUE_6

(

const int &

arg_1

)

[static]

Definition at line 35 of file glue_int.cpp.

References square().

                            {
    return square (arg_1);
  }

static string mmx::GLUE_6

(

const generic &

arg_1

)

[static]

Definition at line 47 of file glue_expression.cpp.

References flatten_as_mmx().

                                {
    return flatten_as_mmx (arg_1);
  }

static double mmx::GLUE_6	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 35 of file glue_double.cpp.

References uniform_deviate().

                                                    {
    return uniform_deviate (arg_1, arg_2);
  }

static document mmx::GLUE_6	(	const literal &	arg_1,
		const tuple< document > &	arg_2
	)			[static]

Definition at line 50 of file glue_document.cpp.

References as_vector(), and make_texmacs().

                                                              {
    return make_texmacs (arg_1, as_vector (arg_2));
  }

static int mmx::GLUE_6

(

const compound &

arg_1

)

[static]

Definition at line 46 of file glue_compound.cpp.

References N().

                                 {
    return N (arg_1);
  }

static generic mmx::GLUE_6	(	const vector< generic > &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 37 of file glue_basix_vector_generic.cpp.

                                                          {
    return arg_1[arg_2];
  }

static table< generic , generic > mmx::GLUE_6

(

const tuple< pair< generic, generic > > &

arg_1

)

[static]

Definition at line 37 of file glue_basix_table_generic.cpp.

References as_vector(), and make_mmx_table().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_double(), glue_expression(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                                       {
    return make_mmx_table (as_vector (arg_1));
  }

static syntactic mmx::GLUE_7	(	const syntactic &	arg_1,
		const syntactic &	arg_2
	)			[static]

Definition at line 54 of file glue_syntactic.cpp.

References syntactic_apply.

                                                          {
    return syntactic_apply (arg_1, arg_2);
  }

static bool mmx::GLUE_7	(	const string &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 42 of file glue_string.cpp.

                                                    {
    return arg_1 < arg_2;
  }

static void mmx::GLUE_7	(	const storage &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 43 of file glue_storage.cpp.

References unlock().

                                                     {
    unlock (arg_1, arg_2);
  }

static vector<routine> mmx::GLUE_7	(	const vector< routine > &	arg_1,
		const int &	arg_2,
		const int &	arg_3
	)			[static]

Definition at line 43 of file glue_routine.cpp.

References range().

                                                                            {
    return range (arg_1, arg_2, arg_3);
  }

static port mmx::GLUE_7

(

const tuple< port > &

arg_1

)

[static]

Definition at line 42 of file glue_port.cpp.

References as_vector(), and composite_port().

                                    {
    return composite_port (as_vector (arg_1));
  }

static list<generic> mmx::GLUE_7	(	const list< generic > &	arg_1,
		const int &	arg_2,
		const int &	arg_3
	)			[static]

Definition at line 42 of file glue_list_generic.cpp.

References range().

                                                                          {
    return range (arg_1, arg_2, arg_3);
  }

static int mmx::GLUE_7	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 40 of file glue_int.cpp.

                                              {
    return arg_1 + arg_2;
  }

static double mmx::GLUE_7

(

const double &

arg_1

)

[static]

Definition at line 40 of file glue_double.cpp.

                               {
    return -arg_1;
  }

static document mmx::GLUE_7

(

const generic &

arg_1

)

[static]

Definition at line 52 of file glue_expression.cpp.

References flatten_as_cpp().

                                {
    return flatten_as_cpp (arg_1);
  }

static generic mmx::GLUE_7	(	const compound &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 51 of file glue_compound.cpp.

                                                   {
    return arg_1[arg_2];
  }

static alias<generic> mmx::GLUE_7	(	const alias< vector< generic > > &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 42 of file glue_basix_vector_generic.cpp.

                                                                  {
    return alias_access<generic > (arg_1, arg_2);
  }

static iterator<generic> mmx::GLUE_7

(

const table< generic, generic > &

arg_1

)

[static]

Definition at line 42 of file glue_basix_table_generic.cpp.

References entries().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_double(), glue_expression(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                                    {
    return entries (arg_1);
  }

static syntactic mmx::GLUE_8	(	const syntactic &	arg_1,
		const syntactic &	arg_2,
		const syntactic &	arg_3
	)			[static]

Definition at line 59 of file glue_syntactic.cpp.

References syntactic_apply.

                                                                                  {
    return syntactic_apply (arg_1, arg_2, arg_3);
  }

static bool mmx::GLUE_8	(	const string &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 47 of file glue_string.cpp.

                                                    {
    return arg_1 <= arg_2;
  }

static storage mmx::GLUE_8	(	const storage &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 48 of file glue_storage.cpp.

References get_branch().

                                                     {
    return get_branch (arg_1, arg_2);
  }

static vector<routine> mmx::GLUE_8

(

const vector< routine > &

arg_1

)

[static]

Definition at line 48 of file glue_routine.cpp.

References reverse().

                                        {
    return reverse (arg_1);
  }

static port mmx::GLUE_8

(

const string &

arg_1

)

[static]

Definition at line 47 of file glue_port.cpp.

References error_port().

                               {
    return error_port (arg_1);
  }

static list<generic> mmx::GLUE_8

(

const list< generic > &

arg_1

)

[static]

Definition at line 47 of file glue_list_generic.cpp.

References reverse().

                                      {
    return reverse (arg_1);
  }

static int mmx::GLUE_8	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 45 of file glue_int.cpp.

                                              {
    return arg_1 - arg_2;
  }

static double mmx::GLUE_8

(

const double &

arg_1

)

[static]

Definition at line 45 of file glue_double.cpp.

References square().

                               {
    return square (arg_1);
  }

static document mmx::GLUE_8

(

const document &

arg_1

)

[static]

Definition at line 60 of file glue_document.cpp.

References make_text().

                                 {
    return make_text (arg_1);
  }

static vector<generic> mmx::GLUE_8

(

const compound &

arg_1

)

[static]

Definition at line 56 of file glue_compound.cpp.

References as_vector().

                                 {
    return as_vector (arg_1);
  }

static vector<generic> mmx::GLUE_8	(	const vector< generic > &	arg_1,
		const int &	arg_2,
		const int &	arg_3
	)			[static]

Definition at line 47 of file glue_basix_vector_generic.cpp.

References range().

                                                                            {
    return range (arg_1, arg_2, arg_3);
  }

static int mmx::GLUE_8

(

const table< generic, generic > &

arg_1

)

[static]

Definition at line 47 of file glue_basix_table_generic.cpp.

References N().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_double(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                                    {
    return N (arg_1);
  }

static syntactic mmx::GLUE_9

(

const syntactic &

arg_1

)

[static]

Definition at line 64 of file glue_syntactic.cpp.

                                  {
    return -arg_1;
  }

static bool mmx::GLUE_9	(	const string &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 52 of file glue_string.cpp.

                                                    {
    return arg_1 > arg_2;
  }

static bool mmx::GLUE_9	(	const storage &	arg_1,
		const string &	arg_2
	)			[static]

Definition at line 53 of file glue_storage.cpp.

References has_branch().

                                                     {
    return has_branch (arg_1, arg_2);
  }

static vector<routine> mmx::GLUE_9	(	const vector< routine > &	arg_1,
		const vector< routine > &	arg_2
	)			[static]

Definition at line 53 of file glue_routine.cpp.

References append().

                                                                      {
    return append (arg_1, arg_2);
  }

static bool mmx::GLUE_9

(

const port &

arg_1

)

[static]

Definition at line 52 of file glue_port.cpp.

References is_output_port().

                             {
    return is_output_port (arg_1);
  }

static list<generic> mmx::GLUE_9	(	const list< generic > &	arg_1,
		const list< generic > &	arg_2
	)			[static]

Definition at line 52 of file glue_list_generic.cpp.

References append().

                                                                  {
    return append (arg_1, arg_2);
  }

static int mmx::GLUE_9	(	const int &	arg_1,
		const int &	arg_2
	)			[static]

Definition at line 50 of file glue_int.cpp.

                                              {
    return arg_1 * arg_2;
  }

static double mmx::GLUE_9	(	const double &	arg_1,
		const double &	arg_2
	)			[static]

Definition at line 50 of file glue_double.cpp.

                                                    {
    return arg_1 + arg_2;
  }

static document mmx::GLUE_9

(

const generic &

arg_1

)

[static]

Definition at line 65 of file glue_document.cpp.

References make_math().

                                {
    return make_math (arg_1);
  }

static vector<generic> mmx::GLUE_9

(

const compound &

arg_1

)

[static]

Definition at line 61 of file glue_compound.cpp.

References compound_arguments.

                                 {
    return compound_arguments (arg_1);
  }

static vector<generic> mmx::GLUE_9

(

const vector< generic > &

arg_1

)

[static]

Definition at line 52 of file glue_basix_vector_generic.cpp.

References reverse().

                                        {
    return reverse (arg_1);
  }

static int mmx::GLUE_9

(

const table< generic, generic > &

arg_1

)

[static]

Definition at line 52 of file glue_basix_table_generic.cpp.

References discrete_complexity().

Referenced by glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_double(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_storage(), glue_string(), and glue_syntactic().

                                                    {
    return discrete_complexity (arg_1);
  }

void mmx::glue_basix

(

)

Definition at line 26 of file glue_basix.cpp.

References done(), glue_basix_table_generic(), glue_basix_vector_generic(), glue_compound(), glue_document(), glue_double(), glue_dynamic(), glue_expression(), glue_generic(), glue_int(), glue_list_generic(), glue_list_map(), glue_literal(), glue_port(), glue_routine(), glue_storage(), glue_string(), glue_syntactic(), glue_vector_map(), and register_glue().

                {
    static bool done = false;
    if (done) return;
    done = true;
    register_glue (string ("glue_basix_table_generic"), (& (glue_basix_table_generic)));
    register_glue (string ("glue_basix_vector_generic"), (& (glue_basix_vector_generic)));
    register_glue (string ("glue_compound"), (& (glue_compound)));
    register_glue (string ("glue_document"), (& (glue_document)));
    register_glue (string ("glue_double"), (& (glue_double)));
    register_glue (string ("glue_dynamic"), (& (glue_dynamic)));
    register_glue (string ("glue_expression"), (& (glue_expression)));
    register_glue (string ("glue_generic"), (& (glue_generic)));
    register_glue (string ("glue_int"), (& (glue_int)));
    register_glue (string ("glue_list_generic"), (& (glue_list_generic)));
    register_glue (string ("glue_list_map"), (& (glue_list_map)));
    register_glue (string ("glue_literal"), (& (glue_literal)));
    register_glue (string ("glue_port"), (& (glue_port)));
    register_glue (string ("glue_routine"), (& (glue_routine)));
    register_glue (string ("glue_storage"), (& (glue_storage)));
    register_glue (string ("glue_string"), (& (glue_string)));
    register_glue (string ("glue_syntactic"), (& (glue_syntactic)));
    register_glue (string ("glue_vector_map"), (& (glue_vector_map)));
    register_glue (string ("glue_basix"), (& (glue_basix)));
    glue_basix_table_generic ();
    glue_basix_vector_generic ();
    glue_compound ();
    glue_document ();
    glue_double ();
    glue_dynamic ();
    glue_expression ();
    glue_generic ();
    glue_int ();
    glue_list_generic ();
    glue_list_map ();
    glue_literal ();
    glue_port ();
    glue_routine ();
    glue_storage ();
    glue_string ();
    glue_syntactic ();
    glue_vector_map ();
  }

void glue_basix_table_generic

(

)

Definition at line 117 of file glue_basix_table_generic.cpp.

References call_glue(), define(), define_converter(), done(), gen(), GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), lit(), and PENALTY_PROMOTE_GENERIC.

Referenced by glue_basix().

                              {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_generic"));
    call_glue (string ("glue_int"));
    define_type<pair<generic, generic> > (gen (lit ("Binding"), lit ("Generic"), lit ("Generic")));
    define ("~>", GLUE_1);
    define (".key", GLUE_2);
    define (".image", GLUE_3);
    define_type<mmx_table(generic, generic) > (gen (lit ("Table"), lit ("Generic"), lit ("Generic")));
    define ("table?", GLUE_4);
    define ("table", GLUE_5);
    define ("table", GLUE_6);
    define_converter (":>", GLUE_7, PENALTY_PROMOTE_GENERIC);
    define ("#", GLUE_8);
    define ("complexity", GLUE_9);
    define ("contains?", GLUE_10);
    define (".[]", GLUE_11);
    define (".[]", GLUE_12);
    define ("reset", GLUE_13);
    define ("set", GLUE_14);
    define ("reverse", GLUE_15);
    define ("><", GLUE_16);
    define ("<<", GLUE_17);
    define ("contains?", GLUE_18);
    define (".[]", GLUE_19);
    define (".[]", GLUE_20);
    define ("reset", GLUE_21);
  }

void glue_basix_vector_generic

(

)

Definition at line 107 of file glue_basix_vector_generic.cpp.

References call_glue(), define(), define_converter(), done(), gen(), GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), lit(), and PENALTY_PROMOTE_GENERIC.

Referenced by glue_basix().

                               {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_generic"));
    call_glue (string ("glue_int"));
    define_type<vector<generic> > (gen (lit ("Vector"), lit ("Generic")));
    define ("vector?", GLUE_1);
    define ("vector", GLUE_2);
    define ("[]", GLUE_3);
    define_converter (":>", GLUE_4, PENALTY_PROMOTE_GENERIC);
    define ("#", GLUE_5);
    define (".[]", GLUE_6);
    define (".[]", GLUE_7);
    define (".[]", GLUE_8);
    define ("reverse", GLUE_9);
    define ("><", GLUE_10);
    define ("<<", GLUE_11);
    define ("cons", GLUE_12);
    define ("car", GLUE_13);
    define ("cdr", GLUE_14);
    define ("nil?", GLUE_15);
    define ("atom?", GLUE_16);
    define ("insert", GLUE_17);
    define ("find", GLUE_18);
    define ("contains?", GLUE_19);
  }

void glue_compound

(

)

Definition at line 66 of file glue_compound.cpp.

References call_glue(), define(), done(), GLUE_1(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_basix().

                   {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_literal"));
    call_glue (string ("glue_basix_vector_generic"));
    define ("compound?", GLUE_1);
    define (".()", GLUE_2);
    define ("compound", GLUE_3);
    define ("as_compound", GLUE_4);
    define ("as_vector", GLUE_5);
    define ("#", GLUE_6);
    define (".[]", GLUE_7);
    define ("components", GLUE_8);
    define ("arguments", GLUE_9);
  }

void glue_document

(

)

Definition at line 90 of file glue_document.cpp.

References call_glue(), define(), define_converter(), done(), GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), lit(), and PENALTY_INCLUSION.

Referenced by glue_basix().

                   {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_expression"));
    define_type<document > (lit ("Document"));
    define ("document", GLUE_1);
    define ("document", GLUE_2);
    define ("as_generic", GLUE_3);
    define_converter ("upgrade", GLUE_4, PENALTY_INCLUSION);
    define ("$tm", GLUE_5);
    define ("$tm", GLUE_6);
    define ("$text", GLUE_7);
    define ("$text", GLUE_8);
    define ("$math", GLUE_9);
    define ("$math", GLUE_10);
    define ("$inline", GLUE_11);
    define ("$block", GLUE_12);
    define ("(.)", GLUE_13);
  }

void glue_double

(

)

Definition at line 280 of file glue_double.cpp.

References define(), define_converter(), done(), GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_31(), GLUE_32(), GLUE_33(), GLUE_34(), GLUE_35(), GLUE_36(), GLUE_37(), GLUE_38(), GLUE_39(), GLUE_4(), GLUE_40(), GLUE_41(), GLUE_42(), GLUE_43(), GLUE_44(), GLUE_45(), GLUE_46(), GLUE_47(), GLUE_48(), GLUE_49(), GLUE_5(), GLUE_50(), GLUE_51(), GLUE_52(), GLUE_53(), GLUE_54(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), lit(), and PENALTY_INCLUSION.

Referenced by glue_basix().

                 {
    static bool done = false;
    if (done) return;
    done = true;
    define_type<double > (lit ("Double"));
    define ("literal_floating", GLUE_1);
    define_converter ("upgrade", GLUE_2, PENALTY_INCLUSION);
    define ("as_int", GLUE_3);
    define ("as_double", GLUE_4);
    define ("as_string", GLUE_5);
    define ("uniform_deviate", GLUE_6);
    define ("-", GLUE_7);
    define ("square", GLUE_8);
    define ("+", GLUE_9);
    define ("-", GLUE_10);
    define ("*", GLUE_11);
    define ("/", GLUE_12);
    define ("sqrt", GLUE_13);
    define ("^", GLUE_14);
    define ("exp", GLUE_15);
    define ("log", GLUE_16);
    define ("cos", GLUE_17);
    define ("sin", GLUE_18);
    define ("tan", GLUE_19);
    define ("arccos", GLUE_20);
    define ("arcsin", GLUE_21);
    define ("arctan", GLUE_22);
    define ("=", GLUE_23);
    define ("!=", GLUE_24);
    define ("<", GLUE_25);
    define ("<=", GLUE_26);
    define (">", GLUE_27);
    define (">=", GLUE_28);
    define ("sign", GLUE_29);
    define ("abs", GLUE_30);
    define ("min", GLUE_31);
    define ("max", GLUE_32);
    define ("inf", GLUE_33);
    define ("sup", GLUE_34);
    define ("floor", GLUE_35);
    define ("ceil", GLUE_36);
    define ("trunc", GLUE_37);
    define ("round", GLUE_38);
    define ("finite?", GLUE_39);
    define ("infinite?", GLUE_40);
    define ("nan?", GLUE_41);
    define ("times_infinity", GLUE_42);
    define ("precision", GLUE_43);
    define ("change_precision", GLUE_44);
    define ("next_above", GLUE_45);
    define ("next_below", GLUE_46);
    define ("exponent", GLUE_47);
    define ("magnitude", GLUE_48);
    define ("increase_exponent", GLUE_49);
    define ("decrease_exponent", GLUE_50);
    define ("rounding_error", GLUE_51);
    define ("additive_error", GLUE_52);
    define ("multiplicative_error", GLUE_53);
    define ("elementary_error", GLUE_54);
  }

void glue_dynamic

(

)

Definition at line 38 of file glue_dynamic.cpp.

References call_glue(), define(), done(), GLUE_1(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), and lit().

Referenced by glue_basix().

                  {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_generic"));
    call_glue (string ("glue_routine"));
    define_type<dynamic > (lit ("Dynamic"));
    define ("dynamic", GLUE_1);
    define ("contents", GLUE_2);
    define ("apply", GLUE_3);
    define ("assign", GLUE_4);
    define ("dynamic_notify", GLUE_5);
  }

void glue_expression

(

)

Definition at line 57 of file glue_expression.cpp.

References call_glue(), define(), done(), GLUE_1(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), and GLUE_7().

Referenced by glue_basix().

                     {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_generic"));
    call_glue (string ("glue_literal"));
    call_glue (string ("glue_compound"));
    define ("boolean?", GLUE_1);
    define ("int?", GLUE_2);
    define ("double?", GLUE_3);
    define ("parse_lisp", GLUE_4);
    define ("as_lisp", GLUE_5);
    define ("flatten_as_mmx", GLUE_6);
    define ("flatten_as_cpp", GLUE_7);
  }

void glue_generic

(

)

Definition at line 6 of file glue_generic.cpp.

References done().

Referenced by glue_basix().

                  {
    static bool done = false;
    if (done) return;
    done = true;
  }

void glue_int

(

)

Definition at line 160 of file glue_int.cpp.

References define(), done(), GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_30(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), int_minus_infinity, int_plus_infinity, and lit().

Referenced by glue_basix().

              {
    static bool done = false;
    if (done) return;
    done = true;
    define_type<int > (lit ("Int"));
    define ("literal_integer", GLUE_1);
    define ("as_int", GLUE_2);
    define ("as_string", GLUE_3);
    define ("as_string_hexa", GLUE_4);
    define ("-", GLUE_5);
    define ("square", GLUE_6);
    define ("+", GLUE_7);
    define ("-", GLUE_8);
    define ("*", GLUE_9);
    define ("div", GLUE_10);
    define ("quo", GLUE_11);
    define ("rem", GLUE_12);
    define ("=", GLUE_13);
    define ("!=", GLUE_14);
    define ("<", GLUE_15);
    define ("<=", GLUE_16);
    define (">", GLUE_17);
    define (">=", GLUE_18);
    define ("sign", GLUE_19);
    define ("abs", GLUE_20);
    define ("min", GLUE_21);
    define ("max", GLUE_22);
    define ("inf", GLUE_23);
    define ("sup", GLUE_24);
    define ("/\\", GLUE_25);
    define ("\\/", GLUE_26);
    define ("xor", GLUE_27);
    define ("floor_sqrt", GLUE_28);
    define ("divides?", GLUE_29);
    define ("random", GLUE_30);
    define_constant<int > ("int_minus_infinity", int_minus_infinity);
    define_constant<int > ("int_plus_infinity", int_plus_infinity);
  }

void glue_list_generic

(

)

Definition at line 97 of file glue_list_generic.cpp.

References call_glue(), define(), define_converter(), done(), gen(), GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), lit(), and PENALTY_PROMOTE_GENERIC.

Referenced by glue_basix().

                       {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_generic"));
    call_glue (string ("glue_int"));
    define_type<list<generic> > (gen (lit ("List"), lit ("Generic")));
    define ("list?", GLUE_1);
    define ("list", GLUE_2);
    define_converter (":>", GLUE_3, PENALTY_PROMOTE_GENERIC);
    define ("#", GLUE_4);
    define (".[]", GLUE_5);
    define (".[]", GLUE_6);
    define (".[]", GLUE_7);
    define ("reverse", GLUE_8);
    define ("><", GLUE_9);
    define ("cons", GLUE_10);
    define ("car", GLUE_11);
    define ("cdr", GLUE_12);
    define ("nil?", GLUE_13);
    define ("atom?", GLUE_14);
    define ("insert", GLUE_15);
    define ("find", GLUE_16);
    define ("contains?", GLUE_17);
  }

void glue_list_map

(

)

Definition at line 160 of file glue_list_map.cpp.

References call_glue(), define(), done(), list_append_several(), list_apply(), list_foreach(), list_map(), list_sort(), and register_glue().

Referenced by glue_basix().

                 {
  static bool done = false;
  if (done) return;
  done = true;
  register_glue ("glue_list_map", &glue_list_map);
  call_glue ("glue_list_generic");
  define ("map", list_map);
  define ("foreach", list_foreach);
  define ("append", list_append_several);
  define ("apply", list_apply);
  define ("sort", list_sort);
  //define ("filter", list_filter);
  //define ("find_index", list_find_index);
}

void glue_literal

(

)

Definition at line 41 of file glue_literal.cpp.

References call_glue(), define(), done(), GLUE_1(), GLUE_2(), GLUE_3(), GLUE_4(), and GLUE_5().

Referenced by glue_basix().

                  {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_string"));
    define ("literal?", GLUE_1);
    define (".()", GLUE_2);
    define (".[]", GLUE_3);
    define ("as_literal", GLUE_4);
    define ("as_string", GLUE_5);
  }

void glue_port

(

)

Definition at line 157 of file glue_port.cpp.

References black_background, black_foreground, blank, blink, blue_background, blue_foreground, bold, call_glue(), cr, cyan_background, cyan_foreground, define(), done(), flush_now, GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_22(), GLUE_23(), GLUE_24(), GLUE_25(), GLUE_26(), GLUE_27(), GLUE_28(), GLUE_29(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), green_background, green_foreground, hrule, indent, lf, lit(), magenta_background, magenta_foreground, mmerr, mmin, mmout, red_background, red_foreground, reset_attributes, reset_indent, stroke, underline, unindent, white_background, white_foreground, yellow_background, and yellow_foreground.

Referenced by glue_basix().

               {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_int"));
    call_glue (string ("glue_string"));
    define_type<print_format > (lit ("Print_format"));
    define_constant<print_format > ("blank", blank);
    define_constant<print_format > ("stroke", stroke);
    define_constant<print_format > ("indent", indent);
    define_constant<print_format > ("unindent", unindent);
    define_constant<print_format > ("reset_indent", reset_indent);
    define_constant<print_format > ("cr", cr);
    define_constant<print_format > ("lf", lf);
    define_constant<print_format > ("hrule", hrule);
    define_constant<print_format > ("flush_now", flush_now);
    define_constant<print_format > ("black_foreground", black_foreground);
    define_constant<print_format > ("red_foreground", red_foreground);
    define_constant<print_format > ("green_foreground", green_foreground);
    define_constant<print_format > ("yellow_foreground", yellow_foreground);
    define_constant<print_format > ("blue_foreground", blue_foreground);
    define_constant<print_format > ("magenta_foreground", magenta_foreground);
    define_constant<print_format > ("cyan_foreground", cyan_foreground);
    define_constant<print_format > ("white_foreground", white_foreground);
    define_constant<print_format > ("black_background", black_background);
    define_constant<print_format > ("red_background", red_background);
    define_constant<print_format > ("green_background", green_background);
    define_constant<print_format > ("yellow_background", yellow_background);
    define_constant<print_format > ("blue_background", blue_background);
    define_constant<print_format > ("magenta_background", magenta_background);
    define_constant<print_format > ("cyan_background", cyan_background);
    define_constant<print_format > ("white_background", white_background);
    define_constant<print_format > ("bold", bold);
    define_constant<print_format > ("underline", underline);
    define_constant<print_format > ("blink", blink);
    define_constant<print_format > ("reset_attributes", reset_attributes);
    define_type<port > (lit ("Port"));
    define_constant<port > ("mmin", mmin);
    define_constant<port > ("mmout", mmout);
    define_constant<port > ("mmerr", mmerr);
    define ("input_string_port", GLUE_1);
    define ("input_file_port", GLUE_2);
    define ("output_file_port", GLUE_3);
    define ("socket_server_port", GLUE_4);
    define ("socket_client_port", GLUE_5);
    define ("pipe_port", GLUE_6);
    define ("composite_port", GLUE_7);
    define ("error_port", GLUE_8);
    define (".output_port?", GLUE_9);
    define (".input_port?", GLUE_10);
    define (".error?", GLUE_11);
    define (".error", GLUE_12);
    define (".busy?", GLUE_13);
    define (".can_write", GLUE_14);
    define (".can_read", GLUE_15);
    define ("write", GLUE_16);
    define ("read", GLUE_17);
    define ("flush", GLUE_18);
    define ("wait", GLUE_19);
    define ("accept", GLUE_20);
    define (".[]", GLUE_21);
    define ("wait", GLUE_22);
    define ("<<", GLUE_23);
    define ("<<", GLUE_24);
    define ("<<", GLUE_25);
    define ("binary_assemble", GLUE_26);
    define ("binary_disassemble", GLUE_27);
    define ("binary_write", GLUE_28);
    define ("binary_read", GLUE_29);
  }

void glue_routine

(

)

Definition at line 108 of file glue_routine.cpp.

References call_glue(), define(), define_converter(), done(), gen(), GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), lit(), PENALTY_CAST, and PENALTY_PROMOTE_GENERIC.

Referenced by glue_basix().

                  {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_basix_vector_generic"));
    define_type<vector<routine> > (gen (lit ("Vector"), lit ("Routine")));
    define ("vector", GLUE_1);
    define ("[]", GLUE_2);
    define_converter (":>", GLUE_3, PENALTY_CAST);
    define ("#", GLUE_4);
    define (".[]", GLUE_5);
    define (".[]", GLUE_6);
    define (".[]", GLUE_7);
    define ("reverse", GLUE_8);
    define ("><", GLUE_9);
    define ("<<", GLUE_10);
    define ("cons", GLUE_11);
    define ("car", GLUE_12);
    define ("cdr", GLUE_13);
    define ("nil?", GLUE_14);
    define ("atom?", GLUE_15);
    define ("insert", GLUE_16);
    define ("find", GLUE_17);
    define ("contains?", GLUE_18);
    define_converter (":>", GLUE_19, PENALTY_PROMOTE_GENERIC);
  }

void glue_storage

(

)

Definition at line 83 of file glue_storage.cpp.

References call_glue(), define(), done(), GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_2(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), and lit().

Referenced by glue_basix().

                  {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_string"));
    call_glue (string ("glue_basix_vector_generic"));
    call_glue (string ("glue_basix_table_generic"));
    define_type<storage > (lit ("Storage"));
    define ("disk_storage", GLUE_1);
    define ("disk_storage", GLUE_2);
    define ("cached_storage", GLUE_3);
    define ("write", GLUE_4);
    define ("read", GLUE_5);
    define ("lock", GLUE_6);
    define ("unlock", GLUE_7);
    define ("get_branch", GLUE_8);
    define ("has_branch?", GLUE_9);
    define ("get_file", GLUE_10);
    define ("has_file?", GLUE_11);
    define (".data", GLUE_12);
    define (".branches", GLUE_13);
    define (".files", GLUE_14);
  }

void glue_string

(

)

Definition at line 127 of file glue_string.cpp.

References call_glue(), define(), done(), GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_22(), GLUE_23(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), and GLUE_9().

Referenced by glue_basix().

                 {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_basix_vector_generic"));
    define ("string?", GLUE_1);
    define ("#", GLUE_2);
    define (".[]", GLUE_3);
    define ("*", GLUE_4);
    define ("><", GLUE_5);
    define ("<<", GLUE_6);
    define ("<", GLUE_7);
    define ("<=", GLUE_8);
    define (">", GLUE_9);
    define (">=", GLUE_10);
    define ("starts?", GLUE_11);
    define ("ends?", GLUE_12);
    define ("replace", GLUE_13);
    define ("search_forwards", GLUE_14);
    define ("search_backwards", GLUE_15);
    define ("upcase", GLUE_16);
    define ("locase", GLUE_17);
    define ("upcase_first", GLUE_18);
    define ("locase_first", GLUE_19);
    define ("quote", GLUE_20);
    define ("unquote", GLUE_21);
    define ("ascii", GLUE_22);
    define ("ascii_code", GLUE_23);
  }

void glue_syntactic

(

)

Definition at line 134 of file glue_syntactic.cpp.

References call_glue(), define(), define_converter(), done(), GLUE_1(), GLUE_10(), GLUE_11(), GLUE_12(), GLUE_13(), GLUE_14(), GLUE_15(), GLUE_16(), GLUE_17(), GLUE_18(), GLUE_19(), GLUE_2(), GLUE_20(), GLUE_21(), GLUE_22(), GLUE_3(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_7(), GLUE_8(), GLUE_9(), lit(), and PENALTY_INCLUSION.

Referenced by glue_basix().

                    {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_expression"));
    define_type<syntactic > (lit ("Syntactic"));
    define ("syntactic", GLUE_1);
    define_converter (":>", GLUE_2, PENALTY_INCLUSION);
    define ("as_generic", GLUE_3);
    define ("as_string", GLUE_4);
    define ("flatten", GLUE_5);
    define ("apply", GLUE_6);
    define ("apply", GLUE_7);
    define ("apply", GLUE_8);
    define ("-", GLUE_9);
    define ("square", GLUE_10);
    define ("+", GLUE_11);
    define ("-", GLUE_12);
    define ("*", GLUE_13);
    define ("/", GLUE_14);
    define ("^", GLUE_15);
    define ("set_frac_flag", GLUE_16);
    define ("ordered_sum", GLUE_17);
    define ("ordered_product", GLUE_18);
    define ("<", GLUE_19);
    define ("<=", GLUE_20);
    define (">", GLUE_21);
    define (">=", GLUE_22);
  }

void glue_vector_map

(

)

Definition at line 163 of file glue_vector_map.cpp.

References call_glue(), define(), done(), register_glue(), vector_append_several(), vector_apply(), vector_foreach(), vector_map(), vector_sort(), and vector_sort_leq().

Referenced by glue_basix().

                   {
  static bool done = false;
  if (done) return;
  done = true;
  register_glue ("glue_vector_map", &glue_vector_map);
  call_glue ("glue_basix_vector_generic");
  define ("map", vector_map);
  define ("foreach", vector_foreach);
  define ("append", vector_append_several);
  define ("apply", vector_apply);
  define ("sort", vector_sort);
  define ("sort", vector_sort_leq);
}

bool mmx::gtr_operator	(	const T &	x,
		const T &	y
	)			[inline]

Definition at line 40 of file operators.hpp.

{ return x>y; }

bool mmx::gtreq_operator	(	const T &	x,
		const T &	y
	)			[inline]

Definition at line 41 of file operators.hpp.

{ return x>=y; }

static void mmx::handle_completion_request

(

const string &

request

)

[static]

Definition at line 128 of file texmacs_interface.cpp.

References complete(), mmerr, N(), output_completion(), parse_completion_request(), and pos.

Referenced by shell_texmacs_input().

                                                  {
  string text;
  nat pos, i, p;
  p = 0;
  pos = 0;
  if (!parse_completion_request (request, pos, text, p)
      || p < 1 || p >= N(request)) {
    output_completion ("", list<string>());
    mmerr << "mmx warning: ignoring texmacs request" << "\n";
    return;
  }
  i=p-1;
  while (i+1 > 0 && ((text[i] >= 'a' && text[i] <= 'z')
                     || (text[i] >= 'A' && text[i] <= 'Z')
                     || text[i] == '_'))
    i--;
  complete (text (i+1, p));
}

bool mmx::hard_eq	(	const updater &	x,
		const updater &	y
	)			[inline]

Definition at line 133 of file dynamic.cpp.

: public observer_rep {

bool mmx::hard_eq	(	const vector< C, V > &	x,
		const vector< C, V > &	y
	)			[inline]

Definition at line 207 of file vector.hpp.

{ return v->n; }

bool mmx::hard_eq	(	const format< C > &	x,
		const format< C > &	y
	)			[inline]

Definition at line 221 of file type_props.hpp.

{ return true; }

bool mmx::hard_eq	(	const triple< C1, C2, C3 > &	x,
		const triple< C1, C2, C3 > &	y
	)			[inline]

Definition at line 60 of file triple.hpp.

{

bool mmx::hard_eq	(	const task &	x,
		const task &	y
	)			[inline]

Definition at line 41 of file threads.hpp.

bool mmx::hard_eq	(	const table< C, T, V > &	x,
		const table< C, T, V > &	y
	)			[inline]

Definition at line 157 of file table.hpp.

{ return t->tfm1 (); }

bool mmx::hard_eq	(	const syntactic &	c1,
		const syntactic &	c2
	)			[inline]

Definition at line 58 of file syntactic.hpp.

References hard_eq().

                                                               {
  return hard_eq (*c1, *c2); }

bool mmx::hard_eq	(	const symbol< C, V > &	x,
		const symbol< C, V > &	y
	)			[inline]

Definition at line 92 of file symbol.hpp.

{

bool mmx::hard_eq	(	const string &	x,
		const string &	y
	)			[inline]

Definition at line 105 of file string.hpp.

{ return copy (s); }

bool mmx::hard_eq	(	const storage &	x,
		const storage &	y
	)			[inline]

Definition at line 53 of file storage.hpp.

{ return "storage"; }

bool mmx::hard_eq	(	const sparse_vector< C, T, V > &	x,
		const sparse_vector< C, T, V > &	y
	)			[inline]

Definition at line 96 of file sparse_vector.hpp.

{ return v.rep->n; }

bool mmx::hard_eq	(	const routine &	x,
		const routine &	y
	)			[inline]

Definition at line 96 of file routine.hpp.

{

bool mmx::hard_eq	(	const primitive &	x,
		const primitive &	y
	)			[inline]

Definition at line 43 of file primitive.hpp.

{

bool mmx::hard_eq	(	const port &	x,
		const port &	y
	)			[inline]

Definition at line 61 of file port.hpp.

{ return p->expression (); }

bool mmx::hard_eq	(	const pair< C1, C2 > &	x,
		const pair< C1, C2 > &	y
	)			[inline]

Definition at line 55 of file pair.hpp.

{

bool mmx::hard_eq	(	const new_table< C, T, V > &	x,
		const new_table< C, T, V > &	y
	)			[inline]

Definition at line 179 of file new_table.hpp.

{ return t->tfm1 (); }

bool mmx::hard_eq	(	const Indirect< R > &	x,
		const Indirect< R > &	y
	)			[inline]

Definition at line 762 of file mmc_glue.hpp.

References Indirect< R >::rep.

                                                                      {
  return x.rep == y.rep; }

bool mmx::hard_eq	(	const literal &	c1,
		const literal &	c2
	)			[inline]

Definition at line 52 of file literal.hpp.

References as_string(), and hard_eq().

                                                           {
  return hard_eq (as_string (c1), as_string (c2)); }

bool mmx::hard_eq	(	const list< C > &	x,
		const list< C > &	y
	)			[inline]

Definition at line 127 of file list.hpp.

                                                        {
  return (x.operator -> ()) == (y.operator -> ()); }

bool mmx::hard_eq	(	const iterator< C > &	x,
		const iterator< C > &	y
	)			[inline]

Definition at line 95 of file iterator.hpp.

{ return it.rep->is_busy (); }

bool mmx::hard_eq	(	const heap< C > &	x,
		const heap< C > &	y
	)			[inline]

Definition at line 96 of file heap.hpp.

bool mmx::hard_eq	(	const generic_function &	x,
		const generic_function &	y
	)			[inline]

Definition at line 47 of file generic_function.hpp.

{

bool mmx::hard_eq	(	const generic &	x,
		const generic &	y
	)			[inline]

Definition at line 146 of file generic.hpp.

bool mmx::hard_eq	(	const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &	f,
		const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &	g
	)			[inline]

Definition at line 609 of file function.hpp.

                                                                {
  return (f.rep) == (g.rep); }

bool mmx::hard_eq	(	const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &	f,
		const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &	g
	)			[inline]

Definition at line 549 of file function.hpp.

                                                                {
  return (f.rep) == (g.rep); }

bool mmx::hard_eq	(	const function_6< D, S1, S2, S3, S4, S5, S6 > &	f,
		const function_6< D, S1, S2, S3, S4, S5, S6 > &	g
	)			[inline]

Definition at line 489 of file function.hpp.

                                                                {
  return (f.rep) == (g.rep); }

bool mmx::hard_eq	(	const function_5< D, S1, S2, S3, S4, S5 > &	f,
		const function_5< D, S1, S2, S3, S4, S5 > &	g
	)			[inline]

Definition at line 430 of file function.hpp.

                                                                {
  return (f.rep) == (g.rep); }

bool mmx::hard_eq	(	const function_4< D, S1, S2, S3, S4 > &	f,
		const function_4< D, S1, S2, S3, S4 > &	g
	)			[inline]

Definition at line 371 of file function.hpp.

                                                                {
  return (f.rep) == (g.rep); }

bool mmx::hard_eq	(	const function_3< D, S1, S2, S3 > &	f,
		const function_3< D, S1, S2, S3 > &	g
	)			[inline]

Definition at line 312 of file function.hpp.

                                                                {
  return (f.rep) == (g.rep); }

bool mmx::hard_eq	(	const function_2< D, S1, S2 > &	f,
		const function_2< D, S1, S2 > &	g
	)			[inline]

Definition at line 253 of file function.hpp.

                                                                {
  return (f.rep) == (g.rep); }

bool mmx::hard_eq	(	const function_1< D, S1 > &	f,
		const function_1< D, S1 > &	g
	)			[inline]

Definition at line 153 of file function.hpp.

                                                                {
  return (f.rep) == (g.rep); }

bool mmx::hard_eq	(	const function_0< D > &	f,
		const function_0< D > &	g
	)			[inline]

Definition at line 97 of file function.hpp.

                                                                {
  return (f.rep) == (g.rep); }

bool mmx::hard_eq	(	const exception &	e1,
		const exception &	e2
	)			[inline]

Definition at line 47 of file exception.hpp.

References hard_eq().

                                                               {
  return hard_eq (*e1, *e2); }

bool mmx::hard_eq	(	const evaluator &	x,
		const evaluator &	y
	)			[inline]

Definition at line 65 of file evaluator.hpp.

bool mmx::hard_eq	(	const dynamic &	x,
		const dynamic &	y
	)			[inline]

Definition at line 85 of file dynamic.hpp.

{ return inside (d) -> val; }

bool mmx::hard_eq	(	const observer &	x,
		const observer &	y
	)			[inline]

Definition at line 56 of file dynamic.hpp.

: public rep_struct {

bool mmx::hard_eq	(	const document &	c1,
		const document &	c2
	)			[inline]

Definition at line 59 of file document.hpp.

References hard_eq().

                                                             {
  return hard_eq (*c1, *c2); }

bool mmx::hard_eq	(	const compound &	c1,
		const compound &	c2
	)			[inline]

Definition at line 57 of file compound.hpp.

References as_vector(), and hard_eq().

                                                             {
  return hard_eq (as_vector (c1), as_vector (c2)); }

bool mmx::hard_eq	(	const chain< C > &	x,
		const chain< C > &	y
	)			[inline]

Definition at line 118 of file chain.hpp.

                                                          {
  return (x.operator -> ()) == (y.operator -> ()); }

bool mmx::hard_eq	(	const cache< C, T > &	c1,
		const cache< C, T > &	c2
	)			[inline]

Definition at line 50 of file cache.hpp.

References hard_eq().

                                                            {
  return hard_eq (*c1, *c2); }

bool mmx::hard_eq	(	const C &	x,
		const C &	y
	)			[inline]

Definition at line 269 of file basix.hpp.

References exact_eq().

Referenced by detach(), exact_eq(), hard_eq(), generic_object_rep::is_hard_eq(), generic_concrete_rep< C >::is_hard_eq(), hard_neq_op::not_op(), hard_eq_op::op(), and operator==().

                                                                  {
  return exact_eq (x, y); }

bool mmx::hard_gtr	(	const C &	x,
		const C &	y
	)			[inline]

Definition at line 275 of file basix.hpp.

References inside().

Referenced by hard_gtr_op::op().

                                                                   {
  return ((void*) inside (x)) > ((void*) inside (y)); }

nat mmx::hard_hash

(

const updater &

x

)

[inline]

Definition at line 133 of file dynamic.cpp.

: public observer_rep {

nat mmx::hard_hash

(

const vector< C, V > &

x

)

[inline]

Definition at line 207 of file vector.hpp.

{ return v->n; }

nat mmx::hard_hash

(

const format< C > &

x

)

[inline]

Definition at line 233 of file type_props.hpp.

{ return 0; }

nat mmx::hard_hash

(

const triple< C1, C2, C3 > &

x

)

[inline]

Definition at line 60 of file triple.hpp.

{

nat mmx::hard_hash

(

const task &

x

)

[inline]

Definition at line 41 of file threads.hpp.

nat mmx::hard_hash

(

const table< C, T, V > &

x

)

[inline]

Definition at line 157 of file table.hpp.

{ return t->tfm1 (); }

nat mmx::hard_hash

(

const syntactic &

c

)

[inline]

Definition at line 49 of file syntactic.hpp.

References hard_hash().

{ return hard_hash (*c); }

nat mmx::hard_hash

(

const symbol< C, V > &

x

)

[inline]

Definition at line 92 of file symbol.hpp.

{

nat mmx::hard_hash

(

const string &

x

)

[inline]

Definition at line 105 of file string.hpp.

{ return copy (s); }

nat mmx::hard_hash

(

const storage &

x

)

[inline]

Definition at line 53 of file storage.hpp.

{ return "storage"; }

nat mmx::hard_hash

(

const sparse_vector< C, T, V > &

x

)

[inline]

Definition at line 96 of file sparse_vector.hpp.

{ return v.rep->n; }

nat mmx::hard_hash

(

const routine &

x

)

[inline]

Definition at line 96 of file routine.hpp.

{

nat mmx::hard_hash

(

const primitive &

x

)

[inline]

Definition at line 43 of file primitive.hpp.

{

nat mmx::hard_hash

(

const port &

x

)

[inline]

Definition at line 61 of file port.hpp.

{ return p->expression (); }

nat mmx::hard_hash

(

const pair< C1, C2 > &

x

)

[inline]

Definition at line 55 of file pair.hpp.

{

nat mmx::hard_hash

(

const new_table< C, T, V > &

x

)

[inline]

Definition at line 179 of file new_table.hpp.

{ return t->tfm1 (); }

nat mmx::hard_hash

(

const Indirect< R > &

x

)

[inline]

Definition at line 770 of file mmc_glue.hpp.

References as_hash(), and Indirect< R >::rep.

                                                 {
  return as_hash (x.rep); }

nat mmx::hard_hash

(

const literal &

c

)

[inline]

Definition at line 43 of file literal.hpp.

References as_string(), and hard_hash().

{ return hard_hash (as_string (c)); }

nat mmx::hard_hash

(

const list< C > &

x

)

[inline]

Definition at line 125 of file list.hpp.

References as_hash().

                                          {
  return as_hash (x.operator -> ()); }

nat mmx::hard_hash

(

const iterator< C > &

x

)

[inline]

Definition at line 95 of file iterator.hpp.

{ return it.rep->is_busy (); }

nat mmx::hard_hash

(

const heap< C > &

x

)

[inline]

Definition at line 96 of file heap.hpp.

nat mmx::hard_hash

(

const generic_function &

x

)

[inline]

Definition at line 47 of file generic_function.hpp.

{

nat mmx::hard_hash

(

const generic &

x

)

[inline]

Definition at line 146 of file generic.hpp.

nat mmx::hard_hash

(

const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &

f

)

[inline]

Definition at line 607 of file function.hpp.

References as_hash().

                                              {
  return as_hash (f.rep); }

nat mmx::hard_hash

(

const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &

f

)

[inline]

Definition at line 547 of file function.hpp.

References as_hash().

                                              {
  return as_hash (f.rep); }

nat mmx::hard_hash

(

const function_6< D, S1, S2, S3, S4, S5, S6 > &

f

)

[inline]

Definition at line 487 of file function.hpp.

References as_hash().

                                              {
  return as_hash (f.rep); }

nat mmx::hard_hash

(

const function_5< D, S1, S2, S3, S4, S5 > &

f

)

[inline]

Definition at line 428 of file function.hpp.

References as_hash().

                                              {
  return as_hash (f.rep); }

nat mmx::hard_hash

(

const function_4< D, S1, S2, S3, S4 > &

f

)

[inline]

Definition at line 369 of file function.hpp.

References as_hash().

                                              {
  return as_hash (f.rep); }

nat mmx::hard_hash

(

const function_3< D, S1, S2, S3 > &

f

)

[inline]

Definition at line 310 of file function.hpp.

References as_hash().

                                              {
  return as_hash (f.rep); }

nat mmx::hard_hash

(

const function_2< D, S1, S2 > &

f

)

[inline]

Definition at line 251 of file function.hpp.

References as_hash().

                                              {
  return as_hash (f.rep); }

nat mmx::hard_hash

(

const function_1< D, S1 > &

f

)

[inline]

Definition at line 151 of file function.hpp.

References as_hash().

                                              {
  return as_hash (f.rep); }

nat mmx::hard_hash

(

const function_0< D > &

f

)

[inline]

Definition at line 95 of file function.hpp.

References as_hash().

                                              {
  return as_hash (f.rep); }

nat mmx::hard_hash

(

const exception &

e

)

[inline]

Definition at line 38 of file exception.hpp.

References hard_hash().

{ return hard_hash (*e); }

nat mmx::hard_hash

(

const evaluator &

x

)

[inline]

Definition at line 65 of file evaluator.hpp.

nat mmx::hard_hash

(

const dynamic &

x

)

[inline]

Definition at line 85 of file dynamic.hpp.

{ return inside (d) -> val; }

nat mmx::hard_hash

(

const observer &

x

)

[inline]

Definition at line 56 of file dynamic.hpp.

: public rep_struct {

nat mmx::hard_hash

(

const document &

c

)

[inline]

Definition at line 50 of file document.hpp.

References hard_hash().

{ return hard_hash (*c); }

nat mmx::hard_hash

(

const compound &

c

)

[inline]

Definition at line 47 of file compound.hpp.

References as_vector(), and hard_hash().

                                         {
  return hard_hash (as_vector (c)); }

nat mmx::hard_hash

(

const chain< C > &

x

)

[inline]

Definition at line 116 of file chain.hpp.

References as_hash().

                                           {
  return as_hash (x.operator -> ()); }

nat mmx::hard_hash

(

const cache< C, T > &

c

)

[inline]

Definition at line 41 of file cache.hpp.

References hard_hash().

{ return hard_hash (*c); }

nat mmx::hard_hash

(

const C &

x

)

[inline]

Definition at line 267 of file basix.hpp.

References exact_hash().

Referenced by exact_hash(), generic_object_rep::get_hard_hash_value(), generic_concrete_rep< C >::get_hard_hash_value(), hard_hash(), hash(), hard_neq_op::hash_op(), hard_eq_op::hash_op(), hard_hash_op::op(), and unique_identifier().

                                                       {
  return exact_hash (x); }

bool mmx::hard_less	(	const C &	x,
		const C &	y
	)			[inline]

Definition at line 273 of file basix.hpp.

References inside().

Referenced by hard_less_op::op().

                                                                    {
  return ((void*) inside (x)) < ((void*) inside (y)); }

bool mmx::hard_neq	(	const updater &	x,
		const updater &	y
	)			[inline]

Definition at line 133 of file dynamic.cpp.

: public observer_rep {

bool mmx::hard_neq	(	const vector< C, V > &	x,
		const vector< C, V > &	y
	)			[inline]

Definition at line 207 of file vector.hpp.

{ return v->n; }

bool mmx::hard_neq	(	const format< C > &	x,
		const format< C > &	y
	)			[inline]

Definition at line 224 of file type_props.hpp.

{ return false; }

bool mmx::hard_neq	(	const triple< C1, C2, C3 > &	x,
		const triple< C1, C2, C3 > &	y
	)			[inline]

Definition at line 60 of file triple.hpp.

{

bool mmx::hard_neq	(	const task &	x,
		const task &	y
	)			[inline]

Definition at line 41 of file threads.hpp.

bool mmx::hard_neq	(	const table< C, T, V > &	x,
		const table< C, T, V > &	y
	)			[inline]

Definition at line 157 of file table.hpp.

{ return t->tfm1 (); }

bool mmx::hard_neq	(	const syntactic &	c1,
		const syntactic &	c2
	)			[inline]

Definition at line 60 of file syntactic.hpp.

References hard_neq().

                                                                {
  return hard_neq (*c1, *c2); }

bool mmx::hard_neq	(	const symbol< C, V > &	x,
		const symbol< C, V > &	y
	)			[inline]

Definition at line 92 of file symbol.hpp.

{

bool mmx::hard_neq	(	const string &	x,
		const string &	y
	)			[inline]

Definition at line 105 of file string.hpp.

{ return copy (s); }

bool mmx::hard_neq	(	const storage &	x,
		const storage &	y
	)			[inline]

Definition at line 53 of file storage.hpp.

{ return "storage"; }

bool mmx::hard_neq	(	const sparse_vector< C, T, V > &	x,
		const sparse_vector< C, T, V > &	y
	)			[inline]

Definition at line 96 of file sparse_vector.hpp.

{ return v.rep->n; }

bool mmx::hard_neq	(	const routine &	x,
		const routine &	y
	)			[inline]

Definition at line 96 of file routine.hpp.

{

bool mmx::hard_neq	(	const primitive &	x,
		const primitive &	y
	)			[inline]

Definition at line 43 of file primitive.hpp.

{

bool mmx::hard_neq	(	const port &	x,
		const port &	y
	)			[inline]

Definition at line 61 of file port.hpp.

{ return p->expression (); }

bool mmx::hard_neq	(	const pair< C1, C2 > &	x,
		const pair< C1, C2 > &	y
	)			[inline]

Definition at line 55 of file pair.hpp.

{

bool mmx::hard_neq	(	const new_table< C, T, V > &	x,
		const new_table< C, T, V > &	y
	)			[inline]

Definition at line 179 of file new_table.hpp.

{ return t->tfm1 (); }

bool mmx::hard_neq	(	const Indirect< R > &	x,
		const Indirect< R > &	y
	)			[inline]

Definition at line 764 of file mmc_glue.hpp.

References Indirect< R >::rep.

                                                                       {
  return x.rep != y.rep; }

bool mmx::hard_neq	(	const literal &	c1,
		const literal &	c2
	)			[inline]

Definition at line 54 of file literal.hpp.

References as_string(), and hard_neq().

                                                            {
  return hard_neq (as_string (c1), as_string (c2)); }

bool mmx::hard_neq	(	const list< C > &	x,
		const list< C > &	y
	)			[inline]

Definition at line 129 of file list.hpp.

                                                         {
  return (x.operator -> ()) != (y.operator -> ()); }

bool mmx::hard_neq	(	const iterator< C > &	x,
		const iterator< C > &	y
	)			[inline]

Definition at line 95 of file iterator.hpp.

{ return it.rep->is_busy (); }

bool mmx::hard_neq	(	const heap< C > &	x,
		const heap< C > &	y
	)			[inline]

Definition at line 96 of file heap.hpp.

bool mmx::hard_neq	(	const generic_function &	x,
		const generic_function &	y
	)			[inline]

Definition at line 47 of file generic_function.hpp.

{

bool mmx::hard_neq	(	const generic &	x,
		const generic &	y
	)			[inline]

Definition at line 146 of file generic.hpp.

bool mmx::hard_neq	(	const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &	f,
		const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &	g
	)			[inline]

Definition at line 611 of file function.hpp.

                                                                 {
  return (f.rep) != (g.rep); }

bool mmx::hard_neq	(	const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &	f,
		const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &	g
	)			[inline]

Definition at line 551 of file function.hpp.

                                                                 {
  return (f.rep) != (g.rep); }

bool mmx::hard_neq	(	const function_6< D, S1, S2, S3, S4, S5, S6 > &	f,
		const function_6< D, S1, S2, S3, S4, S5, S6 > &	g
	)			[inline]

Definition at line 491 of file function.hpp.

                                                                 {
  return (f.rep) != (g.rep); }

bool mmx::hard_neq	(	const function_5< D, S1, S2, S3, S4, S5 > &	f,
		const function_5< D, S1, S2, S3, S4, S5 > &	g
	)			[inline]

Definition at line 432 of file function.hpp.

                                                                 {
  return (f.rep) != (g.rep); }

bool mmx::hard_neq	(	const function_4< D, S1, S2, S3, S4 > &	f,
		const function_4< D, S1, S2, S3, S4 > &	g
	)			[inline]

Definition at line 373 of file function.hpp.

                                                                 {
  return (f.rep) != (g.rep); }

bool mmx::hard_neq	(	const function_3< D, S1, S2, S3 > &	f,
		const function_3< D, S1, S2, S3 > &	g
	)			[inline]

Definition at line 314 of file function.hpp.

                                                                 {
  return (f.rep) != (g.rep); }

bool mmx::hard_neq	(	const function_2< D, S1, S2 > &	f,
		const function_2< D, S1, S2 > &	g
	)			[inline]

Definition at line 255 of file function.hpp.

                                                                 {
  return (f.rep) != (g.rep); }

bool mmx::hard_neq	(	const function_1< D, S1 > &	f,
		const function_1< D, S1 > &	g
	)			[inline]

Definition at line 155 of file function.hpp.

                                                                 {
  return (f.rep) != (g.rep); }

bool mmx::hard_neq	(	const function_0< D > &	f,
		const function_0< D > &	g
	)			[inline]

Definition at line 99 of file function.hpp.

                                                                 {
  return (f.rep) != (g.rep); }

bool mmx::hard_neq	(	const exception &	e1,
		const exception &	e2
	)			[inline]

Definition at line 49 of file exception.hpp.

References hard_neq().

                                                                {
  return hard_neq (*e1, *e2); }

bool mmx::hard_neq	(	const evaluator &	x,
		const evaluator &	y
	)			[inline]

Definition at line 65 of file evaluator.hpp.

bool mmx::hard_neq	(	const dynamic &	x,
		const dynamic &	y
	)			[inline]

Definition at line 85 of file dynamic.hpp.

{ return inside (d) -> val; }

bool mmx::hard_neq	(	const observer &	x,
		const observer &	y
	)			[inline]

Definition at line 56 of file dynamic.hpp.

: public rep_struct {

bool mmx::hard_neq	(	const document &	c1,
		const document &	c2
	)			[inline]

Definition at line 61 of file document.hpp.

References hard_neq().

                                                              {
  return hard_neq (*c1, *c2); }

bool mmx::hard_neq	(	const compound &	c1,
		const compound &	c2
	)			[inline]

Definition at line 59 of file compound.hpp.

References as_vector(), and hard_neq().

                                                              {
  return hard_neq (as_vector (c1), as_vector (c2)); }

bool mmx::hard_neq	(	const chain< C > &	x,
		const chain< C > &	y
	)			[inline]

Definition at line 120 of file chain.hpp.

                                                           {
  return (x.operator -> ()) != (y.operator -> ()); }

bool mmx::hard_neq	(	const cache< C, T > &	c1,
		const cache< C, T > &	c2
	)			[inline]

Definition at line 52 of file cache.hpp.

References hard_neq().

                                                             {
  return hard_neq (*c1, *c2); }

bool mmx::hard_neq	(	const C &	x,
		const C &	y
	)			[inline]

Definition at line 271 of file basix.hpp.

References exact_neq().

Referenced by exact_neq(), hard_neq(), hard_eq_op::not_op(), hard_neq_op::op(), and operator!=().

                                                                   {
  return exact_neq (x, y); }

bool mmx::has_branch	(	const storage &	st,
		const string &	br
	)			[inline]

Get branch br from storage st and create one if the branch does not exist.

Definition at line 82 of file storage.hpp.

Referenced by GLUE_9().

                                                             {
  return st->has_branch (br); }

bool mmx::has_file	(	const storage &	st,
		const string &	orig
	)			[inline]

Get a shadow name for a file orig on the storage, with the same extension.

Definition at line 88 of file storage.hpp.

Referenced by GLUE_11().

                                                             {
  return st->has_file (orig); }

bool has_trace

(

const generic &

exc

)

Definition at line 84 of file exception.cpp.

References GEN_BACKTRACE, GEN_EXCEPTION, and is_func().

Referenced by backtrace(), source_exception(), and trace_depth().

                               {
  if (!is<exception> (exc)) return false;
  generic msg= *as<exception> (exc);
  return
    is_func (msg, GEN_EXCEPTION, 2) &&
    is_func (msg[2], GEN_BACKTRACE, 2);
}

nat mmx::hash

(

const string &

obj->lex_string

)

Definition at line 61 of file string.cpp.

References N().

                       {
  register const char* a= S(s);
  register nat i, h=0, n= N(s);
  for (i=0; i<n; i++)
    h= (h<<1) ^ (h<<9) ^ (h>>23) ^ ((nat) a[i]);
  return h;
}

nat mmx::hash

(

const cpp_printer &

p

)

[inline]

Definition at line 293 of file cpp_printer.cpp.

                            {
  return 0;
}

nat mmx::hash

(

const vector< C, V > &

x

)

[inline]

Definition at line 1151 of file vector.hpp.

{

nat mmx::hash

(

const format< C > &

x

)

[inline]

Definition at line 227 of file type_props.hpp.

{ return 0; }

nat mmx::hash

(

const triple< C1, C2, C3 > &

x

)

[inline]

Definition at line 58 of file triple.hpp.

{

nat mmx::hash

(

const table< C, T, V > &

x

)

[inline]

Definition at line 693 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

nat mmx::hash

(

const syntactic &

c

)

[inline]

Definition at line 47 of file syntactic.hpp.

References hash().

{ return hash (*c); }

nat mmx::hash

(

const symbol< C, equal_table > &

s

)

[inline]

Definition at line 117 of file symbol.hpp.

References exact_hash().

                                                                      {
  return exact_hash (s); }

nat hash

(

const symbol< C, V > &

s

)

[inline]

Definition at line 103 of file symbol.hpp.

References hash().

                                       {
  return hash (*s); }

nat mmx::hash

(

const storage &

x

)

[inline]

Definition at line 56 of file storage.hpp.

{ return "storage"; }

nat mmx::hash

(

const sparse_vector< C, T, V > &

x

)

[inline]

Definition at line 168 of file sparse_vector.hpp.

{

nat mmx::hash

(

const port &

x

)

[inline]

Definition at line 64 of file port.hpp.

{ return p->expression (); }

nat mmx::hash

(

const pair< C1, C2 > &

x

)

[inline]

Definition at line 53 of file pair.hpp.

{

nat mmx::hash

(

const new_table< C, T, V > &

x

)

[inline]

Definition at line 764 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

nat mmx::hash

(

const Indirect< R > &

x

)

[inline]

Definition at line 766 of file mmc_glue.hpp.

References as_hash(), and Indirect< R >::rep.

                                            {
  return as_hash (x.rep); }

nat mmx::hash

(

const literal &

c

)

[inline]

Definition at line 41 of file literal.hpp.

References hash().

{ return hash (as_symbol (c)); }

nat mmx::hash

(

const list< C > &

x

)

[inline]

Definition at line 228 of file list.hpp.

{

nat hash

(

const iterator< C > &

it

)

[inline]

Definition at line 185 of file iterator.hpp.

: public Iterator_rep {

nat mmx::hash

(

const heap< C > &

x

)

[inline]

Definition at line 243 of file heap.hpp.

{

nat mmx::hash

(

const generic &

g

)

[inline]

Definition at line 162 of file generic.hpp.

                                   {
  return g->get_hash_value (); }

nat mmx::hash

(

const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &

x

)

[inline]

Definition at line 614 of file function.hpp.

{

nat mmx::hash

(

const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &

x

)

[inline]

Definition at line 554 of file function.hpp.

{

nat mmx::hash

(

const function_6< D, S1, S2, S3, S4, S5, S6 > &

x

)

[inline]

Definition at line 494 of file function.hpp.

{

nat mmx::hash

(

const function_5< D, S1, S2, S3, S4, S5 > &

x

)

[inline]

Definition at line 435 of file function.hpp.

{

nat mmx::hash

(

const function_4< D, S1, S2, S3, S4 > &

x

)

[inline]

Definition at line 376 of file function.hpp.

{

nat mmx::hash

(

const function_3< D, S1, S2, S3 > &

x

)

[inline]

Definition at line 317 of file function.hpp.

{

nat mmx::hash

(

const function_2< D, S1, S2 > &

x

)

[inline]

Definition at line 258 of file function.hpp.

{

nat mmx::hash

(

const function_1< D, S1 > &

x

)

[inline]

Definition at line 158 of file function.hpp.

{

nat mmx::hash

(

const function_0< D > &

x

)

[inline]

Definition at line 102 of file function.hpp.

{

nat mmx::hash

(

const exception &

e

)

[inline]

Definition at line 36 of file exception.hpp.

References hash().

{ return hash (*e); }

nat mmx::hash

(

const dynamic &

x

)

[inline]

Definition at line 96 of file dynamic.hpp.

nat mmx::hash

(

const observer &

x

)

[inline]

Definition at line 59 of file dynamic.hpp.

: public rep_struct {

nat mmx::hash

(

const document &

c

)

[inline]

Definition at line 48 of file document.hpp.

References hash().

{ return hash (*c); }

nat mmx::hash

(

const compound &

c

)

[inline]

Definition at line 43 of file compound.hpp.

References hash().

                                    {
  return hash (as_symbol (c)); }

nat mmx::hash

(

const cache< C, T > &

c

)

[inline]

Definition at line 39 of file cache.hpp.

References hard_hash().

{ return hard_hash (*c); }

nat mmx::hash

(

C *

p

)

[inline]

Definition at line 204 of file basix.hpp.

References as_hash().

{ return as_hash (p); }

nat mmx::hash

(

const double &

x

)

[inline]

Definition at line 201 of file basix.hpp.

References n.

                                  {
  union { nat n; double d; } u;
  u.d= x; return u.n; }

nat mmx::hash

(

const float &

x

)

[inline]

Definition at line 199 of file basix.hpp.

                                 {
  return (*((nat*) ((void*) &x))) & 0xffffffff; }

nat mmx::hash

(

long long unsigned int

c

)

[inline]

Definition at line 196 of file basix.hpp.

                                           {
  nat h = (nat) ((c >> (4 * sizeof (long int))) >> (4 * sizeof (long int)));
  return (h<<1) ^ (h<<5) ^ (h>>27) ^ ((nat) c); }

nat mmx::hash

(

long long int

c

)

[inline]

Definition at line 193 of file basix.hpp.

                                  {
  nat h = (nat) ((c >> (4 * sizeof (long int))) >> (4 * sizeof (long int)));
  return (h<<1) ^ (h<<5) ^ (h>>27) ^ ((nat) c); }

nat mmx::hash

(

long unsigned int

c

)

[inline]

Definition at line 192 of file basix.hpp.

{ return (nat) c; }

nat mmx::hash

(

long int

c

)

[inline]

Definition at line 191 of file basix.hpp.

{ return (nat) c; }

nat mmx::hash

(

unsigned int

c

)

[inline]

Definition at line 190 of file basix.hpp.

{ return (nat) c; }

nat mmx::hash

(

int

c

)

[inline]

Definition at line 189 of file basix.hpp.

{ return (nat) c; }

nat mmx::hash

(

short unsigned int

c

)

[inline]

Definition at line 188 of file basix.hpp.

{ return (nat) c; }

nat mmx::hash

(

short int

c

)

[inline]

Definition at line 187 of file basix.hpp.

{ return (nat) c; }

nat mmx::hash

(

unsigned char

c

)

[inline]

Definition at line 186 of file basix.hpp.

{ return (nat) c; }

nat mmx::hash

(

signed char

c

)

[inline]

Definition at line 185 of file basix.hpp.

{ return (nat) c; }

nat mmx::hash

(

char

c

)

[inline]

Definition at line 184 of file basix.hpp.

Referenced by generic_object_rep::get_hash_value(), generic_concrete_rep< C >::get_hash_value(), hash(), unequal_op::hash_op(), equal_op::hash_op(), and hash_op::op().

{ return (nat) c; }

nat mmx::hash_combine	(	nat	i,
		nat	j
	)			[inline]

Definition at line 49 of file mmc_glue.hpp.

{ return (i << 7) ^ (i >> 25) ^ j; }

generic mmx::hlist

(

const vector< generic > &

v

)

[inline]

Definition at line 145 of file mmx_printer.cpp.

References gen().

                                                {
  return gen ("$hlist", v); }

syntactic hypot	(	const syntactic &	g1,
		const syntactic &	g2
	)

Definition at line 445 of file syntactic.cpp.

References GEN_HYPOT, and syn().

                                                           {
  return syn (GEN_HYPOT, g1, g2); }

generic hypot	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 517 of file generic.cpp.

References ACC_BINARY, ACC_HYPOT, sqrt(), and square().

                                           {
  ACC_BINARY (ACC_HYPOT, x, y);
  return sqrt (square (x) + square (y));
}

double hypot	(	const double &	x,
		const double &	y
	)			[inline]

Definition at line 58 of file double.hpp.

References hypot().

                                                       {
  return ::hypot (x, y); }

C mmx::hypot	(	const C &	x,
		const C &	y
	)			[inline]

Definition at line 573 of file defaults.hpp.

References sqrt(), and square().

Referenced by hypot(), hypot_op::op(), and hypot_op::set_op().

                               {
  return sqrt (square (x) + square (y));
}

const C & I

(

const table< C, T, V > &

t

)

[inline]

Definition at line 215 of file table.hpp.

                   {
  t->lazy_initialize ();
  return *t->init;
}

C & I

(

table< C, T, V > &

t

)

[inline]

Definition at line 209 of file table.hpp.

             {
  t->lazy_initialize ();
  return *t->init;
}

const C & I

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 232 of file new_table.hpp.

                   {
  t->lazy_initialize ();
  return *t->init;
}

C & I

(

new_table< C, T, V > &

t

)

[inline]

Definition at line 226 of file new_table.hpp.

Referenced by append(), binary_map(), binary_map_scalar(), binary_test(), binary_test_scalar(), common(), copy(), as_helper< table< D, T >, table< C, T > >::cv(), as_helper< new_table< D, T >, new_table< C, T > >::cv(), difference(), binary_helper< table< C, T, V > >::disassemble(), binary_helper< new_table< C, T, V > >::disassemble(), unsigned_int_floor_sqrt_helper< I >::floor_sqrt(), int_floor_sqrt_helper< I >::floor_sqrt(), unsigned_int_gcd_helper::gcd(), int_gcd_helper::gcd(), map(), unsigned_int_reconstruct_helper< U >::reconstruct(), int_reconstruct_helper< I >::reconstruct(), unary_filter(), unary_map(), unary_set(), unary_set_scalar(), binary_helper< table< C, T, V > >::write(), and binary_helper< new_table< C, T, V > >::write().

             {
  t->lazy_initialize ();
  return *t->init;
}

routine identity_routine

(

const vector< nat > &

sig

)

Definition at line 112 of file routine.cpp.

References ASSERT, and N().

                                          {
  // WARNING: we do allow for "fake identity functions" with sig[0] != sig[1]
  // This is useful for fast conversions to generic
  ASSERT (N(sig) == 2, "identity routine should take one argument");
  return new identity_routine_rep (sig);
}

vector<typename unary_return_type_helper<Re_op, C >::RET,V> mmx::Im

(

const vector< C, V > &

v

)

[inline]

Definition at line 1342 of file vector.hpp.

{ return unary_map<Im_op> (v); }

syntactic Im

(

const syntactic &

g1

)

Definition at line 451 of file syntactic.cpp.

References GEN_IM, and syn().

{ return syn (GEN_IM, g1); }

generic Im

(

const generic &

x1

)

Definition at line 736 of file generic.cpp.

References current_ev, and GEN_IM.

                               {
  return current_ev->apply (GEN_IM, x1); }

C mmx::Im

(

const C &

x

)

[inline]

Definition at line 717 of file defaults.hpp.

Referenced by Im_op::op(), Im_op::Real_type(), and Im_op::set_op().

{ return 0; }

C mmx::imaginary_cst

(

const format< C > &

fm

)

[inline]

Definition at line 936 of file type_props.hpp.

References C, promote(), and set_imaginary().

                                    {
  C r= promote (0, fm); set_imaginary (r); return r; }

C mmx::imaginary_cst

(

)

[inline]

Definition at line 902 of file type_props.hpp.

References C, and set_imaginary().

{ C r; set_imaginary (r); return r; }

alias<C> mmx::incarnate_genalias

(

const generic_alias< C > &

a

)

[inline]

Definition at line 166 of file alias.hpp.

                                                                    {
  return new incarnate_alias_rep<C> (a); }

generic incexp2	(	const generic &	x1,
		const xint &	x2
	)

Definition at line 789 of file generic.cpp.

References current_ev.

                                                    {
  return current_ev->apply ("increase_exponent", x1, as<generic> ((int) x2)); }

void incexp2	(	double &	x,
		const double &	y,
		const S &	z
	)			[inline]

Definition at line 108 of file double.hpp.

{ x= ldexp (y, z); }

double incexp2

(

const double &

x

)

[inline]

Definition at line 104 of file double.hpp.

{ return ldexp (x, 1); }

double incexp2	(	const double &	x,
		const S &	y
	)			[inline]

Definition at line 102 of file double.hpp.

{ return ldexp (x, y); }

void mmx::incexp2	(	C &	x,
		const C &	y,
		const S &	z
	)			[inline]

Definition at line 330 of file defaults.hpp.

{ x= y << z; }

C mmx::incexp2

(

const C &

x

)

[inline]

Definition at line 326 of file defaults.hpp.

{ return incexp2<C,xint> (x, 1); }

C mmx::incexp2	(	const C &	x,
		const S &	y
	)			[inline]

Definition at line 324 of file defaults.hpp.

Referenced by GLUE_49(), incexp2_op::op(), and incexp2_op::set_op().

{ return x << y; }

void incexp2_assign	(	double &	x,
		const S &	y
	)			[inline]

Definition at line 106 of file double.hpp.

{ x= ldexp (x, y); }

void mmx::incexp2_assign	(	C &	x,
		const S &	y
	)			[inline]

Definition at line 328 of file defaults.hpp.

Referenced by incexp2_op::set_op().

{ x <<= y; }

void include

(

const string &

name

)

Definition at line 128 of file dlink.cpp.

References eval(), and gen().

                             {
  generic r= eval (gen ("include", as<generic> (name)));
  if (is<exception> (r)) throw as<exception> (r);
}

bool mmx::included	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1360 of file vector.hpp.

Referenced by included_op::not_op(), and included_op::op().

                                                             {
  return binary_test<included_op> (v, w); }

generic mmx::indented

(

const vector< generic > &

v

)

[inline]

Definition at line 149 of file mmx_printer.cpp.

References gen().

                                                   {
  return gen ("$indent", v); }

mmx::INDIRECT_IMPL_1	(	alias	,
		alias_rep	,
		typename C	,
		C
	)			const

Definition at line 52 of file alias.hpp.

References flatten().

                                               { return flatten (a->get ()); }

vector<C,V> mmx::inf	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1124 of file vector.hpp.

                                                   {
  return binary_map<inf_op> (v, w); }

table<C,T,V> mmx::inf	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 639 of file table.hpp.

                                                       {
  return binary_map<inf_op,C,T,V> (t, u); }

sparse_vector<C,T,V> mmx::inf	(	const sparse_vector< C, T, V > &	t,
		const sparse_vector< C, T, V > &	u
	)			[inline]

Definition at line 274 of file sparse_vector.hpp.

                                                     {
  return binary_map<inf_op,C,T,V> (t, u); }

new_table<C,T,V> mmx::inf	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 710 of file new_table.hpp.

                                                       {
  return binary_map<inf_op,C,T,V> (t, u); }

C mmx::inf	(	const C &	x,
		const C &	y
	)			[inline]

Definition at line 479 of file defaults.hpp.

References min().

Referenced by inf_op::op(), and inf_op::set_op().

{ return min (x, y); }

C mmx::infinity_cst

(

const format< C > &

fm

)

[inline]

Definition at line 954 of file type_props.hpp.

References C, promote(), and set_infinity().

                                   {
  C r= promote (0, fm); set_infinity (r); return r; }

C mmx::infinity_cst

(

)

[inline]

Definition at line 914 of file type_props.hpp.

References C, and set_infinity().

{ C r; set_infinity (r); return r; }

generic mmx::infix	(	const generic &	g,
		const generic &	op,
		const generic &	h
	)			[inline]

Definition at line 129 of file mmx_printer.cpp.

References gen().

Referenced by mmx_printer::pp_E0().

                                                                             {
  return gen ("$infix", g, op, h); }

static void mmx::init	(	table< generic, generic > &	t,
		const generic &	key,
		const generic &	val
	)			[inline, static]

Definition at line 95 of file mmx_texmacs.cpp.

                                                                         {
  t[key]= val;
}

bool init

(

const iterator< C > &

it

)

[inline]

Definition at line 99 of file iterator.hpp.

Referenced by as_iterator_rep< C, S >::is_init(), mmx_symbol_table(), binary_helper< table< C, T, V > >::read(), binary_helper< new_table< C, T, V > >::read(), and texmacs_symbol_table().

{ return it.rep->is_init (); }

void init_system

(

)

Definition at line 170 of file system.cpp.

References ASSERT, file_exists(), user_dir(), and var_mkdir().

Referenced by eval_system(), path_name(), system_instance::system_instance(), and var_load().

               {
  string path = user_dir ();
  if (!file_exists (path)) {
    printf ("This is your first use of Mathemagix.\n");
    printf ("I am creating a .mathemagix directory in your home directory\n");
    ASSERT (var_mkdir (path), "Cannot create .mathemagix user directory");
  }
  var_mkdir (path * "/etc");
  var_mkdir (path * "/lib");
  var_mkdir (path * "/var");
  var_mkdir (path * "/mmx");
  var_mkdir (path * "/tmp");
}

void mmx::init_threads

(

)

Definition at line 222 of file threads.cpp.

{}

syntactic inject	(	const syntactic &	x,
		const syntactic &	y,
		const syntactic &	z
	)

Definition at line 511 of file syntactic.cpp.

References syn().

Referenced by mv_inject_op::op(), and mv_inject_op::set_op().

                                                                              {
  return syn ("inject", x, y, z); }

static port mmx::input_file_port	(	FILE *	f,
		bool	close_flag,
		bool	lock,
		const string &	name
	)			[static]

Definition at line 121 of file file_port.cpp.

                                                                          {
  return (port_rep*) new file_port_rep (2, f, close_flag, lock, name);
}

port input_file_port

(

const string &

name

)

Definition at line 156 of file file_port.cpp.

References as_charp(), decode_name(), error_port(), and free_charp().

Referenced by var_load().

                                     {
  string name_s= decode_name (name);
  char* temp= as_charp (name_s);
#if defined(__MINGW__) || defined(__MINGW32__)
  FILE* f= _fsopen (temp, "r", _SH_DENYWR);
#else
  FILE* f= fopen (temp, "r");
#endif
  free_charp (temp);
  if (f == NULL) return error_port ("file '" * name * "' not found");
  return input_file_port (f, true, true, name);
}

static port mmx::input_output_file_port	(	FILE *	f,
		bool	cf,
		bool	lock,
		const string &	name
	)			[static]

Definition at line 126 of file file_port.cpp.

                                                                         {
  return (port_rep*) new file_port_rep (3, f, cf, lock, name);
}

port input_output_file_port

(

const string &

name

)

Definition at line 170 of file file_port.cpp.

References as_charp(), decode_name(), error_port(), and free_charp().

                                            {
  string name_s= decode_name (name);
  char* temp= as_charp (name_s);
#if defined(__MINGW__) || defined(__MINGW32__)
  FILE* f= _fsopen (temp, "w+", _SH_DENYRW);
#else
  FILE* f= fopen (temp, "w+");
#endif
  free_charp (temp);
  if (f == NULL) return error_port ("file '" * name * "' did not open");
  return input_output_file_port (f, true, true, name);
}

port mmx::input_output_string_port

(

string &

obj->lex_string

)

Definition at line 105 of file string_port.cpp.

                                     {
  return (port_rep*) new input_output_string_port_rep (s);
}

port mmx::input_output_string_port

(

string &

s

)

port mmx::input_string_port

(

const string &

obj->lex_string

)

Definition at line 68 of file string_port.cpp.

                                    {
  return (port_rep*) new input_string_port_rep (s);
}

port mmx::input_string_port

(

const string &

s

)

Referenced by GLUE_1().

vector<C,V> mmx::insert	(	const vector< C, V > &	v,
		const vector< C, V > &	x,
		const vector< nat, W > &	pos
	)			[inline]

Definition at line 737 of file vector.hpp.

References ASSERT, C, CF(), n, N(), seg(), and Vector.

                                                                    {
  // insert x[0] at pos[0] in v, then x[1] at pos[1], etc
  ASSERT (N(x) == N(pos), "wrong sizes");
  nat n= N(v) + N(x), i= 0; nat l= aligned_size<C,V> (n);  
  C* a= mmx_formatted_new<C> (l, CF(v));
  const C* p= seg (v);
  for (nat k= 0; k < N(pos); k++) {
    ASSERT (pos[k] < n, "position out of range");
    for (; i < pos[k]; i++, p++) a[i]= *p;
    a[pos[k]]= x[k]; i++;
  }
  for (;i < n; i++, p++) a[i]= *p;
  return Vector (a, n, l, CF(v));
}

vector<C,V> mmx::insert	(	const vector< C, V > &	v,
		const C &	x,
		nat	pos
	)			[inline]

Definition at line 724 of file vector.hpp.

References ASSERT, C, CF(), n, N(), seg(), and Vector.

                                              {
  // insert x at 'pos' in v
  ASSERT (pos <= N(v), "position out of range");
  nat n= N(v) + 1, i; nat l= aligned_size<C,V> (n);
  C* a= mmx_formatted_new<C> (l, CF(v));
  const C* p= seg (v);
  for (i= 0; i < pos; i++, p++) a[i]= *p;
  a[pos]= x; i++;
  for (;i < n; i++, p++) a[i]= *p;
  return Vector (a, n, l, CF(v));
}

vector<C,V> mmx::insert	(	const vector< C, V > &	v,
		const C &	x
	)			[inline]

Definition at line 718 of file vector.hpp.

References append(), and contains().

                                     {
  if (contains (v, x)) return v;
  else return append (v, x);
}

list<C> mmx::insert	(	const list< C > &	l,
		const C &	x
	)			[inline]

Definition at line 314 of file list.hpp.

References car(), cdr(), cons(), is_nil(), and List.

Referenced by GLUE_15(), GLUE_16(), and GLUE_17().

                                   {
  if (is_nil (l)) return List (x);
  else if (car (l) == x) return l;
  else return cons (car (l), insert<C> (cdr (l), x));
}

updater_rep* mmx::inside

(

const updater &

x

)

[inline]

Definition at line 133 of file dynamic.cpp.

: public observer_rep {

vector_rep< C , V >* mmx::inside

(

const vector< C, V > &

x

)

[inline]

Definition at line 207 of file vector.hpp.

{ return v->n; }

task_rep* mmx::inside

(

const task &

x

)

[inline]

Definition at line 41 of file threads.hpp.

table_rep< C , T , V >* mmx::inside

(

const table< C, T, V > &

x

)

[inline]

Definition at line 157 of file table.hpp.

{ return t->tfm1 (); }

symbol_rep< C , V >* mmx::inside

(

const symbol< C, V > &

x

)

[inline]

Definition at line 92 of file symbol.hpp.

{

char* mmx::inside	(	const string &	s,
		nat	pos
	)			[inline]

Definition at line 110 of file string.hpp.

References string::rep.

                                               {
  return s.rep->a + pos; }

string_rep* mmx::inside

(

const string &

x

)

[inline]

Definition at line 105 of file string.hpp.

{ return copy (s); }

storage_rep* mmx::inside

(

const storage &

x

)

[inline]

Definition at line 53 of file storage.hpp.

{ return "storage"; }

sparse_vector_rep< C , T , V >* mmx::inside

(

const sparse_vector< C, T, V > &

x

)

[inline]

Definition at line 96 of file sparse_vector.hpp.

{ return v.rep->n; }

routine_rep* mmx::inside

(

const routine &

x

)

[inline]

Definition at line 96 of file routine.hpp.

{

primitive_rep* mmx::inside

(

const primitive &

x

)

[inline]

Definition at line 43 of file primitive.hpp.

{

port_rep* mmx::inside

(

const port &

x

)

[inline]

Definition at line 61 of file port.hpp.

{ return p->expression (); }

new_table_rep< C , T , V >* mmx::inside

(

const new_table< C, T, V > &

x

)

[inline]

Definition at line 179 of file new_table.hpp.

{ return t->tfm1 (); }

list_rep<C>* mmx::inside

(

const list< C > &

x

)

[inline]

Definition at line 123 of file list.hpp.

References List_rep.

                                      {
  return const_cast<List_rep*> (x.operator -> ()); }

iterator_rep< C >* mmx::inside

(

const iterator< C > &

x

)

[inline]

Definition at line 95 of file iterator.hpp.

{ return it.rep->is_busy (); }

heap_rep< C >* mmx::inside

(

const heap< C > &

x

)

[inline]

Definition at line 96 of file heap.hpp.

generic_function_rep* mmx::inside

(

const generic_function &

x

)

[inline]

Definition at line 47 of file generic_function.hpp.

{

generic_rep* mmx::inside

(

const generic &

x

)

[inline]

Definition at line 146 of file generic.hpp.

function_8_rep<D,S1,S2,S3,S4,S5,S6,S7,S8>* mmx::inside

(

const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &

f

)

[inline]

Definition at line 604 of file function.hpp.

{ return f.rep; }

function_7_rep<D,S1,S2,S3,S4,S5,S6,S7>* mmx::inside

(

const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &

f

)

[inline]

Definition at line 544 of file function.hpp.

{ return f.rep; }

function_6_rep<D,S1,S2,S3,S4,S5,S6>* mmx::inside

(

const function_6< D, S1, S2, S3, S4, S5, S6 > &

f

)

[inline]

Definition at line 484 of file function.hpp.

{ return f.rep; }

function_5_rep<D,S1,S2,S3,S4,S5>* mmx::inside

(

const function_5< D, S1, S2, S3, S4, S5 > &

f

)

[inline]

Definition at line 425 of file function.hpp.

{ return f.rep; }

function_4_rep<D,S1,S2,S3,S4>* mmx::inside

(

const function_4< D, S1, S2, S3, S4 > &

f

)

[inline]

Definition at line 366 of file function.hpp.

{ return f.rep; }

function_3_rep<D,S1,S2,S3>* mmx::inside

(

const function_3< D, S1, S2, S3 > &

f

)

[inline]

Definition at line 307 of file function.hpp.

{ return f.rep; }

function_2_rep<D,S1,S2>* mmx::inside

(

const function_2< D, S1, S2 > &

f

)

[inline]

Definition at line 247 of file function.hpp.

{ return f.rep; }

function_1_rep<D,S1>* mmx::inside

(

const function_1< D, S1 > &

f

)

[inline]

Definition at line 148 of file function.hpp.

{ return f.rep; }

function_0_rep<D>* mmx::inside

(

const function_0< D > &

f

)

[inline]

Definition at line 92 of file function.hpp.

{ return f.rep; }

evaluator_rep* mmx::inside

(

const evaluator &

x

)

[inline]

Definition at line 65 of file evaluator.hpp.

dynamic_rep* mmx::inside

(

const dynamic &

x

)

[inline]

Definition at line 85 of file dynamic.hpp.

{ return inside (d) -> val; }

observer_rep* mmx::inside

(

const observer &

x

)

[inline]

Definition at line 56 of file dynamic.hpp.

: public rep_struct {

chain_rep<C>* mmx::inside

(

const chain< C > &

x

)

[inline]

Definition at line 114 of file chain.hpp.

References Chain_rep.

Referenced by accept(), as_cpp(), assign(), attach(), busy(), can_read(), can_write(), component(), contents(), destroy(), dynamic::dynamic(), error_flag(), error_message(), flatten(), flush(), formatting_port_rep::format(), generic::generic(), hard_gtr(), hard_less(), inside_append(), inside_set(), is_input_port(), is_nil(), is_output_port(), operator<<(), input_output_string_port_rep::read(), input_string_port_rep::read(), posix_port_rep::read(), read(), reset(), seg_inside(), string_to_floating(), table_reset(), table_set(), threads_execute(), wait(), and write().

                                        {
  return const_cast<Chain_rep*> (x.operator -> ()); }

void mmx::inside_append	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 684 of file vector.hpp.

References ASSERT, copy(), inside(), is_non_scalar(), N(), n, and seg().

                                                 {
  typedef implementation<vector_linear,V> Vec;
  ASSERT (is_non_scalar (v) && is_non_scalar (w),
          "non-scalar vectors expected");
  nat n= N(v), p= N(w);
  inside (v)->resize (n + p);
  Vec::copy (const_cast<C*> (seg (v)) + n, seg (w), p);
}

void mmx::inside_set	(	const table< C, T, V > &	t,
		const T &	x,
		const C &	v
	)			[inline]

Definition at line 182 of file table.hpp.

References inside().

                                                                     {
  inside (t) -> set (x) = v; }

void mmx::inside_set	(	const table< C, T, V > &	t,
		const K &	x,
		const C &	v
	)			[inline]

Definition at line 171 of file table.hpp.

References inside().

                                                                      {
  inside (t) -> set (as<T> (x)) = v; }

void mmx::inside_set	(	const new_table< C, T, V > &	t,
		const T &	x,
		const C &	v
	)			[inline]

Definition at line 204 of file new_table.hpp.

References inside().

                                                                     {
  inside (t) -> set (x) = v; }

void mmx::inside_set	(	const new_table< C, T, V > &	t,
		const K &	x,
		const C &	v
	)			[inline]

Definition at line 193 of file new_table.hpp.

References inside().

                                                                      {
  inside (t) -> set (as<T> (x)) = v; }

void mmx::inside_set	(	const cache< C, T > &	c,
		const T &	x,
		const C &	v
	)			[inline]

Definition at line 68 of file cache.hpp.

Referenced by GLUE_14(), new_type_id(), and register_glue().

                                                                     {
  inside_set (*c, x, v); }

double mmx::int_as_double

(

const int &

x

)

[inline]

Definition at line 124 of file double.hpp.

{ return (double) x; }

vector<C,V> mmx::integrate	(	const vector< C, V > &	v,
		const X &	x
	)			[inline]

Definition at line 1209 of file vector.hpp.

                                        {
  return binary_map_scalar<integrate_op> (v, x); }

vector<C,V> mmx::integrate

(

const vector< C, V > &

v

)

[inline]

Definition at line 1200 of file vector.hpp.

                                        {
  return unary_map<integrate_op> (v); }

syntactic integrate	(	const syntactic &	g,
		const syntactic &	v
	)

Definition at line 486 of file syntactic.cpp.

References GEN_INTEGRATE, and syn().

                                                             {
  return syn (GEN_INTEGRATE, g, v); }

syntactic integrate

(

const syntactic &

g

)

Definition at line 484 of file syntactic.cpp.

References GEN_INTEGRATE, and syn().

                                         {
  return syn (GEN_INTEGRATE, g); }

routine integrate

(

const routine &

fun

)

Definition at line 248 of file routine.cpp.

                             {
  return new integrate_routine_rep (r);
}

generic integrate	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 689 of file generic.cpp.

References ACC_BINARY_SCALAR, ACC_DERIVE_WRT, current_ev, and GEN_INTEGRATE.

                                                {
  ACC_BINARY_SCALAR (ACC_DERIVE_WRT, x1, v);
  return current_ev->apply (GEN_INTEGRATE, x1, v);
}

generic integrate

(

const generic &

x1

)

Definition at line 676 of file generic.cpp.

References ACC_INTEGRATE, ACC_UNARY, current_ev, and GEN_INTEGRATE.

Referenced by integrate_routine_rep::apply(), solve_matrix_lde_op::def(), solve_vector_lde_op::def(), atan_op::def(), asin_op::def(), acos_op::def(), trig_op::def(), log_op::def(), exp_op::def(), sqrt_op::def(), integrate_op::op(), and integrate_op::set_op().

                              {
  ACC_UNARY (ACC_INTEGRATE, x1);
  return current_ev->apply (GEN_INTEGRATE, x1);
}

vector<C,V> mmx::integrate_init	(	const vector< C, V > &	v,
		const vector< K, W > &	w
	)			[inline]

Definition at line 1203 of file vector.hpp.

                                                       {
  return binary_map<integrate_init_op> (v, as<vector<K,V> > (w)); }

syntactic integrate_init	(	const syntactic &	g,
		const syntactic &	v,
		const syntactic &	c
	)

Definition at line 501 of file syntactic.cpp.

References syn().

                                              {
  return syn ("integrate_init", g, v, c); }

syntactic integrate_init	(	const syntactic &	x,
		const syntactic &	c
	)

Definition at line 499 of file syntactic.cpp.

References syn().

                                                                  {
  return syn ("integrate_init", g, c); }

generic integrate_init	(	const generic &	x,
		const generic &	c
	)

Definition at line 812 of file generic.cpp.

References current_ev.

Referenced by integrate_init_op::op(), integrate_op::op_init(), and integrate_init_op::set_op().

                                                              {
  return current_ev->apply ("integrate_init", x1, x2); }

function_0<void> mmx::invalidator_1	(	const function_0< void > &	p2,
		R **	t2,
		int *	ol,
		int *	nl
	)			[inline]

Definition at line 41 of file dispatcher.hpp.

                                                                     {
  return function_0<void> (new invalidator_1_rep<R> (p2, t2, ol, nl));
}

function_0<void> mmx::invalidator_2	(	const function_0< void > &	p2,
		R **	t2,
		int *	ol1,
		int *	ol2,
		int *	nl1,
		int *	nl2
	)			[inline]

Definition at line 114 of file dispatcher.hpp.

                                                       {
  return
    function_0<void> (new invalidator_2_rep<R> (p2, t2, ol1, ol2, nl1, nl2));
}

syntactic invert

(

const syntactic &

g

)

Definition at line 285 of file syntactic.cpp.

                            {
  return syntactic (1) / g;
}

generic invert

(

const generic &

x1

)

Definition at line 376 of file generic.cpp.

References ACC_INVERT, ACC_UNARY, current_ev, and GEN_OVER.

                           {
  ACC_UNARY (ACC_INVERT, x1);
  return current_ev->apply (GEN_OVER, 1, x1);
}

double invert

(

const double &

x

)

[inline]

Definition at line 127 of file double.hpp.

{ return 1.0 / x; }

C mmx::invert

(

const C &

x

)

[inline]

Definition at line 530 of file defaults.hpp.

References promote().

Referenced by invert_op::op(), invert_op::set_op(), and sympow().

                    {
  return promote (1, x) / x;
}

bool mmx::is

(

const generic &

x

)

[inline]

Definition at line 182 of file generic.hpp.

References type().

Referenced by binary_helper< vector< C, V > >::assemble(), default_routine(), generic_as_vector(), and vector_size().

                                       {
  return type (x) == type_information<C>::id; }

bool mmx::is_a_scalar

(

const vector< C, vector_fixed< V, S > > &

v

)

[inline]

Definition at line 370 of file vector.hpp.

{ (void) v; return false; }

bool is_a_scalar

(

const vector< C, V > &

v

)

[inline]

Definition at line 212 of file vector.hpp.

Referenced by binary_helper< vector< C, V > >::access(), binary_map(), binary_map_scalar(), binary_test(), binary_test_scalar(), as_helper< vector< T, TV >, vector< F, FV > >::cv(), fast_helper< vector< C, V > >::dd(), binary_helper< vector< C, V > >::disassemble(), exact_eq(), extend(), flatten(), is_finite(), is_fuzz(), is_infinite(), is_nan(), is_reliable(), operator==(), range(), rebuild(), reverse(), vector< observer >::scalar(), project_helper< vector< C, V > >::set_op(), lift_helper< vector< C, V > >::set_op(), binary_helper< vector< C, V > >::size(), unary_map(), unary_set(), unary_set_scalar(), fast_helper< vector< C, V > >::uu(), vector< observer >::vector(), vector_map_1(), vector_map_2(), vector_map_n(), vector_reverse(), and binary_helper< vector< C, V > >::write().

{ return v->scalar_flag; }

static bool is_absolute_name

(

const string &

name

)

[inline, static]

Definition at line 308 of file system.cpp.

References N().

Referenced by path_name(), prefix_dir(), relative_name(), and var_load().

                                      {
#if defined(__MINGW__) || defined(__MINGW32__)
  return N(name) >=2 &&
    ((name[0] >= 'A' && name[0] <= 'Z') ||
     (name[0] >= 'a' && name[0] <= 'z'))
    && name[1] == ':';
#else
  return name != "" && name[0] == '/';
#endif
}

bool mmx::is_alias_type

(

nat

id

)

[inline]

Definition at line 182 of file alias.hpp.

References alias_type_info().

Referenced by define_type_sub(), and generic_object_rep::expression().

                       {
  int mode= 0;
  alias_type_info (id, mode);
  return mode == 1;
}

static bool is_applicable

(

const generic &

g

)

[static]

Definition at line 357 of file mmx_printer.cpp.

References GEN_COERCE, GEN_COERCE_TYPE, GEN_LAMBDA, GEN_MACRO, GEN_SEQAND, GEN_SEQOR, GEN_XOR, literal_to_string(), N(), and s.

                                 {
  if (is<literal> (g)) {
    const string s= literal_to_string (g);
    if (N(s)==0) return false;
    for (nat i=0; i<N(s); i++)
      if (s[i] == '.') {
        if (i != 0 || N(s) == 1) return false; }
      else if (((s[i]<'0') || (s[i]>'9')) &&
               ((s[i]<'a') || (s[i]>'z')) &&
               ((s[i]<'A') || (s[i]>'Z')) &&
               ((s[i]!='_') && (s[i]!='?') && (s[i]!='$')))
        return false;
      else if (s[i] == '$') return true;
  }
  return
    g != GEN_SEQAND && g != GEN_SEQOR && g != GEN_XOR &&
    g != GEN_LAMBDA && g != GEN_MACRO &&
    g != GEN_COERCE && g != GEN_COERCE_TYPE;
}

bool mmx::is_atom

(

const vector< C, V > &

v

)

[inline]

Definition at line 227 of file vector.hpp.

References is_non_scalar(), and N().

                                           {
  return is_non_scalar (v) && N(v) == 1; }

bool is_atom

(

const syntactic &

g

)

Definition at line 25 of file syntactic.cpp.

{ return is<literal> (*g); }

bool mmx::is_atom

(

const list< C > &

l

)

[inline]

Return true iff l has length 1.

Definition at line 152 of file list.hpp.

References cdr(), and is_nil().

Referenced by GLUE_14(), GLUE_15(), GLUE_16(), and signed_decompose().

                                         {
  return !is_nil (l) && is_nil (cdr (l)); }

static bool mmx::is_C0

(

const generic &

g

)

[static]

Definition at line 308 of file mmx_printer.cpp.

References GEN_ASSIGN, GEN_ASSIGN_MACRO, GEN_ASSUME, GEN_AUTOFOLD, GEN_BEGIN, GEN_BREAK, GEN_CATEGORY, GEN_CLASS, GEN_CONSTANT, GEN_CONTINUE, GEN_DEFINE, GEN_DEFINE_MACRO, GEN_EXISTS, GEN_EXTERN, GEN_FORALL, GEN_FOREIGN, GEN_GTRGTREQ, GEN_IF, GEN_INLINE, GEN_INTERN, GEN_LAMBDA, GEN_LESSLESSEQ, GEN_LOOP, GEN_MACRO, GEN_METHOD, GEN_MINUS_ASSIGN, GEN_MODULE, GEN_MUTABLE, GEN_OUTLINE, GEN_OVER_ASSIGN, GEN_PENALTY, GEN_PLUS_ASSIGN, GEN_PRIVATE, GEN_PUBLIC, GEN_RETURN, GEN_TIMES_ASSIGN, GEN_TRY, is_func(), and N().

                         {
  if (is_func (g, GEN_BEGIN) ||
      is_func (g, GEN_IF) ||
      is_func (g, GEN_LOOP) ||
      is_func (g, GEN_BREAK) ||
      is_func (g, GEN_CONTINUE) ||
      is_func (g, GEN_TRY) ||
      is_func (g, GEN_LAMBDA) ||
      is_func (g, GEN_MACRO) ||
      is_func (g, GEN_RETURN) ||
      is_func (g, GEN_CLASS) ||
      is_func (g, GEN_MODULE) ||
      is_func (g, GEN_CATEGORY))
    return true;
  if (N(g) == 2 && is_C0 (g[1]))
    return
      is_func (g, GEN_AUTOFOLD) ||
      is_func (g, GEN_INLINE) ||
      is_func (g, GEN_INTERN) ||
      is_func (g, GEN_METHOD) ||
      is_func (g, GEN_EXTERN) ||
      is_func (g, GEN_MUTABLE) ||
      is_func (g, GEN_CONSTANT) ||
      is_func (g, GEN_OUTLINE) ||
      is_func (g, GEN_PUBLIC) ||
      is_func (g, GEN_PRIVATE);
  if (N(g) == 3 && is_C0 (g[2]))
    return
      is_func (g, GEN_FORALL) ||
      is_func (g, GEN_EXISTS) ||
      is_func (g, GEN_ASSUME) ||
      is_func (g, GEN_PENALTY) ||
      is_func (g, GEN_DEFINE) ||
      is_func (g, GEN_ASSIGN) ||
      is_func (g, GEN_DEFINE_MACRO) ||
      is_func (g, GEN_ASSIGN_MACRO) ||
      is_func (g, GEN_PLUS_ASSIGN) ||
      is_func (g, GEN_MINUS_ASSIGN) ||
      is_func (g, GEN_TIMES_ASSIGN) ||
      is_func (g, GEN_OVER_ASSIGN) ||
      is_func (g, GEN_LESSLESSEQ) ||
      is_func (g, GEN_GTRGTREQ);
  if (N(g) == 4 && is_C0 (g[3]))
    return
      is_func (g, GEN_FOREIGN);
  return false;
}

bool mmx::is_evaluable	(	const vector< C, V > &	v,
		const K &	a,
		vector< typename binary_return_type_helper< evaluate_op, C, K >::RET, W > &	w
	)			[inline]

Definition at line 1289 of file vector.hpp.

References CF(), fill(), and N().

                                               {
  w= fill (N(v), CF(w));
  for (nat i= 0; i < N(v); i++)
    if (!is_evaluable (v[i], a, w[i])) return false;
  return true; }

bool mmx::is_exact_zero

(

const generic &

g1

)

[inline]

Definition at line 358 of file generic.hpp.

References exact_eq().

{ return exact_eq (g1, 0); }

bool mmx::is_exact_zero

(

const C &

x

)

[inline]

Definition at line 143 of file defaults.hpp.

References exact_eq(), and promote().

                                                            {
  return exact_eq (x, promote (0, x)); }

bool mmx::is_finite

(

const vector< C, V > &

v

)

[inline]

Definition at line 1310 of file vector.hpp.

References is_a_scalar(), and is_finite().

                                             {
  if (is_a_scalar (v)) return is_finite (v.scalar());
  return big<and_is_finite_op> (v); }

bool mmx::is_finite

(

const table< C, T, V > &

t

)

[inline]

Definition at line 728 of file table.hpp.

                                            {
  return big<and_is_finite_op> (t); }

bool mmx::is_finite

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 799 of file new_table.hpp.

                                            {
  return big<and_is_finite_op> (t); }

bool mmx::is_finite

(

const double &

x

)

[inline]

Definition at line 77 of file double.hpp.

{ return std::isfinite (x); }

bool mmx::is_finite

(

const C &

x

)

[inline]

Definition at line 693 of file defaults.hpp.

Referenced by GLUE_39(), is_finite(), is_finite_op::not_op(), and_is_finite_op::op(), is_finite_op::op(), and and_is_finite_op::set_op().

                                                        {
  (void) x; return true; }

bool mmx::is_floating_string

(

const string &

obj->lex_string

)

Definition at line 203 of file string.cpp.

References N().

                                     {
  nat i= 0, n= N(s);
  if (i < n && s[i] == '-') i++;
  if (i >= n || s[i] < '0' || s[i] > '9') return false;
  while (i < n && s[i] >= '0' && s[i] <= '9') i++;
  if (i >= n || s[i] != '.') return false;
  i++;
  while (i < n && s[i] >= '0' && s[i] <= '9') i++;
  if (i < n && (s[i] == 'e' || s[i] == 'E')) {
    i++;
    if (i < n && s[i] == '-') i++;
    while (i < n && s[i] >= '0' && s[i] <= '9') i++;
  }
  return i == n;
}

bool mmx::is_floating_string

(

const string &

s

)

Referenced by string_to_numeric().

bool mmx::is_func	(	const syntactic &	g,
		const generic &	f,
		nat(obj->lex_length)
	)

Definition at line 82 of file syntactic.cpp.

References is_func().

                                                           {
  return is_func (*g, f, n); }

bool mmx::is_func	(	const syntactic &	g,
		const syntactic &	f,
		nat(obj->lex_length)
	)

Definition at line 78 of file syntactic.cpp.

References is_func().

                                                             {
  return is_func (*g, *f, n); }

bool mmx::is_func	(	const syntactic &	g,
		const char *	f,
		nat(obj->lex_length)
	)

Definition at line 74 of file syntactic.cpp.

References is_func().

                                                        {
  return is_func (*g, f, n); }

bool mmx::is_func	(	const syntactic &	g,
		const generic &	f,
		nat	n
	)

bool is_func	(	const syntactic &	g,
		const generic &	f
	)

Definition at line 80 of file syntactic.cpp.

References is_func().

                                                    {
  return is_func (*g, f); }

bool mmx::is_func	(	const syntactic &	g,
		const syntactic &	f,
		nat	n
	)

bool is_func	(	const syntactic &	g,
		const syntactic &	f
	)

Definition at line 76 of file syntactic.cpp.

References is_func().

                                                      {
  return is_func (*g, *f); }

bool mmx::is_func	(	const syntactic &	g,
		const char *	f,
		nat	n
	)

bool is_func	(	const syntactic &	g,
		const char *	f
	)

Definition at line 72 of file syntactic.cpp.

References is_func().

                                                 {
  return is_func (*g, f); }

bool is_func	(	const generic &	g,
		const generic &	f,
		nat	n
	)

Definition at line 75 of file generic_utils.cpp.

References exact_eq(), and N().

                                                    {
  return is<compound> (g) && N (g) == (n+1) && exact_eq (g[0], f);
}

bool is_func	(	const generic &	g,
		const generic &	f
	)

Definition at line 70 of file generic_utils.cpp.

References exact_eq().

                                             {
  return is<compound> (g) && exact_eq (g[0], f);
}

bool is_func	(	const generic &	g,
		const char *	f,
		nat	n
	)

Definition at line 65 of file generic_utils.cpp.

References exact_eq(), and N().

                                                 {
  return is<compound> (g) && N (g) == (n+1) && exact_eq (g[0], generic (f));
}

bool is_func	(	const generic &	g,
		const char *	f
	)

Definition at line 60 of file generic_utils.cpp.

References exact_eq().

Referenced by add_modes(), as_texmacs(), collect(), concat_append(), flatten_as_tm(), get_user_type(), has_trace(), is_C0(), is_func(), is_function_type(), is_infix(), make_document(), migrate_negate(), migrate_sub(), mmc_unliteral(), product_less_op::op(), sum_less_op::op(), operator*(), operator+(), operator-(), operator/(), mmx_printer::pp_E0(), replace_lf(), scheme_to_tm(), serialize(), signed_decompose(), texmacs_expand(), trace_pull(), trace_push(), trace_top(), un_try_catch(), and unbracket().

                                          {
  return is<compound> (g) && exact_eq (g[0], generic (f));
}

static bool mmx::is_function_type

(

const generic &

g

)

[static]

Definition at line 575 of file cpp_printer.cpp.

References CPP_FUNCTION_TYPE, CPP_INLINE, CPP_STATIC, and is_func().

                                    {
  return
    is_func (g, CPP_FUNCTION_TYPE) ||
    (is_func (g, CPP_INLINE, 1) && is_function_type (g[1])) ||
    (is_func (g, CPP_STATIC, 1) && is_function_type (g[1]));
}

bool mmx::is_fuzz

(

const vector< C, V > &

v

)

[inline]

Definition at line 1319 of file vector.hpp.

References is_a_scalar(), is_fuzz(), and is_nan().

                                           {
  if (is_a_scalar (v)) return is_fuzz (v.scalar());
  return !is_nan (v) && big<or_is_fuzz_op> (v); }

bool mmx::is_fuzz

(

const table< C, T, V > &

t

)

[inline]

Definition at line 734 of file table.hpp.

References is_nan().

                                          {
  return !is_nan (t) && big<or_is_fuzz_op> (t); }

bool mmx::is_fuzz

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 805 of file new_table.hpp.

References is_nan().

                                          {
  return !is_nan (t) && big<or_is_fuzz_op> (t); }

bool mmx::is_fuzz

(

const double &

x

)

[inline]

Definition at line 79 of file double.hpp.

{ (void) x; return false; }

bool mmx::is_fuzz

(

const C &

x

)

[inline]

Definition at line 697 of file defaults.hpp.

Referenced by is_fuzz(), is_fuzz_op::not_op(), or_is_fuzz_op::op(), is_fuzz_op::op(), and or_is_fuzz_op::set_op().

                                                      {
  (void) x; return false; }

bool mmx::is_infinite

(

const vector< C, V > &

v

)

[inline]

Definition at line 1316 of file vector.hpp.

References is_a_scalar(), is_infinite(), and is_nan().

                                               {
  if (is_a_scalar (v)) return is_infinite (v.scalar());
  return !is_nan (v) && big<or_is_infinite_op> (v); }

bool mmx::is_infinite

(

const table< C, T, V > &

t

)

[inline]

Definition at line 732 of file table.hpp.

References is_nan().

                                              {
  return !is_nan (t) && big<or_is_infinite_op> (t); }

bool mmx::is_infinite

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 803 of file new_table.hpp.

References is_nan().

                                              {
  return !is_nan (t) && big<or_is_infinite_op> (t); }

bool mmx::is_infinite

(

const double &

x

)

[inline]

Definition at line 78 of file double.hpp.

{ return std::isinf (x); }

bool mmx::is_infinite

(

const C &

x

)

[inline]

Definition at line 695 of file defaults.hpp.

Referenced by GLUE_40(), is_infinite(), is_infinite_op::not_op(), or_is_infinite_op::op(), is_infinite_op::op(), and or_is_infinite_op::set_op().

                                                          {
  (void) x; return false; }

bool mmx::is_infix	(	const generic &	g,
		const generic &	op
	)

Definition at line 200 of file mmx_texmacs.cpp.

References is_func().

                                               {
  return is_func (g, "$infix", 3) && g[2] == op;
}

bool mmx::is_input_port

(

const port &

p

)

[inline]

Definition at line 94 of file port.hpp.

References inside().

Referenced by composite_port_rep::can_read(), GLUE_10(), composite_port_rep::is_input_port(), composite_port_rep::read(), and composite_port_rep::wait().

                                          {
  return inside (p)->is_input_port (); }

bool mmx::is_int

(

const double_int &

x

)

[inline]

Definition at line 34 of file int.hpp.

                                         {
  return x == ((double_int) (int) x); }

bool mmx::is_integer_string

(

const string &

obj->lex_string

)

Definition at line 194 of file string.cpp.

References N().

                                    {
  nat i= 0, n= N(s);
  if (i < n && s[i] == '-') i++;
  if (i == n) return false;
  while (i < n && s[i] >= '0' && s[i] <= '9') i++;
  return i == n;
}

bool mmx::is_integer_string

(

const string &

s

)

bool mmx::is_invertible

(

const C &

x

)

[inline]

Definition at line 535 of file defaults.hpp.

                           {
  return false;
}

bool mmx::is_list

(

const generic &

x

)

[inline]

Definition at line 221 of file generic.hpp.

References SPECIES_LIST, and species_type().

                                       {
  return species_type (x) == SPECIES_LIST; }

bool is_literal_double

(

const literal &

l

)

Definition at line 57 of file literal.cpp.

                                     {
  return is_numeric_string<double> (*l);
}

bool is_literal_int

(

const literal &

l

)

Definition at line 52 of file literal.cpp.

                                  {
  return is_numeric_string<int> (*l);
}

bool is_literal_string

(

const literal &

l

)

Definition at line 47 of file literal.cpp.

References is_quoted().

                                     {
  return is_quoted (*l);
}

static bool mmx::is_locase

(

register char

c

)

[static]

Definition at line 424 of file string.cpp.

Referenced by upcase(), and upcase_first().

                            {
  int code= (int) ((unsigned char) c);
  return
    ((c>='a') && (c<='z')) ||
    ((code >= 160) && (code < 189)) ||
    (code >= 224);
}

bool mmx::is_nan

(

const vector< C, V > &

v

)

[inline]

Definition at line 1313 of file vector.hpp.

References is_a_scalar(), and is_nan().

                                          {
  if (is_a_scalar (v)) return is_nan (v.scalar());
  return big<or_is_nan_op> (v); }

bool mmx::is_nan

(

const table< C, T, V > &

t

)

[inline]

Definition at line 730 of file table.hpp.

                                         {
  return big<or_is_nan_op> (t); }

bool mmx::is_nan

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 801 of file new_table.hpp.

                                         {
  return big<or_is_nan_op> (t); }

bool mmx::is_nan

(

const double &

x

)

[inline]

Definition at line 80 of file double.hpp.

{ return std::isnan (x); }

bool mmx::is_nan

(

const C &

x

)

[inline]

Definition at line 699 of file defaults.hpp.

Referenced by GLUE_41(), is_fuzz(), is_infinite(), is_nan(), is_nan_op::not_op(), or_is_nan_op::op(), is_nan_op::op(), and or_is_nan_op::set_op().

                                                     {
  (void) x; return false; }

bool mmx::is_nil

(

const vector< C, V > &

v

)

[inline]

Definition at line 225 of file vector.hpp.

References N().

                                          {
  return N(v) == 0; }

bool mmx::is_nil

(

const source_location &

l

)

[inline]

Definition at line 92 of file source_track.hpp.

References source_location::end, source_position::line, and source_position::position.

                                  {
  return (l.end.line == 0 && l.end.position == 0);
};

bool mmx::is_nil

(

const routine &

fun

)

[inline]

Definition at line 98 of file routine.hpp.

                                        {
  return fun.rep == NULL; }

bool mmx::is_nil

(

const primitive &

fun

)

[inline]

Definition at line 45 of file primitive.hpp.

                                          {
  return fun.rep == NULL; }

bool is_nil

(

const list< C > &

l

)

[inline]

Return true iff is empty.

Definition at line 150 of file list.hpp.

{ return l.rep == NULL; }

bool mmx::is_nil

(

const generic_function &

f

)

[inline]

Definition at line 73 of file generic_function.hpp.

References N().

                                               {
  return N (f -> Signature ()) == 0; }

bool mmx::is_nil

(

const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &

f

)

[inline]

Definition at line 615 of file function.hpp.

References inside().

                                            {
  return (void*) inside (f) == NULL; }

bool mmx::is_nil

(

const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &

f

)

[inline]

Definition at line 555 of file function.hpp.

References inside().

                                            {
  return (void*) inside (f) == NULL; }

bool mmx::is_nil

(

const function_6< D, S1, S2, S3, S4, S5, S6 > &

f

)

[inline]

Definition at line 495 of file function.hpp.

References inside().

                                            {
  return (void*) inside (f) == NULL; }

bool mmx::is_nil

(

const function_5< D, S1, S2, S3, S4, S5 > &

f

)

[inline]

Definition at line 436 of file function.hpp.

References inside().

                                            {
  return (void*) inside (f) == NULL; }

bool mmx::is_nil

(

const function_4< D, S1, S2, S3, S4 > &

f

)

[inline]

Definition at line 377 of file function.hpp.

References inside().

                                            {
  return (void*) inside (f) == NULL; }

bool mmx::is_nil

(

const function_3< D, S1, S2, S3 > &

f

)

[inline]

Definition at line 318 of file function.hpp.

References inside().

                                            {
  return (void*) inside (f) == NULL; }

bool mmx::is_nil

(

const function_2< D, S1, S2 > &

f

)

[inline]

Definition at line 259 of file function.hpp.

References inside().

                                            {
  return (void*) inside (f) == NULL; }

bool mmx::is_nil

(

const function_1< D, S1 > &

f

)

[inline]

Definition at line 159 of file function.hpp.

References inside().

                                            {
  return (void*) inside (f) == NULL; }

bool mmx::is_nil

(

const function_0< D > &

f

)

[inline]

Definition at line 103 of file function.hpp.

References inside().

                                            {
  return (void*) inside (f) == NULL; }

bool is_nil

(

const chain< C > &

c

)

[inline]

Definition at line 134 of file chain.hpp.

Referenced by alias_getter(), alias_setter(), alias_specializer(), append(), invalidator_2_rep< R >::apply(), invalidator_1_rep< R >::apply(), as_vector(), balance_left(), balance_right(), binary_test(), cAr(), car(), cDr(), cdr(), complete(), completion_generator(), table_rep< C, T, V >::contains(), contains(), convert(), copy(), as_helper< list< T >, list< F > >::cv(), binary_helper< list< C > >::disassemble(), dispatcher_2_rep< R >::dispatch(), dispatcher_1_rep< R >::dispatch(), memoizer< V >::end(), exact_eq(), find(), flatten(), table_rep< C, T, V >::get(), GLUE_13(), GLUE_14(), GLUE_15(), insert(), is_atom(), list_iterator_rep< C >::is_busy(), iterate(), list_apply(), list_map_1(), list_map_2(), list_map_n(), map(), merge(), N(), operator==(), output_completion(), range(), table_rep< C, T, V >::reset(), table_rep< C, T, V >::resize(), restore_evaluator(), reverse(), table_rep< C, T, V >::set(), set_as(), table_rep< C, T, V >::simplify(), source_assign(), source_column(), source_error(), source_exists(), source_file(), source_line(), source_locate(), source_string(), source_string_unindented(), source_underlined(), table_iterator_rep< C, T, V >::spool(), entries_iterator_rep< C, T, V >::spool(), unary_hash(), and binary_helper< list< C > >::write().

{ return c.rep == NULL; }

bool mmx::is_non_scalar

(

const vector< C, vector_fixed< V, S > > &

v

)

[inline]

Definition at line 372 of file vector.hpp.

{ (void) v; return true; }

bool is_non_scalar

(

const vector< C, V > &

v

)

[inline]

Definition at line 213 of file vector.hpp.

Referenced by append(), big(), big_dicho(), binary_map(), binary_test(), cons(), dot(), extend(), foreach(), inside_append(), is_atom(), map(), vector< C, V >::operator<<(), vector< observer >::operator[](), seg(), unary_set(), vector_is_atom(), and vector_map_2().

{ return !v->scalar_flag; }

bool mmx::is_numeric

(

const string &

obj->lex_string

)

bool mmx::is_numeric

(

const string &

s

)

Definition at line 105 of file generic_utils.cpp.

References N().

Referenced by compare_sub(), product_less_op::op(), and sum_less_op::op().

                             {
  return
    (N(s) > 0 && s[0] >= '0' && s[0] <= '9') ||
    (N(s) > 1 && s[0] == '-' && s[1] >= '0' && s[1] <= '9');
}

bool mmx::is_numeric_string

(

const string &

s

)

[inline]

Definition at line 201 of file string.hpp.

References C.

                                    {
  C val;
  return string_to_numeric<C> (s, val);
}

bool mmx::is_output_port

(

const port &

p

)

[inline]

Definition at line 96 of file port.hpp.

References inside().

Referenced by composite_port_rep::can_write(), composite_port_rep::flush(), GLUE_9(), composite_port_rep::is_output_port(), and composite_port_rep::write().

                                           {
  return inside (p)->is_output_port (); }

bool mmx::is_power_of_two

(

nat

p

)

[inline]

Definition at line 89 of file int.hpp.

                        {
  if (p == 0) return false;
  while ((p & 1) == 0) p >>= 1;
  return p == 1;
}

bool mmx::is_quoted

(

const string &

obj->lex_string

)

Definition at line 512 of file string.cpp.

References N().

                            {
  nat i, n= N(s);
  if (n < 2) return false;
  if (s[0] == '\"' && s[n-1] == '\"') {
    for (i=1; i<n-1; i++)
      if (s[i] == '\\') i++;
      else if (s[i] == '\"') return false;
    return i == n-1;
  }
  if (s[0] == '/' && s[1] == '\"' && s[n-2] == '\"' && s[n-1] == '/') {
    for (i=2; i<n-2; i++)
      if (s[i] == '\"' && s[i+1] == '/') return false;
    return i == n-2;
  }
  return false;
}

bool mmx::is_quoted

(

const string &

s

)

Add around s.

Referenced by is_literal_string().

bool mmx::is_reconstructible	(	const vector< C, V > &	v,
		vector< typename unary_return_type_helper< reconstruct_op, C >::RET, W > &	w
	)			[inline]

Definition at line 1275 of file vector.hpp.

References CF(), fill(), and N().

                                                                       {
  w= fill (N(v), CF(w));
  for (nat i= 0; i < N(v); i++)
    if (!is_reconstructible (v[i], w[i])) return false;
  return true; }

bool mmx::is_reliable

(

const vector< C, V > &

v

)

[inline]

Definition at line 1322 of file vector.hpp.

References C, is_a_scalar(), and is_reliable().

                                               {
  if (is_a_scalar (v)) return is_reliable (v.scalar());
  return is_reliable (C (0)); }

bool mmx::is_reliable

(

const table< C, T, V > &

t

)

[inline]

Definition at line 736 of file table.hpp.

References C, and is_reliable().

                                              {
  return is_reliable (C (0)); }

bool mmx::is_reliable

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 807 of file new_table.hpp.

References C, and is_reliable().

                                              {
  return is_reliable (C (0)); }

bool mmx::is_reliable

(

const double &

x

)

[inline]

Definition at line 81 of file double.hpp.

{ (void) x; return false; }

bool mmx::is_reliable

(

const C &

x

)

[inline]

Definition at line 701 of file defaults.hpp.

Referenced by is_reliable(), is_reliable_op::not_op(), and is_reliable_op::op().

                                                          {
  (void) x; return true; }

bool mmx::is_table

(

const generic &

x

)

[inline]

Definition at line 223 of file generic.hpp.

References SPECIES_TABLE, and species_type().

Referenced by GLUE_4().

                                        {
  return species_type (x) == SPECIES_TABLE; }

bool mmx::is_tuple_type

(

nat

id

)

[inline]

Definition at line 100 of file tuple.hpp.

References tuple_type_info().

Referenced by define_type_sub().

                       {
  bool mode= false;
  tuple_type_info (id, mode);
  return mode;
}

static bool mmx::is_upcase

(

register char

c

)

[static]

Definition at line 433 of file string.cpp.

Referenced by locase(), and locase_first().

                            {
  int code= (int) ((unsigned char) c);
  return
    ((c>='A') && (c<='Z')) ||
    ((code >= 128) && (code < 159)) ||
    ((code >= 192) && (code < 224));
}

bool mmx::is_vector

(

const generic &

x

)

[inline]

Definition at line 219 of file generic.hpp.

References species_type(), and SPECIES_VECTOR.

                                         {
  return species_type (x) == SPECIES_VECTOR; }

bool mmx::is_zero

(

const C &

x

)

[inline]

Definition at line 141 of file defaults.hpp.

References promote().

Referenced by div_op::def().

                                                      {
  return x == promote (0, x); }

iterator<C> mmx::iterate

(

const vector< C, V > &

v

)

[inline]

Definition at line 515 of file vector.hpp.

                          {
  return iterator<C> (new vector_iterator_rep<C,V> (v));
}

iterator<C> mmx::iterate

(

const tuple< C > &

t

)

[inline]

Definition at line 83 of file tuple.hpp.

References as_vector(), and iterate().

                         {
  return iterate (as_vector (t));
}

iterator<pair<T,C> > mmx::iterate

(

const table< C, T, V > &

t

)

[inline]

Definition at line 414 of file table.hpp.

                         {
  return iterator<pair<T,C> > (new table_iterator_rep<C,T,V> (t));
}

iterator<pair<T,C> > mmx::iterate

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 485 of file new_table.hpp.

                         {
  return iterator<pair<T,C> > (new table_iterator_rep<C,T,V> (t));
}

iterator<C> mmx::iterate

(

const list< C > &

l

)

[inline]

Definition at line 202 of file list.hpp.

                        {
  return iterator<C> (new list_iterator_rep<C> (l));
}

iterator<C> mmx::iterate

(

const heap< C > &

h

)

[inline]

Definition at line 217 of file heap.hpp.

                        {
  return iterator<C> (new heap_iterator_rep<C> (h));
}

iterator<C> mmx::iterate

(

const chain< C > &

c

)

[inline]

Definition at line 142 of file chain.hpp.

References get_format(), is_nil(), left(), middle(), and right().

Referenced by binary_helper< table< C, T, V > >::disassemble(), binary_helper< new_table< C, T, V > >::disassemble(), flatten(), GLUE_3(), lazy_iterator_rep< C, T >::initialize(), iterate(), make_cache_3(), make_cache_4(), make_mmx_new_table(), make_mmx_table(), unary_hash(), and vector_lift_iterator().

                         {
  if (is_nil (c)) return iterator<C> ();
  return
    lazy_iterator<C,Chain > (left (c), get_format (middle (c))) *
    iterator<C> (middle (c)) *
    lazy_iterator<C,Chain > (right (c), get_format (middle (c)));
}

iterator<T> mmx::iterator_append	(	const iterator< T > &	head,
		const iterator< T > &	tail
	)			[inline]

Definition at line 454 of file mmc_glue.hpp.

                                                                   {
  return head * tail;
}

bool mmx::iterator_busy

(

const iterator< T > &

it

)

[inline]

Definition at line 401 of file mmc_glue.hpp.

References busy().

                                      {
  return busy (it);
}

iterator<U> mmx::iterator_cond_where	(	const function_1< U, typename argument_helper< T >::arg_type > &	fun,
		const iterator< T > &	it,
		const function_1< bool, typename argument_helper< T >::arg_type > &	cond,
		const format< T > &	fmT,
		const format< U > &	fmU
	)			[inline]

Definition at line 651 of file mmc_glue.hpp.

References iterator_filter(), and iterator_where().

{
  return iterator_where (fun, iterator_filter (cond, it, fmT), fmU);
}

iterator<U> mmx::iterator_cond_where	(	const function_1< U, typename argument_helper< T >::arg_type > &	fun,
		const iterator< T > &	it,
		const function_1< bool, typename argument_helper< T >::arg_type > &	cond
	)			[inline]

Definition at line 643 of file mmc_glue.hpp.

References iterator_filter(), and iterator_where().

{
  return iterator_where (fun, iterator_filter (cond, it));
}

iterator<T> mmx::iterator_cons	(	const T &	c,
		const iterator< T > &	tail
	)			[inline]

Definition at line 449 of file mmc_glue.hpp.

                                                    {
  return iterator<T> (c) * tail;
}

T mmx::iterator_current

(

const iterator< T > &

it

)

[inline]

Definition at line 406 of file mmc_glue.hpp.

                                         {
  return *it;
}

iterator<S> mmx::iterator_downwards_range	(	const S &	start,
		const T &	end
	)			[inline]

Definition at line 433 of file mmc_glue.hpp.

References range_iterator().

                                                        {
  return range_iterator (start, outplace_set_as<S> (end),
                         outplace_set_as<S> (-1), false);
}

vector<T> mmx::iterator_explode

(

const iterator< T > &

it

)

[inline]

Definition at line 416 of file mmc_glue.hpp.

                                         {
  return vector<T> (it);
}

iterator<T> mmx::iterator_filter	(	const function_1< bool, typename argument_helper< T >::arg_type > &	cond,
		const iterator< T > &	it,
		const format< T > &	fm
	)			[inline]

Definition at line 636 of file mmc_glue.hpp.

{
  return iterator<T> (new filter_iterator_rep<T> (cond, it, fm));
}

iterator<T> mmx::iterator_filter	(	const function_1< bool, typename argument_helper< T >::arg_type > &	cond,
		const iterator< T > &	it
	)			[inline]

Definition at line 629 of file mmc_glue.hpp.

Referenced by iterator_cond_where().

{
  return iterator<T> (new filter_iterator_rep<T> (cond, it));
}

void mmx::iterator_increase

(

const iterator< T > &

it

)

[inline]

Definition at line 411 of file mmc_glue.hpp.

                                          {
  ++it;
}

iterator<U> mmx::iterator_lift	(	const function_1< U, typename argument_helper< T >::arg_type > &	fun,
		const iterator< T > &	it,
		const format< U > &	fm
	)			[inline]

Definition at line 524 of file mmc_glue.hpp.

{
  return iterator<U> (new lift_arg_iterator_rep<T,U> (fun, it, fm));
}

iterator<U> mmx::iterator_lift	(	const function_1< U, typename argument_helper< T >::arg_type > &	fun,
		const iterator< T > &	it
	)			[inline]

Definition at line 517 of file mmc_glue.hpp.

{
  return iterator<U> (new lift_arg_iterator_rep<T,U> (fun, it, format<U> ()));
}

iterator<U> mmx::iterator_lift

(

const iterator< T > &

it

)

[inline]

Definition at line 481 of file mmc_glue.hpp.

                                      {
  return iterator<U> (new lift_iterator_rep<T,U> (it, format<U> ()));
}

iterator<T> mmx::iterator_lift_from_generic	(	const iterator< generic > &	it,
		const format< T > &	fm
	)			[inline]

Definition at line 491 of file mmc_glue.hpp.

                                                 {
  return iterator<T> (new lift_iterator_rep<generic,T> (it, fm));
}

iterator<T> mmx::iterator_lift_from_generic

(

const iterator< generic > &

it

)

[inline]

Definition at line 486 of file mmc_glue.hpp.

                                                         {
  return iterator<T> (new lift_iterator_rep<generic,T> (it, format<T> ()));
}

vector<U> mmx::iterator_lift_vector	(	const function_1< U, typename argument_helper< T >::arg_type > &	fun,
		const iterator< T > &	it,
		const format< U > &	fm
	)			[inline]

Definition at line 538 of file mmc_glue.hpp.

References vector_lift().

{
  return vector_lift (fun, vector<T> (it), fm);
}

vector<U> mmx::iterator_lift_vector	(	const function_1< U, typename argument_helper< T >::arg_type > &	fun,
		const iterator< T > &	it
	)			[inline]

Definition at line 531 of file mmc_glue.hpp.

References vector_lift().

{
  return vector_lift (fun, vector<T> (it));
}

iterator<S> mmx::iterator_natural_range	(	const S &	start,
		const T &	end
	)			[inline]

Definition at line 427 of file mmc_glue.hpp.

References range_iterator().

                                                      {
  return range_iterator (start, outplace_set_as<S> (end),
                         outplace_set_as<S> (1), false);
}

iterator<T> mmx::iterator_nil

(

const format< T > &

fm

)

[inline]

Definition at line 444 of file mmc_glue.hpp.

                                   {
  return iterator<T> (fm);
}

iterator<T> mmx::iterator_nil

(

)

[inline]

Definition at line 439 of file mmc_glue.hpp.

                {
  return iterator<T> ();
}

iterator<S> mmx::iterator_strict_range	(	const S &	start,
		const T &	end
	)			[inline]

Definition at line 421 of file mmc_glue.hpp.

References range_iterator().

                                                     {
  return range_iterator (start, outplace_set_as<S> (end),
                         outplace_set_as<S> (1), true);
}

iterator<T> mmx::iterator_unnest

(

const iterator< iterator< T > > &

it

)

[inline]

Definition at line 695 of file mmc_glue.hpp.

                                                   {
  return iterator<T> (new unnest_iterator_rep<T> (it));
}

iterator<U> mmx::iterator_where	(	const function_1< U, typename argument_helper< T >::arg_type > &	fun,
		const iterator< T > &	it,
		const format< U > &	fm
	)			[inline]

Definition at line 595 of file mmc_glue.hpp.

                                     {
  return iterator<U> (new where_iterator_rep<T,U> (fun, it, fm));
}

iterator<U> mmx::iterator_where	(	const function_1< U, typename argument_helper< T >::arg_type > &	fun,
		const iterator< T > &	it
	)			[inline]

Definition at line 590 of file mmc_glue.hpp.

Referenced by iterator_cond_where().

                                                                              {
  return iterator<U> (new where_iterator_rep<T,U> (fun, it, format<U> ()));
}

generic mmx::keyword	(	const generic &	op,
		const generic &	g
	)			[inline]

Definition at line 143 of file mmx_printer.cpp.

References gen().

                                                             {
  return gen ("$keyword", op, g); }

generic mmx::keyword

(

const generic &

g

)

[inline]

Definition at line 141 of file mmx_printer.cpp.

References gen().

Referenced by mmx_lex(), and mmx_printer::pp_E0().

                                          {
  return gen ("$keyword", g); }

C mmx::largest_cst

(

const format< C > &

fm

)

[inline]

Definition at line 948 of file type_props.hpp.

References C, promote(), and set_largest().

                                  {
  C r= promote (0, fm); set_largest (r); return r; }

C mmx::largest_cst

(

)

[inline]

Definition at line 910 of file type_props.hpp.

References C, and set_largest().

{ C r; set_largest (r); return r; }

iterator<C> mmx::lazy_iterator	(	const T &	x,
		const format< C > &	fm
	)			[inline]

Definition at line 436 of file iterator.hpp.

References Iterator.

                                             {
  return Iterator (new lazy_iterator_rep<C,T> (x, fm));
}

syntactic lcm	(	const syntactic &	g1,
		const syntactic &	g2
	)

Definition at line 408 of file syntactic.cpp.

References exact_eq(), GEN_LCM, and syn().

                                                         {
  if (exact_eq (g1, 0) || exact_eq (g2, 0)) return 0;
  return syn (GEN_LCM, g1, g2);
}

generic lcm	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 719 of file generic.cpp.

References current_ev, and GEN_LCM.

Referenced by lcm_op::op(), and lcm_op::set_op().

                                                   {
  return current_ev->apply (GEN_LCM, x1, x2); }

chain< C > left

(

const chain< C > &

c

)

[inline]

Definition at line 131 of file chain.hpp.

Referenced by balance_left(), balance_right(), binary_test(), car(), cDr(), cdr(), copy(), binary_helper< chain< C > >::disassemble(), iterate(), map(), operator*(), range(), reverse(), shift_left(), shift_right(), skew_div(), skew_quo(), skew_rem(), unary_hash(), and binary_helper< chain< C > >::write_bis().

{ return c.rep->l; }

bool mmx::less_operator	(	const T &	x,
		const T &	y
	)			[inline]

Definition at line 38 of file operators.hpp.

{ return x<y; }

bool mmx::lesseq_operator	(	const T &	x,
		const T &	y
	)			[inline]

Definition at line 39 of file operators.hpp.

{ return x<=y; }

format<typename unary_return_type_helper<lift_op, C >::RET > mmx::lift

(

const format< C > &

fm

)

[inline]

Definition at line 835 of file type_props.hpp.

References get_format(), get_sample(), and lift().

{ return get_format (lift (get_sample (fm))); }

unary_return_type_helper<lift_op, C >::RET mmx::lift

(

const C &

x

)

[inline]

Definition at line 829 of file type_props.hpp.

Referenced by lift(), and lift_helper< vector< C, V > >::op().

{ return lift_helper<C>::op (x); }

generic mmx::list_append_several

(

const tuple< list< generic > > &

t

)

Definition at line 96 of file glue_list_map.cpp.

References N(), and rebuild().

Referenced by glue_list_map().

                                                     {
  list<generic> r;
  for (int i=N(t)-1; i>=0; i--)
    r= t[i] * r;
  return rebuild (r);
}

generic mmx::list_apply	(	const generic &	f,
		const list< generic > &	l2
	)

Definition at line 104 of file glue_list_map.cpp.

References default_routine(), is_nil(), N(), n, read_car(), and read_cdr().

Referenced by glue_list_map().

                                                       {
  routine fun= is<routine> (f)? as<routine> (f): default_routine (f);
  list<generic> l= l2;
  nat i, n= N(l);
  vector<generic> a= fill<generic> (n);
  for (i=0; !is_nil (l); i++, l= read_cdr(l))
    a[i]= read_car (l);
  return fun->apply (a);
}

generic mmx::list_foreach	(	const generic &	f,
		const tuple< list< generic > > &	t
	)

Definition at line 90 of file glue_list_map.cpp.

References gen(), GEN_TUPLE, and list_map().

Referenced by glue_list_map().

                                                                {
  generic r= list_map (f, t);
  return as<generic> (tuple<generic> (gen (GEN_TUPLE)));
}

generic mmx::list_map	(	const generic &	f,
		const tuple< list< generic > > &	t
	)

Definition at line 72 of file glue_list_map.cpp.

References ASSERT, cdr(), compound_to_vector(), default_routine(), list_map_1(), list_map_2(), list_map_n(), n, N(), and rebuild().

Referenced by glue_list_map(), and list_foreach().

                                                            {
  routine fun= is<routine> (f)? as<routine> (f): default_routine (f);
  switch (N(t)) {
  case 0: ASSERT (N(t)>0, "wrong number of arguments");
  case 1: return rebuild (list_map_1 (fun, t[0]));
  case 2: return rebuild (list_map_2 (fun, t[0], t[1]));
  default:
    {
      const vector<generic> a= cdr (compound_to_vector (*t));
      nat i, n= N(a);
      vector<list<generic> > b= fill<list<generic> > (n);
      for (i=0; i<n; i++) b[i]= as<list<generic> > (a[i]);
      return rebuild (list_map_n (fun, b));
    }
  }
}

list<generic> mmx::list_map_1	(	const routine &	fun,
		const list< generic > &	l
	)

Definition at line 36 of file glue_list_map.cpp.

References car(), cdr(), cons(), and is_nil().

Referenced by list_map().

                                                        {
  if (is_nil (l)) return l;
  generic r= fun->apply (car (l));
  return cons (r, list_map_1 (fun, cdr (l)));
}

list<generic> mmx::list_map_2	(	const routine &	fun,
		const list< generic > &	l1,
		const list< generic > &	l2
	)

Definition at line 43 of file glue_list_map.cpp.

References ASSERT, car(), cdr(), cons(), and is_nil().

Referenced by list_map().

{
  ASSERT (is_nil (l1) == is_nil (l2), "lists of unequal lengths");
  if (is_nil (l1)) return l1;
  generic r= fun->apply (car (l1), car (l2));
  return cons (r, list_map_2 (fun, cdr (l1), cdr (l2)));
}

list<generic> mmx::list_map_n	(	const routine &	fun,
		const vector< list< generic > > &	a
	)

Definition at line 53 of file glue_list_map.cpp.

References ASSERT, car(), cdr(), cons(), is_nil(), N(), and n.

Referenced by list_map().

                                                                 {
  nat i, n= N(a);
  vector<generic> cara= fill<generic> (n);
  if (is_nil (a[0])) {
    for (i=0; i<n; i++)
      ASSERT (is_nil (a[i]), "lists of unequal lengths");
    return a[0];
  }
  for (i=0; i<n; i++) {
    ASSERT (!is_nil (a[i]), "lists of unequal lengths");
    cara[i]= car (a[i]);
  }
  vector<list<generic> > cdra= fill<list<generic> > (n);
  for (i=0; i<n; i++) cdra[i]= cdr (a[i]);
  generic r= fun->apply (cara);
  return cons (r, list_map_n (fun, cdra));
}

list<generic> mmx::list_sort	(	const list< generic > &	l,
		const generic &	f
	)

Definition at line 123 of file glue_list_map.cpp.

References current_comparison, default_routine(), generic_compare(), and sort().

Referenced by glue_list_map().

                                                     {
  routine old_comparison= current_comparison;
  current_comparison= is<routine> (f)? as<routine> (f): default_routine (f);
  list<generic> r= sort (l, generic_compare);
  current_comparison= old_comparison;
  return r;
}

generic lit

(

const string &

s

)

Definition at line 39 of file literal.cpp.

                              {
  return new generic_concrete_rep<literal> (literal (s)); }

generic lit

(

const char *

s

)

Definition at line 37 of file literal.cpp.

Referenced by flatten(), glue_basix_table_generic(), glue_basix_vector_generic(), glue_document(), glue_double(), glue_dynamic(), glue_int(), glue_list_generic(), glue_port(), glue_routine(), glue_storage(), and glue_syntactic().

                            {
  return new generic_concrete_rep<literal> (literal (s)); }

compound mmx::literal_apply	(	const literal &	f,
		const vector< generic > &	v
	)			[inline]

Definition at line 70 of file mmc_glue.hpp.

References cons().

                                                           {
  return compound (cons (as<generic> (f), v));
}

string literal_to_string

(

const generic &

g

)

Definition at line 26 of file literal.cpp.

References as_string().

Referenced by as_lisp(), as_math(), as_string(), as_texmacs(), bool(), compare_sub(), concat_append(), is_applicable(), scheme_to_tm(), serialize(), source_error(), source_exception(), texmacs_expand(), and texmacs_to_scheme().

                                     {
  return as_string (as<literal> (g));
}

bool mmx::load	(	const string &	file_path,
		const string &	file_name,
		string &	obj->lex_string
	)

Definition at line 749 of file system.cpp.

References decode_name(), and var_load().

                                                                   {
  //mmout << "load: " << file_path << ", " << file_name << lf;
  return var_load (file_path, decode_name (file_name), s);
}

bool mmx::load	(	const string &	orig_file_name,
		string &	obj->lex_string
	)

Definition at line 718 of file system.cpp.

References decode_name(), and var_load().

                                               {
  return var_load (decode_name (orig_file_name), s);
}

bool mmx::load	(	const string &	fp,
		const string &	file_name,
		string &	s
	)

bool mmx::load	(	const string &	file_name,
		string &	s
	)

Referenced by mmc_load(), mmc_parse(), and shell_load_session().

bool load_directory	(	const string &	name,
		vector< string > &	s
	)

Definition at line 764 of file system.cpp.

References as_charp(), decode_name(), free_charp(), and sort().

Referenced by mmc_load_directory(), and recursive_search_name().

                                                              {
  string name= decode_name (orig_name);
  DIR* dp;
  char* temp= as_charp (name);
  dp= opendir (temp);
  free_charp (temp);
  dir= vector<string> ();
  if (dp == NULL) return true;

  struct dirent* ep;
  while (true) {
    ep= readdir (dp);
    if (ep == NULL) break;
    dir << string (ep->d_name);
  }
  (void) closedir (dp);
  sort (dir);
  return false;
}

string load_path

(

)

Definition at line 259 of file system.cpp.

References _from_dos_to_unix(), get_env(), path_sep, prefix_dir(), and user_dir().

Referenced by path_name(), resolve_name(), and var_load().

             {
  string path= _from_dos_to_unix (get_env ("MMX_LOAD_PATH"));
  if (path != "" && path[0] != path_sep) path= string (path_sep) * path;
  path= "." * string (path_sep) * user_dir () * "/mmx"
    * string (path_sep) * prefix_dir () * "/share"
    * string (path_sep) * prefix_dir () * "/share/mmx" * path;
  return path;
}

string mmx::locase

(

const string &

obj->lex_string

)

Definition at line 452 of file string.cpp.

References is_upcase(), and N().

                         {
  nat i, n= N(s);
  string r (n);
  for (i=0; i<n; i++)
    if (!is_upcase (s[i])) r[i]= s[i];
    else r[i]= (char) (((int) ((unsigned char) s[i]))+32);
  return r;
}

string mmx::locase

(

const string &

s

)

Replace upcases by locases.

Referenced by GLUE_17().

string mmx::locase_first

(

const string &

obj->lex_string

)

Definition at line 470 of file string.cpp.

References copy(), is_upcase(), and N().

                               {
  string r= copy (s);
  if (N(r) != 0 && is_upcase (s[0]))
    r[0]= (char) (((int) ((unsigned char) s[0]))+32);
  return r;
}

string mmx::locase_first

(

const string &

s

)

Replace upcase by locase for first letter.

Referenced by GLUE_19().

void mmx::lock	(	const storage &	st,
		const string &	var
	)			[inline]

Read variable var from storage st.

Definition at line 72 of file storage.hpp.

Referenced by GLUE_6(), mmx_free_thread_safe(), mmx_malloc_thread_safe(), and mmx_realloc_thread_safe().

                                                        {
  st->lock (var); }

vector<C,V> mmx::log

(

const vector< C, V > &

v

)

[inline]

Definition at line 1179 of file vector.hpp.

{ return unary_map<log_op> (v); }

table<C,T,V> mmx::log

(

const table< C, T, V > &

t

)

[inline]

Definition at line 700 of file table.hpp.

{ return unary_map<log_op> (t); }

syntactic log

(

const syntactic &

g

)

Definition at line 429 of file syntactic.cpp.

References GEN_LOG, and syn().

{ return syn (GEN_LOG, g); }

new_table<C,T,V> mmx::log

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 771 of file new_table.hpp.

{ return unary_map<log_op> (t); }

generic log

(

const generic &

x1

)

Definition at line 439 of file generic.cpp.

References ACC_LOG, ACC_UNARY, current_ev, and GEN_LOG.

                        {
  ACC_UNARY (ACC_LOG, x1);
  return current_ev->apply (GEN_LOG, x1);
}

double log

(

const double &

x

)

[inline]

Definition at line 47 of file double.hpp.

Referenced by acosh(), asinh(), atanh(), log_op::op(), set_log2(), and log_op::set_op().

{ return std::log (x); }

double log2

(

const double &

x

)

[inline]

Definition at line 48 of file double.hpp.

Referenced by magnitude(), log2_op::op(), and log2_op::set_op().

{ return ::log2 (x); }

C mmx::log2_cst

(

const format< C > &

fm

)

[inline]

Definition at line 927 of file type_props.hpp.

References C, promote(), and set_log2().

                               {
  C r= promote (0, fm); set_log2 (r); return r; }

C mmx::log2_cst

(

)

[inline]

Definition at line 896 of file type_props.hpp.

References C, and set_log2().

{ C r; set_log2 (r); return r; }

nat mmx::log_2

(

nat

p

)

[inline]

Definition at line 70 of file int.hpp.

              {
  nat i=0;
  while (p>1) {
    p >>= 1;
    i++;
  }
  return i;
}

nat mmx::log_3

(

nat

p

)

[inline]

Definition at line 96 of file int.hpp.

              {
  nat i=0;
  while (p>1) {
    p /= 3;
    i++;
  }
  return i;
}

syntactic log_init	(	const syntactic &	x,
		const syntactic &	c
	)

Definition at line 491 of file syntactic.cpp.

References syn().

                                                            {
  return syn ("log_init", x, c); }

generic log_init	(	const generic &	x,
		const generic &	c
	)

Definition at line 804 of file generic.cpp.

References current_ev.

Referenced by log_op::op_init().

                                                        {
  return current_ev->apply ("log_init", x1, x2); }

vector<typename unary_return_type_helper<center_op, C >::RET,V> mmx::lower

(

const vector< C, V > &

v

)

[inline]

Definition at line 1349 of file vector.hpp.

                                           {
  return unary_map<lower_op> (v); }

C mmx::lower

(

const C &

x

)

[inline]

Definition at line 1114 of file type_props.hpp.

Referenced by lower_op::Center_type(), and lower_op::set_op().

{ return x; }

generic lres	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 842 of file generic.cpp.

References current_ev.

                                                    {
  return current_ev->apply ("lres", x1, x2); }

void mmx::lshift2	(	C &	x,
		const C &	y,
		const S &	z
	)			[inline]

Definition at line 296 of file defaults.hpp.

{ x= y << z; }

C mmx::lshift2

(

const C &

x

)

[inline]

Definition at line 292 of file defaults.hpp.

{ return lshift2<C,int> (x, 1); }

C mmx::lshift2	(	const C &	x,
		const S &	y
	)			[inline]

Definition at line 290 of file defaults.hpp.

Referenced by lshift2_op::op(), and lshift2_op::set_op().

{ return x << y; }

void mmx::lshift2_assign	(	C &	x,
		const S &	y
	)			[inline]

Definition at line 294 of file defaults.hpp.

Referenced by lshift2_op::set_op().

{ x <<= y; }

syntactic lshiftz	(	const syntactic &	g,
		const syntactic &	sh
	)

Definition at line 471 of file syntactic.cpp.

References syn().

                                                            {
  return syn ("lshiftz", g, sh); }

generic lshiftz	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 834 of file generic.cpp.

References current_ev.

                                                       {
  return current_ev->apply ("lshiftz", x1, x2); }

void mmx::lshiftz	(	C &	x,
		const C &	y,
		const S &	z
	)			[inline]

Definition at line 313 of file defaults.hpp.

{ x= y << z; }

C mmx::lshiftz

(

const C &

x

)

[inline]

Definition at line 309 of file defaults.hpp.

{ return lshiftz<C,int> (x, 1); }

C mmx::lshiftz	(	const C &	x,
		const S &	y
	)			[inline]

Definition at line 307 of file defaults.hpp.

Referenced by sqrt_op::def(), quo_op::def(), div_op::def(), invert_op::def(), lshiftz_op::op(), rshiftz(), and lshiftz_op::set_op().

{ return x << y; }

void mmx::lshiftz_assign	(	C &	x,
		const S &	y
	)			[inline]

Definition at line 311 of file defaults.hpp.

Referenced by rshiftz_assign(), and lshiftz_op::set_op().

{ x <<= y; }

double mmx::magnitude

(

const vector< C, V > &

v

)

[inline]

Definition at line 1333 of file vector.hpp.

                                               {
  return big<max_magnitude_op> (v); }

double magnitude

(

const generic &

x

)

Definition at line 785 of file generic.cpp.

References ASSERT, current_ev, and GEN_MAGNITUDE.

                                    {
  generic r= current_ev->apply (GEN_MAGNITUDE, x);
  ASSERT (is<double> (r), "Double return value expected");
  return as<double> (r); }

double mmx::magnitude

(

const double &

x

)

[inline]

Definition at line 93 of file double.hpp.

References log2().

{ return log2 (x); }

double mmx::magnitude

(

const C &

x

)

[inline]

Definition at line 703 of file defaults.hpp.

References exponent().

Referenced by GLUE_48(), magnitude_op::op(), max_magnitude_op::set_op(), and magnitude_op::set_op().

                                                          {
  return (double) exponent (x); }

generic mmx::make_abstract

(

const T &

x

)

[inline]

Definition at line 53 of file routine.hpp.

References generic_converter< T >::make_abstract().

                           {
  return generic_converter<T>::make_abstract (x);
}

B mmx::make_ball	(	const C &	c,
		const R &	r
	)			[inline]

Definition at line 1088 of file type_props.hpp.

                                   {
  return make_ball_helper<B,C,R>::val (c, r);
}

document make_block

(

const vector< document > &

v

)

Definition at line 97 of file document.cpp.

References make_document().

Referenced by GLUE_12().

                                       {
  return make_document (v, true);
}

cache<C,T> mmx::make_cache_1	(	const format< T > &	fm1,
		const format< C > &	fm2
	)			[inline]

Definition at line 86 of file cache.hpp.

References Cache, and default_cst().

                                                          {
  return Cache (table<C,T> (default_cst (fm2), fm1));
}

cache<C,T> mmx::make_cache_2	(	const C &	init,
		const format< T > &	fm
	)			[inline]

Definition at line 91 of file cache.hpp.

References Cache.

                                                  {
  return Cache (table<C,T> (init, fm));
}

cache<C,T> mmx::make_cache_3

(

const vector< pair< T, C > > &

v

)

[inline]

Definition at line 96 of file cache.hpp.

References Cache, CF(), default_cst(), get_format2(), and iterate().

                                           {
  return Cache (table<C,T> (default_cst (get_format2 (CF(v))), iterate (v)));
}

cache<C,T> mmx::make_cache_4	(	const C &	init,
		const vector< pair< T, C > > &	v
	)			[inline]

Definition at line 101 of file cache.hpp.

References Cache, and iterate().

                                                          {
  return Cache (table<C,T> (init, iterate (v)));
}

T mmx::make_concrete

(

const generic &

x

)

[inline]

Definition at line 48 of file routine.hpp.

References generic_converter< T >::make_concrete().

                                 {
  return generic_converter<T>::make_concrete (x);
}

document mmx::make_document	(	const vector< document > &	v,
		bool	block = false
	)

Definition at line 71 of file document.cpp.

References as_document(), as_documents(), as_generic(), cdr(), compound_to_vector(), gen(), GEN_ROW, is_func(), and N().

Referenced by make_block(), and make_inline().

                                                             {
  //mmout << "v= " << v << indent << lf;
  vector<generic> r;
  if (block) r << generic ("$cr");
  for (nat i=0; i<N(v); i++) {
    generic x= as_generic (v[i]);
    //mmout << "v[" << i << "] = " << x << ": " << type_name (x) << lf;
    if (is_func (x, GEN_ROW)) {
      vector<document> a= as_documents (cdr (compound_to_vector (x)));
      r << as_generic (make_document (a));
      if (i != N(v) - 1) r << generic ("$lf");
    }
    else r << x;
  }
  //mmout << unindent;
  //mmout << "r= " << r << lf;
  if (N (r) == 1) return as_document (r[0]);
  else return as_document (gen ("$concat", r));
}

sparse_vector<C,symbol<M>,hard_eq_sparse_vector> mmx::make_formal_vector	(	const C &	c,
		const M &	m
	)			[inline]

Definition at line 353 of file sparse_vector.hpp.

                                            {
  return sparse_vector<C,symbol<M>,hard_eq_sparse_vector> (symbol<M> (m), c);
}

document make_inline

(

const vector< document > &

v

)

Definition at line 92 of file document.cpp.

References make_document().

Referenced by GLUE_11().

                                        {
  return make_document (v);
}

B mmx::make_interval	(	const C &	l,
		const C &	r
	)			[inline]

Definition at line 1110 of file type_props.hpp.

                                       {
  return make_interval_helper<B,C>::val (l, r);
}

C mmx::make_literal

(

const literal &

lit

)

[inline]

Definition at line 58 of file literal.hpp.

References as_string(), and C.

                                  {
  return C (as_string (lit));
}

document make_math

(

const document &

x

)

Definition at line 60 of file document.cpp.

References as_generic(), and make_math().

                              {
  return make_math (as_generic (x));
}

document make_math

(

const generic &

x

)

Definition at line 55 of file document.cpp.

References as_document(), and gen().

Referenced by GLUE_10(), GLUE_9(), and make_math().

                             {
  return as_document (gen ("$math", x));
}

new_table<C,T> mmx::make_mmx_new_table	(	const C &	init,
		const vector< pair< T, C > > &	v
	)			[inline]

Definition at line 885 of file new_table.hpp.

References iterate().

                                                                {
  return table<C,T> (init, iterate (v));
}

new_table<C,T> mmx::make_mmx_new_table

(

const vector< pair< T, C > > &

v

)

[inline]

Definition at line 880 of file new_table.hpp.

References CF(), default_cst(), get_format2(), and iterate().

                                                 {
  return table<C,T> (default_cst (get_format2 (CF(v))), iterate (v));
}

new_table<C,T> mmx::make_mmx_new_table	(	const C &	init,
		const format< T > &	fm
	)			[inline]

Definition at line 875 of file new_table.hpp.

                                                        {
  return table<C,T> (init, fm);
}

new_table<C,T> mmx::make_mmx_new_table	(	const format< T > &	fm1,
		const format< C > &	fm2
	)			[inline]

Definition at line 870 of file new_table.hpp.

References default_cst().

                                                                {
  return table<C,T> (default_cst (fm2), fm1);
}

table<C,T> mmx::make_mmx_table	(	const C &	init,
		const vector< pair< T, C > > &	v
	)			[inline]

Definition at line 814 of file table.hpp.

References iterate().

                                                            {
  return table<C,T> (init, iterate (v));
}

table<C,T> mmx::make_mmx_table

(

const vector< pair< T, C > > &

v

)

[inline]

Definition at line 809 of file table.hpp.

References CF(), default_cst(), get_format2(), and iterate().

                                             {
  return table<C,T> (default_cst (get_format2 (CF(v))), iterate (v));
}

table<C,T> mmx::make_mmx_table	(	const C &	init,
		const format< T > &	fm
	)			[inline]

Definition at line 804 of file table.hpp.

                                                    {
  return table<C,T> (init, fm);
}

table<C,T> mmx::make_mmx_table	(	const format< T > &	fm1,
		const format< C > &	fm2
	)			[inline]

Definition at line 799 of file table.hpp.

References default_cst().

Referenced by GLUE_6().

                                                            {
  return table<C,T> (default_cst (fm2), fm1);
}

pair<T,U> mmx::make_pair	(	const T &	x,
		const U &	y
	)			[inline]

Definition at line 704 of file mmc_glue.hpp.

                                   {
  return pair<T,U> (x, y);
}

document make_row

(

const vector< document > &

v

)

Definition at line 65 of file document.cpp.

References as_document(), as_generics(), gen(), and GEN_ROW.

Referenced by GLUE_13().

                                     {
  vector<generic> r= as_generics (v);
  return as_document (gen (GEN_ROW, r));
}

document make_texmacs	(	const literal &	x,
		const vector< document > &	v
	)

Definition at line 107 of file document.cpp.

References as_document(), as_generics(), as_string(), and gen().

                                                             {
  return as_document (gen ("tm$" * as_string (fun), as_generics (v)));
}

document make_texmacs	(	const string &	x,
		const vector< document > &	v
	)

Definition at line 102 of file document.cpp.

References as_document(), as_generics(), and gen().

Referenced by GLUE_5(), and GLUE_6().

                                                            {
  return as_document (gen ("tm$" * fun, as_generics (v)));
}

document make_text

(

const document &

x

)

Definition at line 50 of file document.cpp.

References as_generic(), and make_text().

                              {
  return make_text (as_generic (x));
}

document make_text

(

const generic &

x

)

Definition at line 45 of file document.cpp.

References as_document(), and gen().

Referenced by GLUE_8(), and make_text().

                             {
  return as_document (gen ("$text", x));
}

vector<D> mmx::map	(	const Fun &	fun,
		const vector< S1 > &	v1,
		const vector< S2 > &	v2,
		const vector< S3 > &	v3,
		const format< D > &	fm
	)			[inline]

Definition at line 982 of file vector.hpp.

References ASSERT, is_non_scalar(), n, and N().

{
  ASSERT (is_non_scalar (v1), "non-scalar vector expected");
  ASSERT (is_non_scalar (v2), "non-scalar vector expected");
  ASSERT (is_non_scalar (v3), "non-scalar vector expected");
  ASSERT (N(v1) == N(v2) && N(v2) == N(v3), "lengths don't match");
  nat n= N(v1);
  nat l= default_aligned_size<D> (n);
  D* r= mmx_formatted_new<D> (l, fm);
  for (nat i=0; i<n; i++) r[i]= fun (v1[i], v2[i], v3[i]);
  return vector<D> (r, n, l, fm);
}

vector<D> mmx::map	(	const function_3< D, typename argument_helper< S1 >::arg_type, typename argument_helper< S2 >::arg_type, typename argument_helper< S3 >::arg_type > &	fun,
		const vector< S1 > &	v1,
		const vector< S2 > &	v2,
		const vector< S3 > &	v3
	)			[inline]

Definition at line 965 of file vector.hpp.

References ASSERT, is_non_scalar(), n, and N().

{
  format<D> fm; //= map (fun, CF(v1), CF(v2), CF(v3));
  ASSERT (is_non_scalar (v1), "non-scalar vector expected");
  ASSERT (is_non_scalar (v2), "non-scalar vector expected");
  ASSERT (is_non_scalar (v3), "non-scalar vector expected");
  ASSERT (N(v1) == N(v2) && N(v2) == N(v3), "lengths don't match");
  nat n= N(v1);
  nat l= default_aligned_size<D> (n);
  D* r= mmx_formatted_new<D> (l, fm);
  for (nat i=0; i<n; i++) r[i]= fun (v1[i], v2[i], v3[i]);
  return vector<D> (r, n, l, fm);
}

vector<D> mmx::map	(	const Fun &	fun,
		const vector< S1 > &	v1,
		const vector< S2 > &	v2,
		const format< D > &	fm
	)			[inline]

Definition at line 951 of file vector.hpp.

References ASSERT, is_non_scalar(), n, and N().

{
  ASSERT (is_non_scalar (v1), "non-scalar vector expected");
  ASSERT (is_non_scalar (v2), "non-scalar vector expected");
  ASSERT (N(v1) == N(v2), "lengths don't match");
  nat n= N(v1);
  nat l= default_aligned_size<D> (n);
  D* r= mmx_formatted_new<D> (l, fm);
  for (nat i=0; i<n; i++) r[i]= fun (v1[i], v2[i]);
  return vector<D> (r, n, l, fm);
}

vector<D> mmx::map	(	D(*)(const S1 &, const S2 &)	fun,
		const vector< S1 > &	v1,
		const vector< S2 > &	v2
	)			[inline]

Definition at line 936 of file vector.hpp.

References ASSERT, is_non_scalar(), n, and N().

{
  format<D> fm; //= map (fun, CF(v1), CF(v2));
  ASSERT (is_non_scalar (v1), "non-scalar vector expected");
  ASSERT (is_non_scalar (v2), "non-scalar vector expected");
  ASSERT (N(v1) == N(v2), "lengths don't match");
  nat n= N(v1);
  nat l= default_aligned_size<D> (n);
  D* r= mmx_formatted_new<D> (l, fm);
  for (nat i=0; i<n; i++) r[i]= fun (v1[i], v2[i]);
  return vector<D> (r, n, l, fm);
}

vector<D> mmx::map	(	const function_2< D, typename argument_helper< S1 >::arg_type, typename argument_helper< S2 >::arg_type > &	fun,
		const vector< S1 > &	v1,
		const vector< S2 > &	v2
	)			[inline]

Definition at line 921 of file vector.hpp.

References ASSERT, is_non_scalar(), n, and N().

{
  format<D> fm; //= map (fun, CF(v1), CF(v2));
  ASSERT (is_non_scalar (v1), "non-scalar vector expected");
  ASSERT (is_non_scalar (v2), "non-scalar vector expected");
  ASSERT (N(v1) == N(v2), "lengths don't match");
  nat n= N(v1);
  nat l= default_aligned_size<D> (n);
  D* r= mmx_formatted_new<D> (l, fm);
  for (nat i=0; i<n; i++) r[i]= fun (v1[i], v2[i]);
  return vector<D> (r, n, l, fm);
}

vector<D> mmx::map	(	const Fun &	fun,
		const vector< S1 > &	v1,
		const format< D > &	fm
	)			[inline]

Definition at line 911 of file vector.hpp.

References ASSERT, is_non_scalar(), N(), and n.

                                                                {
  ASSERT (is_non_scalar (v1), "non-scalar vector expected");
  nat n= N(v1);
  nat l= default_aligned_size<D> (n);
  D* r= mmx_formatted_new<D> (l, fm);
  for (nat i=0; i<n; i++) r[i]= fun (v1[i]);
  return vector<D> (r, n, l, fm);
}

vector<D> mmx::map	(	D(*)(const S1 &)	fun,
		const vector< S1 > &	v1
	)			[inline]

Definition at line 900 of file vector.hpp.

References ASSERT, CF(), is_non_scalar(), map(), N(), and n.

                                                 {
  format<D> fm= map (fun, CF(v1));
  ASSERT (is_non_scalar (v1), "non-scalar vector expected");
  nat n= N(v1);
  nat l= default_aligned_size<D> (n);
  D* r= mmx_formatted_new<D> (l, fm);
  for (nat i=0; i<n; i++) r[i]= fun (v1[i]);
  return vector<D> (r, n, l, fm);
}

vector<D> mmx::map	(	const function_1< D, typename argument_helper< S1 >::arg_type > &	fun,
		const vector< S1 > &	v1
	)			[inline]

Definition at line 889 of file vector.hpp.

References ASSERT, CF(), is_non_scalar(), map(), N(), and n.

                                                                   {
  format<D> fm= map (fun, CF(v1));
  ASSERT (is_non_scalar (v1), "non-scalar vector expected");
  nat n= N(v1);
  nat l= default_aligned_size<D> (n);
  D* r= mmx_formatted_new<D> (l, fm);
  for (nat i=0; i<n; i++) r[i]= fun (v1[i]);
  return vector<D> (r, n, l, fm);
}

table<C2,T2> mmx::map	(	const Fun1 &	funT,
		const Fun2 &	funC,
		const table< C1, T1 > &	t,
		const format< T2 > &	fmT,
		const format< C2 > &	fmC
	)			[inline]

Definition at line 596 of file table.hpp.

References busy(), entries(), I(), and simplify().

{
  table<C2,T2> r (funC (I(t)), fmT);
  for (iterator<T1> it= entries (t); busy (it); ++it)
    r[funT(*it)]= funC (t[*it]);
  simplify (r);
  return r;
}

row_tuple<D> mmx::map	(	const function_1< D, typename argument_helper< S1 >::arg_type > &	fun,
		const row_tuple< S1 > &	v1,
		const format< D > &	fm
	)			[inline]

Definition at line 88 of file row_tuple.hpp.

References as_vector(), and map().

                          {
  return as_row_tuple (map (fun, as_vector (v1), fm)); }

pair<C2,T2> mmx::map	(	const Fun1 &	funT,
		const Fun2 &	funC,
		const pair< C1, T1 > &	p,
		const format< C2 > &	fmC,
		const format< T2 > &	fmT
	)			[inline]

Definition at line 99 of file pair.hpp.

References set_as(), pair< C1, C2 >::x1, and pair< C1, C2 >::x2.

{
  pair<C2,T2> r (fmC, fmT);
  set_as (r.x1, p.x1);
  set_as (r.x2, p.x2);
  return r;
}

new_table<C2,T2> mmx::map	(	const Fun1 &	funT,
		const Fun2 &	funC,
		const new_table< C1, T1 > &	t,
		const format< T2 > &	fmT,
		const format< C2 > &	fmC
	)			[inline]

Definition at line 667 of file new_table.hpp.

References busy(), entries(), I(), and simplify().

{
  table<C2,T2> r (funC (I(t)), fmT);
  for (iterator<T1> it= entries (t); busy (it); ++it)
    r[funT(*it)]= funC (t[*it]);
  simplify (r);
  return r;
}

iterator<U> mmx::map	(	const function_1< U, typename argument_helper< T >::arg_type > &	fun,
		const iterator< T > &	it,
		const format< U > &	fm
	)			[inline]

Definition at line 559 of file mmc_glue.hpp.

{
  return iterator<U> (new lift_arg_iterator_rep<T,U> (fun, it, fm));
}

list<D> mmx::map	(	const Fun &	fun,
		const list< S1 > &	l1,
		const format< D > &	fm
	)			[inline]

Definition at line 337 of file list.hpp.

References car(), cdr(), cons(), is_nil(), and map().

                                                              {
  if (is_nil (l1)) return list<D> (fm);
  else return cons (fun (car (l1)), map (fun, cdr (l1), fm));
}

format<R> mmx::map	(	R(*)(const C &)	fun,
		const format< C > &	fm
	)			[inline]

Definition at line 201 of file function.hpp.

References C, and format_function_helper< FT, R, C, Fun >::op().

                                               {
  typedef R (*Fun) (const C&);
  typedef typename format<R>::FT FT;
  return format_function_helper<FT,R,C,Fun>::op (fun, fm);
}

format<R> mmx::map	(	const function_1< R, typename argument_helper< C >::arg_type > &	fun,
		const format< C > &	fm
	)			[inline]

Definition at line 194 of file function.hpp.

References format_function_helper< FT, R, C, Fun >::op().

                                                                 {
  typedef function_1<R,Argument(C) > Fun;
  typedef typename format<R>::FT FT;
  return format_function_helper<FT,R,C,Fun>::op (fun, fm);
}

chain<D> mmx::map	(	const Fun &	fun,
		const chain< S1 > &	c1,
		const format< D > &	fm
	)			[inline]

Definition at line 353 of file chain.hpp.

References is_nil(), left(), middle(), and right().

Referenced by map().

                                                               {
  if (is_nil (c1)) return chain<D> (fm);
  return chain<D> (map (fun, left (c1), fm),
                   fun (middle (c1)),
                   map (fun, right (c1), fm));
}

static table<string, string, exact_eq_table> mmx::math_symbol_table

(

)

[static]

Definition at line 24 of file math_printer.cpp.

References GEN_ACCESS, GEN_AND, GEN_APPEND, GEN_CATALAN, GEN_COMPOSE, GEN_DELTA, GEN_DERIVATIVE, GEN_DIV, GEN_DOT, GEN_DOWNTO, GEN_E, GEN_EQUAL, GEN_EQUIV, GEN_EULER, GEN_FACTORIAL, GEN_GTR, GEN_GTREQ, GEN_GTRGTR, GEN_I, GEN_IMPLIES, GEN_IN, GEN_INFINITY, GEN_INTO, GEN_LESS, GEN_LESSEQ, GEN_LESSLESS, GEN_MAPSTO, GEN_MINUS, GEN_MOD, GEN_NOT, GEN_OR, GEN_OVER, GEN_PARTIAL, GEN_PI, GEN_PLUS, GEN_POWER, GEN_PRIME, GEN_RANGE, GEN_ROW, GEN_SEQAND, GEN_SEQOR, GEN_SIZE, GEN_SQTUPLE, GEN_TIMES, GEN_TO, GEN_TRANSTYPE, GEN_TUPLE, GEN_UNEQUAL, GEN_VARTRANSTYPE, GEN_VARTYPE, GEN_VWHERE, GEN_WHERE, GEN_XOR, and SET_OPNAME.

Referenced by as_math().

                     {
  table<string, string, exact_eq_table> t;

  SET_OPNAME (GEN_ACCESS, "_"); // or "%sqaccess"
  SET_OPNAME (GEN_AND, "/\\");
  SET_OPNAME (GEN_CATALAN, "%mathcatalan");
  SET_OPNAME (GEN_COMPOSE, "%circ");
  SET_OPNAME (GEN_APPEND, "%join");
  SET_OPNAME (GEN_DELTA, "%delta");
  SET_OPNAME (GEN_DERIVATIVE, "D");
  SET_OPNAME (GEN_DOT, "%dotaccess");
  SET_OPNAME (GEN_DIV, "div");
  SET_OPNAME (GEN_E, "%mathe");
  SET_OPNAME (GEN_EQUAL, "=");
  SET_OPNAME (GEN_EQUIV, "<=>");
  SET_OPNAME (GEN_EULER, "%matheuler");
  SET_OPNAME (GEN_FACTORIAL, "factorial");
  SET_OPNAME (GEN_GTR, ">");
  SET_OPNAME (GEN_GTREQ, ">=");
  SET_OPNAME (GEN_GTRGTR, ">>");
  SET_OPNAME (GEN_I, "%mathi");
  SET_OPNAME (GEN_IMPLIES, "=>");
  SET_OPNAME (GEN_IN, "%in");
  SET_OPNAME (GEN_INFINITY, "%infty");
  SET_OPNAME (GEN_INTO, "->");
  SET_OPNAME (GEN_LESS, "<");
  SET_OPNAME (GEN_LESSEQ, "<=");
  SET_OPNAME (GEN_LESSLESS, "<<");
  SET_OPNAME (GEN_MAPSTO, "#{:->}#");
  SET_OPNAME (GEN_MINUS, "-");
  SET_OPNAME (GEN_MOD, "mod");
  SET_OPNAME (GEN_NOT, "!");
  SET_OPNAME (GEN_OR, "\\/");
  SET_OPNAME (GEN_OVER, "/");
  SET_OPNAME (GEN_PARTIAL, "%partial");
  SET_OPNAME (GEN_PI, "%mathpi");
  SET_OPNAME (GEN_PLUS, "+&");
  SET_OPNAME (GEN_POWER, "^");
  SET_OPNAME (GEN_PRIME, "%prime");
  SET_OPNAME (GEN_RANGE, "%ldots"); // problem with iterator flattening
  SET_OPNAME (GEN_TO, "to");
  SET_OPNAME (GEN_DOWNTO, "downto");
  SET_OPNAME (GEN_ROW, "row");
  SET_OPNAME (GEN_SEQAND, "and");
  SET_OPNAME (GEN_SEQOR, "or");
  SET_OPNAME (GEN_SIZE, "%card");
  SET_OPNAME (GEN_SQTUPLE, "list");
  SET_OPNAME (GEN_TIMES, "*&");
  SET_OPNAME (GEN_VARTYPE, "%colons");
  SET_OPNAME (GEN_TRANSTYPE, "#{:>}#");
  SET_OPNAME (GEN_VARTRANSTYPE, "#{::>}#");
  SET_OPNAME (GEN_TUPLE, "tuple");
  //SET_OPNAME (GEN_TYPE, "#{:}#");
  SET_OPNAME (GEN_UNEQUAL, "!=");
  SET_OPNAME (GEN_VWHERE, "|");
  SET_OPNAME (GEN_WHERE, "||");
  SET_OPNAME (GEN_XOR, "%veebar");

  t["alpha"] = "%alpha";
  t["beta"] = "%beta";
  t["gamma"] = "%gamma";
  t["delta"] = "%delta";
  t["epsilon"] = "%varepsilon";
  t["zeta"] = "%zeta";
  t["eta"] = "%eta";
  t["theta"] = "%theta";
  t["iota"] = "%iota";
  t["kappa"] = "%kappa";
  t["lambda"] = "%lambda";
  t["mu"] = "%mu";
  t["nu"] = "%nu";
  t["xi"] = "%xi";
  t["omicron"] = "%omicron";
  t["pi"] = "%pi";
  t["rho"] = "%rho";
  t["sigma"] = "%sigma";
  t["tau"] = "%tau";
  t["upsilon"] = "%upsilon";
  t["phi"] = "%varphi";
  t["chi"] = "%chi";
  t["psi"] = "%psi";
  t["omega"] = "%omega";

  t["Alpha"] = "%Alpha";
  t["Beta"] = "%Beta";
  t["Gamma"] = "%Gamma";
  t["Delta"] = "%Delta";
  t["Epsilon"] = "%Epsilon";
  t["Zeta"] = "%Zeta";
  t["Eta"] = "%Eta";
  t["Theta"] = "%Theta";
  t["Iota"] = "%Iota";
  t["Kappa"] = "%Kappa";
  t["Lambda"] = "%Lambda";
  t["Mu"] = "%Mu";
  t["Nu"] = "%Nu";
  t["Xi"] = "%Xi";
  t["Omicron"] = "%Omicron";
  t["Pi"] = "%Pi";
  t["Rho"] = "%Rho";
  t["Sigma"] = "%Sigma";
  t["Tau"] = "%Tau";
  t["Upsilon"] = "%Upsilon";
  t["Phi"] = "%Phi";
  t["Chi"] = "%Chi";
  t["Psi"] = "%Psi";
  t["Omega"] = "%Omega";
  return t;
}

source_position mmx::max	(	const source_position &	p1,
		const source_position &	p2
	)			[inline]

Definition at line 53 of file source_track.hpp.

References source_position::position.

                                                           {
  return p1.position > p2.position? p1: p2;
};

generic max	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 728 of file generic.cpp.

References current_ev, and GEN_MAX.

                                                   {
  return current_ev->apply (GEN_MAX, x1, x2); }

C mmx::max	(	const C &	x,
		const C &	y
	)			[inline]

Definition at line 478 of file defaults.hpp.

Referenced by as_double(), exponent(), string_rep::extend(), formatting_port_rep::format(), GLUE_22(), GLUE_24(), GLUE_32(), GLUE_34(), max_op::op(), string_rep::resize(), vector_rep< observer, V >::resize(), max_magnitude_op::set_op(), max_exponent_op::set_op(), max_op::set_op(), source_locate(), string_to_floating(), sup(), and wait_port_event().

{ return x>y? x: y; }

C mmx::maximal_cst

(

const format< C > &

fm

)

[inline]

Definition at line 957 of file type_props.hpp.

References C, promote(), and set_maximal().

                                  {
  C r= promote (0, fm); set_maximal (r); return r; }

C mmx::maximal_cst

(

)

[inline]

Definition at line 916 of file type_props.hpp.

References C, and set_maximal().

{ C r; set_maximal (r); return r; }

void mmx::mem_copy	(	char *	d,
		char *	s,
		nat	n
	)			[inline]

Definition at line 112 of file string.hpp.

Referenced by input_output_string_port_rep::read(), input_string_port_rep::read(), and posix_port_rep::read().

                                               {
  for (nat i=0; i<n; i++) d[i]= s[i]; }

list<C> mmx::merge	(	const list< C > &	head,
		const list< C > &	tail,
		int(*)(const C &, const C &)	cmp
	)			[inline]

Merge head and tail that are supposed to be ordered increasingly wrt cmp.

Definition at line 41 of file list_sort.hpp.

References car(), cdr(), cons(), and is_nil().

Referenced by sort().

                                                                            {
  if (is_nil (head)) return tail;
  if (is_nil (tail)) return head;
  if (cmp (car (head), car (tail)) <= 0)
    return cons (car (head), merge (cdr (head), tail, cmp));
  return cons (car (tail), merge (head, cdr (tail), cmp));
}

void message	(	const dynamic &	d,
		const generic &	msg
	)

Definition at line 41 of file dynamic.cpp.

References N().

                                               {
  for (nat i=0; i<N(d->obs); i++)
    d->obs[i]->message (msg);
}

C middle

(

const chain< C > &

c

)

[inline]

Definition at line 132 of file chain.hpp.

Referenced by balance_left(), balance_right(), binary_test(), cAr(), car(), cDr(), cdr(), copy(), binary_helper< chain< C > >::disassemble(), iterate(), map(), operator*(), range(), reverse(), shift_left(), shift_right(), sort_sub(), unary_hash(), and binary_helper< chain< C > >::write_bis().

{ return c.rep->m; }

syntactic migrate_negate	(	const syntactic &	g,
		nat	maximal
	)

Definition at line 221 of file syntactic.cpp.

References GEN_MINUS, GEN_PLUS, is_func(), migrate_sub(), and signed_decompose().

Referenced by ordered_sum().

                                                 {
  int i= 0, found= -1;
  syntactic h= g;
  while (is_func (h, GEN_PLUS, 2) || is_func (h, GEN_MINUS, 2)) {
    if (is_func (h, GEN_PLUS, 2)) found= i;
    if (maximal == 0) return g;
    h= h[1];
    maximal--;
    i++;
  }
  if (found == -1) return g;
  syntactic abs_h; int sgn_h;
  signed_decompose (h, abs_h, sgn_h);
  if (sgn_h >= 0) return g;
  return migrate_sub (g, found);
}

static syntactic mmx::migrate_sub	(	const syntactic &	g,
		nat	found
	)			[static]

Definition at line 215 of file syntactic.cpp.

References migrate_sub(), and syn().

                                            {
  if (found == 0) return migrate_sub (g[1], g[2]);
  return syn (g[0], migrate_sub (g[1], found-1), g[2]);
}

static syntactic mmx::migrate_sub	(	const syntactic &	g,
		const syntactic &	h
	)			[static]

Definition at line 206 of file syntactic.cpp.

References GEN_MINUS, is_func(), signed_decompose(), and syn().

Referenced by migrate_negate(), and migrate_sub().

                                                     {
  if (is_func (g, GEN_MINUS, 2))
    return syn (GEN_MINUS, migrate_sub (g[1], h), g[2]);
  syntactic abs_g; int sgn_g;
  signed_decompose (g, abs_g, sgn_g);
  return syn (GEN_MINUS, h, abs_g);
}

source_position mmx::min	(	const source_position &	p1,
		const source_position &	p2
	)			[inline]

Definition at line 48 of file source_track.hpp.

References source_position::position.

                                                           {
  return p1.position < p2.position? p1: p2;
};

generic min	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 726 of file generic.cpp.

References current_ev, and GEN_MIN.

                                                   {
  return current_ev->apply (GEN_MIN, x1, x2); }

C mmx::min	(	const C &	x,
		const C &	y
	)			[inline]

Definition at line 477 of file defaults.hpp.

Referenced by add_indentation(), composite_port_rep::can_write(), get_indentation(), GLUE_21(), GLUE_23(), GLUE_31(), GLUE_33(), inf(), min_op::op(), composite_port_rep::read(), string_rep::resize(), vector_rep< observer, V >::resize(), heap_rep< C >::resize(), min_precision_op::set_op(), min_op::set_op(), source_locate(), tokenize(), and composite_port_rep::wait().

{ return x<y? x: y; }

C mmx::minimal_cst

(

const format< C > &

fm

)

[inline]

Definition at line 960 of file type_props.hpp.

References C, promote(), and set_minimal().

                                  {
  C r= promote (0, fm); set_minimal (r); return r; }

C mmx::minimal_cst

(

)

[inline]

Definition at line 918 of file type_props.hpp.

References C, and set_minimal().

{ C r; set_minimal (r); return r; }

bool mkdir

(

const string &

orig_name

)

Definition at line 807 of file system.cpp.

References decode_name(), and var_mkdir().

Referenced by var_mkdir().

                           {
  return var_mkdir (decode_name (name));
}

exception mmc_exception	(	const string &	message,
		const generic &	where
	)			[final]

Definition at line 105 of file mmc_glue.cpp.

                                                            {
  return exception (message, where);
}

void mmc_exit

(

const int &

status

)

Definition at line 41 of file mmc_glue.cpp.

References mmc_terminate().

                             {
  mmc_terminate ();
  exit (status);
}

void mmc_initialize	(	int	argc,
		char **	argv
	)

Definition at line 28 of file mmc_glue.cpp.

References compiler_initialize, and mmc_args.

                                       {
  mmc_args= fill<string> (argc);
  for (int i= 0; i<argc; i++)
    mmc_args[(nat) i]= string (argv[i]);
  if (compiler_initialize != NULL) compiler_initialize ();
}

string mmc_load

(

const string &

name

)

Definition at line 64 of file mmc_glue.cpp.

References ASSERT, load(), and s.

                              {
  string s;
  string file_name= name; //resolve_name ("", name); FIXME ???
  bool e= load (file_name, s);
  ASSERT (!e, "file did not load");
  return s;
}

vector< string > mmc_load_directory

(

const string &

name

)

Definition at line 50 of file mmc_glue.cpp.

References ERROR, load_directory(), and relative_name().

                                                       {
  string dir_name= relative_name ("", name);
  vector<string> dir;
  if (load_directory (dir_name, dir))
    ERROR ("directory " * dir_name * " not found");
  return dir;
}

generic mmc_parse	(	const string &	s,
		const string &	input_name
	)

Definition at line 93 of file mmc_glue.cpp.

References mmx_parse(), and store_file_source().

                                                      {
  store_file_source (input_name, s);
  generic r= mmx_parse (input_name, s);
  if (is<exception> (r)) throw as<exception> (r);
  return r;  
}

generic mmc_parse

(

const string &

file_name

)

Definition at line 81 of file mmc_glue.cpp.

References ERROR, load(), mmx_parse(), s, store_file_source(), and strip_preamble().

                                    {
  string s;
  if (load (file_name, s))
    ERROR ("file " * file_name * " not found");
  s= strip_preamble (s);
  store_file_source (file_name, s);
  generic r= mmx_parse (file_name, s);
  if (is<exception> (r)) throw as<exception> (r);
  return r;
}

void mmc_save	(	const string &	name,
		const string &	s
	)

Definition at line 59 of file mmc_glue.cpp.

References save().

                                               {
  (void) save (name, s);
}

void mmc_terminate

(

)

Definition at line 36 of file mmc_glue.cpp.

References compiler_terminate.

Referenced by mmc_exit().

                 {
  if (compiler_terminate != NULL) compiler_terminate ();
}

generic mmc_unliteral

(

const generic &

x

)

Definition at line 115 of file mmc_glue.cpp.

References as_double(), as_int(), as_string(), ERROR, is_func(), mmerr, and unquote().

                                 {
  if (is_func (x, "literal_integer", 1))
    return as<generic> (as_int (as_string (as<literal> (x[1]))));
  else if (is_func (x, "literal_floating", 1))
    return as<generic> (as_double (as_string (as<literal> (x[1]))));
  else if (is_func (x, "literal_string", 1))
    return as<generic> (unquote (as_string (as<literal> (x[1]))));
  else {
    mmerr << "x= " << x << "\n";
    ERROR ("unknown literal type");
  }
}

void mmx::mmx_classical_delete

(

C *

Ptr

)

[inline]

Definition at line 331 of file fast_new.hpp.

References C, mmx_free(), and n.

                              {
  void* ptr= (void*) (((nat*) ((void*) Ptr)) - 1);
  nat n= *((nat*) ptr);
  C* ctr= Ptr+n-1;
  for (nat i=0; i<n; i++, ctr--) ctr -> ~C();
  mmx_free (ptr, n * sizeof (C) + sizeof (nat));
}

C* mmx::mmx_classical_new

(

nat

n

)

[inline]

Definition at line 320 of file fast_new.hpp.

References C, and mmx_malloc().

                          {
  void* ptr= mmx_malloc (n * sizeof (C) + sizeof (nat));
  *((nat*) ptr)= n;
  ptr= (void*) (((nat*) ptr) + 1);
  C* ctr= (C*) ptr;
  for (nat i=0; i<n; i++, ctr++)
    (void) new ((void*) ctr) C ();
  return (C*) ptr;
}

size_t mmx::mmx_compute_free

(

void *

ptr

)

Definition at line 118 of file fast_new.cpp.

References MMX_IND.

Referenced by mmx_mem_info(), and mmx_used_bytes().

                             {
  nat i= (nat) -1;
  while (ptr!=NULL) {
    i++;
    ptr= MMX_IND (ptr);
  }
  return i;
}

xnat mmx::mmx_cpu_time

(

)

[inline]

Number of cycles of the cpu.

Definition at line 58 of file timer.hpp.

                            {
  return (xnat) clock ();
}

string mmx::mmx_cpu_time_unit

(

)

[inline]

Definition at line 61 of file timer.hpp.

{ return("mus"); };

void mmx::mmx_delete	(	C *	Ptr,
		nat	n
	)			[inline]

Definition at line 285 of file fast_new.hpp.

References C, and mmx_free().

Referenced by vector< observer >::vector().

                           {
#ifdef BASIX_ENABLE_VERIFY
  void* ptr= (void*) Ptr;
  //printf ("{--%p}", ptr); fflush (stdout);
  ptr= (void*) (((char*) ptr) - 16);
  //printf ("{-%p}", ptr); fflush (stdout);
  if (*((nat*) ptr) != n)
    printf ("[%u should be %u]\n", n, *((nat*) ptr));
  assert (*((nat*) ptr) == n);
  C* ctr= Ptr+n-1;
  for (nat i=0; i<n; i++, ctr--) ctr -> ~C();
  mmx_free (ptr, n * sizeof (C) + 16);
#else
  C* ctr= Ptr+n-1;
  for (nat i=0; i<n; i++, ctr--) ctr -> ~C();
  mmx_free ((void*) Ptr, n * sizeof (C));
#endif
}

void mmx::mmx_delete_at

(

T *

pos

)

[inline]

Definition at line 72 of file new_table.hpp.

References T.

Referenced by new_table_rep< C, T, V >::remove(), and new_table_rep< C, T, V >::resize().

                       {
  pos -> ~T ();
}

void mmx::mmx_delete_one

(

C *

ptr

)

[inline]

Definition at line 315 of file fast_new.hpp.

                        {
  mmx_delete<C> (ptr, 1);
}

void mmx::mmx_delete_uninitialized	(	T *	mem,
		nat	i
	)			[inline]

Definition at line 62 of file new_table.hpp.

References T.

                                         {
  mmx_delete<char> ((char*) ((void*) mem), i * sizeof (T));
}

T* mmx::mmx_formatted_new	(	nat	l,
		const format< T > &	fm
	)			[inline]

Definition at line 587 of file type_props.hpp.

                                               {
  typedef typename format<T>::FT FT;
  return formatted_new_helper<FT,T>::op (l, fm);
}

void mmx::mmx_free	(	void *	ptr,
		size_t	old_size
	)			[inline]

Definition at line 208 of file fast_new.hpp.

References mmx_free_thread_safe(), mmx_free_thread_unsafe(), and threads_active.

Referenced by string_rep::extend(), free_charp(), mmx_classical_delete(), mmx_delete(), string_rep::resize(), and string_rep::~string_rep().

                                      {
  threads_active ? mmx_free_thread_safe   (ptr, old_size)
                 : mmx_free_thread_unsafe (ptr, old_size); }

void mmx::mmx_free_thread_safe	(	void *	ptr,
		size_t	old_size
	)			[inline]

Definition at line 193 of file fast_new.hpp.

References lock(), memory_lock, and mmx_free_thread_unsafe().

Referenced by mmx_free().

                                                  {
  mutex_lock lock (memory_lock);
  mmx_free_thread_unsafe (ptr, old_size); }

void mmx_free_thread_unsafe	(	register void *	ptr,
		register size_t	sz
	)

Definition at line 93 of file fast_new.cpp.

References large_uses, MMX_ALLOC_PTR, MMX_IND, MMX_MAX_FAST, MMX_WORD_LENGTH_INC, MMX_WORD_MASK, and safe_free().

Referenced by mmx_free(), mmx_free_thread_safe(), and mmx_realloc_thread_unsafe().

                                                                {
  if (sz == 0) return;
  sz=(sz+MMX_WORD_LENGTH_INC)&MMX_WORD_MASK;
  if (sz<MMX_MAX_FAST) {
    MMX_IND (ptr)     = MMX_ALLOC_PTR (sz);
    MMX_ALLOC_PTR (sz)= ptr;
  }
  else {
    large_uses -= sz;
    safe_free (ptr);
    //printf ("Big free of %d bytes", (int) sz);
    //printf ("Memory used: %d bytes", (int) mmx_used_bytes ());
  }
}

int mmx_lex	(	generic *	lval,
		parse_instance *	obj
	)

Definition at line 79 of file mmx_lexer.cpp.

References ADD_POS, HAS, IN, INC_LINE, INC_POS, is_alpha, keyword(), n, pos, PREFIX, produce, s, SAVE_START, SET_PREV, and test.

                                             {
  if (pos == n) {
    s= NULL;
    *lval= generic ();
    return 0;
  }

  SET_PREV;
  char c= s[pos];
  while ((c<=' ') || (c>'~')) {
    if ((c == '\n') || (c == '\r')) 
      INC_LINE
    else
      INC_POS;
    if (pos == n) {
      s= NULL;
      *lval= generic ();
      return 0;
    }
    c= s[pos];
  }

  SAVE_START;
  INC_POS;
  switch (c) {
  case '!':
    test ('=', NOT_EQUAL);
    if ((pos<n) && (s[pos]=='<')) {
      INC_POS;
      test ('=', NOT_LEQ);
      produce (NOT_LESS);
    }
    if ((pos<n) && (s[pos]=='>')) {
      INC_POS;
      test ('=', NOT_GEQ);
      produce (NOT_GREATER);
    }
    produce (NOT);
  case '\042':
    while (pos<n) {
      if ((s[pos]=='\\') && ((pos+2)<n)) { ADD_POS(2); continue; }
      if (s[pos]=='\n' || (s[pos]=='\r')) { INC_LINE; continue; }
      if (s[pos]=='\042') { INC_POS; break; }
      INC_POS;
    }
    produce (STRING);
  case '#':
    produce (SIZE);
  case '$':
    goto identifier;
  case '%':
    produce (PERCENT);
  case '&':
    produce (AMPERSAND);
  case '\047':
    produce (QUOTE);
  case '(':
  case ')':
    produce (c);
  case '*':
    test ('=', TIMES_ASSIGN);
    produce (TIMES);
  case '+':
    test ('=', PLUS_ASSIGN);
    test ('+', INC);
    produce (PLUS);
  case ',':
    produce (c);
  case '-':
    test ('=', MINUS_ASSIGN);
    test ('-', DEC);
    test ('>', INTO);
    produce (MINUS);
  case '.':
    test ('.', RANGE);
    produce (ACCESS);
  case '/':
    test ('\\', AND);
    if (s[pos]=='/') {
      INC_POS;
      while ((pos<n) && (s[pos]!='\n')) {
        INC_POS;
      }
      if (pos<n) { INC_LINE; }
      return mmx_lex (lval, obj);
    }
    if (s[pos]=='{') {
      nat level= 1;
      INC_POS;
      while ((pos+1<n) && (level>0)) {
        if (s[pos]=='\n' || (s[pos]=='\r')) {
          INC_LINE; continue; }
        if ((s[pos]=='/') && (s[pos+1]=='{')) {
          level++; ADD_POS(2); continue; }
        if ((s[pos]=='}') && (s[pos+1]=='/')) {
          level--; ADD_POS(2); continue; }
        INC_POS;
      }
      if (level>0) pos=n;
      return mmx_lex (lval, obj);
    }
    if (s[pos] == '\"') {
      INC_POS;
      while ((pos+1<n) && ((s[pos]!='\"') || (s[pos+1]!='/'))) {
        if (s[pos]=='\n' || (s[pos]=='\r')) {
          INC_LINE; }
        else {
          INC_POS; }
      }
      if (pos+1 < n) {
        ADD_POS(2);
      }
      produce (STRING);
    }
    test ('=', OVER_ASSIGN);
    produce (OVER);
  case '0':
  case '1':
  case '2':
  case '3':
  case '4':
  case '5':
  case '6':
  case '7':
  case '8':
  case '9':
    goto identifier;
  case ':':
    if ((pos<n) && (s[pos]=='=')) {
      if ((pos+1<n) && (s[pos+1]=='>')) {
        ADD_POS(2); produce (ASSIGN_MACRO); }
      INC_POS; produce (ASSIGN);
    }
    test ('>', TRANSTYPE);
    if ((pos<n) && (s[pos]==':')) {
      if ((pos+1<n) && (s[pos+1]=='>')) {
        ADD_POS(2); produce (VARTRANSTYPE); }
      INC_POS; produce (VARTYPE);
    }
    if ((pos+1<n) && (s[pos]=='-') && (s[pos+1]=='>')) {
      ADD_POS(2); produce (MAPSTO);
    }
    produce (TYPE);
  case ';':
    produce (c);
  case '<':
    if ((pos<n) && (s[pos]=='<')) {
      if ((pos+1<n) && (s[pos+1]=='<')) {
        ADD_POS(2); produce (LEFT_FLUX_BIN); }
      if ((pos+1<n) && (s[pos+1]=='*')) {
        ADD_POS(2); produce (LEFT_FLUX_VAR); }
      if ((pos+1<n) && (s[pos+1]=='%')) {
        ADD_POS(2); produce (LEFT_FLUX_STR); }
      if ((pos+1<n) && (s[pos+1]=='=')) {
        ADD_POS(2); produce (LL_ASSIGN); }
      INC_POS; produce (LEFT_FLUX);
    }
    if ((pos+1<n) && (s[pos]=='=') && (s[pos+1]=='>')) {
      ADD_POS(2); produce (EQUIVALENT);
    }
    test ('=', LEQ);
    produce (LESS);
  case '=':
    if ((pos<n) && (s[pos]=='=')) {
      if ((pos+1<n) && (s[pos+1]=='>')) {
        ADD_POS(2); produce (DEFINE_MACRO); }
      INC_POS; produce (DEFINE);
    }
    test ('>', IMPLIES);
    produce (EQUAL);
  case '>':
    test ('<', APPEND);
    if ((pos<n) && (s[pos]=='>')) {
      if ((pos+1<n) && (s[pos+1]=='>')) {
        ADD_POS(2); produce (RIGHT_FLUX_BIN); }
      if ((pos+1<n) && (s[pos+1]=='=')) {
        ADD_POS(2); produce (GG_ASSIGN); }
      INC_POS; produce (RIGHT_FLUX);
    }
    test ('=', GEQ);
    produce (GREATER);
  case '?':
    goto identifier;
  case '@':
    test ('+', OPLUS);
    test ('-', OMINUS);
    test ('*', OTIMES);
    test ('/', OOVER);
    produce (COMPOSE);
  case 'A':
  case 'B':
  case 'C':
  case 'D':
  case 'E':
  case 'F':
  case 'G':
  case 'H':
  case 'I':
  case 'J':
  case 'K':
  case 'L':
  case 'M':
  case 'N':
  case 'O':
  case 'P':
  case 'Q':
  case 'R':
  case 'S':
  case 'T':
  case 'U':
  case 'V':
  case 'W':
  case 'X':
  case 'Y':
  case 'Z':
    goto identifier;
  case '[':
    produce (c);
  case '\\':
    test ('/', OR);
    produce (c);
  case ']':
    produce (c);
  case '^':
    test ('^', FILL);
    produce (POWER);
  case '_':
    goto identifier;
  case '`':
    produce (BACKQUOTE);
  case 'a':
    if (pos<n) {
      keyword ('b', "abstract", ABSTRACT);
      keyword ('n', "and", SEQAND);
      keyword ('s', "assume", ASSUME);
      keyword ('u', "autofold", AUTOFOLD);
    }
    goto identifier;
  case 'b':
    if (pos<n) keyword ('r', "break", BREAK);
    goto identifier;
  case 'c':
    if ((pos+3)<n) {
      if (s[pos]=='a') {
        INC_POS;
        keyword ('s', "case", CASE);
        if (s[pos] == 't') {
          INC_POS;
          keyword ('c', "catch", CATCH);
          keyword ('e', "category", CATEGORY);
        }
        goto identifier;
      }
      keyword ('l', "class", CLASS);
      if ((s[pos]=='o') && (s[pos+1]=='n')) {
        ADD_POS(2);
        keyword ('c', "concrete", CONCRETE);
        if (((pos+1)<n) && s[pos]=='s' && s[pos+1]=='t') {
          ADD_POS(2);
          keyword ('a', "constant", CONSTANT);
          keyword ('r', "constructor", CONSTRUCTOR);
          goto identifier;
        }
        keyword ('t', "continue", CONTINUE);
      }
    }
    goto identifier;
  case 'd':
    if (pos<n) {
      keyword ('e', "destructor", DESTRUCTOR);
      if (s[pos]=='i') {
        INC_POS;
        keyword ('r', "direct", DIRECT);
        if (((pos+1)<n) && s[pos]=='s') {
          INC_POS;
          keyword ('j', "disjunction", DISJUNCTION);
          keyword ('p', "dispatch", DISPATCH);
          goto identifier;
        }
        keyword ('v', "div", DIV);
        goto identifier;
      }
      if (s[pos]=='o') {
        INC_POS;
        if ((pos >= n) || (!is_alpha (s[pos]))) produce (DO);
        keyword ('w', "downto", DOWNTO);
      }
    }
    goto identifier;
  case 'e':
    if ((pos+1)<n) {
      keyword ('l', "else", ELSE);
      keyword ('v', "evolutive", EVOLUTIVE);
      if (s[pos]=='x') {
        INC_POS;
        keyword ('i', "exists", EXISTS);
        if (s[pos]=='p' && pos+1<n) {
          INC_POS;
          keyword ('l', "explicit", EXPLICIT);
          keyword ('o', "export", EXPORT);
        }
        else if (((pos+2)<n) && (s[pos]=='t') && (s[pos+1]=='e')) {
          ADD_POS(2);
          keyword ('n', "extend", EXTEND);
          keyword ('r', "extern", EXTERN);
        }
      }
    }
    goto identifier;
  case 'f':
    if (pos<n) {
      if ((pos+1<n) && (s[pos]=='o') && (s[pos+1]=='r')) {
        if ((pos+2<n) && (s[pos+2]=='a')) {
          keyword ('o', "forall", FORALL); }
        else if ((pos+2<n) && (s[pos+2]=='e')) {
          keyword ('o', "foreign", FOREIGN); }
        else {
          keyword ('o', "for", FOR); }
      }
      keyword ('r', "from", FROM);
    }
    goto identifier;
  case 'g':
    if (pos<n) keyword ('e', "generate", GENERATE);
    goto identifier;
  case 'h':
    if (pos<n) {
      keyword ('a', "has", HAS);
      keyword ('i', "hidden", HIDDEN);
      keyword ('o', "holds", HOLDS);
    }
    goto identifier;
  case 'i':
    if (pos<n) {
      keyword ('f', "if", IF);
      if (s[pos]=='m' && pos+2<n && s[pos+1]=='p') {
        ADD_POS(2);
        keyword ('o', "import", IMPORT);
        keyword ('l', "implicit", IMPLICIT);
      }
      else if (s[pos]=='n') {
        INC_POS;
        if ((pos >= n) || (!is_alpha (s[pos]))) produce (IN);
        keyword ('d', "indirect", INDIRECT);
        keyword ('f', "infix", INFIX);
        keyword ('h', "inherit", INHERIT);
        keyword ('l', "inline", INLINE);
        keyword ('p', "inplace", INPLACE);
        if ((pos+3<n) && (s[pos]=='t') && (s[pos+1]=='e') && (s[pos+2]=='r')) {
          ADD_POS(3);
          keyword ('a', "interactive", INTERACTIVE);
          keyword ('n', "intern", INTERN);
        }
      }
    }
    goto identifier;
  case 'j':
    if (pos<n) keyword ('o', "join", JOIN);
    goto identifier;
  case 'k':
    if (pos<n) keyword ('e', "keyword", KEYWORD);
    goto identifier;
  case 'l':
    if (pos<n) {
      keyword ('a', "lambda", LAMBDA);
      keyword ('i', "literal", LITERAL);
      if (((pos+1)<n) && (s[pos]=='o')) {
        INC_POS;
        keyword ('c', "locked", LOCKED);
        keyword ('o', "loop", LOOP);
      }
    }
    goto identifier;
  case 'm':
    if (pos<n) {
      if (((pos+1)<n) && (s[pos]=='a')) {
        INC_POS;
        keyword ('c', "macro", MACRO);
        keyword ('t', "match", MATCH);
        goto identifier;
      }
      keyword ('e', "method", METHOD);
      if (((pos+1)<n) && (s[pos]=='o') && (s[pos+1]=='d')) {
        if ((pos+2<n) && (s[pos+2]=='u')) {
          keyword ('o', "module", MODULE); }
        else {
          keyword ('o', "mod", MOD); }
      }
      keyword ('u', "mutable", MUTABLE);
    }
    goto identifier;
  case 'n':
    goto identifier;
  case 'o':
    if (pos<n) {
      keyword ('p', "operator", OPERATOR);
      keyword ('r', "or", SEQOR);
      keyword ('u', "outline", OUTLINE);
    }
    goto identifier;
  case 'p':
    if ((pos+1)<n) {
      if (s[pos]=='a') {
        INC_POS;
        keyword ('c', "packed", PACKED);
        keyword ('t', "pattern", PATTERN);
        goto identifier;
      }
      keyword ('e', "penalty", PENALTY);
      keyword ('o', "postfix", POSTFIX);
      if (s[pos]=='r') {
        INC_POS;
        if ((pos+3<n) && s[pos] == 'e' && s[pos+1] == 'f') {
          ADD_POS(2);
          keyword ('e', "prefer", PREFER);
          keyword ('i', "prefix", PREFIX);
          goto identifier;
        }
        keyword ('i', "private", PRIVATE);
        keyword ('o', "protected", PROTECTED);
        goto identifier;
      }
      keyword ('u', "public", PUBLIC);
    }
    goto identifier;
  case 'q':
    if (pos<n) keyword ('u', "quo", QUO);
    goto identifier;
  case 'r':
    if ((pos+1)<n) {
      keyword ('a', "raise", RAISE);
      if (s[pos]=='e') {
        INC_POS;
        keyword ('m', "rem", REM);
        keyword ('t', "return", RETURN);
      }
    }
    goto identifier;
  case 's':
    if (pos<n) {
      keyword ('e', "sequel", SEQUEL);
      keyword ('p', "split", SPLIT);
      if ((pos+1<n) && (s[pos]=='t')) {
        INC_POS;
        keyword ('e', "step", STEP);
        keyword ('r', "structure", STRUCTURE);
        goto identifier;
      }
    }
    goto identifier;
  case 't':
    if ((pos+1)<n) {
      if (s[pos]=='h') {
        INC_POS;
        keyword ('e', "then", THEN);
        keyword ('i', "this", THIS);
        goto identifier;
      }
      keyword ('r', "try", TRY);
      keyword ('o', "to", TO);
    }
    goto identifier;
  case 'u':
    if (((pos+1)<n) && (s[pos]=='n')) {
      INC_POS;
      keyword ('p', "unpacked", UNPACKED);
      keyword ('t', "until", UNTIL);
    }
    goto identifier;
  case 'v':
    if (pos<n) {
      keyword ('a', "value", VALUE);
      keyword ('i', "virtual", VIRTUAL);
    }
    goto identifier;
  case 'w':
    if (pos<n) {
      keyword ('h', "while", WHILE);
      keyword ('i', "with", WITH);
    }
    goto identifier;
  case 'x':
    if (pos<n) keyword ('o', "xor", XOR);
    goto identifier;
  case 'y':
    if (pos<n) keyword ('i', "yield", YIELD);
    goto identifier;
  case 'z':
    goto identifier;
  case '{':
    produce (c);
  case '|':
    test ('|', VWHERE);
    produce (WHERE);
  case '}':
    produce (c);
  case '~':
    test ('>', CONVERTS);
    produce (TILDA);
  default:
    return mmx_lex (lval, obj);

  identifier:
    while ((pos<n) &&
           (is_alpha (s[pos]) ||
            (s[pos] == '.' && pos>0 && (pos+1)<n &&
             s[pos-1] >= '0' && s[pos-1] <= '9' &&
             s[pos+1] >= '0' && s[pos+1] <= '9')))
      INC_POS;
    produce (IDENTIFIER);
  }
}

void* mmx::mmx_malloc

(

size_t

sz

)

[inline]

Definition at line 198 of file fast_new.hpp.

References mmx_malloc_thread_safe(), mmx_malloc_thread_unsafe(), and threads_active.

Referenced by as_charp(), string_rep::extend(), mmx_classical_new(), mmx_new(), and string_rep::resize().

                       {
  return threads_active ? mmx_malloc_thread_safe   (sz)
                        : mmx_malloc_thread_unsafe (sz); }

void* mmx::mmx_malloc_thread_safe

(

size_t

new_size

)

[inline]

Definition at line 183 of file fast_new.hpp.

References lock(), memory_lock, and mmx_malloc_thread_unsafe().

Referenced by mmx_malloc().

                                         {
  mutex_lock lock (memory_lock);
  return mmx_malloc_thread_unsafe (new_size); }

void * mmx_malloc_thread_unsafe

(

register size_t

sz

)

Definition at line 73 of file fast_new.cpp.

References enlarge_malloc(), large_uses, MMX_ALLOC_PTR, MMX_IND, MMX_MAX_FAST, MMX_WORD_LENGTH_INC, MMX_WORD_MASK, and safe_malloc().

Referenced by mmx_malloc(), mmx_malloc_thread_safe(), and mmx_realloc_thread_unsafe().

                                              {
  if (sz == 0) return NULL;
  sz= (sz+MMX_WORD_LENGTH_INC)&MMX_WORD_MASK;
  if (sz<MMX_MAX_FAST) {
    register void *ptr= MMX_ALLOC_PTR (sz);
    if (ptr==NULL) return enlarge_malloc (sz);
    //assert (((nat) ptr) != 2);
    //assert (((nat) (MMX_IND (ptr))) != 2);
    MMX_ALLOC_PTR (sz)= MMX_IND (ptr);
    return ptr;
  }
  else {
    //printf ("Big alloc of %d bytes", (int) sz);
    //printf ("Memory used: %d bytes", (int) mmx_used_bytes ());
    large_uses += sz;
    return safe_malloc (sz);
  }
}

void mmx::mmx_mem_info

(

)

Definition at line 138 of file fast_new.cpp.

References alloc_remains, alloc_table, fast_chunks, large_uses, mmout, MMX_BLOCK_SIZE, mmx_compute_free(), MMX_MAX_FAST, and MMX_WORD_LENGTH.

                {
  mmout << "\n---------------- memory statistics ----------------\n";
  size_t free_bytes= alloc_remains;
  size_t chunks_use= MMX_BLOCK_SIZE*fast_chunks;
  for (nat i=MMX_WORD_LENGTH; i<MMX_MAX_FAST; i+=MMX_WORD_LENGTH)
    free_bytes += i*mmx_compute_free (alloc_table+i);
  size_t small_uses= chunks_use- free_bytes;
  size_t total_uses= small_uses+ large_uses;
  // mmout << "Fast chunks   : " << chunks_use << " bytes\n";
  // mmout << "Free on chunks: " << alloc_remains << " bytes\n";
  mmout << "User          : " << total_uses << " bytes\n";
  mmout << "Allocator     : " << chunks_use+ large_uses << " bytes\n";
  mmout << "Small mallocs : "
        << ((100*((float) small_uses))/((float) total_uses)) << "%\n";
}

C* mmx::mmx_new	(	nat	n,
		const T1 &	a1,
		const T2 &	a2
	)			[inline]

Definition at line 268 of file fast_new.hpp.

References C, and mmx_malloc().

                                            {
#ifdef BASIX_ENABLE_VERIFY
  void* ptr= mmx_malloc (n * sizeof (C) + 16);
  *((nat*) ptr)= n;
  //printf ("{..+%p}", ptr); fflush (stdout);
  ptr= (void*) (((char*) ptr) + 16);
  //printf ("{..++%p}", ptr); fflush (stdout);
#else
  void* ptr= mmx_malloc (n * sizeof (C));
#endif
  C* ctr= (C*) ptr;
  for (nat i=0; i<n; i++, ctr++)
    (void) new ((void*) ctr) C (a1, a2);
  return (C*) ptr;
}

C* mmx::mmx_new	(	nat	n,
		const T1 &	a1
	)			[inline]

Definition at line 251 of file fast_new.hpp.

References C, and mmx_malloc().

                              {
#ifdef BASIX_ENABLE_VERIFY
  void* ptr= mmx_malloc (n * sizeof (C) + 16);
  *((nat*) ptr)= n;
  //printf ("{.+%p}", ptr); fflush (stdout);
  ptr= (void*) (((char*) ptr) + 16);
  //printf ("{.++%p}", ptr); fflush (stdout);
#else
  void* ptr= mmx_malloc (n * sizeof (C));
#endif
  C* ctr= (C*) ptr;
  for (nat i=0; i<n; i++, ctr++)
    (void) new ((void*) ctr) C (a1);
  return (C*) ptr;
}

C* mmx::mmx_new

(

nat

n

)

[inline]

Definition at line 234 of file fast_new.hpp.

References C, and mmx_malloc().

                {
#ifdef BASIX_ENABLE_VERIFY
  void* ptr= mmx_malloc (n * sizeof (C) + 16);
  *((nat*) ptr)= n;
  //printf ("{+%p}", ptr); fflush (stdout);
  ptr= (void*) (((char*) ptr) + 16);
  //printf ("{++%p}", ptr); fflush (stdout);
#else
  void* ptr= mmx_malloc (n * sizeof (C));
#endif
  C* ctr= (C*) ptr;
  for (nat i=0; i<n; i++, ctr++)
    (void) new ((void*) ctr) C ();
  return (C*) ptr;
}

T* mmx::mmx_new_at

(

T *

pos

)

[inline]

Definition at line 67 of file new_table.hpp.

References T.

Referenced by new_table_rep< C, T, V >::set().

                    {
  return new ((void*) pos) T;
}

C* mmx::mmx_new_one

(

const T1 &

a1

)

[inline]

Definition at line 310 of file fast_new.hpp.

                           {
  return mmx_new<C> (1, a1);
}

C* mmx::mmx_new_one

(

)

[inline]

Definition at line 305 of file fast_new.hpp.

               {
  return mmx_new<C> (1);
}

T* mmx::mmx_new_uninitialized

(

nat

i

)

[inline]

Definition at line 57 of file new_table.hpp.

References T.

                              {
  return (T*) ((void*) mmx_new<char> (i * sizeof (T)));
}

generic mmx::mmx_parse	(	const string &	file_name,
		const string &	s
	)

generic mmx::mmx_parse	(	const string &	file_name,
		nat	input_number,
		const string &	s,
		list< generic > &	errors
	)

Referenced by mmc_parse().

void* mmx::mmx_realloc	(	void *	ptr,
		size_t	old_size,
		size_t	new_size
	)			[inline]

Definition at line 203 of file fast_new.hpp.

References mmx_realloc_thread_safe(), mmx_realloc_thread_unsafe(), and threads_active.

                                                          {
  return threads_active ? mmx_realloc_thread_safe   (ptr, old_size, new_size)
                        : mmx_realloc_thread_unsafe (ptr, old_size, new_size);}

void* mmx::mmx_realloc_thread_safe	(	void *	ptr,
		size_t	old_size,
		size_t	new_size
	)			[inline]

Definition at line 188 of file fast_new.hpp.

References lock(), memory_lock, and mmx_realloc_thread_unsafe().

Referenced by mmx_realloc().

                                                                      {
  mutex_lock lock (memory_lock);
  return mmx_realloc_thread_unsafe (ptr, old_size, new_size); }

void * mmx_realloc_thread_unsafe	(	register void *	old_ptr,
		register size_t	old_sz,
		register size_t	new_sz
	)

Definition at line 109 of file fast_new.cpp.

References mmx_free_thread_unsafe(), and mmx_malloc_thread_unsafe().

Referenced by mmx_realloc(), and mmx_realloc_thread_safe().

                                                   {
  void* new_ptr= mmx_malloc_thread_unsafe (new_sz);
  memcpy (new_ptr, old_ptr, new_sz < old_sz ? new_sz: old_sz);
  mmx_free_thread_unsafe (old_ptr, old_sz);
  return new_ptr;
}

static table<generic,generic> mmx::mmx_symbol_table

(

)

[static]

Definition at line 158 of file mmx_printer.cpp.

References init().

Referenced by serialize().

                    {
  table<generic,generic> t;
  init (t, "mathcatalan", "K");
  init (t, "partial", "d");
  init (t, "derivative", "D");
  init (t, "matheuler", "gamma");
  init (t, "mathd", "d");
  init (t, "mathe", "e");
  init (t, "mathi", "i");
  init (t, "mathpi", "pi");
  return t;
}

nat mmx_time

(

)

Relative time of day.

Definition at line 27 of file timer.cpp.

            {
#ifdef BASIX_HAVE_GETTIMEOFDAY
  struct timeval tp;
  gettimeofday (&tp, NULL);
  return (nat) ((time_t) ((tp.tv_sec * 1000) + (tp.tv_usec / 1000)));
#else
  timeb tb;
  ftime (&tb);
  return (nat) ((time_t) ((tb.time * 1000) + tb.millitm));
#endif
}

string mmx::mmx_time_unit

(

)

[inline]

Definition at line 34 of file timer.hpp.

{ return("ms"); };

size_t mmx_used_bytes

(

)

Definition at line 128 of file fast_new.cpp.

References alloc_remains, alloc_table, fast_chunks, large_uses, MMX_BLOCK_SIZE, mmx_compute_free(), MMX_MAX_FAST, and MMX_WORD_LENGTH.

                  {
  size_t free_bytes= alloc_remains;
  size_t chunks_use= MMX_BLOCK_SIZE*fast_chunks;
  for (nat i=MMX_WORD_LENGTH; i<MMX_MAX_FAST; i+=MMX_WORD_LENGTH)
    free_bytes += i*mmx_compute_free (alloc_table+i);
  size_t small_uses= chunks_use- free_bytes;
  return small_uses+ large_uses;
}

nat mmx_user_time

(

)

User time of the current process and its terminated children.

Definition at line 53 of file timer.cpp.

                 {
#if defined(__MINGW__) || defined(__MINGW32__)
  return 0;
#else
  struct rusage used;
  nat t;
  getrusage(RUSAGE_SELF, &used);
  t = (nat) ((time_t) ((used.ru_utime.tv_sec * 1000)
                     + (used.ru_utime.tv_usec / 1000)));
  getrusage(RUSAGE_CHILDREN, &used);
  return t +  (nat) ((time_t) ((used.ru_utime.tv_sec * 1000)
                             + (used.ru_utime.tv_usec / 1000)));
#endif
}

string mmx::mmx_user_time_unit

(

)

[inline]

Definition at line 38 of file timer.hpp.

{ return("ms"); };

double mmx_var_time

(

)

Definition at line 40 of file timer.cpp.

                {
#ifdef BASIX_HAVE_GETTIMEOFDAY
  struct timeval tp;
  gettimeofday (&tp, NULL);
  return (((double) tp.tv_sec) * 1000) + ((double) (tp.tv_usec / 1000));
#else
  timeb tb;
  ftime (&tb);
  return (((double) tb.time) * 1000) + ((double) tb.millitm);
#endif
}

void mmx::mul	(	R &	x,
		const C1 &	y1,
		const C2 &	y2
	)			[inline]

Definition at line 58 of file operators.hpp.

Referenced by lmul_op::set_op(), rmul_op::set_op(), and mul_op::set_op().

{ x= y1 * y2; }

void mmx::mul_add	(	R &	x,
		const C1 &	y1,
		const C2 &	y2
	)			[inline]

Definition at line 62 of file operators.hpp.

Referenced by lmul_add_op::set_op(), rmul_add_op::set_op(), and mul_add_op::set_op().

{ x += y1 * y2; }

T mmx::mul_operator	(	const T &	x,
		const T &	y
	)			[inline]

Definition at line 33 of file operators.hpp.

{ return x*y; }

void mmx::mul_sub	(	R &	x,
		const C1 &	y1,
		const C2 &	y2
	)			[inline]

Definition at line 64 of file operators.hpp.

Referenced by mul_sub_op::set_op().

{ x -= y1 * y2; }

unary_return_type_helper<abs_op, C >::RET mmx::multiplicative_error

(

const C &

x

)

[inline]

Definition at line 1073 of file type_props.hpp.

References rounding_error().

                                                                          {
  return rounding_error (x); }

generic multiplicative_error

(

const generic &

x

)

Definition at line 776 of file generic.cpp.

References current_ev, and GEN_MULTIPLICATIVE_ERROR.

Referenced by multiplicative_error_op::Abs_type(), GLUE_53(), and multiplicative_error_op::set_op().

                                                {
  return current_ev->apply (GEN_MULTIPLICATIVE_ERROR, x); }

nat mmx::N

(

const vector< C, vector_fixed< V, S > > &

v

)

[inline]

Definition at line 368 of file vector.hpp.

{ return S::val; }

nat N

(

const vector< C, V > &

v

)

[inline]

Definition at line 210 of file vector.hpp.

{ return v->n; }

nat N

(

const table< C, T, V > &

t

)

[inline]

Definition at line 227 of file table.hpp.

                   {
  return t->size;
}

nat N

(

const sparse_vector< C, T, V > &

v

)

[inline]

Definition at line 98 of file sparse_vector.hpp.

{ return v.rep->n; }

nat mmx::N

(

const row_tuple< C > &

t

)

[inline]

Definition at line 43 of file row_tuple.hpp.

References N().

{ return N(*t)-1; }

nat N

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 244 of file new_table.hpp.

                   {
  return t->size;
}

nat mmx::N

(

const list< C > &

l

)

[inline]

Return the number of elements in l.

Definition at line 155 of file list.hpp.

References cdr(), is_nil(), and N().

{ return is_nil (l)? 0: N (cdr (l)) + 1; }

nat N

(

const heap< C > &

h

)

[inline]

Definition at line 193 of file heap.hpp.

                                  {
  return l.rep->n; }

nat mmx::N

(

const generic &

g

)

[inline]

Definition at line 156 of file generic.hpp.

                                {
  return g->get_length (); }

nat N

(

const chain< C > &

c

)

[inline]

Definition at line 135 of file chain.hpp.

{ return (c.rep == NULL? 0: c.rep->size); }

nat mmx::N

(

const cache< C, T > &

c

)

[inline]

Definition at line 61 of file cache.hpp.

Referenced by _mul_add(), inspector< compound >::access(), add_indentation(), add_modes(), append(), composed_routine_rep::apply(), identity_routine_rep::apply(), apply(), quintary_routine_rep< void, S1, S2, S3, S4, S5 >::apply(), quintary_routine_rep< D, S1, S2, S3, S4, S5 >::apply(), quaternary_routine_rep< void, S1, S2, S3, S4 >::apply(), quaternary_routine_rep< D, S1, S2, S3, S4 >::apply(), ternary_routine_rep< void, S1, S2, S3 >::apply(), ternary_routine_rep< D, S1, S2, S3 >::apply(), binary_routine_rep< void, S1, S2 >::apply(), binary_routine_rep< D, S1, S2 >::apply(), unary_routine_rep< void, S1 >::apply(), unary_routine_rep< D, S1 >::apply(), nullary_routine_rep< void >::apply(), as_charp(), as_cpp(), as_documents(), as_double(), as_generics(), as_int(), as_lisp(), as_math(), as_texmacs(), as_vector(), binary_helper< table< C, T, V > >::assemble(), binary_helper< sparse_vector< C, T, V > >::assemble(), binary_helper< new_table< C, T, V > >::assemble(), binary_helper< list< C > >::assemble(), binary_helper< heap< C > >::assemble(), binary_helper< chain< C > >::assemble(), assign(), balance_left(), balance_right(), big(), big_dicho(), binary_map(), binary_map_optimized(), binary_map_scalar(), binary_test(), binary_test_scalar(), bool(), input_string_port_rep::busy(), composite_port_rep::busy(), posix_port_rep::busy(), input_output_string_port_rep::can_read(), input_string_port_rep::can_read(), composite_port_rep::can_read(), posix_port_rep::can_read(), composite_port_rep::can_write(), canonical_name(), cAr(), cDr(), cdr(), collect(), compare_numeric(), compare_sub(), complete(), composite_port_rep::component(), components(), compose(), composed_routine_rep::composed_routine_rep(), composite_port(), concat_append(), cons(), contains(), copy(), cpp_identifier(), as_helper< vector< T, TV >, vector< F, FV > >::cv(), fast_helper< vector< C, V > >::dd(), decode_name(), destroy(), detach(), solve_vector_lde_op::diff_op(), binary_helper< chain< C > >::disassemble(), documentify(), dot(), dynamic::dynamic(), ends(), composite_port_rep::error_flag(), composite_port_rep::error_message(), escape(), eval_system(), exact_eq(), exec(), input_output_string_port_rep::expression(), input_string_port_rep::expression(), composite_port_rep::expression(), extend(), extract(), extract_mod(), socket_port_rep::feed(), file_test(), find(), flatten(), composite_port_rep::flush(), foreach(), formatting_port_rep::format(), generic_size(), get_directory(), get_extension(), get_file_source(), get_indentation(), get_interactive_number(), get_interactive_source(), GLUE_2(), GLUE_4(), GLUE_5(), GLUE_6(), GLUE_8(), handle_completion_request(), hash(), identity_routine(), insert(), inside_append(), is_absolute_name(), is_applicable(), is_atom(), vector_iterator_rep< C, V >::is_busy(), heap_iterator_rep< C >::is_busy(), is_C0(), is_evaluable(), is_floating_string(), is_func(), composite_port_rep::is_input_port(), is_integer_string(), is_nil(), is_numeric(), composite_port_rep::is_output_port(), is_quoted(), is_reconstructible(), inspector< compound >::length(), list< cleaner >::list(), list_append_several(), list_apply(), list_map(), list_map_n(), locase(), locase_first(), make_document(), map(), message(), N(), nullary_set(), symbol_rep< vector< generic >, exact_eq_table >::number_entries(), operator*(), operator<(), operator<<(), vector< C, V >::operator<<(), operator<=(), operator==(), operator>(), operator>=(), vector< observer >::operator[](), ordered_product(), ordered_sum(), output_completion(), parse_blanks(), parse_char(), parse_identifier(), parse_lisp(), parse_nat(), parse_string(), path_name(), range(), input_output_string_port_rep::read(), input_string_port_rep::read(), composite_port_rep::read(), posix_port_rep::read(), reads(), recompose(), recursive_search_name(), relative_name(), remove(), replace(), replace_lf(), resolve_name(), reverse(), scheme_to_tm(), search_backwards(), search_forwards(), semi_recursive_search_name(), serialize(), project_helper< vector< C, V > >::set_op(), lift_helper< vector< C, V > >::set_op(), shell_load_session(), shell_terminal_input(), shell_texmacs_input(), signed_decompose(), size(), binary_helper< vector< C, V > >::size(), binary_helper< sparse_vector< C, T, V > >::size(), binary_helper< heap< C > >::size(), sort(), sort_leq(), source_exception(), source_locate(), starts(), store_interactive_number(), string_as_charcode(), string_to_floating(), string_to_numeric(), strip_directory(), strip_extension(), strip_preamble(), table_size(), texmacs_expand(), texmacs_to_scheme(), tokenize(), type_name(), un_try_catch(), unary_hash(), unary_map(), unary_set(), unary_set_scalar(), underlined(), unescape(), unquote(), upcase(), upcase_first(), updater_rep::update(), fast_helper< vector< C, V > >::uu(), var_load(), vector< observer >::vector(), vector_append_several(), vector_contains(), vector_find(), vector_is_atom(), vector_is_nil(), vector_length(), vector_map(), vector_map_1(), vector_map_2(), vector_map_n(), vector_reverse(), vector_size(), composite_port_rep::wait(), WRAP_BINARY_IMPL_1(), WRAP_INDIRECT_IMPL(), composite_port_rep::write(), binary_helper< vector< C, V > >::write(), binary_helper< table< C, T, V > >::write(), binary_helper< sparse_vector< C, T, V > >::write(), binary_helper< string >::write(), write(), binary_helper< new_table< C, T, V > >::write(), binary_helper< heap< C > >::write(), binary_helper< chain< C > >::write(), xgen_sub(), and dynamic_rep::~dynamic_rep().

                                   {
  return N (*c); }

C mmx::nan_cst

(

const format< C > &

fm

)

[inline]

Definition at line 939 of file type_props.hpp.

References C, promote(), and set_nan().

                              {
  C r= promote (0, fm); set_nan (r); return r; }

C mmx::nan_cst

(

)

[inline]

Definition at line 904 of file type_props.hpp.

References C, and set_nan().

{ C r; set_nan (r); return r; }

iterator<S> mmx::natural_range	(	const S &	start,
		const T &	end
	)			[inline]

Definition at line 365 of file iterator.hpp.

References range_iterator().

                                             {
  return range_iterator (start, outplace_set_as<S> (end),
                         outplace_set_as<S> (1), false);
}

void mmx::neg	(	R &	x,
		const C1 &	y1
	)			[inline]

Definition at line 52 of file operators.hpp.

{ x= -y1; }

void mmx::neg

(

R &

x

)

[inline]

Definition at line 50 of file operators.hpp.

Referenced by neg_op::set_op().

{ x= -x; }

T mmx::neg_operator

(

const T &

x

)

[inline]

Definition at line 30 of file operators.hpp.

{ return -x; }

alias<C> mmx::new_alias

(

const C &

c

)

[inline]

Definition at line 55 of file alias.hpp.

{ return alias<C> (c); }

nat mmx::new_alias_type_id

(

nat

id

)

[inline]

Definition at line 203 of file alias.hpp.

References alias_type_info().

Referenced by define_user_type().

                           {
  int mode= 2;
  alias_type_info (id, mode);
  return id;
}

generic_alias<C> mmx::new_genalias

(

const alias< generic > &

a

)

[inline]

Definition at line 130 of file alias.hpp.

                                                                    {
  return generic_alias<C> (a); }

nat mmx::new_generic_alias_type_id

(

nat

id

)

[inline]

Definition at line 210 of file alias.hpp.

References alias_type_info().

                                   {
  int mode= 3;
  alias_type_info (id, mode);
  return id;
}

nat new_tuple_type_id

(

nat

id

)

[inline]

Definition at line 114 of file tuple.hpp.

References tuple_type_info().

Referenced by define_user_type().

                           {
  bool mode= true;
  tuple_type_info (id, mode);
  return id;
}

nat new_type_id

(

const char *

s

)

Definition at line 38 of file generic.cpp.

References contains(), inside_set(), and new_type_id().

                            {
  static table<nat, string> t;
  if (!contains (t, s)) {
    nat id= new_type_id ();
    inside_set (t, s, id);
    return id;
  }
  return t[s];
}

nat new_type_id

(

)

Definition at line 31 of file generic.cpp.

References ASSERT.

Referenced by alias_type_info(), define_user_type(), global_type_id(), new_type_id(), and tuple_type_info().

               {
  static nat counter= 2;
  ASSERT (counter < 65000, "too many types");
  return counter++;
}

generic next_above

(

const generic &

x

)

Definition at line 768 of file generic.cpp.

References current_ev, and GEN_NEXT_ABOVE.

                                      {
  return current_ev->apply (GEN_NEXT_ABOVE, x); }

double next_above

(

const double &

x

)

[inline]

Referenced by GLUE_45(), and set_smallest().

generic next_below

(

const generic &

x

)

Definition at line 770 of file generic.cpp.

References current_ev, and GEN_NEXT_BELOW.

                                      {
  return current_ev->apply (GEN_NEXT_BELOW, x); }

double mmx::next_below

(

const double &

x

)

[inline]

Definition at line 87 of file double.hpp.

Referenced by GLUE_46(), and set_largest().

{ return nextafter (x, -HUGE_VAL); }

nat mmx::next_power_of_three

(

nat

p

)

[inline]

Definition at line 106 of file int.hpp.

References n.

                            {
  // return 0 in case of overflow
  nat n= 1;
  while (n < p)
    n *= 3;
  return (n<p) ? 0 : n;
}

nat mmx::next_power_of_two

(

nat

p

)

[inline]

Definition at line 80 of file int.hpp.

References n.

                          {
  // return 0 in case of overflow
  nat n= 1;
  while (n < p && n != 0)
    n = n << 1;
  return n;
}

void noop

(

)

[inline]

Definition at line 24 of file basix.cpp.

Referenced by loop_task_rep::execute().

{}

routine mmx::nullary_routine	(	const generic &	name,
		D(*)()	fun
	)			[inline]

Definition at line 172 of file routine.hpp.

Referenced by define().

                                                   {
  return new nullary_routine_rep<D> (name, fun);
}

vector<C,V>& mmx::nullary_set

(

vector< C, V > &

v

)

[inline]

Definition at line 812 of file vector.hpp.

References N(), n, and seg().

                             {
  typedef implementation<vector_linear,V> Vec;
  nat n= N(v);
  Vec::template vec_nullary<Op> (seg (v), n);
  return v;
}

nat mmx::number_entries

(

)

[inline]

Definition at line 135 of file symbol.hpp.

References symbol_rep< C, V >::number_entries().

                                           {
  return symbol_rep<C>::number_entries (); }

syntactic numerator

(

const syntactic &

x

)

Definition at line 462 of file syntactic.cpp.

References GEN_NUMERATOR, and syn().

                                          {
  return syn (GEN_NUMERATOR, g1); }

generic numerator

(

const generic &

x

)

Definition at line 713 of file generic.cpp.

References current_ev, and GEN_NUMERATOR.

Referenced by numerator_op::Numerator_type(), numerator_op::op(), and numerator_op::set_op().

                                     {
  return current_ev->apply (GEN_NUMERATOR, x); }

string mmx::numeric_as_string

(

const C &

x

)

[inline]

Definition at line 207 of file string.hpp.

References s.

                               {
  string s;
  numeric_to_string<C> (x, s);
  return s;
}

void mmx::numeric_to_string	(	const long double &	x,
		string &	obj->lex_string
	)			[inline]

Definition at line 239 of file string.cpp.

References floating_to_string().

                                                               {
  floating_to_string (x, s, "%1.21Le"); }

void mmx::numeric_to_string	(	const double &	x,
		string &	obj->lex_string
	)			[inline]

Definition at line 237 of file string.cpp.

References floating_to_string().

                                                          {
  floating_to_string (x, s, "%1.17le"); }

void mmx::numeric_to_string	(	const float &	x,
		string &	obj->lex_string
	)			[inline]

Definition at line 235 of file string.cpp.

References floating_to_string().

                                                         {
  floating_to_string (x, s, "%1.8e"); }

void mmx::numeric_to_string	(	const long double &	x,
		string &	s
	)			[inline]

void mmx::numeric_to_string	(	const double &	x,
		string &	s
	)			[inline]

void mmx::numeric_to_string	(	const float &	x,
		string &	s
	)			[inline]

void mmx::numeric_to_string	(	const C &	x,
		string &	s
	)			[inline]

Definition at line 158 of file string.hpp.

                                          {
  if (x == 0) s << '0';
  else if (x <= 0) { // NOTE x < 0 would be nicer, but yields warnings
    s << '-';
    numeric_to_string (-x, s);
  }
  else {
    if (x >= 10) numeric_to_string (x/10, s);
    s << (char) (((char) '0') + ((char) ((int) (x%10))));
  }
}

static generic mmx::object_alias

(

const generic &

x

)

[static]

Definition at line 83 of file generic_object.cpp.

References as_object(), scalar_to_alias(), and type().

Referenced by define_user_type().

                                               {
  nat alias_id= scalar_to_alias (type (x));
  return as_object (as<generic> (new_alias<generic> (x)), alias_id); }

static bool mmx::object_equal	(	const generic &	x,
		const generic &	y
	)			[static]

Definition at line 74 of file generic_object.cpp.

Referenced by define_user_type().

                                                              {
  return x == y; }

static syntactic mmx::object_flatten

(

const generic &

x

)

[static]

Definition at line 78 of file generic_object.cpp.

References apply(), as_generic(), flatten(), type(), and type_name().

Referenced by define_user_type().

                                                   {
  nat id= type (x);
  generic rep= as_generic (x, id);
  return apply ("object", flatten (rep), flatten (type_name (id))); }

static alias<generic> mmx::object_generalize_alias

(

const generic &

x

)

[static]

Definition at line 95 of file generic_object.cpp.

References as_generic(), and type().

Referenced by define_user_type().

                                                                 {
  nat alias_id= type (x);
  return as<alias<generic> > (as_generic (x, alias_id)); }

static generic mmx::object_get_alias

(

const generic &

x

)

[static]

Definition at line 86 of file generic_object.cpp.

References as(), as_generic(), get_alias(), and type().

Referenced by define_user_type().

                                                   {
  nat alias_id= type (x);
  return get_alias (as<alias<generic> > (as_generic (x, alias_id))); }

static generic mmx::object_set_alias	(	const generic &	x,
		const generic &	y
	)			[static]

Definition at line 89 of file generic_object.cpp.

References as(), as_generic(), set_alias(), and type().

Referenced by define_user_type().

                                                                     {
  nat alias_id= type (x);
  return set_alias (as<alias<generic> > (as_generic (x, alias_id)), y); }

static generic mmx::object_specialize_alias

(

const alias< generic > &

x

)

[static]

Definition at line 92 of file generic_object.cpp.

References as_object(), get_alias(), scalar_to_alias(), and type().

Referenced by define_user_type().

                                                                 {
  nat alias_id= scalar_to_alias (type (get_alias (x)));
  return as_object (as<generic> (x), alias_id); }

static bool mmx::object_unequal	(	const generic &	x,
		const generic &	y
	)			[static]

Definition at line 76 of file generic_object.cpp.

Referenced by define_user_type().

                                                                {
  return x != y; }

C mmx::one_cst

(

)

[inline]

Definition at line 890 of file type_props.hpp.

References C, and set_one().

{ C r; set_one (r); return r; }

C& mmx::open_alias

(

const alias< C > &

a

)

[inline]

Definition at line 57 of file alias.hpp.

Referenced by alias_binary_access_rep< C, R, A, B >::open(), and alias_unary_access_rep< C, R, A >::open().

{ return a->open (); }

generic mmx::operate	(	const generic &	g,
		const generic &	h
	)			[inline]

Definition at line 139 of file mmx_printer.cpp.

References gen().

Referenced by mmx_printer::pp_E0().

                                                            {
  return gen ("$operate", g, h); }

bool mmx::operator!=	(	const vector< int, V > &	v,
		const int &	c
	)			[inline]

Definition at line 1162 of file vector.hpp.

                                                {
  return !binary_test_scalar<equal_op> (v, c); }

bool mmx::operator!=	(	const vector< C, V > &	x,
		const int &	y
	)			[inline]

Definition at line 1155 of file vector.hpp.

{

bool mmx::operator!=	(	const vector< C, V > &	x,
		const vector< C, V > &	y
	)			[inline]

Definition at line 1151 of file vector.hpp.

{

bool mmx::operator!=	(	const C &	c,
		const vector< C, V > &	v
	)			[inline]

Definition at line 1145 of file vector.hpp.

{ return v != c; }

bool mmx::operator!=	(	const vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 1134 of file vector.hpp.

                                                    {
  return !binary_test_scalar<equal_op> (v, c); }

bool mmx::operator!=	(	const format< C > &	x,
		const format< C > &	y
	)			[inline]

Definition at line 212 of file type_props.hpp.

{ return false; }

bool mmx::operator!=	(	const triple< C1, C2, C3 > &	x,
		const triple< C1, C2, C3 > &	y
	)			[inline]

Definition at line 58 of file triple.hpp.

{

bool mmx::operator!=	(	const table< C, T, V > &	x,
		const table< C, T, V > &	y
	)			[inline]

Definition at line 693 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

bool operator!=	(	const vector< syntactic > &	v,
		const vector< syntactic > &	w
	)

Definition at line 528 of file syntactic.cpp.

                                                                          {
  return !(v == w);
}

bool mmx::operator!=	(	const syntactic &	c1,
		const syntactic &	c2
	)			[inline]

Definition at line 52 of file syntactic.hpp.

                                                                   {
  return (*c1) != (*c2); }

bool mmx::operator!=	(	const symbol< C, equal_table > &	s1,
		const symbol< C, equal_table > &	s2
	)			[inline]

Definition at line 124 of file symbol.hpp.

References exact_neq().

                                              {
  return exact_neq (s1, s2); }

bool operator!=	(	const symbol< C, V > &	s1,
		const symbol< C, V > &	s2
	)			[inline]

Definition at line 107 of file symbol.hpp.

                                                                  {
  return (*s1) != (*s2); }

bool mmx::operator!=	(	const storage &	x,
		const storage &	y
	)			[inline]

Definition at line 56 of file storage.hpp.

{ return "storage"; }

bool mmx::operator!=	(	const sparse_vector< C, T, V > &	x,
		const sparse_vector< C, T, V > &	y
	)			[inline]

Definition at line 168 of file sparse_vector.hpp.

{

bool mmx::operator!=	(	const port &	x,
		const port &	y
	)			[inline]

Definition at line 64 of file port.hpp.

{ return p->expression (); }

bool mmx::operator!=	(	const pair< C1, C2 > &	x,
		const pair< C1, C2 > &	y
	)			[inline]

Definition at line 53 of file pair.hpp.

{

bool mmx::operator!=	(	const new_table< C, T, V > &	x,
		const new_table< C, T, V > &	y
	)			[inline]

Definition at line 764 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

bool mmx::operator!=	(	const Indirect< R > &	x,
		const Indirect< R > &	y
	)			[inline]

Definition at line 756 of file mmc_glue.hpp.

References Indirect< R >::rep.

                                                                          {
  return x.rep != y.rep; }

bool mmx::operator!=	(	const literal &	c1,
		const literal &	c2
	)			[inline]

Definition at line 46 of file literal.hpp.

                                                               {
  return as_symbol (c1) != as_symbol (c2); }

bool mmx::operator!=	(	const list< C > &	x,
		const list< C > &	y
	)			[inline]

Definition at line 228 of file list.hpp.

{

bool mmx::operator!=	(	const iterator< C > &	x,
		const iterator< C > &	y
	)			[inline]

Definition at line 185 of file iterator.hpp.

: public Iterator_rep {

bool mmx::operator!=	(	const instance< Cat, Nr > &	x,
		const int &	i
	)			[inline]

Definition at line 123 of file instance.hpp.

References promote().

                                                               {
  return x != promote (i, x); }

bool mmx::operator!=	(	const heap< C > &	x,
		const heap< C > &	y
	)			[inline]

Definition at line 243 of file heap.hpp.

{

bool operator!=	(	const int &	x1,
		const generic &	x2
	)

Definition at line 583 of file generic.cpp.

{ return x2 != x1; }

bool operator!=	(	const generic &	x1,
		const int &	x2
	)

Definition at line 581 of file generic.cpp.

{ return !(x1 == x2); }

bool operator!=	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 580 of file generic.cpp.

{ return !(x1 == x2); }

bool mmx::operator!=	(	const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &	x,
		const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &	y
	)			[inline]

Definition at line 614 of file function.hpp.

{

bool mmx::operator!=	(	const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &	x,
		const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &	y
	)			[inline]

Definition at line 554 of file function.hpp.

{

bool mmx::operator!=	(	const function_6< D, S1, S2, S3, S4, S5, S6 > &	x,
		const function_6< D, S1, S2, S3, S4, S5, S6 > &	y
	)			[inline]

Definition at line 494 of file function.hpp.

{

bool mmx::operator!=	(	const function_5< D, S1, S2, S3, S4, S5 > &	x,
		const function_5< D, S1, S2, S3, S4, S5 > &	y
	)			[inline]

Definition at line 435 of file function.hpp.

{

bool mmx::operator!=	(	const function_4< D, S1, S2, S3, S4 > &	x,
		const function_4< D, S1, S2, S3, S4 > &	y
	)			[inline]

Definition at line 376 of file function.hpp.

{

bool mmx::operator!=	(	const function_3< D, S1, S2, S3 > &	x,
		const function_3< D, S1, S2, S3 > &	y
	)			[inline]

Definition at line 317 of file function.hpp.

{

bool mmx::operator!=	(	const function_2< D, S1, S2 > &	x,
		const function_2< D, S1, S2 > &	y
	)			[inline]

Definition at line 258 of file function.hpp.

{

bool mmx::operator!=	(	const function_1< D, S1 > &	x,
		const function_1< D, S1 > &	y
	)			[inline]

Definition at line 158 of file function.hpp.

{

bool mmx::operator!=	(	const function_0< D > &	x,
		const function_0< D > &	y
	)			[inline]

Definition at line 102 of file function.hpp.

{

bool mmx::operator!=	(	const exception &	e1,
		const exception &	e2
	)			[inline]

Definition at line 41 of file exception.hpp.

                                                                   {
  return (*e1) != (*e2); }

bool mmx::operator!=	(	const dynamic &	x,
		const dynamic &	y
	)			[inline]

Definition at line 96 of file dynamic.hpp.

bool mmx::operator!=	(	const observer &	x,
		const observer &	y
	)			[inline]

Definition at line 59 of file dynamic.hpp.

: public rep_struct {

bool mmx::operator!=	(	const document &	c1,
		const document &	c2
	)			[inline]

Definition at line 53 of file document.hpp.

                                                                 {
  return (*c1) != (*c2); }

bool mmx::operator!=	(	const compound &	c1,
		const compound &	c2
	)			[inline]

Definition at line 51 of file compound.hpp.

                                                                 {
  return as_symbol (c1) != as_symbol (c2); }

bool mmx::operator!=	(	const cache< C, T > &	c1,
		const cache< C, T > &	c2
	)			[inline]

Definition at line 44 of file cache.hpp.

References hard_neq().

                                                                {
  return hard_neq (*c1, *c2); }

vector<C,V> mmx::operator&	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1108 of file vector.hpp.

                                                          {
  return binary_map<and_op> (v, w); }

table<C,T,V> mmx::operator&	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 637 of file table.hpp.

                                                              {
  return binary_map<and_op,C,T,V> (t, u); }

new_table<C,T,V> mmx::operator&	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 708 of file new_table.hpp.

                                                              {
  return binary_map<and_op,C,T,V> (t, u); }

generic operator&	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 840 of file generic.cpp.

References current_ev, and GEN_AND.

                                                          {
  return current_ev->apply (GEN_AND, x1, x2); }

table<C,T,V> mmx::operator&=	(	table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 671 of file table.hpp.

                                                         {
  return unary_set<and_op,C,T,V> (t, u); }

new_table<C,T,V> mmx::operator&=	(	new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 742 of file new_table.hpp.

                                                         {
  return unary_set<and_op,C,T,V> (t, u); }

string mmx::operator*	(	const string &	s1,
		const string &	s2
	)

Definition at line 411 of file string.cpp.

References N(), and string::rep.

                                                {
  register nat i, n1=N(s1), n2=N(s2);
  string r (n1 + n2);
  for (i=0; i<n1; i++) r.rep->a[i   ]= s1.rep->a[i];
  for (i=0; i<n2; i++) r.rep->a[i+n1]= s2.rep->a[i];
  return r;
}

vector<C,V> mmx::operator*	(	const int &	x,
		const vector< C, V > &	y
	)			[inline]

Definition at line 1154 of file vector.hpp.

{

vector<C,V> mmx::operator*	(	const vector< C, V > &	x,
		const int &	y
	)			[inline]

Definition at line 1154 of file vector.hpp.

{

vector<int,V> mmx::operator*	(	const int &	c,
		const vector< int, V > &	v
	)			[inline]

Definition at line 1090 of file vector.hpp.

                                               {
  return binary_map_scalar<lmul_op> (v, c); }

vector<C,V> mmx::operator*	(	const C &	c,
		const vector< C, V > &	v
	)			[inline]

Definition at line 1087 of file vector.hpp.

                                                     {
  return binary_map_scalar<lmul_op> (v, c); }

vector<int,V> mmx::operator*	(	const vector< int, V > &	v,
		const int &	c
	)			[inline]

Definition at line 1085 of file vector.hpp.

                                               {
  return binary_map_scalar<rmul_op> (v, c); }

vector<C,V> mmx::operator*	(	const vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 1082 of file vector.hpp.

                                                     {
  return binary_map_scalar<rmul_op> (v, c); }

vector<C,V> mmx::operator*	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1074 of file vector.hpp.

                                                          {
  return binary_map<mul_op> (v, w); }

table<C,T,V> mmx::operator*	(	const K &	sc,
		const table< C, T, V > &	t
	)			[inline]

Definition at line 647 of file table.hpp.

                                         {
  return binary_map_scalar<lmul_op> (t, sc); }

table<C,T,V> mmx::operator*	(	const table< C, T, V > &	t,
		const K &	sc
	)			[inline]

Definition at line 644 of file table.hpp.

                                         {
  return binary_map_scalar<rmul_op> (t, sc); }

table<C,T,V> mmx::operator*	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 627 of file table.hpp.

                                                              {
  return binary_map<mul_op,C,T,V> (t, u); }

syntactic operator*	(	const syntactic &	g1,
		const syntactic &	g2
	)

Definition at line 252 of file syntactic.cpp.

References exact_eq(), frac_flag, GEN_OVER, GEN_TIMES, is_func(), and syn().

                                                      {
  if (frac_flag && is_func (g1, GEN_OVER, 2)) {
    if (is_func (g2, GEN_OVER, 2))
      return syn (GEN_OVER, g1[1] * g2[1], g1[2] * g2[2]);
    else return syn (GEN_OVER, g1[1] * g2, g1[2]);
  }
  if (frac_flag && is_func (g2, GEN_OVER, 2))
    return syn (GEN_OVER, g1 * g2[1], g2[2]);
  if (exact_eq (g1, 0)) return 0;
  if (exact_eq (g2, 0)) return 0;
  if (exact_eq (g1, 1)) return g2;
  if (exact_eq (g2, 1)) return g1;
  if (exact_eq (g1, -1)) return -g2;
  if (exact_eq (g2, -1)) return -g1;
  return syn (GEN_TIMES, g1, g2);
}

sparse_vector<C,T,V> mmx::operator*	(	const C &	sc,
		const sparse_vector< C, T, V > &	t
	)			[inline]

Definition at line 299 of file sparse_vector.hpp.

                                                 {
  return binary_map_scalar<lmul_op> (t, sc); }

sparse_vector<C,T,V> mmx::operator*	(	const sparse_vector< C, T, V > &	t,
		const C &	sc
	)			[inline]

Definition at line 296 of file sparse_vector.hpp.

                                                 {
  return binary_map_scalar<rmul_op> (t, sc); }

sparse_vector<C,T,V> mmx::operator*	(	const sparse_vector< C, T, V > &	t,
		const sparse_vector< C, T, V > &	u
	)			[inline]

Definition at line 268 of file sparse_vector.hpp.

                                                            {
  return binary_map<mul_op,C,T,V> (t, u); }

pair<C1,C2> mmx::operator*	(	const pair< C1, C2 > &	p1,
		const pair< C1, C2 > &	p2
	)			[inline]

Definition at line 58 of file pair.hpp.

References Pair.

                                            {
  return Pair (p1.x1 * p2.x1, p1.x2 * p2.x2);
}

new_table<C,T,V> mmx::operator*	(	const K &	sc,
		const new_table< C, T, V > &	t
	)			[inline]

Definition at line 718 of file new_table.hpp.

                                         {
  return binary_map_scalar<lmul_op> (t, sc); }

new_table<C,T,V> mmx::operator*	(	const new_table< C, T, V > &	t,
		const K &	sc
	)			[inline]

Definition at line 715 of file new_table.hpp.

                                         {
  return binary_map_scalar<rmul_op> (t, sc); }

new_table<C,T,V> mmx::operator*	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 698 of file new_table.hpp.

                                                              {
  return binary_map<mul_op,C,T,V> (t, u); }

list<C> mmx::operator*	(	const list< C > &	l1,
		const list< C > &	l2
	)			[inline]

Definition at line 289 of file list.hpp.

References append().

                                            {
  return append (l1, l2);
}

iterator<C> mmx::operator*	(	const iterator< C > &	it1,
		const iterator< C > &	it2
	)			[inline]

Definition at line 399 of file iterator.hpp.

References Iterator.

                                                      {
  return Iterator (new join_iterator_rep<C> (it1, it2));
}

generic operator*	(	const int &	x1,
		const generic &	x2
	)

Definition at line 417 of file generic.cpp.

                                                      {
  return generic (x1) * x2; }

generic operator*	(	const generic &	x1,
		const int &	x2
	)

Definition at line 409 of file generic.cpp.

                                                      {
  return x1 * generic (x2); }

generic operator*	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 394 of file generic.cpp.

References ACC_BINARY, ACC_MUL, current_ev, and GEN_TIMES.

                                                  {
  ACC_BINARY (ACC_MUL, x1, x2);
  return current_ev->apply (GEN_TIMES, x1, x2);
}

chain< C > operator*	(	const chain< C > &	l,
		const chain< C > &	r
	)			[inline]

Definition at line 318 of file chain.hpp.

References balance_left(), balance_right(), cAr(), car(), cDr(), cdr(), Chain, left(), middle(), N(), and right().

                                            {
  nat nl= N (l), nr= N (r);
  if (nl < nr) {
    if (nl == 0) return r;
    if (nr < 2*nl + 3) return Chain (l, car (r), cdr (r));
    Chain br= balance_right (r);
    return Chain (l * left (br), middle (br), right (br));
  }
  else {
    if (nr == 0) return l;
    if (nl < 2*nr + 3) return Chain (cDr (l), cAr (l), r);
    Chain bl= balance_left (l);
    return Chain (left (bl), middle (bl), right (bl) * r);
  }
}

vector<C,V>& mmx::operator*=	(	vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 1119 of file vector.hpp.

                                                 {
  return unary_set_scalar<rmul_op> (v, c); }

vector<C,V>& mmx::operator*=	(	vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1115 of file vector.hpp.

                                                      {
  return unary_set<mul_op> (v, w); }

table<C,T,V>& mmx::operator*=	(	table< C, T, V > &	t,
		const K &	sc
	)			[inline]

Definition at line 674 of file table.hpp.

                                    {
  return unary_set_scalar<rmul_op> (t, sc); }

table<C,T,V> mmx::operator*=	(	table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 665 of file table.hpp.

                                                         {
  return unary_set<mul_op,C,T,V> (t, u); }

new_table<C,T,V>& mmx::operator*=	(	new_table< C, T, V > &	t,
		const K &	sc
	)			[inline]

Definition at line 745 of file new_table.hpp.

                                    {
  return unary_set_scalar<rmul_op> (t, sc); }

new_table<C,T,V> mmx::operator*=	(	new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 736 of file new_table.hpp.

                                                         {
  return unary_set<mul_op,C,T,V> (t, u); }

C& mmx::operator*=	(	C &	x,
		const D &	y
	)			[inline]

Definition at line 265 of file defaults.hpp.

{ return x= x*y; }

vector<C,V> mmx::operator+	(	const int &	x,
		const vector< C, V > &	y
	)			[inline]

Definition at line 1154 of file vector.hpp.

{

vector<C,V> mmx::operator+	(	const vector< C, V > &	x,
		const int &	y
	)			[inline]

Definition at line 1154 of file vector.hpp.

{

vector<int,V> mmx::operator+	(	const vector< int, V > &	w,
		const int &	v
	)			[inline]

Definition at line 1060 of file vector.hpp.

References Vector_int.

                                               {
  return binary_map<add_op> (w, Vector_int (v)); }

vector<C,V> mmx::operator+	(	const vector< C, V > &	w,
		const C &	v
	)			[inline]

Definition at line 1057 of file vector.hpp.

References Vector.

                                                     {
  return binary_map<add_op> (w, Vector (v)); }

vector<int,V> mmx::operator+	(	const int &	v,
		const vector< int, V > &	w
	)			[inline]

Definition at line 1055 of file vector.hpp.

References Vector_int.

                                               {
  return binary_map<add_op> (Vector_int (v), w); }

vector<C,V> mmx::operator+	(	const C &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1052 of file vector.hpp.

References Vector.

                                                     {
  return binary_map<add_op> (Vector (v), w); }

vector<C,V> mmx::operator+	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1050 of file vector.hpp.

                                                          {
  return binary_map<add_op> (v, w); }

table<C,T,V> mmx::operator+	(	const int &	x,
		const table< C, T, V > &	y
	)			[inline]

Definition at line 695 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

table<C,T,V> mmx::operator+	(	const table< C, T, V > &	x,
		const int &	y
	)			[inline]

Definition at line 695 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

table<C,T,V> mmx::operator+	(	const C &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 619 of file table.hpp.

References Table.

                                                          {
  return binary_map<add_op,C,T,V> (Table (t), u); }

table<C,T,V> mmx::operator+	(	const table< C, T, V > &	t,
		const C &	u
	)			[inline]

Definition at line 617 of file table.hpp.

References Table.

                                                          {
  return binary_map<add_op,C,T,V> (t, Table (u)); }

table<C,T,V> mmx::operator+	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 615 of file table.hpp.

                                                              {
  return binary_map<add_op,C,T,V> (t, u); }

syntactic operator+	(	const syntactic &	g1,
		const syntactic &	g2
	)

Definition at line 169 of file syntactic.cpp.

References exact_eq(), GEN_MINUS, GEN_PLUS, is_func(), signed_decompose(), and syn().

                                                      {
  if (exact_eq (g1, 0)) return g2;
  if (exact_eq (g2, 0)) return g1;
  if (is_func (g2, GEN_MINUS, 1))
    return g1 - g2[1];
  if (is_func (g2, GEN_PLUS, 2))
    return (g1 + g2[1]) + g2[2];
  if (is_func (g2, GEN_MINUS, 2))
    return (g1 + g2[1]) - g2[2];
  syntactic abs_g2; int sgn_g2;
  signed_decompose (g2, abs_g2, sgn_g2);
  if (sgn_g2 < 0) return syn (GEN_MINUS, g1, abs_g2);
  else return syn (GEN_PLUS, g1, abs_g2);
}

sparse_vector<C,T,V> mmx::operator+	(	const sparse_vector< C, T, V > &	t,
		const sparse_vector< C, T, V > &	u
	)			[inline]

Definition at line 262 of file sparse_vector.hpp.

                                                            {
  return binary_map_optimized<add_op,C,T,V> (t, u); }

new_table<C,T,V> mmx::operator+	(	const int &	x,
		const new_table< C, T, V > &	y
	)			[inline]

Definition at line 766 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

new_table<C,T,V> mmx::operator+	(	const new_table< C, T, V > &	x,
		const int &	y
	)			[inline]

Definition at line 766 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

new_table<C,T,V> mmx::operator+	(	const C &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 690 of file new_table.hpp.

References Table.

                                                          {
  return binary_map<add_op,C,T,V> (Table (t), u); }

new_table<C,T,V> mmx::operator+	(	const new_table< C, T, V > &	t,
		const C &	u
	)			[inline]

Definition at line 688 of file new_table.hpp.

References Table.

                                                          {
  return binary_map<add_op,C,T,V> (t, Table (u)); }

new_table<C,T,V> mmx::operator+	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 686 of file new_table.hpp.

                                                              {
  return binary_map<add_op,C,T,V> (t, u); }

generic operator+	(	const int &	x1,
		const generic &	x2
	)

Definition at line 413 of file generic.cpp.

                                                      {
  return generic (x1) + x2; }

generic operator+	(	const generic &	x1,
		const int &	x2
	)

Definition at line 405 of file generic.cpp.

                                                      {
  return x1 + generic (x2); }

generic operator+	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 382 of file generic.cpp.

References ACC_ADD, ACC_BINARY, current_ev, and GEN_PLUS.

                                                  {
  ACC_BINARY (ACC_ADD, x1, x2);
  return current_ev->apply (GEN_PLUS, x1, x2);
}

vector<C,V>& mmx::operator+=	(	vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1111 of file vector.hpp.

                                                      {
  return unary_set<add_op> (v, w); }

table<C,T,V> mmx::operator+=	(	table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 661 of file table.hpp.

                                                         {
  return unary_set<add_op,C,T,V> (t, u); }

new_table<C,T,V> mmx::operator+=	(	new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 732 of file new_table.hpp.

                                                         {
  return unary_set<add_op,C,T,V> (t, u); }

C& mmx::operator+=	(	C &	x,
		const D &	y
	)			[inline]

Definition at line 261 of file defaults.hpp.

{ return x= x+y; }

vector<C,V> mmx::operator-	(	const int &	x,
		const vector< C, V > &	y
	)			[inline]

Definition at line 1154 of file vector.hpp.

{

vector<C,V> mmx::operator-	(	const vector< C, V > &	x,
		const int &	y
	)			[inline]

Definition at line 1154 of file vector.hpp.

{

vector<int,V> mmx::operator-	(	const int &	v,
		const vector< int, V > &	w
	)			[inline]

Definition at line 1072 of file vector.hpp.

References Vector_int.

                                               {
  return binary_map<sub_op> (Vector_int (v), w); }

vector<C,V> mmx::operator-	(	const C &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1069 of file vector.hpp.

References Vector.

                                                     {
  return binary_map<sub_op> (Vector (v), w); }

vector<int,V> mmx::operator-	(	const vector< int, V > &	v,
		const int &	w
	)			[inline]

Definition at line 1067 of file vector.hpp.

References Vector_int.

                                               {
  return binary_map<sub_op> (v, Vector_int (w)); }

vector<C,V> mmx::operator-	(	const vector< C, V > &	v,
		const C &	w
	)			[inline]

Definition at line 1064 of file vector.hpp.

References Vector.

                                                     {
  return binary_map<sub_op> (v, Vector (w)); }

vector<C,V> mmx::operator-	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1062 of file vector.hpp.

                                                          {
  return binary_map<sub_op> (v, w); }

vector<C,V> mmx::operator-

(

const vector< C, V > &

v

)

[inline]

Definition at line 1048 of file vector.hpp.

                                         {
  return unary_map<neg_op> (v); }

table<C,T,V> mmx::operator-	(	const int &	x,
		const table< C, T, V > &	y
	)			[inline]

Definition at line 695 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

table<C,T,V> mmx::operator-	(	const table< C, T, V > &	x,
		const int &	y
	)			[inline]

Definition at line 695 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

table<C,T,V> mmx::operator-	(	const C &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 625 of file table.hpp.

References Table.

                                                          {
  return binary_map<sub_op,C,T,V> (Table (t), u); }

table<C,T,V> mmx::operator-	(	const table< C, T, V > &	t,
		const C &	u
	)			[inline]

Definition at line 623 of file table.hpp.

References Table.

                                                          {
  return binary_map<sub_op,C,T,V> (t, Table (u)); }

table<C,T,V> mmx::operator-	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 621 of file table.hpp.

                                                              {
  return binary_map<sub_op,C,T,V> (t, u); }

table<C,T,V> mmx::operator-

(

const table< C, T, V > &

t

)

[inline]

Definition at line 613 of file table.hpp.

                                              {
  return unary_map<neg_op,C,T,V> (t); }

syntactic operator-	(	const syntactic &	g1,
		const syntactic &	g2
	)

Definition at line 185 of file syntactic.cpp.

References exact_eq(), GEN_MINUS, GEN_PLUS, is_func(), signed_decompose(), and syn().

                                                      {
  if (exact_eq (g2, 0)) return g1;
  if (is_func (g2, GEN_MINUS, 1))
    return g1 + g2[1];
  if (is_func (g2, GEN_PLUS, 2))
    return (g1 - g2[1]) - g2[2];
  if (is_func (g2, GEN_MINUS, 2))
    return (g1 - g2[1]) + g2[2];
  syntactic abs_g2; int sgn_g2;
  signed_decompose (g2, abs_g2, sgn_g2);
  if (exact_eq (g1, 0)) {
    if (sgn_g2 > 0) return syn (GEN_MINUS, abs_g2);
    else return abs_g2;    
  }
  else {
    if (sgn_g2 > 0) return syn (GEN_MINUS, g1, abs_g2);
    else return syn (GEN_PLUS, g1, abs_g2);
  }
}

syntactic operator-

(

const syntactic &

g

)

Definition at line 154 of file syntactic.cpp.

References exact_eq(), GEN_MINUS, GEN_PLUS, is_func(), signed_decompose(), and syn().

                                {
  if (exact_eq (g, 0)) return g;
  if (is_func (g, GEN_MINUS, 1))
    return g[1];
  if (is_func (g, GEN_PLUS, 2))
    return (-g[1]) - g[2];
  if (is_func (g, GEN_MINUS, 2))
    return (-g[1]) + g[2];
  syntactic abs_g; int sgn_g;
  signed_decompose (g, abs_g, sgn_g);
  if (sgn_g > 0) return syn (GEN_MINUS, abs_g);
  else return abs_g;
}

sparse_vector<C,T,V> mmx::operator-	(	const sparse_vector< C, T, V > &	t,
		const sparse_vector< C, T, V > &	u
	)			[inline]

Definition at line 265 of file sparse_vector.hpp.

                                                            {
  return binary_map_optimized<sub_op,C,T,V> (t, u); }

sparse_vector<C,T,V> mmx::operator-

(

const sparse_vector< C, T, V > &

t

)

[inline]

Definition at line 189 of file sparse_vector.hpp.

                                    {
  return unary_map<neg_op,C,T,V> (t); }

new_table<C,T,V> mmx::operator-	(	const int &	x,
		const new_table< C, T, V > &	y
	)			[inline]

Definition at line 766 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

new_table<C,T,V> mmx::operator-	(	const new_table< C, T, V > &	x,
		const int &	y
	)			[inline]

Definition at line 766 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

new_table<C,T,V> mmx::operator-	(	const C &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 696 of file new_table.hpp.

References Table.

                                                          {
  return binary_map<sub_op,C,T,V> (Table (t), u); }

new_table<C,T,V> mmx::operator-	(	const new_table< C, T, V > &	t,
		const C &	u
	)			[inline]

Definition at line 694 of file new_table.hpp.

References Table.

                                                          {
  return binary_map<sub_op,C,T,V> (t, Table (u)); }

new_table<C,T,V> mmx::operator-	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 692 of file new_table.hpp.

                                                              {
  return binary_map<sub_op,C,T,V> (t, u); }

new_table<C,T,V> mmx::operator-

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 684 of file new_table.hpp.

                                              {
  return unary_map<neg_op,C,T,V> (t); }

generic operator-	(	const int &	x1,
		const generic &	x2
	)

Definition at line 415 of file generic.cpp.

                                                      {
  return generic (x1) - x2; }

generic operator-	(	const generic &	x1,
		const int &	x2
	)

Definition at line 407 of file generic.cpp.

                                                      {
  return x1 - generic (x2); }

generic operator-	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 388 of file generic.cpp.

References ACC_BINARY, ACC_SUB, current_ev, and GEN_MINUS.

                                                  {
  ACC_BINARY (ACC_SUB, x1, x2);
  return current_ev->apply (GEN_MINUS, x1, x2);
}

generic operator-

(

const generic &

x1

)

Definition at line 364 of file generic.cpp.

References ACC_NEGATE, ACC_UNARY, current_ev, and GEN_MINUS.

                               {
  ACC_UNARY (ACC_NEGATE, x1);
  return current_ev->apply (GEN_MINUS, x1);
}

vector<C,V>& mmx::operator-=	(	vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1113 of file vector.hpp.

                                                      {
  return unary_set<sub_op> (v, w); }

table<C,T,V> mmx::operator-=	(	table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 663 of file table.hpp.

                                                         {
  return unary_set<sub_op,C,T,V> (t, u); }

new_table<C,T,V> mmx::operator-=	(	new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 734 of file new_table.hpp.

                                                         {
  return unary_set<sub_op,C,T,V> (t, u); }

C& mmx::operator-=	(	C &	x,
		const D &	y
	)			[inline]

Definition at line 263 of file defaults.hpp.

{ return x= x-y; }

vector<C,V> mmx::operator/	(	const int &	x,
		const vector< C, V > &	y
	)			[inline]

Definition at line 1154 of file vector.hpp.

{

vector<C,V> mmx::operator/	(	const vector< C, V > &	x,
		const int &	y
	)			[inline]

Definition at line 1154 of file vector.hpp.

{

vector<int,V> mmx::operator/	(	const int &	c,
		const vector< int, V > &	v
	)			[inline]

Definition at line 1100 of file vector.hpp.

                                               {
  return binary_map_scalar<ldiv_op> (v, c); }

vector<C,V> mmx::operator/	(	const C &	c,
		const vector< C, V > &	v
	)			[inline]

Definition at line 1097 of file vector.hpp.

                                                     {
  return binary_map_scalar<ldiv_op> (v, c); }

vector<int,V> mmx::operator/	(	const vector< int, V > &	v,
		const int &	c
	)			[inline]

Definition at line 1095 of file vector.hpp.

                                               {
  return binary_map_scalar<rdiv_op> (v, c); }

vector<C,V> mmx::operator/	(	const vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 1092 of file vector.hpp.

                                                     {
  return binary_map_scalar<rdiv_op> (v, c); }

vector<C,V> mmx::operator/	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1076 of file vector.hpp.

                                                          {
  return binary_map<div_op> (v, w); }

table<C,T,V> mmx::operator/	(	const K &	sc,
		const table< C, T, V > &	t
	)			[inline]

Definition at line 653 of file table.hpp.

                                         {
  return binary_map_scalar<ldiv_op> (t, sc); }

table<C,T,V> mmx::operator/	(	const table< C, T, V > &	t,
		const K &	sc
	)			[inline]

Definition at line 650 of file table.hpp.

                                         {
  return binary_map_scalar<rdiv_op> (t, sc); }

table<C,T,V> mmx::operator/	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 629 of file table.hpp.

                                                              {
  return binary_map<div_op,C,T,V> (t, u); }

syntactic operator/	(	const syntactic &	g1,
		const syntactic &	g2
	)

Definition at line 270 of file syntactic.cpp.

References exact_eq(), frac_flag, GEN_OVER, is_func(), and syn().

                                                      {
  if (frac_flag && is_func (g2, GEN_OVER, 2))
    return g1 * syn (GEN_OVER, g2[2], g2[1]);
  if (exact_eq (g2, 1)) return g1;
  if (exact_eq (g2, -1)) return -g1;
  if (frac_flag) return g1 * syn (GEN_OVER, 1, g2);
  else return syn (GEN_OVER, g1, g2);
}

sparse_vector<C,T,V> mmx::operator/	(	const C &	sc,
		const sparse_vector< C, T, V > &	t
	)			[inline]

Definition at line 305 of file sparse_vector.hpp.

                                                 {
  return binary_map_scalar<ldiv_op> (t, sc); }

sparse_vector<C,T,V> mmx::operator/	(	const sparse_vector< C, T, V > &	t,
		const C &	sc
	)			[inline]

Definition at line 302 of file sparse_vector.hpp.

                                                 {
  return binary_map_scalar<rdiv_op> (t, sc); }

new_table<C,T,V> mmx::operator/	(	const K &	sc,
		const new_table< C, T, V > &	t
	)			[inline]

Definition at line 724 of file new_table.hpp.

                                         {
  return binary_map_scalar<ldiv_op> (t, sc); }

new_table<C,T,V> mmx::operator/	(	const new_table< C, T, V > &	t,
		const K &	sc
	)			[inline]

Definition at line 721 of file new_table.hpp.

                                         {
  return binary_map_scalar<rdiv_op> (t, sc); }

new_table<C,T,V> mmx::operator/	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 700 of file new_table.hpp.

                                                              {
  return binary_map<div_op,C,T,V> (t, u); }

generic operator/	(	const int &	x1,
		const generic &	x2
	)

Definition at line 419 of file generic.cpp.

                                                      {
  return generic (x1) / x2; }

generic operator/	(	const generic &	x1,
		const int &	x2
	)

Definition at line 411 of file generic.cpp.

                                                      {
  return x1 / generic (x2); }

generic operator/	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 400 of file generic.cpp.

References ACC_BINARY, ACC_DIV, current_ev, and GEN_OVER.

                                                  {
  ACC_BINARY (ACC_DIV, x1, x2);
  return current_ev->apply (GEN_OVER, x1, x2);
}

vector<C,V>& mmx::operator/=	(	vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 1121 of file vector.hpp.

                                                 {
  return unary_set_scalar<rdiv_op> (v, c); }

vector<C,V>& mmx::operator/=	(	vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1117 of file vector.hpp.

                                                      {
  return unary_set<div_op> (v, w); }

table<C,T,V>& mmx::operator/=	(	table< C, T, V > &	t,
		const K &	sc
	)			[inline]

Definition at line 677 of file table.hpp.

                                    {
  return unary_set_scalar<rdiv_op> (t, sc); }

table<C,T,V> mmx::operator/=	(	table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 667 of file table.hpp.

                                                         {
  return unary_set<div_op,C,T,V> (t, u); }

new_table<C,T,V>& mmx::operator/=	(	new_table< C, T, V > &	t,
		const K &	sc
	)			[inline]

Definition at line 748 of file new_table.hpp.

                                    {
  return unary_set_scalar<rdiv_op> (t, sc); }

new_table<C,T,V> mmx::operator/=	(	new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 738 of file new_table.hpp.

                                                         {
  return unary_set<div_op,C,T,V> (t, u); }

C& mmx::operator/=	(	C &	x,
		const D &	y
	)			[inline]

Definition at line 267 of file defaults.hpp.

{ return x= x/y; }

bool mmx::operator<	(	const vector< int, V > &	v,
		const int &	c
	)			[inline]

Definition at line 1168 of file vector.hpp.

                                               {
  return v <= c && v != c; }

bool mmx::operator<	(	const vector< C, V > &	x,
		const int &	y
	)			[inline]

Definition at line 1156 of file vector.hpp.

{

bool mmx::operator<	(	const vector< C, V > &	x,
		const vector< C, V > &	y
	)			[inline]

Definition at line 1153 of file vector.hpp.

{

bool mmx::operator<	(	const C &	c,
		const vector< C, V > &	v
	)			[inline]

Definition at line 1146 of file vector.hpp.

{ return v >  c; }

bool mmx::operator<	(	const vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 1138 of file vector.hpp.

                                                          {
  return v <= c && v != c; }

bool mmx::operator<	(	const table< C, T, V > &	x,
		const table< C, T, V > &	y
	)			[inline]

Definition at line 696 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

bool operator<	(	const syntactic &	x,
		const syntactic &	y
	)

Definition at line 379 of file syntactic.cpp.

References as_generic(), and small_big_compare().

                                                    {
  return small_big_compare (as_generic (x), as_generic (y)) < 0;
}

bool operator<	(	const string &	s,
		const string &	t
	)

Definition at line 296 of file string.cpp.

References N().

                                                {
  register nat i;
  for (i=0; i<N(s1); i++) {
    if (i >= N(s2)) return false;
    if (s1[i] < s2[i]) return true;
    if (s2[i] < s1[i]) return false;
  }
  return false;
}

bool mmx::operator<	(	const new_table< C, T, V > &	x,
		const new_table< C, T, V > &	y
	)			[inline]

Definition at line 767 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

bool mmx::operator<	(	const instance< Cat, Nr > &	x,
		const int &	i
	)			[inline]

Definition at line 125 of file instance.hpp.

References promote().

                                                              {
  return x < promote (i, x); }

bool operator<	(	const int &	x1,
		const generic &	x2
	)

Definition at line 656 of file generic.cpp.

                                                   {
  return generic (x1) < x2; }

bool operator<	(	const generic &	x1,
		const int &	x2
	)

Definition at line 648 of file generic.cpp.

                                                   {
  return x1 < generic (x2); }

bool operator<	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 625 of file generic.cpp.

References ACC_LESS, ACC_TEST, as_bool(), current_ev, and GEN_LESS.

                                                  {
  ACC_TEST (ACC_LESS, x1, x2);
  return as_bool (current_ev->apply (GEN_LESS, x1, x2));
}

static string& mmx::operator<<	(	string &	out,
		const generic &	g
	)			[static]

Definition at line 221 of file cpp_printer.cpp.

References mmerr, and type_name().

                                            {
  if (is<string> (g)) return out << as<string> (g);
  if (is<literal> (g)) return out << (*(as<literal> (g)));
  mmerr << g << ": " << type_name (g) << "\n";
  assert (false);
  return out;
}

static string& mmx::operator<<	(	string &	out,
		const char *	s
	)			[static]

Definition at line 216 of file cpp_printer.cpp.

                                         {
  return out << string (s);
}

static string& mmx::operator<<	(	string &	out,
		print_controls	pc
	)			[static]

Definition at line 90 of file mmx_printer.cpp.

References INDENT, indentation_level, inside(), LF, N(), UNINDENT, and VARINDENT.

                                             {
  switch (pc) {
  case LF:
    out << "\n";
    for (nat i=0; i<indentation_level; i++) out << "  ";
    break;
  case INDENT:
    indentation_level++;
    out << "  ";
    break;
  case VARINDENT:
    indentation_level++;
    break;
  case UNINDENT:
    indentation_level--;
    if (N(out) >= 2 && out[N(out)-2] == ' ' && out[N(out)-1] == ' ')
      inside (out) -> resize (N(out) - 2);
    break;
  }
  return out;
}

table<C,T,V>& mmx::operator<<	(	table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 758 of file table.hpp.

References busy(), and entries().

                                       {
  for (iterator<T> it= entries (u); busy (it); ++it)
    t[*it]= u[*it];
  return t;
}

syntactic operator<<	(	const syntactic &	x1,
		const syntactic &	x2
	)

Definition at line 467 of file syntactic.cpp.

References GEN_LESSLESS, and syn().

                                                                 {
  return syn (GEN_LESSLESS, x1, x2); }

port mmx::operator<<	(	const port &	out,
		const print_format &	fm
	)			[inline]

Definition at line 163 of file port.hpp.

References inside().

                                                      {
  inside (out) -> format (fm);
  return out;
}

port mmx::operator<<	(	const port &	out,
		const char &	c
	)			[inline]

Definition at line 157 of file port.hpp.

References string_as_mmx(), and write().

                                             {
  write (out, string_as_mmx (c));
  return out;
}

port mmx::operator<<	(	const port &	out,
		const const_charp &	s
	)			[inline]

Definition at line 151 of file port.hpp.

References string_as_mmx(), and write().

                                                    {
  write (out, string_as_mmx (s));
  return out;
}

port mmx::operator<<	(	const port &	out,
		const charp &	s
	)			[inline]

Definition at line 145 of file port.hpp.

References string_as_mmx(), and write().

                                              {
  write (out, string_as_mmx (s));
  return out;
}

port mmx::operator<<	(	const port &	out,
		const string &	s
	)			[inline]

Definition at line 139 of file port.hpp.

References string_as_mmx(), and write().

                                               {
  write (out, string_as_mmx (s));
  return out;
}

new_table<C,T,V>& mmx::operator<<	(	new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 829 of file new_table.hpp.

References busy(), and entries().

                                       {
  for (iterator<T> it= entries (u); busy (it); ++it)
    t[*it]= u[*it];
  return t;
}

heap<C>& mmx::operator<<	(	heap< C > &	h,
		const C &	x
	)			[inline]

Definition at line 196 of file heap.hpp.

References push().

                                                    {
  push (h, x); return h; }

generic operator<<	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 793 of file generic.cpp.

References current_ev, and GEN_LESSLESS.

                                                           {
  return current_ev->apply (GEN_LESSLESS, x1, x2); }

port operator<<	(	const port &	out,
		const C &	x
	)			[inline]

Definition at line 133 of file port.hpp.

References output_as_mmx(), and write().

                                          {
  write (out, output_as_mmx (as<generic> (x)));
  return out;
}

bool mmx::operator<=	(	const vector< int, V > &	v,
		const int &	c
	)			[inline]

Definition at line 1165 of file vector.hpp.

                                                {
  return binary_test_scalar<lesseq_op> (v, c); }

bool mmx::operator<=	(	const vector< C, V > &	x,
		const int &	y
	)			[inline]

Definition at line 1156 of file vector.hpp.

{

bool mmx::operator<=	(	const C &	c,
		const vector< C, V > &	v
	)			[inline]

Definition at line 1148 of file vector.hpp.

{ return v >= c; }

bool mmx::operator<=	(	const vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 1136 of file vector.hpp.

                                                    {
  return binary_test_scalar<lesseq_op> (v, c); }

bool mmx::operator<=	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1128 of file vector.hpp.

                                                         {
  return binary_test<lesseq_op> (v, w); }

bool mmx::operator<=	(	const table< C, T, V > &	t,
		const K &	c
	)			[inline]

Definition at line 687 of file table.hpp.

                                         {
  return binary_test_scalar<lesseq_op> (t, c); }

bool mmx::operator<=	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 679 of file table.hpp.

                                                              {
  return binary_test<lesseq_op> (t, u); }

bool operator<=	(	const syntactic &	x,
		const syntactic &	y
	)

Definition at line 384 of file syntactic.cpp.

References as_generic(), and small_big_compare().

                                                     {
  return small_big_compare (as_generic (x), as_generic (y)) <= 0;
}

bool operator<=	(	const string &	s,
		const string &	t
	)

Definition at line 307 of file string.cpp.

References N().

                                                 {
  register nat i;
  for (i=0; i<N(s1); i++) {
    if (i >= N(s2)) return false;
    if (s1[i] < s2[i]) return true;
    if (s2[i] < s1[i]) return false;
  }
  return true;
}

bool mmx::operator<=	(	const new_table< C, T, V > &	t,
		const K &	c
	)			[inline]

Definition at line 758 of file new_table.hpp.

                                         {
  return binary_test_scalar<lesseq_op> (t, c); }

bool mmx::operator<=	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 750 of file new_table.hpp.

                                                              {
  return binary_test<lesseq_op> (t, u); }

bool mmx::operator<=	(	const instance< Cat, Nr > &	x,
		const int &	i
	)			[inline]

Definition at line 129 of file instance.hpp.

References promote().

                                                               {
  return x <= promote (i, x); }

bool operator<=	(	const int &	x1,
		const generic &	x2
	)

Definition at line 658 of file generic.cpp.

                                                    {
  return generic (x1) <= x2; }

bool operator<=	(	const generic &	x1,
		const int &	x2
	)

Definition at line 650 of file generic.cpp.

                                                    {
  return x1 <= generic (x2); }

bool operator<=	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 631 of file generic.cpp.

References ACC_LESSEQ, ACC_TEST, as_bool(), current_ev, and GEN_LESSEQ.

                                                   {
  ACC_TEST (ACC_LESSEQ, x1, x2);
  return as_bool (current_ev->apply (GEN_LESSEQ, x1, x2));
}

bool mmx::operator==	(	const vector< int, V > &	v,
		const int &	c
	)			[inline]

Definition at line 1159 of file vector.hpp.

                                                {
  return binary_test_scalar<equal_op> (v, c); }

bool mmx::operator==	(	const vector< C, V > &	x,
		const int &	y
	)			[inline]

Definition at line 1155 of file vector.hpp.

{

bool mmx::operator==	(	const vector< C, V > &	x,
		const vector< C, V > &	y
	)			[inline]

Definition at line 1151 of file vector.hpp.

{

bool mmx::operator==	(	const C &	c,
		const vector< C, V > &	v
	)			[inline]

Definition at line 1144 of file vector.hpp.

{ return v == c; }

bool mmx::operator==	(	const vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 1132 of file vector.hpp.

                                                    {
  return binary_test_scalar<equal_op> (v, c); }

bool mmx::operator==	(	const format< C > &	x,
		const format< C > &	y
	)			[inline]

Definition at line 209 of file type_props.hpp.

{ return true; }

bool mmx::operator==	(	const triple< C1, C2, C3 > &	x,
		const triple< C1, C2, C3 > &	y
	)			[inline]

Definition at line 58 of file triple.hpp.

{

bool mmx::operator==	(	const table< C, T, V > &	t,
		const K &	c
	)			[inline]

Definition at line 684 of file table.hpp.

                                         {
  return binary_test_scalar<equal_op> (t, c); }

bool operator==	(	const table< C, T, V > &	t1,
		const table< C, T, V > &	t2
	)			[inline]

Definition at line 693 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

bool operator==	(	const vector< syntactic > &	v,
		const vector< syntactic > &	w
	)

Definition at line 520 of file syntactic.cpp.

References is_a_scalar(), N(), and vector< C, V >::scalar().

                                                                          {
  if (is_a_scalar (v)) return is_a_scalar (w) && v.scalar () == w.scalar ();
  if (N(v) != N(w)) return false;
  for (nat i=0; i<N(v); i++)
    if (v[i] != w[i]) return false;
  return true;
}

bool mmx::operator==	(	const syntactic &	c1,
		const syntactic &	c2
	)			[inline]

Definition at line 50 of file syntactic.hpp.

                                                                   {
  return (*c1) == (*c2); }

bool mmx::operator==	(	const symbol< C, equal_table > &	s1,
		const symbol< C, equal_table > &	s2
	)			[inline]

Definition at line 120 of file symbol.hpp.

References exact_eq().

                                              {
  return exact_eq (s1, s2); }

bool operator==	(	const symbol< C, V > &	s1,
		const symbol< C, V > &	s2
	)			[inline]

Definition at line 105 of file symbol.hpp.

                                                                  {
  return (*s1) == (*s2); }

bool mmx::operator==	(	const storage &	x,
		const storage &	y
	)			[inline]

Definition at line 56 of file storage.hpp.

{ return "storage"; }

bool mmx::operator==	(	const sparse_vector< C, T, V > &	x,
		const sparse_vector< C, T, V > &	y
	)			[inline]

Definition at line 168 of file sparse_vector.hpp.

{

bool mmx::operator==	(	const port &	x,
		const port &	y
	)			[inline]

Definition at line 64 of file port.hpp.

{ return p->expression (); }

bool mmx::operator==	(	const pair< C1, C2 > &	x,
		const pair< C1, C2 > &	y
	)			[inline]

Definition at line 53 of file pair.hpp.

{

bool mmx::operator==	(	const new_table< C, T, V > &	t,
		const K &	c
	)			[inline]

Definition at line 755 of file new_table.hpp.

                                         {
  return binary_test_scalar<equal_op> (t, c); }

bool operator==	(	const new_table< C, T, V > &	t1,
		const new_table< C, T, V > &	t2
	)			[inline]

Definition at line 764 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

bool mmx::operator==	(	const Indirect< R > &	x,
		const Indirect< R > &	y
	)			[inline]

Definition at line 754 of file mmc_glue.hpp.

References Indirect< R >::rep.

                                                                          {
  return x.rep == y.rep; }

bool mmx::operator==	(	const literal &	c1,
		const literal &	c2
	)			[inline]

Definition at line 44 of file literal.hpp.

                                                               {
  return as_symbol (c1) == as_symbol (c2); }

bool mmx::operator==	(	const list< C > &	x,
		const list< C > &	y
	)			[inline]

Definition at line 228 of file list.hpp.

{

bool mmx::operator==	(	const iterator< C > &	x,
		const iterator< C > &	y
	)			[inline]

Definition at line 185 of file iterator.hpp.

: public Iterator_rep {

bool mmx::operator==	(	const instance< Cat, Nr > &	x,
		const int &	i
	)			[inline]

Definition at line 121 of file instance.hpp.

References promote().

                                                               {
  return x == promote (i, x); }

bool mmx::operator==	(	const heap< C > &	x,
		const heap< C > &	y
	)			[inline]

Definition at line 243 of file heap.hpp.

{

bool operator==	(	const int &	x1,
		const generic &	x2
	)

Definition at line 582 of file generic.cpp.

{ return x2 == x1; }

bool operator==	(	const generic &	x1,
		const int &	x2
	)

Definition at line 570 of file generic.cpp.

References is_nil().

                                               {
  if (is<int> (x1)) return as<int> (x1) == x2;
  else {
    routine* cv= x1->acc_construct (accelerator<int>::id);
    if (cv != NULL && !is_nil (*cv))
      return x1 -> is_equal ((*cv) (as<generic> (x2)));
  }
  return x1 == generic (x2);
}

bool operator==	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 555 of file generic.cpp.

References as_bool(), current_ev, GEN_EQUAL, is_nil(), and same_type().

                                                   {
  if (same_type (x1, x2))
    return x1->is_equal (x2);
  else {
    routine* cv= x1->acc_construct (x2->acc_id ());
    if (cv != NULL && !is_nil (*cv))
      return x1 -> is_equal ((*cv) (x2));
    cv= x2->acc_construct (x1->acc_id ());
    if (cv != NULL && !is_nil (*cv))
      return (*cv) (x1) -> is_equal (x2);
  }
  return as_bool (current_ev->apply (GEN_EQUAL, x1, x2));
}

bool mmx::operator==	(	const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &	x,
		const function_8< D, S1, S2, S3, S4, S5, S6, S7, S8 > &	y
	)			[inline]

Definition at line 614 of file function.hpp.

{

bool mmx::operator==	(	const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &	x,
		const function_7< D, S1, S2, S3, S4, S5, S6, S7 > &	y
	)			[inline]

Definition at line 554 of file function.hpp.

{

bool mmx::operator==	(	const function_6< D, S1, S2, S3, S4, S5, S6 > &	x,
		const function_6< D, S1, S2, S3, S4, S5, S6 > &	y
	)			[inline]

Definition at line 494 of file function.hpp.

{

bool mmx::operator==	(	const function_5< D, S1, S2, S3, S4, S5 > &	x,
		const function_5< D, S1, S2, S3, S4, S5 > &	y
	)			[inline]

Definition at line 435 of file function.hpp.

{

bool mmx::operator==	(	const function_4< D, S1, S2, S3, S4 > &	x,
		const function_4< D, S1, S2, S3, S4 > &	y
	)			[inline]

Definition at line 376 of file function.hpp.

{

bool mmx::operator==	(	const function_3< D, S1, S2, S3 > &	x,
		const function_3< D, S1, S2, S3 > &	y
	)			[inline]

Definition at line 317 of file function.hpp.

{

bool mmx::operator==	(	const function_2< D, S1, S2 > &	x,
		const function_2< D, S1, S2 > &	y
	)			[inline]

Definition at line 258 of file function.hpp.

{

bool mmx::operator==	(	const function_1< D, S1 > &	x,
		const function_1< D, S1 > &	y
	)			[inline]

Definition at line 158 of file function.hpp.

{

bool mmx::operator==	(	const function_0< D > &	x,
		const function_0< D > &	y
	)			[inline]

Definition at line 102 of file function.hpp.

{

bool mmx::operator==	(	const exception &	e1,
		const exception &	e2
	)			[inline]

Definition at line 39 of file exception.hpp.

                                                                   {
  return (*e1) == (*e2); }

bool mmx::operator==	(	const dynamic &	x,
		const dynamic &	y
	)			[inline]

Definition at line 96 of file dynamic.hpp.

bool mmx::operator==	(	const observer &	x,
		const observer &	y
	)			[inline]

Definition at line 59 of file dynamic.hpp.

: public rep_struct {

bool mmx::operator==	(	const document &	c1,
		const document &	c2
	)			[inline]

Definition at line 51 of file document.hpp.

                                                                 {
  return (*c1) == (*c2); }

bool mmx::operator==	(	const compound &	c1,
		const compound &	c2
	)			[inline]

Definition at line 49 of file compound.hpp.

                                                                 {
  return as_symbol (c1) == as_symbol (c2); }

bool mmx::operator==	(	const cache< C, T > &	c1,
		const cache< C, T > &	c2
	)			[inline]

Definition at line 42 of file cache.hpp.

References hard_eq().

                                                                {
  return hard_eq (*c1, *c2); }

bool mmx::operator>	(	const vector< int, V > &	v,
		const int &	c
	)			[inline]

Definition at line 1174 of file vector.hpp.

                                               {
  return v >= c && v != c; }

bool mmx::operator>	(	const vector< C, V > &	x,
		const int &	y
	)			[inline]

Definition at line 1156 of file vector.hpp.

{

bool mmx::operator>	(	const vector< C, V > &	x,
		const vector< C, V > &	y
	)			[inline]

Definition at line 1153 of file vector.hpp.

{

bool mmx::operator>	(	const C &	c,
		const vector< C, V > &	v
	)			[inline]

Definition at line 1147 of file vector.hpp.

{ return v <  c; }

bool mmx::operator>	(	const vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 1142 of file vector.hpp.

                                                          {
  return v >= c && v != c; }

bool mmx::operator>	(	const table< C, T, V > &	x,
		const table< C, T, V > &	y
	)			[inline]

Definition at line 696 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

bool operator>	(	const syntactic &	x,
		const syntactic &	y
	)

Definition at line 389 of file syntactic.cpp.

References as_generic(), and small_big_compare().

                                                    {
  return small_big_compare (as_generic (x), as_generic (y)) > 0;
}

bool operator>	(	const string &	s,
		const string &	t
	)

Definition at line 318 of file string.cpp.

References N().

                                                {
  register nat i;
  for (i=0; i<N(s1); i++) {
    if (i >= N(s2)) return true;
    if (s1[i] > s2[i]) return true;
    if (s2[i] > s1[i]) return false;
  }
  return false;
}

bool mmx::operator>	(	const new_table< C, T, V > &	x,
		const new_table< C, T, V > &	y
	)			[inline]

Definition at line 767 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

bool mmx::operator>	(	const instance< Cat, Nr > &	x,
		const int &	i
	)			[inline]

Definition at line 127 of file instance.hpp.

References promote().

                                                              {
  return x > promote (i, x); }

bool operator>	(	const int &	x1,
		const generic &	x2
	)

Definition at line 660 of file generic.cpp.

                                                   {
  return generic (x1) > x2; }

bool operator>	(	const generic &	x1,
		const int &	x2
	)

Definition at line 652 of file generic.cpp.

                                                   {
  return x1 > generic (x2); }

bool operator>	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 637 of file generic.cpp.

References ACC_GTR, ACC_TEST, as_bool(), current_ev, and GEN_GTR.

                                                  {
  ACC_TEST (ACC_GTR, x1, x2);
  return as_bool (current_ev->apply (GEN_GTR, x1, x2));
}

bool mmx::operator>=	(	const vector< int, V > &	v,
		const int &	c
	)			[inline]

Definition at line 1171 of file vector.hpp.

                                                {
  return binary_test_scalar<gtreq_op> (v, c); }

bool mmx::operator>=	(	const vector< C, V > &	x,
		const int &	y
	)			[inline]

Definition at line 1156 of file vector.hpp.

{

bool mmx::operator>=	(	const C &	c,
		const vector< C, V > &	v
	)			[inline]

Definition at line 1149 of file vector.hpp.

{ return v <= c; }

bool mmx::operator>=	(	const vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 1140 of file vector.hpp.

                                                    {
  return binary_test_scalar<gtreq_op> (v, c); }

bool mmx::operator>=	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1130 of file vector.hpp.

                                                         {
  return binary_test<gtreq_op> (v, w); }

bool mmx::operator>=	(	const table< C, T, V > &	t,
		const K &	c
	)			[inline]

Definition at line 690 of file table.hpp.

                                         {
  return binary_test_scalar<gtreq_op> (t, c); }

bool mmx::operator>=	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 681 of file table.hpp.

                                                              {
  return binary_test<gtreq_op,C,T,V> (t, u); }

bool operator>=	(	const syntactic &	x,
		const syntactic &	y
	)

Definition at line 394 of file syntactic.cpp.

References as_generic(), and small_big_compare().

                                                     {
  return small_big_compare (as_generic (x), as_generic (y)) >= 0;
}

bool operator>=	(	const string &	s,
		const string &	t
	)

Definition at line 329 of file string.cpp.

References N().

                                                 {
  register nat i;
  for (i=0; i<N(s1); i++) {
    if (i >= N(s2)) return true;
    if (s1[i] > s2[i]) return true;
    if (s2[i] > s1[i]) return false;
  }
  return true;
}

bool mmx::operator>=	(	const new_table< C, T, V > &	t,
		const K &	c
	)			[inline]

Definition at line 761 of file new_table.hpp.

                                         {
  return binary_test_scalar<gtreq_op> (t, c); }

bool mmx::operator>=	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 752 of file new_table.hpp.

                                                              {
  return binary_test<gtreq_op,C,T,V> (t, u); }

bool mmx::operator>=	(	const instance< Cat, Nr > &	x,
		const int &	i
	)			[inline]

Definition at line 131 of file instance.hpp.

References promote().

                                                               {
  return x >= promote (i, x); }

bool operator>=	(	const int &	x1,
		const generic &	x2
	)

Definition at line 662 of file generic.cpp.

                                                    {
  return generic (x1) >= x2; }

bool operator>=	(	const generic &	x1,
		const int &	x2
	)

Definition at line 654 of file generic.cpp.

                                                    {
  return x1 >= generic (x2); }

bool operator>=	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 643 of file generic.cpp.

References ACC_GTREQ, ACC_TEST, as_bool(), current_ev, and GEN_GTREQ.

                                                   {
  ACC_TEST (ACC_GTREQ, x1, x2);
  return as_bool (current_ev->apply (GEN_GTREQ, x1, x2));
}

syntactic operator>>	(	const syntactic &	x1,
		const syntactic &	x2
	)

Definition at line 469 of file syntactic.cpp.

References GEN_GTRGTR, and syn().

                                                                 {
  return syn (GEN_GTRGTR, x1, x2); }

port mmx::operator>>	(	const port &	in,
		char &	c
	)			[inline]

Definition at line 169 of file port.hpp.

References read().

                                      {
  read (in, &c, 1);
  return in;
}

heap<C>& mmx::operator>>	(	heap< C > &	h,
		C &	x
	)			[inline]

Definition at line 198 of file heap.hpp.

References pull().

                                              {
  x= pull (h); return h; }

generic operator>>	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 795 of file generic.cpp.

References current_ev, and GEN_GTRGTR.

                                                           {
  return current_ev->apply (GEN_GTRGTR, x1, x2); }

vector<C,V> mmx::operator|	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1106 of file vector.hpp.

                                                          {
  return binary_map<or_op> (v, w); }

table<C,T,V> mmx::operator|	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 635 of file table.hpp.

                                                              {
  return binary_map<or_op,C,T,V> (t, u); }

new_table<C,T,V> mmx::operator|	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 706 of file new_table.hpp.

                                                              {
  return binary_map<or_op,C,T,V> (t, u); }

generic operator|	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 838 of file generic.cpp.

References current_ev, and GEN_OR.

                                                          {
  return current_ev->apply (GEN_OR, x1, x2); }

table<C,T,V> mmx::operator|=	(	table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 669 of file table.hpp.

                                                         {
  return unary_set<or_op,C,T,V> (t, u); }

new_table<C,T,V> mmx::operator|=	(	new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 740 of file new_table.hpp.

                                                         {
  return unary_set<or_op,C,T,V> (t, u); }

static table<string, string> mmx::opname_table

(

)

[static]

Definition at line 149 of file cpp_printer.cpp.

References CPP_ACCESS, CPP_AND, CPP_APPLY, CPP_ARROW, CPP_ASSIGN, CPP_BITWISE_AND, CPP_BITWISE_OR, CPP_BITWISE_XOR, CPP_COMPLEMENT, CPP_EQUAL, CPP_GTR, CPP_GTREQ, CPP_GTRGTR, CPP_GTRGTREQ(), CPP_LESS, CPP_LESSEQ, CPP_LESSLESS, CPP_LESSLESSEQ(), CPP_MINUS, CPP_MINUS_ASSIGN, CPP_MOD, CPP_MOD_ASSIGN, CPP_NOT, CPP_OR, CPP_OVER, CPP_OVER_ASSIGN, CPP_PLUS, CPP_PLUS_ASSIGN, CPP_PREDEC, CPP_PREINC, CPP_TIMES, CPP_TIMES_ASSIGN, CPP_UNEQUAL, and SET_OPNAME.

                {
  table<string, string> t;
  SET_OPNAME (CPP_PLUS, "+")
  SET_OPNAME (CPP_MINUS, "-");
  SET_OPNAME (CPP_TIMES, "*");
  SET_OPNAME (CPP_OVER, "/");
  SET_OPNAME (CPP_MOD, "%");
  SET_OPNAME (CPP_AND, "&&");
  SET_OPNAME (CPP_OR, "||");
  SET_OPNAME (CPP_NOT, "!");
  SET_OPNAME (CPP_BITWISE_AND, "&");
  SET_OPNAME (CPP_BITWISE_OR, "|");
  SET_OPNAME (CPP_BITWISE_XOR, "^");
  SET_OPNAME (CPP_ASSIGN, "=");
  SET_OPNAME (CPP_LESS, "<");
  SET_OPNAME (CPP_GTR, ">");
  SET_OPNAME (CPP_PLUS_ASSIGN, "+=");
  SET_OPNAME (CPP_MINUS_ASSIGN, "-=");
  SET_OPNAME (CPP_TIMES_ASSIGN, "*=");
  SET_OPNAME (CPP_OVER_ASSIGN, "/=");
  SET_OPNAME (CPP_MOD_ASSIGN, "%=");
  SET_OPNAME (CPP_LESSLESS, "<<");
  SET_OPNAME (CPP_LESSLESSEQ, "<<=");
  SET_OPNAME (CPP_GTRGTR, ">>");
  SET_OPNAME (CPP_GTRGTREQ, ">>=");
  SET_OPNAME (CPP_EQUAL, "==");
  SET_OPNAME (CPP_UNEQUAL, "!=");
  SET_OPNAME (CPP_LESSEQ, "<=");
  SET_OPNAME (CPP_GTREQ, ">=");
  SET_OPNAME (CPP_PREINC, "++");
  SET_OPNAME (CPP_PREDEC, "--");
  SET_OPNAME (CPP_APPLY, "()");
  SET_OPNAME (CPP_ACCESS, "[]");
  SET_OPNAME (CPP_COMPLEMENT, "~");
  SET_OPNAME (CPP_ARROW, "->");
  return t;
}

syntactic ordered_product

(

const vector< syntactic > &

v

)

Definition at line 364 of file syntactic.cpp.

References copy(), N(), and set_frac_flag().

Referenced by GLUE_18().

                                             {
  vector<syntactic> w= copy (v);
  sort_leq<product_less_op> (w);
  bool old= set_frac_flag (true);
  syntactic r= 1;
  for (nat i=0; i<N(w); i++) r= r * w[i];
  (void) set_frac_flag (old);
  return r;
}

syntactic ordered_sum

(

const vector< syntactic > &

v

)

Definition at line 337 of file syntactic.cpp.

References copy(), migrate_negate(), and N().

Referenced by GLUE_17().

                                         {
  vector<syntactic> w= copy (v);
  sort_leq<sum_less_op> (w);
  syntactic r= 0;
  for (nat i=0; i<N(w); i++) r= r + w[i];
  return migrate_negate (r, 5);
}

T mmx::outplace_set_as

(

const F &

x

)

[inline]

Definition at line 715 of file type_props.hpp.

References set_as(), and T.

                             {
  T r;
  set_as (r, x);
  return r;
}

string output_as_mmx

(

const generic &

g

)

Definition at line 974 of file mmx_printer.cpp.

References as_generic(), as_mmx(), DATA_BEGIN, DATA_END, flatten(), flatten_as_texmacs_scheme(), and math_mode.

Referenced by operator<<().

                                 {
  if (math_mode) {
    string r;
    r << DATA_BEGIN << "scheme:";
    r << flatten_as_texmacs_scheme (g);
    r << DATA_END;
    return r;
  }
  else {
    generic f= as_generic (flatten (g));
    return as_mmx (f);
  }
}

static void mmx::output_completion	(	const string &	text,
		const list< string > &	matches2
	)			[static]

Definition at line 28 of file texmacs_interface.cpp.

References car(), cdr(), DATA_BEGIN, DATA_END, flush_now, is_nil(), mmout, and N().

Referenced by complete(), and handle_completion_request().

                                                                     {
  list<string> matches= matches2;
  mmout << DATA_BEGIN << "scheme:(tuple ";
  mmout << '\"' << text << '\"';
  while (!is_nil (matches)) {
    if (N (car (matches)) > 0)
      mmout << " \"" << car (matches) << '\"';
    matches = cdr (matches);
  }
  mmout << ')';
  mmout << DATA_END << flush_now;
}

static port mmx::output_file_port	(	FILE *	f,
		bool	close_flag,
		bool	lock,
		const string &	name
	)			[static]

Definition at line 116 of file file_port.cpp.

                                                                           {
  return (port_rep*) new file_port_rep (1, f, close_flag, lock, name);
}

port output_file_port

(

const string &

name

)

Definition at line 142 of file file_port.cpp.

References as_charp(), decode_name(), error_port(), and free_charp().

Referenced by GLUE_3(), and save().

                                      {
  string name_s= decode_name (name);
  char* temp= as_charp (name_s);
#if defined(__MINGW__) || defined(__MINGW32__)
  FILE* f= _fsopen (temp, "w", _SH_DENYRW);
#else
  FILE* f= fopen (temp, "w");
#endif
  free_charp (temp);
  if (f == NULL) return error_port ("file '" * name * "' not writable");
  return output_file_port (f, true, true, name);
}

observer mmx::output_observer

(

dynamic_rep *

arg

)

Definition at line 85 of file dynamic.cpp.

Referenced by flatten().

                                   {
  return observer (new output_observer_rep (arg));
}

port mmx::output_string_port

(

string &

obj->lex_string

)

Definition at line 40 of file string_port.cpp.

                               {
  return (port_rep*) new output_string_port_rep (s);
}

port mmx::output_string_port

(

string &

s

)

Referenced by read_line().

static bool mmx::parse_blanks	(	const string &	text,
		nat &	obj->lex_pos
	)			[static]

Definition at line 68 of file texmacs_interface.cpp.

References N().

Referenced by parse_completion_request().

                                            {
  nat beg= pos;
  while (pos < N(text) &&
         (text[pos] == ' ' || text[pos] == '\t' || text[pos] == '\n'))
    ++pos;
  return (pos > beg);
}

static bool mmx::parse_char	(	const string &	text,
		char	c,
		nat &	obj->lex_pos
	)			[static]

Definition at line 61 of file texmacs_interface.cpp.

References N().

Referenced by parse_completion_request(), and parse_string().

                                                  {
  if ((pos >= N(text)) || (text[pos]!=c)) return false;
  ++pos;
  return true;
}

static bool mmx::parse_completion_request	(	const string &	text,
		nat &	obj->lex_pos,
		string &	obj->lex_string,
		nat &	p
	)			[static]

Definition at line 112 of file texmacs_interface.cpp.

References parse_blanks(), parse_char(), parse_identifier(), parse_nat(), and parse_string().

Referenced by handle_completion_request().

                                                                           {
  nat i=pos;
  if (!parse_char(text, '(', i)) return false;
  parse_blanks(text, i);
  if (!parse_identifier(text, "complete", i)) return false;
  parse_blanks(text, i);
  if (!parse_string(text, i, s)) return false;
  parse_blanks(text, i);
  if (!parse_nat(text, i, p)) return false;
  parse_blanks(text, i);
  if (!parse_char(text, ')', i)) return false;
  pos = i;
  return true;
}

static bool mmx::parse_identifier	(	const string &	text,
		const string &	id,
		nat &	obj->lex_pos
	)			[static]

Definition at line 86 of file texmacs_interface.cpp.

References N().

Referenced by parse_completion_request().

                                                                  {
  nat beg = pos;
  for(nat j=0; j < N(id); pos++,j++)
    if ((pos >= N(text)) || (text[pos]!=id[j])) {
      pos = beg;
      return false;
    }
  return true;
}

static generic mmx::parse_lisp	(	const string &	s,
		nat &	pos,
		bool	unquote_flag,
		bool	fun_flag
	)			[static]

Definition at line 19 of file lisp_parser.cpp.

References N(), parse_lisp(), s, start, unquote(), and vector_to_compound().

                                                                         {
  while (pos < N(s) && s[pos] == ' ') pos++;
  if (s[pos] == '(') {
    vector<generic> v;
    pos++;
    while (pos < N(s) && s[pos] != ')') {
      bool fun= (N(v) == 0);
      v << parse_lisp (s, pos, unquote_flag, fun);
      while (pos < N(s) && s[pos] == ' ') pos++;
    }
    if (pos < N(s)) pos++;
    return vector_to_compound (v);
  }
  else if (unquote_flag && !fun_flag && pos < N(s) && s[pos] == '\"') {
    nat start= pos;
    pos++;
    while (pos < N(s) && s[pos] != '\"')
      if (s[pos] == '\\') pos += 2;
      else pos++;
    if (pos < N(s)) pos++;
    return generic (unquote (s (start, pos)));
  }
  else {
    nat start= pos;
    while (pos < N(s) && s[pos] != ' ' && s[pos] != '(' && s[pos] != ')')
      pos++;
    return generic (s (start, pos));
  }
}

generic parse_lisp	(	const string &	s,
		bool	unquote_flag = false
	)

Definition at line 50 of file lisp_parser.cpp.

References pos.

Referenced by flatten_as_tm(), GLUE_4(), and parse_lisp().

                                                {
  nat pos= 0;
  return parse_lisp (s, pos, unquote_flag, false);
}

static bool mmx::parse_nat	(	const string &	text,
		nat &	obj->lex_pos,
		nat &	out
	)			[static]

Definition at line 77 of file texmacs_interface.cpp.

References as_int(), and N().

Referenced by parse_completion_request().

                                                   {
  nat beg= pos;
  while (pos < N(text) && text[pos] >= '0' && text[pos] <= '9')
    ++pos;
  out= as_int (text (beg, pos));
  return (pos > beg);
}

static bool mmx::parse_string	(	const string &	text,
		nat &	obj->lex_pos,
		string &	out
	)			[static]

Definition at line 97 of file texmacs_interface.cpp.

References N(), and parse_char().

Referenced by parse_completion_request().

                                                         {
  bool esc= false;
  nat i= pos;
  if (!parse_char(text, '\"', i)) return false;
  while ((i < N(text)) && (esc || text[i]!='\"')) {
    esc = (!esc) && (text[i]=='\\');
    ++i;
  }
  out = text(pos+1,i);
  if (!parse_char(text,'\"',i)) return false;
  pos = i;
  return true;
}

static int mmx::passive_newline	(	int	a,
		int	b
	)			[static]

Definition at line 283 of file terminal_interface.cpp.

References fed.

Referenced by shell_terminal_input().

                              {
  (void) a;
  (void) b;
  rl_crlf ();
  rl_on_new_line ();
  fed = false;
  rl_done = 1;
  return 0;
}

string path_name	(	const string &	file_path,
		const string &	file_name
	)

Definition at line 375 of file system.cpp.

References _from_dos_to_unix(), canonical_name(), file_exists(), get_env(), init_system(), is_absolute_name(), load_path(), N(), n, path_sep, start, and var_pwd().

Referenced by connect_to_server(), dl_find(), and prefix_dir().

                                                             {
  //mmout << "path_name: file_path= " << file_path << lf;
  //mmout << "           file_name= " << file_name << lf;
  if (is_absolute_name (file_name)) {
    if (file_exists (file_name)) return canonical_name (file_name);
    else return "";
  }
  else {
    nat i, n= N(file_path), start= 0;
    for (i=0; i<=n; i++)
      if ((i==n) || (file_path[i] == path_sep)) {
        string ss= file_path (start, i);
        if ((N(ss) > 0) && (ss[0] == '$')) {
          init_system ();
          if (ss == "$MMX_LOAD_PATH") ss= load_path ();
          else if (ss == "$PWD") ss= var_pwd ();
          else ss= _from_dos_to_unix (get_env (ss (1, N(ss))));
          string r= path_name (ss, file_name);
          if (r != "") return r;
        }
        else {
          if (ss == "" || ss == ".") ss= var_pwd ();
          if (ss != "" && ss[N(ss)-1] != '/') ss= ss * "/";
          if (file_exists (ss * file_name))
            return canonical_name (ss * file_name);
        }
        start= i+1;
      }
    return "";
  }
}

C mmx::pi_cst

(

const format< C > &

fm

)

[inline]

Definition at line 924 of file type_props.hpp.

References C, promote(), and set_pi().

                             {
  C r= promote (0, fm); set_pi (r); return r; }

C mmx::pi_cst

(

)

[inline]

Definition at line 894 of file type_props.hpp.

References C, and set_pi().

{ C r; set_pi (r); return r; }

port mmx::pipe_port	(	nat	kind,
		nat	fd,
		nat	pid,
		const string &	cmd,
		const string &	role
	)

Definition at line 59 of file pipe_port.cpp.

                                                                             {
  return (port_rep*) new pipe_port_rep (kind, fd, pid, cmd, role);
}

port pipe_port

(

const string &

cmd

)

Definition at line 68 of file pipe_port.cpp.

References composite_port(), IN, lf, mmerr, OUT, STDERR, STDIN, STDOUT, and system().

Referenced by GLUE_6().

                              {
#if defined(__MINGW__) || defined(__MINGW32__)
  mmerr << "pipe_port not implemented" << lf;
  exit (-1);
#else
  int pp_in [2];  // for data going to the child
  int pp_out[2];  // for data coming from the child
  int pp_err[2];  // for error messages coming from the child

  int e1 = pipe (pp_in ); (void) e1;
  int e2 = pipe (pp_out); (void) e2;
  int e3 = pipe (pp_err); (void) e3;
  int pid= fork ();

  if (pid==0) { // the child
    setsid();
    close (pp_in  [OUT]);
    close (pp_out [IN ]);
    close (pp_err [IN ]);
    dup2  (pp_in  [IN ], STDIN );
    close (pp_in  [IN ]);
    dup2  (pp_out [OUT], STDOUT);
    close (pp_out [OUT]);
    dup2  (pp_err [OUT], STDERR);
    close (pp_err [OUT]);

    system (cmd);
    exit (127);
    // exit (system (cmd) != 0);
  }

  else { // the main process
    int in = pp_in  [OUT];
    close (pp_in [IN]);
    int out= pp_out [IN ];
    close (pp_out [OUT]);
    int err= pp_err [IN ];
    close (pp_err [OUT]);

    port pin = pipe_port (1, in , pid, cmd, "in" );
    port pout= pipe_port (2, out, pid, cmd, "out");
    port perr= pipe_port (2, err, pid, cmd, "err");
    return composite_port (vec<port> (pin, pout, perr),
                           vec<string> ("in", "out", "err"));
  }
#endif
}

syntactic polar	(	const syntactic &	g1,
		const syntactic &	g2
	)

Definition at line 457 of file syntactic.cpp.

References exp(), and Imaginary.

                                                           {
  return g1 * exp (g2 * Imaginary (syntactic)); }

generic polar	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 742 of file generic.cpp.

References exp(), and Imaginary.

Referenced by polar_op::set_op().

                                                     {
  return x1 * exp (x2 * Imaginary (generic)); }

generic mmx::postfix	(	const generic &	g,
		const generic &	op
	)			[inline]

Definition at line 135 of file mmx_printer.cpp.

References gen().

                                                             {
  return gen ("$postfix", g, op); }

vector<C,V> mmx::pow	(	const int &	w,
		const vector< C, V > &	v
	)			[inline]

Definition at line 1195 of file vector.hpp.

                                                {
  return binary_map_scalar<lpow_op> (v, w); }

vector<C,V> mmx::pow	(	const vector< C, V > &	v,
		const int &	w
	)			[inline]

Definition at line 1193 of file vector.hpp.

                                                {
  return binary_map_scalar<rpow_op> (v, w); }

vector<C,V> mmx::pow	(	const C &	w,
		const vector< C, V > &	v
	)			[inline]

Definition at line 1191 of file vector.hpp.

                                              {
  return binary_map_scalar<lpow_op> (v, w); }

vector<C,V> mmx::pow	(	const vector< C, V > &	v,
		const C &	w
	)			[inline]

Definition at line 1189 of file vector.hpp.

                                              {
  return binary_map_scalar<rpow_op> (v, w); }

vector<C,V> mmx::pow	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1187 of file vector.hpp.

                                                   {
  return binary_map<pow_op> (v, w); }

table<C,T,V> mmx::pow	(	const int &	u,
		const table< C, T, V > &	t
	)			[inline]

Definition at line 712 of file table.hpp.

                                              {
  return binary_map_scalar<lpow_op> (t, u); }

table<C,T,V> mmx::pow	(	const table< C, T, V > &	t,
		const int &	u
	)			[inline]

Definition at line 710 of file table.hpp.

                                              {
  return binary_map_scalar<rpow_op> (t, u); }

table<C,T,V> mmx::pow	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 708 of file table.hpp.

                                                {
  return binary_map<pow_op> (t, u); }

syntactic pow	(	const int &	g1,
		const syntactic &	g2
	)

Definition at line 311 of file syntactic.cpp.

References flatten(), and pow().

                                         {
  return pow (flatten (g1), g2);
}

syntactic pow	(	const syntactic &	g1,
		const int &	g2
	)

Definition at line 306 of file syntactic.cpp.

References flatten(), and pow().

                                         {
  return pow (g1, flatten (g2));
}

syntactic pow	(	const syntactic &	g1,
		const syntactic &	g2
	)

Definition at line 290 of file syntactic.cpp.

References abs(), exact_eq(), frac_flag, GEN_OVER, GEN_POWER, GEN_SQRT, pow(), signed_decompose(), and syn().

                                               {
  if (exact_eq (g1, 0)) return 0;
  if (exact_eq (g1, 1)) return 1;
  if (exact_eq (g2, 0)) return 1;
  if (exact_eq (g2, 1)) return g1;
  if (exact_eq (g2, syn (GEN_OVER, syntactic (1), syntactic (2))))
    return syn (GEN_SQRT, g1);
  if (frac_flag) {
    syntactic abs; int sgn;
    signed_decompose (g2, abs, sgn);
    if (sgn < 0) return syn (GEN_OVER, 1, pow (g1, abs));
  }
  return syn (GEN_POWER, g1, g2);
}

new_table<C,T,V> mmx::pow	(	const int &	u,
		const new_table< C, T, V > &	t
	)			[inline]

Definition at line 783 of file new_table.hpp.

                                              {
  return binary_map_scalar<lpow_op> (t, u); }

new_table<C,T,V> mmx::pow	(	const new_table< C, T, V > &	t,
		const int &	u
	)			[inline]

Definition at line 781 of file new_table.hpp.

                                              {
  return binary_map_scalar<rpow_op> (t, u); }

new_table<C,T,V> mmx::pow	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 779 of file new_table.hpp.

                                                {
  return binary_map<pow_op> (t, u); }

generic pow	(	const nat &	x1,
		const generic &	x2
	)

Definition at line 545 of file generic.cpp.

References pow().

                                               {
  return pow (generic (x1), x2); }

generic pow	(	const generic &	x1,
		const nat &	x2
	)

Definition at line 543 of file generic.cpp.

References pow().

                                               {
  return pow (x1, generic (x2)); }

generic pow	(	const int &	x1,
		const generic &	x2
	)

Definition at line 541 of file generic.cpp.

References pow().

                                               {
  return pow (generic (x1), x2); }

generic pow	(	const generic &	x1,
		const int &	x2
	)

Definition at line 539 of file generic.cpp.

References pow().

                                               {
  return pow (x1, generic (x2)); }

generic pow	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 534 of file generic.cpp.

References ACC_BINARY, ACC_POW, current_ev, and GEN_POWER.

                                           {
  ACC_BINARY (ACC_POW, x1, x2);
  return current_ev->apply (GEN_POWER, x1, x2);
}

double pow	(	const int &	x,
		const double &	y
	)			[inline]

Definition at line 66 of file double.hpp.

References pow().

                                                  {
  return std::pow ((double) x, y); }

double pow	(	const double &	x,
		const int &	y
	)			[inline]

Definition at line 64 of file double.hpp.

References pow().

                                                  {
  return std::pow (x, (double) y); }

double pow	(	const double &	x,
		const double &	y
	)			[inline]

Definition at line 62 of file double.hpp.

Referenced by apply(), GLUE_15(), lpow_op::op(), pow_op::op(), pow(), lpow_op::set_op(), pow_op::set_op(), and sympow().

                                                     {
  return std::pow (x, y); }

C mmx::powint	(	const C &	i,
		const int &	n
	)			[inline]

Definition at line 549 of file defaults.hpp.

References binpow(), C, promote(), and square().

                                  {
  // FIXME: how to merge with pow?
  if (n < 0) return promote (1, i) / binpow (i, (nat) (-n));
  if (n <= 1) return n==0? promote (1, i): i;
  C j= square (binpow (i, (nat) (n >> 1)));
  if ((n&1) == 0) return j;
  else return i * j;
}

xnat mmx::precision

(

const vector< C, V > &

v

)

[inline]

Definition at line 1328 of file vector.hpp.

                                             {
  return big<min_precision_op> (v); }

xnat precision

(

const generic &

x

)

Definition at line 764 of file generic.cpp.

References ASSERT, current_ev, and GEN_PRECISION.

                                  {
  generic r= current_ev->apply (GEN_PRECISION, x);
  ASSERT (is<int> (r), "Int return value expected");
  return as<int> (r); }

xnat mmx::precision

(

const double &

x

)

[inline]

Definition at line 83 of file double.hpp.

Referenced by GLUE_43(), precision_op::op(), set_accuracy(), min_precision_op::set_op(), and precision_op::set_op().

{ (void) x; return 51; }

generic mmx::prefix	(	const generic &	op,
		const generic &	g
	)			[inline]

Definition at line 137 of file mmx_printer.cpp.

References gen().

                                                            {
  return gen ("$prefix", op, g); }

string prefix_dir

(

)

Definition at line 224 of file system.cpp.

References _from_dos_to_unix(), ASSERT, BASIX_PREFIX, command_dir(), eval_system(), file_exists(), get_directory(), get_env(), is_absolute_name(), and path_name().

Referenced by dl_find(), load_path(), and sysconf_dir().

              {
  string dir= get_env ("MMX_PREFIX_DIR");
#if defined(__MINGW__) || defined(__MINGW32__)
  if (!file_exists (dir)) {
    try { dir= eval_system ("basix-config --prefix"); }
    catch (const exception&) {
      dir= get_directory (command_dir ());
      if (!is_absolute_name (dir))
        dir= get_directory (get_directory (path_name
                                           (_from_dos_to_unix (get_env ("PATH")), "mmx-light.exe")));
      ASSERT (is_absolute_name (dir), "Cannot determine installation prefix");
    }
  }
#else
  if (dir == "") dir= string (BASIX_PREFIX);
  if (!file_exists (dir)) dir= eval_system ("basix-config --prefix");
#endif
  return _from_dos_to_unix (dir);
}

generic prime

(

const generic &

x1

)

Definition at line 694 of file generic.cpp.

References current_ev.

                                  {
  return current_ev->apply ("'", x1); }

generic print_mmx

(

const generic &

g

)

Referenced by as_mmx(), as_snippet(), as_texmacs_scheme(), and as_texmacs_snippet().

format<typename unary_return_type_helper<project_op, C >::RET > mmx::project

(

const format< C > &

fm

)

[inline]

Definition at line 853 of file type_props.hpp.

References get_format(), get_sample(), and project().

{ return get_format (project (get_sample (fm)));}

unary_return_type_helper<project_op, C >::RET mmx::project

(

const C &

x

)

[inline]

Definition at line 847 of file type_props.hpp.

{ return project_helper<C>::op (x); }

syntactic project	(	const syntactic &	x,
		const syntactic &	y
	)

Definition at line 513 of file syntactic.cpp.

References syn().

Referenced by project_helper< vector< C, V > >::op(), mv_project_op::op(), project(), and mv_project_op::set_op().

                                                           {
  return syn ("project", x, y); }

T mmx::promote	(	const F &	x,
		const format< T > &	fm
	)			[inline]

Definition at line 729 of file type_props.hpp.

References get_sample(), and promote().

                                          {
  return promote (x, get_sample (fm));
}

C mmx::promote

(

R *

rep

)

[inline]

Definition at line 51 of file mmc_glue.hpp.

References C.

{ return C (rep); }

double mmx::promote	(	const F &	x,
		const double &
	)			[inline]

Definition at line 53 of file defaults.hpp.

{ return as<double> (x); }

float mmx::promote	(	const F &	x,
		const float &
	)			[inline]

Definition at line 51 of file defaults.hpp.

{ return as<float> (x); }

unsigned long long int mmx::promote	(	const F &	x,
		const unsigned long long int &
	)			[inline]

Definition at line 48 of file defaults.hpp.

                                                    {
  return as<unsigned long long int> (x); }

long long int mmx::promote	(	const F &	x,
		const long long int &
	)			[inline]

Definition at line 46 of file defaults.hpp.

{ return as<long long int> (x); }

unsigned long int mmx::promote	(	const F &	x,
		const unsigned long int &
	)			[inline]

Definition at line 43 of file defaults.hpp.

                                               {
  return as<unsigned long int> (x); }

long int mmx::promote	(	const F &	x,
		const long int &
	)			[inline]

Definition at line 41 of file defaults.hpp.

{ return as<long int> (x); }

unsigned int mmx::promote	(	const F &	x,
		const unsigned int &
	)			[inline]

Definition at line 39 of file defaults.hpp.

{ return as<unsigned int> (x); }

int mmx::promote	(	const F &	x,
		const int &
	)			[inline]

Definition at line 37 of file defaults.hpp.

{ return as<int> (x); }

unsigned char mmx::promote	(	const F &	x,
		const unsigned char &
	)			[inline]

Definition at line 35 of file defaults.hpp.

{ return as<unsigned char> (x); }

signed char mmx::promote	(	const F &	x,
		const signed char &
	)			[inline]

Definition at line 33 of file defaults.hpp.

{ return as<signed char> (x); }

char mmx::promote	(	const F &	x,
		const char &
	)			[inline]

Definition at line 31 of file defaults.hpp.

{ return as<char> (x); }

bool mmx::promote	(	const F &	x,
		const bool &
	)			[inline]

Definition at line 29 of file defaults.hpp.

{ return as<bool> (x); }

T promote	(	const F &	x,
		const T &	y
	)			[inline]

Definition at line 722 of file type_props.hpp.

References set_as(), and T.

Referenced by accuracy_cst(), acosh(), asinh(), atan2(), atanh(), binpow(), catalan_cst(), clear(), common_part(), cosh(), euler_cst(), fuzz_cst(), imaginary_cst(), infinity_cst(), invert(), is_exact_zero(), is_zero(), largest_cst(), log2_cst(), maximal_cst(), minimal_cst(), nan_cst(), promote_scalar_helper< empty_format, F, T >::op(), promote_scalar_helper< FT, F, T >::op(), operator!=(), operator<(), operator<=(), operator==(), operator>(), operator>=(), pi_cst(), powint(), promote(), quo(), rem(), rounding_error(), set_accuracy(), set_imaginary(), set_infinity(), set_nan(), set_pi(), set_smallest(), sinh(), smallest_cst(), and sympow().

                                 {
  T r= y;
  set_as (r, x);
  return r;
}

scalar_type_helper< T >::val mmx::promote_scalar	(	const F &	x,
		const T &	y
	)			[inline]

Definition at line 562 of file type_props.hpp.

References T.

Referenced by zero_scalar().

                                        {
  return promote_scalar_helper<typename format<T>::FT,F,T>::op (x, y);
}

C pull

(

heap< C > &

h

)

[inline]

Definition at line 191 of file heap.hpp.

Referenced by heap_iterator_rep< C >::advance(), binary_test(), operator>>(), unary_hash(), and binary_helper< heap< C > >::write().

                             {
  h.secure(); return h.rep->Pull (); }

void push	(	heap< C > &	h,
		const C &	x
	)			[inline]

Definition at line 189 of file heap.hpp.

Referenced by binary_helper< heap< C > >::assemble(), operator<<(), and binary_helper< heap< C > >::read().

                                            {
  h.secure(); h.rep->Push (x); }

routine mmx::quaternary_routine	(	const generic &	name,
		D(*)(const S1 &, const S2 &, const S3 &, const S4 &)	f
	)			[inline]

Definition at line 368 of file routine.hpp.

Referenced by define().

                                                                        {
  return new quaternary_routine_rep<D,S1,S2,S3,S4> (name, f);
}

routine mmx::quintary_routine	(	const generic &	name,
		D(*)(const S1 &, const S2 &, const S3 &, const S4 &, const S5 &)	f
	)			[inline]

Definition at line 429 of file routine.hpp.

Referenced by define().

                                                 {
  return new quintary_routine_rep<D,S1,S2,S3,S4,S5> (name, f);
}

vector<C,V> mmx::quo	(	const vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 1102 of file vector.hpp.

                                              {
  return binary_map_scalar<rquo_op> (v, c); }

vector<C,V> mmx::quo	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1078 of file vector.hpp.

                                                   {
  return binary_map<quo_op> (v, w); }

table<C,T,V> mmx::quo	(	const table< C, T, V > &	t,
		const K &	sc
	)			[inline]

Definition at line 656 of file table.hpp.

                                  {
  return binary_map_scalar<rquo_op> (t, sc); }

table<C,T,V> mmx::quo	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 631 of file table.hpp.

                                                       {
  return binary_map<quo_op,C,T,V> (t, u); }

new_table<C,T,V> mmx::quo	(	const new_table< C, T, V > &	t,
		const K &	sc
	)			[inline]

Definition at line 727 of file new_table.hpp.

                                  {
  return binary_map_scalar<rquo_op> (t, sc); }

new_table<C,T,V> mmx::quo	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 702 of file new_table.hpp.

                                                       {
  return binary_map<quo_op,C,T,V> (t, u); }

unsigned long long int mmx::quo	(	const unsigned long long int &	n,
		const unsigned long long int &	m
	)			[inline]

Definition at line 574 of file int.hpp.

{

unsigned long int mmx::quo	(	const unsigned long int &	n,
		const unsigned long int &	m
	)			[inline]

Definition at line 573 of file int.hpp.

{

unsigned int mmx::quo	(	const unsigned int &	n,
		const unsigned int &	m
	)			[inline]

Definition at line 572 of file int.hpp.

{

unsigned short int mmx::quo	(	const unsigned short int &	n,
		const unsigned short int &	m
	)			[inline]

Definition at line 571 of file int.hpp.

{

unsigned char mmx::quo	(	const unsigned char &	n,
		const unsigned char &	m
	)			[inline]

Definition at line 570 of file int.hpp.

{

long long int mmx::quo	(	const long long int &	n,
		const long long int &	m
	)			[inline]

Definition at line 561 of file int.hpp.

{ return (m % n) == 0; } \

long int mmx::quo	(	const long int &	n,
		const long int &	m
	)			[inline]

Definition at line 560 of file int.hpp.

{ return (m % n) == 0; } \

int mmx::quo	(	const int &	n,
		const int &	m
	)			[inline]

Definition at line 559 of file int.hpp.

{ return (m % n) == 0; } \

short int mmx::quo	(	const short int &	n,
		const short int &	m
	)			[inline]

Definition at line 558 of file int.hpp.

{ return (m % n) == 0; } \

signed char mmx::quo	(	const signed char &	n,
		const signed char &	m
	)			[inline]

Definition at line 557 of file int.hpp.

{ return (m % n) == 0; } \

generic quo	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 709 of file generic.cpp.

References current_ev, and GEN_DIV.

                                                   {
  return current_ev->apply (GEN_DIV, x1, x2); }

C mmx::quo	(	const C &	x,
		const D &	y
	)			[inline]

Definition at line 270 of file defaults.hpp.

References promote().

Referenced by quo_op::def(), GLUE_11(), rquo_op::op(), quo_op::op(), rquo_op::set_op(), quo_op::set_op(), and skew_quo().

                             { // NOTE: by default we divide on the right
  if (y == promote (0, y)) return promote (0, x); else return x/y; }

string mmx::quote

(

const string &

obj->lex_string

)

Definition at line 530 of file string.cpp.

References escape().

                        {
  return "\"" * escape (s) * "\"";
}

string mmx::quote

(

const string &

s

)

Check whether @ s is quoted.

Referenced by as_lisp(), input_output_string_port_rep::expression(), input_string_port_rep::expression(), output_string_port_rep::expression(), error_port_rep::expression(), flatten(), GLUE_20(), and texmacs_to_scheme().

vector<typename unary_return_type_helper<radius_op, C >::RET,V> mmx::radius

(

const vector< C, V > &

v

)

[inline]

Definition at line 1347 of file vector.hpp.

                                            {
  return unary_map<radius_op> (v); }

unary_return_type_helper<abs_op, C >::RET mmx::radius

(

const C &

x

)

[inline]

Definition at line 1093 of file type_props.hpp.

{ return 0; }

syntactic radius

(

const syntactic &

g1

)

Definition at line 461 of file syntactic.cpp.

References GEN_RADIUS, and syn().

{ return syn (GEN_RADIUS, g1); }

generic radius

(

const generic &

x1

)

Definition at line 823 of file generic.cpp.

References current_ev.

Referenced by radius_op::Radius_type(), and radius_op::set_op().

                                   {
  return current_ev->apply ("radius", x1); }

vector<C,V> mmx::range	(	const vector< C, V > &	v,
		nat	start,
		nat	end
	)			[inline]

Definition at line 578 of file vector.hpp.

References C, CF(), copy(), is_a_scalar(), n, seg(), Vector, and VERIFY.

                                            {
  typedef implementation<vector_linear,V> Vec;
  VERIFY(end >= start, "bad range");
  nat n= end - start;
  if (is_a_scalar (v)) return Vector (v.scalar(), n);
  nat l= aligned_size<C,V> (n);
  C* a= mmx_formatted_new<C> (l, CF(v));
  Vec::copy (a, seg (v) + start, n);
  return Vector (a, n, l, CF(v));
}

list<C> mmx::range	(	const list< C > &	l,
		nat	start,
		nat	end
	)			[inline]

Return a copy of the sublist of l from positions start to end.

Definition at line 306 of file list.hpp.

References ASSERT, car(), cdr(), cons(), is_nil(), List, and range().

                                          {
  if (start >= end) return List ();
  ASSERT (!is_nil (l), "non-empty list expected");
  if (start > 0) return range (cdr (l), start-1, end-1);
  return cons (car (l), range (cdr (l), 0, end-1));
}

generic range	(	const generic &	g,
		nat	start,
		nat	end
	)

Definition at line 24 of file generic_utils.cpp.

References compound_to_vector(), range(), and vector_to_compound().

                                             {
  return vector_to_compound (range (compound_to_vector (g), start, end));
}

chain<C> mmx::range	(	const chain< C > &	c,
		nat	start,
		nat	end
	)			[inline]

Definition at line 335 of file chain.hpp.

References ASSERT, C, Chain, is_nil(), left(), middle(), N(), n, and right().

Referenced by cDr(), cdr(), detach(), GLUE_7(), GLUE_8(), range(), store_interactive_number(), and vector_range().

                                           {
  if (start >= end) return Chain ();
  ASSERT (!is_nil (c), "non-empty chain expected");
  nat n= N (left (c));
  if (end <= n) return range (left (c), start, end);
  if (start > n) return range (right (c), start-n-1, end-n-1);
  Chain l= range (left (c), start, n);
  C     m= middle (c);
  Chain r= range (right (c), 0, end-n-1);
  if (N(l) < 2*(N(r) + 1) && N(r) < 2*(N(l) + 1)) return Chain (l, m, r);
  return l * Chain (m) * r;
}

iterator<C> mmx::range_iterator	(	const C &	start,
		const C &	end,
		const C &	step = outplace_set_as<C> (1),
		bool	strict = true
	)			[inline]

Definition at line 352 of file iterator.hpp.

References Iterator.

Referenced by downwards_range(), iterator_downwards_range(), iterator_natural_range(), iterator_strict_range(), natural_range(), and strict_range().

{
  return Iterator (new range_iterator_rep<C> (start, end, step, strict));
}

void mmx::raw_read	(	M &	m,
		const char *	p,
		nat	n
	)			[inline]

Definition at line 1001 of file type_props.hpp.

References busy(), and VERIFY.

Referenced by raw_read_length().

                                      {
  for (nat i=0; i<n; i++) {
    VERIFY (busy (m), "read failed");
    m >> p[i];
  }
}

void mmx::raw_read_length	(	M &	m,
		nat &	l
	)			[inline]

Definition at line 1018 of file type_props.hpp.

References raw_read().

                               {
  char c;
  m >> c;
  if (c != ((char) 255)) l= (nat) ((uchar) c);
  else raw_read (m, (char*) ((void)* (&l)), sizeof (nat));
}

void mmx::raw_write	(	M &	m,
		const char *	p,
		nat	n
	)			[inline]

Definition at line 996 of file type_props.hpp.

Referenced by raw_write_length().

                                       {
  for (nat i=0; i<n; i++) m << p[i];
}

void mmx::raw_write_length	(	M &	m,
		nat	l
	)			[inline]

Definition at line 1009 of file type_props.hpp.

References raw_write().

                               {
  if (l < (nat) 255) m << ((char) l);
  else {
    m << ((char) 255);
    raw_write (m, (const char*) ((const void*) (&l)), sizeof (nat));
  }
}

vector<typename unary_return_type_helper<Re_op, C >::RET,V> mmx::Re

(

const vector< C, V > &

v

)

[inline]

Definition at line 1341 of file vector.hpp.

{ return unary_map<Re_op> (v); }

syntactic Re

(

const syntactic &

g1

)

Definition at line 450 of file syntactic.cpp.

References GEN_RE, and syn().

{ return syn (GEN_RE, g1); }

generic Re

(

const generic &

x1

)

Definition at line 734 of file generic.cpp.

References current_ev, and GEN_RE.

                               {
  return current_ev->apply (GEN_RE, x1); }

C mmx::Re

(

const C &

x

)

[inline]

Definition at line 716 of file defaults.hpp.

Referenced by Re_op::op(), Re_op::Real_type(), and Re_op::set_op().

{ return x; }

const C& mmx::read	(	const vector< C, V > &	v,
		nat	i
	)			[inline]

Definition at line 214 of file vector.hpp.

{ return v[i]; }

const C& mmx::read	(	const table< C, T, V > &	t,
		const T &	x
	)			[inline]

Definition at line 176 of file table.hpp.

                                                       {
  return t[x]; }

const C& mmx::read	(	const table< C, T, V > &	t,
		const K &	x
	)			[inline]

Definition at line 165 of file table.hpp.

                                                        {
  return t[as<T> (x)]; }

string mmx::read	(	const storage &	st,
		const string &	var
	)			[inline]

Set variable var to val on storage st.

Definition at line 69 of file storage.hpp.

                                                          {
  return st->read (var); }

string mmx::read	(	const port &	p,
		nat	n
	)			[inline]

Definition at line 113 of file port.hpp.

References inside().

                                          {
  string r (n); inside (p)->read (inside (r, 0), n); return r; }

void mmx::read	(	const port &	p,
		char *	s,
		nat	n
	)			[inline]

Definition at line 111 of file port.hpp.

References inside().

                                                 {
  inside (p)->read (s, n); }

const C& mmx::read	(	const new_table< C, T, V > &	t,
		const T &	x
	)			[inline]

Definition at line 198 of file new_table.hpp.

                                                       {
  return t[x]; }

const C& mmx::read	(	const new_table< C, T, V > &	t,
		const K &	x
	)			[inline]

Definition at line 187 of file new_table.hpp.

                                                        {
  return t[as<T> (x)]; }

const C& mmx::read	(	const list< C > &	l,
		nat	i
	)			[inline]

The same as l[i].

Definition at line 157 of file list.hpp.

{ return l[i]; }

C mmx::read	(	const cache< C, T > &	c,
		const T &	x
	)			[inline]

Definition at line 74 of file cache.hpp.

Referenced by inspector< compound >::access(), alias_getter(), alias_setter(), alias_specializer(), alias_type_info(), binary_read(), binary_read_generic(), binary_rr(), composed_routine_rep::composed_routine_rep(), alias_binary_access_rep< C, R, A, B >::get(), alias_unary_access_rep< C, R, A >::get(), get_file_source(), GLUE_11(), GLUE_17(), GLUE_5(), operator>>(), binary_helper< format< T > >::read(), binary_helper< string >::read(), binary_helper< bool >::read(), source_locate(), tuple_type_info(), and unary_set().

                                                {
  return read (*c, x); }

const C& mmx::read_car

(

const list< C > &

l

)

[inline]

The same as car.

Definition at line 142 of file list.hpp.

References car().

Referenced by binary_test(), table_rep< C, T, V >::contains(), table_iterator_rep< C, T, V >::current(), entries_iterator_rep< C, T, V >::current(), list_iterator_rep< C >::current(), memoizer< V >::end(), flatten(), table_rep< C, T, V >::get(), list_apply(), table_rep< C, T, V >::reset(), table_rep< C, T, V >::resize(), restore_evaluator(), reverse(), table_rep< C, T, V >::set(), table_rep< C, T, V >::simplify(), and unary_hash().

{ return car (l); }

const list<C>& mmx::read_cdr

(

const list< C > &

l

)

[inline]

The same as cdr.

Definition at line 147 of file list.hpp.

References cdr().

Referenced by table_iterator_rep< C, T, V >::advance(), entries_iterator_rep< C, T, V >::advance(), list_iterator_rep< C >::advance(), binary_test(), table_rep< C, T, V >::contains(), memoizer< V >::end(), flatten(), table_rep< C, T, V >::get(), list_apply(), table_rep< C, T, V >::reset(), table_rep< C, T, V >::resize(), restore_evaluator(), reverse(), table_rep< C, T, V >::simplify(), and unary_hash().

{ return cdr (l); }

const C & read_I

(

const table< C, T, V > &

t

)

[inline]

Definition at line 221 of file table.hpp.

                        {
  t->lazy_initialize ();
  return *t->init;
}

const C & read_I

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 238 of file new_table.hpp.

Referenced by unary_set().

                        {
  t->lazy_initialize ();
  return *t->init;
}

static bool mmx::read_line	(	string	prompt,
		string &	sline
	)			[static]

Definition at line 72 of file terminal_interface.cpp.

References as_charp(), blue_foreground, bold, charcode_as_string(), cyan_foreground, flush_now, formatting_port(), free_charp(), line, mmout, output_string_port(), and reset_attributes.

Referenced by shell_terminal_input().

                                         {
  char* line;
  string buf = "";
  port p = formatting_port (output_string_port (buf));
  p << charcode_as_string (RL_PROMPT_START_IGNORE)
    << bold << blue_foreground
    << charcode_as_string (RL_PROMPT_END_IGNORE)
    << prompt
    << charcode_as_string (RL_PROMPT_START_IGNORE)
    << reset_attributes
    << cyan_foreground
    << charcode_as_string (RL_PROMPT_END_IGNORE);
  char* _prompt = as_charp (buf);
  line = readline (_prompt);
  free_charp (_prompt);
  mmout << reset_attributes << flush_now;
  if (line == NULL) {
    sline = "";
    return false;
  }
  sline = string(line);
  free (line);
  return true;
}

const C& mmx::read_only

(

const C &

c

)

[inline]

Definition at line 762 of file defaults.hpp.

Referenced by list< cleaner >::operator[]().

                       {
  return c;
}

static bool mmx::reads	(	const string &	obj->lex_string,
		nat(obj->lex_pos)	,
		const string &	what
	)			[static]

Definition at line 548 of file string.cpp.

References N().

Referenced by replace(), search_backwards(), and search_forwards().

                                                     {
  nat i, n= N(s), l= N(what);
  for (i=0; pos+i<n && i<l; i++)
    if (s[pos+i] != what[i]) return false;
  return i == l;
}

static generic mmx::rebuild

(

const vector< generic > &

v

)

[static]

Definition at line 20 of file glue_vector_map.cpp.

References apply(), eval(), is_a_scalar(), and vector< C, V >::scalar().

                                   {
  if (is_a_scalar (v)) {
    generic make_vector= eval ("scalar_vector");
    return as<routine> (make_vector) -> apply (vec<generic> (v.scalar()));
  }
  else {
    generic make_vector= eval ("vector");
    return as<routine> (make_vector) -> apply (v);
  }
}

static generic mmx::rebuild

(

const list< generic > &

l

)

[static]

Definition at line 30 of file glue_list_map.cpp.

References apply(), and eval().

Referenced by list_append_several(), list_map(), vector_append_several(), and vector_map().

                                 {
  generic make_list= eval ("list");
  return as<routine> (make_list) -> apply (as_vector<generic> (l));
}

string recompose	(	const vector< string > &	v,
		const string &	sep,
		bool	last = true
	)

Reconstruct string from pieces in using as a separator.

Definition at line 609 of file string.cpp.

References N().

Referenced by add_indentation(), get_file_source(), get_interactive_source(), shell_terminal_input(), and shell_texmacs_input().

                                                                  {
  string s;
  for (nat i=0; i<N(v); i++) {
    s << v[i];
    if (i+1 < N(v) || last) s << sep;
  }
  return s;
}

vector<typename unary_return_type_helper<reconstruct_op, C >::RET> mmx::reconstruct

(

const vector< C, V > &

v

)

[inline]

Definition at line 1271 of file vector.hpp.

                                                        {
  return as<Reconstructed_vector> (unary_map<reconstruct_op> (v)); }

bool mmx::reconstruct	(	signed_of_helper< unsigned long long int >::type &	n,
		signed_of_helper< unsigned long long int >::type &	d,
		const unsigned long long int &	u,
		const unsigned long long int &	m
	)			[inline]

Definition at line 805 of file int.hpp.

{

bool mmx::reconstruct	(	signed_of_helper< unsigned long long int >::type &	n,
		signed_of_helper< unsigned long long int >::type &	d,
		const unsigned long long int &	u,
		const unsigned long long int &	m,
		const unsigned long long int &	N,
		const unsigned long long int &	D
	)			[inline]

Definition at line 805 of file int.hpp.

{

bool mmx::reconstruct	(	signed_of_helper< unsigned long int >::type &	n,
		signed_of_helper< unsigned long int >::type &	d,
		const unsigned long int &	u,
		const unsigned long int &	m
	)			[inline]

Definition at line 804 of file int.hpp.

{

bool mmx::reconstruct	(	signed_of_helper< unsigned long int >::type &	n,
		signed_of_helper< unsigned long int >::type &	d,
		const unsigned long int &	u,
		const unsigned long int &	m,
		const unsigned long int &	N,
		const unsigned long int &	D
	)			[inline]

Definition at line 804 of file int.hpp.

{

bool mmx::reconstruct	(	signed_of_helper< unsigned int >::type &	n,
		signed_of_helper< unsigned int >::type &	d,
		const unsigned int &	u,
		const unsigned int &	m
	)			[inline]

Definition at line 803 of file int.hpp.

{

bool mmx::reconstruct	(	signed_of_helper< unsigned int >::type &	n,
		signed_of_helper< unsigned int >::type &	d,
		const unsigned int &	u,
		const unsigned int &	m,
		const unsigned int &	N,
		const unsigned int &	D
	)			[inline]

Definition at line 803 of file int.hpp.

{

bool mmx::reconstruct	(	signed_of_helper< unsigned short int >::type &	n,
		signed_of_helper< unsigned short int >::type &	d,
		const unsigned short int &	u,
		const unsigned short int &	m
	)			[inline]

Definition at line 802 of file int.hpp.

{

bool mmx::reconstruct	(	signed_of_helper< unsigned short int >::type &	n,
		signed_of_helper< unsigned short int >::type &	d,
		const unsigned short int &	u,
		const unsigned short int &	m,
		const unsigned short int &	N,
		const unsigned short int &	D
	)			[inline]

Definition at line 802 of file int.hpp.

{

bool mmx::reconstruct	(	signed_of_helper< unsigned char >::type &	n,
		signed_of_helper< unsigned char >::type &	d,
		const unsigned char &	u,
		const unsigned char &	m
	)			[inline]

Definition at line 801 of file int.hpp.

{

bool mmx::reconstruct	(	signed_of_helper< unsigned char >::type &	n,
		signed_of_helper< unsigned char >::type &	d,
		const unsigned char &	u,
		const unsigned char &	m,
		const unsigned char &	N,
		const unsigned char &	D
	)			[inline]

Definition at line 801 of file int.hpp.

{

bool mmx::reconstruct	(	signed long long int &	n,
		signed long long int &	d,
		const signed long long int &	u,
		const signed long long int &	m
	)			[inline]

Definition at line 754 of file int.hpp.

bool mmx::reconstruct	(	signed long long int &	n,
		signed long long int &	d,
		const signed long long int &	u,
		const signed long long int &	m,
		const signed long long int &	N,
		const signed long long int &	D
	)			[inline]

Definition at line 754 of file int.hpp.

bool mmx::reconstruct	(	signed long int &	n,
		signed long int &	d,
		const signed long int &	u,
		const signed long int &	m
	)			[inline]

Definition at line 753 of file int.hpp.

bool mmx::reconstruct	(	signed long int &	n,
		signed long int &	d,
		const signed long int &	u,
		const signed long int &	m,
		const signed long int &	N,
		const signed long int &	D
	)			[inline]

Definition at line 753 of file int.hpp.

bool mmx::reconstruct	(	signed int &	n,
		signed int &	d,
		const signed int &	u,
		const signed int &	m
	)			[inline]

Definition at line 752 of file int.hpp.

bool mmx::reconstruct	(	signed int &	n,
		signed int &	d,
		const signed int &	u,
		const signed int &	m,
		const signed int &	N,
		const signed int &	D
	)			[inline]

Definition at line 752 of file int.hpp.

bool mmx::reconstruct	(	signed short int &	n,
		signed short int &	d,
		const signed short int &	u,
		const signed short int &	m
	)			[inline]

Definition at line 751 of file int.hpp.

bool mmx::reconstruct	(	signed short int &	n,
		signed short int &	d,
		const signed short int &	u,
		const signed short int &	m,
		const signed short int &	N,
		const signed short int &	D
	)			[inline]

Definition at line 751 of file int.hpp.

bool mmx::reconstruct	(	signed char &	n,
		signed char &	d,
		const signed char &	u,
		const signed char &	m
	)			[inline]

Definition at line 750 of file int.hpp.

bool mmx::reconstruct	(	signed char &	n,
		signed char &	d,
		const signed char &	u,
		const signed char &	m,
		const signed char &	N,
		const signed char &	D
	)			[inline]

Definition at line 750 of file int.hpp.

Referenced by reconstruct_op::Reconstruct_type(), and reconstruct_op::set_op().

static string mmx::recursive_search_name	(	const string &	dir,
		const string &	name,
		bool	is_dir
	)			[static]

Definition at line 606 of file system.cpp.

References canonical_name(), file_exists(), file_is_directory(), file_is_file(), get_directory(), load_directory(), N(), starts(), and strip_directory().

Referenced by semi_recursive_search_name().

                                                                           {
  //mmout << "Recursive search " << dir << ", " << name << "\n";
  if (!file_exists (dir) || !file_is_directory (dir)) return "";
  if (get_directory (name) != ".") {
    string fdir = get_directory (name);
    string fname= strip_directory (name);
    string sdir = recursive_search_name (dir, fdir, true);
    if (sdir == "") return "";
    return recursive_search_name (sdir, fname, is_dir);
  }
  string fname= canonical_name (dir * "/" * name);
  if (file_exists (fname)) {
    if (is_dir && file_is_directory (fname)) return fname;
    if (!is_dir && file_is_file (fname)) return fname;
  }
  if (file_exists (dir * "/mmx") && file_is_directory (dir * "/mmx")) {
    string fdir= canonical_name (dir * "/mmx");
    string sname= recursive_search_name (fdir, name, is_dir);
    if (sname != "") return sname;
  }
  vector<string> v;
  if (load_directory (dir, v)) return "";
  for (nat i=0; i<N(v); i++)
    if (!starts (v[i], ".") && v[i] != "mmx") {
      string fdir= canonical_name (dir * "/" * v[i]);
      if (file_is_directory (fdir)) {
        string sname= recursive_search_name (fdir, name, is_dir);
        if (sname != "") return sname;
      }
    }
  return "";
}

void mmx::register_glue	(	const string &	s,
		void(*)()	f
	)

Definition at line 113 of file glue.cpp.

References glue_table, and inside_set().

                                                   {
  inside_set (glue_table (), s, f);
}

void mmx::register_glue	(	const string &	,
		void(*)(void)
	)

Referenced by glue_basix(), glue_list_map(), and glue_vector_map().

string relative_name	(	const string &	base,
		const string &	name
	)

Definition at line 472 of file system.cpp.

References canonical_name(), is_absolute_name(), and N().

Referenced by mmc_load_directory(), and resolve_name().

                                                       {
  //mmout << "relative_name: " << base << lf;
  string file_name= name;
  if (base != "" && !is_absolute_name (file_name)) {
    int i;
    for (i= N(base)-1; i>=0; i--)
      if (base[i] == '/') break;
    file_name= base (0, i+1) * file_name;
  }
  return canonical_name (file_name);
}

static void mmx::release_lock

(

FILE *

f

)

[static]

Definition at line 48 of file file_port.cpp.

Referenced by file_port_rep::~file_port_rep().

                       {
#if !(defined(__MINGW__) || defined(__MINGW32__))
  struct flock fl;
  int fd= fileno (f);
  fl.l_type   = F_UNLCK;
  fl.l_whence = SEEK_SET;
  fl.l_start  = 0;
  fl.l_len    = 0;
  fl.l_pid    = getpid ();
  fcntl (fd, F_SETLK, &fl);
  //mmout << "Unlocked " << fd << lf;
#endif
}

vector<C,V> mmx::rem	(	const vector< C, V > &	v,
		const C &	c
	)			[inline]

Definition at line 1104 of file vector.hpp.

                                              {
  return binary_map_scalar<rrem_op> (v, c); }

vector<C,V> mmx::rem	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1080 of file vector.hpp.

                                                   {
  return binary_map<rem_op> (v, w); }

table<C,T,V> mmx::rem	(	const table< C, T, V > &	t,
		const K &	sc
	)			[inline]

Definition at line 659 of file table.hpp.

                                  {
  return binary_map_scalar<rrem_op> (t, sc); }

table<C,T,V> mmx::rem	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 633 of file table.hpp.

                                                       {
  return binary_map<rem_op,C,T,V> (t, u); }

new_table<C,T,V> mmx::rem	(	const new_table< C, T, V > &	t,
		const K &	sc
	)			[inline]

Definition at line 730 of file new_table.hpp.

                                  {
  return binary_map_scalar<rrem_op> (t, sc); }

new_table<C,T,V> mmx::rem	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 704 of file new_table.hpp.

                                                       {
  return binary_map<rem_op,C,T,V> (t, u); }

unsigned long long int mmx::rem	(	const unsigned long long int &	n,
		const unsigned long long int &	m,
		unsigned long long int &	q
	)			[inline]

Definition at line 574 of file int.hpp.

{

unsigned long long int mmx::rem	(	const unsigned long long int &	n,
		const unsigned long long int &	m
	)			[inline]

Definition at line 574 of file int.hpp.

{

unsigned long int mmx::rem	(	const unsigned long int &	n,
		const unsigned long int &	m,
		unsigned long int &	q
	)			[inline]

Definition at line 573 of file int.hpp.

{

unsigned long int mmx::rem	(	const unsigned long int &	n,
		const unsigned long int &	m
	)			[inline]

Definition at line 573 of file int.hpp.

{

unsigned int mmx::rem	(	const unsigned int &	n,
		const unsigned int &	m,
		unsigned int &	q
	)			[inline]

Definition at line 572 of file int.hpp.

{

unsigned int mmx::rem	(	const unsigned int &	n,
		const unsigned int &	m
	)			[inline]

Definition at line 572 of file int.hpp.

{

unsigned short int mmx::rem	(	const unsigned short int &	n,
		const unsigned short int &	m,
		unsigned short int &	q
	)			[inline]

Definition at line 571 of file int.hpp.

{

unsigned short int mmx::rem	(	const unsigned short int &	n,
		const unsigned short int &	m
	)			[inline]

Definition at line 571 of file int.hpp.

{

unsigned char mmx::rem	(	const unsigned char &	n,
		const unsigned char &	m,
		unsigned char &	q
	)			[inline]

Definition at line 570 of file int.hpp.

{

unsigned char mmx::rem	(	const unsigned char &	n,
		const unsigned char &	m
	)			[inline]

Definition at line 570 of file int.hpp.

{

long long int mmx::rem	(	const long long int &	n,
		const long long int &	m
	)			[inline]

Definition at line 561 of file int.hpp.

{ return (m % n) == 0; } \

long long int mmx::rem	(	const long long int &	n,
		const long long int &	m,
		long long int &	q
	)			[inline]

Definition at line 561 of file int.hpp.

{ return (m % n) == 0; } \

long int mmx::rem	(	const long int &	n,
		const long int &	m
	)			[inline]

Definition at line 560 of file int.hpp.

{ return (m % n) == 0; } \

long int mmx::rem	(	const long int &	n,
		const long int &	m,
		long int &	q
	)			[inline]

Definition at line 560 of file int.hpp.

{ return (m % n) == 0; } \

int mmx::rem	(	const int &	n,
		const int &	m
	)			[inline]

Definition at line 559 of file int.hpp.

{ return (m % n) == 0; } \

int mmx::rem	(	const int &	n,
		const int &	m,
		int &	q
	)			[inline]

Definition at line 559 of file int.hpp.

{ return (m % n) == 0; } \

short int mmx::rem	(	const short int &	n,
		const short int &	m
	)			[inline]

Definition at line 558 of file int.hpp.

{ return (m % n) == 0; } \

short int mmx::rem	(	const short int &	n,
		const short int &	m,
		short int &	q
	)			[inline]

Definition at line 558 of file int.hpp.

{ return (m % n) == 0; } \

signed char mmx::rem	(	const signed char &	n,
		const signed char &	m
	)			[inline]

Definition at line 557 of file int.hpp.

{ return (m % n) == 0; } \

signed char mmx::rem	(	const signed char &	n,
		const signed char &	m,
		signed char &	q
	)			[inline]

Definition at line 557 of file int.hpp.

{ return (m % n) == 0; } \

generic rem	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 711 of file generic.cpp.

References current_ev, and GEN_MOD.

                                                   {
  return current_ev->apply (GEN_MOD, x1, x2); }

C mmx::rem	(	const C &	x,
		const D &	y
	)			[inline]

Definition at line 273 of file defaults.hpp.

References promote().

Referenced by GLUE_12(), rrem_op::op(), rem_op::op(), unsigned_int_reconstruct_helper< U >::reconstruct(), int_reconstruct_helper< I >::reconstruct(), rrem_op::set_op(), rem_op::set_op(), and skew_rem().

                             { // NOTE: by default we divide on the right
  if (y == promote (0, y)) return x; else return promote (0, x); }

vector<C,V> mmx::remove	(	const vector< C, V > &	v,
		vector< nat >	e
	)			[inline]

Definition at line 608 of file vector.hpp.

References N(), n, and Vector.

Referenced by var_rm().

                                        {
  nat n= N(v);
  vector<nat> f ((nat) 0, n);
  for (nat i= 0; i < n; i++) f[i]= i;
  for (nat i= 0; i < N(e); i++) if (e[i] < n) f[e[i]]= n;
  Vector r;
  for (nat i= 0; i < n; i++) {
    if (f[i] == n) continue;
    r << v[i];
  }
  return r;
}

string repeated	(	const string &	obj->lex_string,
		nat(obj->lex_length)
	)

Definition at line 623 of file string.cpp.

Referenced by add_indentation(), and source_string_unindented().

                                  {
  string r;
  for (nat i=0; i<n; i++) r << s;
  return r;
}

string mmx::replace	(	const string &	obj->lex_string,
		const string &	what,
		const string &	by
	)

Definition at line 556 of file string.cpp.

References N(), and reads().

                                                                {
  nat i, n= N(s);
  string r;
  for (i=0; i<n; )
    if (reads (s, i, what)) { r << by; i += N(what); }
    else r << s[i++];
  return r;
}

string mmx::replace	(	const string &	s,
		const string &	what,
		const string &	by
	)

Replace all the occurences of what by in s.

Referenced by GLUE_13().

generic mmx::replace_lf

(

const generic &

g

)

Definition at line 360 of file mmx_texmacs.cpp.

References ERROR, gen(), is_func(), mmout, N(), and type_name().

Referenced by as_snippet(), as_texmacs_scheme(), and as_texmacs_snippet().

                              {
  if (is<literal> (g)) return g;
  else if (is_func (g, "$concat")) {
    bool block= false;
    vector<generic> d;
    vector<generic> c;
    for (nat i=1; i<N(g); i++) {
      if (is_func (g[i], "$lf", 0)) {
        if (N(c) == 0) d << generic ("");
        else if (N(c) == 1) d << c;
        else if (N(c) > 1) d << gen ("$concat", c);
        c= vector<generic> ();
      }
      else if (is_func (g[i], "$cr", 0)) block= true;
      else c << replace_lf (g[i]);
    }
    if (N(c) == 1) d << c;
    else if (N(c) != 0) d << gen ("$concat", c);
    if (N(d) != 1 || block) return gen ("$document", d);
    return d[0];
  }
  else if (is<compound> (g)) {
    vector<generic> v;
    for (nat i=1; i<N(g); i++)
      v << replace_lf (g[i]);
    return gen (g[0], v);
  }
  else {
    mmout << "g= " << g << ": " << type_name (g) << "\n";
    ERROR ("TeXmacs document expected");
  }
}

void mmx::reset	(	table< C, T, V > &	t,
		const T &	x
	)			[inline]

Definition at line 178 of file table.hpp.

References inside(), and reset().

                                              {
  t.secure(); inside (t) -> reset (x); }

void mmx::reset	(	table< C, T, V > &	t,
		const K &	x
	)			[inline]

Definition at line 167 of file table.hpp.

References inside(), and reset().

                                               {
  t.secure(); inside (t) -> reset (as<T> (x)); }

void mmx::reset	(	new_table< C, T, V > &	t,
		const T &	x
	)			[inline]

Definition at line 200 of file new_table.hpp.

References inside(), and reset().

                                              {
  t.secure(); inside (t) -> reset (x); }

void mmx::reset	(	new_table< C, T, V > &	t,
		const K &	x
	)			[inline]

Definition at line 189 of file new_table.hpp.

References inside(), and reset().

                                               {
  t.secure(); inside (t) -> reset (as<T> (x)); }

void mmx::reset	(	cache< C, T > &	c,
		const T &	x
	)			[inline]

Definition at line 70 of file cache.hpp.

Referenced by alias_reset(), reset(), source_delete(), table_reset(), ttable_reset(), unary_set(), and posix_port_rep::~posix_port_rep().

                                              {
  reset (*c, x); }

string resolve_name	(	const string &	base,
		const string &	name
	)

Definition at line 675 of file system.cpp.

References ancestor_search_name(), file_exists(), get_directory(), load_path(), N(), path_sep, pos, relative_name(), search_backwards(), semi_recursive_search_name(), starts(), and tokenize().

                                                      {
  //mmout << "Resolve " << base << ", " << name << "\n";
  if (name != "" && name[0] == '.')
    return resolve_name (base, string ("$PWD") * name (1, N(name)));
  string name_bis= name;
#if defined(__MINGW__) || defined(__MINGW32__)
  int pos= search_backwards (name, ":", N(name));
  if (pos > 1) name_bis= name (pos-1, N(name)); else {
    if (name != "" && name[0] == '/') name_bis= "/" * name; }
#else
  if (name != "" && name[0] == '/') name_bis= "/" * name;
#endif
  string r= relative_name (base, name_bis);
  if (file_exists (r) || starts (name_bis, "//")) return r;
  r= ancestor_search_name (get_directory (base), name_bis);
  if (r != "") return r;
  vector<string> v= tokenize (load_path (), string (path_sep), false);
  for (nat i=0; i<N(v); i++)
    if (v[i] != ".") {
      r= semi_recursive_search_name (v[i], name_bis);
      if (r != "") return r;
    }
  return "";
}

void restore_evaluator

(

)

Definition at line 79 of file evaluator.cpp.

References ASSERT, current_ev, is_nil(), read_car(), read_cdr(), and stack_ev.

                     {
  //assert (!ev_lock);
  //ev_lock= true;
  //{
  ASSERT (!is_nil (stack_ev), "empty evaluator stack");
  /*
    if (N(stack_ev) < 6)
    mmout << "[" << N (stack_ev)-1
    << ":" << inside (current_ev)
    << "-" << inside (car (stack_ev))
    << "]" << flush_now;
  */
  evaluator aux_ev= current_ev; // only destroy current_ev on exit
  current_ev= read_car (stack_ev);
  stack_ev  = read_cdr (stack_ev);
  //}
  //ev_lock= false;
}

observer mmx::result_observer	(	dynamic_rep *	arg,
		const updater &	u
	)

Definition at line 169 of file dynamic.cpp.

Referenced by dynamic::dynamic().

                                                     {
  return observer (new result_observer_rep (arg, u));
}

vector<string> mmx::retrieve_branches

(

const storage &

st

)

[inline]

Retrieve all variables for storage st.

Definition at line 95 of file storage.hpp.

                                                            {
  return st->retrieve_branches (); }

vector<generic> mmx::retrieve_branches_bis

(

const storage &

st

)

[inline]

Retrieve all variables for storage st.

Definition at line 105 of file storage.hpp.

Referenced by GLUE_13().

                                                                 {
  return as<vector<generic> > (st->retrieve_branches ()); }

vector<string> mmx::retrieve_data

(

const storage &

st

)

[inline]

Check whether the storage admits a shadow for the file orig.

Definition at line 92 of file storage.hpp.

                                                        {
  return st->retrieve_data (); }

vector<generic> mmx::retrieve_data_bis

(

const storage &

st

)

[inline]

Retrieve all files for storage st.

Definition at line 102 of file storage.hpp.

Referenced by GLUE_12().

                                                             {
  return as<vector<generic> > (st->retrieve_data ()); }

vector<string> mmx::retrieve_files

(

const storage &

st

)

[inline]

Retrieve all branches for storage st.

Definition at line 98 of file storage.hpp.

                                                         {
  return st->retrieve_files (); }

vector<generic> mmx::retrieve_files_bis

(

const storage &

st

)

[inline]

Retrieve all branches for storage st.

Definition at line 108 of file storage.hpp.

Referenced by GLUE_14().

                                                              {
  return as<vector<generic> > (st->retrieve_files ()); }

string mmx::reverse

(

const string &

obj->lex_string

)

Definition at line 580 of file string.cpp.

References N().

                          {
  nat i, n= N(s);
  string r (n);
  for (i=0; i<n; i++) r[i]= s[n-1-i];
  return r;
}

vector<C,V> mmx::reverse

(

const vector< C, V > &

v

)

[inline]

Definition at line 694 of file vector.hpp.

References C, CF(), is_a_scalar(), N(), n, seg(), and Vector.

                          {
  typedef implementation<vector_linear,V> Vec;
  if (is_a_scalar (v)) return v;
  nat n= N(v);
  nat l= aligned_size<C,V> (n);
  C* a= mmx_formatted_new<C> (l, CF(v));
  Vec::vec_reverse (a, seg (v), n);
  return Vector (a, n, l, CF(v));
}

table<T,C,V> mmx::reverse

(

const table< C, T, V > &

t

)

[inline]

Definition at line 749 of file table.hpp.

References busy(), CF1(), CF2(), entries(), and simplify().

                         {
  table<T,C,V> r (CF2 (t), CF1 (t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    r[t[*it]]= *it;
  simplify (r);
  return r;
}

string mmx::reverse

(

const string &

s

)

Reverse the order of the characters in s.

new_table<T,C,V> mmx::reverse

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 820 of file new_table.hpp.

References busy(), CF1(), CF2(), entries(), and simplify().

                         {
  table<T,C,V> r (CF2 (t), CF1 (t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    r[t[*it]]= *it;
  simplify (r);
  return r;
}

list<C> mmx::reverse

(

const list< C > &

ll

)

[inline]

Return the reversed list of l.

Definition at line 295 of file list.hpp.

References cons(), is_nil(), List, read_car(), and read_cdr().

                         {
  List l= ll, r;
  while (!is_nil (l)) {
    r= cons (read_car (l), r);
    l= read_cdr (l);
  }
  return r;
}

chain<C> mmx::reverse

(

const chain< C > &

c

)

[inline]

Definition at line 201 of file chain.hpp.

References Chain, is_nil(), left(), middle(), and right().

Referenced by GLUE_15(), GLUE_8(), GLUE_9(), reverse_op::op(), and reverse_op::set_op().

                         {
  if (is_nil (c)) return c;
  return Chain (reverse (right (c)), middle (c), reverse (left (c)));
}

chain< C > right

(

const chain< C > &

c

)

[inline]

Definition at line 133 of file chain.hpp.

Referenced by balance_left(), balance_right(), binary_test(), cAr(), cDr(), cdr(), copy(), binary_helper< chain< C > >::disassemble(), iterate(), map(), operator*(), range(), reverse(), shift_left(), shift_right(), unary_hash(), and binary_helper< chain< C > >::write_bis().

{ return c.rep->r; }

generic round

(

const generic &

x

)

Definition at line 755 of file generic.cpp.

References current_ev, and GEN_ROUND.

                                 {
  return current_ev->apply (GEN_ROUND, x); }

double round

(

const double &

x

)

[inline]

Definition at line 132 of file double.hpp.

References floor().

Referenced by round_op::op(), and round_op::set_op().

{ return std::floor (x + 0.5); }

unary_return_type_helper<abs_op, C >::RET mmx::rounding_error

(

const C &

x

)

[inline]

Definition at line 1069 of file type_props.hpp.

References abs(), and promote().

                                                                    {
  return promote (0, abs (x)); }

generic rounding_error

(

const generic &

x

)

Definition at line 772 of file generic.cpp.

References current_ev, and GEN_ROUNDING_ERROR.

                                          {
  return current_ev->apply (GEN_ROUNDING_ERROR, x); }

double rounding_error

(

const double &

x

)

[inline]

Referenced by rounding_error_op::Abs_type(), additive_error(), elementary_error(), GLUE_51(), multiplicative_error(), and rounding_error_op::set_op().

generic rres	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 844 of file generic.cpp.

References current_ev.

                                                    {
  return current_ev->apply ("rres", x1, x2); }

void mmx::rshift2	(	C &	x,
		const C &	y,
		const S &	z
	)			[inline]

Definition at line 304 of file defaults.hpp.

{ x= y >> z; }

C mmx::rshift2

(

const C &

x

)

[inline]

Definition at line 300 of file defaults.hpp.

{ return rshift2<C,int> (x, 1); }

C mmx::rshift2	(	const C &	x,
		const S &	y
	)			[inline]

Definition at line 298 of file defaults.hpp.

Referenced by rshift2_op::op(), and rshift2_op::set_op().

{ return x >> y; }

void mmx::rshift2_assign	(	C &	x,
		const S &	y
	)			[inline]

Definition at line 302 of file defaults.hpp.

Referenced by rshift2_op::set_op().

{ x >>= y; }

syntactic rshiftz	(	const syntactic &	g,
		const syntactic &	sh
	)

Definition at line 473 of file syntactic.cpp.

References syn().

                                                            {
  return syn ("rshiftz", g, sh); }

generic rshiftz	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 836 of file generic.cpp.

References current_ev.

                                                       {
  return current_ev->apply ("rshiftz", x1, x2); }

void mmx::rshiftz	(	C &	x,
		const C &	y,
		const S &	z
	)			[inline]

Definition at line 321 of file defaults.hpp.

References lshiftz().

{ lshiftz (x, y, -z); }

C mmx::rshiftz

(

const C &

x

)

[inline]

Definition at line 317 of file defaults.hpp.

{ return rshiftz<C,int> (x, 1); }

C mmx::rshiftz	(	const C &	x,
		const S &	y
	)			[inline]

Definition at line 315 of file defaults.hpp.

References lshiftz().

Referenced by sqrt_op::def(), quo_op::def(), div_op::def(), invert_op::def(), rshiftz_op::op(), and rshiftz_op::set_op().

{ return lshiftz (x, -y); }

void mmx::rshiftz_assign	(	C &	x,
		const S &	y = 1
	)			[inline]

Definition at line 319 of file defaults.hpp.

References lshiftz_assign().

Referenced by rshiftz_op::set_op().

{ lshiftz_assign (x, -y); }

void mmx::safe_free

(

register void *

ptr

)

[inline]

Definition at line 126 of file fast_new.hpp.

Referenced by mmx_free_thread_unsafe().

                               {
  //printf ("Free : %p, %p\n", ptr,
  //        *((void**) ((void*) (((char*) ptr) - sizeof (void*)))));
  free (*((void**) ((void*) (((char*) ptr) - sizeof (void*)))));
}

void * safe_malloc

(

register size_t

sz

)

Definition at line 34 of file fast_new.cpp.

Referenced by enlarge_malloc(), and mmx_malloc_thread_unsafe().

                                 {
  // Always guarantees 16 byte alignment
  register char* ret;
  register char* ptr= (char*) malloc (sz + 16);
  if (ptr == NULL) {
    fprintf (stderr, "Fatal error: out of memory\n");
    assert (false);
    exit (1);
  }
  ret= ptr + (16 - (((nat) ((uintptr_t) ((void*) ptr))) & 15));
  //printf ("Alloc: %lx, %lx\n",
  //        (uintptr_t) (void*) ret, (uintptr_t) (void*) ptr);
  *((void**) ((void*) (ret - sizeof (void*))))= (void*) ptr;
  return (void*) ret;
}

bool mmx::same_type	(	const generic &	x1,
		const generic &	x2
	)			[inline]

Definition at line 184 of file generic.hpp.

Referenced by convert(), exact_eq(), and operator==().

                                                             {
  return x1->same_type (x2); }

bool mmx::save	(	const string &	orig_file_name,
		const string &	obj->lex_string
	)

Definition at line 755 of file system.cpp.

References decode_name(), error_flag(), and output_file_port().

                                                     {
  string file_name= decode_name (orig_file_name);
  port f= output_file_port (file_name);
  if (error_flag (f)) return true;
  f << s;
  return false;
}

bool mmx::save	(	const string &	file_name,
		const string &	s
	)

Referenced by mmc_save(), and shell_save_session().

nat mmx::scalar_to_alias

(

nat

id

)

[inline]

Definition at line 196 of file alias.hpp.

References alias_type_info().

Referenced by object_alias(), and object_specialize_alias().

                         {
  int mode= 1;
  alias_type_info (id, mode);
  return id;
}

static void mmx::scheme_to_tm	(	string &	obj->lex_string,
		const generic &	g,
		int	indent
	)			[static]

Definition at line 520 of file mmx_texmacs.cpp.

References cdr(), compound_to_vector(), ends(), ERROR, is_func(), literal_to_string(), n, N(), spaces(), unquote(), and write().

Referenced by flatten_as_tm().

                                                       {
  //mmout << "Converting " << g << "\n";
  if (is<literal> (g))
    write (s, unquote (literal_to_string (g)));
  else if (is_func (g, "concat")) {
    for (nat i=1; i<N(g); i++)
      scheme_to_tm (s, g[i], indent);
  }
  else if (is_func (g, "document")) {
    for (nat i=1; i<N(g); i++) {
      if (i>1) {
        if (ends (s, "\n")) s << "\\;";
        s << "\n\n" << spaces (indent);
      }
      scheme_to_tm (s, g[i], indent);
    }
  }
  else if (is<compound> (g) && N(g) > 0 && is<literal> (g[0])) {
    string func= literal_to_string (g[0]);
    vector<generic> args= cdr (compound_to_vector (g));
    int i, last, n=N(args);
    for (i=n-1; i>=0; i--)
      if (is_func (args[i], "document"))
        break;
    last= i;
    if (last >= 0) {
      for (i=0; i<=n; i++) {
        bool flag= (i<n) && is_func (args[i], "document");
        if (i==0) s << "<\\" << func;
        else if (i==last+1) s << "</" << func;
        else if (is_func (args[i-1], "document")) s << "<|" << func;
        if (i==n) { s << ">"; break; }

        if (flag) {
          s << ">";
          if (!ends (s, "\n")) s << "\n" << spaces (indent + 2);
          scheme_to_tm (s, args[i], indent + 2);
          if (!ends (s, "\n")) s << "\n" << spaces (indent);
        }
        else {
          s << "|";
          scheme_to_tm (s, args[i], indent);
        }
      }
    }
    else {
      s << "<" << func;
      for (i=0; i<n; i++) {
        s << "|";
        scheme_to_tm (s, args[i], indent);
      }
      s << ">";
    }    
  }
  else ERROR ("invalid scheme markup");
}

int mmx::search_backwards	(	const string &	obj->lex_string,
		const string &	what,
		const int &	obj->lex_pos
	)

Definition at line 573 of file string.cpp.

References N(), and reads().

                                                                       {
  for (int i= pos - N(what); i >= 0; i--)
    if (reads (s, i, what)) return i;
  return -1;
}

int mmx::search_backwards	(	const string &	s,
		const string &	what,
		const int &	pos
	)

Search first occurrence of @ in @ before @ or @-1@.

Referenced by GLUE_15(), and resolve_name().

int mmx::search_forwards	(	const string &	obj->lex_string,
		const string &	what,
		const int &	obj->lex_pos
	)

Definition at line 566 of file string.cpp.

References N(), and reads().

                                                                      {
  for (nat i= pos; i + N(what) <= N(s); i++)
    if (reads (s, i, what)) return i;
  return -1;
}

int mmx::search_forwards	(	const string &	s,
		const string &	what,
		const int &	pos
	)

Search first occurrence of @ in @ after @ or @-1@.

Referenced by GLUE_14().

double mmx::sec

(

const double &

x

)

[inline]

Definition at line 69 of file double.hpp.

{ return std::isfinite (x); }

double mmx::sech

(

const double &

x

)

[inline]

Definition at line 70 of file double.hpp.

{ return std::isfinite (x); }

C2 mmx::second

(

const triple< C1, C2, C3 > &

t

)

[inline]

Definition at line 41 of file triple.hpp.

{ return t.x2; }

const C * seg

(

const vector< C, V > &

v

)

[inline]

Definition at line 215 of file vector.hpp.

{ return v->a; }

C * seg

(

vector< C, V > &

v

)

[inline]

Definition at line 216 of file vector.hpp.

References is_non_scalar(), and VERIFY.

Referenced by append(), big(), big_dicho(), binary_map(), binary_map_scalar(), binary_test(), binary_test_scalar(), cons(), dot(), insert(), inside_append(), nullary_set(), vector< C, V >::operator<<(), range(), reverse(), project_helper< vector< C, V > >::set_op(), lift_helper< vector< C, V > >::set_op(), unary_map(), unary_set(), unary_set_scalar(), and vector< observer >::vector().

                               {
  VERIFY (is_non_scalar (v), "non-scalar vector expected");
  v.secure(); return v->a; }

C * seg_inside

(

const vector< C, V > &

v

)

[inline]

Definition at line 219 of file vector.hpp.

References inside().

{ return inside (v)->a; }

void select_evaluator

(

const evaluator &

ev

)

Definition at line 61 of file evaluator.cpp.

References cons(), current_ev, and stack_ev.

                                       {
  //assert (!ev_lock);
  //ev_lock= true;
  //{
  /*
    if (N(stack_ev) < 6)
    mmout << "[" << N (stack_ev)
    << ":" << inside (current_ev)
    << "+" << inside (ev)
    << "]" << flush_now;
  */
  stack_ev  = cons (current_ev, stack_ev);
  current_ev= ev;
  //}
  //ev_lock= false;
}

static string mmx::semi_recursive_search_name	(	const string &	dir,
		const string &	name
	)			[static]

Definition at line 640 of file system.cpp.

References canonical_name(), file_exists(), file_is_directory(), file_is_file(), N(), and recursive_search_name().

Referenced by ancestor_search_name(), and resolve_name().

                                                                   {
  //mmout << "Semi recursive search " << dir << ", " << name << "\n";
  if (!file_exists (dir) || !file_is_directory (dir)) return "";
  nat i;
  for (i=0; i<N(name); i++)
    if (name[i] == '/') break;
  if (i >= N(name)) {
    string sname= canonical_name (dir * "/" * name);
    if (file_exists (sname) && file_is_file (sname)) return sname;
  }
  else {
    string sdir= canonical_name (dir * "/" * name (0, i));
    if (file_exists (sdir) && file_is_directory (sdir)) {
      string sname= recursive_search_name (sdir, name (i+1, N(name)), false);
      if (sname != "") return sname;
    }
  }
  return "";
}

iterator<C> mmx::seq	(	const C &	c1,
		const C &	c2,
		const C &	c3,
		const C &	c4,
		const C &	c5,
		const C &	c6
	)			[inline]

Definition at line 313 of file iterator.hpp.

References C, get_format(), and Iterator.

{
  C* a= mmx_new<C> (6);
  a[0]= c1; a[1]= c2; a[2]= c3; a[3]= c4; a[4]= c5; a[5]= c6;
  return Iterator (new finite_iterator_rep<C> (a, 6, get_format (c1)));
}

iterator<C> mmx::seq	(	const C &	c1,
		const C &	c2,
		const C &	c3,
		const C &	c4,
		const C &	c5
	)			[inline]

Definition at line 304 of file iterator.hpp.

References C, get_format(), and Iterator.

{
  C* a= mmx_new<C> (5);
  a[0]= c1; a[1]= c2; a[2]= c3; a[3]= c4; a[4]= c5;
  return Iterator (new finite_iterator_rep<C> (a, 5, get_format (c1)));
}

iterator<C> mmx::seq	(	const C &	c1,
		const C &	c2,
		const C &	c3,
		const C &	c4
	)			[inline]

Definition at line 295 of file iterator.hpp.

References C, get_format(), and Iterator.

{
  C* a= mmx_new<C> (4);
  a[0]= c1; a[1]= c2; a[2]= c3; a[3]= c4;
  return Iterator (new finite_iterator_rep<C> (a, 4, get_format (c1)));
}

iterator<C> mmx::seq	(	const C &	c1,
		const C &	c2,
		const C &	c3
	)			[inline]

Definition at line 288 of file iterator.hpp.

References C, get_format(), and Iterator.

                                            {
  C* a= mmx_new<C> (3);
  a[0]= c1; a[1]= c2; a[2]= c3;
  return Iterator (new finite_iterator_rep<C> (a, 3, get_format (c1)));
}

iterator<C> mmx::seq	(	const C &	c1,
		const C &	c2
	)			[inline]

Definition at line 281 of file iterator.hpp.

References C, get_format(), and Iterator.

                               {
  C* a= mmx_new<C> (2);
  a[0]= c1; a[1]= c2;
  return Iterator (new finite_iterator_rep<C> (a, 2, get_format (c1)));
}

iterator<C> mmx::seq

(

const C &

c1

)

[inline]

Definition at line 274 of file iterator.hpp.

References C, get_format(), and Iterator.

                  {
  C* a= mmx_new<C> (1);
  a[0]= c1;
  return Iterator (new finite_iterator_rep<C> (a, 1, get_format (c1)));
}

static string mmx::serialize

(

const generic &

g

)

[static]

Definition at line 272 of file mmx_printer.cpp.

References s, and serialize().

                             {
  string s;
  serialize (s, g);
  return s;
}

static void mmx::serialize	(	string &	obj->lex_string,
		const generic &	g
	)			[static]

Definition at line 172 of file mmx_printer.cpp.

References as_string(), contains(), GEN_MINUS, GEN_PLUS, INDENT, is_func(), LF, literal_to_string(), mmx_symbol_table(), N(), starts(), texmacs_expand(), UNINDENT, and VARINDENT.

Referenced by as_mmx(), and serialize().

                                        {
  if (is<literal> (g)) {
    static table<generic,generic> t= mmx_symbol_table ();
    if (contains (t, g)) s << literal_to_string (t[g]);
    else if (g == "$spc") s << " ";
    else if (g == "$lf") s << LF;
    else if (g == "$cr");
    else s << literal_to_string (g);
  }
  else if (is_func (g, "$concat") ||
           is_func (g, "$bracket") ||
           is_func (g, "$prefix") ||
           is_func (g, "$postfix"))
    for (nat i=1; i<N(g); i++)
      serialize (s, g[i]);
  else if (is_func (g, "$infix", 3)) {
    serialize (s, g[1]);
    if (g[2] != "^" && g[2] != "^^") s << " ";
    serialize (s, g[2]);
    if (g[2] != "^" && g[2] != "^^") s << " ";
    serialize (s, g[3]); 
  }
  else if (is_func (g, "$bigop") && N(g) >= 3) {
    if (g[1] == GEN_PLUS && is_func (g[2], GEN_MINUS, 1)) {
      s << "-";
      serialize (s, g[2][1]);
    }
    else serialize (s, g[2]);
    for (nat i=3; i<N(g); i++) {
      if (g[1] == GEN_PLUS && is_func (g[i], GEN_MINUS, 1)) {
        s << " " << "-" << " ";
        serialize (s, g[i][1]);
      }
      else {
        s << " ";
        serialize (s, g[1]);
        s << " ";
        serialize (s, g[i]);
      }
    }
  }
  else if (is_func (g, "$keyword", 1))
    serialize (s, g[1]);
  else if (is_func (g, "$operate", 2) ||
           is_func (g, "$keyword", 2)) {
    serialize (s, g[1]);
    s << " ";
    serialize (s, g[2]);
  }
  else if (is_func (g, "$hlist") ||
           is_func (g, "$vlist")) {
    if (N(g) == 1) return;
    serialize (s, g[1]);
    for (nat i=2; i<N(g); i++) {
      if (g[0] == "$hlist") s << ", ";
      else s << "; ";
      serialize (s, g[i]);
    }
  }
  else if (is_func (g, "$indent")) {
    s << INDENT;
    for (nat i=1; i<N(g); i++)
      serialize (s, g[i]);
    s << UNINDENT;
  }
  else if (is_func (g, "$varindent")) {
    serialize (s, g[1]);
    s << VARINDENT;
    for (nat i=2; i<N(g); i++)
      serialize (s, g[i]);
    s << UNINDENT;
  }
  else if (is_func (g, "$text", 1))
    serialize (s, g[1]);
  else if (is_func (g, "$math", 1))
    serialize (s, g[1]);
  else if (is_func (g, "$dynamic", 2)) {
    s << "< ";
    serialize (s, g[1]);
    s << " | ";
    serialize (s, g[2]);
    s << " >";
  }
  else if (is<compound> (g) && is<literal> (g[0]) &&
           starts (as_string (as<literal> (g[0])), "tm$")) {
    generic h= texmacs_expand (g);
    serialize (s, h);
  }
  else {
    serialize (s, g[0]);
    s << " (";
    for (nat i=1; i<N(g); i++) {
      if (i != 1) s << ", ";
      serialize (s, g[i]);
    }
    s << ")";
  }
}

void mmx::set_accuracy

(

vector< C, V > &

v

)

[inline]

Definition at line 1034 of file vector.hpp.

{ nullary_set<accuracy_as_op> (v); }

void mmx::set_accuracy

(

T &

x

)

[inline]

Definition at line 872 of file type_props.hpp.

References decexp2(), precision(), and promote().

                                                     {
  x= decexp2 (promote (1, x), precision (x) - 1); }

void set_accuracy

(

syntactic &

x

)

Definition at line 104 of file syntactic.cpp.

References as_syntactic(), and GEN_ACCURACY.

{ x= as_syntactic (GEN_ACCURACY); }

void set_accuracy

(

generic &

x

)

Definition at line 251 of file generic.cpp.

References GEN_ACCURACY.

{ x= GEN_ACCURACY; }

void set_accuracy

(

double &

x

)

[inline]

Definition at line 34 of file double.hpp.

Referenced by accuracy_cst(), and accuracy_as_op::set_op().

{ x= __DBL_EPSILON__; }

generic set_alias	(	const generic &	a,
		const generic &	val
	)

Definition at line 89 of file alias.cpp.

References alias_setter(), and type().

                                                 {
  routine r;
  alias_setter (type (a), r);
  return r->apply (a, val);
}

C mmx::set_alias	(	const alias< C > &	a,
		const C &	c
	)			[inline]

Definition at line 59 of file alias.hpp.

Referenced by object_set_alias(), and set_genalias().

                                                     {
  a->open ()= c; a->close (); return c; }

void mmx::set_as	(	vector< C, V > &	r,
		const T &	x
	)			[inline]

Definition at line 282 of file vector.hpp.

References CF(), and Vector.

                               {
  r= Vector (x, CF(r));
}

void mmx::set_as	(	vector< T, TV > &	r,
		const vector< F, FV > &	v
	)			[inline]

Definition at line 277 of file vector.hpp.

References CF().

                                                {
  r= vector<T,TV> (v, CF(r));
}

void mmx::set_as	(	T &	r,
		const F &	x
	)			[inline]

Definition at line 710 of file type_props.hpp.

                          {
  r= as_helper<T,F>::cv (x);
}

void mmx::set_as	(	list< C > &	r,
		const T &	x
	)			[inline]

Definition at line 179 of file list.hpp.

References C, and set_as().

                             {
  C c; set_as (c, x);
  r= list<T> (c);
}

void mmx::set_as	(	list< T > &	r,
		const vector< F > &	l
	)			[inline]

Definition at line 169 of file list.hpp.

References car(), cdr(), CF(), cons(), is_nil(), s, set_as(), and T.

                                        {
  if (is_nil (l)) r= list<T> (CF(r));
  else {
    T c; set_as (c, car (l));
    list<T> s (CF (r)); set_as (s, cdr (l));
    r= cons (c, s);
  }
}

void mmx::set_as	(	iterator< T > &	r,
		const iterator< F > &	x
	)			[inline]

Definition at line 221 of file iterator.hpp.

References CF().

                                              {
  r= iterator<T> (new as_iterator_rep<T,F> (x, CF(r)));
}

void mmx::set_as	(	generic &	r,
		const generic &	x
	)			[inline]

Definition at line 583 of file generic.hpp.

                                      {
 r= x;
}

void mmx::set_as	(	C &	r,
		const generic &	x
	)			[inline]

Definition at line 578 of file generic.hpp.

                                {
  r= ((generic_concrete_rep<C>*) inspect(x)) -> rep;
}

void mmx::set_as	(	generic &	r,
		const C &	x
	)			[inline]

Definition at line 573 of file generic.hpp.

Referenced by implementation< vector_linear, V, vector_naive >::clear(), map(), constructor_3< Cat, Nr, C1, C2, C3 >::op(), constructor_2< Cat, Nr, C1, C2 >::op(), constructor_1< Cat, Nr, C1 >::op(), outplace_set_as(), promote(), set_as(), set_false(), set_one(), lift_helper< C >::set_op(), complete_op::set_op(), truncate_op::set_op(), reconstruct_op::set_op(), evaluate_op::set_op(), as_op::set_op(), set_true(), set_zero(), and vector< observer >::vector().

                                {
  r= new generic_concrete_rep<C> (x);
}

void mmx::set_catalan

(

vector< C, V > &

v

)

[inline]

Definition at line 1028 of file vector.hpp.

{ nullary_set<catalan_as_op> (v); }

void set_catalan

(

syntactic &

x

)

Definition at line 108 of file syntactic.cpp.

References as_syntactic(), and GEN_CATALAN.

{ x= as_syntactic (GEN_CATALAN); }

void set_catalan

(

generic &

x

)

Definition at line 255 of file generic.cpp.

References GEN_CATALAN.

Referenced by catalan_cst(), and catalan_as_op::set_op().

{ x= GEN_CATALAN; }

void mmx::set_default

(

vector< C, V > &

v

)

[inline]

Definition at line 1024 of file vector.hpp.

{ nullary_set<default_as_op> (v); }

void mmx::set_default

(

bool &

x

)

[inline]

Definition at line 885 of file type_props.hpp.

{ x= false; }

void mmx::set_default

(

T &

x

)

[inline]

Definition at line 864 of file type_props.hpp.

References get_format(), and get_sample().

                                                    {
  x= get_sample (get_format (x)); }

void set_default

(

syntactic &

x

)

Definition at line 101 of file syntactic.cpp.

{ x= syntactic ("false"); }

void set_default

(

generic &

x

)

Definition at line 248 of file generic.cpp.

{ x= as<generic> (false); }

void set_default

(

double &

x

)

[inline]

Definition at line 26 of file double.hpp.

{ x= 0; }

void set_default

(

long unsigned int &

x

)

[inline]

Definition at line 42 of file int.hpp.

{ x= 0; }

void set_default

(

long int &

x

)

[inline]

Definition at line 41 of file int.hpp.

{ x= 0; }

void set_default

(

nat &

x

)

[inline]

Definition at line 40 of file int.hpp.

{ x= 0; }

void set_default

(

int &

x

)

[inline]

Definition at line 39 of file int.hpp.

Referenced by default_cst(), and default_as_op::set_op().

{ x= 0; }

int set_env	(	const string &	var,
		const string &	value
	)

Definition at line 94 of file system.cpp.

References as_charp(), and free_charp().

                                                 {
  char* _var= as_charp (var);
  char* _value= as_charp (value);
  int ret= setenv (_var, _value, 1);
  free_charp (_var);
  free_charp (_value);
  return ret;
}

void mmx::set_euler

(

vector< C, V > &

v

)

[inline]

Definition at line 1027 of file vector.hpp.

{ nullary_set<euler_as_op> (v); }

void set_euler

(

syntactic &

x

)

Definition at line 107 of file syntactic.cpp.

References as_syntactic(), and GEN_EULER.

{ x= as_syntactic (GEN_EULER); }

void set_euler

(

generic &

x

)

Definition at line 254 of file generic.cpp.

References GEN_EULER.

{ x= GEN_EULER; }

void set_euler

(

double &

x

)

[inline]

Definition at line 37 of file double.hpp.

Referenced by euler_cst(), and euler_as_op::set_op().

{ x= 0.5772156649015328606065120900824024L; }

void mmx::set_false

(

T &

x

)

[inline]

Definition at line 862 of file type_props.hpp.

References set_as().

Referenced by or_is_nan_op::set_neutral(), or_is_fuzz_op::set_neutral(), or_is_infinite_op::set_neutral(), and or_op::set_neutral().

{ set_as (x, false); }

bool set_frac_flag

(

bool

new_val

)

Definition at line 245 of file syntactic.cpp.

References frac_flag.

Referenced by GLUE_16(), and ordered_product().

                             {
  bool ret= frac_flag;
  frac_flag= new_val;
  return ret;
}

void mmx::set_fuzz

(

vector< C, V > &

v

)

[inline]

Definition at line 1031 of file vector.hpp.

{ nullary_set<fuzz_as_op> (v); }

void set_fuzz

(

syntactic &

x

)

Definition at line 111 of file syntactic.cpp.

References as_syntactic(), and GEN_FUZZ.

{ x= as_syntactic (GEN_FUZZ); }

void set_fuzz

(

generic &

x

)

Definition at line 258 of file generic.cpp.

References GEN_FUZZ.

{ x= GEN_FUZZ; }

void set_fuzz

(

double &

x

)

[inline]

Definition at line 31 of file double.hpp.

Referenced by fuzz_cst(), and fuzz_as_op::set_op().

{ x= 0.0; }

generic mmx::set_genalias	(	const generic_alias< C > &	a,
		const generic &	c
	)			[inline]

Definition at line 136 of file alias.hpp.

References set_alias().

Referenced by WRAP_WRAPPED_IMPL().

                                                                            {
  return set_alias (*a, c); }

void mmx::set_imaginary

(

vector< C, V > &

v

)

[inline]

Definition at line 1029 of file vector.hpp.

{ nullary_set<imaginary_as_op> (v); }

void mmx::set_imaginary

(

T &

x

)

[inline]

Definition at line 870 of file type_props.hpp.

References promote().

                                                      {
  x= times_i (promote (1, x)); }

void set_imaginary

(

syntactic &

x

)

Definition at line 109 of file syntactic.cpp.

References as_syntactic(), and GEN_I.

{ x= as_syntactic (GEN_I); }

void set_imaginary

(

generic &

x

)

Definition at line 256 of file generic.cpp.

References GEN_I.

Referenced by imaginary_cst(), and imaginary_as_op::set_op().

{ x= GEN_I; }

void mmx::set_infinity

(

vector< C, V > &

v

)

[inline]

Definition at line 1035 of file vector.hpp.

{ nullary_set<infinity_as_op> (v); }

void mmx::set_infinity

(

T &

x

)

[inline]

Definition at line 874 of file type_props.hpp.

References promote(), and times_infinity().

                                                     {
  x= times_infinity (promote (1, x)); }

void set_infinity

(

syntactic &

x

)

Definition at line 112 of file syntactic.cpp.

References as_syntactic(), and GEN_INFINITY.

{ x= as_syntactic (GEN_INFINITY); }

void set_infinity

(

generic &

x

)

Definition at line 259 of file generic.cpp.

References GEN_INFINITY.

{ x= GEN_INFINITY; }

void set_infinity

(

double &

x

)

[inline]

Definition at line 30 of file double.hpp.

Referenced by infinity_cst(), set_largest(), set_maximal(), and infinity_as_op::set_op().

{ x= HUGE_VAL; }

void mmx::set_largest

(

vector< C, V > &

v

)

[inline]

Definition at line 1033 of file vector.hpp.

{ nullary_set<largest_as_op> (v); }

void mmx::set_largest

(

T &

x

)

[inline]

Definition at line 878 of file type_props.hpp.

References next_below(), and set_infinity().

                                             {
  set_infinity (x); x= next_below (x); }

void set_largest

(

syntactic &

x

)

Definition at line 103 of file syntactic.cpp.

References as_syntactic(), and GEN_LARGEST.

{ x= as_syntactic (GEN_LARGEST); }

void set_largest

(

generic &

x

)

Definition at line 250 of file generic.cpp.

References GEN_LARGEST.

{ x= GEN_LARGEST; }

void set_largest

(

double &

x

)

[inline]

Definition at line 33 of file double.hpp.

Referenced by largest_cst(), and largest_as_op::set_op().

{ x= nextafter (HUGE_VAL, 0.0); }

void mmx::set_lift	(	R &	y,
		const C &	x
	)			[inline]

Definition at line 832 of file type_props.hpp.

Referenced by lift_helper< vector< C, V > >::set_op().

{ lift_helper<C>::set_op (y, x); }

void mmx::set_log2

(

vector< C, V > &

v

)

[inline]

Definition at line 1026 of file vector.hpp.

{ nullary_set<log2_as_op> (v); }

void set_log2

(

syntactic &

x

)

Definition at line 106 of file syntactic.cpp.

References as_syntactic(), and log().

{ x= log (as_syntactic (2)); }

void set_log2

(

generic &

x

)

Definition at line 253 of file generic.cpp.

References log().

{ x= log (generic (2)); }

void set_log2

(

double &

x

)

[inline]

Definition at line 35 of file double.hpp.

Referenced by log2_cst(), and log2_as_op::set_op().

{ x= 0.6931471805599453094172321214581766L; }

void mmx::set_maximal

(

vector< C, V > &

v

)

[inline]

Definition at line 1036 of file vector.hpp.

{ nullary_set<maximal_as_op> (v); }

void mmx::set_maximal

(

T &

x

)

[inline]

Definition at line 880 of file type_props.hpp.

References set_infinity().

                                                    {
  set_infinity (x); }

void set_maximal

(

syntactic &

x

)

Definition at line 113 of file syntactic.cpp.

References as_syntactic(), and GEN_INFINITY.

{ x= as_syntactic (GEN_INFINITY); }

void mmx::set_maximal

(

long long unsigned int &

x

)

[inline]

Definition at line 64 of file int.hpp.

                                                    {
  x= (long long unsigned int) (-1); }

void mmx::set_maximal

(

long long int &

x

)

[inline]

Definition at line 60 of file int.hpp.

                                           {
  x= (long long int) (((long long unsigned int) (-1)) >> 1); }

void set_maximal

(

generic &

x

)

Definition at line 260 of file generic.cpp.

References GEN_INFINITY.

{ x= GEN_INFINITY; }

void set_maximal

(

double &

x

)

[inline]

Definition at line 28 of file double.hpp.

{ x= HUGE_VAL; }

void set_maximal

(

long unsigned int &

x

)

[inline]

Definition at line 56 of file int.hpp.

                                               {
  x= (long unsigned int) (-1); }

void set_maximal

(

long int &

x

)

[inline]

Definition at line 52 of file int.hpp.

                                      {
  x= (long int) (((long unsigned int) (-1)) >> 1); }

void set_maximal

(

nat &

x

)

[inline]

Definition at line 48 of file int.hpp.

                                 {
  x= (nat) (-1); }

void set_maximal

(

int &

x

)

[inline]

Definition at line 44 of file int.hpp.

Referenced by maximal_cst(), set_minimal(), inf_op::set_neutral(), min_op::set_neutral(), and maximal_as_op::set_op().

                                 {
  x= (int) (((nat) (-1)) >> 1); }

void mmx::set_minimal

(

vector< C, V > &

v

)

[inline]

Definition at line 1037 of file vector.hpp.

{ nullary_set<minimal_as_op> (v); }

void mmx::set_minimal

(

T &

x

)

[inline]

Definition at line 882 of file type_props.hpp.

References set_maximal().

                                                    {
  set_maximal (x); x= -x; }

void set_minimal

(

syntactic &

x

)

Definition at line 114 of file syntactic.cpp.

References as_syntactic(), and GEN_INFINITY.

{ x= -as_syntactic (GEN_INFINITY); }

void mmx::set_minimal

(

long long unsigned int &

x

)

[inline]

Definition at line 66 of file int.hpp.

                                                    {
  x= (long long unsigned int) 0; }

void mmx::set_minimal

(

long long int &

x

)

[inline]

Definition at line 62 of file int.hpp.

                                           {
  x= (long long int) ((((long long unsigned int) (-1)) >> 1) + 1); }

void set_minimal

(

generic &

x

)

Definition at line 261 of file generic.cpp.

References GEN_INFINITY.

{ x= -GEN_INFINITY; }

void set_minimal

(

double &

x

)

[inline]

Definition at line 29 of file double.hpp.

{ x= -HUGE_VAL; }

void set_minimal

(

long unsigned int &

x

)

[inline]

Definition at line 58 of file int.hpp.

                                               {
  x= (long unsigned int) 0; }

void set_minimal

(

long int &

x

)

[inline]

Definition at line 54 of file int.hpp.

                                      {
  x= (long int) ((((long unsigned int) (-1)) >> 1) + 1); }

void set_minimal

(

nat &

x

)

[inline]

Definition at line 50 of file int.hpp.

                                 {
  x= (nat) 0; }

void set_minimal

(

int &

x

)

[inline]

Definition at line 46 of file int.hpp.

Referenced by minimal_cst(), min_precision_op::set_neutral(), max_magnitude_op::set_neutral(), max_exponent_op::set_neutral(), sup_op::set_neutral(), max_op::set_neutral(), and minimal_as_op::set_op().

                                 {
  x= (int) ((((nat) (-1)) >> 1) + 1); }

void mmx::set_nan

(

vector< C, V > &

v

)

[inline]

Definition at line 1030 of file vector.hpp.

{ nullary_set<nan_as_op> (v); }

void mmx::set_nan

(

T &

x

)

[inline]

Definition at line 868 of file type_props.hpp.

References promote().

                                                {
  x= promote (1, x) / promote (0, x); }

void set_nan

(

syntactic &

x

)

Definition at line 110 of file syntactic.cpp.

References as_syntactic(), and GEN_NAN.

{ x= as_syntactic (GEN_NAN); }

void set_nan

(

generic &

x

)

Definition at line 257 of file generic.cpp.

References GEN_NAN.

{ x= GEN_NAN; }

void set_nan

(

double &

x

)

[inline]

Definition at line 27 of file double.hpp.

Referenced by nan_cst(), and nan_as_op::set_op().

{ x= NAN; }

void mmx::set_one

(

T &

x

)

[inline]

Definition at line 860 of file type_props.hpp.

References set_as().

Referenced by one_cst(), lcm_op::set_neutral(), and mul_op::set_neutral().

{ set_as (x, (int) 1); }

void mmx::set_pi

(

vector< C, V > &

v

)

[inline]

Definition at line 1025 of file vector.hpp.

{ nullary_set<pi_as_op> (v); }

void mmx::set_pi

(

T &

x

)

[inline]

Definition at line 866 of file type_props.hpp.

References atan(), and promote().

                                               {
  x= promote (4, x) * atan (promote (1, x)); }

void set_pi

(

syntactic &

x

)

Definition at line 105 of file syntactic.cpp.

References as_syntactic(), and GEN_PI.

{ x= as_syntactic (GEN_PI); }

void set_pi

(

generic &

x

)

Definition at line 252 of file generic.cpp.

References GEN_PI.

{ x= GEN_PI; }

void set_pi

(

double &

x

)

[inline]

Definition at line 36 of file double.hpp.

Referenced by pi_cst(), and pi_as_op::set_op().

{ x= 3.1415926535897932384626433832795029L; }

void mmx::set_project	(	R &	y,
		const C &	x
	)			[inline]

Definition at line 850 of file type_props.hpp.

Referenced by project_helper< vector< C, V > >::set_op().

{ project_helper<C>::set_op (y, x); }

void mmx::set_smallest

(

vector< C, V > &

v

)

[inline]

Definition at line 1032 of file vector.hpp.

{ nullary_set<smallest_as_op> (v); }

void mmx::set_smallest

(

T &

x

)

[inline]

Definition at line 876 of file type_props.hpp.

References next_above(), and promote().

                                              {
  x= next_above (promote (0, x)); }

void set_smallest

(

syntactic &

x

)

Definition at line 102 of file syntactic.cpp.

References as_syntactic(), and GEN_SMALLEST.

{ x= as_syntactic (GEN_SMALLEST); }

void set_smallest

(

generic &

x

)

Definition at line 249 of file generic.cpp.

References GEN_SMALLEST.

{ x= GEN_SMALLEST; }

void set_smallest

(

double &

x

)

[inline]

Definition at line 32 of file double.hpp.

Referenced by smallest_as_op::set_op(), and smallest_cst().

{ x= nextafter (0.0, HUGE_VAL); }

void set_top	(	heap< C > &	h,
		const C &	x
	)			[inline]

Definition at line 185 of file heap.hpp.

                                               {
  h.secure(); h.rep->Set_top (x); }

void mmx::set_true

(

T &

x

)

[inline]

Definition at line 861 of file type_props.hpp.

References set_as().

Referenced by and_is_finite_op::set_neutral(), and and_op::set_neutral().

{ set_as (x, true); }

void mmx::set_zero

(

T &

x

)

[inline]

Definition at line 859 of file type_props.hpp.

References set_as().

Referenced by _mul_add(), binary_map(), binary_map_optimized(), binary_map_scalar(), gcd_op::set_neutral(), mul_sub_op::set_neutral(), mul_add_op::set_neutral(), add_op::set_neutral(), sparse_vector< C, T, V >::sparse_vector(), unary_map(), and zero_cst().

{ set_as (x, (int) 0); }

vector<C,V> mmx::sharpen

(

const vector< C, V > &

v

)

[inline]

Definition at line 1353 of file vector.hpp.

                                             {
  return unary_map<sharpen_op> (v); }

table<C,T,V> mmx::sharpen

(

const table< C, T, V > &

t

)

[inline]

Definition at line 739 of file table.hpp.

                                           {
  return unary_map<sharpen_op> (t); }

new_table<C,T,V> mmx::sharpen

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 810 of file new_table.hpp.

                                           {
  return unary_map<sharpen_op> (t); }

generic sharpen

(

const generic &

x1

)

Definition at line 825 of file generic.cpp.

References current_ev.

                                    {
  return current_ev->apply ("sharpen", x1); }

C mmx::sharpen

(

const C &

x

)

[inline]

Definition at line 707 of file defaults.hpp.

Referenced by sharpen_op::op(), and sharpen_op::set_op().

                                                   {
  return x; }

void shell_load_history

(

)

Definition at line 109 of file terminal_interface.cpp.

References as_charp(), free_charp(), history_size, and user_dir().

                      {
  string dir = user_dir ();
  if (dir == "") return;
  string file_name = dir * "/var/history";
  char* _f = as_charp (file_name);
  history_truncate_file (_f, history_size);
  read_history (_f);
  free_charp (_f);
}

vector< string > shell_load_session

(

void

)

Definition at line 167 of file terminal_interface.cpp.

References load(), N(), store_interactive_number(), store_interactive_source(), tokenize(), and user_dir().

                          {
  string dir = user_dir ();
  string file_name = dir * "/var/session";
  string data;
  load (file_name, data);
  store_interactive_number (0);
  string sep= "\n\n"; sep[0]= '\0';
  vector<string> inputs= tokenize (data, sep);
  vector<string> v;
  for (nat i=0; i<N(inputs); i++) {
    v << tokenize (inputs[i], "\n", true);
    store_interactive_source (inputs[i]);
  }
  return inputs;
}

void shell_save_history

(

)

Definition at line 98 of file terminal_interface.cpp.

References as_charp(), free_charp(), history_size, and user_dir().

Referenced by shell_terminal_input().

                      {
  string dir= user_dir ();
  if (dir == "") return;
  string file_name = dir * "/var/history";
  char* _f = as_charp (file_name);
  write_history (_f);
  history_truncate_file (_f, history_size);
  free_charp (_f);
}

void shell_save_session

(

void

)

Definition at line 152 of file terminal_interface.cpp.

References contents(), get_interactive_number(), get_interactive_source(), save(), and user_dir().

Referenced by shell_terminal_input().

                          {
  nat i;
  string dir = user_dir ();
  string contents = "";
  char z = 0;
  if (dir == "") return;
  string file_name = dir * "/var/session";
  for (i = 0; i < get_interactive_number (); ++i) {
    contents << get_interactive_source (i);
    contents << z << "\n";
  }
  save (file_name, contents);
}

bool shell_terminal_input

(

string &

in

)

Definition at line 309 of file terminal_interface.cpp.

References active_newline(), as_charp(), as_string(), complete(), completion_mode, entries(), fed, free_charp(), get_interactive_number(), N(), passive_newline(), quiet_mode, read_line(), recompose(), s, shell_save_history(), shell_save_session(), size(), and store_interactive_source().

                                      {
  string prompt, promptc;
  string s;
  bool b;
  nat i, size;
  vector<string> v;
  char* tmp;
  buffer = "";
  fed = false;
  size = 0;

  HIST_ENTRY* last_entry;
  HISTORY_STATE* history = history_get_history_state ();

  if (quiet_mode) {
    prompt = "";
    promptc= "";
  }
  else {
    string next= as_string (get_interactive_number () + 1);
    prompt = next * "] ";
    promptc = "";
    for (i=0; i < N(next); i++)
      promptc << " ";
    promptc << "] ";
  }

  // entering interactive input
  while (true) {
    if (completion_mode)
      rl_attempted_completion_function = complete;
    rl_bind_key (RETURN, active_newline);
    rl_bind_key (META(RETURN), passive_newline);

    b = read_line (prompt, s);
    v << s;
    size += N(s);
    buffer << s << "\n";
    if (N(s) > 0) {
      tmp = as_charp(s);
      if (history->length == 0)
        last_entry = NULL;
      else
        last_entry = history -> entries[history->length-1];
      if ((last_entry == NULL) ||
          ((last_entry != NULL) && (strcmp (tmp, last_entry->line) != 0))) {
        add_history (tmp);
        shell_save_history ();
        shell_save_session ();
      }
      free_charp (tmp);
    }
    if (fed || !b) {
      if (size > 0)
        store_interactive_source (recompose (v, "\n"));
      else
        buffer = "";
      shell_save_history ();
      shell_save_session ();
      return b;
    }
    prompt = promptc;
  }
}

void shell_texmacs_initialize

(

void

)

Definition at line 150 of file texmacs_interface.cpp.

References completion_mode, DATA_BEGIN, DATA_END, dynamic_event, mmout, and texmacs_dynamic_event().

                            {
  dynamic_event= texmacs_dynamic_event;
  mmout << DATA_BEGIN << "verbatim:";
  if (completion_mode) {
    mmout << DATA_BEGIN << "command:";
    mmout << "(plugin-configure mathemagix (:tab-completion #t))";
    mmout << DATA_END;
  }
}

bool mmx::shell_texmacs_input

(

string &

obj->lex_line

)

Definition at line 163 of file texmacs_interface.cpp.

References as_string(), busy(), completion_mode, DATA_BEGIN, DATA_COMMAND, DATA_END, flush_now, handle_completion_request(), mmin, mmout, N(), recompose(), shell_mmx_prompt, texmacs_flush_commands(), and tokenize().

                                   {
  static nat nr= 1;
  string next= "\"" * as_string (nr++) * "\"";
  mmout << DATA_BEGIN << "channel:prompt" << DATA_END;
  mmout << DATA_BEGIN << "scheme:(" << shell_mmx_prompt
        << " " << next << ")" << DATA_END;
  mmout << texmacs_flush_commands ();
  mmout << DATA_END << flush_now;
  string in;
  string request;
  char c;
  nat discard=0;
  while (busy (mmin)) {
    mmin >> c;
    if (c==DATA_COMMAND) {
      discard++;
      continue;
    }
    if (c=='\n' && discard) {
      discard--;
      if (discard==0) {
        if (completion_mode)
          handle_completion_request(request);
        request = string("");
      }
      continue;
    }
    if (discard) {
      request << c;
      continue;
    }
    if (c=='\n' && !discard) break;
    in << c;
  }
  mmout << DATA_BEGIN << "verbatim:";
  if (N(in)==0 && c==EOF) {
    mmout << DATA_END << flush_now;
    return false;
  }
  line = recompose (tokenize (in, "/{CR}/"), "\n", true);
  //store_interactive_source (line); // >> TODO
  return true;
}

bool mmx::shell_texmacs_input

(

string &

in

)

void shell_texmacs_output	(	const generic &	g,
		const generic &	t
	)

Definition at line 210 of file texmacs_interface.cpp.

References DATA_BEGIN, DATA_END, exact_neq(), flatten_as_texmacs_scheme(), math_mode, mmout, and type_mode.

                                                          {
  if (math_mode) {
    mmout << DATA_BEGIN << "scheme:";
    mmout << flatten_as_texmacs_scheme (g);
    mmout << DATA_END;
  }
  else
    mmout << g;
  if (type_mode && exact_neq (t, "Document"))
    mmout << ": " << t;
  mmout << "\n";
}

chain<C> chain<C> mmx::shift_left

(

const chain< C > &

c

)

[inline]

Definition at line 246 of file chain.hpp.

References Chain, left(), middle(), and right().

Referenced by balance_left().

                            {
  return Chain (Chain (left (c), middle (c), left (right (c))),
                middle (right (c)),
                right (right (c)));
}

chain<C> mmx::shift_right

(

const chain< C > &

c

)

[inline]

Definition at line 253 of file chain.hpp.

References Chain, left(), middle(), and right().

Referenced by balance_right().

                             {
  return Chain (left (left (c)),
                middle (left (c)),
                Chain (right (left (c)), middle (c), right (c)));
}

void mmx::show_symbol_entries

(

)

[inline]

Definition at line 132 of file symbol.hpp.

                                 {
  Symbol_rep::show_symbol_entries (); }

int mmx::sign

(

const long long unsigned int &

x

)

[inline]

Definition at line 412 of file defaults.hpp.

{ return (x == 0) ? 0 : 1; }

int mmx::sign

(

const long unsigned int &

x

)

[inline]

Definition at line 409 of file defaults.hpp.

{ return (x == 0) ? 0 : 1; }     

int mmx::sign

(

const unsigned int &

x

)

[inline]

Definition at line 406 of file defaults.hpp.

{ return (x == 0) ? 0 : 1; }     

int mmx::sign

(

const short unsigned int &

x

)

[inline]

Definition at line 403 of file defaults.hpp.

{ return (x == 0) ? 0 : 1; }     

int mmx::sign

(

const unsigned char &

x

)

[inline]

Definition at line 400 of file defaults.hpp.

{ return (x == 0) ? 0 : 1; }     

int mmx::sign

(

const C &

x

)

[inline]

Definition at line 393 of file defaults.hpp.

Referenced by atan2(), compare(), GLUE_19(), GLUE_29(), sign_op::op(), and sign_op::set_op().

                  {
  if (x>0) return 1;
  if (x<0) return -1;
  return 0;
}

vector<nat> mmx::signature

(

const generic_function &

fun

)

[inline]

Definition at line 52 of file generic_function.hpp.

                                                           {
  return fun -> Signature (); }

static void mmx::signed_decompose	(	const syntactic &	g,
		syntactic &	abs_g,
		int &	sgn_g
	)			[static]

Definition at line 121 of file syntactic.cpp.

References as_string(), GEN_MINUS, GEN_OVER, GEN_TIMES, is_atom(), is_func(), N(), and s.

Referenced by migrate_negate(), migrate_sub(), operator+(), operator-(), and pow().

                                                                    {
  if (is_atom (g)) {
    const string s= as_string (g);
    if (N(s) > 1 && s[0] == '-' &&
        (s[1] == '.' || (s[1] >= '0' && s[1] <= '9'))) {
      abs_g= syntactic (s (1, N(s)));
      sgn_g= -1;
    }
    else {
      abs_g= g;
      sgn_g= 1;
    }
  }
  else if (is_func (g, GEN_MINUS, 1)) {
    signed_decompose (g[1], abs_g, sgn_g);
    sgn_g= -sgn_g;
  }
  else if (is_func (g, GEN_TIMES, 2) || is_func (g, GEN_OVER, 2)) {
    syntactic a1, a2;
    int     s1, s2;
    signed_decompose (g[1], a1, s1);
    signed_decompose (g[2], a2, s2);
    if (is_func (g, GEN_TIMES, 2)) abs_g= a1 * a2;
    else abs_g= a1 / a2;
    sgn_g= s1 * s2;
  }
  else {
    abs_g= g;
    sgn_g= 1;
  }
}

void simplify

(

table< C, T, V > &

t

)

[inline]

Definition at line 174 of file table.hpp.

                                     {
  t.secure(); t.rep->simplify (); }

void simplify

(

new_table< C, T, V > &

t

)

[inline]

Definition at line 196 of file new_table.hpp.

Referenced by binary_combine(), binary_map(), binary_map_scalar(), map(), reverse(), unary_map(), and unary_set_scalar().

                                     {
  t.secure(); t.rep->simplify (); }

vector<C,V> mmx::sin

(

const vector< C, V > &

v

)

[inline]

Definition at line 1181 of file vector.hpp.

{ return unary_map<sin_op> (v); }

table<C,T,V> mmx::sin

(

const table< C, T, V > &

t

)

[inline]

Definition at line 702 of file table.hpp.

{ return unary_map<sin_op> (t); }

syntactic sin

(

const syntactic &

g

)

Definition at line 431 of file syntactic.cpp.

References GEN_SIN, and syn().

{ return syn (GEN_SIN, g); }

new_table<C,T,V> mmx::sin

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 773 of file new_table.hpp.

{ return unary_map<sin_op> (t); }

generic sin

(

const generic &

x1

)

Definition at line 451 of file generic.cpp.

References ACC_SIN, ACC_UNARY, current_ev, and GEN_SIN.

                        {
  ACC_UNARY (ACC_SIN, x1);
  return current_ev->apply (GEN_SIN, x1);
}

double sin

(

const double &

x

)

[inline]

Definition at line 50 of file double.hpp.

Referenced by cos_sin(), cos_op::diff_op(), sin_op::op(), trig_op::op(), sin_op::op_init(), sin_op::set_op(), and trig().

{ return std::sin (x); }

syntactic sinh

(

const syntactic &

g

)

Definition at line 437 of file syntactic.cpp.

References GEN_SH, and syn().

{ return syn (GEN_SH, g); }

generic sinh

(

const generic &

x1

)

Definition at line 487 of file generic.cpp.

References ACC_SINH, ACC_UNARY, and exp().

                         {
  ACC_UNARY (ACC_SINH, x1);
  return (exp (x1) - exp (-x1)) / 2;
}

double sinh

(

const double &

x

)

[inline]

Definition at line 53 of file double.hpp.

References sinh().

{ return std::sinh (x); }

C mmx::sinh

(

const C &

x

)

[inline]

Definition at line 591 of file defaults.hpp.

References exp(), and promote().

Referenced by cosh_op::diff_op(), sinh_op::op(), sinh_op::op_init(), sinh_op::set_op(), and sinh().

                                                {
  return (exp (x) - exp (-x)) / promote (2, x); }

nat size

(

const generic &

g

)

Definition at line 89 of file generic_utils.cpp.

References N(), n, and var_flatten().

Referenced by binary_size(), compare_sub(), cpp_demangle(), and shell_terminal_input().

                        {
  if (is<literal> (g)) return 1;
  if (is<compound> (g)) {
    nat i, n= N (g), sum= 1;
    for (i=0; i<n; i++)
      sum += size (g[i]);
    return sum;
  }
  return size (var_flatten (g));
}

C mmx::skew_div	(	const C &	x,
		const C &	y,
		bool	left = false
	)			[inline]

Definition at line 276 of file defaults.hpp.

References left().

                                                    {
  (void) left; return x / y; }

C mmx::skew_quo	(	const C &	x,
		const C &	y,
		bool	left = false
	)			[inline]

Definition at line 279 of file defaults.hpp.

References left(), and quo().

                                                    {
  (void) left; return quo (x, y); }

C mmx::skew_rem	(	const C &	x,
		const C &	y,
		bool	left = false
	)			[inline]

Definition at line 282 of file defaults.hpp.

References left(), and rem().

                                                    {
  (void) left; return rem (x, y); }

format<T> mmx::slow

(

const format< typename fast_helper< T >::fast_type > &

fm

)

[inline]

Definition at line 802 of file type_props.hpp.

References get_format(), and get_sample().

                                       {
  return get_format (slow<T> (get_sample (fm)));
}

T mmx::slow

(

const typename fast_helper< T >::fast_type &

x

)

[inline]

Definition at line 787 of file type_props.hpp.

Referenced by slow_op::op().

                             {
  return fast_helper<T>::uu (x);
}

format<T> mmx::slow_as

(

const format< F > &

fm

)

[inline]

Definition at line 807 of file type_props.hpp.

References get_format(), and get_sample().

                              {
  return get_format (slow_as<T,F> (get_sample (fm)));
}

T mmx::slow_as

(

const F &

x

)

[inline]

Definition at line 792 of file type_props.hpp.

                     {
  return fast_helper<T>::uu (x);
}

int small_big_compare	(	const generic &	g1,
		const generic &	g2
	)

Definition at line 181 of file generic_utils.cpp.

References compare().

Referenced by operator<(), operator<=(), operator>(), and operator>=().

                                                         {
  return compare (g1, g2, 1);
}

C mmx::smallest_cst

(

const format< C > &

fm

)

[inline]

Definition at line 945 of file type_props.hpp.

References C, promote(), and set_smallest().

                                   {
  C r= promote (0, fm); set_smallest (r); return r; }

C mmx::smallest_cst

(

)

[inline]

Definition at line 908 of file type_props.hpp.

References C, and set_smallest().

{ C r; set_smallest (r); return r; }

port socket_client_port	(	const string &	host,
		int	port
	)

Definition at line 159 of file socket_port.cpp.

References as_charp(), as_string(), error_port(), free_charp(), and socket_port().

Referenced by connect_to_server(), and GLUE_5().

                                                 {
  // getting host
  char* _host= as_charp (host);
  struct hostent *hp = gethostbyname (_host);
  free_charp (_host);
  if (hp == NULL) return error_port ("no connection for '" * host * "'");

  // creating socket
  int fd= socket (AF_INET, SOCK_STREAM, 0);
  if (fd < 0) return error_port ("socket could not be created");

  // connecting to socket
  struct sockaddr_in insock;
  string where= host * ":" * as_string (pnr);
  memset ((char*) &insock, 0, sizeof (insock));
  insock.sin_family = AF_INET;
  insock.sin_port = htons ((unsigned short) pnr);
  memcpy ((char*) &insock.sin_addr, hp->h_addr, hp->h_length);
  if (connect (fd, (struct sockaddr*) &insock, sizeof (insock)) < 0)
    return error_port ("refused connection to '" * where * "'");

  // testing whether it works
#if defined(__MINGW__) || defined(__MINGW32__)
  unsigned long flags = -1;
  if (ioctlsocket (fd, FIONBIO, &flags) == SOCKET_ERROR)
    return error_port ("non working connection to '" * where * "'");
#else
  int flags = O_NONBLOCK;
  if (fcntl (fd, F_SETFL, flags) < 0)
    return error_port ("non working connection to '" * where * "'");
#endif
  return socket_port (host, pnr, 2, fd);
}

port mmx::socket_port	(	const string &	host,
		int	pnr,
		int	role,
		int	fd
	)

Definition at line 88 of file socket_port.cpp.

Referenced by socket_port_rep::accept(), socket_client_port(), and socket_server_port().

                                                            {
  return (port_rep*) new socket_port_rep (host, pnr, role, fd);
}

port socket_server_port	(	const string &	host,
		int	port
	)

Definition at line 97 of file socket_port.cpp.

References error_port(), and socket_port().

Referenced by GLUE_4().

                                                 {
  // get the server
  int fd;
  if ((fd = socket (PF_INET, SOCK_STREAM, 0)) == -1)
    return error_port ("call to 'socket' failed");

  // lose the pesky "address already in use" error message
#if defined(__MINGW__) || defined(__MINGW32__)
  if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, NULL, 0) == -1)
    return error_port ("call to 'setsockopt' failed");
#else
  int yes= 1;
  if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR,
                  &yes, sizeof (int)) == -1)
    return error_port ("call to 'setsockopt' failed");
#endif

  // bind
  struct sockaddr_in local_address;
  local_address.sin_family = AF_INET;
  local_address.sin_addr.s_addr = INADDR_ANY;
  local_address.sin_port = htons (pnr);
  memset (local_address.sin_zero, '\0', sizeof local_address.sin_zero);
  if (bind (fd, (struct sockaddr *) &local_address,
            sizeof (local_address)) == -1)
    return error_port ("call to 'bind' failed");

  // listen
  if (::listen (fd, 10) == -1)
    return error_port ("call to 'listen' failed");
  return socket_port (host, pnr, 0, fd);
}

generic solve	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 702 of file generic.cpp.

References current_ev, and GEN_SOLVE.

                                                     {
  return current_ev->apply (GEN_SOLVE, x1, x2); }

syntactic solve_lde_init	(	const syntactic &	x,
		const syntactic &	c
	)

Definition at line 504 of file syntactic.cpp.

References syn().

                                                                  {
  return syn ("solve_lde_init", x, c); }

generic solve_lde_init	(	const generic &	x,
		const generic &	c
	)

Definition at line 814 of file generic.cpp.

References current_ev.

Referenced by solve_matrix_lde_op::op_init(), and solve_vector_lde_op::op_init().

                                                              {
  return current_ev->apply ("solve_lde_init", x1, x2); }

void mmx::sort	(	vector< T > &	v,
		vector< nat > &	sigma
	)			[inline]

Definition at line 79 of file vector_sort.hpp.

                                        {
  sort_leq<less_op> (v, sigma);
}

void mmx::sort

(

vector< T > &

v

)

[inline]

Definition at line 49 of file vector_sort.hpp.

                    {
  sort_leq<less_op> (v);
}

list<C> mmx::sort	(	const list< C > &	l,
		int(*)(const C &, const C &)	cmp
	)			[inline]

Sort l increasingly wrt to cmp. cmp (x, y) < 0 iff x < y, cmp (x, y) = 0 iff x = y, cmp (x, y) > 0 iff x > y.

Definition at line 54 of file list_sort.hpp.

References List, merge(), N(), n, and split().

Referenced by list_sort(), load_directory(), and vector_sort().

                                                      {
  nat n= N(l);
  if (n <= 1) return l;
  List head, tail;
  split (l, n>>1, head, tail);
  head= sort (head, cmp);
  tail= sort (tail, cmp);
  return merge (head, tail, cmp);
}

void mmx::sort_leq	(	vector< T > &	v,
		vector< nat > &	sigma
	)			[inline]

Definition at line 68 of file vector_sort.hpp.

References car(), cdr(), CF(), N(), Pair, and T.

                                            {
  typedef pair<T,nat> Pair;
  vector<Pair> tmp_v (Pair(T(),0), N(v)), merge_buf (Pair(T(),0), N(v));
  for (nat i= 0; i < N(v); i++) tmp_v[i]= Pair (v[i], i);  
  sort_sub<sort_op_pair_wrapper<Op> > (tmp_v, 0, N(v), merge_buf);
  sigma= fill<nat> (N(v), CF(v));
  for (nat i= 0; i < N(v); i++) sigma[i]= cdr (tmp_v[i]);
  for (nat i= 0; i < N(v); i++) v[i]    = car (tmp_v[i]);
}

void mmx::sort_leq

(

vector< T > &

v

)

[inline]

Definition at line 43 of file vector_sort.hpp.

References CF(), and N().

                        {
  vector<T> merge_buf= fill<T> (N(v), CF(v)); 
  sort_sub<Op> (v, 0, N(v), merge_buf);
}

static void mmx::sort_sub	(	vector< T > &	a,
		int	start,
		int	end,
		vector< T > &	merge_buf
	)			[inline, static]

Definition at line 20 of file vector_sort.hpp.

References middle().

                                                                  {
  if (end-start <= 1) return;
  if (end-start == 2) {
    if (!Op::op (a[start], a[start+1])) {
      merge_buf[start]= a[start];
      a[start]= a[start+1];
      a[start+1]= merge_buf[start];
    }
    return;
  }
  int middle= (start+end)>>1; 
  sort_sub<Op> (a, start, middle, merge_buf);
  sort_sub<Op> (a, middle, end, merge_buf);
  int i,j,k;
  for (i=start, j=middle, k=start; (i<middle) && (j<end); )
    if (Op::op (a[i], a[j])) merge_buf[k++]= a[i++];
    else                     merge_buf[k++]= a[j++];
  j=k;
  while (i!=middle) a[k++]= a[i++];
  for (i=start; i<j; i++) a[i]= merge_buf[i];
}

generic source_assign	(	const generic &	g1,
		const generic &	g2
	)

Definition at line 142 of file source_track.cpp.

References is_nil(), source_insert(), and source_locate().

                                                     {
  source_location l= source_locate (g2);
  if (!is_nil (l)) source_insert (g1, l);
  return g1;
}

string source_begin

(

const generic &

g

)

Definition at line 237 of file source_track.cpp.

References as_string(), source_column(), source_exists(), source_file(), and source_line().

                                {
  if (!source_exists (g)) return "Unknown location";
  return source_file (g) * ":" *
         as_string (source_line (g, false)) * ":" *
         as_string (source_column (g, false));
}

int source_column	(	const generic &	g,
		const bool &	last
	)

Definition at line 229 of file source_track.cpp.

References source_location::begin, source_position::column, source_location::end, is_nil(), and source_locate().

Referenced by source_begin(), and source_end().

                                                   {
  source_location l= source_locate (g);
  if (is_nil (l)) return 0;
  else if (last) return l.end.column;
  else return l.begin.column;
}

void source_delete

(

const generic &

g

)

Definition at line 129 of file source_track.cpp.

References reset(), and source_locs().

Referenced by source_extend().

                                 {
  reset (source_locs (), g);
}

string source_end

(

const generic &

g

)

Definition at line 245 of file source_track.cpp.

References as_string(), source_column(), source_exists(), source_file(), and source_line().

                              {
  if (!source_exists (g)) return "Unknown location";
  return source_file (g) * ":" *
         as_string (source_line (g, true)) * ":" *
         as_string (source_column (g, true));
}

string source_error	(	const string &	msg,
		const generic &	where
	)

Definition at line 336 of file source_track.cpp.

References as_string(), source_location::begin, source_position::column, is_nil(), source_position::line, literal_to_string(), mmerr, s, source_file(), source_locate(), source_underlined(), and strip_directory().

Referenced by source_exception().

                                                   {
  mmerr << ">>> g= " << g << "\n";
  string s;
  source_location l= source_locate (g);
  if (is_nil (l) && is<literal> (g))
    s << "Inside " << literal_to_string (g) << ": ";
  else if (is_nil (l))
    s << "Unknown location: ";
  else
    s << strip_directory (source_file (g)) << ":"
      << as_string (l.begin.line + 1) << ":" 
      << as_string (l.begin.column + 1) << ": ";
  s << msg << "\n"
    << source_underlined (g);
  return s;
}

string source_exception

(

const exception &

e

)

Definition at line 361 of file source_track.cpp.

References backtrace(), backtrace_depth, has_trace(), literal_to_string(), N(), source_error(), and trace_bottom().

Referenced by as_string(), and backtrace().

                                      {
  generic g= as<generic> (e);
  if (has_trace (g))
    return backtrace (trace_bottom (g, backtrace_depth));
  else {
    generic err= *e;
    if (is<literal> (err[1]))
      return source_error (literal_to_string (err[1]), err[N(err)-1]);
    else return source_error ("unknown", err[N(err)-1]);
  }
}

bool source_exists

(

const generic &

g

)

Definition at line 207 of file source_track.cpp.

References is_nil(), and source_locate().

Referenced by source_begin(), and source_end().

                                 {
  return !is_nil (source_locate (g));
}

generic mmx::source_extend	(	const generic &	g1,
		const generic &	g2,
		const generic &	g3
	)			[inline]

Definition at line 155 of file source_track.hpp.

References source_extend().

                                                                        {
  return source_extend (source_extend (g1, g2), g3);
}

generic source_extend	(	const generic &	g1,
		const generic &	g2
	)

Definition at line 149 of file source_track.cpp.

References source_location::obj, source_delete(), source_insert(), and source_locate().

Referenced by source_extend().

                                                     {
  //mmout << "source extending " << g1 << " with " << g2 <<"\n";
  source_location l;
  source_locate (g1, l);
  source_locate (g2, l);
  source_delete (g1);
  source_delete (g2);
  l.obj = g1;
  source_insert (g1, l);
  return g1;
}

string source_file

(

const generic &

g

)

Definition at line 212 of file source_track.cpp.

References as_string(), source_location::file_name, source_location::input_number, is_nil(), and source_locate().

Referenced by source_begin(), source_end(), and source_error().

                               {
  source_location l= source_locate (g);
  if (is_nil (l)) return "";
  else if (l.file_name == "")
    return "input[" * as_string (l.input_number + 1) * "]";
  else return l.file_name;
}

bool source_has_exact

(

const generic &

g

)

Definition at line 202 of file source_track.cpp.

References contains(), and source_locs().

                                    {
  return (source_locs () -> contains (g));
}

void source_insert	(	const generic &	g,
		const source_location &	l
	)

Definition at line 124 of file source_track.cpp.

References source_locs().

Referenced by source_assign(), and source_extend().

                                                           {
  source_locs () [g] = l;
}

int source_line	(	const generic &	g,
		const bool &	last
	)

Definition at line 221 of file source_track.cpp.

References source_location::begin, source_location::end, is_nil(), source_position::line, and source_locate().

Referenced by source_begin(), and source_end().

                                                 {
  source_location l= source_locate (g);
  if (is_nil (l)) return 0;
  else if (last) return l.end.line;
  else return l.begin.line;
}

generic source_link	(	const generic &	g,
		const generic &	h,
		const generic &	kind
	)

Definition at line 134 of file source_track.cpp.

References contains(), and source_locs().

                                                                        {
  (void) kind;
  table<source_location, generic, gen_eq_table>& t= source_locs ();
  if (!contains (t, g1) && contains (t, g2)) t[g1] = t[g2];
  return g1;
}

source_location source_locate

(

const generic &

g

)

Definition at line 191 of file source_track.cpp.

References source_locate().

                                 {
  source_location l;
  source_locate (g, l);
  return l;
}

void source_locate	(	const generic &	g,
		source_location &	l
	)

Definition at line 166 of file source_track.cpp.

References source_location::begin, contains(), source_location::end, source_location::file_name, source_location::input_number, is_nil(), max(), min(), N(), source_location::obj, read(), and source_locs().

Referenced by source_assign(), source_column(), source_error(), source_exists(), source_extend(), source_file(), source_line(), source_locate(), source_string(), source_string_unindented(), and source_underlined().

                                                     {
  // mmout << "source_locate: " << g << " @ " << inside (g) << "\n";
  source_location arg_l = l;
  if (source_locs () -> contains (g)) {
    source_location l1 = read (source_locs (), g);
    if (is_nil (l))
      l = l1;
    else 
      if (!is_nil (l1)) {
        l.obj = l1.obj;
        if (l.file_name == l1.file_name && l.input_number == l1.input_number) {
          l.begin = min (l.begin, l1.begin);
          l.end = max (l.end, l1.end);
        }
        // If the location is not 'connected', we leave l unchanged. 
      }
    return;
  }
  if (is<compound> (g))
    for (nat i=0; i<N(g); i++)
      source_locate (g[i], l);
  l.obj = g;
}

table<source_location, generic, gen_eq_table>& mmx::source_locs

(

)

Definition at line 114 of file source_track.cpp.

Referenced by source_delete(), source_has_exact(), source_insert(), source_link(), and source_locate().

               {
  static table<source_location, generic, gen_eq_table> t=
    table<source_location, generic, gen_eq_table> ();
  return t;
}

string source_string

(

const generic &

g

)

Definition at line 253 of file source_track.cpp.

References source_location::begin, source_location::end, source_location::file_name, get_source(), source_location::input_number, is_nil(), source_position::position, and source_locate().

                                 {
  source_location l= source_locate (g);
  if (is_nil (l)) return "";
  else {
    string src= get_source (l.file_name, l.input_number);
    return src (l.begin.position, l.end.position);
  }
}

string source_string_unindented

(

const generic &

g

)

Definition at line 263 of file source_track.cpp.

References add_indentation(), source_location::begin, source_position::column, source_location::end, source_location::file_name, get_indentation(), get_source(), source_location::input_number, is_nil(), source_position::position, repeated(), source_locate(), and sub().

                                            {
  source_location l= source_locate (g);
  if (is_nil (l)) return "";
  else {
    string src= get_source (l.file_name, l.input_number);
    string sub= src (l.begin.position, l.end.position);
    string bis= repeated (" ", l.begin.column) * sub;
    return add_indentation (bis, -((int) get_indentation (bis)));
  }
}

string source_underlined

(

const generic &

g

)

Definition at line 329 of file source_track.cpp.

References source_location::begin, source_location::end, source_location::file_name, source_location::input_number, is_nil(), source_locate(), and underlined().

Referenced by source_error().

                                     {
  source_location l= source_locate (g);
  if (is_nil (l)) return "";
  else return underlined (l.file_name, l.input_number, l.begin, l.end);
}

static string mmx::spaces

(

nat

indent

)

[static]

Definition at line 493 of file mmx_texmacs.cpp.

References s.

Referenced by scheme_to_tm().

                    {
  string s;
  for (nat i=0; i<indent; i++)
    s << " ";
  return s;
}

sparse_vector<C,T,V> mmx::sparse_mul_add	(	const sparse_vector< C, T, V > &	v1,
		const sparse_vector< C, T, V > &	v2,
		const C &	x
	)			[inline]

Definition at line 343 of file sparse_vector.hpp.

                                                                              {
  return _mul_add<mul_op> (v1, v2, x); }

generic specialize	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 848 of file generic.cpp.

References current_ev.

                                                          {
  return current_ev->apply ("specialize", x1, x2); }

generic specialize_alias

(

const generic &

a

)

Definition at line 60 of file alias.cpp.

References alias_specializer(), as(), get_alias(), and type().

                                    {
  generic val= get_alias (as<alias<generic> > (a));
  routine r;
  alias_specializer (type (val), r);
  return r->apply (a);
}

nat mmx::species_type

(

const generic &

g

)

[inline]

Definition at line 154 of file generic.hpp.

Referenced by is_list(), is_table(), and is_vector().

                                           {
  return g->get_species_type (); }

void mmx::split	(	const list< C > &	l,
		nat	n,
		list< C > &	head,
		list< C > &	tail
	)			[inline]

head := copy (l[0..n-1]), tail := copy (l[n..N (l)-1]).

Definition at line 27 of file list_sort.hpp.

References car(), cdr(), cons(), and List.

Referenced by sort().

                                                     {
  if (n == 0) {
    head= List ();
    tail= l;
  }
  else {
    split (cdr (l), n-1, head, tail);
    head= cons (car (l), head);
  }
}

vector<C,V> mmx::sqrt

(

const vector< C, V > &

v

)

[inline]

Definition at line 1177 of file vector.hpp.

{ return unary_map<sqrt_op> (v); }

table<C,T,V> mmx::sqrt

(

const table< C, T, V > &

t

)

[inline]

Definition at line 698 of file table.hpp.

{ return unary_map<sqrt_op> (t); }

syntactic sqrt

(

const syntactic &

g

)

Definition at line 427 of file syntactic.cpp.

References GEN_SQRT, and syn().

{ return syn (GEN_SQRT, g); }

new_table<C,T,V> mmx::sqrt

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 769 of file new_table.hpp.

{ return unary_map<sqrt_op> (t); }

generic sqrt

(

const generic &

x1

)

Definition at line 427 of file generic.cpp.

References ACC_SQRT, ACC_UNARY, current_ev, and GEN_SQRT.

                         {
  ACC_UNARY (ACC_SQRT, x1);
  return current_ev->apply (GEN_SQRT, x1);
}

double sqrt

(

const double &

x

)

[inline]

Definition at line 44 of file double.hpp.

Referenced by acosh(), asinh(), sqrt_op::def(), asinh_op::diff_op(), acosh_op::diff_op(), asin_op::diff_op(), acos_op::diff_op(), hypot(), sqrt_op::op(), and sqrt_op::set_op().

{ return std::sqrt (x); }

syntactic sqrt_init	(	const syntactic &	x,
		const syntactic &	c
	)

Definition at line 489 of file syntactic.cpp.

References syn().

                                                             {
  return syn ("sqrt_init", x, c); }

generic sqrt_init	(	const generic &	x,
		const generic &	c
	)

Definition at line 802 of file generic.cpp.

References current_ev.

Referenced by sqrt_op::op_init().

                                                         {
  return current_ev->apply ("sqrt_init", x1, x2); }

syntactic square

(

const syntactic &

g

)

Definition at line 280 of file syntactic.cpp.

References GEN_POWER, and syn().

                            {
  return syn (GEN_POWER, g, syntactic (2));
}

generic square

(

const generic &

x1

)

Definition at line 370 of file generic.cpp.

References ACC_SQUARE, ACC_UNARY, current_ev, and GEN_TIMES.

                           {
  ACC_UNARY (ACC_SQUARE, x1);
  return current_ev->apply (GEN_TIMES, x1, x1);
}

double square

(

const double &

x

)

[inline]

Definition at line 126 of file double.hpp.

{ return x * x; }

C mmx::square

(

const C &

x

)

[inline]

Definition at line 525 of file defaults.hpp.

Referenced by acosh(), asinh(), binpow(), atanh_op::diff_op(), asinh_op::diff_op(), acosh_op::diff_op(), tanh_op::diff_op(), atan_op::diff_op(), asin_op::diff_op(), acos_op::diff_op(), tan_op::diff_op(), ldiv_op::diff_op(), div_op::diff_op(), invert_op::diff_op(), GLUE_10(), GLUE_6(), GLUE_8(), hypot(), square_op::op(), powint(), square_op::set_op(), and sympow().

                    {
  return x * x;
}

bool mmx::starts	(	const string &	obj->lex_string,
		const string &	what
	)

Definition at line 344 of file string.cpp.

References N(), and s.

                                             {
  return N(s) >= N(what) && s (0, N(what)) == what;
}

bool mmx::starts	(	const string &	s,
		const string &	what
	)

Tell if s starts with what.

Referenced by ancestor_search_name(), as_texmacs(), complete(), decode_name(), file_is_script(), GLUE_11(), recursive_search_name(), resolve_name(), serialize(), texmacs_expand(), texmacs_to_scheme(), and unquote().

generic std_exception	(	const string &	msg,
		const generic &	a,
		const generic &	w
	)

Definition at line 25 of file exception.cpp.

References flatten_as_mmx(), gen(), and GEN_EXCEPTION.

                                                                          {
  exception exc (gen (GEN_EXCEPTION, msg * flatten_as_mmx (a), where));
  return as<generic> (exc);
}

generic std_exception	(	const string &	msg,
		const generic &	where
	)

Definition at line 20 of file exception.cpp.

References gen(), and GEN_EXCEPTION.

Referenced by type_mismatch(), and wrong_nr_args().

                                                        {
  return as<generic> (exception (gen (GEN_EXCEPTION, msg, where)));
}

void store_file_source	(	const string &	file_name,
		const string &	data
	)

Definition at line 66 of file source_track.cpp.

References file_sources, and tokenize().

Referenced by mmc_parse().

                                                                {
  file_sources [file_name] = tokenize (data, "\n");
}

void mmx::store_interactive_number

(

nat(obj->lex_length)

)

Definition at line 34 of file source_track.cpp.

References ASSERT, interactive_sources, N(), and range().

                                 {
  ASSERT (n <= N(interactive_sources), "input number out of range");
  interactive_sources= range (interactive_sources, 0, n);
}

void mmx::store_interactive_number

(

nat

n

)

Referenced by shell_load_session().

void mmx::store_interactive_source	(	const string &	data,
		nat(obj->lex_length)
	)

Definition at line 45 of file source_track.cpp.

References ASSERT, get_interactive_number(), interactive_sources, and tokenize().

                                                     {
  ASSERT (n <= get_interactive_number (), "input number out of range");
  vector<string> v= tokenize (data, "\n");
  if (n == get_interactive_number ()) interactive_sources << v;
  else interactive_sources[n]= v;
}

void mmx::store_interactive_source	(	const string &	data,
		nat	n = get_interactive_number()
	)

Referenced by shell_load_session(), and shell_terminal_input().

iterator<S> mmx::strict_range	(	const S &	start,
		const T &	end
	)			[inline]

Definition at line 359 of file iterator.hpp.

References range_iterator().

                                            {
  return range_iterator (start, outplace_set_as<S> (end),
                         outplace_set_as<S> (1), true);
}

int mmx::string_as_charcode

(

const string &

s

)

[inline]

Definition at line 146 of file string.hpp.

References ASSERT, and N().

Referenced by GLUE_23().

                                                {
  ASSERT (N(s) == 1, "single character expected");
  return (int) s[0]; }

literal mmx::string_as_literal

(

const string &

s

)

[inline]

Definition at line 60 of file mmc_glue.hpp.

                                    {
  return literal (s);
}

string mmx::string_as_mmx

(

const string &

obj->lex_string

)

Definition at line 989 of file mmx_printer.cpp.

                                {
  //if (math_mode) { ... }
  return s;
}

string string_as_mmx

(

const string &

s

)

Referenced by operator<<().

C mmx::string_as_numeric

(

const string &

s

)

[inline]

Definition at line 214 of file string.hpp.

References C.

                                    {
  C val;
  (void) string_to_numeric<C> (s, val);
  return val;
}

void mmx::string_to_floating	(	const string &	obj->lex_string,
		C &	val,
		const char *	fm
	)			[inline]

Definition at line 227 of file string.cpp.

References inside(), max(), and N().

Referenced by string_to_numeric().

                                                             {
  nat n= max (N(s), (nat) 39);
  char buffer[40];
  strncpy (buffer, inside (s, 0), n);
  buffer [n]= '\0';
  sscanf (buffer, fm, &val);
}

bool mmx::string_to_numeric	(	const string &	obj->lex_string,
		long double &	x
	)			[inline]

Definition at line 247 of file string.cpp.

References is_floating_string(), and string_to_floating().

                                                               {
  string_to_floating (s, x, "%Lf");
  return is_floating_string (s); }

bool mmx::string_to_numeric	(	const string &	obj->lex_string,
		double &	x
	)			[inline]

Definition at line 244 of file string.cpp.

References is_floating_string(), and string_to_floating().

                                                          {
  string_to_floating (s, x, "%lf");
  return is_floating_string (s); }

bool mmx::string_to_numeric	(	const string &	obj->lex_string,
		float &	x
	)			[inline]

Definition at line 241 of file string.cpp.

References is_floating_string(), and string_to_floating().

                                                         {
  string_to_floating (s, x, "%f");
  return is_floating_string (s); }

bool mmx::string_to_numeric	(	const string &	s,
		long double &	val
	)			[inline]

bool mmx::string_to_numeric	(	const string &	s,
		double &	val
	)			[inline]

bool mmx::string_to_numeric	(	const string &	s,
		float &	val
	)			[inline]

bool mmx::string_to_numeric	(	const string &	s,
		C &	val
	)			[inline]

Definition at line 171 of file string.hpp.

References C, N(), and n.

                                            {
  nat i= 0, n= N(s);
  val= 0;
  if (n == 0) return false;
  C eps= 1;
  bool ok= true;
  if (s[0] == '-') {
    i++;
    eps= -1;
    if (eps > 0) ok= false;
  }
  if (i == n) return false;
  while (i < n) {
    if (s[i] < '0' || s[i] > '9') return false;
    C c= (C) (s[i] - '0');
    C r= 10 * val + (eps * c);
    if (val != (r / 10)) ok= false;
    val= r;
  }
  return ok;
}

string strip_directory

(

const string &

name

)

Definition at line 443 of file system.cpp.

References N().

Referenced by recursive_search_name(), and source_error().

                                     {
  if (N(name) == 1 && name[0] == '/') return name;
  for (int i= N(name)-1; i>=0; i--)
    if (name[i]=='/')
      return name (i+1, N(name));
  return name;
}

string strip_extension

(

const string &

name

)

Definition at line 452 of file system.cpp.

References N().

                                     {
  for (int i= N(name)-1; i>=0; i--)
    if (name[i]=='.')
      return name (0, i);
    else if (name[i]=='/')
      return name;
  return name;
}

static string mmx::strip_preamble

(

const string &

s

)

[static]

Definition at line 73 of file mmc_glue.cpp.

References N(), and s.

Referenced by mmc_parse().

                                 {
  string preamble= "#!/usr/bin/env mmx-light\n";
  if (N(s) >= N(preamble) && s (0, N(preamble)) == preamble)
    return s (N(preamble)-1, N(s));
  return s;
}

void mmx::sub	(	R &	x,
		const C1 &	y1,
		const C2 &	y2
	)			[inline]

Definition at line 56 of file operators.hpp.

Referenced by lsub_op::set_op(), rsub_op::set_op(), sub_op::set_op(), and source_string_unindented().

{ x= y1 - y2; }

T mmx::sub_operator	(	const T &	x,
		const T &	y
	)			[inline]

Definition at line 32 of file operators.hpp.

{ return x-y; }

generic substitute	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 696 of file generic.cpp.

References current_ev, and GEN_SUBSTITUTE.

                                                          {
  return current_ev->apply (GEN_SUBSTITUTE, x1, x2); }

vector<C,V> mmx::sup	(	const vector< C, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 1126 of file vector.hpp.

                                                   {
  return binary_map<sup_op> (v, w); }

table<C,T,V> mmx::sup	(	const table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 641 of file table.hpp.

                                                       {
  return binary_map<sup_op,C,T,V> (t, u); }

sparse_vector<C,T,V> mmx::sup	(	const sparse_vector< C, T, V > &	t,
		const sparse_vector< C, T, V > &	u
	)			[inline]

Definition at line 271 of file sparse_vector.hpp.

                                                     {
  return binary_map<sup_op,C,T,V> (t, u); }

new_table<C,T,V> mmx::sup	(	const new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 712 of file new_table.hpp.

                                                       {
  return binary_map<sup_op,C,T,V> (t, u); }

C mmx::sup	(	const C &	x,
		const C &	y
	)			[inline]

Definition at line 480 of file defaults.hpp.

References max().

Referenced by sup_op::op(), and sup_op::set_op().

{ return max (x, y); }

bool mmx::supports_color

(

)

Definition at line 25 of file formatting_port.cpp.

References color_mode, get_env(), and texmacs_mode.

Referenced by formatting_port_rep::format().

                  {
  static bool terminal_supports_color=
    get_env ("TERM") == string ("xterm") ||
    get_env ("TERM") == string ("xterm-color") ||
    get_env ("TERM") == string ("xterm-256color");
  return terminal_supports_color && !texmacs_mode && color_mode;
}

void mmx::swap	(	C &	x,
		C &	y
	)			[inline]

Definition at line 755 of file defaults.hpp.

References C.

Referenced by heap_rep< C >::correct_downwards(), and heap_rep< C >::correct_upwards().

                  {
  C temp= x;
  x= y;
  y= temp;
}

nat mmx::symbolic_type

(

const generic &

g

)

[inline]

Definition at line 152 of file generic.hpp.

                                            {
  return g->get_symbolic_type (); }

C mmx::sympow	(	const C &	c,
		const ZZ &	i
	)			[inline]

Definition at line 559 of file defaults.hpp.

References invert(), pow(), promote(), and square().

                                 {
  switch (i) {
  case -2: return invert (square (c));
  case -1: return invert (c);
  case  0: return promote (1, c);
  case  1: return c;
  case  2: return square (c);
  case  3: return c * square (c);
  case  4: return square (square (c));
  default: return pow (c, i);
  }
}

syntactic mmx::syn	(	const generic &	f,
		const vector< syntactic > &	a
	)			[inline]

Definition at line 134 of file syntactic.hpp.

References as_syntactic(), and gen().

                                                                    {
  const vector<generic>* ptr= (vector<generic>*) ((void*) (&a));
  return as_syntactic (gen (f, *ptr)); }

syntactic mmx::syn	(	const generic &	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3,
		const syntactic &	a4
	)			[inline]

Definition at line 130 of file syntactic.hpp.

References as_syntactic(), and gen().

                                                                {
  return as_syntactic (gen (f, *a1, *a2, *a3, *a4)); }

syntactic mmx::syn	(	const generic &	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3
	)			[inline]

Definition at line 127 of file syntactic.hpp.

References as_syntactic(), and gen().

                                                                {
  return as_syntactic (gen (f, *a1, *a2, *a3)); }

syntactic mmx::syn	(	const generic &	f,
		const syntactic &	a1,
		const syntactic &	a2
	)			[inline]

Definition at line 124 of file syntactic.hpp.

References as_syntactic(), and gen().

                                           {
  return as_syntactic (gen (f, *a1, *a2)); }

syntactic mmx::syn	(	const generic &	f,
		const syntactic &	a1
	)			[inline]

Definition at line 122 of file syntactic.hpp.

References as_syntactic(), and gen().

                                                             {
  return as_syntactic (gen (f, *a1)); }

syntactic mmx::syn

(

const generic &

f

)

[inline]

Definition at line 120 of file syntactic.hpp.

References as_syntactic(), and gen().

                                        {
  return as_syntactic (gen (f)); }

syntactic mmx::syn	(	const char *	f,
		const vector< syntactic > &	a
	)			[inline]

Definition at line 116 of file syntactic.hpp.

References as_syntactic(), and gen().

                                                                 {
  const vector<generic>* ptr= (vector<generic>*) ((void*) (&a));
  return as_syntactic (gen (generic (f), *ptr)); }

syntactic mmx::syn	(	const char *	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3,
		const syntactic &	a4
	)			[inline]

Definition at line 112 of file syntactic.hpp.

References as_syntactic(), and gen().

                                                                {
  return as_syntactic (gen (generic (f), *a1, *a2, *a3, *a4)); }

syntactic mmx::syn	(	const char *	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3
	)			[inline]

Definition at line 109 of file syntactic.hpp.

References as_syntactic(), and gen().

                                                                {
  return as_syntactic (gen (generic (f), *a1, *a2, *a3)); }

syntactic mmx::syn	(	const char *	f,
		const syntactic &	a1,
		const syntactic &	a2
	)			[inline]

Definition at line 106 of file syntactic.hpp.

References as_syntactic(), and gen().

                                           {
  return as_syntactic (gen (generic (f), *a1, *a2)); }

syntactic mmx::syn	(	const char *	f,
		const syntactic &	a1
	)			[inline]

Definition at line 104 of file syntactic.hpp.

References as_syntactic(), and gen().

                                                          {
  return as_syntactic (gen (generic (f), *a1)); }

syntactic mmx::syn

(

const char *

f

)

[inline]

Definition at line 102 of file syntactic.hpp.

References as_syntactic(), and gen().

                                     {
  return as_syntactic (gen (generic (f))); }

syntactic mmx::syn	(	const syntactic &	f,
		const vector< syntactic > &	a
	)			[inline]

Definition at line 98 of file syntactic.hpp.

References as_syntactic(), and gen().

                                                                      {
  const vector<generic>* ptr= (vector<generic>*) ((void*) (&a));
  return as_syntactic (gen (*f, *ptr)); }

syntactic mmx::syn	(	const syntactic &	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3,
		const syntactic &	a4
	)			[inline]

Definition at line 94 of file syntactic.hpp.

References as_syntactic(), and gen().

                                                                {
  return as_syntactic (gen (*f, *a1, *a2, *a3, *a4)); }

syntactic mmx::syn	(	const syntactic &	f,
		const syntactic &	a1,
		const syntactic &	a2,
		const syntactic &	a3
	)			[inline]

Definition at line 91 of file syntactic.hpp.

References as_syntactic(), and gen().

                                                                {
  return as_syntactic (gen (*f, *a1, *a2, *a3)); }

syntactic mmx::syn	(	const syntactic &	f,
		const syntactic &	a1,
		const syntactic &	a2
	)			[inline]

Definition at line 88 of file syntactic.hpp.

References as_syntactic(), and gen().

                                           {
  return as_syntactic (gen (*f, *a1, *a2)); }

syntactic mmx::syn	(	const syntactic &	f,
		const syntactic &	a1
	)			[inline]

Definition at line 86 of file syntactic.hpp.

References as_syntactic(), and gen().

                                                               {
  return as_syntactic (gen (*f, *a1)); }

syntactic mmx::syn

(

const syntactic &

f

)

[inline]

Definition at line 84 of file syntactic.hpp.

References as_syntactic(), and gen().

Referenced by abs(), access(), acos(), acos_init(), acosh(), arg(), asin(), asin_init(), asinh(), atan(), atan2(), atan_init(), atanh(), center(), conj(), cos(), cosh(), denominator(), derive(), exp(), input_output_string_port_rep::expression(), input_string_port_rep::expression(), output_string_port_rep::expression(), socket_port_rep::expression(), error_port_rep::expression(), pipe_port_rep::expression(), formatting_port_rep::expression(), file_port_rep::expression(), composite_port_rep::expression(), flatten(), gcd(), hypot(), Im(), inject(), integrate(), integrate_init(), lcm(), log(), log_init(), lshiftz(), migrate_sub(), numerator(), operator*(), operator+(), operator-(), operator/(), operator<<(), operator>>(), pow(), project(), radius(), Re(), rshiftz(), sin(), sinh(), solve_lde_init(), sqrt(), sqrt_init(), square(), tan(), tanh(), trig(), xderive(), and xgcd().

                                          {
  return as_syntactic (gen (*f)); }

string sysconf_dir

(

)

Definition at line 245 of file system.cpp.

References _from_dos_to_unix(), eval_system(), get_env(), and prefix_dir().

               {
  string dir= get_env ("MMX_SYSCONF_DIR");
#if defined(__MINGW__) || defined(__MINGW32__)
  if (dir == "") {
    try { dir= eval_system ("basix-config --sysconfdir"); }
    catch (const exception&) { dir= prefix_dir () * "/etc"; } 
  }
#else
  if (dir == "") dir= eval_system ("basix-config --sysconfdir");
#endif
  return _from_dos_to_unix (dir);
}

int mmx::system

(

const string &

obj->lex_string

)

Definition at line 156 of file system.cpp.

References as_charp(), free_charp(), and system().

                         {
  //mmout << "system: " << s << "\n";
  char* _s= as_charp (s);
  int r= ::system (_s);
  free_charp (_s);
  return r;
}

int mmx::system

(

const string &

s

)

Referenced by connect_to_server(), eval_system(), pipe_port(), system(), var_mkdir(), and var_rm().

bool mmx::table_contains	(	const table< D, generic > &	t,
		const generic &	x,
		const generic &	y
	)			[inline]

Definition at line 370 of file mmc_glue.hpp.

References gen(), and GEN_TUPLE.

                                                    {
  return t->contains (gen (GEN_TUPLE, x, y));
}

bool mmx::table_contains	(	const table< D, generic > &	t,
		const generic &	x
	)			[inline]

Definition at line 345 of file mmc_glue.hpp.

                                                             {
  return t->contains (x);
}

iterator<generic> mmx::table_explode

(

const table< D, generic > &

t

)

[inline]

Definition at line 340 of file mmc_glue.hpp.

References entries().

                                          {
  return entries (t);
}

table<D,generic> mmx::table_new

(

const D &

x

)

[inline]

Definition at line 330 of file mmc_glue.hpp.

                       {
  return table<D,generic> (x, 1);
}

D mmx::table_read	(	const table< D, generic > &	t,
		const generic &	x,
		const generic &	y
	)			[inline]

Definition at line 381 of file mmc_glue.hpp.

References gen(), and GEN_TUPLE.

                                                                           {
  return t[gen (GEN_TUPLE, x, y)];
}

D mmx::table_read	(	const table< D, generic > &	t,
		const generic &	x
	)			[inline]

Definition at line 355 of file mmc_glue.hpp.

                                                         {
  return t[x];
}

void mmx::table_reset	(	const table< D, generic > &	t,
		const generic &	x,
		const generic &	y
	)			[inline]

Definition at line 376 of file mmc_glue.hpp.

References gen(), GEN_TUPLE, inside(), and reset().

                                                                            {
  return inside (t) -> reset (gen (GEN_TUPLE, x, y));
}

void mmx::table_reset	(	table< D, generic > &	t,
		const generic &	x
	)			[inline]

Definition at line 350 of file mmc_glue.hpp.

References reset().

                                                    {
  reset (t, x);
}

void mmx::table_set	(	const table< D, generic > &	t,
		const generic &	x,
		const generic &	y,
		const D &	v
	)			[inline]

Definition at line 391 of file mmc_glue.hpp.

References gen(), GEN_TUPLE, and inside().

                       {
  inside (t) -> set (gen (GEN_TUPLE, x, y)) = v;
}

void mmx::table_set	(	const table< D, generic > &	t,
		const generic &	x,
		const D &	v
	)			[inline]

Definition at line 365 of file mmc_glue.hpp.

References inside().

                                                                    {
  inside (t) -> set (x) = v;
}

int mmx::table_size

(

const table< D, generic > &

t

)

[inline]

Definition at line 335 of file mmc_glue.hpp.

References N().

                                       {
  return (int) N(t);
}

D& mmx::table_write	(	table< D, generic > &	t,
		const generic &	x,
		const generic &	y
	)			[inline]

Definition at line 386 of file mmc_glue.hpp.

References gen(), and GEN_TUPLE.

                                                                      {
  return t[gen (GEN_TUPLE, x, y)];
}

D& mmx::table_write	(	table< D, generic > &	t,
		const generic &	x
	)			[inline]

Definition at line 360 of file mmc_glue.hpp.

                                                    {
  return t[x];
}

vector<C,V> mmx::tan

(

const vector< C, V > &

v

)

[inline]

Definition at line 1182 of file vector.hpp.

{ return unary_map<tan_op> (v); }

table<C,T,V> mmx::tan

(

const table< C, T, V > &

t

)

[inline]

Definition at line 703 of file table.hpp.

{ return unary_map<tan_op> (t); }

syntactic tan

(

const syntactic &

g

)

Definition at line 432 of file syntactic.cpp.

References GEN_TAN, and syn().

{ return syn (GEN_TAN, g); }

new_table<C,T,V> mmx::tan

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 774 of file new_table.hpp.

{ return unary_map<tan_op> (t); }

generic tan

(

const generic &

x1

)

Definition at line 457 of file generic.cpp.

References ACC_TAN, ACC_UNARY, current_ev, and GEN_TAN.

                        {
  ACC_UNARY (ACC_TAN, x1);
  return current_ev->apply (GEN_TAN, x1);
}

double tan

(

const double &

x

)

[inline]

Definition at line 51 of file double.hpp.

Referenced by tan_op::op(), tan_op::op_init(), and tan_op::set_op().

{ return std::tan (x); }

syntactic tanh

(

const syntactic &

g

)

Definition at line 438 of file syntactic.cpp.

References GEN_TH, and syn().

{ return syn (GEN_TH, g); }

generic tanh

(

const generic &

x1

)

Definition at line 493 of file generic.cpp.

References ACC_TANH, ACC_UNARY, and exp().

                         {
  ACC_UNARY (ACC_TANH, x1);
  return (exp (x1) - exp (-x1)) / (exp (x1) + exp (-x1));
}

double tanh

(

const double &

x

)

[inline]

Definition at line 54 of file double.hpp.

References tanh().

{ return std::tanh (x); }

C mmx::tanh

(

const C &

x

)

[inline]

Definition at line 593 of file defaults.hpp.

References exp().

Referenced by tanh_op::op(), tanh_op::op_init(), tanh_op::set_op(), and tanh().

                                                {
  return (exp (x) - exp (-x)) / (exp (x) + exp (-x)); }

void mmx::term_threads

(

)

Definition at line 223 of file threads.cpp.

{}

routine mmx::ternary_routine	(	const generic &	name,
		D(*)(const S1 &, const S2 &, const S3 &)	f
	)			[inline]

Definition at line 315 of file routine.hpp.

Referenced by define().

                                                           {
  return new ternary_routine_rep<D,S1,S2,S3> (name, f);
}

static bool mmx::test_keyword	(	const char *	k,
		parse_instance *	obj
	)			[static]

Definition at line 65 of file mmx_lexer.cpp.

References INC_POS, is_alpha, n, pos, RESTORE_START, and s.

                                                  {
  RESTORE_START;
  while ((*k)!='\0') {
    if (pos>=n) return false;
    if (s[pos]!=(*k)) return false;
    INC_POS;
    k++;
  }
  if (pos>=n) return true;
  if (is_alpha (s[pos])) return false;
  return true;
}

void texmacs_command

(

const string &

cmd

)

Definition at line 36 of file mmx_texmacs.cpp.

References texmacs_pending.

Referenced by texmacs_dynamic_event().

                                    {
  texmacs_pending << " " << cmd << "\n";
}

void texmacs_dynamic_event	(	const string &	id,
		const generic &	val
	)

Definition at line 52 of file mmx_texmacs.cpp.

References as_generic(), as_texmacs_snippet(), flatten(), mmout, texmacs_command(), and texmacs_flush_commands().

Referenced by shell_texmacs_initialize().

                                                             {
  string v= as_texmacs_snippet (as_generic (flatten (val)));
  texmacs_command ("(locus-set \"" * id * "\" '" * v * ")");
  mmout << texmacs_flush_commands ();
}

generic texmacs_expand

(

const generic &

g

)

Definition at line 398 of file mmx_texmacs.cpp.

References gen(), is_func(), literal_to_string(), N(), and starts().

Referenced by serialize().

                                  {
  if (is_func (g, "tm$with"))
    return texmacs_expand (g[N(g)-1]);
  else if (is_func (g, "tm$itemize", 1) || is_func (g, "tm$enumerate", 1))
    return gen ("$indent", texmacs_expand (g[1]));
  else if (is_func (g, "tm$item", 0))
    return generic ("* ");
  else if (is_func (g, "tm$folded", 2))
    return gen ("$varindent",
                gen ("$concat",
                     generic ("o "), texmacs_expand (g[1])));
  else if (is_func (g, "tm$unfolded", 2))
    return gen ("$varindent",
                gen ("$concat",
                     generic ("* "), texmacs_expand (g[1]),
                     generic ("$lf"), texmacs_expand (g[2])));
  else if (is_func (g, "tm$folded-explain", 2))
    return texmacs_expand (g[1]);
  else if (is_func (g, "tm$unfolded-explain", 2))
    return gen ("$concat", texmacs_expand (g[1]),
                generic ("$lf"), generic ("$lf"), texmacs_expand (g[2]));
  else if (is_func (g, "tm$explain", 2))
    return gen ("$concat", texmacs_expand (g[1]), generic ("$lf"),
                gen ("$indent", texmacs_expand (g[2])));
  else if (is_func (g, "tm$explain-synopsis", 1))
    return gen ("$concat", generic (" --- "), texmacs_expand (g[1]));
  else if (is<compound> (g)) {
    vector<generic> v;
    for (nat i=1; i<N(g); i++) v << texmacs_expand (g[i]);
    if (is<literal> (g[0]) && starts (literal_to_string (g[0]), "tm$")) {
      if (N(v) == 1) return v[0];
      else return gen ("$concat", v);
    }
    else return gen (g[0], v);
  }
  else return g;
}

string texmacs_flush_commands

(

)

Definition at line 41 of file mmx_texmacs.cpp.

References DATA_BEGIN, DATA_END, s, and texmacs_pending.

Referenced by shell_texmacs_input(), and texmacs_dynamic_event().

                          {
  if (texmacs_pending == "") return "";
  string s=
    string (DATA_BEGIN) *
    "command:(begin" * texmacs_pending * ")" *
    string (DATA_END);
  texmacs_pending= "";
  return s;
}

static table<generic,generic> mmx::texmacs_symbol_table

(

)

[static]

Definition at line 100 of file mmx_texmacs.cpp.

References init().

Referenced by as_texmacs().

                        {
  table<generic,generic> t;

  init (t, "/\\", "tm$wedge");
  init (t, "mathcatalan", "tm$mathcatalan");
  init (t, "@", "tm$circ");
  init (t, "><", "tm$join");
  init (t, "derivative", "D");
  init (t, "mathe", "tm$mathe");
  init (t, "<=>", "tm$Leftrightarrow");
  init (t, "matheuler", "tm$matheuler");
  init (t, ">", "tm$gtr");
  init (t, ">=", "tm$geqslant");
  init (t, ">>", "tm$gg");
  init (t, "mathi", "tm$mathi");
  init (t, "=>", "tm$Rightarrow");
  init (t, "Infty", "tm$infty");
  init (t, "->", "tm$rightarrow");
  init (t, "<", "tm$less");
  init (t, "<=", "tm$leqslant");
  init (t, "<<", "tm$ll");
  init (t, ":->", "tm$mapsto");
  init (t, ".!", "!");
  init (t, "!", "tm$neg");
  init (t, "\\/", "tm$vee");
  init (t, "partial", "tm$partial");
  init (t, "mathpi", "tm$mathpi");
  init (t, ".'", "'");
  init (t, ".`", "`");
  init (t, "..", "tm$ldots");
  init (t, "::", "tm$colons");
  init (t, ":>", "tm$transtype");
  init (t, "!=", "tm$neq");
  init (t, "|", "|");
  init (t, "||", "tm$||");
  init (t, "xor", "tm$veebar");
  init (t, ":=", "tm$assign");
  init (t, "+=", "tm$plusassign");
  init (t, "-=", "tm$minusassign");
  init (t, "*=", "tm$astassign");
  init (t, "/=", "tm$overassign");

  init (t, "alpha", "tm$alpha");
  init (t, "beta", "tm$beta");
  init (t, "gamma", "tm$gamma");
  init (t, "delta", "tm$delta");
  init (t, "epsilon", "tm$varepsilon");
  init (t, "zeta", "tm$zeta");
  init (t, "eta", "tm$eta");
  init (t, "theta", "tm$theta");
  init (t, "iota", "tm$iota");
  init (t, "kappa", "tm$kappa");
  init (t, "lambda", "tm$lambda");
  init (t, "mu", "tm$mu");
  init (t, "nu", "tm$nu");
  init (t, "xi", "tm$xi");
  init (t, "omicron", "tm$omicron");
  init (t, "pi", "tm$pi");
  init (t, "rho", "tm$rho");
  init (t, "sigma", "tm$sigma");
  init (t, "tau", "tm$tau");
  init (t, "upsilon", "tm$upsilon");
  init (t, "phi", "tm$varphi");
  init (t, "chi", "tm$chi");
  init (t, "psi", "tm$psi");
  init (t, "omega", "tm$omega");

  init (t, "Alpha", "tm$Alpha");
  init (t, "Beta", "tm$Beta");
  init (t, "Gamma", "tm$Gamma");
  init (t, "Delta", "tm$Delta");
  init (t, "Epsilon", "tm$Epsilon");
  init (t, "Zeta", "tm$Zeta");
  init (t, "Eta", "tm$Eta");
  init (t, "Theta", "tm$Theta");
  init (t, "Iota", "tm$Iota");
  init (t, "Kappa", "tm$Kappa");
  init (t, "Lambda", "tm$Lambda");
  init (t, "Mu", "tm$Mu");
  init (t, "Nu", "tm$Nu");
  init (t, "Xi", "tm$Xi");
  init (t, "Omicron", "tm$Omicron");
  init (t, "Pi", "tm$Pi");
  init (t, "Rho", "tm$Rho");
  init (t, "Sigma", "tm$Sigma");
  init (t, "Tau", "tm$Tau");
  init (t, "Upsilon", "tm$Upsilon");
  init (t, "Phi", "tm$Phi");
  init (t, "Chi", "tm$Chi");
  init (t, "Psi", "tm$Psi");
  init (t, "Omega", "tm$Omega");

  return t;
}

static void mmx::texmacs_to_scheme	(	string &	obj->lex_string,
		const generic &	g
	)			[static]

Definition at line 441 of file mmx_texmacs.cpp.

References ASSERT, compound_to_vector(), ERROR, literal_to_string(), mmerr, N(), quote(), and starts().

Referenced by as_snippet(), as_texmacs_scheme(), and as_texmacs_snippet().

                                                {
  //mmerr << "g= " << as_lisp (g) << "\n";
  if (is<literal> (g)) s << quote (literal_to_string (g));
  else if (is<compound> (g) && is<literal> (g[0]) &&
           literal_to_string (g[0]) == " ")
    s << "\" \"";
  else if (is<compound> (g) && is<literal> (g[0])) {
    string op= literal_to_string (g[0]);
    if (starts (op, "tm$")) op= op (2, N(op));
    if (!starts (op, "$")) {
      mmerr << "op  = " << op << "\n";
      mmerr << "args= " << compound_to_vector (g) << "\n";
    }
    ASSERT (starts (op, "$"), "invalid TeXmacs markup");
    s << "(" << op (1, N(op));
    for (nat i=1; i<N(g); i++) {
      s << " ";
      texmacs_to_scheme (s, g[i]);
    }
    s << ")";
  }
  else ERROR ("invalid TeXmacs markup");
}

syntactic& mmx::the_polynomial_var

(

)

Definition at line 560 of file syntactic.cpp.

                      {
  static syntactic v ("x");
  return v;
}

syntactic& mmx::the_series_var

(

)

Definition at line 554 of file syntactic.cpp.

                  {
  static syntactic v ("z");
  return v;
}

C3 mmx::third

(

const triple< C1, C2, C3 > &

t

)

[inline]

Definition at line 42 of file triple.hpp.

{ return t.x3; }

void mmx::threads_execute	(	task *	ts,
		nat(obj->lex_length)
	)

Definition at line 224 of file threads.cpp.

References inside().

                                       {
  for (nat i=0; i<n; i++) inside (ts[i]) -> execute (); }

void mmx::threads_execute	(	task *	ts,
		nat	n
	)

Referenced by threads_simple_loop().

int threads_get_number

(

)

Definition at line 219 of file threads.cpp.

{ return 1; }

void mmx::threads_initialize

(

nat(obj->lex_length)

)

Definition at line 217 of file threads.cpp.

{ (void) n; }

void mmx::threads_initialize

(

nat

n

)

void mmx::threads_set_number

(

const int &

obj->lex_length

)

Definition at line 220 of file threads.cpp.

References ASSERT.

                                       {
  ASSERT (n == 1, "multithreading disabled"); }

void mmx::threads_set_number

(

const int &

n

)

void threads_simple_loop	(	nat	nr_instances,
		nat	nr_iterations
	)

Definition at line 282 of file threads.cpp.

References threads_execute().

                                                          {
  task ts[nr_instances];
  for (nat id=0; id<nr_instances; id++)
    ts[id]= new loop_task_rep (nr_iterations);
  threads_execute (ts, nr_instances);
}

void threads_terminate

(

)

Definition at line 218 of file threads.cpp.

{}

double times_infinity

(

const double &

x

)

[inline]

Definition at line 38 of file double.hpp.

Referenced by GLUE_42(), and set_infinity().

{ return x * HUGE_VAL; }

vector<string> mmx::tokenize	(	const string &	obj->lex_string,
		const string &	sep,
		bool	keep
	)

Definition at line 592 of file string.cpp.

References ASSERT, min(), N(), s, and start.

                                                         {
  ASSERT (N(sep) != 0, "separator should be non-empty");
  vector<string> v;
  nat start= 0;
  while (start < N(s)) {
    nat end= start;
    while (end < N(s) &&
           (s[end] != sep[0] || s (end, min (N(s), end + N(sep))) != sep))
      end++;
    if (keep) v << (s (start, end) * sep);
    else v << s (start, end);
    start= end + N(sep);
  }
  return v;
}

vector<string> mmx::tokenize	(	const string &	s,
		const string &	sep,
		bool	keep = false
	)

Cut into pieces, using as a separator.

Referenced by add_indentation(), documentify(), get_indentation(), resolve_name(), shell_load_session(), shell_texmacs_input(), store_file_source(), and store_interactive_source().

generic trace_bottom	(	const generic &	exc,
		nat	n = 1
	)

Definition at line 76 of file exception.cpp.

References trace_depth(), and trace_pull().

Referenced by source_exception().

                                         {
  generic g= exc;
  nat d= trace_depth (exc);
  for (nat i=n; i<d; i++) g= trace_pull (g);
  return g;
}

nat mmx::trace_depth

(

const generic &

exc

)

Definition at line 70 of file exception.cpp.

References has_trace(), and trace_pull().

Referenced by trace_bottom().

                                 {
  if (has_trace (exc)) return trace_depth (trace_pull (exc)) + 1;
  else return 1;
}

generic trace_pull

(

const generic &

exc

)

Definition at line 54 of file exception.cpp.

References ASSERT, gen(), GEN_BACKTRACE, GEN_EXCEPTION, and is_func().

Referenced by backtrace(), trace_bottom(), and trace_depth().

                                {
  generic msg= *as<exception> (exc);
  ASSERT (is_func (msg, GEN_EXCEPTION, 2), "invalid exception");
  ASSERT (is_func (msg[2], GEN_BACKTRACE, 2), "backtrace expected");
  return as<generic> (exception (gen (msg[0], msg[1], msg[2][2])));
}

generic trace_push	(	const generic &	exc,
		const generic &	where
	)

Definition at line 46 of file exception.cpp.

References ASSERT, gen(), GEN_BACKTRACE, GEN_EXCEPTION, and is_func().

                                                      {
  generic msg= *as<exception> (exc);
  ASSERT (is_func (msg, GEN_EXCEPTION, 2), "invalid exception");
  generic w= gen (GEN_BACKTRACE, where, msg[2]);
  return as<generic> (exception (gen (msg[0], msg[1], w)));
}

generic trace_top

(

const generic &

exc

)

Definition at line 62 of file exception.cpp.

References ASSERT, gen(), GEN_BACKTRACE, GEN_EXCEPTION, and is_func().

Referenced by backtrace().

                               {
  generic msg= *as<exception> (exc);
  ASSERT (is_func (msg, GEN_EXCEPTION, 2), "invalid exception");
  ASSERT (is_func (msg[2], GEN_BACKTRACE, 2), "backtrace expected");
  return as<generic> (exception (gen (msg[0], "backtrace", msg[2][1])));
}

vector<C> mmx::trig

(

const vector< C > &

v

)

[inline]

Definition at line 1409 of file vector.hpp.

References cos(), sin(), and vec().

                                                         {
  return vec (cos (v[0]), sin (v[0])); }

syntactic trig

(

const syntactic &

g

)

Definition at line 443 of file syntactic.cpp.

References cos(), GEN_SQTUPLE, sin(), and syn().

                                    {
  return syn (GEN_SQTUPLE, cos (g), sin (g)); }

generic trig

(

const generic &

x1

)

Definition at line 547 of file generic.cpp.

References comma(), cos(), sin(), and xsqtuple().

Referenced by trig_op::op(), trig_op::op_init(), and trig_op::set_op().

                                 {
  return xsqtuple (comma (cos (x1), sin (x1))); }

mmx::TRUE_IDENTITY_OP_SUGAR	(	template< typename C >	,
		chain< C >
	)

generic trunc

(

const generic &

x

)

Definition at line 751 of file generic.cpp.

References current_ev, and GEN_TRUNC.

                                 {
  return current_ev->apply (GEN_TRUNC, x); }

double trunc

(

const double &

x

)

[inline]

Definition at line 130 of file double.hpp.

Referenced by trunc_op::op(), and trunc_op::set_op().

{ return ::trunc (x); }

vector<typename binary_return_type_helper<truncate_op, C ,nat>::RET> mmx::truncate	(	const vector< C, V > &	v,
		nat	n
	)			[inline]

Definition at line 1300 of file vector.hpp.

Referenced by truncate_op::set_op().

                                                        {
  return as<Truncated_vector> (binary_map_scalar<truncate_op> (v, n)); }

C& mmx::ttable_access	(	table< C, generic > &	t,
		const generic &	a,
		const generic &	b,
		const vector< generic > &	c
	)			[inline]

Definition at line 835 of file table.hpp.

References cons().

                                                                  {
  return t[cons (a, cons (b, c))];
}

C mmx::ttable_access	(	const table< C, generic > &	t,
		const generic &	a,
		const generic &	b,
		const vector< generic > &	c
	)			[inline]

Definition at line 830 of file table.hpp.

References cons().

                                                                        {
  return t[cons (a, cons (b, c))];
}

C& mmx::ttable_access	(	new_table< C, generic > &	t,
		const generic &	a,
		const generic &	b,
		const vector< generic > &	c
	)			[inline]

Definition at line 908 of file new_table.hpp.

References cons().

                                                                  {
  return t[cons (a, cons (b, c))];
}

C mmx::ttable_access	(	const new_table< C, generic > &	t,
		const generic &	a,
		const generic &	b,
		const vector< generic > &	c
	)			[inline]

Definition at line 903 of file new_table.hpp.

References cons().

Referenced by GLUE_19().

                                                                        {
  return t[cons (a, cons (b, c))];
}

bool mmx::ttable_contains	(	const table< C, generic > &	t,
		const generic &	a,
		const generic &	b,
		const vector< generic > &	c
	)			[inline]

Definition at line 825 of file table.hpp.

References cons(), and contains().

                                                                          {
  return contains (t, cons (a, cons (b, c)));
}

bool mmx::ttable_contains	(	const new_table< C, generic > &	t,
		const generic &	a,
		const generic &	b,
		const vector< generic > &	c
	)			[inline]

Definition at line 898 of file new_table.hpp.

References cons(), and contains().

Referenced by GLUE_18().

                                                                          {
  return contains (t, cons (a, cons (b, c)));
}

void mmx::ttable_reset	(	table< C, generic > &	t,
		const generic &	a,
		const generic &	b,
		const vector< generic > &	c
	)			[inline]

Definition at line 840 of file table.hpp.

References cons(), and reset().

                                                                 {
  reset (t, cons (a, cons (b, c)));
}

void mmx::ttable_reset	(	new_table< C, generic > &	t,
		const generic &	a,
		const generic &	b,
		const vector< generic > &	c
	)			[inline]

Definition at line 913 of file new_table.hpp.

References cons(), and reset().

                                                                 {
  reset (t, cons (a, cons (b, c)));
}

nat mmx::tuple_to_scalar

(

nat

id

)

[inline]

Definition at line 107 of file tuple.hpp.

References tuple_type_info().

                         {
  bool mode= false;
  tuple_type_info (id, mode);
  return id;
}

void tuple_type_info	(	nat &	id,
		bool &	mode
	)

Definition at line 17 of file tuple.cpp.

References new_type_id(), and read().

Referenced by is_tuple_type(), new_tuple_type_id(), and tuple_to_scalar().

                                      {
  static table<nat,nat> t (0);
  static table<nat,nat> u (0);
  if (mode == false) {
    mode= t->contains (id);
    id= read (t, id);
  }
  else {
    if (u->contains (id)) id= u[id];
    else {
      nat new_id= new_type_id ();
      t[new_id]= id;
      u[id]= new_id;
      id= new_id;
    }
  }
}

nat mmx::type

(

const generic &

g

)

[inline]

Definition at line 150 of file generic.hpp.

Referenced by as_generic(), get_alias(), is(), generic_object_rep::is_equal(), generic_concrete_rep< C >::is_equal(), generic_object_rep::is_exact_eq(), generic_concrete_rep< C >::is_exact_eq(), generic_object_rep::is_hard_eq(), generic_concrete_rep< C >::is_hard_eq(), object_alias(), object_flatten(), object_generalize_alias(), object_get_alias(), object_set_alias(), object_specialize_alias(), generic_object_rep::same_type(), set_alias(), specialize_alias(), and type_name().

                                   {
  return g->get_type (); }

nat mmx::type_id

(

)

[inline]

Definition at line 191 of file generic.hpp.

                                           {
  return type_information<C>::id; }

nat type_id

(

const generic &

name

)

Definition at line 78 of file glue.cpp.

References current_ev, gen(), and GEN_TYPE_ID.

Referenced by define_type_helper< C >::def_type(), and get_user_type().

                              {
  generic id;
  if (current_ev->get (gen (GEN_TYPE_ID, name), id) && is<nat> (id))
    return as<nat> (id);
  else return 1;
}

generic type_mismatch	(	const generic &	expect,
		const generic &	where
	)

Definition at line 41 of file exception.cpp.

References std_exception().

                                                            {
  return std_exception ("expected ", expect, where);
}

vector<generic> mmx::type_name

(

const vector< nat > &

ids

)

Definition at line 24 of file routine.cpp.

References N(), n, and type_name().

                                   {
  nat i, n= N(ids);
  vector<generic> ret= fill<generic> (n);
  for (i=0; i<n; i++)
    ret[i]= type_name (ids[i]);
  return ret;
}

generic type_name

(

)

[inline]

generic type_name

(

const generic &

g

)

Definition at line 94 of file glue.cpp.

References type(), and type_name().

                             {
  return type_name (type (g));
}

generic type_name

(

nat

id

)

Definition at line 86 of file glue.cpp.

References current_ev, gen(), GEN_TYPE_NAME, and GEN_UNSPECIFIED_TYPE.

Referenced by convert(), verbose_as_helper< T, F >::cv(), flatten_type(), routine_rep::function_type(), object_flatten(), operator<<(), replace_lf(), and type_name().

                   {
  generic name;
  if (current_ev->get (gen (GEN_TYPE_NAME, as<generic> (id)), name))
    return name;
  else return GEN_UNSPECIFIED_TYPE;
}

static generic mmx::un_try_catch

(

const generic &

g

)

[static]

Definition at line 382 of file mmx_printer.cpp.

References cdr(), compound_to_vector(), gen(), GEN_BEGIN, is_func(), and N().

                                {
  vector<generic> v;
  if (is_func (g[1], GEN_BEGIN)) v << cdr (compound_to_vector (g[1]));
  else v << g[1];
  for (nat i=2; i<N(g); i++) v << g[i];
  return gen (g[0], gen (GEN_BEGIN, v));
}

table<C,T,V> mmx::unary_filter

(

const table< C, T, V > &

t

)

[inline]

Definition at line 583 of file table.hpp.

References busy(), entries(), I(), and Table.

                              {
  Table r (I(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    if (Op::op (*it)) r[*it]= t[*it];
  return r;
}

new_table<C,T,V> mmx::unary_filter

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 654 of file new_table.hpp.

References busy(), entries(), I(), and Table.

                              {
  Table r (I(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    if (Op::op (*it)) r[*it]= t[*it];
  return r;
}

nat mmx::unary_hash

(

const vector< C, V > &

v

)

[inline]

Definition at line 757 of file vector.hpp.

References N(), and n.

                                  {
  register nat i, h= 12345, n= N(v);
  for (i=0; i<n; i++)
    h= (h<<1) ^ (h<<5) ^ (h>>27) ^ Op::op (v[i]);
  return h;
}

nat mmx::unary_hash

(

const triple< C1, C2, C3 > &

t

)

[inline]

Definition at line 48 of file triple.hpp.

                             {
  nat h1= Op::op (t.x1), h2= Op::op (t.x2);
  return h1 ^ h2 ^ (h1<<3) ^ (h2<<5) ^ Op::op (t.x3);
}

nat mmx::unary_hash

(

const table< C, T, V > &

t

)

[inline]

Definition at line 474 of file table.hpp.

References busy(), iterate(), pair< C1, C2 >::x1, and pair< C1, C2 >::x2.

                            {
  // we add all hash codes of the element pairs; don't "cycle",
  // because the order of the element pairs is not uniquely determined
  nat h=54321;
  for (iterator<pair<T,C> > it= iterate (t); busy (it); ++it) {
    pair<T,C> p= *it;
    nat key_h= V::key_op::hash_op (p.x1);
    nat val_h= Op::op (p.x2);
    h += (key_h << 5) ^ (key_h >> 27) ^ val_h;
  }
  return h;
}

nat mmx::unary_hash

(

const sparse_vector< C, T, V > &

v

)

[inline]

Definition at line 151 of file sparse_vector.hpp.

References N().

                                    {
  nat h=1236321;
  for (nat i=0; i<N(v); i++)
    h = (h << 5) ^ (h >> 27) ^ Op::op (v[i]);
  return h;
}

nat mmx::unary_hash

(

const pair< C1, C2 > &

p

)

[inline]

Definition at line 43 of file pair.hpp.

                           {
  nat h= Op::op (p.x1);
  return (h<<1) ^ (h<<3) ^ (h<<9) ^ (h>>29) ^ Op::op (p.x2);
}

nat mmx::unary_hash

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 545 of file new_table.hpp.

References busy(), iterate(), pair< C1, C2 >::x1, and pair< C1, C2 >::x2.

                            {
  // we add all hash codes of the element pairs; don't "cycle",
  // because the order of the element pairs is not uniquely determined
  nat h=54321;
  for (iterator<pair<T,C> > it= iterate (t); busy (it); ++it) {
    pair<T,C> p= *it;
    nat key_h= V::key_op::hash_op (p.x1);
    nat val_h= Op::op (p.x2);
    h += (key_h << 5) ^ (key_h >> 27) ^ val_h;
  }
  return h;
}

nat mmx::unary_hash

(

const list< C > &

ll

)

[inline]

Definition at line 211 of file list.hpp.

References is_nil(), List, read_car(), and read_cdr().

                            {
  List l= ll;
  register nat h= 253648;
  while (!is_nil (l)) {
    h= (h<<1) ^ (h<<5) ^ (h>>27) ^ Op::op (read_car (l));
    l= read_cdr (l);
  }
  return h;
}

nat mmx::unary_hash

(

const iterator< C > &

it

)

[inline]

Definition at line 156 of file iterator.hpp.

                                {
  (void) it; return 20077002;
  /*
  Iterator it1= copy (it);
  register nat h= 20077002;
  while (busy (it1)) {
    h= (h<<3) ^ (h>>29) ^ Op::op (*it1);
    ++it1;
  }
  return h;
  */
}

nat mmx::unary_hash

(

const heap< C > &

HH

)

[inline]

Definition at line 226 of file heap.hpp.

References copy(), Heap, N(), and pull().

                            {
  Heap H= copy (HH);
  register nat h= 2531648;
  while (N(H) > 0)
    h= (h<<1) ^ (h<<5) ^ (h>>27) ^ Op::op (pull (H));
  return h;
}

nat mmx::unary_hash

(

const chain< C > &

c

)

[inline]

Definition at line 221 of file chain.hpp.

References is_nil(), left(), middle(), and right().

                            {
  if (is_nil (c)) return 1928;
  nat h1= Op::op (left (c));
  nat h2= Op::op (middle (c));
  nat h3= Op::op (right (c));
  return h1 ^ (h2>>1) ^ (h2<<31) ^ (h3>>3) ^ (h3>>29);
}

vector<typename unary_return_type_helper< Op , C >::RET,V> mmx::unary_map

(

const vector< C, V > &

v

)

[inline]

Definition at line 766 of file vector.hpp.

References C, CF(), is_a_scalar(), N(), n, vector< C, V >::scalar(), seg(), T, and Unary_return_type.

                                 {
  typedef implementation<vector_linear,V> Vec;
  typedef Unary_return_type(Op,C) T;
  format<T> fm= unary_map<Op> (CF(v));
  if (is_a_scalar (v)) return vector<T,V> (Op::op (v.scalar()));
  nat n= N(v);
  nat l= aligned_size<T,V> (n);
  T* r= mmx_formatted_new<T> (l, fm);
  Vec::template vec_unary<Op> (r, seg (v), n);
  return vector<T,V> (r, n, l, fm);
}

format<typename unary_return_type_helper< Op , C >::RET > mmx::unary_map

(

const format< C > &

fm

)

[inline]

Definition at line 622 of file type_props.hpp.

References C, and Unary_return_type.

                                {
  typedef Unary_return_type(Op,C) R;
  typedef typename format<R>::FT FT;
  return format_unary_map_helper<Op,FT,R,C>::op (fm);
}

table<C,T,V> mmx::unary_map

(

const table< C, T, V > &

t

)

[inline]

Definition at line 496 of file table.hpp.

References busy(), CF2(), entries(), I(), simplify(), and Table.

                           {
  Table r (Op::op (I(t)), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    r[*it]= Op::op (t[*it]);
  simplify (r);
  return r;
}

sparse_vector<C,T,V> mmx::unary_map

(

const sparse_vector< C, T, V > &

v

)

[inline]

Definition at line 176 of file sparse_vector.hpp.

References N(), n, Pair, set_zero(), and Sparse_vector.

                                   {
  typedef typename V::val_op Eq;
  static C zero; set_zero (zero);
  nat i, j, n= N(v);
  Pair* r= mmx_new<Pair > (n);
  for (i= j= 0; i < n; i++) {
    Pair e (v[i].x1, Op::op (v[i].x2));
    if (Eq::not_op (e.x2, zero)) r[j++]= e;
  }
  return Sparse_vector (r, j, n);
}

new_table<C,T,V> mmx::unary_map

(

const new_table< C, T, V > &

t

)

[inline]

Definition at line 567 of file new_table.hpp.

References busy(), CF2(), entries(), I(), simplify(), and Table.

                           {
  Table r (Op::op (I(t)), CF2(t));
  for (iterator<T> it= entries (t); busy (it); ++it)
    r[*it]= Op::op (t[*it]);
  simplify (r);
  return r;
}

routine mmx::unary_routine	(	const generic &	name,
		D(*)(const S1 &)	fun
	)			[inline]

Definition at line 218 of file routine.hpp.

Referenced by accelerate(), accelerate_converter(), attach_generic_binary_assembler(), attach_generic_binary_reader(), define_type_helper< C >::def_type(), define(), define_constructor(), define_converter(), and define_user_type().

                                                          {
  return new unary_routine_rep<D,S1> (name, fun);
}

vector<T,V>& mmx::unary_set	(	vector< T, V > &	v,
		const vector< C, V > &	w
	)			[inline]

Definition at line 820 of file vector.hpp.

References ASSERT, extend(), is_a_scalar(), is_non_scalar(), N(), n, vector< C, V >::scalar(), and seg().

                                                 {
  typedef implementation<vector_linear,V> Vec;
  if (is_a_scalar (v) || is_a_scalar (w)) {
    if (is_non_scalar (v))
      return unary_set<Op> (v, extend (w, v));
    else if (is_non_scalar (w))
      v= extend (v, w);
    else {
      Op::set_op (v.scalar(), w.scalar());
      return v;
    }
  }
  nat n= N(v);
  ASSERT (N(w) == n, "lengths don't match");
  Vec::template vec_unary<Op> (seg (v), seg (w), n);
  return v;
}

table<C,T,V>& mmx::unary_set	(	table< C, T, V > &	t,
		const table< C, T, V > &	u
	)			[inline]

Definition at line 526 of file table.hpp.

References busy(), entries(), I(), read(), read_I(), and reset().

                                     {
  Op::set_op (I(t), I(u));
  for (iterator<T> it= entries (u); busy (it); ++it) {
    Op::set_op (t[*it], u[*it]);
    if (V::val_op::op (read (t, *it), read_I (t))) reset (t, *it);
  }
  return t;
}

new_table<C,T,V>& mmx::unary_set	(	new_table< C, T, V > &	t,
		const new_table< C, T, V > &	u
	)			[inline]

Definition at line 597 of file new_table.hpp.

References busy(), entries(), I(), read(), read_I(), and reset().

                                     {
  Op::set_op (I(t), I(u));
  for (iterator<T> it= entries (u); busy (it); ++it) {
    Op::set_op (t[*it], u[*it]);
    if (V::val_op::op (read (t, *it), read_I (t))) reset (t, *it);
  }
  return t;
}

vector<T,V>& mmx::unary_set_scalar	(	vector< T, V > &	v,
		const X &	x
	)			[inline]

Definition at line 839 of file vector.hpp.

References is_a_scalar(), N(), n, vector< C, V >::scalar(), and seg().

                                              {
  typedef implementation<vector_linear,V> Vec;
  if (is_a_scalar (v)) {
    Op::set_op (v.scalar(), x);
    return v;
  }
  nat n= N(v);
  Vec::template vec_unary_scalar<Op> (seg (v), x, n);
  return v;
}

table<C,T,V>& mmx::unary_set_scalar	(	table< C, T, V > &	t,
		const X &	x
	)			[inline]

Definition at line 536 of file table.hpp.

References busy(), entries(), I(), and simplify().

                                        {
  Op::set_op (I (t), x);
  for (iterator<T> it= entries (t); busy (it); ++it)
    Op::set_op (t[*it], x);
  simplify (t);
  return t;
}

new_table<C,T,V>& mmx::unary_set_scalar	(	new_table< C, T, V > &	t,
		const X &	x
	)			[inline]

Definition at line 607 of file new_table.hpp.

References busy(), entries(), I(), and simplify().

                                        {
  Op::set_op (I (t), x);
  for (iterator<T> it= entries (t); busy (it); ++it)
    Op::set_op (t[*it], x);
  simplify (t);
  return t;
}

generic mmx::unbracket

(

const generic &

g

)

Definition at line 205 of file mmx_texmacs.cpp.

References is_func().

Referenced by as_texmacs().

                             {
  if (is_func (g, "$bracket", 3)) return g[2];
  else return g;
}

static string mmx::underlined	(	const string &	file_name,
		const nat &	obj->lex_length,
		const source_position &	b,
		const source_position &	e
	)			[static]

Definition at line 279 of file source_track.cpp.

References source_position::column, get_source(), source_position::line, line, and N().

Referenced by source_underlined().

{
  // empty file_name means interactive input. In this only situation
  // n means the input number. n is not used for a regular file.
  nat j;
  string line;
  string sout;

  line = get_source (file_name, n, b.line);

  sout << line << "\n";
  for (j=0; j < b.column; ++j)
    sout << " ";
  if (b.line == e.line) {
    for (; j < e.column; ++j)
      sout << "~";
  }
  else {
    if (e.line == b.line+1 && e.column == 0)
      sout << "^";
    else {
      for (; j < N(line); ++j)
        sout << "~";
      sout << "\n";
      if (e.column == 0) {
        if (e.line - 1 > b.line + 1)
          sout << "...\n";
        line = get_source (file_name, n, e.line-1);
        sout << line << "\n";
        for (j=0; j < N(line); ++j)
          sout << "~";
        if (N(line) == 0)
          sout << "^";
      }
      else {
        if (e.line > b.line + 1)
          sout << "...\n";
        line = get_source (file_name, n, e.line);
        sout << line << "\n";
        for (j=0; j < e.column; ++j)
          sout << "~";
      }
    }
  }
  sout << "\n";
  return sout;
}

bool mmx::unequal_operator	(	const T &	x,
		const T &	y
	)			[inline]

Definition at line 37 of file operators.hpp.

{ return x!=y; }

string mmx::unescape

(

const string &

obj->lex_string

)

Definition at line 492 of file string.cpp.

References N(), string::rep, and string_rep::resize().

                           {
  int i, n= N(s);
  string r;
  for (i=0; i<n; i++)
    if ((i+1<n) && (s[i] == '\\')) {
      i++;
      if (s[i] == 't') r << '\t';
      else if (s[i] == 'n') r << '\n';
      else if (s[i] == 'r') r << '\r';
      else if (s[i] == 'b') {
        if (N(r)>0)
          r.rep->resize (N(r)-1);
      }
      else r << s[i];
    }
    else r << s[i];
  return r;
}

string mmx::unescape

(

const string &

s

)

Replace "\\n", "\\t", and "\\b" respectively by "\n", "\t", and "\b".

Referenced by unquote().

generic uniform	(	const generic &	x1,
		const generic &	x2
	)

Definition at line 846 of file generic.cpp.

References current_ev.

                                                       {
  return current_ev->apply ("uniform", x1, x2); }

double uniform_deviate	(	const double &	lo,
		const double &	hi
	)

Definition at line 17 of file double.cpp.

Referenced by GLUE_6().

                                                     {
  double x= ((double) rand ()) / RAND_MAX;
  return lo + (hi - lo) * x;
}

string mmx::unique_identifier

(

const dynamic &

g

)

Definition at line 69 of file dynamic.cpp.

References as_string(), and hard_hash().

Referenced by flatten(), and output_observer_rep::modify().

                                     {
  return "mmx-" * as_string (hard_hash (g));
}

void mmx::unlock	(	const storage &	st,
		const string &	var
	)			[inline]

Lock variable var on storage st.

Definition at line 75 of file storage.hpp.

Referenced by GLUE_7().

                                                          {
  st->unlock (var); }

string mmx::unquote

(

const string &

obj->lex_string

)

Definition at line 535 of file string.cpp.

References ends(), N(), s, starts(), and unescape().

                          {
  if ((N(s) >= 2) && (s[0] == '\"') && (s[N(s)-1] == '\"'))
    return unescape (s (1, N(s)-1));
  else if (starts (s, "/\"") && ends (s, "\"/"))
    return s (2, N(s)-2);
  else return unescape (s);
}

string mmx::unquote

(

const string &

s

)

Remove all the "..." and /"..."/ around s.

Referenced by as_literal_string(), GLUE_21(), mmc_unliteral(), parse_lisp(), and scheme_to_tm().

string mmx::upcase

(

const string &

obj->lex_string

)

Definition at line 442 of file string.cpp.

References is_locase(), and N().

                         {
  nat i, n= N(s);
  string r (n);
  for (i=0; i<n; i++)
    if (!is_locase (s[i])) r[i]= s[i];
    else r[i]= (char) (((int) ((unsigned char) s[i]))-32);
  return r;
}

string mmx::upcase

(

const string &

s

)

Replace locases by upcases.

Referenced by GLUE_16().

string mmx::upcase_first

(

const string &

obj->lex_string

)

Definition at line 462 of file string.cpp.

References copy(), is_locase(), and N().

                               {
  string r= copy (s);
  if (N(r) != 0 && is_locase (s[0]))
    r[0]= (char) (((int) ((unsigned char) s[0]))-32);
  return r;
}

string mmx::upcase_first

(

const string &

s

)

Replace locase by upcase for first letter.

Referenced by GLUE_18().

vector<typename unary_return_type_helper<center_op, C >::RET,V> mmx::upper

(

const vector< C, V > &

v

)

[inline]

Definition at line 1351 of file vector.hpp.

                                           {
  return unary_map<upper_op> (v); }

C mmx::upper

(

const C &

x

)

[inline]

Definition at line 1115 of file type_props.hpp.

Referenced by upper_op::Center_type(), and upper_op::set_op().

{ return x; }

string user_dir

(

)

Definition at line 207 of file system.cpp.

References _from_dos_to_unix(), ASSERT, and get_env().

Referenced by disk_storage(), eval_system(), init_system(), load_path(), shell_load_history(), shell_load_session(), shell_save_history(), and shell_save_session().

            {
  string dir= get_env ("MMX_USER_DIR");
  if (dir == "") {
#if defined(__MINGW__) || defined(__MINGW32__)
    string home = get_env ("USERPROFILE");
    ASSERT (home != "", "Can not determine user's directory.\n Please set MMX_USER_DIR or USERPROFILE.\n");
    dir= home * "/AppData/Local/Mathemagix";
#else
    string home = get_env ("HOME");
    ASSERT (home != "", "Can not determine user's directory.\n Please set $MMX_USER_DIR or $HOME.\n");
    dir= home * "/.mathemagix";
#endif
  }
  return _from_dos_to_unix (dir);
}

generic user_exception	(	const vector< generic > &	msg,
		const generic &	where
	)

Definition at line 31 of file exception.cpp.

References gen(), and GEN_EXCEPTION.

                                                              {
  return as<generic> (exception (gen (GEN_EXCEPTION, as<generic> (msg), w)));
}

generic mmx::var_flatten

(

const generic &

g

)

Definition at line 84 of file generic_utils.cpp.

References as_generic(), and flatten().

Referenced by compare_sub(), and size().

                               {
  return as_generic (flatten (g));
}

bool var_load	(	const string &	file_path,
		const string &	file_name,
		string &	obj->lex_string
	)

Definition at line 723 of file system.cpp.

References _from_dos_to_unix(), get_env(), init_system(), is_absolute_name(), load_path(), N(), n, path_sep, start, var_load(), and var_pwd().

                                                                       {
  //mmout << "var_load: " << file_path << ", " << file_name << lf;
  if (is_absolute_name (file_name))
    return var_load (file_name, s);
  nat i, n= N(file_path), start= 0;
  for (i=0; i<=n; i++)
    if ((i==n) || (file_path[i] == path_sep)) {
      string ss= file_path (start, i);
      if ((N(ss) > 0) && (ss[0] == '$')) {
        init_system ();
        if (ss == "$MMX_LOAD_PATH") ss= load_path ();
        else if (ss == "$PWD") ss= var_pwd ();
        else ss= _from_dos_to_unix (get_env (ss (1, N(ss))));
        if (!var_load (ss, file_name, s)) return false;
      }
      else {
        if (ss == "") ss= ".";
        if (ss[N(ss)-1] != '/') ss= ss * "/";
        if (!var_load (ss * file_name, s)) return false;
      }
      start= i+1;
    }
  return true;
}

bool var_load	(	const string &	file_name,
		string &	obj->lex_string
	)

Definition at line 705 of file system.cpp.

References can_read(), error_flag(), and input_file_port().

Referenced by eval_system(), load(), and var_load().

                                              {
  //mmout << "var_load: " << file_name << lf;
  port f= input_file_port (file_name);
  if (error_flag (f)) return true;
  char c;
  while (can_read (f) > 0) {
    f >> c;
    s << c;
  }
  return false;
}

bool var_mkdir

(

const string &

name

)

Definition at line 789 of file system.cpp.

References as_charp(), file_exists(), free_charp(), mkdir(), and system().

Referenced by init_system(), and mkdir().

                               {
#if defined (BASIX_HAVE_SYS_TYPES_H) && defined (BASIX_HAVE_SYS_STAT_H)
  if (file_exists (name)) return false;
  char* _name= as_charp (name);
#if defined(__MINGW__) || defined(__MINGW32__)
  int r= ::mkdir (_name);
  ::chmod (_name, 744);
#else
  int r= ::mkdir (_name, S_IRWXU + S_IRGRP + S_IROTH);
#endif
  free_charp (_name);
  return r != 0;
#else  
  return system ("mkdir -m 744 -p " * orig_name) != 0;
#endif
}

string var_pwd

(

)

Definition at line 825 of file system.cpp.

References _from_dos_to_unix(), and get_env().

Referenced by ancestor_search_name(), get_env(), path_name(), and var_load().

           {
#if defined(__MINGW__) || defined(__MINGW32__)
  char* ret= getcwd (NULL, 4096);
  if (ret == NULL) return "";
  string aux (ret);
  free (ret);
  return _from_dos_to_unix (aux);
#else
  return _from_dos_to_unix (get_env ("PWD"));
#endif
}

bool var_rm

(

const string &

name

)

Definition at line 812 of file system.cpp.

References as_charp(), file_exists(), free_charp(), remove(), and system().

Referenced by eval_system().

                            {
#if defined (BASIX_HAVE_SYS_TYPES_H) && defined (BASIX_HAVE_SYS_STAT_H)
  if (!file_exists (name)) return false;
  char* _name= as_charp (name);
  int r= ::remove (_name);
  free_charp (_name);
  return r != 0;
#else  
  return system ("rm " * orig_name) != 0;
#endif
}

vector<C> mmx::vec	(	const C &	c1,
		const C &	c2,
		const C &	c3,
		const C &	c4,
		const C &	c5,
		const C &	c6,
		const C &	c7,
		const C &	c8
	)			[inline]

Definition at line 462 of file vector.hpp.

References C, Format, and get_format().

                                                         {
  Format fm= get_format (c1);
  nat l= default_aligned_size<C> ((nat) 8);
  C* a= mmx_formatted_new<C> (l, fm);
  a[0]= c1; a[1]= c2; a[2]= c3; a[3]= c4;
  a[4]= c5; a[5]= c6; a[6]= c7; a[7]= c8;
  return vector<C> (a, 8, l, fm);
}

vector<C> mmx::vec	(	const C &	c1,
		const C &	c2,
		const C &	c3,
		const C &	c4,
		const C &	c5,
		const C &	c6,
		const C &	c7
	)			[inline]

Definition at line 452 of file vector.hpp.

References C, Format, and get_format().

                                            {
  Format fm= get_format (c1);
  nat l= default_aligned_size<C> ((nat) 7);
  C* a= mmx_formatted_new<C> (l, fm);
  a[0]= c1; a[1]= c2; a[2]= c3; a[3]= c4; a[4]= c5; a[5]= c6; a[6]= c7;
  return vector<C> (a, 7, l, fm);
}

vector<C> mmx::vec	(	const C &	c1,
		const C &	c2,
		const C &	c3,
		const C &	c4,
		const C &	c5,
		const C &	c6
	)			[inline]

Definition at line 442 of file vector.hpp.

References C, Format, and get_format().

                                            {
  Format fm= get_format (c1);
  nat l= default_aligned_size<C> ((nat) 6);
  C* a= mmx_formatted_new<C> (l, fm);
  a[0]= c1; a[1]= c2; a[2]= c3; a[3]= c4; a[4]= c5; a[5]= c6;
  return vector<C> (a, 6, l, fm);
}

vector<C> mmx::vec	(	const C &	c1,
		const C &	c2,
		const C &	c3,
		const C &	c4,
		const C &	c5
	)			[inline]

Definition at line 433 of file vector.hpp.

References C, Format, and get_format().

                                                                      {
  Format fm= get_format (c1);
  nat l= default_aligned_size<C> ((nat) 5);
  C* a= mmx_formatted_new<C> (l, fm);
  a[0]= c1; a[1]= c2; a[2]= c3; a[3]= c4; a[4]= c5;
  return vector<C> (a, 5, l, fm);
}

vector<C> mmx::vec	(	const C &	c1,
		const C &	c2,
		const C &	c3,
		const C &	c4
	)			[inline]

Definition at line 424 of file vector.hpp.

References C, Format, and get_format().

                                                         {
  Format fm= get_format (c1);
  nat l= default_aligned_size<C> ((nat) 4);
  C* a= mmx_formatted_new<C> (l, fm);
  a[0]= c1; a[1]= c2; a[2]= c3; a[3]= c4;
  return vector<C> (a, 4, l, fm);
}

vector<C> mmx::vec	(	const C &	c1,
		const C &	c2,
		const C &	c3
	)			[inline]

Definition at line 415 of file vector.hpp.

References C, Format, and get_format().

                                            {
  Format fm= get_format (c1);
  nat l= default_aligned_size<C> ((nat) 3);
  C* a= mmx_formatted_new<C> (l, fm);
  a[0]= c1; a[1]= c2; a[2]= c3;
  return vector<C> (a, 3, l, fm);
}

vector<C> mmx::vec	(	const C &	c1,
		const C &	c2
	)			[inline]

Definition at line 406 of file vector.hpp.

References C, Format, and get_format().

                               {
  Format fm= get_format (c1);
  nat l= default_aligned_size<C> ((nat) 2);
  C* a= mmx_formatted_new<C> (l, fm);
  a[0]= c1; a[1]= c2;
  return vector<C> (a, 2, l, fm);
}

vector<C> mmx::vec

(

const C &

c1

)

[inline]

Definition at line 397 of file vector.hpp.

References C, Format, and get_format().

                  {
  Format fm= get_format (c1);
  nat l= default_aligned_size<C> ((nat) 1);
  C* a= mmx_formatted_new<C> (l, fm);
  a[0]= c1;
  return vector<C> (a, 1, l, fm);
}

vector<C> mmx::vec

(

const format< C > &

fm

)

[inline]

Definition at line 390 of file vector.hpp.

References C.

                       {
  nat l= default_aligned_size<C> ((nat) 0);
  C* a= mmx_formatted_new<C> (l, fm);
  return vector<C> (a, 0, l, fm);
}

vector<C> mmx::vec

(

)

[inline]

Definition at line 382 of file vector.hpp.

References C, and Format.

Referenced by apply(), as_texmacs(), compose(), cos_sin(), trig_op::diff_op(), and trig().

       {
  Format fm;
  nat l= default_aligned_size<C> ((nat) 0);
  C* a= mmx_formatted_new<C> (l, fm);
  return vector<C> (a, 0, l, fm);
}

generic vector_access	(	const generic &	g,
		nat	i
	)

Definition at line 68 of file generic.cpp.

Referenced by void_binary_helper< table< C, T, V > >::access(), binary_helper< triple< C1, C2, C3 > >::assemble(), binary_helper< generic >::assemble(), and binary_helper< pair< C1, C2 > >::assemble().

                                                {
  return as<vector<generic> > (g) [i]; }

vector<T> mmx::vector_append	(	const vector< T > &	v,
		const T &	x
	)			[inline]

Definition at line 231 of file mmc_glue.hpp.

References append().

                                               {
  return append (v, x);
}

vector<T> mmx::vector_append	(	const vector< T > &	v1,
		const vector< T > &	v2
	)			[inline]

Definition at line 226 of file mmc_glue.hpp.

References append().

Referenced by vector_insert().

                                                         {
  return append (v1, v2);
}

generic mmx::vector_append_several

(

const tuple< vector< generic > > &

t

)

Definition at line 123 of file glue_vector_map.cpp.

References N(), and rebuild().

Referenced by glue_vector_map().

                                                         {
  vector<generic> r;
  for (nat i=0; i<N(t); i++)
    r << t[i];
  return rebuild (r);
}

generic mmx::vector_apply	(	const generic &	f,
		const vector< generic > &	a
	)

Definition at line 131 of file glue_vector_map.cpp.

References default_routine().

Referenced by glue_vector_map().

                                                          {
  routine fun= is<routine> (f)? as<routine> (f): default_routine (f);
  return fun->apply (a);
}

compound mmx::vector_as_compound

(

const vector< generic > &

l

)

[inline]

Definition at line 65 of file mmc_glue.hpp.

                                              {
  return compound (l);
}

vector<T> mmx::vector_cons	(	const T &	x,
		const vector< T > &	v
	)			[inline]

Definition at line 221 of file mmc_glue.hpp.

References cons().

                                             {
  return cons (x, v);
}

bool mmx::vector_contains	(	const vector< T > &	v,
		const T &	x
	)			[inline]

Definition at line 283 of file mmc_glue.hpp.

References N(), and vector_find().

Referenced by vector_insert().

                                                 {
  return vector_find (v, x) < ((int) N(v));
}

int mmx::vector_find	(	const vector< T > &	v,
		const T &	x
	)			[inline]

Definition at line 275 of file mmc_glue.hpp.

References N(), and n.

Referenced by vector_contains().

                                             {
  nat i, n=N(v);
  for (i=0; i<n; i++)
    if (v[i] == x) return (int) i;
  return (int) i;
}

generic mmx::vector_foreach	(	const generic &	f,
		const tuple< vector< generic > > &	t
	)

Definition at line 117 of file glue_vector_map.cpp.

References gen(), GEN_TUPLE, and vector_map().

Referenced by glue_vector_map().

                                                                    {
  generic r= vector_map (f, t);
  return as<generic> (tuple<generic> (gen (GEN_TUPLE)));
}

vector<T> mmx::vector_insert	(	const vector< T > &	v,
		const T &	x
	)			[inline]

Definition at line 288 of file mmc_glue.hpp.

References vector_append(), and vector_contains().

                                               {
  if (vector_contains (v, x)) return v;
  else return vector_append (v, x);
}

bool mmx::vector_is_atom

(

const vector< T > &

v

)

[inline]

Definition at line 261 of file mmc_glue.hpp.

References is_non_scalar(), and N().

                                    {
  return is_non_scalar (v) && N(v) == 1;
}

bool mmx::vector_is_nil

(

const vector< T > &

v

)

[inline]

Definition at line 256 of file mmc_glue.hpp.

References N().

                                   {
  return N(v) == 0;
}

int mmx::vector_length

(

const vector< T > &

v

)

[inline]

Definition at line 206 of file mmc_glue.hpp.

References N().

                                   {
  return (int) N(v);
}

vector<T>& mmx::vector_lessless	(	vector< T > &	v1,
		const vector< T > &	v2
	)			[inline]

Definition at line 236 of file mmc_glue.hpp.

                                                     {
  return v1 << v2;
}

vector<D> mmx::vector_lift	(	D(*)(const S1 &)	fun,
		const vector< S1 > &	v1,
		const format< D > &	fm
	)			[inline]

Definition at line 320 of file mmc_glue.hpp.

                                  {
  return map<S1,D> (fun, v1, fm);
}

vector<D> mmx::vector_lift	(	const function_1< D, typename argument_helper< S1 >::arg_type > &	fun,
		const vector< S1 > &	v1,
		const format< D > &	fm
	)			[inline]

Definition at line 314 of file mmc_glue.hpp.

                                  {
  return map<S1,D> (fun, v1, fm);
}

vector<D> mmx::vector_lift	(	D(*)(const S1 &)	fun,
		const vector< S1 > &	v1
	)			[inline]

Definition at line 309 of file mmc_glue.hpp.

                                                         {
  return map<S1,D> (fun, v1);
}

vector<D> mmx::vector_lift	(	const function_1< D, typename argument_helper< S1 >::arg_type > &	fun,
		const vector< S1 > &	v1
	)			[inline]

Definition at line 304 of file mmc_glue.hpp.

                                                                           {
  return map<S1,D> (fun, v1);
}

vector<U> mmx::vector_lift

(

const vector< T > &

v

)

[inline]

Definition at line 294 of file mmc_glue.hpp.

Referenced by iterator_lift_vector(), and vector_lift_iterator().

                                 {
  return as<vector<U> > (v);
}

iterator<U> mmx::vector_lift_iterator	(	const function_1< U, typename argument_helper< T >::arg_type > &	fun,
		const vector< T > &	v,
		const format< U > &	fm
	)			[inline]

Definition at line 552 of file mmc_glue.hpp.

References iterate(), and vector_lift().

{
  return iterate (vector_lift (fun, v, fm));
}

iterator<U> mmx::vector_lift_iterator	(	const function_1< U, typename argument_helper< T >::arg_type > &	fun,
		const vector< T > &	v
	)			[inline]

Definition at line 545 of file mmc_glue.hpp.

References iterate(), and vector_lift().

{
  return iterate (vector_lift (fun, v));
}

vector<generic> mmx::vector_lift_to_generic

(

const vector< T > &

v

)

[inline]

Definition at line 299 of file mmc_glue.hpp.

                                            {
  return vector_lift<T,generic> (v);
}

generic mmx::vector_map	(	const generic &	f,
		const tuple< vector< generic > > &	t
	)

Definition at line 99 of file glue_vector_map.cpp.

References ASSERT, compound_to_vector(), default_routine(), n, N(), rebuild(), vector_map_1(), vector_map_2(), and vector_map_n().

Referenced by glue_vector_map(), and vector_foreach().

                                                                {
  routine fun= is<routine> (f)? as<routine> (f): default_routine (f);
  switch (N(t)) {
  case 0: ASSERT (N(t)>0, "wrong number of arguments");
  case 1: return rebuild (vector_map_1 (fun, t[0]));
  case 2: return rebuild (vector_map_2 (fun, t[0], t[1]));
  default:
    {
      const vector<generic> a= compound_to_vector (*t);
      nat i, n= N(a)-1;
      vector<vector<generic> > b= fill<vector<generic> > (n);
      for (i=0; i<n; i++) b[i]= as<vector<generic> > (a[i+1]);
      return rebuild (vector_map_n (fun, b));
    }
  }
}

vector<generic> mmx::vector_map_1	(	const routine &	fun,
		const vector< generic > &	v
	)

Definition at line 32 of file glue_vector_map.cpp.

References is_a_scalar(), mmout, N(), and n.

Referenced by vector_map().

                                                            {
  if (is_a_scalar (v)) mmout << fun << ", " << v << "\n";
  //mmout << fun << ", " << v << ", " << is_a_scalar (v) << "\n";
  if (is_a_scalar (v)) return vector<generic> (fun->apply (v.scalar()));
  nat n= N(v);
  generic* r= mmx_new<generic> (n);
  for (nat i=0; i<n; i++)
    r[i]= fun->apply (v[i]);
  //mmout << "  -> " << vector<generic> (r, n) << "\n";
  return vector<generic> (r, n, format<generic> ());
}

vector<generic> mmx::vector_map_2	(	const routine &	fun,
		const vector< generic > &	v1,
		const vector< generic > &	v2
	)

Definition at line 45 of file glue_vector_map.cpp.

References ASSERT, extend(), is_a_scalar(), is_non_scalar(), n, N(), and vector< C, V >::scalar().

Referenced by vector_map().

{
  if (is_a_scalar (v1) || is_a_scalar (v2)) {
    if (is_non_scalar (v1)) return vector_map_2 (fun, v1, extend (v2, v1));
    if (is_non_scalar (v2)) return vector_map_2 (fun, extend (v1, v2), v2);
    return vector<generic> (fun->apply (v1.scalar(), v2.scalar()));
  }
  ASSERT (N (v1) == N (v2), "vectors of unequal lengths");
  nat n= N(v1);
  generic* r= mmx_new<generic> (n);
  for (nat i=0; i<n; i++)
    r[i]= fun->apply (v1[i], v2[i]);
  return vector<generic> (r, n, format<generic> ());
}

vector<generic> mmx::vector_map_n	(	const routine &	fun,
		const vector< vector< generic > > &	a
	)

Definition at line 62 of file glue_vector_map.cpp.

References arg(), ASSERT, is_a_scalar(), N(), and n.

Referenced by vector_map().

                                                                     {
  bool all_scalar= true, one_scalar= false;
  nat i, n= N(a), l= 0;
  for (i=0; i<n; i++)
    if (is_a_scalar (a[i])) one_scalar= true;
    else {
      if (all_scalar) l= N(a[i]);
      else ASSERT (N(a[i]) == l, "vectors of unequal lengths");
      all_scalar= false;
    }

  if (all_scalar) {
    vector<generic> arg= fill<generic> (n);
    for (i=0; i<n; i++)
      arg[i]= a[i].scalar();
    return vector<generic> (fun->apply (arg));
  }

  if (one_scalar) {
    vector<vector<generic> > b= fill<vector<generic> > (n);
    for (i=0; i<n; i++)
      if (is_a_scalar (a[i])) b[i]= vector<generic> (a[i].scalar(), l);
      else b[i]= a[i];
    return vector_map_n (fun, b);
  }

  generic* r= mmx_new<generic> (l);
  for (nat j=0; j<l; j++) {
    vector<generic> arg= fill<generic> (n);
    for (i=0; i<n; i++)
      arg[i]= a[i][j];
    r[j]= fun->apply (arg);
  }
  return vector<generic> (r, l, format<generic> ());
}

vector<T> mmx::vector_new

(

const vector< T > &

v

)

[inline]

Definition at line 201 of file mmc_glue.hpp.

                                {
  return v;
}

vector<T> mmx::vector_nil

(

const format< T > &

fm

)

[inline]

Definition at line 216 of file mmc_glue.hpp.

                                 {
  return vec<T> (fm);
}

vector<T> mmx::vector_nil

(

)

[inline]

Definition at line 211 of file mmc_glue.hpp.

              {
  return vector<T> ();
}

vector<T> mmx::vector_range	(	const vector< T > &	v,
		const int &	i,
		const int &	j
	)			[inline]

Definition at line 251 of file mmc_glue.hpp.

References range().

                                                              {
  return range (v, (nat) i, (nat) j);
}

T mmx::vector_read	(	const vector< T > &	v,
		const int &	i
	)			[inline]

Definition at line 241 of file mmc_glue.hpp.

                                               {
  return v[(nat) i];
}

vector<T> mmx::vector_reverse

(

const vector< T > &

v

)

[inline]

Definition at line 266 of file mmc_glue.hpp.

References is_a_scalar(), N(), and n.

                                    {
  if (is_a_scalar (v)) return v;
  nat i, n= N(v);
  vector<T> r= fill<T> (n);
  for (i=0; i<n; i++) r[i]= v[n-1-i];
  return r;
}

generic mmx::vector_size

(

const generic &

g

)

Definition at line 65 of file generic.cpp.

References as(), is(), and N().

Referenced by void_binary_helper< table< C, T, V > >::size().

                                       {
  if (!is<vector<generic> > (g)) return 0;
  else return N(as<vector<generic> > (g)); }

vector<generic> mmx::vector_sort

(

const vector< generic > &

v

)

Definition at line 139 of file glue_vector_map.cpp.

References copy(), and sort().

Referenced by glue_vector_map().

                                       {
  vector<generic> r= copy (v);
  sort (r);
  return r;
}

vector<generic> mmx::vector_sort_leq	(	const vector< generic > &	v,
		const generic &	f
	)

Definition at line 153 of file glue_vector_map.cpp.

References copy(), current_comparison, and default_routine().

Referenced by glue_vector_map().

                                                             {
  routine old_comparison= current_comparison;
  current_comparison= is<routine> (f)? as<routine> (f): default_routine (f);
  vector<generic> r= copy (v);
  sort_leq<vector_sort_leq_op> (r);
  current_comparison= old_comparison;
  return r;
}

generic vector_to_compound

(

const vector< generic > &

v

)

Definition at line 22 of file compound.cpp.

Referenced by access(), add_modes(), append(), apply(), cdr(), cons(), flatten(), parse_lisp(), range(), WRAP_BINARY_IMPL_1(), and xgen().

                                              {
  return as<generic> (compound (v));
}

T& mmx::vector_write	(	vector< T > &	v,
		const int &	i
	)			[inline]

Definition at line 246 of file mmc_glue.hpp.

                                          {
  return v[(nat) i];
}

Dest& mmx::view_as

(

Src &

src

)

[inline]

Definition at line 60 of file instance.hpp.

                   {
  return *((Dest*) ((void*) &src));
}

Dest mmx::view_as

(

const Src &

src

)

[inline]

Definition at line 55 of file instance.hpp.

                         {
  return *((Dest*) ((void*) &src));
}

generic mmx::vlist

(

const vector< generic > &

v

)

[inline]

Definition at line 147 of file mmx_printer.cpp.

References gen().

                                                {
  return gen ("$vlist", v); }

generic void_value

(

)

Definition at line 146 of file generic.cpp.

References gen(), and GEN_TUPLE.

Referenced by quintary_routine_rep< void, S1, S2, S3, S4, S5 >::apply(), quaternary_routine_rep< void, S1, S2, S3, S4 >::apply(), ternary_routine_rep< void, S1, S2, S3 >::apply(), binary_routine_rep< void, S1, S2 >::apply(), unary_routine_rep< void, S1 >::apply(), and nullary_routine_rep< void >::apply().

              {
  static generic val= as<generic> (tuple<generic> (gen (GEN_TUPLE)));
  return val;
}

bool mmx::wait	(	const port &	p,
		int	msec
	)			[inline]

Definition at line 117 of file port.hpp.

References inside().

Referenced by composite_port_rep::wait().

                                           {
  return inside (p)->wait (msec); }

nat wait_port_event

(

int

msecs

)

Definition at line 108 of file posix_port.cpp.

References busy(), entries(), in_count, and max().

Referenced by connect_to_server().

                            {
  //mmout << "Global wait " << msecs << " ms\n";
  int max_fd= 0;

  fd_set in_fds;
  FD_ZERO (&in_fds);
  for (iterator<int> it= entries (in_count); busy (it); ++it) {
    //mmout << "  Setting " << (*it) << "\n";
    FD_SET (*it, &in_fds);
    max_fd= max (max_fd, (*it) + 1);
  }
  
  nat nr;
  struct timeval tv;
  tv.tv_sec  = msecs / 1000;
  tv.tv_usec = 1000 * (msecs % 1000);
  if (msecs < 0) nr= select (max_fd, &in_fds, NULL, NULL, NULL);
  else nr= select (max_fd, &in_fds, NULL, NULL, &tv);
  //mmout << "Received " << nr << "\n";
  return nr;
}

mmx::WRAP_BINARY_IMPL	(	template< typename Cat, nat Nr >	,
		instance< Cat, Nr >	,
		generic	,
		"Ins"	,
		"Ins"
	)

mmx::WRAP_BINARY_IMPL_1	(	template< typename C >	,
		tuple< C >	,
		generic	,
		"Tu"	,
		"Tuple"	,
		C
	)			const

Definition at line 50 of file tuple.hpp.

References GEN_TUPLE, N(), n, Tuple, and vector_to_compound().

                              {
  nat i, n= N(a);
  vector<generic> t= fill<generic> (n+1);
  t[0]= GEN_TUPLE;
  for (i=0; i<n; i++)
    t[i+1]= as<generic> (a[i]);
  return Tuple (vector_to_compound (t));
}

mmx::WRAP_BINARY_IMPL_1	(	template< typename C >	,
		row_tuple< C >	,
		generic	,
		"Rtu"	,
		"Row_tuple"	,
		C
	)			const

Definition at line 52 of file row_tuple.hpp.

References GEN_ROW, N(), n, Row_tuple, and vector_to_compound().

                                  {
  nat i, n= N(a);
  vector<generic> t= fill<generic> (n+1);
  t[0]= GEN_ROW;
  for (i=0; i<n; i++)
    t[i+1]= as<generic> (a[i]);
  return Row_tuple (vector_to_compound (t));
}

mmx::WRAP_INDIRECT_IMPL	(	template< typename C >	inline,
		tuple< C >
	)			const

Definition at line 41 of file tuple.hpp.

References N().

                                   { return N (*t) - 1; }

mmx::WRAP_INDIRECT_IMPL	(	template< typename C >	inline,
		row_tuple< C >
	)			const

Definition at line 45 of file row_tuple.hpp.

References as_syntactic(), cdr(), compound_to_vector(), gen(), and GEN_ROW.

                             {
  return as_syntactic (gen (GEN_ROW, cdr (compound_to_vector (*t))));
}

mmx::WRAP_INDIRECT_IMPL	(	inline	,
		routine
	)			const

mmx::WRAP_INDIRECT_IMPL	(	inline	,
		generic_function
	)

Definition at line 46 of file generic_function.hpp.

                                                       {

mmx::WRAP_INDIRECT_IMPL	(	template< typename C >	inline,
		alias< C >
	)

Definition at line 62 of file alias.hpp.

References C, Full_type_name, gen(), and Short_type_name.

                            : public void_binary_helper<Alias > {
  static inline string short_type_name () {
    return "Al" * Short_type_name (C); }
  static inline generic full_type_name () {
    return gen ("Alias", Full_type_name (C)); }
};

mmx::WRAP_PRINT_IMPL	(	template< typename Cat, nat Nr >	,
		instance< Cat, Nr >
	)

mmx::WRAP_WRAPPED_IMPL	(	template< typename Cat, nat Nr >	,
		instance< Cat, Nr >
	)

mmx::WRAP_WRAPPED_IMPL	(	template< typename C >	inline,
		generic_alias< C >
	)

Definition at line 139 of file alias.hpp.

References ASSERT, C, get_genalias(), and set_genalias().

                         : public Alias_rep {
  generic_alias<C> a;
  C* temp;
public:
  inline incarnate_alias_rep (const generic_alias<C>& a2):
    a (a2), temp (NULL) {}
  inline ~incarnate_alias_rep () {
    ASSERT (temp == NULL, "destruction while accessing alias"); }
  inline C get () const { return get_genalias (a); }
  inline C& open () const {
    incarnate_alias_rep<C>* me= const_cast<incarnate_alias_rep<C>*> (this);
    me->temp= mmx_new_one<C> (as<C> (get_genalias (a)));
    return *me->temp; }
  inline void close () const {
    incarnate_alias_rep<C>* me= const_cast<incarnate_alias_rep<C>*> (this);
    set_genalias (a, as<generic> (*temp));
    mmx_delete_one<C> (me->temp);
    me->temp= NULL; }
};

static void mmx::write	(	string &	r,
		const string &	obj->lex_string
	)			[static]

Definition at line 501 of file mmx_texmacs.cpp.

References ends(), N(), and n.

                                   {
  nat i, n=N(s);
  for (i=0; i<n; i++) {
    char c= s[i];
    if (c == ' ' && ends (r, " ")) r << "\\ ";
    else if (c == '\n') r << "\\n";
    else if (c == '\t') r << "\\t";
    else if (c == '\0') r << "\\0";
    else if (c == '\\') r << "\\\\";
    else if (c == '<') r << "\\<";
    else if (c == '|') r << "\\|";
    else if (c == '>') r << "\\>";
    else if (c == '\34') r << c;
    else if (((unsigned char) c) < ' ') r << '\\' << (c+'@');
    else r << c;
  }
}

void mmx::write	(	const storage &	st,
		const string &	var,
		const string &	val
	)			[inline]

Wrap storage st such that values will be read at most once from server.

Definition at line 66 of file storage.hpp.

                                                                            {
  st->write (var, val); }

void write	(	const port &	p,
		const string &	s
	)			[inline]

Definition at line 109 of file port.hpp.

References inside(), and N().

                                                   {
  inside (p)->write (inside (s, 0), N(s)); }

void write	(	const port &	p,
		const char *	s,
		nat	n
	)			[inline]

Definition at line 107 of file port.hpp.

References inside().

Referenced by binary_ll(), binary_write(), generic_concrete_rep< C >::binary_write(), GLUE_16(), GLUE_4(), operator<<(), scheme_to_tm(), composite_port_rep::write(), binary_helper< format< T > >::write(), binary_helper< string >::write(), and binary_helper< bool >::write().

                                                        {
  inside (p)->write (s, n); }

generic wrong_nr_args

(

const generic &

where

)

Definition at line 36 of file exception.cpp.

References std_exception().

                                     {
  return std_exception ("wrong number of arguments", where);
}

generic xaccess	(	const generic &	f,
		const generic &	args
	)

Definition at line 173 of file generic.cpp.

References comma(), GEN_ACCESS, and xgen().

                                                        {
  return xgen (GEN_ACCESS, comma (f, args)); }

syntactic xderive	(	const syntactic &	g,
		const syntactic &	v
	)

Definition at line 482 of file syntactic.cpp.

References GEN_XDERIVE, and syn().

                                                           {
  return syn (GEN_XDERIVE, g, v); }

syntactic xderive

(

const syntactic &

g

)

Definition at line 480 of file syntactic.cpp.

References GEN_XDERIVE, and syn().

Referenced by xderive_op::op(), and xderive_op::set_op().

                                       {
  return syn (GEN_XDERIVE, g); }

syntactic xgcd	(	const syntactic &	g1,
		const syntactic &	g2
	)

Definition at line 413 of file syntactic.cpp.

References exact_eq(), GEN_ROW, GEN_SQTUPLE, and syn().

                                                          {
  if (exact_eq (g1, 0))
    return exact_eq (g2, 0) ?
      syn (GEN_SQTUPLE, syn (GEN_ROW, 1, 0     ), syn (GEN_ROW, 0, 1)) :
      syn (GEN_SQTUPLE, syn (GEN_ROW, 0, 1 / g2), syn (GEN_ROW, 1, 0));
  return exact_eq (g2, 0) ?
    syn (GEN_SQTUPLE, syn (GEN_ROW, 1 / g1, 0), syn (GEN_ROW, 0  , 1 )) :
    syn (GEN_SQTUPLE, syn (GEN_ROW, 1 / g1, 0), syn (GEN_ROW, -g2, g1));
}

xgcd_matrix<generic> mmx::xgcd	(	const generic &	x1,
		const generic &	x2
	)

Referenced by xgcd_op::op(), and xgcd_op::set_op().

generic xgen	(	const generic &	f,
		const generic &	args
	)

Definition at line 162 of file generic.cpp.

References vector_to_compound(), and xgen_sub().

Referenced by xaccess(), xrow(), xsqtuple(), and xtuple().

                                             {
  vector<generic> v;
  v << f;
  xgen_sub (v, args);
  return vector_to_compound (v);
}

void mmx::xgen_sub	(	vector< generic > &	v,
		const generic &	g
	)

Definition at line 152 of file generic.cpp.

References exact_eq(), GEN_COMMA, n, and N().

Referenced by xgen().

                                                {
  if (is<compound> (g) && N(g) >= 1 && exact_eq (g[0], GEN_COMMA)) {
    int i, n= N(g);
    for (i=1; i<n; i++)
      xgen_sub (v, g[i]);
  }
  else v << g;
}

generic xrow

(

const generic &

args

)

Definition at line 179 of file generic.cpp.

References GEN_ROW, and xgen().

                                {
  return xgen (GEN_ROW, g); }

generic xsqtuple

(

const generic &

args

)

Definition at line 177 of file generic.cpp.

References GEN_SQTUPLE, and xgen().

Referenced by trig_op::op(), and trig().

                                    {
  return xgen (GEN_SQTUPLE, g); }

generic xtuple

(

const generic &

args

)

Definition at line 175 of file generic.cpp.

References GEN_TUPLE, and xgen().

                                  {
  return xgen (GEN_TUPLE, g); }

C mmx::zero_cst

(

)

[inline]

Definition at line 888 of file type_props.hpp.

References C, and set_zero().

{ C r; set_zero (r); return r; }

scalar_type_helper< T >::val mmx::zero_scalar

(

const T &

y

)

[inline]

Definition at line 567 of file type_props.hpp.

References promote_scalar().

                         {
  return promote_scalar ((int) 0, y);
}

---

Variable Documentation

char * alloc_mem = NULL

Definition at line 27 of file fast_new.cpp.

Referenced by enlarge_malloc().

size_t alloc_remains = 0

Definition at line 28 of file fast_new.cpp.

Referenced by enlarge_malloc(), mmx_mem_info(), and mmx_used_bytes().

char alloc_table

Definition at line 26 of file fast_new.cpp.

Referenced by mmx_mem_info(), and mmx_used_bytes().

nat allocated = 0

Definition at line 29 of file fast_new.cpp.

string(* as_string_hook)(double x) = NULL

Referenced by as_string().

nat backtrace_depth = 8

Definition at line 20 of file source_track.cpp.

Referenced by source_exception().

bool batch_mode = false

Definition at line 54 of file terminal_interface.cpp.

Referenced by batch_mode_initialize().

table<generic,string> binary_readers [static]

Definition at line 55 of file generic.cpp.

Referenced by attach_generic_binary_reader(), and binary_read_generic().

bool booting_done

C

Definition at line 182 of file new_table.hpp.

Referenced by _mul_add(), accuracy_cst(), append(), big(), binary_map(), binary_map_optimized(), binary_map_scalar(), binpow(), bit_size(), catalan_cst(), cons(), copy(), invert_op::def(), default_cst(), solve_vector_lde_op::diff_op(), binary_helper< symbol< C, V > >::disassemble(), euler_cst(), extract(), extract_mod(), fill(), binary_helper< vector< C, V > >::full_type_name(), binary_helper< table< C, T, V > >::full_type_name(), binary_helper< symbol< C, V > >::full_type_name(), binary_helper< sparse_vector< C, T, V > >::full_type_name(), binary_helper< new_table< C, T, V > >::full_type_name(), binary_helper< list< C > >::full_type_name(), binary_helper< iterator< C > >::full_type_name(), binary_helper< heap< C > >::full_type_name(), binary_helper< chain< C > >::full_type_name(), fuzz_cst(), imaginary_cst(), infinity_cst(), insert(), is_numeric_string(), is_reliable(), iterator< C >::iterator(), largest_cst(), table_rep< D, pair< S1, S2 >, table_variant >::lazy_initialize(), new_table_rep< C, T, V >::lazy_initialize(), list< cleaner >::list(), log2_cst(), make_literal(), map(), maximal_cst(), minimal_cst(), mmx_classical_delete(), mmx_classical_new(), mmx_delete(), mmx_new(), nan_cst(), min_precision_op::neutral(), max_magnitude_op::neutral(), max_exponent_op::neutral(), sup_op::neutral(), inf_op::neutral(), max_op::neutral(), min_op::neutral(), lcm_op::neutral(), gcd_op::neutral(), one_cst(), prem_op::op(), lmul_op::op_mod(), rmul_op::op_mod(), mul_op::op_mod(), sub_op::op_mod(), add_op::op_mod(), neg_op::op_mod(), basic_alias_rep< C >::open(), pi_cst(), powint(), promote(), heap_rep< C >::Pull(), range(), binary_helper< vector< C, V > >::read(), binary_helper< table< C, T, V > >::read(), binary_helper< new_table< C, T, V > >::read(), vector_rep< observer, V >::resize(), heap_rep< C >::resize(), reverse(), format< iterator< T > >::sample(), seq(), set_as(), swap_op::set_op(), binary_helper< vector< C, V > >::short_type_name(), binary_helper< table< C, T, V > >::short_type_name(), binary_helper< symbol< C, V > >::short_type_name(), binary_helper< sparse_vector< C, T, V > >::short_type_name(), binary_helper< new_table< C, T, V > >::short_type_name(), binary_helper< list< C > >::short_type_name(), binary_helper< iterator< C > >::short_type_name(), binary_helper< heap< C > >::short_type_name(), binary_helper< chain< C > >::short_type_name(), smallest_cst(), sparse_vector< C, T, V >::sparse_vector(), string_as_numeric(), string_to_numeric(), swap(), unary_map(), fast_helper< vector< C, V > >::uu(), vec(), implementation< vector_linear, V, vector_naive >::vec_reverse(), implementation< vector_abstractions, V, vector_naive >::vec_unary_big(), implementation< vector_abstractions, V, vector_naive >::vec_unary_big_dicho(), implementation< vector_abstractions_stride, V, vector_naive >::vec_unary_big_stride(), vector< observer >::vector(), WRAP_INDIRECT_IMPL(), WRAP_WRAPPED_IMPL(), and zero_cst().

C2

Definition at line 40 of file triple.hpp.

Referenced by binary_map(), binary_map_scalar(), binary_helper< triple< C1, C2, C3 > >::full_type_name(), binary_helper< pair< C1, C2 > >::full_type_name(), binary_helper< triple< C1, C2, C3 > >::read(), binary_helper< pair< C1, C2 > >::read(), binary_helper< triple< C1, C2, C3 > >::short_type_name(), and binary_helper< pair< C1, C2 > >::short_type_name().

bool color_mode = false

Definition at line 22 of file port.cpp.

Referenced by supports_color().

char * command_name = NULL

Definition at line 33 of file system.cpp.

Referenced by command_dir().

void(* compiler_initialize)(void) = NULL

Referenced by mmc_initialize().

void(* compiler_terminate)(void) = NULL

Referenced by mmc_terminate().

bool completion_mode = true

Definition at line 53 of file terminal_interface.cpp.

Referenced by shell_terminal_input(), shell_texmacs_initialize(), and shell_texmacs_input().

generic CPP_ACCESS(".[]")

Referenced by opname_table().

generic CPP_ALIAS

generic CPP_ALIAS_TYPE("Alias")

generic CPP_AND("and")

Referenced by opname_table().

generic CPP_APPLY(".()")

Referenced by opname_table().

generic CPP_ARRAY_TYPE("Array")

generic CPP_ARROW("->")

Referenced by opname_table().

generic CPP_ASSIGN

Referenced by opname_table().

generic CPP_BEGIN("begin")

generic CPP_BITWISE_AND("/\\")

Referenced by opname_table().

generic CPP_BITWISE_OR("\\/")

Referenced by opname_table().

generic CPP_BITWISE_XOR("xor")

Referenced by opname_table().

generic CPP_BOOL

generic CPP_BOOL_TYPE("Boolean")

generic CPP_BRACKETS("()")

generic CPP_BREAK("break")

generic CPP_CAST(":>")

generic CPP_CATCH("catch")

generic CPP_CHAR_TYPE("Char")

generic CPP_CLASS

generic CPP_CLASS_TYPE("Type")

generic CPP_COMMA(",")

generic CPP_COMPLEMENT("~")

Referenced by opname_table().

generic CPP_CONST("const")

generic CPP_CONST_METHOD("const_method")

generic CPP_CONSTRUCT("construct")

generic CPP_CONSTRUCTOR("constructor")

generic CPP_CONTINUE("continue")

generic CPP_DELETE("delete")

generic CPP_DESTRUCTOR("destructor")

generic CPP_DIV

generic CPP_DO("do")

generic CPP_DOT(".")

generic CPP_ELSE("else")

generic CPP_EQUAL

Referenced by opname_table().

generic CPP_EXIT("exit")

generic CPP_EXTERN("extern")

generic CPP_EXTERN_C("extern_C")

generic CPP_FOR("for")

generic CPP_FRIEND("friend")

generic CPP_FUNCTION_TYPE("Function")

Referenced by is_function_type().

generic CPP_GOTO("goto")

generic CPP_GTR(">")

Referenced by opname_table().

generic CPP_GTREQ(">=")

Referenced by opname_table().

generic CPP_GTRGTR(">>")

Referenced by opname_table().

generic CPP_IF("if")

generic CPP_INHERIT("inherit")

generic CPP_INITIALIZE("initialize")

generic CPP_INLINE("inline")

Referenced by is_function_type().

generic CPP_INT

generic CPP_INT_TYPE("Int")

generic CPP_LABEL("label")

generic CPP_LESS

Referenced by opname_table().

generic CPP_LESSEQ("<=")

Referenced by opname_table().

generic CPP_LESSLESS("<<")

Referenced by opname_table().

generic CPP_MACRO("cpp_macro")

generic CPP_MINUS("-")

Referenced by opname_table().

generic CPP_MINUS_ASSIGN

Referenced by opname_table().

generic CPP_MMX_APPLICATION_TYPE("Mmx_application")

generic CPP_MOD("%")

Referenced by opname_table().

generic CPP_MOD_ASSIGN

Referenced by opname_table().

generic CPP_NAMESPACE("namespace")

generic CPP_NEW("new")

generic CPP_NOT("!")

Referenced by opname_table().

generic CPP_OR("or")

Referenced by opname_table().

generic CPP_OSTREAM

generic CPP_OVER("/")

Referenced by opname_table().

generic CPP_OVER_ASSIGN

Referenced by opname_table().

generic CPP_PLUS("+")

Referenced by opname_table().

generic CPP_PLUS_ASSIGN

Referenced by opname_table().

generic CPP_POINTER

generic CPP_POINTER_TYPE("Pointer")

generic CPP_POSTDEC(".--")

generic CPP_POSTINC(".++")

generic CPP_POWER("^")

generic CPP_PREDEC("--.")

Referenced by opname_table().

generic CPP_PREINC("++.")

Referenced by opname_table().

generic CPP_PUBLIC("public")

generic CPP_RETURN("return")

generic CPP_SCOPE("::")

generic CPP_SEMICOLON(";")

generic CPP_SPECIALIZE("specialize")

generic CPP_STATIC("static")

Referenced by is_function_type().

generic CPP_STRING

generic CPP_STRING_TYPE("String")

generic CPP_STRUCT("struct")

generic CPP_SWITCH("switch")

generic CPP_TEMPLATE("template")

generic CPP_THROW("raise")

generic CPP_TIMES("*")

Referenced by opname_table().

generic CPP_TIMES_ASSIGN

Referenced by opname_table().

generic CPP_TRY("try")

generic CPP_TYPE(":")

generic CPP_TYPE_CONSTRUCTOR("type_constructor")

generic CPP_TYPEDEF("typedef")

generic CPP_UNALIAS("unalias")

generic CPP_UNEQUAL

Referenced by opname_table().

generic CPP_UNFUNCTION("unfunction")

generic CPP_UNPOINTER("unpointer")

generic CPP_USING("using")

generic CPP_VERBATIM("verbatim")

generic CPP_VIRTUAL("virtual")

generic CPP_VOID

generic CPP_VOID_TYPE("Void")

generic CPP_WHILE("while")

generic CPP_XOR("^^")

static routine current_comparison [static]

Definition at line 114 of file glue_list_map.cpp.

Referenced by generic_compare(), list_sort(), vector_sort_leq_op::op(), and vector_sort_leq().

evaluator current_ev

Definition at line 57 of file evaluator.cpp.

Referenced by abs(), acos(), acos_init(), additive_error(), all_type_names(), default_routine_rep::apply(), apply(), arg(), asin(), asin_init(), atan(), atan_init(), attach_generic_binary_assembler(), binary_assemble_generic(), blur(), ceil(), center(), change_precision(), compose(), conj(), construct(), convert(), cos(), decexp2(), define(), define_constant(), define_constructor(), define_converter(), define_primitive(), define_type_sub(), define_user_type(), denominator(), derive(), dilate(), elementary_error(), eval(), exp(), exponent(), generic_object_rep::expression(), floor(), gcd(), generic::generic(), Im(), incexp2(), integrate(), integrate_init(), invert(), lcm(), log(), log_init(), lres(), lshiftz(), magnitude(), max(), min(), multiplicative_error(), next_above(), next_below(), numerator(), operator&(), operator*(), operator+(), operator-(), operator/(), operator<(), operator<<(), operator<=(), operator==(), operator>(), operator>=(), operator>>(), operator|(), pow(), precision(), prime(), quo(), radius(), Re(), rem(), restore_evaluator(), round(), rounding_error(), rres(), rshiftz(), select_evaluator(), sharpen(), sin(), solve(), solve_lde_init(), specialize(), sqrt(), sqrt_init(), square(), substitute(), tan(), trunc(), type_id(), type_name(), and uniform().

bool debug_mode = false

Definition at line 48 of file terminal_interface.cpp.

void(* dynamic_event)(const string &id, const generic &val)	(	const string &	id,
		const generic &	val
	)			= NULL

Referenced by GLUE_5(), output_observer_rep::modify(), and shell_texmacs_initialize().

void(* embedded_link)(const string &name)

(

const string &

name

)

= NULL

Referenced by dl_link().

bool ev_lock = false

Definition at line 56 of file evaluator.cpp.

nat fast_chunks = 0

Definition at line 30 of file fast_new.cpp.

Referenced by enlarge_malloc(), mmx_mem_info(), and mmx_used_bytes().

bool fed [static]

Definition at line 280 of file terminal_interface.cpp.

Referenced by active_newline(), passive_newline(), and shell_terminal_input().

table< vector<string>, string > file_sources [static]

Definition at line 31 of file source_track.cpp.

Referenced by get_file_source(), and store_file_source().

bool frac_flag = false [static]

Definition at line 242 of file syntactic.cpp.

Referenced by operator*(), operator/(), pow(), and set_frac_flag().

generic GEN_ABS("abs")

Referenced by abs(), abs_as_op::name(), and abs_op::name().

generic GEN_ACCESS(".[]")

Referenced by access(), math_symbol_table(), access_op::name(), and xaccess().

generic GEN_ACCURACY("accuracy")

Referenced by set_accuracy().

generic GEN_ADDITIVE_ERROR("additive_error")

Referenced by additive_error(), and additive_error_op::name().

generic GEN_ALIAS("alias")

Referenced by define_type_helper< C >::def_type(), and define_user_type().

generic GEN_ALIAS_TYPE("Alias")

Referenced by define_type_helper< C >::def_type(), define_user_type(), and get_user_type().

generic GEN_ALL_TYPES("all_types")

Referenced by all_type_names(), and define_type_sub().

generic GEN_AND("/\\")

Referenced by both< T1, T2 >::lazy_value(), math_symbol_table(), and operator&().

generic GEN_APPEND("><")

Referenced by math_symbol_table(), and append_op::name().

generic GEN_APPLY(".()")

Referenced by default_routine_rep::apply().

generic GEN_ARCCOS("arccos")

Referenced by accelerate(), acos(), and acos_op::name().

generic GEN_ARCSIN("arcsin")

Referenced by accelerate(), asin(), and asin_op::name().

generic GEN_ARCTAN("arctan")

Referenced by accelerate(), atan(), and atan_op::name().

generic GEN_ARCTAN2("arctan2")

Referenced by accelerate(), atan2(), and atan2_op::name().

generic GEN_ARG("arg")

Referenced by arg(), and arg_op::name().

generic GEN_ARGCH("argch")

Referenced by accelerate(), acosh(), and acosh_op::name().

generic GEN_ARGSH("argsh")

Referenced by accelerate(), asinh(), and asinh_op::name().

generic GEN_ARGTH("argth")

Referenced by accelerate(), atanh(), and atanh_op::name().

generic GEN_ASSIGN

Referenced by is_C0(), mmx_printer::pp_E0(), and id_op::set_name().

generic GEN_ASSIGN_MACRO(":=>")

Referenced by is_C0(), and mmx_printer::pp_E0().

generic GEN_ASSUME("assume")

Referenced by is_C0(), and mmx_printer::pp_E0().

generic GEN_AUTOFOLD("autofold")

Referenced by is_C0().

generic GEN_BACKPRIME(".`")

generic GEN_BACKQUOTE("`")

generic GEN_BACKTRACE("backtrace")

Referenced by has_trace(), trace_pull(), trace_push(), and trace_top().

generic GEN_BALL("ball")

Referenced by ball_op::name().

generic GEN_BEGIN("begin")

Referenced by is_C0(), and un_try_catch().

generic GEN_BLUR("blur")

Referenced by blur_op::name().

generic GEN_BOOLEAN_TYPE("Boolean")

Referenced by define_prerequisites().

generic GEN_BREAK("break")

Referenced by is_C0().

generic GEN_CACHE_CONVERTER("cache/converter")

generic GEN_CACHE_CONVERTERS("cache/converters")

generic GEN_CACHE_PENALTY("cache/penalty")

generic GEN_CACHED_DERIVE("%derive")

Referenced by derive().

generic GEN_CASE("case")

generic GEN_CAST("cast")

Referenced by accelerate().

generic GEN_CATALAN("mathcatalan")

Referenced by math_symbol_table(), and set_catalan().

generic GEN_CATCH("catch")

generic GEN_CATEGORY("category")

Referenced by is_C0().

generic GEN_CBRT("cbrt")

Referenced by cbrt_op::name().

generic GEN_CEIL("ceil")

Referenced by ceil(), and ceil_op::name().

generic GEN_CENTER("center")

Referenced by center(), and center_op::name().

generic GEN_CH("ch")

Referenced by accelerate(), cosh(), and cosh_op::name().

generic GEN_CHANGE_PRECISION("change_precision")

Referenced by change_precision(), and change_precision_op::name().

generic GEN_CLASS("class")

Referenced by is_C0().

generic GEN_CLASS_ACCESS("class/access")

generic GEN_CLASS_ENCAPSULATION("class/encapsulation")

generic GEN_CLASS_EXPORT("class/export")

generic GEN_CLASS_FIELDS("class/fields")

generic GEN_CLASS_MODE("class/mode")

generic GEN_CLASS_NAME("class/name")

generic GEN_CLOSURE("closure")

generic GEN_COERCE("coerce")

Referenced by is_applicable().

generic GEN_COERCE_TYPE("Coerce")

Referenced by is_applicable().

generic GEN_COMMA(",")

Referenced by comma(), and xgen_sub().

generic GEN_COMPLETE("complete")

Referenced by complete_op::name().

generic GEN_COMPOSE("@")

Referenced by compose(), math_symbol_table(), and compose_op::name().

generic GEN_COMPOUND_TYPE("Compound")

Referenced by define_prerequisites().

generic GEN_CONJ("conj")

Referenced by conj(), and conj_op::name().

generic GEN_CONSTANT("constant")

Referenced by is_C0().

generic GEN_CONSTRUCTOR("constructor")

generic GEN_CONTINUE("continue")

Referenced by is_C0().

generic GEN_CONVERT

Definition at line 309 of file identifiers.hpp.

Referenced by convert().

generic GEN_CONVERTER("converter")

generic GEN_CONVERTERS("converters")

generic GEN_CONVERTS("~>")

generic GEN_COS("cos")

Referenced by accelerate(), cos(), and cos_op::name().

generic GEN_CROSS_TYPE("Cross")

generic GEN_D("mathd")

generic GEN_DEFINE

Referenced by is_C0(), and mmx_printer::pp_E0().

generic GEN_DEFINE_MACRO

Referenced by is_C0(), and mmx_printer::pp_E0().

generic GEN_DELTA("delta")

Referenced by math_symbol_table().

generic GEN_DENOMINATOR("denominator")

Referenced by denominator(), and denominator_op::name().

generic GEN_DERIVATIVE("derivative")

Referenced by math_symbol_table().

generic GEN_DERIVE("derive")

Referenced by accelerate(), derive(), and derive_op::name().

generic GEN_DESTRUCTOR("destructor")

generic GEN_DIV("div")

Referenced by math_symbol_table(), rquo_op::name(), quo_op::name(), and quo().

generic GEN_DO("do")

generic GEN_DOT(".")

Referenced by math_symbol_table().

generic GEN_DOUBLE_TYPE("Double")

Referenced by define_prerequisites().

generic GEN_DOWNGRADE("downgrade")

generic GEN_DOWNTO("downto")

Referenced by math_symbol_table().

generic GEN_DUPLICATE("duplicate")

generic GEN_E("mathe")

Referenced by math_symbol_table().

generic GEN_ELEMENTARY_ERROR("elementary_error")

Referenced by elementary_error(), and elementary_error_op::name().

generic GEN_ELSE("else")

generic GEN_EMPTY("")

generic GEN_EQUAL

Referenced by define_type_helper< C >::def_default(), define_prerequisites(), define_user_type(), math_symbol_table(), equal_op::name(), and operator==().

generic GEN_EQUALIZE_GROUPED("equalize_grouped")

generic GEN_EQUIV("<=>")

Referenced by math_symbol_table().

generic GEN_ERF("erf")

Referenced by erf_op::name().

generic GEN_ERROR("error")

generic GEN_EULER("matheuler")

Referenced by math_symbol_table(), and set_euler().

generic GEN_EVALUATE("evaluate")

Referenced by evaluate_op::name().

generic GEN_EXACT_EQ("exact_eq")

Referenced by exact_eq_op::name().

generic GEN_EXACT_HASH("exact_hash")

Referenced by exact_hash_op::name().

generic GEN_EXACT_NEQ("exact_neq")

Referenced by exact_neq_op::name().

generic GEN_EXCEPTION("exception")

Referenced by has_trace(), std_exception(), trace_pull(), trace_push(), trace_top(), and user_exception().

generic GEN_EXISTS("exists")

Referenced by is_C0(), and mmx_printer::pp_E0().

generic GEN_EXP("exp")

Referenced by accelerate(), exp(), and exp_op::name().

generic GEN_EXP10("exp10")

Referenced by exp10_op::name().

generic GEN_EXP2("exp2")

Referenced by exp2_op::name().

generic GEN_EXPECTED("expected")

generic GEN_EXPLODE("@")

generic GEN_EXPONENT("exponent")

Referenced by exponent(), and exponent_op::name().

generic GEN_EXPORT("export")

generic GEN_EXTERN("extern")

Referenced by is_C0().

generic GEN_FACTORIAL(".!")

Referenced by math_symbol_table().

generic GEN_FALSE("false")

Referenced by define_prerequisites().

generic GEN_FAST("fast")

Referenced by fast_op::name().

generic GEN_FILL("^^")

generic GEN_FLATTEN("flatten")

Referenced by define_type_helper< C >::def_default(), define_user_type(), and generic_object_rep::expression().

generic GEN_FLOATING_TYPE("Floating")

generic GEN_FLOOR("floor")

Referenced by floor(), and floor_op::name().

generic GEN_FOR("for")

generic GEN_FORALL("forall")

Referenced by is_C0(), and mmx_printer::pp_E0().

generic GEN_FOREIGN("foreign")

Referenced by is_C0().

generic GEN_FUNCTION_TYPE("Function")

Referenced by routine_rep::function_type().

generic GEN_FUZZ("Fuzz")

Referenced by set_fuzz().

generic GEN_GAMMA("gamma")

Referenced by gamma_op::name().

generic GEN_GAUSSIAN("gaussian")

Referenced by gaussian_op::name().

generic GEN_GCD("gcd")

Referenced by gcd(), and gcd_op::name().

generic GEN_GENERATE("generate")

generic GEN_GENERATOR_TYPE("Generator")

generic GEN_GENERIC_ALIAS_TYPE("Generic_alias")

Referenced by define_type_helper< C >::def_type(), and get_user_type().

generic GEN_GENERIC_TYPE("Generic")

Referenced by define_prerequisites(), and define_user_type().

generic GEN_GLOBAL("global")

generic GEN_GRAD("grad")

generic GEN_GRAEFFE("graeffe")

Referenced by graeffe_op::name().

generic GEN_GTR(">")

Referenced by accelerate(), math_symbol_table(), gtr_op::name(), and operator>().

generic GEN_GTREQ(">=")

Referenced by accelerate(), math_symbol_table(), gtreq_op::name(), and operator>=().

generic GEN_GTRGTR(">>")

Referenced by math_symbol_table(), and operator>>().

generic GEN_GTRGTREQ

Referenced by is_C0(), and mmx_printer::pp_E0().

generic GEN_HARD_EQ("hard_eq")

Referenced by hard_eq_op::name().

generic GEN_HARD_GTR("hard_gtr")

Referenced by hard_gtr_op::name().

generic GEN_HARD_HASH("hard_hash")

Referenced by hard_hash_op::name().

generic GEN_HARD_LESS("hard_less")

Referenced by hard_less_op::name().

generic GEN_HARD_NEQ("hard_neq")

Referenced by hard_neq_op::name().

generic GEN_HAS("has")

Referenced by has< T, Op >::lazy_value().

generic GEN_HASH("hash")

Referenced by hash_op::name().

generic GEN_HAT(".^")

generic GEN_HYPOT("hypot")

Referenced by accelerate(), hypot(), and hypot_op::name().

generic GEN_I("mathi")

Referenced by math_symbol_table(), and set_imaginary().

generic GEN_IDENTITY("identity")

Referenced by compose(), and id_op::name().

generic GEN_IF("if")

Referenced by is_C0().

generic GEN_IM("Im")

Referenced by Im(), and Im_op::name().

generic GEN_IMPLIES("=>")

Referenced by math_symbol_table().

generic GEN_IMPORT("import")

generic GEN_IN("in")

Referenced by math_symbol_table().

generic GEN_INCLUDED("included")

Referenced by included_op::name().

generic GEN_INF

Referenced by inf_op::name().

generic GEN_INFINITY("Infty")

Referenced by math_symbol_table(), set_infinity(), set_maximal(), and set_minimal().

generic GEN_INFIX("infix")

generic GEN_INLINE("inline")

Referenced by is_C0().

generic GEN_INPLACE("inplace")

generic GEN_INT_TYPE("Int")

Referenced by define_prerequisites().

generic GEN_INTEGER_TYPE("Integer")

generic GEN_INTEGRATE("integrate")

Referenced by accelerate(), integrate(), and integrate_op::name().

generic GEN_INTEGRATE_INIT("integrate_init")

Referenced by integrate_init_op::name().

generic GEN_INTERN("intern")

Referenced by is_C0().

generic GEN_INTERVAL("interval")

Referenced by interval_op::name().

generic GEN_INTO("->")

Referenced by accelerate_converter(), define_converter(), define_user_type(), and math_symbol_table().

generic GEN_INVERT("invert")

Referenced by accelerate(), and invert_op::name().

generic GEN_KEYWORD("keyword")

generic GEN_LAMBDA("lambda")

Referenced by is_applicable(), and is_C0().

generic GEN_LARGEST("largest")

Referenced by set_largest().

generic GEN_LCM("lcm")

Referenced by lcm(), and lcm_op::name().

generic GEN_LESS

Referenced by accelerate(), math_symbol_table(), less_op::name(), and operator<().

generic GEN_LESSEQ("<=")

Referenced by accelerate(), math_symbol_table(), lesseq_op::name(), and operator<=().

generic GEN_LESSLESS("<<")

Referenced by math_symbol_table(), and operator<<().

generic GEN_LESSLESSEQ

Referenced by is_C0(), and mmx_printer::pp_E0().

generic GEN_LIFT("lift")

Referenced by lift_op::name().

generic GEN_LIST("list")

generic GEN_LITERAL_FLOATING("literal_floating")

generic GEN_LITERAL_INTEGER("literal_integer")

generic GEN_LITERAL_STRING("literal_string")

generic GEN_LITERAL_TYPE("Literal")

Referenced by define_prerequisites().

generic GEN_LOCAL("local")

generic GEN_LOG("log")

Referenced by accelerate(), log(), and log_op::name().

generic GEN_LOG10("log10")

Referenced by log10_op::name().

generic GEN_LOG2("log2")

Referenced by log2_op::name().

generic GEN_LOG2_AS("set_log2")

generic GEN_LOOP("loop")

Referenced by is_C0().

generic GEN_LOWER("lower")

Referenced by lower_op::name().

generic GEN_MACRO("macro")

Referenced by is_applicable(), and is_C0().

generic GEN_MACRO_TYPE("Macro")

Referenced by define_prerequisites().

generic GEN_MAGNITUDE("magnitude")

Referenced by magnitude(), and magnitude_op::name().

generic GEN_MAPSTO(":->")

Referenced by math_symbol_table().

generic GEN_MATCH("match")

generic GEN_MAX("max")

Referenced by max(), and max_op::name().

generic GEN_METHOD("method")

Referenced by is_C0().

generic GEN_MIN("min")

Referenced by min(), and min_op::name().

generic GEN_MINUS("-")

Referenced by accelerate(), as_texmacs(), collect(), math_symbol_table(), migrate_negate(), migrate_sub(), lsub_op::name(), rsub_op::name(), sub_op::name(), neg_op::name(), operator+(), operator-(), serialize(), and signed_decompose().

generic GEN_MINUS_ASSIGN

Referenced by is_C0(), mmx_printer::pp_E0(), and sub_op::set_name().

generic GEN_MOD("mod")

Referenced by math_symbol_table(), rrem_op::name(), rem_op::name(), and rem().

generic GEN_MODULE("module")

Referenced by is_C0().

generic GEN_MUL_ADD("mul_add")

Referenced by lmul_add_op::name(), rmul_add_op::name(), and mul_add_op::name().

generic GEN_MUL_SUB("mul_sub")

Referenced by mul_sub_op::name().

generic GEN_MULTIPLICATIVE_ERROR("multiplicative_error")

Referenced by multiplicative_error(), and multiplicative_error_op::name().

generic GEN_MUTABLE("mutable")

Referenced by is_C0().

generic GEN_NAN("NaN")

Referenced by set_nan().

generic GEN_NEW("new")

Referenced by define_constructor().

generic GEN_NEXT_ABOVE("next_above")

Referenced by next_above().

generic GEN_NEXT_BELOW("next_below")

Referenced by next_below().

generic GEN_NIL("nil")

Referenced by flatten().

generic GEN_NOOP("noop")

Referenced by no_op::set_name().

generic GEN_NOT("!")

Referenced by math_symbol_table().

generic GEN_NUMERATOR("numerator")

Referenced by numerator_op::name(), and numerator().

generic GEN_OPERATOR("operator")

generic GEN_OR("\\/")

Referenced by math_symbol_table(), and operator|().

generic GEN_OUTLINE("outline")

Referenced by is_C0().

generic GEN_OVER("/")

Referenced by accelerate(), invert(), math_symbol_table(), ldiv_op::name(), rdiv_op::name(), div_op::name(), product_less_op::op(), sum_less_op::op(), operator*(), operator/(), pow(), and signed_decompose().

generic GEN_OVER_ASSIGN

Referenced by is_C0(), mmx_printer::pp_E0(), and div_op::set_name().

generic GEN_OVER_I("over_i")

Referenced by over_i_op::name().

generic GEN_PARTIAL("partial")

Referenced by math_symbol_table().

generic GEN_PATTERN("pattern")

generic GEN_PENALTY("penalty")

Referenced by is_C0(), and mmx_printer::pp_E0().

generic GEN_PI("mathpi")

Referenced by math_symbol_table(), and set_pi().

generic GEN_PLUS("+")

Referenced by accelerate(), as_texmacs(), collect(), math_symbol_table(), migrate_negate(), ladd_op::name(), radd_op::name(), add_op::name(), operator+(), operator-(), and serialize().

generic GEN_PLUS_ASSIGN

Referenced by is_C0(), mmx_printer::pp_E0(), and add_op::set_name().

generic GEN_POLAR("polar")

Referenced by polar_op::name().

generic GEN_POSTFIX("postfix")

generic GEN_POWER("^")

Referenced by accelerate(), math_symbol_table(), lpow_op::name(), pow_op::name(), product_less_op::op(), pow(), and square().

generic GEN_PRECISION("precision")

Referenced by precision_op::name(), and precision().

generic GEN_PREFER("prefer")

generic GEN_PREFIX("prefix")

generic GEN_PRIME(".'")

Referenced by math_symbol_table().

generic GEN_PRIVATE("private")

Referenced by is_C0().

generic GEN_PROJECT("project")

Referenced by project_op::name().

generic GEN_PUBLIC("public")

Referenced by is_C0().

generic GEN_QUO("quo")

generic GEN_QUOTE("'")

generic GEN_RADIUS("radius")

Referenced by radius_op::name(), and radius().

generic GEN_RAISE("raise")

generic GEN_RANGE("..")

Referenced by math_symbol_table().

generic GEN_RATIONAL_TYPE("Rational")

generic GEN_RE("Re")

Referenced by Re_op::name(), and Re().

generic GEN_RECONSTRUCT("reconstruct")

Referenced by reconstruct_op::name().

generic GEN_REM("rem")

generic GEN_RETURN("return")

Referenced by is_C0().

generic GEN_REVERSE("reverse")

Referenced by reverse_op::name().

generic GEN_REWRITE("rewrite")

Referenced by define_type_helper< C >::def_type(), and define_user_type().

generic GEN_ROUND("round")

Referenced by round_op::name(), and round().

generic GEN_ROUNDING_ERROR("rounding_error")

Referenced by rounding_error_op::name(), and rounding_error().

generic GEN_ROUTINE_TYPE("Routine")

Referenced by define_prerequisites().

generic GEN_ROW("(.)")

Referenced by as_math(), make_document(), make_row(), math_symbol_table(), WRAP_BINARY_IMPL_1(), WRAP_INDIRECT_IMPL(), xgcd(), and xrow().

generic GEN_SEMICOLON(";")

generic GEN_SEQAND("and")

Referenced by is_applicable(), and math_symbol_table().

generic GEN_SEQOR("or")

Referenced by is_applicable(), and math_symbol_table().

generic GEN_SH("sh")

Referenced by accelerate(), sinh_op::name(), and sinh().

generic GEN_SHARPEN("sharpen")

Referenced by sharpen_op::name().

generic GEN_SIGN

Referenced by sign_op::name(), and sign_op::op().

generic GEN_SIN("sin")

Referenced by accelerate(), sin_op::name(), and sin().

generic GEN_SINGLE_TYPE("Single")

generic GEN_SIZE("#")

Referenced by math_symbol_table().

generic GEN_SLOW("slow")

Referenced by slow_op::name().

generic GEN_SMALLEST("smallest")

Referenced by set_smallest().

generic GEN_SOLVE("solve")

Referenced by solve().

generic GEN_SPECIALIZE("specialize")

Referenced by define_type_helper< C >::def_type(), and define_user_type().

generic GEN_SPECIALIZE_ALIAS("specialize_alias")

generic GEN_SQRT("sqrt")

Referenced by accelerate(), sqrt_op::name(), pow(), and sqrt().

generic GEN_SQTUPLE("[]")

Referenced by as_math(), flatten(), math_symbol_table(), trig(), xgcd(), and xsqtuple().

generic GEN_SQUARE("square")

Referenced by accelerate(), and square_op::name().

generic GEN_STAR(".*")

generic GEN_STEP("step")

generic GEN_SUBSTITUTE("substitute")

Referenced by substitute().

generic GEN_SUP

Referenced by sup_op::name().

generic GEN_SYMBOL_TYPE("Symbol")

generic GEN_TAN("tan")

Referenced by accelerate(), tan_op::name(), and tan().

generic GEN_TH("th")

Referenced by accelerate(), tanh_op::name(), and tanh().

generic GEN_THIS("this")

generic GEN_THIS_TYPE("This")

generic GEN_TILDA(".~")

generic GEN_TIMES("*")

Referenced by accelerate(), math_symbol_table(), lmul_op::name(), rmul_op::name(), mul_op::name(), sum_less_op::op(), operator*(), signed_decompose(), and square().

generic GEN_TIMES_ASSIGN

Referenced by is_C0(), mmx_printer::pp_E0(), and mul_op::set_name().

generic GEN_TIMES_I("times_i")

Referenced by times_i_op::name().

generic GEN_TO("to")

Referenced by math_symbol_table().

generic GEN_TRANSITIVE("transitive")

generic GEN_TRANSTYPE(":>")

Referenced by math_symbol_table().

generic GEN_TRUE("true")

Referenced by define_prerequisites().

generic GEN_TRUNC("trunc")

Referenced by trunc_op::name(), and trunc().

generic GEN_TRUNCATE("truncate")

Referenced by truncate_op::name().

generic GEN_TRY("try")

Referenced by is_C0().

generic GEN_TUPLE("()")

Referenced by flatten(), list_foreach(), math_symbol_table(), table_contains(), table_read(), table_reset(), table_set(), table_write(), vector_foreach(), void_value(), WRAP_BINARY_IMPL_1(), and xtuple().

generic GEN_TUPLE_TYPE("Tuple")

Referenced by define_type_helper< C >::def_type(), define_user_type(), and get_user_type().

generic GEN_TYPE(":")

Referenced by composite_port_rep::expression().

generic GEN_TYPE_ID("type_id")

Referenced by define_type_sub(), and type_id().

generic GEN_TYPE_NAME("type_name")

Referenced by define_type_sub(), and type_name().

generic GEN_TYPE_TYPE("Type")

generic GEN_UNALIAS("unalias")

Referenced by define_type_helper< C >::def_type(), and define_user_type().

generic GEN_UNEQUAL

Referenced by define_type_helper< C >::def_default(), define_prerequisites(), define_user_type(), math_symbol_table(), and unequal_op::name().

generic GEN_UNSPECIFIED_TYPE("Unspecified")

Referenced by type_name().

generic GEN_UNTIL("until")

generic GEN_UPGRADE("upgrade")

generic GEN_UPPER("upper")

Referenced by upper_op::name().

generic GEN_VARTRANSTYPE("::>")

Referenced by math_symbol_table().

generic GEN_VARTYPE("::")

Referenced by math_symbol_table().

generic GEN_VIA_TUPLE("via_tuple")

generic GEN_VOID_TYPE("Void")

generic GEN_VWHERE("||")

Referenced by math_symbol_table().

generic GEN_WHERE("|")

Referenced by math_symbol_table().

generic GEN_WHILE("while")

generic GEN_XDERIVE("xderive")

Referenced by xderive_op::name(), and xderive().

generic GEN_XGCD("xgcd")

generic GEN_XOR("xor")

Referenced by is_applicable(), and math_symbol_table().

generic GEN_YIELD("yield")

generic GEN_ZETA("zeta")

Referenced by zeta_op::name().

table<void (*) (), string> glue_table)() [static]

Definition at line 108 of file glue.cpp.

Referenced by call_glue(), and register_glue().

                                                 {
  static table<void (*) (), string> t;
  return t;
}

const nat hibit_mask = ((nat) 1) << 31

Definition at line 54 of file new_table.hpp.

Referenced by new_table_rep< C, T, V >::find(), and new_table_rep< C, T, V >::set().

nat history_size = 100

Definition at line 51 of file terminal_interface.cpp.

Referenced by shell_load_history(), and shell_save_history().

list< string > identifiers_for_completion

Initial value:

 
  list<string> ("case", "continue", "else", "error") *
  list<string> ("exists", "for", "generate", "in") *
  list<string> ("operator", "postfix", "prefix", "step") *
  list<string> ("then", "until", "while", "help")

Definition at line 190 of file terminal_interface.cpp.

Referenced by complete(), and completion_generator().

table< int, int > in_count

Definition at line 33 of file posix_port.cpp.

Referenced by posix_port_rep::posix_port_rep(), wait_port_event(), and posix_port_rep::~posix_port_rep().

static nat indentation_level = 0 [static]

Definition at line 193 of file cpp_printer.cpp.

Referenced by cpp_printer::cpp_printer(), and operator<<().

const int int_minus_infinity = (int) ((((nat) (-1)) >> 1) + 1)

Definition at line 23 of file int.hpp.

Referenced by glue_int().

const int int_plus_infinity = (int) (((nat) (-1)) >> 1)

Definition at line 22 of file int.hpp.

Referenced by glue_int().

const int int_size = sizeof (int)

Definition at line 25 of file int.hpp.

vector< vector<string> > interactive_sources [static]

Definition at line 30 of file source_track.cpp.

Referenced by get_interactive_number(), get_interactive_source(), store_interactive_number(), and store_interactive_source().

nat large_uses = 0

Definition at line 31 of file fast_new.cpp.

Referenced by mmx_free_thread_unsafe(), mmx_malloc_thread_unsafe(), mmx_mem_info(), and mmx_used_bytes().

const int long_int_size = sizeof (long int)

Definition at line 26 of file int.hpp.

bool math_mode = false

Definition at line 21 of file port.cpp.

Referenced by output_as_mmx(), and shell_texmacs_output().

mutex memory_lock

Definition at line 26 of file threads.cpp.

Referenced by mmx_free_thread_safe(), mmx_malloc_thread_safe(), and mmx_realloc_thread_safe().

vector< string > mmc_args

Definition at line 22 of file mmc_glue.cpp.

Referenced by mmc_initialize().

port mmerr = formatting_port (output_file_port (stderr, false, false, "mmerr"))

Definition at line 74 of file port.hpp.

Referenced by port_rep::accept(), routine_rep::apply(), binary_assemble_generic(), binary_read_generic(), port_rep::component(), verbose_as_helper< T, F >::cv(), file_last_modified(), port_rep::format(), glue_port(), handle_completion_request(), mmc_unliteral(), operator<<(), pipe_port(), nil_function_rep::Quote_apply(), source_error(), and texmacs_to_scheme().

port mmin = input_file_port (stdin , false, false, "mmin")

Definition at line 137 of file file_port.cpp.

Referenced by glue_port(), and shell_texmacs_input().

port mmout = formatting_port (output_file_port (stdout, false, false, "mmout"))

Definition at line 73 of file port.hpp.

Referenced by fatal_error(), glue_port(), mmx_mem_info(), output_completion(), read_line(), replace_lf(), shell_texmacs_initialize(), shell_texmacs_input(), shell_texmacs_output(), symbol_rep< vector< generic >, exact_eq_table >::show_symbol_entries(), texmacs_dynamic_event(), and vector_map_1().

bool mmx_abbreviate_coerce = true

Definition at line 23 of file mmx_printer.cpp.

int mmx_argc

Definition at line 22 of file basix.cpp.

char ** mmx_argv

Definition at line 23 of file basix.cpp.

bool new_convert_style

bool new_lambda_style

new_table< C, T, V >

Definition at line 182 of file new_table.hpp.

table< int, int > out_count

Definition at line 32 of file posix_port.cpp.

Referenced by posix_port_rep::posix_port_rep(), and posix_port_rep::~posix_port_rep().

const char path_sep = ':' [static]

Definition at line 58 of file system.cpp.

Referenced by global_path(), load_path(), path_name(), resolve_name(), and var_load().

bool quiet_mode = false

Definition at line 47 of file terminal_interface.cpp.

Referenced by shell_terminal_input().

scalar_type

Definition at line 182 of file new_table.hpp.

bool script_mode = false

Definition at line 46 of file terminal_interface.cpp.

string shell_mmx_prompt = "mmx-prompt"

Definition at line 160 of file texmacs_interface.cpp.

Referenced by shell_texmacs_input().

list<evaluator> stack_ev

Definition at line 58 of file evaluator.cpp.

Referenced by restore_evaluator(), and select_evaluator().

table< generic, generic > strings_for_completion

Definition at line 196 of file terminal_interface.cpp.

Referenced by complete(), and completion_generator().

system_instance system_inst

Definition at line 189 of file system.cpp.

T

Definition at line 182 of file new_table.hpp.

Referenced by binary_map(), binary_map_scalar(), as_helper< vector< T, TV >, vector< F, FV > >::cv(), verbose_as_helper< T, F >::cv(), binary_helper< table< C, T, V > >::full_type_name(), binary_helper< format< T > >::full_type_name(), binary_helper< new_table< C, T, V > >::full_type_name(), global_type_id(), mmx_delete_at(), mmx_delete_uninitialized(), mmx_new_at(), mmx_new_uninitialized(), zero_op::op(), outplace_set_as(), promote(), promote_scalar(), binary_helper< table< C, T, V > >::read(), binary_helper< new_table< C, T, V > >::read(), set_as(), project_helper< vector< C, V > >::set_op(), lift_helper< vector< C, V > >::set_op(), binary_helper< table< C, T, V > >::short_type_name(), binary_helper< format< T > >::short_type_name(), binary_helper< new_table< C, T, V > >::short_type_name(), sort_leq(), and unary_map().

table< C, T, V >

Definition at line 160 of file table.hpp.

bool texmacs_mode = false

Definition at line 22 of file port.hpp.

Referenced by batch_mode_initialize(), and supports_color().

string texmacs_pending = "" [static]

Definition at line 33 of file mmx_texmacs.cpp.

Referenced by texmacs_command(), and texmacs_flush_commands().

bool the_series_expr = false

Definition at line 551 of file syntactic.cpp.

nat the_series_prec = 10

Definition at line 549 of file syntactic.cpp.

nat the_series_zt = 25

Definition at line 550 of file syntactic.cpp.

const bool threads_active = false [static]

Definition at line 97 of file fast_new.hpp.

Referenced by mmx_free(), mmx_malloc(), and mmx_realloc().

nat threads_number = 1

Definition at line 216 of file threads.cpp.

bool time_mode = false

Definition at line 50 of file terminal_interface.cpp.

bool type_mode = false

Definition at line 49 of file terminal_interface.cpp.

Referenced by shell_texmacs_output().

V

Definition at line 182 of file new_table.hpp.

Referenced by default_aligned_size(), and solve_vector_lde_op::diff_op().