Graybyt3 Was Here

FreeBSD Web03.ClusterA.securedomainservice.net 13.5-RELEASE-p6 FreeBSD 13.5-RELEASE-p6 GENERIC amd64
LiteSpeed
62.50.189.236

File Name : TensorUInt128.h

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@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_CXX11_TENSOR_TENSOR_UINT128_H
#define EIGEN_CXX11_TENSOR_TENSOR_UINT128_H

namespace Eigen {
namespace internal {

template <uint64_t n>
struct static_val {
  static const uint64_t value = n;
  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE operator uint64_t() const { return n; }

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static_val() { }

template <typename T>
  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static_val(const T& v) {
    EIGEN_UNUSED_VARIABLE(v);
    eigen_assert(v == n);
  }
};

template <typename HIGH = uint64_t, typename LOW = uint64_t>
struct TensorUInt128
{
  HIGH high;
  LOW low;

template<typename OTHER_HIGH, typename OTHER_LOW>
  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
  TensorUInt128(const TensorUInt128<OTHER_HIGH, OTHER_LOW>& other) : high(other.high), low(other.low) {
    EIGEN_STATIC_ASSERT(sizeof(OTHER_HIGH) <= sizeof(HIGH), YOU_MADE_A_PROGRAMMING_MISTAKE);
    EIGEN_STATIC_ASSERT(sizeof(OTHER_LOW) <= sizeof(LOW), YOU_MADE_A_PROGRAMMING_MISTAKE);
  }

template<typename OTHER_HIGH, typename OTHER_LOW>
  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
  TensorUInt128& operator = (const TensorUInt128<OTHER_HIGH, OTHER_LOW>& other) {
    EIGEN_STATIC_ASSERT(sizeof(OTHER_HIGH) <= sizeof(HIGH), YOU_MADE_A_PROGRAMMING_MISTAKE);
    EIGEN_STATIC_ASSERT(sizeof(OTHER_LOW) <= sizeof(LOW), YOU_MADE_A_PROGRAMMING_MISTAKE);
    high = other.high;
    low = other.low;
    return *this;
  }

template<typename T>
  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
  explicit TensorUInt128(const T& x) : high(0), low(x) {
    eigen_assert((static_cast<typename conditional<sizeof(T) == 8, uint64_t, uint32_t>::type>(x) <= NumTraits<uint64_t>::highest()));
    eigen_assert(x >= 0);
  }

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
  TensorUInt128(HIGH y, LOW x) : high(y), low(x) { }

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE operator LOW() const {
    return low;
  }
  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE LOW lower() const {
    return low;
  }
  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE HIGH upper() const {
    return high;
  }
};

template <typename HL, typename LL, typename HR, typename LR>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool operator == (const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs)
{
  return (lhs.high == rhs.high) & (lhs.low == rhs.low);
}

template <typename HL, typename LL, typename HR, typename LR>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool operator != (const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs)
{
  return (lhs.high != rhs.high) | (lhs.low != rhs.low);
}

template <typename HL, typename LL, typename HR, typename LR>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool operator >= (const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs)
{
  if (lhs.high != rhs.high) {
    return lhs.high > rhs.high;
  }
  return lhs.low >= rhs.low;
}

template <typename HL, typename LL, typename HR, typename LR>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
bool operator < (const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs)
{
  if (lhs.high != rhs.high) {
    return lhs.high < rhs.high;
  }
  return lhs.low < rhs.low;
}

template <typename HL, typename LL, typename HR, typename LR>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
TensorUInt128<uint64_t, uint64_t> operator + (const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs)
{
  TensorUInt128<uint64_t, uint64_t> result(lhs.high + rhs.high, lhs.low + rhs.low);
  if (result.low < rhs.low) {
    result.high += 1;
  }
  return result;
}

template <typename HL, typename LL, typename HR, typename LR>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
TensorUInt128<uint64_t, uint64_t> operator - (const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs)
{
  TensorUInt128<uint64_t, uint64_t> result(lhs.high - rhs.high, lhs.low - rhs.low);
  if (result.low > lhs.low) {
    result.high -= 1;
  }
  return result;
}

template <typename HL, typename LL, typename HR, typename LR>
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
TensorUInt128<uint64_t, uint64_t> operator * (const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs)
{
  // Split each 128-bit integer into 4 32-bit integers, and then do the
  // multiplications by hand as follow:
  //   lhs      a  b  c  d
  //   rhs      e  f  g  h
  //           -----------
  //           ah bh ch dh
  //           bg cg dg
  //           cf df
  //           de
  // The result is stored in 2 64bit integers, high and low.

const uint64_t LOW = 0x00000000FFFFFFFFLL;
  const uint64_t HIGH = 0xFFFFFFFF00000000LL;

uint64_t d = lhs.low & LOW;
  uint64_t c = (lhs.low & HIGH) >> 32LL;
  uint64_t b = lhs.high & LOW;
  uint64_t a = (lhs.high & HIGH) >> 32LL;

uint64_t h = rhs.low & LOW;
  uint64_t g = (rhs.low & HIGH) >> 32LL;
  uint64_t f = rhs.high & LOW;
  uint64_t e = (rhs.high & HIGH) >> 32LL;

// Compute the low 32 bits of low
  uint64_t acc = d * h;
  uint64_t low = acc & LOW;
  //  Compute the high 32 bits of low. Add a carry every time we wrap around
  acc >>= 32LL;
  uint64_t carry = 0;
  uint64_t acc2 = acc + c * h;
  if (acc2 < acc) {
    carry++;
  }
  acc = acc2 + d * g;
  if (acc < acc2) {
    carry++;
  }
  low |= (acc << 32LL);

// Carry forward the high bits of acc to initiate the computation of the
  // low 32 bits of high
  acc2 = (acc >> 32LL) | (carry << 32LL);
  carry = 0;

acc = acc2 + b * h;
  if (acc < acc2) {
    carry++;
  }
  acc2 = acc + c * g;
  if (acc2 < acc) {
    carry++;
  }
  acc = acc2 + d * f;
  if (acc < acc2) {
    carry++;
  }
  uint64_t high = acc & LOW;

// Start to compute the high 32 bits of high.
  acc2 = (acc >> 32LL) | (carry << 32LL);

acc = acc2 + a * h;
  acc2 = acc + b * g;
  acc = acc2 + c * f;
  acc2 = acc + d * e;
  high |= (acc2 << 32LL);

return TensorUInt128<uint64_t, uint64_t>(high, low);
}

template <typename HL, typename LL, typename HR, typename LR>
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
TensorUInt128<uint64_t, uint64_t> operator / (const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs)
{
  if (rhs == TensorUInt128<static_val<0>, static_val<1> >(1)) {
    return TensorUInt128<uint64_t, uint64_t>(lhs.high, lhs.low);
  } else if (lhs < rhs) {
    return TensorUInt128<uint64_t, uint64_t>(0);
  } else {
    // calculate the biggest power of 2 times rhs that's less than or equal to lhs
    TensorUInt128<uint64_t, uint64_t> power2(1);
    TensorUInt128<uint64_t, uint64_t> d(rhs);
    TensorUInt128<uint64_t, uint64_t> tmp(lhs - d);
    while (lhs >= d) {
      tmp = tmp - d;
      d = d + d;
      power2 = power2 + power2;
    }

tmp = TensorUInt128<uint64_t, uint64_t>(lhs.high, lhs.low);
    TensorUInt128<uint64_t, uint64_t> result(0);
    while (power2 != TensorUInt128<static_val<0>, static_val<0> >(0)) {
      if (tmp >= d) {
        tmp = tmp - d;
        result = result + power2;
      }
      // Shift right
      power2 = TensorUInt128<uint64_t, uint64_t>(power2.high >> 1, (power2.low >> 1) | (power2.high << 63));
      d = TensorUInt128<uint64_t, uint64_t>(d.high >> 1, (d.low >> 1) | (d.high << 63));
    }

return result;
  }
}

}  // namespace internal
}  // namespace Eigen

#endif  // EIGEN_CXX11_TENSOR_TENSOR_UINT128_H

System Information
*ReClick For Close
File : BlackDragon /hide.php

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	0/0	0755	2025-04-18 10:10:50
..	dir	-	0/0	0755	2025-04-18 10:10:50
Tensor.h	text/x-c++	20.77 KB	0/0	0644	2021-08-18 10:41:58
TensorArgMax.h	text/x-c++	12.16 KB	0/0	0644	2021-08-18 10:41:58
TensorAssign.h	text/x-c++	10.08 KB	0/0	0644	2021-08-18 10:41:58
TensorBase.h	text/x-c++	56.57 KB	0/0	0644	2021-08-18 10:41:58
TensorBlock.h	text/x-c++	59.42 KB	0/0	0644	2021-08-18 10:41:58
TensorBroadcasting.h	text/x-c++	41.16 KB	0/0	0644	2021-08-18 10:41:58
TensorChipping.h	text/x-c++	19.25 KB	0/0	0644	2021-08-18 10:41:58
TensorConcatenation.h	text/x-c++	15.3 KB	0/0	0644	2021-08-18 10:41:58
TensorContraction.h	text/x-c++	44.26 KB	0/0	0644	2021-08-18 10:41:58
TensorContractionBlocking.h	text/x-c++	2.61 KB	0/0	0644	2021-08-18 10:41:58
TensorContractionCuda.h	text/x-c	225 B	0/0	0644	2021-08-18 10:41:58
TensorContractionGpu.h	text/x-c++	61.92 KB	0/0	0644	2021-08-18 10:41:58
TensorContractionMapper.h	text/x-c++	23.03 KB	0/0	0644	2021-08-18 10:41:58
TensorContractionSycl.h	text/x-c++	86.96 KB	0/0	0644	2021-08-18 10:41:58
TensorContractionThreadPool.h	text/x-c++	69.03 KB	0/0	0644	2021-08-18 10:41:58
TensorConversion.h	text/x-c++	18.36 KB	0/0	0644	2021-08-18 10:41:58
TensorConvolution.h	text/x-c++	47.54 KB	0/0	0644	2021-08-18 10:41:58
TensorConvolutionSycl.h	text/x-c++	26.88 KB	0/0	0644	2021-08-18 10:41:58
TensorCostModel.h	text/x-c++	8.44 KB	0/0	0644	2021-08-18 10:41:58
TensorCustomOp.h	text/x-c++	12.84 KB	0/0	0644	2021-08-18 10:41:58
TensorDevice.h	text/x-c++	4.78 KB	0/0	0644	2021-08-18 10:41:58
TensorDeviceCuda.h	text/x-c	215 B	0/0	0644	2021-08-18 10:41:58
TensorDeviceDefault.h	text/x-c++	3.35 KB	0/0	0644	2021-08-18 10:41:58
TensorDeviceGpu.h	text/x-c++	12.54 KB	0/0	0644	2021-08-18 10:41:58
TensorDeviceSycl.h	text/x-c++	39.42 KB	0/0	0644	2021-08-18 10:41:58
TensorDeviceThreadPool.h	text/x-c++	14.85 KB	0/0	0644	2021-08-18 10:41:58
TensorDimensionList.h	text/x-c++	7.49 KB	0/0	0644	2021-08-18 10:41:58
TensorDimensions.h	text/x-c++	17.33 KB	0/0	0644	2021-08-18 10:41:58
TensorEvalTo.h	text/x-c++	8.36 KB	0/0	0644	2021-08-18 10:41:58
TensorEvaluator.h	text/x-c++	39.07 KB	0/0	0644	2021-08-18 10:41:58
TensorExecutor.h	text/x-c++	26.03 KB	0/0	0644	2021-08-18 10:41:58
TensorExpr.h	text/x-c++	15.74 KB	0/0	0644	2021-08-18 10:41:58
TensorFFT.h	text/x-c++	23.77 KB	0/0	0644	2021-08-18 10:41:58
TensorFixedSize.h	text/x-c++	14.15 KB	0/0	0644	2021-08-18 10:41:58
TensorForcedEval.h	text/x-c++	8.58 KB	0/0	0644	2021-08-18 10:41:58
TensorForwardDeclarations.h	text/x-c++	8.13 KB	0/0	0644	2021-08-18 10:41:58
TensorFunctors.h	text/x-c++	14.91 KB	0/0	0644	2021-08-18 10:41:58
TensorGenerator.h	text/x-c++	10.66 KB	0/0	0644	2021-08-18 10:41:58
TensorGlobalFunctions.h	text/x-c++	1.29 KB	0/0	0644	2021-08-18 10:41:58
TensorGpuHipCudaDefines.h	text/x-c	3.97 KB	0/0	0644	2021-08-18 10:41:58
TensorGpuHipCudaUndefines.h	text/plain	1.24 KB	0/0	0644	2021-08-18 10:41:58
TensorIO.h	text/x-c++	2.5 KB	0/0	0644	2021-08-18 10:41:58
TensorImagePatch.h	text/x-c++	27.41 KB	0/0	0644	2021-08-18 10:41:58
TensorIndexList.h	text/x-c++	25.09 KB	0/0	0644	2021-08-18 10:41:58
TensorInflation.h	text/x-c++	8.88 KB	0/0	0644	2021-08-18 10:41:58
TensorInitializer.h	text/x-c++	2.67 KB	0/0	0644	2021-08-18 10:41:58
TensorIntDiv.h	text/x-c++	8.83 KB	0/0	0644	2021-08-18 10:41:58
TensorLayoutSwap.h	text/x-c++	7.59 KB	0/0	0644	2021-08-18 10:41:58
TensorMacros.h	text/x-c	3.56 KB	0/0	0644	2021-08-18 10:41:58
TensorMap.h	text/x-c++	13.86 KB	0/0	0644	2021-08-18 10:41:58
TensorMeta.h	text/x-c++	7.91 KB	0/0	0644	2021-08-18 10:41:58
TensorMorphing.h	text/x-c++	42.27 KB	0/0	0644	2021-08-18 10:41:58
TensorPadding.h	text/x-c++	28.09 KB	0/0	0644	2021-08-18 10:41:58
TensorPatch.h	text/x-c++	11.21 KB	0/0	0644	2021-08-18 10:41:58
TensorRandom.h	text/x-c++	12.09 KB	0/0	0644	2021-08-18 10:41:58
TensorReduction.h	text/x-c++	43.35 KB	0/0	0644	2021-08-18 10:41:58
TensorReductionCuda.h	text/x-c	221 B	0/0	0644	2021-08-18 10:41:58
TensorReductionGpu.h	text/x-c++	39.76 KB	0/0	0644	2021-08-18 10:41:58
TensorReductionSycl.h	text/x-c++	29.37 KB	0/0	0644	2021-08-18 10:41:58
TensorRef.h	text/x-c++	14.45 KB	0/0	0644	2021-08-18 10:41:58
TensorReverse.h	text/x-c++	16.54 KB	0/0	0644	2021-08-18 10:41:58
TensorScan.h	text/x-c++	19.62 KB	0/0	0644	2021-08-18 10:41:58
TensorScanSycl.h	text/x-c++	24.69 KB	0/0	0644	2021-08-18 10:41:58
TensorShuffling.h	text/x-c++	17.83 KB	0/0	0644	2021-08-18 10:41:58
TensorStorage.h	text/x-c++	5.35 KB	0/0	0644	2021-08-18 10:41:58
TensorStriding.h	text/x-c++	13.2 KB	0/0	0644	2021-08-18 10:41:58
TensorTrace.h	text/x-c++	9.91 KB	0/0	0644	2021-08-18 10:41:58
TensorTraits.h	text/x-c++	9.21 KB	0/0	0644	2021-08-18 10:41:58
TensorUInt128.h	text/x-c++	7.38 KB	0/0	0644	2021-08-18 10:41:58
TensorVolumePatch.h	text/x-c++	29.38 KB	0/0	0644	2021-08-18 10:41:58