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
add(Num $value) (Num)
The add method returns the result of addition performed on the argument provided.
Since 1.23
1.23
# given: synopsis; my $add = $number->add(1_000); # 2000
append(Str @parts) (Str)
The append method appends arugments to the number.
# given: synopsis; my $append = $number->append(0); # 10_000
append_with(Str $delimiter, Str @parts) (Str)
The append_with method appends arugments to the number using the delimiter provided.
# given: synopsis; my $append = $number->append_with('.', 0); # "1000.0"
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")
concat(Str @parts) (Str)
The concat method returns the number with the argument list appended to it.
package main; use Venus::Number; my $number = Venus::Number->new(1_000); my $concat = $number->concat('.', '0001'); # "1000.0001"
contains(Str $expr) (Bool)
The contains method searches the number for a substring or expression returns true or false if found.
package main; use Venus::Number; my $number = Venus::Number->new(1_0001); my $contains = $number->contains(10); # 1
package main; use Venus::Number; my $number = Venus::Number->new(1_0001); my $contains = $number->contains(2); # 0
package main; use Venus::Number; my $number = Venus::Number->new(1_0001); my $contains = $number->contains(qr/01$/); # 1
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() (Num)
The default method returns the default value, i.e. 0.
0
# given: synopsis; my $default = $number->default; # 0
div(Num $value) (Num)
The div method returns the result of division performed on the argument provided.
# given: synopsis; my $div = $number->div(2); # 500
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
index(Str $substr, Int $start) (Num)
The index method searches for the argument within the number and returns the position of the first occurrence of the argument.
package main; use Venus::Number; my $number = Venus::Number->new(1_0001); my $index = $number->index(0); # 1
package main; use Venus::Number; my $number = Venus::Number->new(1_0001); my $index = $number->index(1, 1); # 4
package main; use Venus::Number; my $number = Venus::Number->new(1_0001); my $index = $number->index(2); # -1
int() (Num)
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
length() (Num)
The length method returns the number of characters within the number.
# given: synopsis; my $length = $number->length; # 4
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
lshift(Num $value) (Num)
The lshift method returns the result of a left shift performed on the argument provided.
# given: synopsis; my $lshift = $number->lshift(2); # 4000
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() (Num)
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
multi(Num $value) (Num)
The multi method returns the result multiplication performed on the argument provided.
# given: synopsis; my $multi = $number->multi(2); # 2000
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() (Num)
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
prepend(Str @parts) (Str)
The prepend method prepends arugments to the number.
# given: synopsis; my $prepend = $number->prepend(1); # 11_000
prepend_with(Str $delimiter, Str @parts) (Str)
The prepend_with method prepends arugments to the number using the delimiter provided.
# given: synopsis; my $prepend = $number->prepend_with('.', '11'); # "11.1000"
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]
repeat(Num $number, Str $delimiter) (Str)
The repeat method repeats the number value N times based on the argument provided and returns a new concatenated number. Optionally, a delimiter can be provided and be place between the occurences.
package main; use Venus::Number; my $number = Venus::Number->new('999'); my $repeat = $number->repeat(2); # 999999
package main; use Venus::Number; my $number = Venus::Number->new('999'); my $repeat = $number->repeat(2, '.'); # 999.999
rshift(num $value) (Num)
The rshift method returns the result a right shift performed on the argument provided.
# given: synopsis; my $rshift = $number->rshift(2); # 250
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
sub(Num $value) (Num)
The sub method returns the result subtraction performed on the argument provided.
# given: synopsis; my $sub = $number->sub(500); # 500
substr(Num $offset, Num $length, Str $replace) (Str)
The substr method calls the core "substr" function with the object's number value. In list context returns the result and the subject.
package main; use Venus::Number; my $number = Venus::Number->new(1234567890); my $substr = $number->substr(0, 5); # 12345
package main; use Venus::Number; my $number = Venus::Number->new(1234567890); my $substr = $number->substr(6, 5); # 7890
package main; use Venus::Number; my $number = Venus::Number->new(1234567890); my $substr = $number->substr(6, 5, '0000'); # "1234560000"
package main; use Venus::Number; my $number = Venus::Number->new(1234567890); my ($result, $subject) = $number->substr(6, 5, '0000'); # ("789", "1234560000")
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.