`Unsigned` and `Signed` by ktbarrett · Pull Request #271 · ktbarrett/coconext

ktbarrett · 2026-06-08T14:24:42Z

Closes #191.

These are useful for implementing a bunch of features currently found in cocotb's LogicArray (e.g. from_unsigned, to_unsigned) that we for binding coconext's DynLogicArray to Python in a way it can sit in place of cocotb's using the patcher.

This just uses uint64_t and int64_t. We will adapt UInt, and SInt from #278 once it's done.

codecov · 2026-06-08T14:46:19Z

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 92.30%. Comparing base (f015a94) to head (e05e267).

Additional details and impacted files

@@            Coverage Diff             @@
##              dev     #271      +/-   ##
==========================================
+ Coverage   92.23%   92.30%   +0.07%     
==========================================
  Files          24       24              
  Lines        1339     1339              
  Branches      331      331              
==========================================
+ Hits         1235     1236       +1     
  Misses         45       45              
+ Partials       59       58       -1

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

ktbarrett

The shape looks good.

ktbarrett · 2026-06-30T04:37:53Z

+        for (auto const& bit : other) {
+            temp_bit = bit ? 1 : 0;
+            value_ = (value_ << 1) | temp_bit;
+        }


Welp, I guess we should move BitArray over to Bits as well now.

Wrap BitArray around Bits? A packed Bitarray rework was mentioned in the unsigned signed docs. That is a similar thing?

Yeah it's similar. Right now the implicit upcast is kind of an expensive operation. If everything was just Bits under the hood, we can just copy/move the Bits object around.

ZiaCheemaGit · 2026-07-04T07:14:07Z

Follow ups would be

APInt BigInts
BitArray packing
Also I have left out slicing etc things as it would require rework after BitArray is packed

ktbarrett · 2026-07-07T16:06:58Z

+            if (storage_ == other.storage_) {
+                return std::strong_ordering::equal;
+            }
+            if (storage_ < other.storage_) {
+                return std::strong_ordering::less;
+            }
+            return std::strong_ordering::greater;


Seems like you could just implement operator<=> for BigInt and leave the else branch as the only implementation.

ktbarrett · 2026-07-09T05:22:43Z

Sorry started to review, but got side-tracked, will have time tomorrow as I'm almost done my work for the week.

ktbarrett · 2026-07-09T15:16:34Z

@@ -0,0 +1,422 @@
+#include <gtest/gtest.h>


Suggested change

#include <gtest/gtest.h>

// LCOV_EXCL_BR_START -- gtest macros generate noisy uncovered branches

#include <gtest/gtest.h>

ktbarrett · 2026-07-09T15:45:57Z

+struct UnsignedTag {};
+struct SignedTag {};


Lets not do this this way. This basically works because of EBO, but if we don't get EBO or the optimizer gets confused we break autovectorization.

We can accomplish the same thing with a template variable specialization:

template <typename T> inline constexpr bool is_coconext_unsigned_v = false; template <Range R> inline constexpr bool is_coconext_unsigned_v<detail::Unsigned<R>> = true;

ktbarrett

The big issue is the order of operations issue in in-place operations. Everything else is kinda nitpicking.

ktbarrett · 2026-07-09T15:49:45Z

+    template <size_t W>
+    constexpr Signed(Bits<W> const& val) {
+        static_assert(W == R.length(), "Construction from Bits requires identical width");
+        value_ = val;
+    }


Bits is in the detail namespace. I don't think we should be having public methods get or return Bits.

ktbarrett · 2026-07-09T15:57:09Z

+        for (auto& bit : temp) {
+            if constexpr (!Bits<R.length()>::is_not_native_int) {
+                bit = to_bit(((value_.srl(bit_idx)) & temp_bit).raw());
+            } else {
+                bit = to_bit(((value_.srl(bit_idx)) & temp_bit).raw().get_word(0));
+            }
+            if (bit_idx > 0) {
+                bit_idx--;
+            }
+        }


This is very inefficient, but that will change once the BitArray specialization is in. I wonder if we should just be doing that change first to prevent churn?

ktbarrett · 2026-07-09T16:02:54Z

+        constexpr Range R_res = detail::int_downto_range(R.length() + 1);
+        auto ext = resize<R_res.length()>(*this);
+        return Signed<R_res>(detail::Bits<R_res.length()>(0) - ext.value_);


Probably more simply stated as return Signed<1>(0) - *this

ktbarrett · 2026-07-09T16:11:59Z

+    template <Range R2>
+    constexpr Signed& operator+=(Signed<R2> const& rhs) {
+        this->value_ = this->value_ + resize<R.length()>(rhs).value_;
+        return *this;
+    }
+    template <Range R2>
+    constexpr Signed& operator-=(Signed<R2> const& rhs) {
+        this->value_ = this->value_ - resize<R.length()>(rhs).value_;
+        return *this;
+    }
+    template <Range R2>
+    constexpr Signed& operator*=(Signed<R2> const& rhs) {
+        this->value_ = this->value_ * resize<R.length()>(rhs).value_;
+        return *this;
+    }
+    template <Range R2>
+    constexpr Signed& operator/=(Signed<R2> const& rhs) {
+        if (!static_cast<bool>(rhs)) {
+            throw std::domain_error("Division by zero");
+        }
+        this->value_ = this->value_.sdiv(resize<R.length()>(rhs).value_);
+        return *this;
+    }
+    template <Range R2>
+    constexpr Signed& operator%=(Signed<R2> const& rhs) {
+        if (!static_cast<bool>(rhs)) {
+            throw std::domain_error("Division by zero");
+        }
+        this->value_ = this->value_.smod(resize<R.length()>(rhs).value_);
+        return *this;
+    }


The order of operations here is off. We want full-sized operation then resize back down:

*this = resize<R>(*this + rhs);

ktbarrett · 2026-07-09T16:14:04Z

+
+    template <Integer T>
+    constexpr Signed& operator+=(T const& rhs) {
+        *this += Signed<R>(rhs);


Can't assume RHS will fit into the LHS's bounds. This is the same order of operations bug. We want

*this = resize<R>(*this + rhs)

ktbarrett · 2026-07-09T16:16:56Z

+        constexpr const_iterator(Signed const* parent, size_t offset)
+            : parent_(parent), offset_(offset) {}
+
+        constexpr reference operator*() const {


WE are going to need mutable references here at some point, but we can get to that later. WE will need a proper BitProxy class like std::vector uses and that should just go on Bits and we can remove this iterator.

ktbarrett · 2026-07-09T16:20:15Z

+template <typename Target, typename Source>
+    requires detail::is_coconext_signed<Target>::value
+constexpr Target as(Source const& source) noexcept {
+    static_assert(
+        Target::static_range.length() == Source::static_range.length(),
+        "as() requires equal widths."
+    );
+    return Target(static_cast<detail::Array<Bit, Source::static_range>>(source));
+}


I think this could be expanded to accept any object with Bits as the implementation type. You could make a detail::uses_Bits trait with Signed, Unsigned, BitArray, and eventually the fixed point and float classes all participating, then you only have one implementation of this function.

ktbarrett force-pushed the unsigned-signed branch from ab25267 to 58d2fbc Compare June 8, 2026 14:44

ktbarrett force-pushed the unsigned-signed branch from 58d2fbc to 58074e5 Compare June 8, 2026 15:50

ZiaCheemaGit force-pushed the unsigned-signed branch from 4454dc3 to 5529b4b Compare June 17, 2026 09:26

ZiaCheemaGit mentioned this pull request Jun 25, 2026

Bits class #298

Merged

ZiaCheemaGit force-pushed the unsigned-signed branch 3 times, most recently from 3bb9234 to a5b17ca Compare June 29, 2026 20:29

ktbarrett commented Jun 30, 2026

View reviewed changes

ZiaCheemaGit force-pushed the unsigned-signed branch from eb4e00a to a8c22fd Compare July 4, 2026 06:04

ZiaCheemaGit marked this pull request as ready for review July 4, 2026 06:09

ktbarrett and others added 7 commits July 4, 2026 11:12

Add fixed-width Unsigned and DynUnsigned integer types

d016659

Add fixed-width Signed and DynSigned integer types

e7ff3ac

resolve pre-commit issues left out by re-base

23dc790

some restructure and unsigned work

d7640ff

more unsigned work

ae0d094

finalize signed/unsigned before merge

d71e1f8

clang demands more strictness on compile time exps

d9c4995

ZiaCheemaGit force-pushed the unsigned-signed branch from a8c22fd to d9c4995 Compare July 4, 2026 06:15

fix pre-commit

e05e267

ktbarrett commented Jul 9, 2026

View reviewed changes

	#include <gtest/gtest.h>
	// LCOV_EXCL_BR_START -- gtest macros generate noisy uncovered branches
	#include <gtest/gtest.h>

Conversation

ktbarrett commented Jun 8, 2026 • edited by ZiaCheemaGit Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

codecov Bot commented Jun 8, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Codecov Report

Uh oh!

ktbarrett left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

ZiaCheemaGit Jun 30, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

ZiaCheemaGit commented Jul 4, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

ktbarrett commented Jul 9, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

ktbarrett left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

ktbarrett commented Jun 8, 2026 •

edited by ZiaCheemaGit

Loading

codecov Bot commented Jun 8, 2026 •

edited

Loading

ZiaCheemaGit Jun 30, 2026 •

edited

Loading