blib/lib/Venus/Number.pm

filter: Statementstmt 89.2% 125 / 140 Branchbran 80.0% 16 / 20 Conditioncond 75.0% 15 / 20 MC/DCmcdc 50.0% 5 / 10 Subroutinesub 75.4% 43 / 57 Podpod 97.0% 33 / 34 totaltotal 84.3% 237 / 281 CC 21 SCAR 9.3
CC
21
Cov
87%
substr
8.9
contains
5.1
repeat
3.0
CRAP 2.5
« blib/lib/Venus/Result.pm ↑ Summary blib/lib/Venus/Kind.pm »
1 package Venus::Number;
2  
3 20 ▶use 5.018;
Subroutine BEGIN: called CC=1 SCAR=0.0
4  
5 20 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 20 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
7  
8 # IMPORTS
9  
10 20 ▶use Venus::Class 'base';
Subroutine BEGIN: called CC=1 SCAR=0.0
11  
12 # INHERITS
13  
14 20 base 'Venus::Kind::Value';
15  
16 # OVERLOADS
17  
18 20 ▶use overload (
Subroutine BEGIN: called CC=1 SCAR=2.8
19 15 ▶ '!' => sub{!$_[0]->get},
Subroutine __ANON__: called CC=1 SCAR=0.0
20 0 ▶ '!=' => sub{$_[0]->get != ($_[1] + 0)},
Subroutine __ANON__: not called CC=1 SCAR=6.9
21 0 ▶ '%' => sub{$_[0]->get % ($_[1] + 0)},
Subroutine __ANON__: not called CC=1 SCAR=6.9
22 0 ▶ '*' => sub{$_[0]->get * ($_[1] + 0)},
Subroutine __ANON__: not called CC=1 SCAR=6.9
23 0 ▶ '+' => sub{$_[0]->get + ($_[1] + 0)},
Subroutine __ANON__: not called CC=1 SCAR=6.9
24 0 ▶ '-' => sub{$_[0]->get - ($_[1] + 0)},
Subroutine __ANON__: not called CC=1 SCAR=6.9
25 0 ▶ '/' => sub{$_[0]->get / ($_[1] + 0)},
Subroutine __ANON__: not called CC=1 SCAR=6.9
26 0 ▶ '0+' => sub{$_[0]->get + 0},
Subroutine __ANON__: not called CC=1 SCAR=6.9
27 0 ▶ '<' => sub{$_[0]->get < ($_[1] + 0)},
Subroutine __ANON__: not called CC=1 SCAR=6.9
28 0 ▶ '<=' => sub{$_[0]->get <= ($_[1] + 0)},
Subroutine __ANON__: not called CC=1 SCAR=6.9
29 1 ▶ '==' => sub{$_[0]->get == ($_[1] + 0)},
Subroutine __ANON__: called CC=1 SCAR=0.0
30 0 ▶ '>' => sub{$_[0]->get > ($_[1] + 0)},
Subroutine __ANON__: not called CC=1 SCAR=6.9
31 0 ▶ '>=' => sub{$_[0]->get >= ($_[1] + 0)},
Subroutine __ANON__: not called CC=1 SCAR=6.9
32 36 ▶ 'bool' => sub{$_[0]->get + 0},
Subroutine __ANON__: called CC=1 SCAR=0.0
33 2 ▶ 'eq' => sub{"$_[0]" eq "$_[1]"},
Subroutine __ANON__: called CC=1 SCAR=0.0
34 0 ▶ 'ne' => sub{"$_[0]" ne "$_[1]"},
Subroutine __ANON__: not called CC=1 SCAR=6.9
35 0 ▶ 'qr' => sub{qr/@{[quotemeta($_[0]->get)]}/},
Subroutine __ANON__: not called CC=1 SCAR=6.9
36 0 ▶ 'x' => sub{$_[0]->get x ($_[1] + 0)},
Subroutine __ANON__: not called CC=1 SCAR=6.9
37 20 fallback => 1,
38 20 );
39  
40 # METHODS
41  
42 3 ▶sub abs {
Subroutine abs: called CC=1 SCAR=0.0
Pod documented
43 3 my ($self) = @_;
44  
45 3 my $data = $self->get;
46  
47 3 return CORE::abs($data);
48 }
49  
50 1 ▶sub add {
Subroutine add: called CC=1 SCAR=0.0
Pod documented
51 1 my ($self, $arg) = @_;
52  
53 1 my $data = $self->get;
54  
55 1 return $data + ($arg + 0);
56 }
57  
58 1 ▶sub append {
Subroutine append: called CC=1 SCAR=0.0
Pod documented
59 1 my ($self, @args) = @_;
60  
61 1 return $self->append_with(undef, @args);
62 }
63  
64 2 ▶sub append_with {
Subroutine append_with: called CC=2 SCAR=6.9
Pod documented
65 2 my ($self, $delimiter, @args) = @_;
66  
67 2 my $data = $self->get;
68  
69 2 ▶ return CORE::join($delimiter // '', $data, @args);
Condition100%2/2
$delimiter // ""
l!l
11
MC/DC100%1/1
$delimiter // ""
$delimiter
Truth table100%2/2
A
A= $delimiter
Aresult
11
00
70 }
71  
72 1 ▶sub atan2 {
Subroutine atan2: called CC=1 SCAR=0.0
Pod documented
73 1 my ($self, $arg) = @_;
74  
75 1 my $data = $self->get;
76  
77 1 return CORE::atan2($data, $arg + 0);
78 }
79  
80 233 ▶sub comparer {
Subroutine comparer: called CC=1 SCAR=0.0
Pod undocumented
81 233 my ($self) = @_;
82  
83 233 return 'numified';
84 }
85  
86 1 ▶sub concat {
Subroutine concat: called CC=1 SCAR=0.0
Pod documented
87 1 my ($self, @args) = @_;
88  
89 1 my $data = $self->get;
90  
91 1 return CORE::join('', $data, @args);
92 }
93  
94 3 ▶sub contains {
Subroutine contains: called CC=5 SCAR=16.2
Pod documented
95 3 my ($self, $pattern) = @_;
96  
97 3 my $data = $self->get;
98  
99 3 ▶ return 0 unless CORE::defined($pattern);
Branch: 1 branch
BranchTrueFalseTotal
unless defined $pattern 0 3 3
100  
101 3 my $regexp = UNIVERSAL::isa($pattern, 'Regexp');
102  
103 3 ▶ return CORE::index($data, $pattern) < 0 ? 0 : 1 if !$regexp;
Branch: 2 branches
BranchTrueFalseTotal
unless $regexp 2 1 3
CORE::index($data, $pattern) == -1 ? : 1 1 2
104  
105 1 ▶ return ($data =~ $pattern) ? true : false;
Branch: 1 branch
BranchTrueFalseTotal
$data =~ /$pattern/u ? : 1 0 1
106 }
107  
108 1 ▶sub cos {
Subroutine cos: called CC=1 SCAR=0.0
Pod documented
109 1 my ($self) = @_;
110  
111 1 my $data = $self->get;
112  
113 1 return CORE::cos($data);
114 }
115  
116 2 ▶sub decr {
Subroutine decr: called CC=2 SCAR=6.9
Pod documented
117 2 my ($self, $arg) = @_;
118  
119 2 my $data = $self->get;
120  
121 2 ▶ return $data - (($arg || 1) + 0);
Condition100%2/2
$arg || 1
l!l
11
MC/DC100%1/1
$arg || 1
$arg
Truth table100%2/2
A
A= $arg
Aresult
11
00
122 }
123  
124 184 ▶sub default {
Subroutine default: called CC=1 SCAR=0.0
Pod documented
125  
126 184 return 0;
127 }
128  
129 1 ▶sub div {
Subroutine div: called CC=1 SCAR=0.0
Pod documented
130 1 my ($self, $arg) = @_;
131  
132 1 my $data = $self->get;
133  
134 1 return $data / ($arg + 0);
135 }
136  
137 3 ▶sub exp {
Subroutine exp: called CC=1 SCAR=0.0
Pod documented
138 3 my ($self) = @_;
139  
140 3 my $data = $self->get;
141  
142 3 return CORE::exp($data);
143 }
144  
145 1 ▶sub hex {
Subroutine hex: called CC=1 SCAR=0.0
Pod documented
146 1 my ($self) = @_;
147  
148 1 my $data = $self->get;
149  
150 1 return CORE::sprintf('%#x', $data);
151 }
152  
153 28 ▶sub incr {
Subroutine incr: called CC=2 SCAR=6.9
Pod documented
154 28 my ($self, $arg) = @_;
155  
156 28 my $data = $self->get;
157  
158 28 ▶ return $data + (($arg || 1) + 0);
Condition100%2/2
$arg || 1
l!l
127
MC/DC100%1/1
$arg || 1
$arg
Truth table100%2/2
A
A= $arg
Aresult
11
00
159 }
160  
161 3 ▶sub index {
Subroutine index: called CC=2 SCAR=6.9
Pod documented
162 3 my ($self, $substr, $start) = @_;
163  
164 3 my $data = $self->get;
165  
166 3 ▶ return CORE::index($data, $substr) if not(CORE::defined($start));
Branch: 1 branch
BranchTrueFalseTotal
unless defined $start 2 1 3
167 1 return CORE::index($data, $substr, $start);
168 }
169  
170 2 ▶sub int {
Subroutine int: called CC=1 SCAR=0.0
Pod documented
171 2 my ($self) = @_;
172  
173 2 my $data = $self->get;
174  
175 2 return CORE::int($data);
176 }
177  
178 1 ▶sub length {
Subroutine length: called CC=1 SCAR=0.0
Pod documented
179 1 my ($self) = @_;
180  
181 1 my $data = $self->get;
182  
183 1 return CORE::length($data);
184 }
185  
186 1 ▶sub log {
Subroutine log: called CC=1 SCAR=0.0
Pod documented
187 1 my ($self) = @_;
188  
189 1 my $data = $self->get;
190  
191 1 return CORE::log($data);
192 }
193  
194 1 ▶sub lshift {
Subroutine lshift: called CC=1 SCAR=0.0
Pod documented
195 1 my ($self, $arg) = @_;
196  
197 1 my $data = $self->get;
198  
199 1 return $data << ($arg + 0);
200 }
201  
202 3 ▶sub mod {
Subroutine mod: called CC=1 SCAR=0.0
Pod documented
203 3 my ($self, $arg) = @_;
204  
205 3 my $data = $self->get;
206  
207 3 return $data % ($arg + 0);
208 }
209  
210 1 ▶sub multi {
Subroutine multi: called CC=1 SCAR=0.0
Pod documented
211 1 my ($self, $arg) = @_;
212  
213 1 my $data = $self->get;
214  
215 1 return $data * ($arg + 0);
216 }
217  
218 1 ▶sub neg {
Subroutine neg: called CC=2 SCAR=7.1
Pod documented
219 1 my ($self) = @_;
220  
221 1 my $data = $self->get;
222  
223 1 ▶ return $data =~ /^-(.*)/ ? $1 : -$data;
Branch: 1 branch
BranchTrueFalseTotal
$data =~ /^-(.*)/u ? : 0 1 1
224 }
225  
226 406 ▶sub numified {
Subroutine numified: called CC=1 SCAR=0.0
Pod documented
227 406 my ($self) = @_;
228  
229 406 my $data = $self->get;
230  
231 406 return 0 + $data;
232 }
233  
234 1 ▶sub pow {
Subroutine pow: called CC=1 SCAR=0.0
Pod documented
235 1 my ($self, $arg) = @_;
236  
237 1 my $data = $self->get;
238  
239 1 return $data ** ($arg + 0);
240 }
241  
242 2 ▶sub prepend {
Subroutine prepend: called CC=1 SCAR=0.0
Pod documented
243 2 my ($self, @args) = @_;
244  
245 2 return $self->prepend_with(undef, @args);
246 }
247  
248 3 ▶sub prepend_with {
Subroutine prepend_with: called CC=2 SCAR=6.9
Pod documented
249 3 my ($self, $delimiter, @args) = @_;
250  
251 3 my $data = $self->get;
252  
253 3 ▶ return CORE::join($delimiter // '', @args, $data);
Condition100%2/2
$delimiter // ""
l!l
12
MC/DC100%1/1
$delimiter // ""
$delimiter
Truth table100%2/2
A
A= $delimiter
Aresult
11
00
254 }
255  
256 2 ▶sub range {
Subroutine range: called CC=2 SCAR=6.9
Pod documented
257 2 my ($self, $arg) = @_;
258  
259 2 my $data = $self->get;
260  
261 return [
262 2 ▶ ($data > ($arg + 0)) ? CORE::reverse(($arg + 0)..$data) : ($data..($arg + 0))
Branch: 1 branch
BranchTrueFalseTotal
$data > $arg + 0 ? : 1 1 2
263 ];
264 }
265  
266 2 ▶sub repeat {
Subroutine repeat: called CC=3 SCAR=11.1
Pod documented
267 2 my ($self, $count, $delimiter) = @_;
268  
269 2 my $data = $self->get;
270  
271 2 ▶ return CORE::join($delimiter // '', CORE::map $data, 1..($count || 1));
Condition75%3/4
$delimiter // ""
l!l
11
$count || 1
l!l
20
MC/DC100%1/1
$delimiter // ""
$delimiter
MC/DC0%0/1
$count || 1
$count
Truth table100%2/2
A
A= $delimiter
Aresult
11
00
Truth table50%1/2
A
A= $count
Aresult
11
00
272 }
273  
274 1 ▶sub rshift {
Subroutine rshift: called CC=1 SCAR=0.0
Pod documented
275 1 my ($self, $arg) = @_;
276  
277 1 my $data = $self->get;
278  
279 1 return $data >> ($arg + 0);
280 }
281  
282 1 ▶sub sin {
Subroutine sin: called CC=1 SCAR=0.0
Pod documented
283 1 my ($self) = @_;
284  
285 1 my $data = $self->get;
286  
287 1 return CORE::sin($data);
288 }
289  
290 1 ▶sub sqrt {
Subroutine sqrt: called CC=1 SCAR=0.0
Pod documented
291 1 my ($self) = @_;
292  
293 1 my $data = $self->get;
294  
295 1 return CORE::sqrt($data);
296 }
297  
298 1 ▶sub sub {
Subroutine sub: called CC=1 SCAR=0.0
Pod documented
299 1 my ($self, $arg) = @_;
300  
301 1 my $data = $self->get;
302  
303 1 return $data - ($arg + 0);
304 }
305  
306 4 ▶sub substr {
Subroutine substr: called CC=8 SCAR=21.8
Pod documented
307 4 my ($self, $offset, $length, $replace) = @_;
308  
309 4 my $data = $self->get;
310  
311 4 ▶ if (CORE::defined($replace)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $replace) { } 2 2 4
312 2 ▶ my $result = CORE::substr($data, $offset // 0, $length // 0, $replace);
Condition50%2/4
$offset // 0
l!l
20
$length // 0
l!l
20
MC/DC0%0/1
$offset // 0
$offset
MC/DC0%0/1
$length // 0
$length
Truth table50%1/2
A
A= $offset
Aresult
11
00
Truth table50%1/2
A
A= $length
Aresult
11
00
313 2 ▶ return wantarray ? ($result, $data) : $data;
Branch: 1 branch
BranchTrueFalseTotal
wantarray ? : 1 1 2
314 }
315 else {
316 2 ▶ my $result = CORE::substr($data, $offset // 0, $length // 0);
Condition50%2/4
$offset // 0
l!l
20
$length // 0
l!l
20
MC/DC0%0/1
$offset // 0
$offset
MC/DC0%0/1
$length // 0
$length
Truth table50%1/2
A
A= $offset
Aresult
11
00
Truth table50%1/2
A
A= $length
Aresult
11
00
317 2 ▶ return wantarray ? ($result, $data) : $result;
Branch: 1 branch
BranchTrueFalseTotal
wantarray ? : 0 2 2
318 }
319 }
320  
321 20 1;
322  
323  
324  
325 =head1 NAME
326  
327 Venus::Number - Number Class
328  
329 =cut
330  
331 =head1 ABSTRACT
332  
333 Number Class for Perl 5
334  
335 =cut
336  
337 =head1 SYNOPSIS
338  
339 package main;
340  
341 use Venus::Number;
342  
343 my $number = Venus::Number->new(1_000);
344  
345 # $number->abs;
346  
347 =cut
348  
349 =head1 DESCRIPTION
350  
351 This package provides methods for manipulating number data.
352  
353 =cut
354  
355 =head1 INHERITS
356  
357 This package inherits behaviors from:
358  
359 L<Venus::Kind::Value>
360  
361 =cut
362  
363 =head1 METHODS
364  
365 This package provides the following methods:
366  
367 =cut
368  
369 =head2 abs
370  
371 abs() (Num)
372  
373 The abs method returns the absolute value of the number.
374  
375 I<Since C<0.01>>
376  
377 =over 4
378  
379 =item abs example 1
380  
381 # given: synopsis;
382  
383 my $abs = $number->abs;
384  
385 # 1000
386  
387 =back
388  
389 =over 4
390  
391 =item abs example 2
392  
393 package main;
394  
395 use Venus::Number;
396  
397 my $number = Venus::Number->new(12);
398  
399 my $abs = $number->abs;
400  
401 # 12
402  
403 =back
404  
405 =over 4
406  
407 =item abs example 3
408  
409 package main;
410  
411 use Venus::Number;
412  
413 my $number = Venus::Number->new(-12);
414  
415 my $abs = $number->abs;
416  
417 # 12
418  
419 =back
420  
421 =cut
422  
423 =head2 add
424  
425 add(Num $value) (Num)
426  
427 The add method returns the result of addition performed on the argument
428 provided.
429  
430 I<Since C<1.23>>
431  
432 =over 4
433  
434 =item add example 1
435  
436 # given: synopsis;
437  
438 my $add = $number->add(1_000);
439  
440 # 2000
441  
442 =back
443  
444 =cut
445  
446 =head2 append
447  
448 append(string @parts) (string)
449  
450 The append method appends arugments to the number.
451  
452 I<Since C<1.23>>
453  
454 =over 4
455  
456 =item append example 1
457  
458 # given: synopsis;
459  
460 my $append = $number->append(0);
461  
462 # 10_000
463  
464 =back
465  
466 =cut
467  
468 =head2 append_with
469  
470 append_with(string $delimiter, string @parts) (string)
471  
472 The append_with method appends arugments to the number using the delimiter
473 provided.
474  
475 I<Since C<1.23>>
476  
477 =over 4
478  
479 =item append_with example 1
480  
481 # given: synopsis;
482  
483 my $append = $number->append_with('.', 0);
484  
485 # "1000.0"
486  
487 =back
488  
489 =cut
490  
491 =head2 atan2
492  
493 atan2() (Num)
494  
495 The atan2 method returns the arctangent of Y/X in the range -PI to PI.
496  
497 I<Since C<0.01>>
498  
499 =over 4
500  
501 =item atan2 example 1
502  
503 package main;
504  
505 use Venus::Number;
506  
507 my $number = Venus::Number->new(1);
508  
509 my $atan2 = $number->atan2(1);
510  
511 # 0.785398163397448
512  
513 =back
514  
515 =cut
516  
517 =head2 cast
518  
519 cast(string $kind) (object | undef)
520  
521 The cast method converts L<"value"|Venus::Kind::Value> objects between
522 different I<"value"> object types, based on the name of the type provided. This
523 method will return C<undef> if the invocant is not a L<Venus::Kind::Value>.
524  
525 I<Since C<0.08>>
526  
527 =over 4
528  
529 =item cast example 1
530  
531 package main;
532  
533 use Venus::Number;
534  
535 my $number = Venus::Number->new;
536  
537 my $cast = $number->cast('array');
538  
539 # bless({ value => [0] }, "Venus::Array")
540  
541 =back
542  
543 =over 4
544  
545 =item cast example 2
546  
547 package main;
548  
549 use Venus::Number;
550  
551 my $number = Venus::Number->new;
552  
553 my $cast = $number->cast('boolean');
554  
555 # bless({ value => 0 }, "Venus::Boolean")
556  
557 =back
558  
559 =over 4
560  
561 =item cast example 3
562  
563 package main;
564  
565 use Venus::Number;
566  
567 my $number = Venus::Number->new;
568  
569 my $cast = $number->cast('code');
570  
571 # bless({ value => sub { ... } }, "Venus::Code")
572  
573 =back
574  
575 =over 4
576  
577 =item cast example 4
578  
579 package main;
580  
581 use Venus::Number;
582  
583 my $number = Venus::Number->new;
584  
585 my $cast = $number->cast('float');
586  
587 # bless({ value => "0.0" }, "Venus::Float")
588  
589 =back
590  
591 =over 4
592  
593 =item cast example 5
594  
595 package main;
596  
597 use Venus::Number;
598  
599 my $number = Venus::Number->new;
600  
601 my $cast = $number->cast('hash');
602  
603 # bless({ value => { "0" => 0 } }, "Venus::Hash")
604  
605 =back
606  
607 =over 4
608  
609 =item cast example 6
610  
611 package main;
612  
613 use Venus::Number;
614  
615 my $number = Venus::Number->new;
616  
617 my $cast = $number->cast('number');
618  
619 # bless({ value => 0 }, "Venus::Number")
620  
621 =back
622  
623 =over 4
624  
625 =item cast example 7
626  
627 package main;
628  
629 use Venus::Number;
630  
631 my $number = Venus::Number->new;
632  
633 my $cast = $number->cast('regexp');
634  
635 # bless({ value => qr/(?^u:0)/ }, "Venus::Regexp")
636  
637 =back
638  
639 =over 4
640  
641 =item cast example 8
642  
643 package main;
644  
645 use Venus::Number;
646  
647 my $number = Venus::Number->new;
648  
649 my $cast = $number->cast('scalar');
650  
651 # bless({ value => \0 }, "Venus::Scalar")
652  
653 =back
654  
655 =over 4
656  
657 =item cast example 9
658  
659 package main;
660  
661 use Venus::Number;
662  
663 my $number = Venus::Number->new;
664  
665 my $cast = $number->cast('string');
666  
667 # bless({ value => 0 }, "Venus::String")
668  
669 =back
670  
671 =over 4
672  
673 =item cast example 10
674  
675 package main;
676  
677 use Venus::Number;
678  
679 my $number = Venus::Number->new;
680  
681 my $cast = $number->cast('undef');
682  
683 # bless({ value => undef }, "Venus::Undef")
684  
685 =back
686  
687 =cut
688  
689 =head2 concat
690  
691 concat(string @parts) (string)
692  
693 The concat method returns the number with the argument list appended to it.
694  
695 I<Since C<1.23>>
696  
697 =over 4
698  
699 =item concat example 1
700  
701 package main;
702  
703 use Venus::Number;
704  
705 my $number = Venus::Number->new(1_000);
706  
707 my $concat = $number->concat('.', '0001');
708  
709 # "1000.0001"
710  
711 =back
712  
713 =cut
714  
715 =head2 contains
716  
717 contains(string $expr) (boolean)
718  
719 The contains method searches the number for a substring or expression returns
720 true or false if found.
721  
722 I<Since C<1.23>>
723  
724 =over 4
725  
726 =item contains example 1
727  
728 package main;
729  
730 use Venus::Number;
731  
732 my $number = Venus::Number->new(1_0001);
733  
734 my $contains = $number->contains(10);
735  
736 # 1
737  
738 =back
739  
740 =over 4
741  
742 =item contains example 2
743  
744 package main;
745  
746 use Venus::Number;
747  
748 my $number = Venus::Number->new(1_0001);
749  
750 my $contains = $number->contains(2);
751  
752 # 0
753  
754 =back
755  
756 =over 4
757  
758 =item contains example 3
759  
760 package main;
761  
762 use Venus::Number;
763  
764 my $number = Venus::Number->new(1_0001);
765  
766 my $contains = $number->contains(qr/01$/);
767  
768 # 1
769  
770 =back
771  
772 =cut
773  
774 =head2 cos
775  
776 cos() (Num)
777  
778 The cos method computes the cosine of the number (expressed in radians).
779  
780 I<Since C<0.01>>
781  
782 =over 4
783  
784 =item cos example 1
785  
786 package main;
787  
788 use Venus::Number;
789  
790 my $number = Venus::Number->new(12);
791  
792 my $cos = $number->cos;
793  
794 # 0.843853958732492
795  
796 =back
797  
798 =cut
799  
800 =head2 decr
801  
802 decr() (Num)
803  
804 The decr method returns the numeric number decremented by 1.
805  
806 I<Since C<0.01>>
807  
808 =over 4
809  
810 =item decr example 1
811  
812 package main;
813  
814 use Venus::Number;
815  
816 my $number = Venus::Number->new(123456789);
817  
818 my $decr = $number->decr;
819  
820 # 123456788
821  
822 =back
823  
824 =over 4
825  
826 =item decr example 2
827  
828 package main;
829  
830 use Venus::Number;
831  
832 my $number = Venus::Number->new(123456789);
833  
834 my $decr = $number->decr(123456788);
835  
836 # 1
837  
838 =back
839  
840 =cut
841  
842 =head2 default
843  
844 default() (Num)
845  
846 The default method returns the default value, i.e. C<0>.
847  
848 I<Since C<0.01>>
849  
850 =over 4
851  
852 =item default example 1
853  
854 # given: synopsis;
855  
856 my $default = $number->default;
857  
858 # 0
859  
860 =back
861  
862 =cut
863  
864 =head2 div
865  
866 div(Num $value) (Num)
867  
868 The div method returns the result of division performed on the argument
869 provided.
870  
871 I<Since C<1.23>>
872  
873 =over 4
874  
875 =item div example 1
876  
877 # given: synopsis;
878  
879 my $div = $number->div(2);
880  
881 # 500
882  
883 =back
884  
885 =cut
886  
887 =head2 eq
888  
889 eq(any $arg) (boolean)
890  
891 The eq method performs an I<"equals"> operation using the argument provided.
892  
893 I<Since C<0.08>>
894  
895 =over 4
896  
897 =item eq example 1
898  
899 package main;
900  
901 use Venus::Array;
902 use Venus::Number;
903  
904 my $lvalue = Venus::Number->new;
905 my $rvalue = Venus::Array->new;
906  
907 my $result = $lvalue->eq($rvalue);
908  
909 # 0
910  
911 =back
912  
913 =over 4
914  
915 =item eq example 2
916  
917 package main;
918  
919 use Venus::Code;
920 use Venus::Number;
921  
922 my $lvalue = Venus::Number->new;
923 my $rvalue = Venus::Code->new;
924  
925 my $result = $lvalue->eq($rvalue);
926  
927 # 0
928  
929 =back
930  
931 =over 4
932  
933 =item eq example 3
934  
935 package main;
936  
937 use Venus::Float;
938 use Venus::Number;
939  
940 my $lvalue = Venus::Number->new;
941 my $rvalue = Venus::Float->new;
942  
943 my $result = $lvalue->eq($rvalue);
944  
945 # 1
946  
947 =back
948  
949 =over 4
950  
951 =item eq example 4
952  
953 package main;
954  
955 use Venus::Hash;
956 use Venus::Number;
957  
958 my $lvalue = Venus::Number->new;
959 my $rvalue = Venus::Hash->new;
960  
961 my $result = $lvalue->eq($rvalue);
962  
963 # 0
964  
965 =back
966  
967 =over 4
968  
969 =item eq example 5
970  
971 package main;
972  
973 use Venus::Number;
974  
975 my $lvalue = Venus::Number->new;
976 my $rvalue = Venus::Number->new;
977  
978 my $result = $lvalue->eq($rvalue);
979  
980 # 1
981  
982 =back
983  
984 =over 4
985  
986 =item eq example 6
987  
988 package main;
989  
990 use Venus::Number;
991 use Venus::Regexp;
992  
993 my $lvalue = Venus::Number->new;
994 my $rvalue = Venus::Regexp->new;
995  
996 my $result = $lvalue->eq($rvalue);
997  
998 # 0
999  
1000 =back
1001  
1002 =over 4
1003  
1004 =item eq example 7
1005  
1006 package main;
1007  
1008 use Venus::Number;
1009 use Venus::Scalar;
1010  
1011 my $lvalue = Venus::Number->new;
1012 my $rvalue = Venus::Scalar->new;
1013  
1014 my $result = $lvalue->eq($rvalue);
1015  
1016 # 0
1017  
1018 =back
1019  
1020 =over 4
1021  
1022 =item eq example 8
1023  
1024 package main;
1025  
1026 use Venus::Number;
1027 use Venus::String;
1028  
1029 my $lvalue = Venus::Number->new;
1030 my $rvalue = Venus::String->new;
1031  
1032 my $result = $lvalue->eq($rvalue);
1033  
1034 # 1
1035  
1036 =back
1037  
1038 =over 4
1039  
1040 =item eq example 9
1041  
1042 package main;
1043  
1044 use Venus::Number;
1045 use Venus::Undef;
1046  
1047 my $lvalue = Venus::Number->new;
1048 my $rvalue = Venus::Undef->new;
1049  
1050 my $result = $lvalue->eq($rvalue);
1051  
1052 # 1
1053  
1054 =back
1055  
1056 =cut
1057  
1058 =head2 exp
1059  
1060 exp() (Num)
1061  
1062 The exp method returns e (the natural logarithm base) to the power of the
1063 number.
1064  
1065 I<Since C<0.01>>
1066  
1067 =over 4
1068  
1069 =item exp example 1
1070  
1071 package main;
1072  
1073 use Venus::Number;
1074  
1075 my $number = Venus::Number->new(0);
1076  
1077 my $exp = $number->exp;
1078  
1079 # 1
1080  
1081 =back
1082  
1083 =over 4
1084  
1085 =item exp example 2
1086  
1087 package main;
1088  
1089 use Venus::Number;
1090  
1091 my $number = Venus::Number->new(1);
1092  
1093 my $exp = $number->exp;
1094  
1095 # 2.71828182845905
1096  
1097 =back
1098  
1099 =over 4
1100  
1101 =item exp example 3
1102  
1103 package main;
1104  
1105 use Venus::Number;
1106  
1107 my $number = Venus::Number->new(1.5);
1108  
1109 my $exp = $number->exp;
1110  
1111 # 4.48168907033806
1112  
1113 =back
1114  
1115 =cut
1116  
1117 =head2 ge
1118  
1119 ge(any $arg) (boolean)
1120  
1121 The ge method performs a I<"greater-than-or-equal-to"> operation using the
1122 argument provided.
1123  
1124 I<Since C<0.08>>
1125  
1126 =over 4
1127  
1128 =item ge example 1
1129  
1130 package main;
1131  
1132 use Venus::Array;
1133 use Venus::Number;
1134  
1135 my $lvalue = Venus::Number->new;
1136 my $rvalue = Venus::Array->new;
1137  
1138 my $result = $lvalue->ge($rvalue);
1139  
1140 # 0
1141  
1142 =back
1143  
1144 =over 4
1145  
1146 =item ge example 2
1147  
1148 package main;
1149  
1150 use Venus::Code;
1151 use Venus::Number;
1152  
1153 my $lvalue = Venus::Number->new;
1154 my $rvalue = Venus::Code->new;
1155  
1156 my $result = $lvalue->ge($rvalue);
1157  
1158 # 0
1159  
1160 =back
1161  
1162 =over 4
1163  
1164 =item ge example 3
1165  
1166 package main;
1167  
1168 use Venus::Float;
1169 use Venus::Number;
1170  
1171 my $lvalue = Venus::Number->new;
1172 my $rvalue = Venus::Float->new;
1173  
1174 my $result = $lvalue->ge($rvalue);
1175  
1176 # 1
1177  
1178 =back
1179  
1180 =over 4
1181  
1182 =item ge example 4
1183  
1184 package main;
1185  
1186 use Venus::Hash;
1187 use Venus::Number;
1188  
1189 my $lvalue = Venus::Number->new;
1190 my $rvalue = Venus::Hash->new;
1191  
1192 my $result = $lvalue->ge($rvalue);
1193  
1194 # 0
1195  
1196 =back
1197  
1198 =over 4
1199  
1200 =item ge example 5
1201  
1202 package main;
1203  
1204 use Venus::Number;
1205  
1206 my $lvalue = Venus::Number->new;
1207 my $rvalue = Venus::Number->new;
1208  
1209 my $result = $lvalue->ge($rvalue);
1210  
1211 # 1
1212  
1213 =back
1214  
1215 =over 4
1216  
1217 =item ge example 6
1218  
1219 package main;
1220  
1221 use Venus::Number;
1222 use Venus::Regexp;
1223  
1224 my $lvalue = Venus::Number->new;
1225 my $rvalue = Venus::Regexp->new;
1226  
1227 my $result = $lvalue->ge($rvalue);
1228  
1229 # 0
1230  
1231 =back
1232  
1233 =over 4
1234  
1235 =item ge example 7
1236  
1237 package main;
1238  
1239 use Venus::Number;
1240 use Venus::Scalar;
1241  
1242 my $lvalue = Venus::Number->new;
1243 my $rvalue = Venus::Scalar->new;
1244  
1245 my $result = $lvalue->ge($rvalue);
1246  
1247 # 0
1248  
1249 =back
1250  
1251 =over 4
1252  
1253 =item ge example 8
1254  
1255 package main;
1256  
1257 use Venus::Number;
1258 use Venus::String;
1259  
1260 my $lvalue = Venus::Number->new;
1261 my $rvalue = Venus::String->new;
1262  
1263 my $result = $lvalue->ge($rvalue);
1264  
1265 # 1
1266  
1267 =back
1268  
1269 =over 4
1270  
1271 =item ge example 9
1272  
1273 package main;
1274  
1275 use Venus::Number;
1276 use Venus::Undef;
1277  
1278 my $lvalue = Venus::Number->new;
1279 my $rvalue = Venus::Undef->new;
1280  
1281 my $result = $lvalue->ge($rvalue);
1282  
1283 # 1
1284  
1285 =back
1286  
1287 =cut
1288  
1289 =head2 gele
1290  
1291 gele(any $arg1, any $arg2) (boolean)
1292  
1293 The gele method performs a I<"greater-than-or-equal-to"> operation on the 1st
1294 argument, and I<"lesser-than-or-equal-to"> operation on the 2nd argument.
1295  
1296 I<Since C<0.08>>
1297  
1298 =over 4
1299  
1300 =item gele example 1
1301  
1302 package main;
1303  
1304 use Venus::Array;
1305 use Venus::Number;
1306  
1307 my $lvalue = Venus::Number->new;
1308 my $rvalue = Venus::Array->new;
1309  
1310 my $result = $lvalue->gele($rvalue);
1311  
1312 # 0
1313  
1314 =back
1315  
1316 =over 4
1317  
1318 =item gele example 2
1319  
1320 package main;
1321  
1322 use Venus::Code;
1323 use Venus::Number;
1324  
1325 my $lvalue = Venus::Number->new;
1326 my $rvalue = Venus::Code->new;
1327  
1328 my $result = $lvalue->gele($rvalue);
1329  
1330 # 0
1331  
1332 =back
1333  
1334 =over 4
1335  
1336 =item gele example 3
1337  
1338 package main;
1339  
1340 use Venus::Float;
1341 use Venus::Number;
1342  
1343 my $lvalue = Venus::Number->new;
1344 my $rvalue = Venus::Float->new;
1345  
1346 my $result = $lvalue->gele($rvalue);
1347  
1348 # 1
1349  
1350 =back
1351  
1352 =over 4
1353  
1354 =item gele example 4
1355  
1356 package main;
1357  
1358 use Venus::Hash;
1359 use Venus::Number;
1360  
1361 my $lvalue = Venus::Number->new;
1362 my $rvalue = Venus::Hash->new;
1363  
1364 my $result = $lvalue->gele($rvalue);
1365  
1366 # 0
1367  
1368 =back
1369  
1370 =over 4
1371  
1372 =item gele example 5
1373  
1374 package main;
1375  
1376 use Venus::Number;
1377  
1378 my $lvalue = Venus::Number->new;
1379 my $rvalue = Venus::Number->new;
1380  
1381 my $result = $lvalue->gele($rvalue);
1382  
1383 # 1
1384  
1385 =back
1386  
1387 =over 4
1388  
1389 =item gele example 6
1390  
1391 package main;
1392  
1393 use Venus::Number;
1394 use Venus::Regexp;
1395  
1396 my $lvalue = Venus::Number->new;
1397 my $rvalue = Venus::Regexp->new;
1398  
1399 my $result = $lvalue->gele($rvalue);
1400  
1401 # 0
1402  
1403 =back
1404  
1405 =over 4
1406  
1407 =item gele example 7
1408  
1409 package main;
1410  
1411 use Venus::Number;
1412 use Venus::Scalar;
1413  
1414 my $lvalue = Venus::Number->new;
1415 my $rvalue = Venus::Scalar->new;
1416  
1417 my $result = $lvalue->gele($rvalue);
1418  
1419 # 0
1420  
1421 =back
1422  
1423 =over 4
1424  
1425 =item gele example 8
1426  
1427 package main;
1428  
1429 use Venus::Number;
1430 use Venus::String;
1431  
1432 my $lvalue = Venus::Number->new;
1433 my $rvalue = Venus::String->new;
1434  
1435 my $result = $lvalue->gele($rvalue);
1436  
1437 # 1
1438  
1439 =back
1440  
1441 =over 4
1442  
1443 =item gele example 9
1444  
1445 package main;
1446  
1447 use Venus::Number;
1448 use Venus::Undef;
1449  
1450 my $lvalue = Venus::Number->new;
1451 my $rvalue = Venus::Undef->new;
1452  
1453 my $result = $lvalue->gele($rvalue);
1454  
1455 # 1
1456  
1457 =back
1458  
1459 =cut
1460  
1461 =head2 gt
1462  
1463 gt(any $arg) (boolean)
1464  
1465 The gt method performs a I<"greater-than"> operation using the argument provided.
1466  
1467 I<Since C<0.08>>
1468  
1469 =over 4
1470  
1471 =item gt example 1
1472  
1473 package main;
1474  
1475 use Venus::Array;
1476 use Venus::Number;
1477  
1478 my $lvalue = Venus::Number->new;
1479 my $rvalue = Venus::Array->new;
1480  
1481 my $result = $lvalue->gt($rvalue);
1482  
1483 # 0
1484  
1485 =back
1486  
1487 =over 4
1488  
1489 =item gt example 2
1490  
1491 package main;
1492  
1493 use Venus::Code;
1494 use Venus::Number;
1495  
1496 my $lvalue = Venus::Number->new;
1497 my $rvalue = Venus::Code->new;
1498  
1499 my $result = $lvalue->gt($rvalue);
1500  
1501 # 0
1502  
1503 =back
1504  
1505 =over 4
1506  
1507 =item gt example 3
1508  
1509 package main;
1510  
1511 use Venus::Float;
1512 use Venus::Number;
1513  
1514 my $lvalue = Venus::Number->new;
1515 my $rvalue = Venus::Float->new;
1516  
1517 my $result = $lvalue->gt($rvalue);
1518  
1519 # 0
1520  
1521 =back
1522  
1523 =over 4
1524  
1525 =item gt example 4
1526  
1527 package main;
1528  
1529 use Venus::Hash;
1530 use Venus::Number;
1531  
1532 my $lvalue = Venus::Number->new;
1533 my $rvalue = Venus::Hash->new;
1534  
1535 my $result = $lvalue->gt($rvalue);
1536  
1537 # 0
1538  
1539 =back
1540  
1541 =over 4
1542  
1543 =item gt example 5
1544  
1545 package main;
1546  
1547 use Venus::Number;
1548  
1549 my $lvalue = Venus::Number->new;
1550 my $rvalue = Venus::Number->new;
1551  
1552 my $result = $lvalue->gt($rvalue);
1553  
1554 # 0
1555  
1556 =back
1557  
1558 =over 4
1559  
1560 =item gt example 6
1561  
1562 package main;
1563  
1564 use Venus::Number;
1565 use Venus::Regexp;
1566  
1567 my $lvalue = Venus::Number->new;
1568 my $rvalue = Venus::Regexp->new;
1569  
1570 my $result = $lvalue->gt($rvalue);
1571  
1572 # 0
1573  
1574 =back
1575  
1576 =over 4
1577  
1578 =item gt example 7
1579  
1580 package main;
1581  
1582 use Venus::Number;
1583 use Venus::Scalar;
1584  
1585 my $lvalue = Venus::Number->new;
1586 my $rvalue = Venus::Scalar->new;
1587  
1588 my $result = $lvalue->gt($rvalue);
1589  
1590 # 0
1591  
1592 =back
1593  
1594 =over 4
1595  
1596 =item gt example 8
1597  
1598 package main;
1599  
1600 use Venus::Number;
1601 use Venus::String;
1602  
1603 my $lvalue = Venus::Number->new;
1604 my $rvalue = Venus::String->new;
1605  
1606 my $result = $lvalue->gt($rvalue);
1607  
1608 # 0
1609  
1610 =back
1611  
1612 =over 4
1613  
1614 =item gt example 9
1615  
1616 package main;
1617  
1618 use Venus::Number;
1619 use Venus::Undef;
1620  
1621 my $lvalue = Venus::Number->new;
1622 my $rvalue = Venus::Undef->new;
1623  
1624 my $result = $lvalue->gt($rvalue);
1625  
1626 # 0
1627  
1628 =back
1629  
1630 =cut
1631  
1632 =head2 gtlt
1633  
1634 gtlt(any $arg1, any $arg2) (boolean)
1635  
1636 The gtlt method performs a I<"greater-than"> operation on the 1st argument, and
1637 I<"lesser-than"> operation on the 2nd argument.
1638  
1639 I<Since C<0.08>>
1640  
1641 =over 4
1642  
1643 =item gtlt example 1
1644  
1645 package main;
1646  
1647 use Venus::Array;
1648 use Venus::Number;
1649  
1650 my $lvalue = Venus::Number->new;
1651 my $rvalue = Venus::Array->new;
1652  
1653 my $result = $lvalue->gtlt($rvalue);
1654  
1655 # 0
1656  
1657 =back
1658  
1659 =over 4
1660  
1661 =item gtlt example 2
1662  
1663 package main;
1664  
1665 use Venus::Code;
1666 use Venus::Number;
1667  
1668 my $lvalue = Venus::Number->new;
1669 my $rvalue = Venus::Code->new;
1670  
1671 my $result = $lvalue->gtlt($rvalue);
1672  
1673 # 0
1674  
1675 =back
1676  
1677 =over 4
1678  
1679 =item gtlt example 3
1680  
1681 package main;
1682  
1683 use Venus::Float;
1684 use Venus::Number;
1685  
1686 my $lvalue = Venus::Number->new;
1687 my $rvalue = Venus::Float->new;
1688  
1689 my $result = $lvalue->gtlt($rvalue);
1690  
1691 # 0
1692  
1693 =back
1694  
1695 =over 4
1696  
1697 =item gtlt example 4
1698  
1699 package main;
1700  
1701 use Venus::Hash;
1702 use Venus::Number;
1703  
1704 my $lvalue = Venus::Number->new;
1705 my $rvalue = Venus::Hash->new;
1706  
1707 my $result = $lvalue->gtlt($rvalue);
1708  
1709 # 0
1710  
1711 =back
1712  
1713 =over 4
1714  
1715 =item gtlt example 5
1716  
1717 package main;
1718  
1719 use Venus::Number;
1720  
1721 my $lvalue = Venus::Number->new;
1722 my $rvalue = Venus::Number->new;
1723  
1724 my $result = $lvalue->gtlt($rvalue);
1725  
1726 # 0
1727  
1728 =back
1729  
1730 =over 4
1731  
1732 =item gtlt example 6
1733  
1734 package main;
1735  
1736 use Venus::Number;
1737 use Venus::Regexp;
1738  
1739 my $lvalue = Venus::Number->new;
1740 my $rvalue = Venus::Regexp->new;
1741  
1742 my $result = $lvalue->gtlt($rvalue);
1743  
1744 # 0
1745  
1746 =back
1747  
1748 =over 4
1749  
1750 =item gtlt example 7
1751  
1752 package main;
1753  
1754 use Venus::Number;
1755 use Venus::Scalar;
1756  
1757 my $lvalue = Venus::Number->new;
1758 my $rvalue = Venus::Scalar->new;
1759  
1760 my $result = $lvalue->gtlt($rvalue);
1761  
1762 # 0
1763  
1764 =back
1765  
1766 =over 4
1767  
1768 =item gtlt example 8
1769  
1770 package main;
1771  
1772 use Venus::Number;
1773 use Venus::String;
1774  
1775 my $lvalue = Venus::Number->new;
1776 my $rvalue = Venus::String->new;
1777  
1778 my $result = $lvalue->gtlt($rvalue);
1779  
1780 # 0
1781  
1782 =back
1783  
1784 =over 4
1785  
1786 =item gtlt example 9
1787  
1788 package main;
1789  
1790 use Venus::Number;
1791 use Venus::Undef;
1792  
1793 my $lvalue = Venus::Number->new;
1794 my $rvalue = Venus::Undef->new;
1795  
1796 my $result = $lvalue->gtlt($rvalue);
1797  
1798 # 0
1799  
1800 =back
1801  
1802 =cut
1803  
1804 =head2 hex
1805  
1806 hex() (string)
1807  
1808 The hex method returns a hex string representing the value of the number.
1809  
1810 I<Since C<0.01>>
1811  
1812 =over 4
1813  
1814 =item hex example 1
1815  
1816 package main;
1817  
1818 use Venus::Number;
1819  
1820 my $number = Venus::Number->new(175);
1821  
1822 my $hex = $number->hex;
1823  
1824 # "0xaf"
1825  
1826 =back
1827  
1828 =cut
1829  
1830 =head2 incr
1831  
1832 incr() (Num)
1833  
1834 The incr method returns the numeric number incremented by 1.
1835  
1836 I<Since C<0.01>>
1837  
1838 =over 4
1839  
1840 =item incr example 1
1841  
1842 package main;
1843  
1844 use Venus::Number;
1845  
1846 my $number = Venus::Number->new(123456789);
1847  
1848 my $incr = $number->incr;
1849  
1850 # 123456790
1851  
1852 =back
1853  
1854 =over 4
1855  
1856 =item incr example 2
1857  
1858 package main;
1859  
1860 use Venus::Number;
1861  
1862 my $number = Venus::Number->new(123456790);
1863  
1864 my $incr = $number->incr(-1);
1865  
1866 # 123456789
1867  
1868 =back
1869  
1870 =cut
1871  
1872 =head2 index
1873  
1874 index(string $substr, number $start) (Num)
1875  
1876 The index method searches for the argument within the number and returns the
1877 position of the first occurrence of the argument.
1878  
1879 I<Since C<1.23>>
1880  
1881 =over 4
1882  
1883 =item index example 1
1884  
1885 package main;
1886  
1887 use Venus::Number;
1888  
1889 my $number = Venus::Number->new(1_0001);
1890  
1891 my $index = $number->index(0);
1892  
1893 # 1
1894  
1895 =back
1896  
1897 =over 4
1898  
1899 =item index example 2
1900  
1901 package main;
1902  
1903 use Venus::Number;
1904  
1905 my $number = Venus::Number->new(1_0001);
1906  
1907 my $index = $number->index(1, 1);
1908  
1909 # 4
1910  
1911 =back
1912  
1913 =over 4
1914  
1915 =item index example 3
1916  
1917 package main;
1918  
1919 use Venus::Number;
1920  
1921 my $number = Venus::Number->new(1_0001);
1922  
1923 my $index = $number->index(2);
1924  
1925 # -1
1926  
1927 =back
1928  
1929 =cut
1930  
1931 =head2 int
1932  
1933 int() (Num)
1934  
1935 The int method returns the integer portion of the number. Do not use this
1936 method for rounding.
1937  
1938 I<Since C<0.01>>
1939  
1940 =over 4
1941  
1942 =item int example 1
1943  
1944 package main;
1945  
1946 use Venus::Number;
1947  
1948 my $number = Venus::Number->new(12.5);
1949  
1950 my $int = $number->int;
1951  
1952 # 12
1953  
1954 =back
1955  
1956 =cut
1957  
1958 =head2 le
1959  
1960 le(any $arg) (boolean)
1961  
1962 The le method performs a I<"lesser-than-or-equal-to"> operation using the
1963 argument provided.
1964  
1965 I<Since C<0.08>>
1966  
1967 =over 4
1968  
1969 =item le example 1
1970  
1971 package main;
1972  
1973 use Venus::Array;
1974 use Venus::Number;
1975  
1976 my $lvalue = Venus::Number->new;
1977 my $rvalue = Venus::Array->new;
1978  
1979 my $result = $lvalue->le($rvalue);
1980  
1981 # 1
1982  
1983 =back
1984  
1985 =over 4
1986  
1987 =item le example 2
1988  
1989 package main;
1990  
1991 use Venus::Code;
1992 use Venus::Number;
1993  
1994 my $lvalue = Venus::Number->new;
1995 my $rvalue = Venus::Code->new;
1996  
1997 my $result = $lvalue->le($rvalue);
1998  
1999 # 1
2000  
2001 =back
2002  
2003 =over 4
2004  
2005 =item le example 3
2006  
2007 package main;
2008  
2009 use Venus::Float;
2010 use Venus::Number;
2011  
2012 my $lvalue = Venus::Number->new;
2013 my $rvalue = Venus::Float->new;
2014  
2015 my $result = $lvalue->le($rvalue);
2016  
2017 # 1
2018  
2019 =back
2020  
2021 =over 4
2022  
2023 =item le example 4
2024  
2025 package main;
2026  
2027 use Venus::Hash;
2028 use Venus::Number;
2029  
2030 my $lvalue = Venus::Number->new;
2031 my $rvalue = Venus::Hash->new;
2032  
2033 my $result = $lvalue->le($rvalue);
2034  
2035 # 1
2036  
2037 =back
2038  
2039 =over 4
2040  
2041 =item le example 5
2042  
2043 package main;
2044  
2045 use Venus::Number;
2046  
2047 my $lvalue = Venus::Number->new;
2048 my $rvalue = Venus::Number->new;
2049  
2050 my $result = $lvalue->le($rvalue);
2051  
2052 # 1
2053  
2054 =back
2055  
2056 =over 4
2057  
2058 =item le example 6
2059  
2060 package main;
2061  
2062 use Venus::Number;
2063 use Venus::Regexp;
2064  
2065 my $lvalue = Venus::Number->new;
2066 my $rvalue = Venus::Regexp->new;
2067  
2068 my $result = $lvalue->le($rvalue);
2069  
2070 # 1
2071  
2072 =back
2073  
2074 =over 4
2075  
2076 =item le example 7
2077  
2078 package main;
2079  
2080 use Venus::Number;
2081 use Venus::Scalar;
2082  
2083 my $lvalue = Venus::Number->new;
2084 my $rvalue = Venus::Scalar->new;
2085  
2086 my $result = $lvalue->le($rvalue);
2087  
2088 # 1
2089  
2090 =back
2091  
2092 =over 4
2093  
2094 =item le example 8
2095  
2096 package main;
2097  
2098 use Venus::Number;
2099 use Venus::String;
2100  
2101 my $lvalue = Venus::Number->new;
2102 my $rvalue = Venus::String->new;
2103  
2104 my $result = $lvalue->le($rvalue);
2105  
2106 # 1
2107  
2108 =back
2109  
2110 =over 4
2111  
2112 =item le example 9
2113  
2114 package main;
2115  
2116 use Venus::Number;
2117 use Venus::Undef;
2118  
2119 my $lvalue = Venus::Number->new;
2120 my $rvalue = Venus::Undef->new;
2121  
2122 my $result = $lvalue->le($rvalue);
2123  
2124 # 1
2125  
2126 =back
2127  
2128 =cut
2129  
2130 =head2 length
2131  
2132 length() (Num)
2133  
2134 The length method returns the number of characters within the number.
2135  
2136 I<Since C<1.23>>
2137  
2138 =over 4
2139  
2140 =item length example 1
2141  
2142 # given: synopsis;
2143  
2144 my $length = $number->length;
2145  
2146 # 4
2147  
2148 =back
2149  
2150 =cut
2151  
2152 =head2 log
2153  
2154 log() (Num)
2155  
2156 The log method returns the natural logarithm (base e) of the number.
2157  
2158 I<Since C<0.01>>
2159  
2160 =over 4
2161  
2162 =item log example 1
2163  
2164 package main;
2165  
2166 use Venus::Number;
2167  
2168 my $number = Venus::Number->new(12345);
2169  
2170 my $log = $number->log;
2171  
2172 # 9.42100640177928
2173  
2174 =back
2175  
2176 =cut
2177  
2178 =head2 lshift
2179  
2180 lshift(Num $value) (Num)
2181  
2182 The lshift method returns the result of a left shift performed on the argument
2183 provided.
2184  
2185 I<Since C<1.23>>
2186  
2187 =over 4
2188  
2189 =item lshift example 1
2190  
2191 # given: synopsis;
2192  
2193 my $lshift = $number->lshift(2);
2194  
2195 # 4000
2196  
2197 =back
2198  
2199 =cut
2200  
2201 =head2 lt
2202  
2203 lt(any $arg) (boolean)
2204  
2205 The lt method performs a I<"lesser-than"> operation using the argument provided.
2206  
2207 I<Since C<0.08>>
2208  
2209 =over 4
2210  
2211 =item lt example 1
2212  
2213 package main;
2214  
2215 use Venus::Array;
2216 use Venus::Number;
2217  
2218 my $lvalue = Venus::Number->new;
2219 my $rvalue = Venus::Array->new;
2220  
2221 my $result = $lvalue->lt($rvalue);
2222  
2223 # 1
2224  
2225 =back
2226  
2227 =over 4
2228  
2229 =item lt example 2
2230  
2231 package main;
2232  
2233 use Venus::Code;
2234 use Venus::Number;
2235  
2236 my $lvalue = Venus::Number->new;
2237 my $rvalue = Venus::Code->new;
2238  
2239 my $result = $lvalue->lt($rvalue);
2240  
2241 # 1
2242  
2243 =back
2244  
2245 =over 4
2246  
2247 =item lt example 3
2248  
2249 package main;
2250  
2251 use Venus::Float;
2252 use Venus::Number;
2253  
2254 my $lvalue = Venus::Number->new;
2255 my $rvalue = Venus::Float->new;
2256  
2257 my $result = $lvalue->lt($rvalue);
2258  
2259 # 0
2260  
2261 =back
2262  
2263 =over 4
2264  
2265 =item lt example 4
2266  
2267 package main;
2268  
2269 use Venus::Hash;
2270 use Venus::Number;
2271  
2272 my $lvalue = Venus::Number->new;
2273 my $rvalue = Venus::Hash->new;
2274  
2275 my $result = $lvalue->lt($rvalue);
2276  
2277 # 1
2278  
2279 =back
2280  
2281 =over 4
2282  
2283 =item lt example 5
2284  
2285 package main;
2286  
2287 use Venus::Number;
2288  
2289 my $lvalue = Venus::Number->new;
2290 my $rvalue = Venus::Number->new;
2291  
2292 my $result = $lvalue->lt($rvalue);
2293  
2294 # 0
2295  
2296 =back
2297  
2298 =over 4
2299  
2300 =item lt example 6
2301  
2302 package main;
2303  
2304 use Venus::Number;
2305 use Venus::Regexp;
2306  
2307 my $lvalue = Venus::Number->new;
2308 my $rvalue = Venus::Regexp->new;
2309  
2310 my $result = $lvalue->lt($rvalue);
2311  
2312 # 1
2313  
2314 =back
2315  
2316 =over 4
2317  
2318 =item lt example 7
2319  
2320 package main;
2321  
2322 use Venus::Number;
2323 use Venus::Scalar;
2324  
2325 my $lvalue = Venus::Number->new;
2326 my $rvalue = Venus::Scalar->new;
2327  
2328 my $result = $lvalue->lt($rvalue);
2329  
2330 # 1
2331  
2332 =back
2333  
2334 =over 4
2335  
2336 =item lt example 8
2337  
2338 package main;
2339  
2340 use Venus::Number;
2341 use Venus::String;
2342  
2343 my $lvalue = Venus::Number->new;
2344 my $rvalue = Venus::String->new;
2345  
2346 my $result = $lvalue->lt($rvalue);
2347  
2348 # 0
2349  
2350 =back
2351  
2352 =over 4
2353  
2354 =item lt example 9
2355  
2356 package main;
2357  
2358 use Venus::Number;
2359 use Venus::Undef;
2360  
2361 my $lvalue = Venus::Number->new;
2362 my $rvalue = Venus::Undef->new;
2363  
2364 my $result = $lvalue->lt($rvalue);
2365  
2366 # 0
2367  
2368 =back
2369  
2370 =cut
2371  
2372 =head2 mod
2373  
2374 mod() (Num)
2375  
2376 The mod method returns the division remainder of the number divided by the
2377 argment.
2378  
2379 I<Since C<0.01>>
2380  
2381 =over 4
2382  
2383 =item mod example 1
2384  
2385 package main;
2386  
2387 use Venus::Number;
2388  
2389 my $number = Venus::Number->new(12);
2390  
2391 my $mod = $number->mod(1);
2392  
2393 # 0
2394  
2395 =back
2396  
2397 =over 4
2398  
2399 =item mod example 2
2400  
2401 package main;
2402  
2403 use Venus::Number;
2404  
2405 my $number = Venus::Number->new(12);
2406  
2407 my $mod = $number->mod(2);
2408  
2409 # 0
2410  
2411 =back
2412  
2413 =over 4
2414  
2415 =item mod example 3
2416  
2417 package main;
2418  
2419 use Venus::Number;
2420  
2421 my $number = Venus::Number->new(12);
2422  
2423 my $mod = $number->mod(5);
2424  
2425 # 2
2426  
2427 =back
2428  
2429 =cut
2430  
2431 =head2 multi
2432  
2433 multi(Num $value) (Num)
2434  
2435 The multi method returns the result multiplication performed on the argument
2436 provided.
2437  
2438 I<Since C<1.23>>
2439  
2440 =over 4
2441  
2442 =item multi example 1
2443  
2444 # given: synopsis;
2445  
2446 my $multi = $number->multi(2);
2447  
2448 # 2000
2449  
2450 =back
2451  
2452 =cut
2453  
2454 =head2 ne
2455  
2456 ne(any $arg) (boolean)
2457  
2458 The ne method performs a I<"not-equal-to"> operation using the argument provided.
2459  
2460 I<Since C<0.08>>
2461  
2462 =over 4
2463  
2464 =item ne example 1
2465  
2466 package main;
2467  
2468 use Venus::Array;
2469 use Venus::Number;
2470  
2471 my $lvalue = Venus::Number->new;
2472 my $rvalue = Venus::Array->new;
2473  
2474 my $result = $lvalue->ne($rvalue);
2475  
2476 # 1
2477  
2478 =back
2479  
2480 =over 4
2481  
2482 =item ne example 2
2483  
2484 package main;
2485  
2486 use Venus::Code;
2487 use Venus::Number;
2488  
2489 my $lvalue = Venus::Number->new;
2490 my $rvalue = Venus::Code->new;
2491  
2492 my $result = $lvalue->ne($rvalue);
2493  
2494 # 1
2495  
2496 =back
2497  
2498 =over 4
2499  
2500 =item ne example 3
2501  
2502 package main;
2503  
2504 use Venus::Float;
2505 use Venus::Number;
2506  
2507 my $lvalue = Venus::Number->new;
2508 my $rvalue = Venus::Float->new;
2509  
2510 my $result = $lvalue->ne($rvalue);
2511  
2512 # 0
2513  
2514 =back
2515  
2516 =over 4
2517  
2518 =item ne example 4
2519  
2520 package main;
2521  
2522 use Venus::Hash;
2523 use Venus::Number;
2524  
2525 my $lvalue = Venus::Number->new;
2526 my $rvalue = Venus::Hash->new;
2527  
2528 my $result = $lvalue->ne($rvalue);
2529  
2530 # 1
2531  
2532 =back
2533  
2534 =over 4
2535  
2536 =item ne example 5
2537  
2538 package main;
2539  
2540 use Venus::Number;
2541  
2542 my $lvalue = Venus::Number->new;
2543 my $rvalue = Venus::Number->new;
2544  
2545 my $result = $lvalue->ne($rvalue);
2546  
2547 # 0
2548  
2549 =back
2550  
2551 =over 4
2552  
2553 =item ne example 6
2554  
2555 package main;
2556  
2557 use Venus::Number;
2558 use Venus::Regexp;
2559  
2560 my $lvalue = Venus::Number->new;
2561 my $rvalue = Venus::Regexp->new;
2562  
2563 my $result = $lvalue->ne($rvalue);
2564  
2565 # 1
2566  
2567 =back
2568  
2569 =over 4
2570  
2571 =item ne example 7
2572  
2573 package main;
2574  
2575 use Venus::Number;
2576 use Venus::Scalar;
2577  
2578 my $lvalue = Venus::Number->new;
2579 my $rvalue = Venus::Scalar->new;
2580  
2581 my $result = $lvalue->ne($rvalue);
2582  
2583 # 1
2584  
2585 =back
2586  
2587 =over 4
2588  
2589 =item ne example 8
2590  
2591 package main;
2592  
2593 use Venus::Number;
2594 use Venus::String;
2595  
2596 my $lvalue = Venus::Number->new;
2597 my $rvalue = Venus::String->new;
2598  
2599 my $result = $lvalue->ne($rvalue);
2600  
2601 # 0
2602  
2603 =back
2604  
2605 =over 4
2606  
2607 =item ne example 9
2608  
2609 package main;
2610  
2611 use Venus::Number;
2612 use Venus::Undef;
2613  
2614 my $lvalue = Venus::Number->new;
2615 my $rvalue = Venus::Undef->new;
2616  
2617 my $result = $lvalue->ne($rvalue);
2618  
2619 # 0
2620  
2621 =back
2622  
2623 =cut
2624  
2625 =head2 neg
2626  
2627 neg() (Num)
2628  
2629 The neg method returns a negative version of the number.
2630  
2631 I<Since C<0.01>>
2632  
2633 =over 4
2634  
2635 =item neg example 1
2636  
2637 package main;
2638  
2639 use Venus::Number;
2640  
2641 my $number = Venus::Number->new(12345);
2642  
2643 my $neg = $number->neg;
2644  
2645 # -12345
2646  
2647 =back
2648  
2649 =cut
2650  
2651 =head2 new
2652  
2653 new(any @args) (Venus::Number)
2654  
2655 The new method constructs an instance of the package.
2656  
2657 I<Since C<4.15>>
2658  
2659 =over 4
2660  
2661 =item new example 1
2662  
2663 package main;
2664  
2665 use Venus::Number;
2666  
2667 my $new = Venus::Number->new;
2668  
2669 # bless(..., "Venus::Number")
2670  
2671 =back
2672  
2673 =over 4
2674  
2675 =item new example 2
2676  
2677 package main;
2678  
2679 use Venus::Number;
2680  
2681 my $new = Venus::Number->new(1_000);
2682  
2683 # bless(..., "Venus::Number")
2684  
2685 =back
2686  
2687 =over 4
2688  
2689 =item new example 3
2690  
2691 package main;
2692  
2693 use Venus::Number;
2694  
2695 my $new = Venus::Number->new(value => 1_000);
2696  
2697 # bless(..., "Venus::Number")
2698  
2699 =back
2700  
2701 =cut
2702  
2703 =head2 numified
2704  
2705 numified() (Num)
2706  
2707 The numified method returns the numerical representation of the object. For
2708 number objects this method returns the object's underlying value.
2709  
2710 I<Since C<0.08>>
2711  
2712 =over 4
2713  
2714 =item numified example 1
2715  
2716 # given: synopsis;
2717  
2718 my $numified = $number->numified;
2719  
2720 # 1000
2721  
2722 =back
2723  
2724 =over 4
2725  
2726 =item numified example 2
2727  
2728 package main;
2729  
2730 use Venus::Number;
2731  
2732 my $number = Venus::Number->new(2_000);
2733  
2734 my $numified = $number->numified;
2735  
2736 # 2000
2737  
2738 =back
2739  
2740 =over 4
2741  
2742 =item numified example 3
2743  
2744 package main;
2745  
2746 use Venus::Number;
2747  
2748 my $number = Venus::Number->new(10_000);
2749  
2750 my $numified = $number->numified;
2751  
2752 # 10000
2753  
2754 =back
2755  
2756 =cut
2757  
2758 =head2 pow
2759  
2760 pow() (Num)
2761  
2762 The pow method returns a number, the result of a math operation, which is the
2763 number to the power of the argument.
2764  
2765 I<Since C<0.01>>
2766  
2767 =over 4
2768  
2769 =item pow example 1
2770  
2771 package main;
2772  
2773 use Venus::Number;
2774  
2775 my $number = Venus::Number->new(12345);
2776  
2777 my $pow = $number->pow(3);
2778  
2779 # 1881365963625
2780  
2781 =back
2782  
2783 =cut
2784  
2785 =head2 prepend
2786  
2787 prepend(string @parts) (string)
2788  
2789 The prepend method prepends arugments to the number.
2790  
2791 I<Since C<1.23>>
2792  
2793 =over 4
2794  
2795 =item prepend example 1
2796  
2797 # given: synopsis;
2798  
2799 my $prepend = $number->prepend(1);
2800  
2801 # 11_000
2802  
2803 =back
2804  
2805 =cut
2806  
2807 =head2 prepend_with
2808  
2809 prepend_with(string $delimiter, string @parts) (string)
2810  
2811 The prepend_with method prepends arugments to the number using the delimiter
2812 provided.
2813  
2814 I<Since C<1.23>>
2815  
2816 =over 4
2817  
2818 =item prepend_with example 1
2819  
2820 # given: synopsis;
2821  
2822 my $prepend = $number->prepend_with('.', '11');
2823  
2824 # "11.1000"
2825  
2826 =back
2827  
2828 =cut
2829  
2830 =head2 range
2831  
2832 range() (arrayref)
2833  
2834 The range method returns an array reference containing integer increasing values
2835 up-to or down-to the limit specified.
2836  
2837 I<Since C<0.01>>
2838  
2839 =over 4
2840  
2841 =item range example 1
2842  
2843 package main;
2844  
2845 use Venus::Number;
2846  
2847 my $number = Venus::Number->new(5);
2848  
2849 my $range = $number->range(9);
2850  
2851 # [5..9]
2852  
2853 =back
2854  
2855 =over 4
2856  
2857 =item range example 2
2858  
2859 package main;
2860  
2861 use Venus::Number;
2862  
2863 my $number = Venus::Number->new(5);
2864  
2865 my $range = $number->range(1);
2866  
2867 # [5, 4, 3, 2, 1]
2868  
2869 =back
2870  
2871 =cut
2872  
2873 =head2 repeat
2874  
2875 repeat(Num $number, string $delimiter) (string)
2876  
2877 The repeat method repeats the number value N times based on the argument provided
2878 and returns a new concatenated number. Optionally, a delimiter can be provided
2879 and be place between the occurences.
2880  
2881 I<Since C<1.23>>
2882  
2883 =over 4
2884  
2885 =item repeat example 1
2886  
2887 package main;
2888  
2889 use Venus::Number;
2890  
2891 my $number = Venus::Number->new('999');
2892  
2893 my $repeat = $number->repeat(2);
2894  
2895 # 999999
2896  
2897 =back
2898  
2899 =over 4
2900  
2901 =item repeat example 2
2902  
2903 package main;
2904  
2905 use Venus::Number;
2906  
2907 my $number = Venus::Number->new('999');
2908  
2909 my $repeat = $number->repeat(2, '.');
2910  
2911 # 999.999
2912  
2913 =back
2914  
2915 =cut
2916  
2917 =head2 rshift
2918  
2919 rshift(num $value) (Num)
2920  
2921 The rshift method returns the result a right shift performed on the argument
2922 provided.
2923  
2924 I<Since C<1.23>>
2925  
2926 =over 4
2927  
2928 =item rshift example 1
2929  
2930 # given: synopsis;
2931  
2932 my $rshift = $number->rshift(2);
2933  
2934 # 250
2935  
2936 =back
2937  
2938 =cut
2939  
2940 =head2 sin
2941  
2942 sin() (Num)
2943  
2944 The sin method returns the sine of the number (expressed in radians).
2945  
2946 I<Since C<0.01>>
2947  
2948 =over 4
2949  
2950 =item sin example 1
2951  
2952 package main;
2953  
2954 use Venus::Number;
2955  
2956 my $number = Venus::Number->new(12345);
2957  
2958 my $sin = $number->sin;
2959  
2960 # -0.993771636455681
2961  
2962 =back
2963  
2964 =cut
2965  
2966 =head2 sqrt
2967  
2968 sqrt() (Num)
2969  
2970 The sqrt method returns the positive square root of the number.
2971  
2972 I<Since C<0.01>>
2973  
2974 =over 4
2975  
2976 =item sqrt example 1
2977  
2978 package main;
2979  
2980 use Venus::Number;
2981  
2982 my $number = Venus::Number->new(12345);
2983  
2984 my $sqrt = $number->sqrt;
2985  
2986 # 111.108055513541
2987  
2988 =back
2989  
2990 =cut
2991  
2992 =head2 sub
2993  
2994 sub(Num $value) (Num)
2995  
2996 The sub method returns the result subtraction performed on the argument
2997 provided.
2998  
2999 I<Since C<1.23>>
3000  
3001 =over 4
3002  
3003 =item sub example 1
3004  
3005 # given: synopsis;
3006  
3007 my $sub = $number->sub(500);
3008  
3009 # 500
3010  
3011 =back
3012  
3013 =cut
3014  
3015 =head2 substr
3016  
3017 substr(Num $offset, Num $length, string $replace) (string)
3018  
3019 The substr method calls the core L</substr> function with the object's number
3020 value. In list context returns the result and the subject.
3021  
3022 I<Since C<1.23>>
3023  
3024 =over 4
3025  
3026 =item substr example 1
3027  
3028 package main;
3029  
3030 use Venus::Number;
3031  
3032 my $number = Venus::Number->new(1234567890);
3033  
3034 my $substr = $number->substr(0, 5);
3035  
3036 # 12345
3037  
3038 =back
3039  
3040 =over 4
3041  
3042 =item substr example 2
3043  
3044 package main;
3045  
3046 use Venus::Number;
3047  
3048 my $number = Venus::Number->new(1234567890);
3049  
3050 my $substr = $number->substr(6, 5);
3051  
3052 # 7890
3053  
3054 =back
3055  
3056 =over 4
3057  
3058 =item substr example 3
3059  
3060 package main;
3061  
3062 use Venus::Number;
3063  
3064 my $number = Venus::Number->new(1234567890);
3065  
3066 my $substr = $number->substr(6, 5, '0000');
3067  
3068 # "1234560000"
3069  
3070 =back
3071  
3072 =over 4
3073  
3074 =item substr example 4
3075  
3076 package main;
3077  
3078 use Venus::Number;
3079  
3080 my $number = Venus::Number->new(1234567890);
3081  
3082 my ($result, $subject) = $number->substr(6, 5, '0000');
3083  
3084 # ("789", "1234560000")
3085  
3086 =back
3087  
3088 =cut
3089  
3090 =head2 tv
3091  
3092 tv(any $arg) (boolean)
3093  
3094 The tv method performs a I<"type-and-value-equal-to"> operation using argument
3095 provided.
3096  
3097 I<Since C<0.08>>
3098  
3099 =over 4
3100  
3101 =item tv example 1
3102  
3103 package main;
3104  
3105 use Venus::Array;
3106 use Venus::Number;
3107  
3108 my $lvalue = Venus::Number->new;
3109 my $rvalue = Venus::Array->new;
3110  
3111 my $result = $lvalue->tv($rvalue);
3112  
3113 # 0
3114  
3115 =back
3116  
3117 =over 4
3118  
3119 =item tv example 2
3120  
3121 package main;
3122  
3123 use Venus::Code;
3124 use Venus::Number;
3125  
3126 my $lvalue = Venus::Number->new;
3127 my $rvalue = Venus::Code->new;
3128  
3129 my $result = $lvalue->tv($rvalue);
3130  
3131 # 0
3132  
3133 =back
3134  
3135 =over 4
3136  
3137 =item tv example 3
3138  
3139 package main;
3140  
3141 use Venus::Float;
3142 use Venus::Number;
3143  
3144 my $lvalue = Venus::Number->new;
3145 my $rvalue = Venus::Float->new;
3146  
3147 my $result = $lvalue->tv($rvalue);
3148  
3149 # 1
3150  
3151 =back
3152  
3153 =over 4
3154  
3155 =item tv example 4
3156  
3157 package main;
3158  
3159 use Venus::Hash;
3160 use Venus::Number;
3161  
3162 my $lvalue = Venus::Number->new;
3163 my $rvalue = Venus::Hash->new;
3164  
3165 my $result = $lvalue->tv($rvalue);
3166  
3167 # 0
3168  
3169 =back
3170  
3171 =over 4
3172  
3173 =item tv example 5
3174  
3175 package main;
3176  
3177 use Venus::Number;
3178  
3179 my $lvalue = Venus::Number->new;
3180 my $rvalue = Venus::Number->new;
3181  
3182 my $result = $lvalue->tv($rvalue);
3183  
3184 # 1
3185  
3186 =back
3187  
3188 =over 4
3189  
3190 =item tv example 6
3191  
3192 package main;
3193  
3194 use Venus::Number;
3195 use Venus::Regexp;
3196  
3197 my $lvalue = Venus::Number->new;
3198 my $rvalue = Venus::Regexp->new;
3199  
3200 my $result = $lvalue->tv($rvalue);
3201  
3202 # 0
3203  
3204 =back
3205  
3206 =over 4
3207  
3208 =item tv example 7
3209  
3210 package main;
3211  
3212 use Venus::Number;
3213 use Venus::Scalar;
3214  
3215 my $lvalue = Venus::Number->new;
3216 my $rvalue = Venus::Scalar->new;
3217  
3218 my $result = $lvalue->tv($rvalue);
3219  
3220 # 0
3221  
3222 =back
3223  
3224 =over 4
3225  
3226 =item tv example 8
3227  
3228 package main;
3229  
3230 use Venus::Number;
3231 use Venus::String;
3232  
3233 my $lvalue = Venus::Number->new;
3234 my $rvalue = Venus::String->new;
3235  
3236 my $result = $lvalue->tv($rvalue);
3237  
3238 # 0
3239  
3240 =back
3241  
3242 =over 4
3243  
3244 =item tv example 9
3245  
3246 package main;
3247  
3248 use Venus::Number;
3249 use Venus::Undef;
3250  
3251 my $lvalue = Venus::Number->new;
3252 my $rvalue = Venus::Undef->new;
3253  
3254 my $result = $lvalue->tv($rvalue);
3255  
3256 # 0
3257  
3258 =back
3259  
3260 =cut
3261  
3262 =head1 AUTHORS
3263  
3264 Awncorp, C<awncorp@cpan.org>
3265  
3266 =cut
3267  
3268 =head1 LICENSE
3269  
3270 Copyright (C) 2022, Awncorp, C<awncorp@cpan.org>.
3271  
3272 This program is free software, you can redistribute it and/or modify it under
3273 the terms of the Apache license version 2.0.
3274  
3275 =cut
« blib/lib/Venus/Result.pm ↑ Summary blib/lib/Venus/Kind.pm »