Results for: "Logger"

Return the receiver associated with this NameError exception.

Return this SystemCallError’s error number.

Registers filename to be loaded (using Kernel::require) the first time that module (which may be a String or a symbol) is accessed in the namespace of mod.

module A
end
A.autoload(:B, "b")
A::B.doit            # autoloads "b"

Returns filename to be loaded if name is registered as autoload in the namespace of mod.

module A
end
A.autoload(:B, "b")
A.autoload?(:B)            #=> "b"

Internal method used to provide marshalling support. See the Marshal module.

Returns the modulus from dividing by b.

See BigDecimal#divmod.

Returns the remainder from dividing by the value.

x.remainder(y) means x-y*(x/y).truncate

Return the largest integer less than or equal to the value, as a BigDecimal.

BigDecimal('3.14159').floor #=> 3
BigDecimal('-9.1').floor #=> -10

If n is specified and positive, the fractional part of the result has no more than that many digits.

If n is specified and negative, at least that many digits to the left of the decimal point will be 0 in the result.

BigDecimal('3.14159').floor(3) #=> 3.141
BigDecimal('13345.234').floor(-2) #=> 13300.0

Returns the value raised to the power of n.

Note that n must be an Integer.

Also available as the operator **.

Returns True if the value is zero.

Returns self if the value is non-zero, nil otherwise.

The coerce method provides support for Ruby type coercion. It is not enabled by default.

This means that binary operations like + * / or - can often be performed on a BigDecimal and an object of another type, if the other object can be coerced into a BigDecimal value.

e.g.

a = BigDecimal("1.0")
b = a / 2.0 #=> 0.5

Note that coercing a String to a BigDecimal is not supported by default; it requires a special compile-time option when building Ruby.

Returns the numerator.

Rational(7).numerator        #=> 7
Rational(7, 1).numerator     #=> 7
Rational(9, -4).numerator    #=> -9
Rational(-2, -10).numerator  #=> 1

Returns the largest number less than or equal to rat with a precision of ndigits decimal digits (default: 0).

When the precision is negative, the returned value is an integer with at least ndigits.abs trailing zeros.

Returns a rational when ndigits is positive, otherwise returns an integer.

Rational(3).floor      #=> 3
Rational(2, 3).floor   #=> 0
Rational(-3, 2).floor  #=> -2

  #    decimal      -  1  2  3 . 4  5  6
  #                   ^  ^  ^  ^   ^  ^
  #   precision      -3 -2 -1  0  +1 +2

Rational('-123.456').floor(+1).to_f  #=> -123.5
Rational('-123.456').floor(-1)       #=> -130

Creates a date object denoting the given week date.

The week and the day of week should be a negative or a positive number (as a relative week/day from the end of year/week when negative). They should not be zero.

Date.commercial(2001)     #=> #<Date: 2001-01-01 ...>
Date.commercial(2002)     #=> #<Date: 2001-12-31 ...>
Date.commercial(2001,5,6) #=> #<Date: 2001-02-03 ...>

See also ::jd and ::new.

Creates a DateTime object denoting the given week date.

DateTime.commercial(2001) #=> #<DateTime: 2001-01-01T00:00:00+00:00 ...>
DateTime.commercial(2002) #=> #<DateTime: 2001-12-31T00:00:00+00:00 ...>
DateTime.commercial(2001,5,6,4,5,6,'+7')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

Same as Time::gm, but interprets the values in the local time zone.

Time.local(2000,"jan",1,20,15,1)   #=> 2000-01-01 20:15:01 -0600

Converts time to local time (using the local time zone in effect at the creation time of time) modifying the receiver.

If utc_offset is given, it is used instead of the local time.

t = Time.utc(2000, "jan", 1, 20, 15, 1) #=> 2000-01-01 20:15:01 UTC
t.utc?                                  #=> true

t.localtime                             #=> 2000-01-01 14:15:01 -0600
t.utc?                                  #=> false

t.localtime("+09:00")                   #=> 2000-01-02 05:15:01 +0900
t.utc?                                  #=> false

If utc_offset is not given and time is local time, just returns the receiver.

Returns a new Time object representing time in UTC.

t = Time.local(2000,1,1,20,15,1)   #=> 2000-01-01 20:15:01 -0600
t.gmt?                             #=> false
y = t.getgm                        #=> 2000-01-02 02:15:01 UTC
y.gmt?                             #=> true
t == y                             #=> true

Returns a new Time object representing time in UTC.

t = Time.local(2000,1,1,20,15,1)   #=> 2000-01-01 20:15:01 -0600
t.gmt?                             #=> false
y = t.getgm                        #=> 2000-01-02 02:15:01 UTC
y.gmt?                             #=> true
t == y                             #=> true

Closes the database.

Returns true if the database is closed, false otherwise.

Returns a Hash (not a DBM database) created by using each value in the database as a key, with the corresponding key as its value.

Returns true if the database contains the specified key, false otherwise.