blib/lib/Venus/Float.pm

filter: Statementstmt 100% 14 / 14 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 100% 5 / 5 Podpod 100% 1 / 1 totaltotal 100% 20 / 20 CC 1 SCAR 0.0
CC
1
Cov
100%
BEGIN
1.0
BEGIN
1.0
BEGIN
1.0
CRAP 1.0
« blib/lib/Venus/Core.pm ↑ Summary blib/lib/Venus/Scalar.pm »
1 package Venus::Float;
2  
3 15 ▶use 5.018;
Subroutine BEGIN: called CC=1 SCAR=0.0
4  
5 15 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 15 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
7  
8 # IMPORTS
9  
10 15 ▶use Venus::Class 'base';
Subroutine BEGIN: called CC=1 SCAR=0.0
11  
12 # INHERITS
13  
14 15 base 'Venus::Number';
15  
16 # METHODS
17  
18 181 ▶sub default {
Subroutine default: called CC=1 SCAR=0.0
Pod documented
19 181 return '0.0';
20 }
21  
22 15 1;
23  
24  
25  
26 =head1 NAME
27  
28 Venus::Float - Float Class
29  
30 =cut
31  
32 =head1 ABSTRACT
33  
34 Float Class for Perl 5
35  
36 =cut
37  
38 =head1 SYNOPSIS
39  
40 package main;
41  
42 use Venus::Float;
43  
44 my $float = Venus::Float->new(1.23);
45  
46 # $float->int;
47  
48 =cut
49  
50 =head1 DESCRIPTION
51  
52 This package provides methods for manipulating float data.
53  
54 =cut
55  
56 =head1 INHERITS
57  
58 This package inherits behaviors from:
59  
60 L<Venus::Number>
61  
62 =cut
63  
64 =head1 METHODS
65  
66 This package provides the following methods:
67  
68 =cut
69  
70 =head2 cast
71  
72 cast(string $kind) (object | undef)
73  
74 The cast method converts L<"value"|Venus::Kind::Value> objects between
75 different I<"value"> object types, based on the name of the type provided. This
76 method will return C<undef> if the invocant is not a L<Venus::Kind::Value>.
77  
78 I<Since C<0.08>>
79  
80 =over 4
81  
82 =item cast example 1
83  
84 package main;
85  
86 use Venus::Float;
87  
88 my $float = Venus::Float->new;
89  
90 my $cast = $float->cast('array');
91  
92 # bless({ value => ["0.0"] }, "Venus::Array")
93  
94 =back
95  
96 =over 4
97  
98 =item cast example 2
99  
100 package main;
101  
102 use Venus::Float;
103  
104 my $float = Venus::Float->new;
105  
106 my $cast = $float->cast('boolean');
107  
108 # bless({ value => 1 }, "Venus::Boolean")
109  
110 =back
111  
112 =over 4
113  
114 =item cast example 3
115  
116 package main;
117  
118 use Venus::Float;
119  
120 my $float = Venus::Float->new;
121  
122 my $cast = $float->cast('code');
123  
124 # bless({ value => sub { ... } }, "Venus::Code")
125  
126 =back
127  
128 =over 4
129  
130 =item cast example 4
131  
132 package main;
133  
134 use Venus::Float;
135  
136 my $float = Venus::Float->new;
137  
138 my $cast = $float->cast('float');
139  
140 # bless({ value => "0.0" }, "Venus::Float")
141  
142 =back
143  
144 =over 4
145  
146 =item cast example 5
147  
148 package main;
149  
150 use Venus::Float;
151  
152 my $float = Venus::Float->new;
153  
154 my $cast = $float->cast('hash');
155  
156 # bless({ value => { "0.0" => "0.0" } }, "Venus::Hash")
157  
158 =back
159  
160 =over 4
161  
162 =item cast example 6
163  
164 package main;
165  
166 use Venus::Float;
167  
168 my $float = Venus::Float->new;
169  
170 my $cast = $float->cast('number');
171  
172 # bless({ value => 0 }, "Venus::Number")
173  
174 =back
175  
176 =over 4
177  
178 =item cast example 7
179  
180 package main;
181  
182 use Venus::Float;
183  
184 my $float = Venus::Float->new;
185  
186 my $cast = $float->cast('regexp');
187  
188 # bless({ value => qr/(?^u:0\.0)/ }, "Venus::Regexp")
189  
190 =back
191  
192 =over 4
193  
194 =item cast example 8
195  
196 package main;
197  
198 use Venus::Float;
199  
200 my $float = Venus::Float->new;
201  
202 my $cast = $float->cast('scalar');
203  
204 # bless({ value => \"0.0" }, "Venus::Scalar")
205  
206 =back
207  
208 =over 4
209  
210 =item cast example 9
211  
212 package main;
213  
214 use Venus::Float;
215  
216 my $float = Venus::Float->new;
217  
218 my $cast = $float->cast('string');
219  
220 # bless({ value => "0.0" }, "Venus::String")
221  
222 =back
223  
224 =over 4
225  
226 =item cast example 10
227  
228 package main;
229  
230 use Venus::Float;
231  
232 my $float = Venus::Float->new;
233  
234 my $cast = $float->cast('undef');
235  
236 # bless({ value => undef }, "Venus::Undef")
237  
238 =back
239  
240 =cut
241  
242 =head2 default
243  
244 default() (string)
245  
246 The default method returns the default value, i.e. C<0.0>.
247  
248 I<Since C<0.01>>
249  
250 =over 4
251  
252 =item default example 1
253  
254 # given: synopsis;
255  
256 my $default = $float->default;
257  
258 # "0.0"
259  
260 =back
261  
262 =cut
263  
264 =head2 eq
265  
266 eq(any $arg) (boolean)
267  
268 The eq method performs an I<"equals"> operation using the argument provided.
269  
270 I<Since C<0.08>>
271  
272 =over 4
273  
274 =item eq example 1
275  
276 package main;
277  
278 use Venus::Array;
279 use Venus::Float;
280  
281 my $lvalue = Venus::Float->new;
282 my $rvalue = Venus::Array->new;
283  
284 my $result = $lvalue->eq($rvalue);
285  
286 # 0
287  
288 =back
289  
290 =over 4
291  
292 =item eq example 2
293  
294 package main;
295  
296 use Venus::Code;
297 use Venus::Float;
298  
299 my $lvalue = Venus::Float->new;
300 my $rvalue = Venus::Code->new;
301  
302 my $result = $lvalue->eq($rvalue);
303  
304 # 0
305  
306 =back
307  
308 =over 4
309  
310 =item eq example 3
311  
312 package main;
313  
314 use Venus::Float;
315  
316 my $lvalue = Venus::Float->new;
317 my $rvalue = Venus::Float->new;
318  
319 my $result = $lvalue->eq($rvalue);
320  
321 # 1
322  
323 =back
324  
325 =over 4
326  
327 =item eq example 4
328  
329 package main;
330  
331 use Venus::Float;
332 use Venus::Hash;
333  
334 my $lvalue = Venus::Float->new;
335 my $rvalue = Venus::Hash->new;
336  
337 my $result = $lvalue->eq($rvalue);
338  
339 # 0
340  
341 =back
342  
343 =over 4
344  
345 =item eq example 5
346  
347 package main;
348  
349 use Venus::Float;
350 use Venus::Number;
351  
352 my $lvalue = Venus::Float->new;
353 my $rvalue = Venus::Number->new;
354  
355 my $result = $lvalue->eq($rvalue);
356  
357 # 1
358  
359 =back
360  
361 =over 4
362  
363 =item eq example 6
364  
365 package main;
366  
367 use Venus::Float;
368 use Venus::Regexp;
369  
370 my $lvalue = Venus::Float->new;
371 my $rvalue = Venus::Regexp->new;
372  
373 my $result = $lvalue->eq($rvalue);
374  
375 # 0
376  
377 =back
378  
379 =over 4
380  
381 =item eq example 7
382  
383 package main;
384  
385 use Venus::Float;
386 use Venus::Scalar;
387  
388 my $lvalue = Venus::Float->new;
389 my $rvalue = Venus::Scalar->new;
390  
391 my $result = $lvalue->eq($rvalue);
392  
393 # 0
394  
395 =back
396  
397 =over 4
398  
399 =item eq example 8
400  
401 package main;
402  
403 use Venus::Float;
404 use Venus::String;
405  
406 my $lvalue = Venus::Float->new;
407 my $rvalue = Venus::String->new;
408  
409 my $result = $lvalue->eq($rvalue);
410  
411 # 1
412  
413 =back
414  
415 =over 4
416  
417 =item eq example 9
418  
419 package main;
420  
421 use Venus::Float;
422 use Venus::Undef;
423  
424 my $lvalue = Venus::Float->new;
425 my $rvalue = Venus::Undef->new;
426  
427 my $result = $lvalue->eq($rvalue);
428  
429 # 1
430  
431 =back
432  
433 =cut
434  
435 =head2 ge
436  
437 ge(any $arg) (boolean)
438  
439 The ge method performs a I<"greater-than-or-equal-to"> operation using the
440 argument provided.
441  
442 I<Since C<0.08>>
443  
444 =over 4
445  
446 =item ge example 1
447  
448 package main;
449  
450 use Venus::Array;
451 use Venus::Float;
452  
453 my $lvalue = Venus::Float->new;
454 my $rvalue = Venus::Array->new;
455  
456 my $result = $lvalue->ge($rvalue);
457  
458 # 0
459  
460 =back
461  
462 =over 4
463  
464 =item ge example 2
465  
466 package main;
467  
468 use Venus::Code;
469 use Venus::Float;
470  
471 my $lvalue = Venus::Float->new;
472 my $rvalue = Venus::Code->new;
473  
474 my $result = $lvalue->ge($rvalue);
475  
476 # 0
477  
478 =back
479  
480 =over 4
481  
482 =item ge example 3
483  
484 package main;
485  
486 use Venus::Float;
487  
488 my $lvalue = Venus::Float->new;
489 my $rvalue = Venus::Float->new;
490  
491 my $result = $lvalue->ge($rvalue);
492  
493 # 1
494  
495 =back
496  
497 =over 4
498  
499 =item ge example 4
500  
501 package main;
502  
503 use Venus::Float;
504 use Venus::Hash;
505  
506 my $lvalue = Venus::Float->new;
507 my $rvalue = Venus::Hash->new;
508  
509 my $result = $lvalue->ge($rvalue);
510  
511 # 0
512  
513 =back
514  
515 =over 4
516  
517 =item ge example 5
518  
519 package main;
520  
521 use Venus::Float;
522 use Venus::Number;
523  
524 my $lvalue = Venus::Float->new;
525 my $rvalue = Venus::Number->new;
526  
527 my $result = $lvalue->ge($rvalue);
528  
529 # 1
530  
531 =back
532  
533 =over 4
534  
535 =item ge example 6
536  
537 package main;
538  
539 use Venus::Float;
540 use Venus::Regexp;
541  
542 my $lvalue = Venus::Float->new;
543 my $rvalue = Venus::Regexp->new;
544  
545 my $result = $lvalue->ge($rvalue);
546  
547 # 0
548  
549 =back
550  
551 =over 4
552  
553 =item ge example 7
554  
555 package main;
556  
557 use Venus::Float;
558 use Venus::Scalar;
559  
560 my $lvalue = Venus::Float->new;
561 my $rvalue = Venus::Scalar->new;
562  
563 my $result = $lvalue->ge($rvalue);
564  
565 # 0
566  
567 =back
568  
569 =over 4
570  
571 =item ge example 8
572  
573 package main;
574  
575 use Venus::Float;
576 use Venus::String;
577  
578 my $lvalue = Venus::Float->new;
579 my $rvalue = Venus::String->new;
580  
581 my $result = $lvalue->ge($rvalue);
582  
583 # 1
584  
585 =back
586  
587 =over 4
588  
589 =item ge example 9
590  
591 package main;
592  
593 use Venus::Float;
594 use Venus::Undef;
595  
596 my $lvalue = Venus::Float->new;
597 my $rvalue = Venus::Undef->new;
598  
599 my $result = $lvalue->ge($rvalue);
600  
601 # 1
602  
603 =back
604  
605 =cut
606  
607 =head2 gele
608  
609 gele(any $arg1, any $arg2) (boolean)
610  
611 The gele method performs a I<"greater-than-or-equal-to"> operation on the 1st
612 argument, and I<"lesser-than-or-equal-to"> operation on the 2nd argument.
613  
614 I<Since C<0.08>>
615  
616 =over 4
617  
618 =item gele example 1
619  
620 package main;
621  
622 use Venus::Array;
623 use Venus::Float;
624  
625 my $lvalue = Venus::Float->new;
626 my $rvalue = Venus::Array->new;
627  
628 my $result = $lvalue->gele($rvalue);
629  
630 # 0
631  
632 =back
633  
634 =over 4
635  
636 =item gele example 2
637  
638 package main;
639  
640 use Venus::Code;
641 use Venus::Float;
642  
643 my $lvalue = Venus::Float->new;
644 my $rvalue = Venus::Code->new;
645  
646 my $result = $lvalue->gele($rvalue);
647  
648 # 0
649  
650 =back
651  
652 =over 4
653  
654 =item gele example 3
655  
656 package main;
657  
658 use Venus::Float;
659  
660 my $lvalue = Venus::Float->new;
661 my $rvalue = Venus::Float->new;
662  
663 my $result = $lvalue->gele($rvalue);
664  
665 # 1
666  
667 =back
668  
669 =over 4
670  
671 =item gele example 4
672  
673 package main;
674  
675 use Venus::Float;
676 use Venus::Hash;
677  
678 my $lvalue = Venus::Float->new;
679 my $rvalue = Venus::Hash->new;
680  
681 my $result = $lvalue->gele($rvalue);
682  
683 # 0
684  
685 =back
686  
687 =over 4
688  
689 =item gele example 5
690  
691 package main;
692  
693 use Venus::Float;
694 use Venus::Number;
695  
696 my $lvalue = Venus::Float->new;
697 my $rvalue = Venus::Number->new;
698  
699 my $result = $lvalue->gele($rvalue);
700  
701 # 1
702  
703 =back
704  
705 =over 4
706  
707 =item gele example 6
708  
709 package main;
710  
711 use Venus::Float;
712 use Venus::Regexp;
713  
714 my $lvalue = Venus::Float->new;
715 my $rvalue = Venus::Regexp->new;
716  
717 my $result = $lvalue->gele($rvalue);
718  
719 # 0
720  
721 =back
722  
723 =over 4
724  
725 =item gele example 7
726  
727 package main;
728  
729 use Venus::Float;
730 use Venus::Scalar;
731  
732 my $lvalue = Venus::Float->new;
733 my $rvalue = Venus::Scalar->new;
734  
735 my $result = $lvalue->gele($rvalue);
736  
737 # 0
738  
739 =back
740  
741 =over 4
742  
743 =item gele example 8
744  
745 package main;
746  
747 use Venus::Float;
748 use Venus::String;
749  
750 my $lvalue = Venus::Float->new;
751 my $rvalue = Venus::String->new;
752  
753 my $result = $lvalue->gele($rvalue);
754  
755 # 1
756  
757 =back
758  
759 =over 4
760  
761 =item gele example 9
762  
763 package main;
764  
765 use Venus::Float;
766 use Venus::Undef;
767  
768 my $lvalue = Venus::Float->new;
769 my $rvalue = Venus::Undef->new;
770  
771 my $result = $lvalue->gele($rvalue);
772  
773 # 1
774  
775 =back
776  
777 =cut
778  
779 =head2 gt
780  
781 gt(any $arg) (boolean)
782  
783 The gt method performs a I<"greater-than"> operation using the argument provided.
784  
785 I<Since C<0.08>>
786  
787 =over 4
788  
789 =item gt example 1
790  
791 package main;
792  
793 use Venus::Array;
794 use Venus::Float;
795  
796 my $lvalue = Venus::Float->new;
797 my $rvalue = Venus::Array->new;
798  
799 my $result = $lvalue->gt($rvalue);
800  
801 # 0
802  
803 =back
804  
805 =over 4
806  
807 =item gt example 2
808  
809 package main;
810  
811 use Venus::Code;
812 use Venus::Float;
813  
814 my $lvalue = Venus::Float->new;
815 my $rvalue = Venus::Code->new;
816  
817 my $result = $lvalue->gt($rvalue);
818  
819 # 0
820  
821 =back
822  
823 =over 4
824  
825 =item gt example 3
826  
827 package main;
828  
829 use Venus::Float;
830  
831 my $lvalue = Venus::Float->new;
832 my $rvalue = Venus::Float->new;
833  
834 my $result = $lvalue->gt($rvalue);
835  
836 # 0
837  
838 =back
839  
840 =over 4
841  
842 =item gt example 4
843  
844 package main;
845  
846 use Venus::Float;
847 use Venus::Hash;
848  
849 my $lvalue = Venus::Float->new;
850 my $rvalue = Venus::Hash->new;
851  
852 my $result = $lvalue->gt($rvalue);
853  
854 # 0
855  
856 =back
857  
858 =over 4
859  
860 =item gt example 5
861  
862 package main;
863  
864 use Venus::Float;
865 use Venus::Number;
866  
867 my $lvalue = Venus::Float->new;
868 my $rvalue = Venus::Number->new;
869  
870 my $result = $lvalue->gt($rvalue);
871  
872 # 0
873  
874 =back
875  
876 =over 4
877  
878 =item gt example 6
879  
880 package main;
881  
882 use Venus::Float;
883 use Venus::Regexp;
884  
885 my $lvalue = Venus::Float->new;
886 my $rvalue = Venus::Regexp->new;
887  
888 my $result = $lvalue->gt($rvalue);
889  
890 # 0
891  
892 =back
893  
894 =over 4
895  
896 =item gt example 7
897  
898 package main;
899  
900 use Venus::Float;
901 use Venus::Scalar;
902  
903 my $lvalue = Venus::Float->new;
904 my $rvalue = Venus::Scalar->new;
905  
906 my $result = $lvalue->gt($rvalue);
907  
908 # 0
909  
910 =back
911  
912 =over 4
913  
914 =item gt example 8
915  
916 package main;
917  
918 use Venus::Float;
919 use Venus::String;
920  
921 my $lvalue = Venus::Float->new;
922 my $rvalue = Venus::String->new;
923  
924 my $result = $lvalue->gt($rvalue);
925  
926 # 0
927  
928 =back
929  
930 =over 4
931  
932 =item gt example 9
933  
934 package main;
935  
936 use Venus::Float;
937 use Venus::Undef;
938  
939 my $lvalue = Venus::Float->new;
940 my $rvalue = Venus::Undef->new;
941  
942 my $result = $lvalue->gt($rvalue);
943  
944 # 0
945  
946 =back
947  
948 =cut
949  
950 =head2 gtlt
951  
952 gtlt(any $arg1, any $arg2) (boolean)
953  
954 The gtlt method performs a I<"greater-than"> operation on the 1st argument, and
955 I<"lesser-than"> operation on the 2nd argument.
956  
957 I<Since C<0.08>>
958  
959 =over 4
960  
961 =item gtlt example 1
962  
963 package main;
964  
965 use Venus::Array;
966 use Venus::Float;
967  
968 my $lvalue = Venus::Float->new;
969 my $rvalue = Venus::Array->new;
970  
971 my $result = $lvalue->gtlt($rvalue);
972  
973 # 0
974  
975 =back
976  
977 =over 4
978  
979 =item gtlt example 2
980  
981 package main;
982  
983 use Venus::Code;
984 use Venus::Float;
985  
986 my $lvalue = Venus::Float->new;
987 my $rvalue = Venus::Code->new;
988  
989 my $result = $lvalue->gtlt($rvalue);
990  
991 # 0
992  
993 =back
994  
995 =over 4
996  
997 =item gtlt example 3
998  
999 package main;
1000  
1001 use Venus::Float;
1002  
1003 my $lvalue = Venus::Float->new;
1004 my $rvalue = Venus::Float->new;
1005  
1006 my $result = $lvalue->gtlt($rvalue);
1007  
1008 # 0
1009  
1010 =back
1011  
1012 =over 4
1013  
1014 =item gtlt example 4
1015  
1016 package main;
1017  
1018 use Venus::Float;
1019 use Venus::Hash;
1020  
1021 my $lvalue = Venus::Float->new;
1022 my $rvalue = Venus::Hash->new;
1023  
1024 my $result = $lvalue->gtlt($rvalue);
1025  
1026 # 0
1027  
1028 =back
1029  
1030 =over 4
1031  
1032 =item gtlt example 5
1033  
1034 package main;
1035  
1036 use Venus::Float;
1037 use Venus::Number;
1038  
1039 my $lvalue = Venus::Float->new;
1040 my $rvalue = Venus::Number->new;
1041  
1042 my $result = $lvalue->gtlt($rvalue);
1043  
1044 # 0
1045  
1046 =back
1047  
1048 =over 4
1049  
1050 =item gtlt example 6
1051  
1052 package main;
1053  
1054 use Venus::Float;
1055 use Venus::Regexp;
1056  
1057 my $lvalue = Venus::Float->new;
1058 my $rvalue = Venus::Regexp->new;
1059  
1060 my $result = $lvalue->gtlt($rvalue);
1061  
1062 # 0
1063  
1064 =back
1065  
1066 =over 4
1067  
1068 =item gtlt example 7
1069  
1070 package main;
1071  
1072 use Venus::Float;
1073 use Venus::Scalar;
1074  
1075 my $lvalue = Venus::Float->new;
1076 my $rvalue = Venus::Scalar->new;
1077  
1078 my $result = $lvalue->gtlt($rvalue);
1079  
1080 # 0
1081  
1082 =back
1083  
1084 =over 4
1085  
1086 =item gtlt example 8
1087  
1088 package main;
1089  
1090 use Venus::Float;
1091 use Venus::String;
1092  
1093 my $lvalue = Venus::Float->new;
1094 my $rvalue = Venus::String->new;
1095  
1096 my $result = $lvalue->gtlt($rvalue);
1097  
1098 # 0
1099  
1100 =back
1101  
1102 =over 4
1103  
1104 =item gtlt example 9
1105  
1106 package main;
1107  
1108 use Venus::Float;
1109 use Venus::Undef;
1110  
1111 my $lvalue = Venus::Float->new;
1112 my $rvalue = Venus::Undef->new;
1113  
1114 my $result = $lvalue->gtlt($rvalue);
1115  
1116 # 0
1117  
1118 =back
1119  
1120 =cut
1121  
1122 =head2 le
1123  
1124 le(any $arg) (boolean)
1125  
1126 The le method performs a I<"lesser-than-or-equal-to"> operation using the
1127 argument provided.
1128  
1129 I<Since C<0.08>>
1130  
1131 =over 4
1132  
1133 =item le example 1
1134  
1135 package main;
1136  
1137 use Venus::Array;
1138 use Venus::Float;
1139  
1140 my $lvalue = Venus::Float->new;
1141 my $rvalue = Venus::Array->new;
1142  
1143 my $result = $lvalue->le($rvalue);
1144  
1145 # 1
1146  
1147 =back
1148  
1149 =over 4
1150  
1151 =item le example 2
1152  
1153 package main;
1154  
1155 use Venus::Code;
1156 use Venus::Float;
1157  
1158 my $lvalue = Venus::Float->new;
1159 my $rvalue = Venus::Code->new;
1160  
1161 my $result = $lvalue->le($rvalue);
1162  
1163 # 1
1164  
1165 =back
1166  
1167 =over 4
1168  
1169 =item le example 3
1170  
1171 package main;
1172  
1173 use Venus::Float;
1174  
1175 my $lvalue = Venus::Float->new;
1176 my $rvalue = Venus::Float->new;
1177  
1178 my $result = $lvalue->le($rvalue);
1179  
1180 # 1
1181  
1182 =back
1183  
1184 =over 4
1185  
1186 =item le example 4
1187  
1188 package main;
1189  
1190 use Venus::Float;
1191 use Venus::Hash;
1192  
1193 my $lvalue = Venus::Float->new;
1194 my $rvalue = Venus::Hash->new;
1195  
1196 my $result = $lvalue->le($rvalue);
1197  
1198 # 1
1199  
1200 =back
1201  
1202 =over 4
1203  
1204 =item le example 5
1205  
1206 package main;
1207  
1208 use Venus::Float;
1209 use Venus::Number;
1210  
1211 my $lvalue = Venus::Float->new;
1212 my $rvalue = Venus::Number->new;
1213  
1214 my $result = $lvalue->le($rvalue);
1215  
1216 # 1
1217  
1218 =back
1219  
1220 =over 4
1221  
1222 =item le example 6
1223  
1224 package main;
1225  
1226 use Venus::Float;
1227 use Venus::Regexp;
1228  
1229 my $lvalue = Venus::Float->new;
1230 my $rvalue = Venus::Regexp->new;
1231  
1232 my $result = $lvalue->le($rvalue);
1233  
1234 # 1
1235  
1236 =back
1237  
1238 =over 4
1239  
1240 =item le example 7
1241  
1242 package main;
1243  
1244 use Venus::Float;
1245 use Venus::Scalar;
1246  
1247 my $lvalue = Venus::Float->new;
1248 my $rvalue = Venus::Scalar->new;
1249  
1250 my $result = $lvalue->le($rvalue);
1251  
1252 # 1
1253  
1254 =back
1255  
1256 =over 4
1257  
1258 =item le example 8
1259  
1260 package main;
1261  
1262 use Venus::Float;
1263 use Venus::String;
1264  
1265 my $lvalue = Venus::Float->new;
1266 my $rvalue = Venus::String->new;
1267  
1268 my $result = $lvalue->le($rvalue);
1269  
1270 # 1
1271  
1272 =back
1273  
1274 =over 4
1275  
1276 =item le example 9
1277  
1278 package main;
1279  
1280 use Venus::Float;
1281 use Venus::Undef;
1282  
1283 my $lvalue = Venus::Float->new;
1284 my $rvalue = Venus::Undef->new;
1285  
1286 my $result = $lvalue->le($rvalue);
1287  
1288 # 1
1289  
1290 =back
1291  
1292 =cut
1293  
1294 =head2 lt
1295  
1296 lt(any $arg) (boolean)
1297  
1298 The lt method performs a I<"lesser-than"> operation using the argument provided.
1299  
1300 I<Since C<0.08>>
1301  
1302 =over 4
1303  
1304 =item lt example 1
1305  
1306 package main;
1307  
1308 use Venus::Array;
1309 use Venus::Float;
1310  
1311 my $lvalue = Venus::Float->new;
1312 my $rvalue = Venus::Array->new;
1313  
1314 my $result = $lvalue->lt($rvalue);
1315  
1316 # 1
1317  
1318 =back
1319  
1320 =over 4
1321  
1322 =item lt example 2
1323  
1324 package main;
1325  
1326 use Venus::Code;
1327 use Venus::Float;
1328  
1329 my $lvalue = Venus::Float->new;
1330 my $rvalue = Venus::Code->new;
1331  
1332 my $result = $lvalue->lt($rvalue);
1333  
1334 # 1
1335  
1336 =back
1337  
1338 =over 4
1339  
1340 =item lt example 3
1341  
1342 package main;
1343  
1344 use Venus::Float;
1345  
1346 my $lvalue = Venus::Float->new;
1347 my $rvalue = Venus::Float->new;
1348  
1349 my $result = $lvalue->lt($rvalue);
1350  
1351 # 0
1352  
1353 =back
1354  
1355 =over 4
1356  
1357 =item lt example 4
1358  
1359 package main;
1360  
1361 use Venus::Float;
1362 use Venus::Hash;
1363  
1364 my $lvalue = Venus::Float->new;
1365 my $rvalue = Venus::Hash->new;
1366  
1367 my $result = $lvalue->lt($rvalue);
1368  
1369 # 1
1370  
1371 =back
1372  
1373 =over 4
1374  
1375 =item lt example 5
1376  
1377 package main;
1378  
1379 use Venus::Float;
1380 use Venus::Number;
1381  
1382 my $lvalue = Venus::Float->new;
1383 my $rvalue = Venus::Number->new;
1384  
1385 my $result = $lvalue->lt($rvalue);
1386  
1387 # 0
1388  
1389 =back
1390  
1391 =over 4
1392  
1393 =item lt example 6
1394  
1395 package main;
1396  
1397 use Venus::Float;
1398 use Venus::Regexp;
1399  
1400 my $lvalue = Venus::Float->new;
1401 my $rvalue = Venus::Regexp->new;
1402  
1403 my $result = $lvalue->lt($rvalue);
1404  
1405 # 1
1406  
1407 =back
1408  
1409 =over 4
1410  
1411 =item lt example 7
1412  
1413 package main;
1414  
1415 use Venus::Float;
1416 use Venus::Scalar;
1417  
1418 my $lvalue = Venus::Float->new;
1419 my $rvalue = Venus::Scalar->new;
1420  
1421 my $result = $lvalue->lt($rvalue);
1422  
1423 # 1
1424  
1425 =back
1426  
1427 =over 4
1428  
1429 =item lt example 8
1430  
1431 package main;
1432  
1433 use Venus::Float;
1434 use Venus::String;
1435  
1436 my $lvalue = Venus::Float->new;
1437 my $rvalue = Venus::String->new;
1438  
1439 my $result = $lvalue->lt($rvalue);
1440  
1441 # 0
1442  
1443 =back
1444  
1445 =over 4
1446  
1447 =item lt example 9
1448  
1449 package main;
1450  
1451 use Venus::Float;
1452 use Venus::Undef;
1453  
1454 my $lvalue = Venus::Float->new;
1455 my $rvalue = Venus::Undef->new;
1456  
1457 my $result = $lvalue->lt($rvalue);
1458  
1459 # 0
1460  
1461 =back
1462  
1463 =cut
1464  
1465 =head2 ne
1466  
1467 ne(any $arg) (boolean)
1468  
1469 The ne method performs a I<"not-equal-to"> operation using the argument provided.
1470  
1471 I<Since C<0.08>>
1472  
1473 =over 4
1474  
1475 =item ne example 1
1476  
1477 package main;
1478  
1479 use Venus::Array;
1480 use Venus::Float;
1481  
1482 my $lvalue = Venus::Float->new;
1483 my $rvalue = Venus::Array->new;
1484  
1485 my $result = $lvalue->ne($rvalue);
1486  
1487 # 1
1488  
1489 =back
1490  
1491 =over 4
1492  
1493 =item ne example 2
1494  
1495 package main;
1496  
1497 use Venus::Code;
1498 use Venus::Float;
1499  
1500 my $lvalue = Venus::Float->new;
1501 my $rvalue = Venus::Code->new;
1502  
1503 my $result = $lvalue->ne($rvalue);
1504  
1505 # 1
1506  
1507 =back
1508  
1509 =over 4
1510  
1511 =item ne example 3
1512  
1513 package main;
1514  
1515 use Venus::Float;
1516  
1517 my $lvalue = Venus::Float->new;
1518 my $rvalue = Venus::Float->new;
1519  
1520 my $result = $lvalue->ne($rvalue);
1521  
1522 # 0
1523  
1524 =back
1525  
1526 =over 4
1527  
1528 =item ne example 4
1529  
1530 package main;
1531  
1532 use Venus::Float;
1533 use Venus::Hash;
1534  
1535 my $lvalue = Venus::Float->new;
1536 my $rvalue = Venus::Hash->new;
1537  
1538 my $result = $lvalue->ne($rvalue);
1539  
1540 # 1
1541  
1542 =back
1543  
1544 =over 4
1545  
1546 =item ne example 5
1547  
1548 package main;
1549  
1550 use Venus::Float;
1551 use Venus::Number;
1552  
1553 my $lvalue = Venus::Float->new;
1554 my $rvalue = Venus::Number->new;
1555  
1556 my $result = $lvalue->ne($rvalue);
1557  
1558 # 0
1559  
1560 =back
1561  
1562 =over 4
1563  
1564 =item ne example 6
1565  
1566 package main;
1567  
1568 use Venus::Float;
1569 use Venus::Regexp;
1570  
1571 my $lvalue = Venus::Float->new;
1572 my $rvalue = Venus::Regexp->new;
1573  
1574 my $result = $lvalue->ne($rvalue);
1575  
1576 # 1
1577  
1578 =back
1579  
1580 =over 4
1581  
1582 =item ne example 7
1583  
1584 package main;
1585  
1586 use Venus::Float;
1587 use Venus::Scalar;
1588  
1589 my $lvalue = Venus::Float->new;
1590 my $rvalue = Venus::Scalar->new;
1591  
1592 my $result = $lvalue->ne($rvalue);
1593  
1594 # 1
1595  
1596 =back
1597  
1598 =over 4
1599  
1600 =item ne example 8
1601  
1602 package main;
1603  
1604 use Venus::Float;
1605 use Venus::String;
1606  
1607 my $lvalue = Venus::Float->new;
1608 my $rvalue = Venus::String->new;
1609  
1610 my $result = $lvalue->ne($rvalue);
1611  
1612 # 0
1613  
1614 =back
1615  
1616 =over 4
1617  
1618 =item ne example 9
1619  
1620 package main;
1621  
1622 use Venus::Float;
1623 use Venus::Undef;
1624  
1625 my $lvalue = Venus::Float->new;
1626 my $rvalue = Venus::Undef->new;
1627  
1628 my $result = $lvalue->ne($rvalue);
1629  
1630 # 0
1631  
1632 =back
1633  
1634 =cut
1635  
1636 =head2 new
1637  
1638 new(any @args) (Venus::Float)
1639  
1640 The new method constructs an instance of the package.
1641  
1642 I<Since C<4.15>>
1643  
1644 =over 4
1645  
1646 =item new example 1
1647  
1648 package main;
1649  
1650 use Venus::Float;
1651  
1652 my $new = Venus::Float->new;
1653  
1654 # bless(..., "Venus::Float")
1655  
1656 =back
1657  
1658 =over 4
1659  
1660 =item new example 2
1661  
1662 package main;
1663  
1664 use Venus::Float;
1665  
1666 my $new = Venus::Float->new(1.23);
1667  
1668 # bless(..., "Venus::Float")
1669  
1670 =back
1671  
1672 =over 4
1673  
1674 =item new example 3
1675  
1676 package main;
1677  
1678 use Venus::Float;
1679  
1680 my $new = Venus::Float->new(value => 1.23);
1681  
1682 # bless(..., "Venus::Float")
1683  
1684 =back
1685  
1686 =cut
1687  
1688 =head2 tv
1689  
1690 tv(any $arg) (boolean)
1691  
1692 The tv method performs a I<"type-and-value-equal-to"> operation using argument
1693 provided.
1694  
1695 I<Since C<0.08>>
1696  
1697 =over 4
1698  
1699 =item tv example 1
1700  
1701 package main;
1702  
1703 use Venus::Array;
1704 use Venus::Float;
1705  
1706 my $lvalue = Venus::Float->new;
1707 my $rvalue = Venus::Array->new;
1708  
1709 my $result = $lvalue->tv($rvalue);
1710  
1711 # 0
1712  
1713 =back
1714  
1715 =over 4
1716  
1717 =item tv example 2
1718  
1719 package main;
1720  
1721 use Venus::Code;
1722 use Venus::Float;
1723  
1724 my $lvalue = Venus::Float->new;
1725 my $rvalue = Venus::Code->new;
1726  
1727 my $result = $lvalue->tv($rvalue);
1728  
1729 # 0
1730  
1731 =back
1732  
1733 =over 4
1734  
1735 =item tv example 3
1736  
1737 package main;
1738  
1739 use Venus::Float;
1740  
1741 my $lvalue = Venus::Float->new;
1742 my $rvalue = Venus::Float->new;
1743  
1744 my $result = $lvalue->tv($rvalue);
1745  
1746 # 1
1747  
1748 =back
1749  
1750 =over 4
1751  
1752 =item tv example 4
1753  
1754 package main;
1755  
1756 use Venus::Float;
1757 use Venus::Hash;
1758  
1759 my $lvalue = Venus::Float->new;
1760 my $rvalue = Venus::Hash->new;
1761  
1762 my $result = $lvalue->tv($rvalue);
1763  
1764 # 0
1765  
1766 =back
1767  
1768 =over 4
1769  
1770 =item tv example 5
1771  
1772 package main;
1773  
1774 use Venus::Float;
1775 use Venus::Number;
1776  
1777 my $lvalue = Venus::Float->new;
1778 my $rvalue = Venus::Number->new;
1779  
1780 my $result = $lvalue->tv($rvalue);
1781  
1782 # 0
1783  
1784 =back
1785  
1786 =over 4
1787  
1788 =item tv example 6
1789  
1790 package main;
1791  
1792 use Venus::Float;
1793 use Venus::Regexp;
1794  
1795 my $lvalue = Venus::Float->new;
1796 my $rvalue = Venus::Regexp->new;
1797  
1798 my $result = $lvalue->tv($rvalue);
1799  
1800 # 0
1801  
1802 =back
1803  
1804 =over 4
1805  
1806 =item tv example 7
1807  
1808 package main;
1809  
1810 use Venus::Float;
1811 use Venus::Scalar;
1812  
1813 my $lvalue = Venus::Float->new;
1814 my $rvalue = Venus::Scalar->new;
1815  
1816 my $result = $lvalue->tv($rvalue);
1817  
1818 # 0
1819  
1820 =back
1821  
1822 =over 4
1823  
1824 =item tv example 8
1825  
1826 package main;
1827  
1828 use Venus::Float;
1829 use Venus::String;
1830  
1831 my $lvalue = Venus::Float->new;
1832 my $rvalue = Venus::String->new;
1833  
1834 my $result = $lvalue->tv($rvalue);
1835  
1836 # 0
1837  
1838 =back
1839  
1840 =over 4
1841  
1842 =item tv example 9
1843  
1844 package main;
1845  
1846 use Venus::Float;
1847 use Venus::Undef;
1848  
1849 my $lvalue = Venus::Float->new;
1850 my $rvalue = Venus::Undef->new;
1851  
1852 my $result = $lvalue->tv($rvalue);
1853  
1854 # 0
1855  
1856 =back
1857  
1858 =cut
1859  
1860 =head1 AUTHORS
1861  
1862 Awncorp, C<awncorp@cpan.org>
1863  
1864 =cut
1865  
1866 =head1 LICENSE
1867  
1868 Copyright (C) 2022, Awncorp, C<awncorp@cpan.org>.
1869  
1870 This program is free software, you can redistribute it and/or modify it under
1871 the terms of the Apache license version 2.0.
1872  
1873 =cut
« blib/lib/Venus/Core.pm ↑ Summary blib/lib/Venus/Scalar.pm »