void Init_Range(void) { #undef rb_intern #define rb_intern(str) rb_intern_const(str) id_cmp = rb_intern("<=>"); id_succ = rb_intern("succ"); id_beg = rb_intern("begin"); id_end = rb_intern("end"); id_excl = rb_intern("excl"); id_integer_p = rb_intern("integer?"); id_div = rb_intern("div"); rb_cRange = rb_struct_define_without_accessor( "Range", rb_cObject, range_alloc, "begin", "end", "excl", NULL); rb_include_module(rb_cRange, rb_mEnumerable); rb_marshal_define_compat(rb_cRange, rb_cObject, range_dumper, range_loader); rb_define_method(rb_cRange, "initialize", range_initialize, -1); rb_define_method(rb_cRange, "initialize_copy", range_initialize_copy, 1); rb_define_method(rb_cRange, "==", range_eq, 1); rb_define_method(rb_cRange, "===", range_eqq, 1); rb_define_method(rb_cRange, "eql?", range_eql, 1); rb_define_method(rb_cRange, "hash", range_hash, 0); rb_define_method(rb_cRange, "each", range_each, 0); rb_define_method(rb_cRange, "step", range_step, -1); rb_define_method(rb_cRange, "bsearch", range_bsearch, 0); rb_define_method(rb_cRange, "begin", range_begin, 0); rb_define_method(rb_cRange, "end", range_end, 0); rb_define_method(rb_cRange, "first", range_first, -1); rb_define_method(rb_cRange, "last", range_last, -1); rb_define_method(rb_cRange, "min", range_min, -1); rb_define_method(rb_cRange, "max", range_max, -1); rb_define_method(rb_cRange, "size", range_size, 0); rb_define_method(rb_cRange, "to_s", range_to_s, 0); rb_define_method(rb_cRange, "inspect", range_inspect, 0); rb_define_method(rb_cRange, "exclude_end?", range_exclude_end_p, 0); rb_define_method(rb_cRange, "member?", range_include, 1); rb_define_method(rb_cRange, "include?", range_include, 1); rb_define_method(rb_cRange, "cover?", range_cover, 1); }
/* * A complex number can be represented as a paired real number with * imaginary unit; a+bi. Where a is real part, b is imaginary part * and i is imaginary unit. Real a equals complex a+0i * mathematically. * * In ruby, you can create complex object with Complex, Complex::rect, * Complex::polar or to_c method. * * Complex(1) #=> (1+0i) * Complex(2, 3) #=> (2+3i) * Complex.polar(2, 3) #=> (-1.9799849932008908+0.2822400161197344i) * 3.to_c #=> (3+0i) * * You can also create complex object from floating-point numbers or * strings. * * Complex(0.3) #=> (0.3+0i) * Complex('0.3-0.5i') #=> (0.3-0.5i) * Complex('2/3+3/4i') #=> ((2/3)+(3/4)*i) * Complex('1@2') #=> (-0.4161468365471424+0.9092974268256817i) * * 0.3.to_c #=> (0.3+0i) * '0.3-0.5i'.to_c #=> (0.3-0.5i) * '2/3+3/4i'.to_c #=> ((2/3)+(3/4)*i) * '1@2'.to_c #=> (-0.4161468365471424+0.9092974268256817i) * * A complex object is either an exact or an inexact number. * * Complex(1, 1) / 2 #=> ((1/2)+(1/2)*i) * Complex(1, 1) / 2.0 #=> (0.5+0.5i) */ void Init_Complex(void) { VALUE compat; #undef rb_intern #define rb_intern(str) rb_intern_const(str) assert(fprintf(stderr, "assert() is now active\n")); id_abs = rb_intern("abs"); id_arg = rb_intern("arg"); id_convert = rb_intern("convert"); id_denominator = rb_intern("denominator"); id_eqeq_p = rb_intern("=="); id_expt = rb_intern("**"); id_fdiv = rb_intern("fdiv"); id_negate = rb_intern("-@"); id_numerator = rb_intern("numerator"); id_quo = rb_intern("quo"); id_real_p = rb_intern("real?"); id_to_f = rb_intern("to_f"); id_to_i = rb_intern("to_i"); id_to_r = rb_intern("to_r"); id_i_real = rb_intern("@real"); id_i_imag = rb_intern("@image"); /* @image, not @imag */ rb_cComplex = rb_define_class("Complex", rb_cNumeric); rb_define_alloc_func(rb_cComplex, nucomp_s_alloc); rb_undef_method(CLASS_OF(rb_cComplex), "allocate"); #if 0 rb_define_private_method(CLASS_OF(rb_cComplex), "new!", nucomp_s_new_bang, -1); rb_define_private_method(CLASS_OF(rb_cComplex), "new", nucomp_s_new, -1); #else rb_undef_method(CLASS_OF(rb_cComplex), "new"); #endif rb_define_singleton_method(rb_cComplex, "rectangular", nucomp_s_new, -1); rb_define_singleton_method(rb_cComplex, "rect", nucomp_s_new, -1); rb_define_singleton_method(rb_cComplex, "polar", nucomp_s_polar, -1); rb_define_global_function("Complex", nucomp_f_complex, -1); rb_undef_method(rb_cComplex, "%"); rb_undef_method(rb_cComplex, "<"); rb_undef_method(rb_cComplex, "<="); rb_undef_method(rb_cComplex, "<=>"); rb_undef_method(rb_cComplex, ">"); rb_undef_method(rb_cComplex, ">="); rb_undef_method(rb_cComplex, "between?"); rb_undef_method(rb_cComplex, "div"); rb_undef_method(rb_cComplex, "divmod"); rb_undef_method(rb_cComplex, "floor"); rb_undef_method(rb_cComplex, "ceil"); rb_undef_method(rb_cComplex, "modulo"); rb_undef_method(rb_cComplex, "remainder"); rb_undef_method(rb_cComplex, "round"); rb_undef_method(rb_cComplex, "step"); rb_undef_method(rb_cComplex, "truncate"); rb_undef_method(rb_cComplex, "i"); rb_define_method(rb_cComplex, "real", nucomp_real, 0); rb_define_method(rb_cComplex, "imaginary", nucomp_imag, 0); rb_define_method(rb_cComplex, "imag", nucomp_imag, 0); rb_define_method(rb_cComplex, "-@", nucomp_negate, 0); rb_define_method(rb_cComplex, "+", nucomp_add, 1); rb_define_method(rb_cComplex, "-", nucomp_sub, 1); rb_define_method(rb_cComplex, "*", nucomp_mul, 1); rb_define_method(rb_cComplex, "/", nucomp_div, 1); rb_define_method(rb_cComplex, "quo", nucomp_quo, 1); rb_define_method(rb_cComplex, "fdiv", nucomp_fdiv, 1); rb_define_method(rb_cComplex, "**", nucomp_expt, 1); rb_define_method(rb_cComplex, "==", nucomp_eqeq_p, 1); rb_define_method(rb_cComplex, "coerce", nucomp_coerce, 1); rb_define_method(rb_cComplex, "abs", nucomp_abs, 0); rb_define_method(rb_cComplex, "magnitude", nucomp_abs, 0); rb_define_method(rb_cComplex, "abs2", nucomp_abs2, 0); rb_define_method(rb_cComplex, "arg", nucomp_arg, 0); rb_define_method(rb_cComplex, "angle", nucomp_arg, 0); rb_define_method(rb_cComplex, "phase", nucomp_arg, 0); rb_define_method(rb_cComplex, "rectangular", nucomp_rect, 0); rb_define_method(rb_cComplex, "rect", nucomp_rect, 0); rb_define_method(rb_cComplex, "polar", nucomp_polar, 0); rb_define_method(rb_cComplex, "conjugate", nucomp_conj, 0); rb_define_method(rb_cComplex, "conj", nucomp_conj, 0); #if 0 rb_define_method(rb_cComplex, "~", nucomp_conj, 0); /* gcc */ #endif rb_define_method(rb_cComplex, "real?", nucomp_false, 0); #if 0 rb_define_method(rb_cComplex, "complex?", nucomp_true, 0); rb_define_method(rb_cComplex, "exact?", nucomp_exact_p, 0); rb_define_method(rb_cComplex, "inexact?", nucomp_inexact_p, 0); #endif rb_define_method(rb_cComplex, "numerator", nucomp_numerator, 0); rb_define_method(rb_cComplex, "denominator", nucomp_denominator, 0); rb_define_method(rb_cComplex, "hash", nucomp_hash, 0); rb_define_method(rb_cComplex, "eql?", nucomp_eql_p, 1); rb_define_method(rb_cComplex, "to_s", nucomp_to_s, 0); rb_define_method(rb_cComplex, "inspect", nucomp_inspect, 0); rb_define_private_method(rb_cComplex, "marshal_dump", nucomp_marshal_dump, 0); compat = rb_define_class_under(rb_cComplex, "compatible", rb_cObject); /* :nodoc: */ rb_define_private_method(compat, "marshal_load", nucomp_marshal_load, 1); rb_marshal_define_compat(rb_cComplex, compat, nucomp_dumper, nucomp_loader); /* --- */ rb_define_method(rb_cComplex, "to_i", nucomp_to_i, 0); rb_define_method(rb_cComplex, "to_f", nucomp_to_f, 0); rb_define_method(rb_cComplex, "to_r", nucomp_to_r, 0); rb_define_method(rb_cComplex, "rationalize", nucomp_rationalize, -1); rb_define_method(rb_cComplex, "to_c", nucomp_to_c, 0); rb_define_method(rb_cNilClass, "to_c", nilclass_to_c, 0); rb_define_method(rb_cNumeric, "to_c", numeric_to_c, 0); rb_define_method(rb_cString, "to_c", string_to_c, 0); rb_define_private_method(CLASS_OF(rb_cComplex), "convert", nucomp_s_convert, -1); /* --- */ rb_define_method(rb_cNumeric, "real", numeric_real, 0); rb_define_method(rb_cNumeric, "imaginary", numeric_imag, 0); rb_define_method(rb_cNumeric, "imag", numeric_imag, 0); rb_define_method(rb_cNumeric, "abs2", numeric_abs2, 0); rb_define_method(rb_cNumeric, "arg", numeric_arg, 0); rb_define_method(rb_cNumeric, "angle", numeric_arg, 0); rb_define_method(rb_cNumeric, "phase", numeric_arg, 0); rb_define_method(rb_cNumeric, "rectangular", numeric_rect, 0); rb_define_method(rb_cNumeric, "rect", numeric_rect, 0); rb_define_method(rb_cNumeric, "polar", numeric_polar, 0); rb_define_method(rb_cNumeric, "conjugate", numeric_conj, 0); rb_define_method(rb_cNumeric, "conj", numeric_conj, 0); rb_define_method(rb_cFloat, "arg", float_arg, 0); rb_define_method(rb_cFloat, "angle", float_arg, 0); rb_define_method(rb_cFloat, "phase", float_arg, 0); /* * The imaginary unit. */ rb_define_const(rb_cComplex, "I", f_complex_new_bang2(rb_cComplex, ZERO, ONE)); rb_provide("complex.so"); /* for backward compatibility */ }
/* called from Init_vm() in vm.c */ void Init_vm_backtrace(void) { /* :nodoc: */ rb_cBacktrace = rb_define_class_under(rb_cThread, "Backtrace", rb_cObject); rb_define_alloc_func(rb_cBacktrace, backtrace_alloc); rb_undef_method(CLASS_OF(rb_cBacktrace), "new"); rb_marshal_define_compat(rb_cBacktrace, rb_cArray, backtrace_dump_data, backtrace_load_data); /* * An object representation of a stack frame, initialized by * Kernel#caller_locations. * * For example: * * # caller_locations.rb * def a(skip) * caller_locations(skip) * end * def b(skip) * a(skip) * end * def c(skip) * b(skip) * end * * c(0..2).map do |call| * puts call.to_s * end * * Running <code>ruby caller_locations.rb</code> will produce: * * caller_locations.rb:2:in `a' * caller_locations.rb:5:in `b' * caller_locations.rb:8:in `c' * * Here's another example with a slightly different result: * * # foo.rb * class Foo * attr_accessor :locations * def initialize(skip) * @locations = caller_locations(skip) * end * end * * Foo.new(0..2).locations.map do |call| * puts call.to_s * end * * Now run <code>ruby foo.rb</code> and you should see: * * init.rb:4:in `initialize' * init.rb:8:in `new' * init.rb:8:in `<main>' */ rb_cBacktraceLocation = rb_define_class_under(rb_cBacktrace, "Location", rb_cObject); rb_undef_alloc_func(rb_cBacktraceLocation); rb_undef_method(CLASS_OF(rb_cBacktraceLocation), "new"); rb_define_method(rb_cBacktraceLocation, "lineno", location_lineno_m, 0); rb_define_method(rb_cBacktraceLocation, "label", location_label_m, 0); rb_define_method(rb_cBacktraceLocation, "base_label", location_base_label_m, 0); rb_define_method(rb_cBacktraceLocation, "path", location_path_m, 0); rb_define_method(rb_cBacktraceLocation, "absolute_path", location_absolute_path_m, 0); rb_define_method(rb_cBacktraceLocation, "to_s", location_to_str_m, 0); rb_define_method(rb_cBacktraceLocation, "inspect", location_inspect_m, 0); rb_define_global_function("caller", rb_f_caller, -1); rb_define_global_function("caller_locations", rb_f_caller_locations, -1); }