/ 
Venus-0.08
River stage two • 3 direct dependents • 56 total dependents
/ Venus::Float

NAME

Venus::Float - Float Class

ABSTRACT

Float Class for Perl 5

SYNOPSIS

package main;

use Venus::Float;

my $float = Venus::Float->new(1.23);

# $float->int;

DESCRIPTION

This package provides methods for manipulating float data.

INHERITS

This package inherits behaviors from:

Venus::Number

METHODS

This package provides the following methods:

cast

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.

Since 0.08

cast example 1
package main;

use Venus::Float;

my $float = Venus::Float->new;

my $cast = $float->cast('array');

# bless({ value => ["0.0"] }, "Venus::Array")
cast example 2
package main;

use Venus::Float;

my $float = Venus::Float->new;

my $cast = $float->cast('boolean');

# bless({ value => 1 }, "Venus::Boolean")
cast example 3
package main;

use Venus::Float;

my $float = Venus::Float->new;

my $cast = $float->cast('code');

# bless({ value => sub { ... } }, "Venus::Code")
cast example 4
package main;

use Venus::Float;

my $float = Venus::Float->new;

my $cast = $float->cast('float');

# bless({ value => "0.0" }, "Venus::Float")
cast example 5
package main;

use Venus::Float;

my $float = Venus::Float->new;

my $cast = $float->cast('hash');

# bless({ value => { "0.0" => "0.0" } }, "Venus::Hash")
cast example 6
package main;

use Venus::Float;

my $float = Venus::Float->new;

my $cast = $float->cast('number');

# bless({ value => 0 }, "Venus::Number")
cast example 7
package main;

use Venus::Float;

my $float = Venus::Float->new;

my $cast = $float->cast('regexp');

# bless({ value => qr/(?^u:0\.0)/ }, "Venus::Regexp")
cast example 8
package main;

use Venus::Float;

my $float = Venus::Float->new;

my $cast = $float->cast('scalar');

# bless({ value => \"0.0" }, "Venus::Scalar")
cast example 9
package main;

use Venus::Float;

my $float = Venus::Float->new;

my $cast = $float->cast('string');

# bless({ value => "0.0" }, "Venus::String")
cast example 10
package main;

use Venus::Float;

my $float = Venus::Float->new;

my $cast = $float->cast('undef');

# bless({ value => undef }, "Venus::Undef")

default

default() (Str)

The default method returns the default value, i.e. 0.0.

Since 0.01

default example 1
# given: synopsis;

my $default = $float->default;

# "0.0"

eq

eq(Any $arg) (Bool)

The eq method performs an "equals" operation using the argument provided.

Since 0.08

eq example 1
package main;

use Venus::Array;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Array->new;

my $result = $lvalue->eq($rvalue);

# 0
eq example 2
package main;

use Venus::Code;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Code->new;

my $result = $lvalue->eq($rvalue);

# 0
eq example 3
package main;

use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Float->new;

my $result = $lvalue->eq($rvalue);

# 1
eq example 4
package main;

use Venus::Float;
use Venus::Hash;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Hash->new;

my $result = $lvalue->eq($rvalue);

# 0
eq example 5
package main;

use Venus::Float;
use Venus::Number;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Number->new;

my $result = $lvalue->eq($rvalue);

# 1
eq example 6
package main;

use Venus::Float;
use Venus::Regexp;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Regexp->new;

my $result = $lvalue->eq($rvalue);

# 0
eq example 7
package main;

use Venus::Float;
use Venus::Scalar;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Scalar->new;

my $result = $lvalue->eq($rvalue);

# 0
eq example 8
package main;

use Venus::Float;
use Venus::String;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::String->new;

my $result = $lvalue->eq($rvalue);

# 1
eq example 9
package main;

use Venus::Float;
use Venus::Undef;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Undef->new;

my $result = $lvalue->eq($rvalue);

# 1

ge

ge(Any $arg) (Bool)

The ge method performs a "greater-than-or-equal-to" operation using the argument provided.

Since 0.08

ge example 1
package main;

use Venus::Array;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Array->new;

my $result = $lvalue->ge($rvalue);

# 0
ge example 2
package main;

use Venus::Code;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Code->new;

my $result = $lvalue->ge($rvalue);

# 0
ge example 3
package main;

use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Float->new;

my $result = $lvalue->ge($rvalue);

# 1
ge example 4
package main;

use Venus::Float;
use Venus::Hash;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Hash->new;

my $result = $lvalue->ge($rvalue);

# 0
ge example 5
package main;

use Venus::Float;
use Venus::Number;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Number->new;

my $result = $lvalue->ge($rvalue);

# 1
ge example 6
package main;

use Venus::Float;
use Venus::Regexp;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Regexp->new;

my $result = $lvalue->ge($rvalue);

# 0
ge example 7
package main;

use Venus::Float;
use Venus::Scalar;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Scalar->new;

my $result = $lvalue->ge($rvalue);

# 0
ge example 8
package main;

use Venus::Float;
use Venus::String;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::String->new;

my $result = $lvalue->ge($rvalue);

# 1
ge example 9
package main;

use Venus::Float;
use Venus::Undef;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Undef->new;

my $result = $lvalue->ge($rvalue);

# 1

gele

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.

Since 0.08

gele example 1
package main;

use Venus::Array;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Array->new;

my $result = $lvalue->gele($rvalue);

# 0
gele example 2
package main;

use Venus::Code;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Code->new;

my $result = $lvalue->gele($rvalue);

# 0
gele example 3
package main;

use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Float->new;

my $result = $lvalue->gele($rvalue);

# 1
gele example 4
package main;

use Venus::Float;
use Venus::Hash;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Hash->new;

my $result = $lvalue->gele($rvalue);

# 0
gele example 5
package main;

use Venus::Float;
use Venus::Number;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Number->new;

my $result = $lvalue->gele($rvalue);

# 1
gele example 6
package main;

use Venus::Float;
use Venus::Regexp;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Regexp->new;

my $result = $lvalue->gele($rvalue);

# 0
gele example 7
package main;

use Venus::Float;
use Venus::Scalar;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Scalar->new;

my $result = $lvalue->gele($rvalue);

# 0
gele example 8
package main;

use Venus::Float;
use Venus::String;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::String->new;

my $result = $lvalue->gele($rvalue);

# 1
gele example 9
package main;

use Venus::Float;
use Venus::Undef;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Undef->new;

my $result = $lvalue->gele($rvalue);

# 1

gt

gt(Any $arg) (Bool)

The gt method performs a "greater-than" operation using the argument provided.

Since 0.08

gt example 1
package main;

use Venus::Array;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Array->new;

my $result = $lvalue->gt($rvalue);

# 0
gt example 2
package main;

use Venus::Code;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Code->new;

my $result = $lvalue->gt($rvalue);

# 0
gt example 3
package main;

use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Float->new;

my $result = $lvalue->gt($rvalue);

# 0
gt example 4
package main;

use Venus::Float;
use Venus::Hash;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Hash->new;

my $result = $lvalue->gt($rvalue);

# 0
gt example 5
package main;

use Venus::Float;
use Venus::Number;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Number->new;

my $result = $lvalue->gt($rvalue);

# 0
gt example 6
package main;

use Venus::Float;
use Venus::Regexp;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Regexp->new;

my $result = $lvalue->gt($rvalue);

# 0
gt example 7
package main;

use Venus::Float;
use Venus::Scalar;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Scalar->new;

my $result = $lvalue->gt($rvalue);

# 0
gt example 8
package main;

use Venus::Float;
use Venus::String;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::String->new;

my $result = $lvalue->gt($rvalue);

# 0
gt example 9
package main;

use Venus::Float;
use Venus::Undef;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Undef->new;

my $result = $lvalue->gt($rvalue);

# 0

gtlt

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.

Since 0.08

gtlt example 1
package main;

use Venus::Array;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Array->new;

my $result = $lvalue->gtlt($rvalue);

# 0
gtlt example 2
package main;

use Venus::Code;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Code->new;

my $result = $lvalue->gtlt($rvalue);

# 0
gtlt example 3
package main;

use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Float->new;

my $result = $lvalue->gtlt($rvalue);

# 0
gtlt example 4
package main;

use Venus::Float;
use Venus::Hash;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Hash->new;

my $result = $lvalue->gtlt($rvalue);

# 0
gtlt example 5
package main;

use Venus::Float;
use Venus::Number;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Number->new;

my $result = $lvalue->gtlt($rvalue);

# 0
gtlt example 6
package main;

use Venus::Float;
use Venus::Regexp;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Regexp->new;

my $result = $lvalue->gtlt($rvalue);

# 0
gtlt example 7
package main;

use Venus::Float;
use Venus::Scalar;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Scalar->new;

my $result = $lvalue->gtlt($rvalue);

# 0
gtlt example 8
package main;

use Venus::Float;
use Venus::String;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::String->new;

my $result = $lvalue->gtlt($rvalue);

# 0
gtlt example 9
package main;

use Venus::Float;
use Venus::Undef;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Undef->new;

my $result = $lvalue->gtlt($rvalue);

# 0

le

le(Any $arg) (Bool)

The le method performs a "lesser-than-or-equal-to" operation using the argument provided.

Since 0.08

le example 1
package main;

use Venus::Array;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Array->new;

my $result = $lvalue->le($rvalue);

# 1
le example 2
package main;

use Venus::Code;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Code->new;

my $result = $lvalue->le($rvalue);

# 1
le example 3
package main;

use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Float->new;

my $result = $lvalue->le($rvalue);

# 1
le example 4
package main;

use Venus::Float;
use Venus::Hash;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Hash->new;

my $result = $lvalue->le($rvalue);

# 1
le example 5
package main;

use Venus::Float;
use Venus::Number;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Number->new;

my $result = $lvalue->le($rvalue);

# 1
le example 6
package main;

use Venus::Float;
use Venus::Regexp;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Regexp->new;

my $result = $lvalue->le($rvalue);

# 1
le example 7
package main;

use Venus::Float;
use Venus::Scalar;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Scalar->new;

my $result = $lvalue->le($rvalue);

# 1
le example 8
package main;

use Venus::Float;
use Venus::String;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::String->new;

my $result = $lvalue->le($rvalue);

# 1
le example 9
package main;

use Venus::Float;
use Venus::Undef;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Undef->new;

my $result = $lvalue->le($rvalue);

# 1

lt

lt(Any $arg) (Bool)

The lt method performs a "lesser-than" operation using the argument provided.

Since 0.08

lt example 1
package main;

use Venus::Array;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Array->new;

my $result = $lvalue->lt($rvalue);

# 1
lt example 2
package main;

use Venus::Code;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Code->new;

my $result = $lvalue->lt($rvalue);

# 1
lt example 3
package main;

use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Float->new;

my $result = $lvalue->lt($rvalue);

# 0
lt example 4
package main;

use Venus::Float;
use Venus::Hash;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Hash->new;

my $result = $lvalue->lt($rvalue);

# 1
lt example 5
package main;

use Venus::Float;
use Venus::Number;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Number->new;

my $result = $lvalue->lt($rvalue);

# 0
lt example 6
package main;

use Venus::Float;
use Venus::Regexp;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Regexp->new;

my $result = $lvalue->lt($rvalue);

# 1
lt example 7
package main;

use Venus::Float;
use Venus::Scalar;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Scalar->new;

my $result = $lvalue->lt($rvalue);

# 1
lt example 8
package main;

use Venus::Float;
use Venus::String;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::String->new;

my $result = $lvalue->lt($rvalue);

# 0
lt example 9
package main;

use Venus::Float;
use Venus::Undef;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Undef->new;

my $result = $lvalue->lt($rvalue);

# 0

ne

ne(Any $arg) (Bool)

The ne method performs a "not-equal-to" operation using the argument provided.

Since 0.08

ne example 1
package main;

use Venus::Array;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Array->new;

my $result = $lvalue->ne($rvalue);

# 1
ne example 2
package main;

use Venus::Code;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Code->new;

my $result = $lvalue->ne($rvalue);

# 1
ne example 3
package main;

use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Float->new;

my $result = $lvalue->ne($rvalue);

# 0
ne example 4
package main;

use Venus::Float;
use Venus::Hash;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Hash->new;

my $result = $lvalue->ne($rvalue);

# 1
ne example 5
package main;

use Venus::Float;
use Venus::Number;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Number->new;

my $result = $lvalue->ne($rvalue);

# 0
ne example 6
package main;

use Venus::Float;
use Venus::Regexp;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Regexp->new;

my $result = $lvalue->ne($rvalue);

# 1
ne example 7
package main;

use Venus::Float;
use Venus::Scalar;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Scalar->new;

my $result = $lvalue->ne($rvalue);

# 1
ne example 8
package main;

use Venus::Float;
use Venus::String;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::String->new;

my $result = $lvalue->ne($rvalue);

# 0
ne example 9
package main;

use Venus::Float;
use Venus::Undef;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Undef->new;

my $result = $lvalue->ne($rvalue);

# 0

tv

tv(Any $arg) (Bool)

The tv method performs a "type-and-value-equal-to" operation using argument provided.

Since 0.08

tv example 1
package main;

use Venus::Array;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Array->new;

my $result = $lvalue->tv($rvalue);

# 0
tv example 2
package main;

use Venus::Code;
use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Code->new;

my $result = $lvalue->tv($rvalue);

# 0
tv example 3
package main;

use Venus::Float;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Float->new;

my $result = $lvalue->tv($rvalue);

# 1
tv example 4
package main;

use Venus::Float;
use Venus::Hash;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Hash->new;

my $result = $lvalue->tv($rvalue);

# 0
tv example 5
package main;

use Venus::Float;
use Venus::Number;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Number->new;

my $result = $lvalue->tv($rvalue);

# 0
tv example 6
package main;

use Venus::Float;
use Venus::Regexp;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Regexp->new;

my $result = $lvalue->tv($rvalue);

# 0
tv example 7
package main;

use Venus::Float;
use Venus::Scalar;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Scalar->new;

my $result = $lvalue->tv($rvalue);

# 0
tv example 8
package main;

use Venus::Float;
use Venus::String;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::String->new;

my $result = $lvalue->tv($rvalue);

# 0
tv example 9
package main;

use Venus::Float;
use Venus::Undef;

my $lvalue = Venus::Float->new;
my $rvalue = Venus::Undef->new;

my $result = $lvalue->tv($rvalue);

# 0

AUTHORS

Cpanery, cpanery@cpan.org

LICENSE

Copyright (C) 2021, Cpanery

Read the "license" file.