tomoto 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f261799f417a11ff64ca5ece40201469b3ca4d59e1ae7967b744e342476df61e
-  data.tar.gz: 698cbb9b4a51c9bbd4d5b1a2a5bb641d2e0328e32009bb4dc2835eaff164a17d
+  metadata.gz: 7b9dd5706eb7ad70f92f52d3a321d6a9f96fb1b06243170657a722c3e1b99a2d
+  data.tar.gz: 50b3a62afbf79d23cbf2b11956e26fcfb922e26b229a0f82eaf1946d4e86a65f
 SHA512:
-  metadata.gz: fe5e6840fdd9c056747529fd590319390e90c06e273c6f843dae2cd862f2cf17891f3681c5e5fb7442ee7f16c2ae82cc96b7f6d6c8df96269e6993dc6204c9ef
-  data.tar.gz: 57681426bba4aa89a3482955d3b4f40a1dcc2a673d4f5700c12805c1f90d9710923489927dddb33b54f0b14f864ecf14de24768f28d08166c0e0ccdce81e2ffc
+  metadata.gz: ee26d6f9789a461dbcdd2995ab8db74c42cda56abd127af1567b100fbcb14b770942f0f03a5b5d2782475abdaae69f9dabb2aaf31d81ce4ec267870cf78b39e7
+  data.tar.gz: 181ce20d28f143a03964818806caa49f596eb22423302a24b2d0c5f4a53c07f1369aed642ad920b676c12aa4fea3d21599185d4ef66019cbacd36a745728e5f2

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.6.2 (2026-02-21)
+
+- Updated tomoto to 0.14.0
+- Fixed memory leak with `make_doc` method
+
 ## 0.6.1 (2026-01-01)
 
 - Added support for Ruby 4.0

data/ext/tomoto/ct.cpp

@@ -16,7 +16,7 @@ void init_ct(Rice::Module& m) {
         if (seed >= 0) {
           args.seed = seed;
         }
-        return tomoto::ICTModel::create((tomoto::TermWeight)tw, args);
+        return tomoto::ICTModel::create((tomoto::TermWeight)tw, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "_correlations",

data/ext/tomoto/dmr.cpp

@@ -22,7 +22,7 @@ void init_dmr(Rice::Module& m) {
         if (seed >= 0) {
           args.seed = seed;
         }
-        return tomoto::IDMRModel::create((tomoto::TermWeight)tw, args);
+        return tomoto::IDMRModel::create((tomoto::TermWeight)tw, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",

data/ext/tomoto/dt.cpp

@@ -27,7 +27,7 @@ void init_dt(Rice::Module& m) {
         if (seed >= 0) {
           args.seed = seed;
         }
-        return tomoto::IDTModel::create((tomoto::TermWeight)tw, args);
+        return tomoto::IDTModel::create((tomoto::TermWeight)tw, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",

data/ext/tomoto/extconf.rb

@@ -19,25 +19,21 @@ end
 apple_clang = RbConfig::CONFIG["CC_VERSION_MESSAGE"] =~ /apple clang/i
 
 if apple_clang
-  # silence rice warnings
-  $CXXFLAGS += " -Wno-deprecated-declarations"
+  # silence tomoto warnings
+  $CXXFLAGS += " -Wno-switch -Wno-unqualified-std-cast-call -Wno-inconsistent-missing-override"
 else
   # silence eigen warnings
-  $CXXFLAGS += " -Wno-ignored-attributes -Wno-deprecated-copy"
+  $CXXFLAGS += " -Wno-ignored-attributes"
 end
 
-# silence tomoto warnings
-$CXXFLAGS += " -Wno-unused-variable -Wno-switch -Wno-unqualified-std-cast-call"
-
 ext = File.expand_path(".", __dir__)
 tomoto = File.expand_path("../../vendor/tomotopy/src/TopicModel", __dir__)
 tomoto_utils = File.expand_path("../../vendor/tomotopy/src/Utils", __dir__)
 eigen = File.expand_path("../../vendor/eigen", __dir__)
 eigen_rand = File.expand_path("../../vendor/EigenRand", __dir__)
-variant = File.expand_path("../../vendor/variant/include", __dir__)
 
 $srcs = Dir["{#{ext},#{tomoto},#{tomoto_utils}}/*.cpp"]
-$INCFLAGS += " -I#{tomoto} -I#{eigen} -I#{eigen_rand} -I#{variant}"
+$INCFLAGS += " -I#{tomoto} -I#{eigen} -I#{eigen_rand}"
 $VPATH << tomoto
 $VPATH << tomoto_utils
 

data/ext/tomoto/gdmr.cpp

@@ -24,7 +24,7 @@ void init_gdmr(Rice::Module& m) {
         if (seed >= 0) {
           args.seed = seed;
         }
-        return tomoto::IGDMRModel::create((tomoto::TermWeight)tw, args);
+        return tomoto::IGDMRModel::create((tomoto::TermWeight)tw, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",

data/ext/tomoto/hdp.cpp

@@ -17,7 +17,7 @@ void init_hdp(Rice::Module& m) {
         if (seed >= 0) {
           args.seed = seed;
         }
-        return tomoto::IHDPModel::create((tomoto::TermWeight)tw, args);
+        return tomoto::IHDPModel::create((tomoto::TermWeight)tw, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "alpha",

data/ext/tomoto/hlda.cpp

@@ -17,7 +17,7 @@ void init_hlda(Rice::Module& m) {
         if (seed >= 0) {
           args.seed = seed;
         }
-        return tomoto::IHLDAModel::create((tomoto::TermWeight)tw, args);
+        return tomoto::IHLDAModel::create((tomoto::TermWeight)tw, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "alpha",

data/ext/tomoto/hpa.cpp

@@ -17,7 +17,7 @@ void init_hpa(Rice::Module& m) {
         if (seed >= 0) {
           args.seed = seed;
         }
-        return tomoto::IHPAModel::create((tomoto::TermWeight)tw, false, args);
+        return tomoto::IHPAModel::create((tomoto::TermWeight)tw, false, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "alpha",

data/ext/tomoto/lda.cpp

@@ -12,10 +12,36 @@
 
 class DocumentObject {
 public:
-  DocumentObject(const tomoto::DocumentBase* _doc, const tomoto::ITopicModel* _tm) : doc{ _doc }, tm{ _tm } {}
+  DocumentObject(const tomoto::DocumentBase* _doc, const tomoto::ITopicModel* _tm, bool _owner = false) : doc{ _doc }, tm{ _tm }, owner{ _owner } {}
+
+  ~DocumentObject() {
+    if (owner && doc) {
+      delete doc;
+      doc = NULL;
+    }
+  }
+
+  // prevent copy
+  DocumentObject(const DocumentObject&) = delete;
+  DocumentObject& operator=(const DocumentObject&) = delete;
+
+  DocumentObject(DocumentObject&& other) noexcept {
+    *this = std::move(other);
+  }
+
+  DocumentObject& operator=(DocumentObject&& other) noexcept {
+    if (this != &other) {
+      doc = other.doc;
+      tm = other.tm;
+      owner = other.owner;
+      other.owner = false;
+    }
+    return *this;
+  }
 
   const tomoto::DocumentBase* doc;
   const tomoto::ITopicModel* tm;
+  bool owner;
 };
 
 void init_lda(Rice::Module& m) {
@@ -42,7 +68,7 @@ void init_lda(Rice::Module& m) {
         if (seed >= 0) {
           args.seed = seed;
         }
-        return tomoto::ILDAModel::create((tomoto::TermWeight)tw, args);
+        return tomoto::ILDAModel::create((tomoto::TermWeight)tw, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",
@@ -52,7 +78,7 @@ void init_lda(Rice::Module& m) {
     .define_method(
       "_make_doc",
       [](tomoto::ILDAModel& self, std::vector<std::string> words) {
-        return DocumentObject(self.makeDoc(buildDoc(words)).release(), &self);
+        return DocumentObject(self.makeDoc(buildDoc(words)).release(), &self, true);
       })
     .define_method(
       "_infer",

data/ext/tomoto/llda.cpp

@@ -20,7 +20,7 @@ void init_llda(Rice::Module& m) {
         if (seed >= 0) {
           args.seed = seed;
         }
-        return tomoto::ILLDAModel::create((tomoto::TermWeight)tw, args);
+        return tomoto::ILLDAModel::create((tomoto::TermWeight)tw, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",

data/ext/tomoto/mglda.cpp

@@ -23,7 +23,7 @@ void init_mglda(Rice::Module& m) {
         args.alphaML = alpha_ml;
         args.eta = eta_g;
         // TODO more args
-        return tomoto::IMGLDAModel::create((tomoto::TermWeight)tw, args);
+        return tomoto::IMGLDAModel::create((tomoto::TermWeight)tw, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",

data/ext/tomoto/pa.cpp

@@ -17,7 +17,7 @@ void init_pa(Rice::Module& m) {
         if (seed >= 0) {
           args.seed = seed;
         }
-        return tomoto::IPAModel::create((tomoto::TermWeight)tw, args);
+        return tomoto::IPAModel::create((tomoto::TermWeight)tw, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "k1",

data/ext/tomoto/plda.cpp

@@ -20,7 +20,7 @@ void init_plda(Rice::Module& m) {
         if (seed >= 0) {
           args.seed = seed;
         }
-        return tomoto::IPLDAModel::create((tomoto::TermWeight)tw, args);
+        return tomoto::IPLDAModel::create((tomoto::TermWeight)tw, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",

data/ext/tomoto/slda.cpp

@@ -29,7 +29,7 @@ void init_slda(Rice::Module& m) {
         if (seed >= 0) {
           args.seed = seed;
         }
-        return tomoto::ISLDAModel::create((tomoto::TermWeight)tw, args);
+        return tomoto::ISLDAModel::create((tomoto::TermWeight)tw, args).release();
       }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",

data/lib/tomoto/lda.rb

@@ -11,6 +11,7 @@ module Tomoto
     def self.load(filename)
       model = new
       model._load(filename)
+      model.instance_variable_set(:@prepared, true)
       model
     end
 

data/lib/tomoto/version.rb

@@ -1,3 +1,3 @@
 module Tomoto
-  VERSION = "0.6.1"
+  VERSION = "0.6.2"
 end

data/vendor/EigenRand/EigenRand/Core.h

@@ -2,10 +2,10 @@
  * @file Core.h
  * @author bab2min (bab2min@gmail.com)
  * @brief 
- * @version 0.4.1
- * @date 2022-08-13
- * 
- * @copyright Copyright (c) 2020-2021
+ * @version 0.5.1
+ * @date 2024-09-08
+ *
+ * @copyright Copyright (c) 2020-2024
  * 
  */
 
@@ -15,6 +15,8 @@
 
 #include "RandUtils.h"
 
+#include "CwiseHeteroBinaryOp.h"
+
 #include "Dists/Basic.h"
 #include "Dists/Discrete.h"
 #include "Dists/NormalExp.h"

data/vendor/EigenRand/EigenRand/CwiseHeteroBinaryOp.h

@@ -0,0 +1,265 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_HETERO_BINARY_OP_H
+#define EIGEN_CWISE_HETERO_BINARY_OP_H
+
+namespace Eigen {
+    
+    template<typename BinaryOp, typename LhsType, typename RhsType>
+    class CwiseHeteroBinaryOp;
+
+    namespace internal {
+        template<typename BinaryOp, typename Lhs, typename Rhs>
+        struct traits<CwiseHeteroBinaryOp<BinaryOp, Lhs, Rhs> >
+        {
+            // we must not inherit from traits<Lhs> since it has
+            // the potential to cause problems with MSVC
+            typedef typename remove_all<Lhs>::type Ancestor;
+            typedef typename traits<Ancestor>::XprKind XprKind;
+            enum {
+                RowsAtCompileTime = traits<Ancestor>::RowsAtCompileTime,
+                ColsAtCompileTime = traits<Ancestor>::ColsAtCompileTime,
+                MaxRowsAtCompileTime = traits<Ancestor>::MaxRowsAtCompileTime,
+                MaxColsAtCompileTime = traits<Ancestor>::MaxColsAtCompileTime
+            };
+
+            // even though we require Lhs and Rhs to have the same scalar type (see CwiseHeteroBinaryOp constructor),
+            // we still want to handle the case when the result type is different.
+            typedef typename result_of<
+                BinaryOp(
+                    const typename Lhs::Scalar&,
+                    const typename Rhs::Scalar&
+                )
+            >::type Scalar;
+            typedef typename cwise_promote_storage_type<typename traits<Lhs>::StorageKind,
+                typename traits<Rhs>::StorageKind,
+                BinaryOp>::ret StorageKind;
+            typedef typename promote_index_type<typename traits<Lhs>::StorageIndex,
+                typename traits<Rhs>::StorageIndex>::type StorageIndex;
+            typedef typename Lhs::Nested LhsNested;
+            typedef typename Rhs::Nested RhsNested;
+            typedef typename remove_reference<LhsNested>::type _LhsNested;
+            typedef typename remove_reference<RhsNested>::type _RhsNested;
+            enum {
+                Flags = cwise_promote_storage_order<typename traits<Lhs>::StorageKind, typename traits<Rhs>::StorageKind, _LhsNested::Flags& RowMajorBit, _RhsNested::Flags& RowMajorBit>::value
+            };
+        };
+    } // end namespace internal
+
+    template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind>
+    class CwiseHeteroBinaryOpImpl;
+
+    /** \class CwiseHeteroBinaryOp
+      * \ingroup Core_Module
+      *
+      * \brief Generic expression where a coefficient-wise binary operator is applied to two expressions
+      *
+      * \tparam BinaryOp template functor implementing the operator
+      * \tparam LhsType the type of the left-hand side
+      * \tparam RhsType the type of the right-hand side
+      *
+      * This class represents an expression  where a coefficient-wise binary operator is applied to two expressions.
+      * It is the return type of binary operators, by which we mean only those binary operators where
+      * both the left-hand side and the right-hand side are Eigen expressions.
+      * For example, the return type of matrix1+matrix2 is a CwiseHeteroBinaryOp.
+      *
+      * Most of the time, this is the only way that it is used, so you typically don't have to name
+      * CwiseHeteroBinaryOp types explicitly.
+      *
+      * \sa MatrixBase::binaryExpr(const MatrixBase<OtherDerived> &,const CustomBinaryOp &) const, class CwiseUnaryOp, class CwiseNullaryOp
+      */
+    template<typename BinaryOp, typename LhsType, typename RhsType>
+    class CwiseHeteroBinaryOp :
+        public CwiseHeteroBinaryOpImpl<
+        BinaryOp, LhsType, RhsType,
+        typename internal::cwise_promote_storage_type<typename internal::traits<LhsType>::StorageKind,
+        typename internal::traits<RhsType>::StorageKind,
+        BinaryOp>::ret>,
+        internal::no_assignment_operator
+    {
+    public:
+
+        typedef typename internal::remove_all<BinaryOp>::type Functor;
+        typedef typename internal::remove_all<LhsType>::type Lhs;
+        typedef typename internal::remove_all<RhsType>::type Rhs;
+
+        typedef typename CwiseHeteroBinaryOpImpl<
+            BinaryOp, LhsType, RhsType,
+            typename internal::cwise_promote_storage_type<typename internal::traits<LhsType>::StorageKind,
+            typename internal::traits<Rhs>::StorageKind,
+            BinaryOp>::ret>::Base Base;
+        EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseHeteroBinaryOp)
+
+            typedef typename internal::ref_selector<LhsType>::type LhsNested;
+        typedef typename internal::ref_selector<RhsType>::type RhsNested;
+        typedef typename internal::remove_reference<LhsNested>::type _LhsNested;
+        typedef typename internal::remove_reference<RhsNested>::type _RhsNested;
+
+#if EIGEN_COMP_MSVC && EIGEN_HAS_CXX11
+        //Required for Visual Studio or the Copy constructor will probably not get inlined!
+        EIGEN_STRONG_INLINE
+            CwiseHeteroBinaryOp(const CwiseHeteroBinaryOp<BinaryOp, LhsType, RhsType>&) = default;
+#endif
+
+        EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+            CwiseHeteroBinaryOp(const Lhs& aLhs, const Rhs& aRhs, const BinaryOp& func = BinaryOp())
+            : m_lhs(aLhs), m_rhs(aRhs), m_functor(func)
+        {
+            // require the sizes to match
+            EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs)
+                eigen_assert(aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols());
+        }
+
+        EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr
+            Index rows() const EIGEN_NOEXCEPT {
+            // return the fixed size type if available to enable compile time optimizations
+            return internal::traits<typename internal::remove_all<LhsNested>::type>::RowsAtCompileTime == Dynamic ? m_rhs.rows() : m_lhs.rows();
+        }
+        EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr
+            Index cols() const EIGEN_NOEXCEPT {
+            // return the fixed size type if available to enable compile time optimizations
+            return internal::traits<typename internal::remove_all<LhsNested>::type>::ColsAtCompileTime == Dynamic ? m_rhs.cols() : m_lhs.cols();
+        }
+
+        /** \returns the left hand side nested expression */
+        EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+            const _LhsNested& lhs() const { return m_lhs; }
+        /** \returns the right hand side nested expression */
+        EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+            const _RhsNested& rhs() const { return m_rhs; }
+        /** \returns the functor representing the binary operation */
+        EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+            const BinaryOp& functor() const { return m_functor; }
+
+    protected:
+        LhsNested m_lhs;
+        RhsNested m_rhs;
+        const BinaryOp m_functor;
+    };
+
+    // Generic API dispatcher
+    template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind>
+    class CwiseHeteroBinaryOpImpl
+        : public internal::generic_xpr_base<CwiseHeteroBinaryOp<BinaryOp, Lhs, Rhs> >::type
+    {
+    public:
+        typedef typename internal::generic_xpr_base<CwiseHeteroBinaryOp<BinaryOp, Lhs, Rhs> >::type Base;
+    };
+
+
+    namespace internal {
+        // -------------------- CwiseHeteroBinaryOp --------------------
+
+        // this is a binary expression
+        template<typename BinaryOp, typename Lhs, typename Rhs>
+        struct evaluator<CwiseHeteroBinaryOp<BinaryOp, Lhs, Rhs> >
+            : public binary_evaluator<CwiseHeteroBinaryOp<BinaryOp, Lhs, Rhs> >
+        {
+            typedef CwiseHeteroBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+            typedef binary_evaluator<CwiseHeteroBinaryOp<BinaryOp, Lhs, Rhs> > Base;
+
+            EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+                explicit evaluator(const XprType& xpr) : Base(xpr) {}
+        };
+
+        template<typename BinaryOp, typename Lhs, typename Rhs>
+        struct binary_evaluator<CwiseHeteroBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IndexBased>
+            : evaluator_base<CwiseHeteroBinaryOp<BinaryOp, Lhs, Rhs> >
+        {
+            typedef CwiseHeteroBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+            using LhsScalar = typename Lhs::Scalar;
+            using RhsScalar = typename Rhs::Scalar;
+
+            enum {
+                CoeffReadCost = int(evaluator<Lhs>::CoeffReadCost) + int(evaluator<Rhs>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+
+                LhsFlags = evaluator<Lhs>::Flags,
+                RhsFlags = evaluator<Rhs>::Flags,
+                SameType = is_same<typename Lhs::Scalar, typename Rhs::Scalar>::value,
+                StorageOrdersAgree = (int(LhsFlags) & RowMajorBit) == (int(RhsFlags) & RowMajorBit),
+                Flags0 = (int(LhsFlags) | int(RhsFlags)) & (
+                    HereditaryBits
+                    | (int(LhsFlags) & int(RhsFlags) &
+                        ((StorageOrdersAgree ? LinearAccessBit : 0)
+                            | (functor_traits<BinaryOp>::PacketAccess && StorageOrdersAgree ? PacketAccessBit : 0)
+                            )
+                        )
+                    ),
+                Flags = (Flags0 & ~RowMajorBit) | (LhsFlags & RowMajorBit),
+                Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<Lhs>::Alignment, evaluator<Rhs>::Alignment)
+            };
+
+            EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+                explicit binary_evaluator(const XprType& xpr) : m_d(xpr)
+            {
+                EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+                EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+            }
+
+            typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+            EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+                CoeffReturnType coeff(Index row, Index col) const
+            {
+                return m_d.func()(m_d.lhsImpl.coeff(row, col), m_d.rhsImpl.coeff(row, col));
+            }
+
+            EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+                CoeffReturnType coeff(Index index) const
+            {
+                return m_d.func()(m_d.lhsImpl.coeff(index), m_d.rhsImpl.coeff(index));
+            }
+
+            template<int LoadMode, typename PacketType>
+            EIGEN_STRONG_INLINE
+                PacketType packet(Index row, Index col) const
+            {
+                using IPacketType = decltype(reinterpret_to_float(std::declval<PacketType>()));
+                using FPacketType = decltype(reinterpret_to_float(std::declval<PacketType>()));
+                using RhsPacket = typename std::conditional<std::is_same<RhsScalar, float>::value, FPacketType, IPacketType>::type;
+
+                return m_d.func().packetOp(m_d.lhsImpl.template packet<LoadMode, PacketType>(row, col),
+                    m_d.rhsImpl.template packet<LoadMode, RhsPacket>(row, col));
+            }
+
+            template<int LoadMode, typename PacketType>
+            EIGEN_STRONG_INLINE
+                PacketType packet(Index index) const
+            {
+                using IPacketType = decltype(reinterpret_to_float(std::declval<PacketType>()));
+                using FPacketType = decltype(reinterpret_to_float(std::declval<PacketType>()));
+                using RhsPacket = typename std::conditional<std::is_same<RhsScalar, float>::value, FPacketType, IPacketType>::type;
+
+                return m_d.func().packetOp(m_d.lhsImpl.template packet<LoadMode, PacketType>(index),
+                    m_d.rhsImpl.template packet<LoadMode, RhsPacket>(index));
+            }
+
+        protected:
+
+            // this helper permits to completely eliminate the functor if it is empty
+            struct Data
+            {
+                EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+                    Data(const XprType& xpr) : op(xpr.functor()), lhsImpl(xpr.lhs()), rhsImpl(xpr.rhs()) {}
+                EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+                    const BinaryOp& func() const { return op; }
+                BinaryOp op;
+                evaluator<Lhs> lhsImpl;
+                evaluator<Rhs> rhsImpl;
+            };
+
+            Data m_d;
+        };
+    }
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_HETERO_BINARY_OP_H