fix operators/times.h

Author: Enchufa2

inst/include/Rcpp/sugar/operators/times.h

@@ -2,7 +2,8 @@
 //
 // times.h: Rcpp R/C++ interface class library -- operator*
 //
-// Copyright (C) 2010 - 2011 Dirk Eddelbuettel and Romain Francois
+// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois
+// Copyright (C) 2026        Dirk Eddelbuettel, Romain Francois and Iñaki Ucar
 //
 // This file is part of Rcpp.
 //
@@ -43,7 +44,7 @@ namespace sugar{
 			STORAGE lhs_ = lhs[i] ;
 			if( traits::is_na<RTYPE>(lhs_) ) return lhs_ ;
 			STORAGE rhs_ = rhs[i] ;
-			return traits::is_na<RTYPE>(rhs_) ? rhs_ : (lhs_ * rhs_) ;
+			return traits::is_na<RTYPE>(rhs_) ? rhs_ : RCPP_SAFE_MUL(lhs_, rhs_) ;
 		}
 
 		inline R_xlen_t size() const { return lhs.size() ; }
@@ -96,7 +97,7 @@ namespace sugar{
 		inline STORAGE operator[]( R_xlen_t i ) const {
 			STORAGE rhs_ = rhs[i] ;
 			if( traits::is_na<RTYPE>(rhs_) ) return rhs_ ;
-			return lhs[i] * rhs_  ;
+			return RCPP_SAFE_MUL(lhs[i], rhs_);
 		}
 
 		inline R_xlen_t size() const { return lhs.size() ; }
@@ -148,7 +149,7 @@ namespace sugar{
 		inline STORAGE operator[]( R_xlen_t i ) const {
 			STORAGE lhs_ = lhs[i] ;
 			if( traits::is_na<RTYPE>(lhs_) ) return lhs_ ;
-			return lhs_ * rhs[i]  ;
+			return RCPP_SAFE_MUL(lhs_, rhs[i]);
 		}
 
 		inline R_xlen_t size() const { return lhs.size() ; }
@@ -197,7 +198,7 @@ namespace sugar{
 			lhs(lhs_.get_ref()), rhs(rhs_.get_ref()){}
 
 		inline STORAGE operator[]( R_xlen_t i ) const {
-			return lhs[i] * rhs[i]  ;
+			return RCPP_SAFE_MUL(lhs[i], rhs[i]);
 		}
 
 		inline R_xlen_t size() const { return lhs.size() ; }
@@ -247,7 +248,7 @@ namespace sugar{
 		inline STORAGE operator[]( R_xlen_t i ) const {
 			if( rhs_na ) return rhs ;
 			STORAGE x = lhs[i] ;
-			return Rcpp::traits::is_na<RTYPE>(x) ? x : (x * rhs) ;
+			return Rcpp::traits::is_na<RTYPE>(x) ? x : RCPP_SAFE_MUL(x, rhs) ;
 		}
 
 		inline R_xlen_t size() const { return lhs.size() ; }
@@ -293,7 +294,7 @@ namespace sugar{
 			lhs(lhs_.get_ref()), rhs(rhs_), rhs_na( Rcpp::traits::is_na<RTYPE>(rhs_) ) {}
 
 		inline STORAGE operator[]( R_xlen_t i ) const {
-			return rhs_na ? rhs : (rhs * lhs[i] ) ;
+			return rhs_na ? rhs : (rhs * lhs[i]);
 		}
 
 		inline R_xlen_t size() const { return lhs.size() ; }
@@ -345,7 +346,7 @@ namespace sugar{
 
 		inline STORAGE operator[]( R_xlen_t i ) const {
 			STORAGE x = lhs[i] ;
-			return Rcpp::traits::is_na<RTYPE>(x) ? x : (x * rhs) ;
+			return Rcpp::traits::is_na<RTYPE>(x) ? x : RCPP_SAFE_MUL(x, rhs);
 		}
 
 		inline R_xlen_t size() const { return lhs.size() ; }
@@ -391,7 +392,7 @@ namespace sugar{
 			lhs(lhs_.get_ref()), rhs(rhs_) {}
 
 		inline STORAGE operator[]( R_xlen_t i ) const {
-			return rhs * lhs[i] ;
+			return RCPP_SAFE_MUL(rhs, lhs[i]);
 		}
 
 		inline R_xlen_t size() const { return lhs.size() ; }

inst/tinytest/cpp/sugar.cpp

@@ -348,6 +348,15 @@ List runit_minus_seqlen(){
     ) ;
 }
 
+// [[Rcpp::export]]
+List runit_times_seqlen(){
+    return List::create(
+        seq_len(10) * 10,
+        10 * seq_len(10),
+        seq_len(10) * seq_len(10)
+    ) ;
+}
+
 // [[Rcpp::export]]
 LogicalVector runit_plus_all( IntegerVector xx ){
     return all( (xx+xx) < 10 ) ;
@@ -467,6 +476,21 @@ List runit_times( IntegerVector xx ){
     ) ;
 }
 
+// [[Rcpp::export]]
+IntegerVector runit_times_ivv( IntegerVector x, IntegerVector y ){
+    return x * y;
+}
+
+// [[Rcpp::export]]
+IntegerVector runit_times_ivp( IntegerVector x, int y ){
+    return x * y;
+}
+
+// [[Rcpp::export]]
+IntegerVector runit_times_ipv( int x, IntegerVector y ){
+    return x * y;
+}
+
 // [[Rcpp::export]]
 List runit_divides( NumericVector xx ){
     return List::create(

inst/tinytest/test_sugar.R

@@ -485,12 +485,20 @@ expect_equal(fx( seq(-10, 10, length.out = 51), -25:25 ),
 
 
 #    test.sugar.times <- function( ){
+expect_error(runit_times_ivv(.Machine$integer.max, 2), "overflow")
+expect_error(runit_times_ivp(.Machine$integer.max, 2), "overflow")
+expect_error(runit_times_ipv(.Machine$integer.max, 2), "overflow")
 fx <- runit_times
 expect_equal(fx(1:10) ,
              list(10L*(1:10), 10L*(1:10), (1:10)*(1:10), (1:10)*(1:10)*(1:10),
                   c(NA,(2:10)*(2:10)), c(NA,10L*(2:10)), c(NA,10L*(2:10)), rep( NA_integer_, 10L )))
 
 
+#    test.sugar.times.seqlen <- function( ){
+fx <- runit_times_seqlen
+expect_equal( fx() , list( seq(10, 100, 10), seq(10, 100, 10), 1:10*1:10) )
+
+
 #    test.sugar.divides <- function( ){
 fx <- runit_divides
 expect_equal(fx(1:10) ,