Ticket #481: PCA-patch-003.patch

src/ops/set.ops

@@ -40 +40 @@
 
 =item B<set>(out INT, in NUM)
 
+A floating-point number is truncated (rounded toward zero) when assigned
+to an integer register.
+
 =item B<set>(out INT, invar PMC)
 
 =item B<set>(out INT, invar PMC)

src/dynoplibs/trans.ops

@@ -105 +105 @@
 
 ########################################
 
+=item B<cot>(out NUM, in NUM)
+
+Set $1 to the cotangent of $2 (given in radians).
+
+=cut
+
+inline op cot(out NUM, in NUM) :base_math {
+    $1 = ((FLOATVAL)1) / tan((FLOATVAL)$2);
+}
+
+########################################
+
+=item B<csc>(out NUM, in NUM)
+
+Set $1 to the cosecant of $2 (given in radians).
+
+=cut
+
+inline op csc(out NUM, in NUM) :base_math {
+    $1 = ((FLOATVAL)1) / sin((FLOATVAL)$2);
+}
+
+########################################
+
 =item B<exp>(out NUM, in NUM)
 
 Set $1 to I<e> raised to the power $2. I<e> is the base of the natural

src/pmc/float.pmc

@@ -77 +77 @@
 
 =item C<INTVAL get_integer()>
 
-Returns an integer representation of the number (by casting).
+Returns an integer representation of the number by truncating
+(rounding toward zero).
 
 =cut
 
@@ -391 +392 @@
 
 =item C<METHOD PMC *cosh()>
 
+=item C<METHOD PMC *cot()>
+
+=item C<METHOD PMC *csc()>
+
 =item C<METHOD PMC *exp()>
 
 =item C<METHOD PMC *ln()>
@@ -425 +430 @@
         RETURN(PMC *d);
     }
 
-    METHOD cos() {
-        PMC * const d  = Parrot_pmc_new(INTERP,
-                Parrot_get_ctx_HLL_type(INTERP, enum_class_Float));
-        SET_ATTR_fv(INTERP, d, cos(SELF.get_number()));
-        RETURN(PMC *d);
-    }
-
     METHOD asec() {
         PMC * const d  = Parrot_pmc_new(INTERP, VTABLE_type(INTERP, SELF));
         SET_ATTR_fv(INTERP, d, acos(1.0 / SELF.get_number()));
@@ -456 +454 @@
         RETURN(PMC *d);
     }
 
+    METHOD cos() {
+        PMC * const d  = Parrot_pmc_new(INTERP,
+                Parrot_get_ctx_HLL_type(INTERP, enum_class_Float));
+        SET_ATTR_fv(INTERP, d, cos(SELF.get_number()));
+        RETURN(PMC *d);
+    }
+
     METHOD cosh() {
         PMC * const d  = Parrot_pmc_new(INTERP, VTABLE_type(INTERP, SELF));
         SET_ATTR_fv(INTERP, d, cosh(SELF.get_number()));
         RETURN(PMC *d);
     }
 
+    METHOD cot() {
+        PMC * const d  = Parrot_pmc_new(INTERP, VTABLE_type(INTERP, SELF));
+        SET_ATTR_fv(INTERP, d, 1.0 / tan(SELF.get_number()));
+        RETURN(PMC *d);
+    }
+
+    METHOD csc() {
+        PMC * const d  = Parrot_pmc_new(INTERP, VTABLE_type(INTERP, SELF));
+        SET_ATTR_fv(INTERP, d, 1.0 / sin(SELF.get_number()));
+        RETURN(PMC *d);
+    }
+
     METHOD exp() {
         PMC * const d  = Parrot_pmc_new(INTERP, VTABLE_type(INTERP, SELF));
         SET_ATTR_fv(INTERP, d, exp(SELF.get_number()));

t/pmc/float.t

@@ -16 +16 @@
 
 =cut
 
-.const int TESTS = 162
+.const int TESTS = 166
 .const num PRECISION = 0.000001
 
 .sub 'test' :main
@@ -78 +78 @@
     log10_method()
     log2_method()
     sec_method()
+    csc_method()
     sech_method()
     sin_method()
     sinh_method()
     tan_method()
+    cot_method()
     tanh_method()
     sqrt_method()
 .end
@@ -998 +1000 @@
     test_method('sec', 0.5, 1.139493927)
 .end
 
+.sub 'csc_method'
+    test_method('csc', 0.5, 2.0858296)
+    test_method('csc', 1.0, 1.1883951)
+.end
+
 .sub 'sech_method'
     test_method('sech', 0.0, 1.0)
     test_method('sech', 0.5, 0.886818884)
@@ -1018 +1025 @@
     test_method('tan', 0.5, 0.546302490)
 .end
 
+.sub 'cot_method'
+    test_method('cot', 0.5, 1.8304877)
+    test_method('cot', 1.0, 0.64209262)
+.end
+
 .sub 'tanh_method'
     test_method('tanh', 0.0, 0.0)
     test_method('tanh', 0.5, 0.462117157)

t/dynoplibs/trans.t

@@ -23 +23 @@
     .local num epsilon
     epsilon = _epsilon()
 
-    plan(69)
+    plan(77)
 
     test_sin_n(epsilon)
     test_sin_i(epsilon)
@@ -31 +31 @@
     test_cos_i(epsilon)
     test_tan_n(epsilon)
     test_tan_i(epsilon)
+    test_cot_n(epsilon)
+    test_cot_i(epsilon)
     test_sec_n(epsilon)
     test_sec_i(epsilon)
+    test_csc_n(epsilon)
+    test_csc_i(epsilon)
     test_atan_n(epsilon)
     test_atan_i(epsilon)
     test_asin_n(epsilon)
@@ -137 +141 @@
     is($N0, 1.557408, "tan(1)", epsilon)
 .end
 
+.sub test_cot_n
+    .param num epsilon
+
+    $N0 = cot 0.5
+    is($N0,  1.8305, "cot(0.5)", epsilon)
+
+    $N0 = cot 1.0
+    is($N0,  0.64209, "cot(1.0)", epsilon)
+.end
+
+.sub test_cot_i
+    .param num epsilon
+
+    $N0 = cot 1
+    is($N0, 0.64209, "cot(1)", epsilon)
+
+    $N0 = cot 2
+    is($N0,  -0.45766, "cot(2)", epsilon)
+.end
+
 .sub test_sec_n
     .param num epsilon
 
@@ -153 +177 @@
     is($N1, 1.850816, "sec(1)", epsilon)
 .end
 
+.sub test_csc_n
+    .param num epsilon
+
+    $N0 = csc 0.5
+    is($N0,   2.0858, "csc(0.5)", epsilon)
+
+    $N0 = csc 1.0
+    is($N0,  1.1884, "csc(1.0)", epsilon)
+.end
+
+.sub test_csc_i
+    .param num epsilon
+
+    $N0 = csc 1
+    is($N0, 1.1884, "csc(1)", epsilon)
+
+    $N0 = csc 2
+    is($N0,   1.0998, "csc(2)", epsilon)
+.end
+
 .sub test_atan_n
     .param num epsilon
 

t/dynoplibs/trans-infnan.t

@@ -20 +20 @@
 
 .sub main :main
     .include 'test_more.pir'
-    plan(67)
+    plan(70)
 
     test_exp()
     test_sin()
@@ -36 +36 @@
     test_coth()
     test_acot()
     test_sec()
+    test_csc()
     test_sech()
     test_asec()
     test_ln()
@@ -232 +233 @@
     is($N1, 'NaN', '... sec NaN')
 .end
 
+.sub test_csc
+    $N0 = 'Inf'
+    $N1 = csc $N0
+    is($N1, 'NaN', 'csc: csc Inf')
+    $N0 = '-Inf'
+    $N1 = csc $N0
+    is($N1, 'NaN', '... csc -Inf')
+    $N0 = 'NaN'
+    $N1 = csc $N0
+    is($N1, 'NaN', '... csc NaN')
+.end
+
 .sub test_sech
     $N0 = 'Inf'
     $N1 = sech $N0
@@ -295 +308 @@
     is($N1, 'NaN', '... log2 -Inf')
 .end
 
-
 .sub test_cot
     $N0 = 'Inf'
-    #$N1 = cot $N0
-    #is($N1, 'NaN', 'cot: cot Inf')
-    todo(0, 'cot Inf', 'cot/coth/acot not implemented for real numbers')
+    $N1 = cot $N0
+    is($N1, 'NaN', 'cot: cot Inf')
     $N0 = '-Inf'
-    #$N1 = cot $N0
-    #is($N1, 'NaN', '... cot -Inf')
-    todo(0, 'cot -Inf', 'cot/coth/acot not implemented for real numbers')
+    $N1 = cot $N0
+    is($N1, 'NaN', '... cot -Inf')
     $N0 = 'NaN'
-    #$N1 = cot $N0
-    #is($N1, 'NaN', '... cot NaN')
-    todo(0, 'cot NaN', 'cot/coth/acot not implemented for real numbers')
+    $N1 = cot $N0
+    is($N1, 'NaN', '... cot NaN')
 .end
 
 .sub test_pow