Venus::Number - Number Class
Number Class for Perl 5
package main; use Venus::Number; my $number = Venus::Number->new(1_000); # $number->abs;
This package provides methods for manipulating number data.
This package inherits behaviors from:
Venus::Kind::Value
This package provides the following methods:
abs() (Num)
The abs method returns the absolute value of the number.
Since 0.01
0.01
# given: synopsis; my $abs = $number->abs; # 1000
package main; use Venus::Number; my $number = Venus::Number->new(12); my $abs = $number->abs; # 12
package main; use Venus::Number; my $number = Venus::Number->new(-12); my $abs = $number->abs; # 12
atan2() (Num)
The atan2 method returns the arctangent of Y/X in the range -PI to PI.
package main; use Venus::Number; my $number = Venus::Number->new(1); my $atan2 = $number->atan2(1); # 0.785398163397448
cast(Str $kind) (Object | Undef)
The cast method converts "value" objects between different "value" object types, based on the name of the type provided. This method will return undef if the invocant is not a Venus::Kind::Value.
undef
Since 0.08
0.08
package main; use Venus::Number; my $number = Venus::Number->new; my $cast = $number->cast('array'); # bless({ value => [0] }, "Venus::Array")
package main; use Venus::Number; my $number = Venus::Number->new; my $cast = $number->cast('boolean'); # bless({ value => 0 }, "Venus::Boolean")
package main; use Venus::Number; my $number = Venus::Number->new; my $cast = $number->cast('code'); # bless({ value => sub { ... } }, "Venus::Code")
package main; use Venus::Number; my $number = Venus::Number->new; my $cast = $number->cast('float'); # bless({ value => "0.0" }, "Venus::Float")
package main; use Venus::Number; my $number = Venus::Number->new; my $cast = $number->cast('hash'); # bless({ value => { "0" => 0 } }, "Venus::Hash")
package main; use Venus::Number; my $number = Venus::Number->new; my $cast = $number->cast('number'); # bless({ value => 0 }, "Venus::Number")
package main; use Venus::Number; my $number = Venus::Number->new; my $cast = $number->cast('regexp'); # bless({ value => qr/(?^u:0)/ }, "Venus::Regexp")
package main; use Venus::Number; my $number = Venus::Number->new; my $cast = $number->cast('scalar'); # bless({ value => \0 }, "Venus::Scalar")
package main; use Venus::Number; my $number = Venus::Number->new; my $cast = $number->cast('string'); # bless({ value => 0 }, "Venus::String")
package main; use Venus::Number; my $number = Venus::Number->new; my $cast = $number->cast('undef'); # bless({ value => undef }, "Venus::Undef")
cos() (Num)
The cos method computes the cosine of the number (expressed in radians).
package main; use Venus::Number; my $number = Venus::Number->new(12); my $cos = $number->cos; # 0.843853958732492
decr() (Num)
The decr method returns the numeric number decremented by 1.
package main; use Venus::Number; my $number = Venus::Number->new(123456789); my $decr = $number->decr; # 123456788
package main; use Venus::Number; my $number = Venus::Number->new(123456789); my $decr = $number->decr(123456788); # 1
default() (Int)
The default method returns the default value, i.e. 0.
0
# given: synopsis; my $default = $number->default; # 0
eq(Any $arg) (Bool)
The eq method performs an "equals" operation using the argument provided.
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Array->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Code->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Float; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Float->new; my $result = $lvalue->eq($rvalue); # 1
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Number->new; my $result = $lvalue->eq($rvalue); # 1
package main; use Venus::Number; use Venus::Regexp; my $lvalue = Venus::Number->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Number; use Venus::Scalar; my $lvalue = Venus::Number->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::Number->new; my $rvalue = Venus::String->new; my $result = $lvalue->eq($rvalue); # 1
package main; use Venus::Number; use Venus::Undef; my $lvalue = Venus::Number->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->eq($rvalue); # 1
exp() (Num)
The exp method returns e (the natural logarithm base) to the power of the number.
package main; use Venus::Number; my $number = Venus::Number->new(0); my $exp = $number->exp; # 1
package main; use Venus::Number; my $number = Venus::Number->new(1); my $exp = $number->exp; # 2.71828182845905
package main; use Venus::Number; my $number = Venus::Number->new(1.5); my $exp = $number->exp; # 4.48168907033806
ge(Any $arg) (Bool)
The ge method performs a "greater-than-or-equal-to" operation using the argument provided.
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Array->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Code->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Float; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Float->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Number->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Number; use Venus::Regexp; my $lvalue = Venus::Number->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Number; use Venus::Scalar; my $lvalue = Venus::Number->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::Number->new; my $rvalue = Venus::String->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Number; use Venus::Undef; my $lvalue = Venus::Number->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->ge($rvalue); # 1
gele(Any $arg1, Any $arg2) (Bool)
The gele method performs a "greater-than-or-equal-to" operation on the 1st argument, and "lesser-than-or-equal-to" operation on the 2nd argument.
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Float; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gele($rvalue); # 1
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gele($rvalue); # 1
package main; use Venus::Number; use Venus::Regexp; my $lvalue = Venus::Number->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Number; use Venus::Scalar; my $lvalue = Venus::Number->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::Number->new; my $rvalue = Venus::String->new; my $result = $lvalue->gele($rvalue); # 1
package main; use Venus::Number; use Venus::Undef; my $lvalue = Venus::Number->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->gele($rvalue); # 1
gt(Any $arg) (Bool)
The gt method performs a "greater-than" operation using the argument provided.
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Float; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Number; use Venus::Regexp; my $lvalue = Venus::Number->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Number; use Venus::Scalar; my $lvalue = Venus::Number->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::Number->new; my $rvalue = Venus::String->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Number; use Venus::Undef; my $lvalue = Venus::Number->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->gt($rvalue); # 0
gtlt(Any $arg1, Any $arg2) (Bool)
The gtlt method performs a "greater-than" operation on the 1st argument, and "lesser-than" operation on the 2nd argument.
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Float; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Number; use Venus::Regexp; my $lvalue = Venus::Number->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Number; use Venus::Scalar; my $lvalue = Venus::Number->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::Number->new; my $rvalue = Venus::String->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Number; use Venus::Undef; my $lvalue = Venus::Number->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->gtlt($rvalue); # 0
hex() (Str)
The hex method returns a hex string representing the value of the number.
package main; use Venus::Number; my $number = Venus::Number->new(175); my $hex = $number->hex; # "0xaf"
incr() (Num)
The incr method returns the numeric number incremented by 1.
package main; use Venus::Number; my $number = Venus::Number->new(123456789); my $incr = $number->incr; # 123456790
package main; use Venus::Number; my $number = Venus::Number->new(123456790); my $incr = $number->incr(-1); # 123456789
int() (Int)
The int method returns the integer portion of the number. Do not use this method for rounding.
package main; use Venus::Number; my $number = Venus::Number->new(12.5); my $int = $number->int; # 12
le(Any $arg) (Bool)
The le method performs a "lesser-than-or-equal-to" operation using the argument provided.
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Array->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Code->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Float; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Float->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Number->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Number; use Venus::Regexp; my $lvalue = Venus::Number->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Number; use Venus::Scalar; my $lvalue = Venus::Number->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::Number->new; my $rvalue = Venus::String->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Number; use Venus::Undef; my $lvalue = Venus::Number->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->le($rvalue); # 1
log() (Num)
The log method returns the natural logarithm (base e) of the number.
package main; use Venus::Number; my $number = Venus::Number->new(12345); my $log = $number->log; # 9.42100640177928
lt(Any $arg) (Bool)
The lt method performs a "lesser-than" operation using the argument provided.
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Array->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Code->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Float; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Float->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Number->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Number; use Venus::Regexp; my $lvalue = Venus::Number->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Number; use Venus::Scalar; my $lvalue = Venus::Number->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::Number->new; my $rvalue = Venus::String->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Number; use Venus::Undef; my $lvalue = Venus::Number->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->lt($rvalue); # 0
mod() (Int)
The mod method returns the division remainder of the number divided by the argment.
package main; use Venus::Number; my $number = Venus::Number->new(12); my $mod = $number->mod(1); # 0
package main; use Venus::Number; my $number = Venus::Number->new(12); my $mod = $number->mod(2); # 0
package main; use Venus::Number; my $number = Venus::Number->new(12); my $mod = $number->mod(5); # 2
ne(Any $arg) (Bool)
The ne method performs a "not-equal-to" operation using the argument provided.
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Array->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Code->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Float; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Float->new; my $result = $lvalue->ne($rvalue); # 0
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Number->new; my $result = $lvalue->ne($rvalue); # 0
package main; use Venus::Number; use Venus::Regexp; my $lvalue = Venus::Number->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Number; use Venus::Scalar; my $lvalue = Venus::Number->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::Number->new; my $rvalue = Venus::String->new; my $result = $lvalue->ne($rvalue); # 0
package main; use Venus::Number; use Venus::Undef; my $lvalue = Venus::Number->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->ne($rvalue); # 0
neg() (Num)
The neg method returns a negative version of the number.
package main; use Venus::Number; my $number = Venus::Number->new(12345); my $neg = $number->neg; # -12345
numified() (Int)
The numified method returns the numerical representation of the object. For number objects this method returns the object's underlying value.
# given: synopsis; my $numified = $number->numified; # 1000
package main; use Venus::Number; my $number = Venus::Number->new(2_000); my $numified = $number->numified; # 2000
package main; use Venus::Number; my $number = Venus::Number->new(10_000); my $numified = $number->numified; # 10000
pow() (Num)
The pow method returns a number, the result of a math operation, which is the number to the power of the argument.
package main; use Venus::Number; my $number = Venus::Number->new(12345); my $pow = $number->pow(3); # 1881365963625
range() (ArrayRef)
The range method returns an array reference containing integer increasing values up-to or down-to the limit specified.
package main; use Venus::Number; my $number = Venus::Number->new(5); my $range = $number->range(9); # [5..9]
package main; use Venus::Number; my $number = Venus::Number->new(5); my $range = $number->range(1); # [5, 4, 3, 2, 1]
sin() (Num)
The sin method returns the sine of the number (expressed in radians).
package main; use Venus::Number; my $number = Venus::Number->new(12345); my $sin = $number->sin; # -0.993771636455681
sqrt() (Num)
The sqrt method returns the positive square root of the number.
package main; use Venus::Number; my $number = Venus::Number->new(12345); my $sqrt = $number->sqrt; # 111.108055513541
tv(Any $arg) (Bool)
The tv method performs a "type-and-value-equal-to" operation using argument provided.
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Array->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Code->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Float; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Float->new; my $result = $lvalue->tv($rvalue); # 1
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Number; my $lvalue = Venus::Number->new; my $rvalue = Venus::Number->new; my $result = $lvalue->tv($rvalue); # 1
package main; use Venus::Number; use Venus::Regexp; my $lvalue = Venus::Number->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Number; use Venus::Scalar; my $lvalue = Venus::Number->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::Number->new; my $rvalue = Venus::String->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Number; use Venus::Undef; my $lvalue = Venus::Number->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->tv($rvalue); # 0
To install Venus, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Venus
CPAN shell
perl -MCPAN -e shell install Venus
For more information on module installation, please visit the detailed CPAN module installation guide.