HDLRuby 3.7.7 → 3.7.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15e4da96afaa32db3686dcbad0ea327db644719dadfdba4ed6dcef1464f1e391
-  data.tar.gz: 1d08ab446037ab8ae6b86e6394a209a03ef06e8bcf233d10d9af25d059873f47
+  metadata.gz: 5cd33c7551f3da873475ca05e7047b40cd83abf4016e97fcdcbf266dca32b9b2
+  data.tar.gz: 4bce7700302da9f025b7bea65102973375746d6f767013a0b4db9259b7aea464
 SHA512:
-  metadata.gz: 444499b3dc4f0577f113630a521bf7de67186f8dc2936c8626b91fd1dc556fac9b5f361f7265dbe81123c6a8391054eca2d57076e3067653b41c9566125d5b65
-  data.tar.gz: 9284989cce6b6006c3551e6d5f8e40a29a8c16726d168cab4347f27b596eac1962f045cd260c072ad0be31665e69f2f84ce6406e28b65d378262bc7586c39fbb
+  metadata.gz: 9914adec792666008ce4a122d9014ede48b27c7c649c26b969d9eddf34e08a742382feda2925991522f0a9d632763d3d65df444ac48ad3ac5927bc0f44750ed7
+  data.tar.gz: 297426eacd2fe788c6fb2f7ea239106a3c4eab1ea48e1506f36058ec259479e49a9c2d7aa746b090fe16f147e46568c6cb101b8351bb70ec3b226ccdbf965069

data/README.md

@@ -17,6 +17,16 @@ hdrcc --get-tuto
 
 __What's new_
 
+For HDLRuby version 3.7.9:
+
+* Added Python code generation from the software sequencers.
+
+* Added [parallel enumerators](#parallel-enumerators-stdhruby_enumrb). 
+
+For HDLRuby versions 3.7.7/3.7.8:
+
+* Various fixes regqrding the software sequencers.
+
 For HDLRuby version 3.7.6:
 
 * Added initial value to signals for the software sequencers.
@@ -3252,6 +3262,125 @@ fsm(clk.posedge,rst,:static)
 end
 ```
 
+
+## Parallel Enumerators:: `std/hruby_enum.rb`
+<a name="enumertor"></a>
+
+HDLRuby parallel enumerators are objects for generating hardware processing series of signals in parallel. They are created using the method `heach` on parallel enumerable objects.
+
+Parallel enumerable objects include, arrays of signals and ranges.
+A parallel enumerable object can also be generated from an integer values using one of the following method:
+
+
+ - `<integer>.htimes`: is equivalent to the range `0..<integer-1>`.
+
+ - `<integer>.supto(<last>)`: is equivalent to the range `<integer>..<last>`.
+
+ - `<integer>.sdownto(<last>)`: is equivalent to the range `<last>..<integer>`.
+
+The parallel enumerators can be controlled using the following methods:
+
+ - `hsize`: returns the number of elements the enumerator can access.
+
+ - `htype`: returns the type of the elements accessed by the enumerator.
+
+ - `heach`: returns the current enumerator. If a block is given, it performs the iteration instead of returning an enumerator.
+
+ - `heach_with_index`: returns an enumerator over the elements of the current enumerator associated with their index position. If a block is given, it performs the iteration instead of returning an enumerator.
+
+ - `heach_with_object(<obj>)`: returns an enumerator over the elements of the current enumerator associated with object `obj` (any object, HDLRuby or not, can be used). If a block is given, it performs the iteration instead of returning an enumerator.
+
+ - `with_index`: identical to `seach_with_index`.
+
+ - `with_object(<obj>)`: identical to `seach_with_object`.
+
+ - `clone`: create a new enumerator on the same elements.
+
+ - `+`: concatenation of enumerators.
+
+
+With this basis, several algorithms have been implemented using enumerators and are usable for all the enumerable objects inside and outside proceses. All these algorithms are HW implantation of the Ruby Enumerable methods. They are accessible using the corresponding ruby method prefixed by character `h`. For example, the HW implementation of the ruby `all?` method is generated by the `hall?` method. In details:
+
+ - `hall?`: HW implementation of the Ruby `all?` method. Returns a single-bit signal. When 0 this value means false and when 1 it means true.
+
+ - `hany?`: HW implementation of the Ruby `any?` method. Returns a single-bit signal. When 0 this value means false and when 1 it means true.
+
+ - `hchain`: HW implementation of the Ruby `chain`.
+
+ - `hmap`: HW implementation of the Ruby `map` method. When used with a block returns a vector signal containing each computation result.
+
+ <!-- - `hcompact`: HW implementation of the Ruby `compact` method. However, since there is no nil value in HW, use 0 instead for compacting. Returns a vector signal containing the compaction result. -->
+
+ - `hcount`: HW implementation of the Ruby `count` method. Returns a signal whose bit width matches the size of the enumerator containing the count result.
+
+<!-- - `hcycle`: HW implementation of the Ruby `cycle` method. -->
+
+ - `hfind`: HW implementation of the Ruby `find` method. Returns a signal containing the found element, or 0 if not found.
+
+ - `hdrop`: HW implementation of the Ruby `drop` method. Returns a vector signal containing the remaining elements.
+
+<!-- - `hdrop_while`: HW implementation of the Ruby `drop_while` method. Returns a vector signal containing the remaining elements. -->
+
+ - `heach_cons`: HW implementation of the Ruby `each_cons` method.
+
+ - `heach_slice`: HW implementation of the Ruby `each_slice` method.
+
+ - `heach_with_index`: HW implementation of the Ruby `each_with_index` method.
+
+ - `heach_with_object`: HW implementation of the Ruby `each_with_object` method.
+
+ - `hto_a`: HW implementation of the Ruby `to_a` method. Returns a vector signal containing all the elements of the enumerator.
+
+<!-- - `hselect`: HW implementation of the Ruby `select` method. Returns a vector signal containing the selected elements. -->
+
+ - `hfind_index`: HW implementation of the Ruby `find_index` method. Returns the index of the found element or -1 if not.
+
+ - `hfirst`: HW implementation of the Ruby `first` method. Returns a vector signal containing the first elements.
+
+ - `hinclude?`: HW implementation of the Ruby `include?` method. Returns a single-bit signal. When 0 this value means false and when 1 it means true.
+
+ - `hinject`: HW implementation of the Ruby `inject` method. Return a signal of the type of elements containing the computation result.
+
+ - `hmax`: HW implementation of the Ruby `max` method. Return a vector signal containing the found max values.
+ *Note:* For now only one max value can be returned.
+
+ - `hmax_by`: HW implementation of the Ruby `max_by` method. Return a vector signal containing the found max values.
+ *Note:* For now only one max value can be returned.
+
+ - `hmin`: HW implementation of the Ruby `min` method. Return a vector signal containing the found min values.
+ *Note:* For now only one min value can be returned.
+
+ - `hmin_by`: HW implementation of the Ruby `min_by` method. Return a vector signal containing the found min values.
+ *Note:* For now only one min value can be returned.
+
+ - `hminmax`: HW implementation of the Ruby `minmax` method. Returns a 2-element vector signal containing the resulting min and max values.
+
+ - `hminmax_by`: HW implementation of the Ruby `minmax_by` method. Returns a 2-element vector signal containing the resulting min and max values.
+
+ - `hnone?`: HW implementation of the Ruby `none?` method. Returns a single-bit signal. When 0 this value means false and when 1 it means true.
+
+ - `hone?`: HW implementation of the Ruby `one?` method. Returns a single-bit signal. When 0 this value means false and when 1 it means true.
+
+<!--  - `hreject`: HW implementation of the Ruby `reject` method. Returns a vector signal containing the remaining elements. -->
+
+ - `hreverse_each`: HW implementation of the Ruby `reverse_each` method.
+ *Note:* This algorithm makes sense inside a `seq` process.
+
+ - `hsort`: HW implementation of the Ruby `sort` method. Returns a vector signal containing the sorted elements.
+ *Note:* If you use a custom comparison (passed as a Ruby block) and the number of elements to sort is not a power of 2, you need to provide as argument the maximum possible value (or minimum in case of decreasing order).
+
+ - `hsort_by`: HW implementation of the Ruby `sort_by` method. Returns a vector signal containing the sorted elements.
+ *Note:* If the number of elements to sort is not a power of 2, you need to provide as argument the maximum possible value (or minimum in case of decreasing order).
+
+ - `hsum`: HW implementation of the Ruby `sum` method. Returns a signal with the type of elements containing the sum result.
+
+ - `htake`: HW implementation of the Ruby `take` method. Returns a vector signal containing the taken elements.
+
+<!--  - `htake_while`: HW implementation of the Ruby `take_while` method. Returns a vector signal containing the taken elements. -->
+
+<!-- - `huniq`: HW implementation the Ruby `uniq` method. Returns a vector signal containing the selected elements. -->
+
+
 ## Sequencer (software-like hardware coding):: `std/sequencer.rb`
 <a name="sequencer"></a>
 
@@ -3390,9 +3519,9 @@ end
 ```
 
 
-### HDLRuby enumerators and enumerable objects: `std/sequencer.rb`
+### HDLRuby sequential enumerators and enumerable objects: `std/sequencer.rb`
 
-HDLRuby enumerators are objects for generating iterations within sequencers. They are created using the method `seach` on enumerable objects as presented in the previous section.
+HDLRuby sequential enumerators are objects for generating iterations within sequencers. They are created using the method `seach` on enumerable objects as presented in the previous section.
 
 The enumerators can be controlled using the following methods:
 
@@ -3846,6 +3975,18 @@ File.open("sequencer_in_ruby.rb","w") do |f|
 end
 ```
 
+It is also possible to generate C or Python code from the sequencer using the `to_c` and `to_python` methods, respectively. For example, the commands below generate a C file and a Python file from `my_seq`. However, the synchronization commands are not yet supported.
+
+```ruby
+File.open("seqiemcer_in_c.c","w" do |f|
+   f << my_seq.to_c
+end
+
+File.open("seqiemcer_in_python.py","w" do |f|
+   f << my_seq.to_python
+end
+```
+
 __Note__: the ruby code for sequencers is compatible with mruby for execution on embedded systems.
 
 
@@ -3986,7 +4127,7 @@ end.()
 
 Both method are functionally equivalent. However, the first is safer as potential errors are detected at the compile stage, but is incompatible with separated code generation and is slow, while the second allows separate code generation, if fast, but is less safe since it is only at the execution stage that the code is checked.
 
-__Note__: Since the string in text is grafted as is into the generated Ruby (or C) code, you cannot directly access the value of a signal. However, you can use to_ruby or to_c to access the underlying raw value, or use value_text to retrieve the value with proper type adjustment in case of overflow or underflow. For example, the following will display the raw value of signal sig0 and the hardware-accurate value of signal sig1:
+__Note__: Since the string in text is grafted as is into the generated Ruby (or C) code, you cannot directly access the value of a signal. However, you can use to_ruby, to_c or to_python to access the underlying raw value, or use value_text to retrieve the value with proper type adjustment in case of overflow or underflow. For example, the following will display the raw value of signal sig0 and the hardware-accurate value of signal sig1:
 
 ```ruby
 sequencer do

data/ext/hruby_sim/hruby_sim_calc.c

@@ -690,13 +690,13 @@ static Value mul_value_defined_bitstring(Value src0, Value src1, Value dst) {
         int sgn1 = (src1->type->flags.sign) && (src1->data_str[width1-1] == '1');
         // printf("sgn0=%d sgn1=%d\n",(src0->type->flags.sign) && (src0->data_str[width0-1] == '1'),sgn1);
         Value psrc1;
-        // printf("first scr1->data_str=%s\n",src1->data_str);fflush(stdout);
+        // printf("first src1->data_str=%s\n",src1->data_str);fflush(stdout);
         if (sgn1) {
             psrc1 = neg_value_bitstring(src1,get_value());
         } else {
             psrc1 = src1;
         }
-        // printf("now pscr1->data_str=%s\n",psrc1->data_str);fflush(stdout);
+        // printf("now psrc1->data_str=%s\n",psrc1->data_str);fflush(stdout);
         /* Perform the multiplying with sucessive shifts and additions. */
         /* First the result is zero. */
         const char* str = psrc1->data_str;
@@ -778,8 +778,8 @@ static Value mod_value_defined_bitstring(Value src0, Value src1, Value dst) {
 
 
 /** Computes the greater comparision of two defined bitstring values.
- *  @param src0 the first source value of the addition
- *  @param src1 the second source value of the addition
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
  *  @param dst the destination value
  *  @return dst */
 static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst) {
@@ -788,28 +788,13 @@ static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst)
     dst->type = src0->type;
     dst->numeric = 1;
 
-    // /* Converts the values to integers. */
-    // unsigned long long src0i = value2integer(src0);
-    // unsigned long long src1i = value2integer(src1);
-    // /* Perform the comparison. */
-    // if (src0->type->flags.sign) {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src0i > (signed long long)src1i;
-    //     else
-    //         dst->data_int = (signed long long)src0i >= 0 ? src0i > src1i : 0;
-    // } else {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src1i >= 0 ? src0i > src1i : 1;
-    //     else 
-    //         dst->data_int = src0i > src1i;
-    // }
     char* src0_data = src0->data_str;
     char* src1_data = src1->data_str;
     long long width0 = type_width(src0->type);
     long long width1 = type_width(src1->type);
     long long width = width0>width1 ? width0 : width1;
-    if (src0->type->flags.sign && src0_data[width0-1] == '1') {
-        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+    if (src0->type->flags.sign && (src0_data[width0-1] == '1')) {
+        if(src1->type->flags.sign && (src1_data[width1-1] == '1')) {
             /* Negative-negative comparison. */
             for(long long i=width-1; i >= 0; --i) {
                 char d0 = i >= width0 ? '1' : src0_data[i];
@@ -828,7 +813,7 @@ static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst)
             return dst;
         }
     } else {
-        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+        if(src1->type->flags.sign && (src1_data[width1-1] == '1')) {
             /* Positive-negative comparison, src0 is greater. */
             dst->data_int = 1;
             return dst;
@@ -852,9 +837,72 @@ static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst)
     return dst;
 }
 
+/** Computes the greater comparision of a numeric value and a
+ * defined bitstring values.
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
+ *  @param dst the destination value
+ *  @return dst */
+static Value greater_value_numeric_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("greater_value_numeric_defined_bitstring.\n");
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    unsigned long long src0_int = src0->data_int;
+    char* src1_data = src1->data_str;
+    long long width0 = type_width(src0->type);
+    long long width1 = type_width(src1->type);
+    long long width = width0>width1 ? width0 : width1;
+    if (src0->type->flags.sign && (src0_int & (1 << (width0-1)))) {
+        if(src1->type->flags.sign && (src1_data[width1-1] == '1')) {
+            /* Negative-negative comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '1' : 
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '1' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 0;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 1;
+                    return dst;
+                }
+            }
+        } else {
+            /* Negative positive comparison, src0 is smaller. */
+            dst->data_int = 0;
+            return dst;
+        }
+    } else {
+        if(src1->type->flags.sign && (src1_data[width1-1] == '1')) {
+            /* Positive-negative comparison, src0 is greater. */
+            dst->data_int = 1;
+            return dst;
+        } else {
+            /* Positive-positive comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '0' : 
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '0' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 0;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 1;
+                    return dst;
+                }
+            }
+        }
+    }
+    /* Equality. */
+    dst->data_int = 0;
+    return dst;
+}
+
 /** Computes the lesser comparision of two defined bitstring values.
- *  @param src0 the first source value of the addition
- *  @param src1 the second source value of the addition
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
  *  @param dst the destination value
  *  @return dst */
 static Value lesser_value_defined_bitstring(Value src0, Value src1, Value dst) {
@@ -863,21 +911,6 @@ static Value lesser_value_defined_bitstring(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    // /* Converts the values to integers. */
-    // unsigned long long src0i = value2integer(src0);
-    // unsigned long long src1i = value2integer(src1);
-    // /* Perform the comparison. */
-    // if (src0->type->flags.sign) {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src0i < (signed long long)src1i;
-    //     else
-    //         dst->data_int = (signed long long)src0i >= 0 ? src0i < src1i : 1;
-    // } else {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src1i >= 0 ? src0i < src1i : 0;
-    //     else 
-    //         dst->data_int = src0i < src1i;
-    // }
     char* src0_data = src0->data_str;
     char* src1_data = src1->data_str;
     long long width0 = type_width(src0->type);
@@ -927,32 +960,80 @@ static Value lesser_value_defined_bitstring(Value src0, Value src1, Value dst) {
     return dst;
 }
 
+/** Computes the lesser comparision of one numeric value and one
+ *  defined bitstring values.
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
+ *  @param dst the destination value
+ *  @return dst */
+static Value lesser_value_numeric_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("lesser_value_numeric_defined_bitstring.\n");
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    unsigned long long src0_int = src0->data_int;
+    char* src1_data = src1->data_str;
+    long long width0 = type_width(src0->type);
+    long long width1 = type_width(src1->type);
+    long long width = width0>width1 ? width0 : width1;
+    if (src0->type->flags.sign && (src0_int & (1 << (width0-1)))) {
+        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+            /* Negative-negative comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '1' : 
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '1' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 1;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 0;
+                    return dst;
+                }
+            }
+        } else {
+            /* Negative positive comparison, src0 is smaller. */
+            dst->data_int = 1;
+            return dst;
+        }
+    } else {
+        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+            /* Positive-negative comparison, src0 is greater. */
+            dst->data_int = 0;
+            return dst;
+        } else {
+            /* Positive-positive comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '0' :
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '0' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 1;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 0;
+                    return dst;
+                }
+            }
+        }
+    }
+    /* Equality. */
+    dst->data_int = 0;
+    return dst;
+}
+
 /** Computes the greater or equal comparision of two defined bitstring values.
- *  @param src0 the first source value of the addition
- *  @param src1 the second source value of the addition
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
  *  @param dst the destination value
  *  @return dst */
 static Value greater_equal_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("greater_equal_value_defined_bitstring.\n");
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
 
-    // /* Converts the values to integers. */
-    // unsigned long long src0i = value2integer(src0);
-    // unsigned long long src1i = value2integer(src1);
-    // // printf("src0i=%lld src1i=%lld, src0i.sign=%d src0i.width=%d, src1i.sign=%d src1i.width=%d\n",src0i,src1i,src0->type->flags.sign,type_width(src0->type),src1->type->flags.sign,type_width(src1->type));
-    // /* Perform the comparison. */
-    // if (src0->type->flags.sign) {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src0i >= (signed long long)src1i;
-    //     else
-    //         dst->data_int = (signed long long)src0i >= 0 ? src0i >= src1i : 0;
-    // } else {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src1i >= 0 ? src0i >= src1i : 1;
-    //     else 
-    //         dst->data_int = src0i >= src1i;
-    // }
     char* src0_data = src0->data_str;
     char* src1_data = src1->data_str;
     long long width0 = type_width(src0->type);
@@ -1002,31 +1083,80 @@ static Value greater_equal_value_defined_bitstring(Value src0, Value src1, Value
     return dst;
 }
 
+/** Computes the greater or equal comparision of numeric and one
+ *  defined bitstring values.
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
+ *  @param dst the destination value
+ *  @return dst */
+static Value greater_equal_value_numeric_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("greater_equal_value_numeric_defined_bitstring.\n");
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    unsigned long long src0_int = src0->data_int;
+    char* src1_data = src1->data_str;
+    long long width0 = type_width(src0->type);
+    long long width1 = type_width(src1->type);
+    long long width = width0>width1 ? width0 : width1;
+    if (src0->type->flags.sign && (src0_int & (1 <<(width0-1)))) {
+        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+            /* Negative-negative comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '1' :
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '1' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 0;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 1;
+                    return dst;
+                }
+            }
+        } else {
+            /* Negative positive comparison, src0 is smaller. */
+            dst->data_int = 0;
+            return dst;
+        }
+    } else {
+        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+            /* Positive-negative comparison, src0 is greater. */
+            dst->data_int = 1;
+            return dst;
+        } else {
+            /* Positive-positive comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '0' : 
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '0' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 0;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 1;
+                    return dst;
+                }
+            }
+        }
+    }
+    /* Equality. */
+    dst->data_int = 1;
+    return dst;
+}
+
 /** Computes the lesser or equal comparision of two defined bitstring values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
  *  @param dst the destination value
  *  @return dst */
 static Value lesser_equal_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("lesser_equal_value_defined_bitstring.\n");
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
 
-    // /* Converts the values to integers. */
-    // unsigned long long src0i = value2integer(src0);
-    // unsigned long long src1i = value2integer(src1);
-    // /* Perform the comparison. */
-    // if (src0->type->flags.sign) {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src0i <= (signed long long)src1i;
-    //     else
-    //         dst->data_int = (signed long long)src0i >= 0 ? src0i <= src1i : 1;
-    // } else {
-    //     if (src1->type->flags.sign)
-    //         dst->data_int = (signed long long)src1i >= 0 ? src0i <= src1i : 0;
-    //     else 
-    //         dst->data_int = src0i <= src1i;
-    // }
     char* src0_data = src0->data_str;
     char* src1_data = src1->data_str;
     long long width0 = type_width(src0->type);
@@ -1076,6 +1206,70 @@ static Value lesser_equal_value_defined_bitstring(Value src0, Value src1, Value
     return dst;
 }
 
+/** Computes the lesser or equal comparision of on numeric value and one
+ *  defined bitstring values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+static Value lesser_equal_value_numeric_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("lesser_equal_value_numeric_defined_bitstring.\n");
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    unsigned long long src0_int = src0->data_int;
+    char* src1_data = src1->data_str;
+    long long width0 = type_width(src0->type);
+    long long width1 = type_width(src1->type);
+    long long width = width0>width1 ? width0 : width1;
+    if (src0->type->flags.sign && (src0_int & (1 << (width0-1)))) {
+        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+            /* Negative-negative comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '1' :
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '1' : src1_data[i];
+                if (d0 < d1) {
+                    dst->data_int = 1;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 0;
+                    return dst;
+                }
+            }
+        } else {
+            /* Negative positive comparison, src0 is smaller. */
+            dst->data_int = 1;
+            return dst;
+        }
+    } else {
+        if(src1->type->flags.sign && src1_data[width1-1] == '1') {
+            /* Positive-negative comparison, src0 is greater. */
+            dst->data_int = 0;
+            return dst;
+        } else {
+            /* Positive-positive comparison. */
+            for(long long i=width-1; i >= 0; --i) {
+                char d0 = i >= width0 ? '0' :
+                    ((src0_int & (1 << i)) ? '1' : '0');
+                char d1 = i >= width1 ? '0' : src1_data[i];
+                // printf("d0=%c d1=%c\n",d0,d1);
+                if (d0 < d1) {
+                    dst->data_int = 1;
+                    return dst;
+                } else if (d0 > d1) {
+                    dst->data_int = 0;
+                    return dst;
+                }
+            }
+        }
+    }
+    /* Equality. */
+    dst->data_int = 1;
+    return dst;
+}
+
 
 /** Computes the NOT of a bitstring value.
  *  @param src the source value of the not
@@ -3111,6 +3305,10 @@ Value greater_value(Value src0, Value src1, Value dst) {
         /* Both sources are numeric. */
         return greater_value_numeric(src0,src1,dst);
     } else if (is_defined_value(src0) && is_defined_value(src1)) {
+        if (src0->numeric)
+            return greater_value_numeric_defined_bitstring(src0,src1,dst);
+        if (src1->numeric)
+            return lesser_equal_value_numeric_defined_bitstring(src1,src0,dst);
         /* Both sources can be converted to numeric values. */
         return greater_value_defined_bitstring(src0,src1,dst);
     } else {
@@ -3139,6 +3337,10 @@ Value lesser_value(Value src0, Value src1, Value dst) {
         return lesser_value_numeric(src0,src1,dst);
     } else if (is_defined_value(src0) && is_defined_value(src1)) {
         /* Both sources can be converted to numeric values. */
+        if (src0->numeric)
+            return lesser_value_numeric_defined_bitstring(src0,src1,dst);
+        if (src1->numeric)
+            return greater_equal_value_numeric_defined_bitstring(src1,src0,dst);
         return lesser_value_defined_bitstring(src0,src1,dst);
     } else {
         /* Cannot compute (for now), simply undefines the destination. */
@@ -3166,6 +3368,10 @@ Value greater_equal_value(Value src0, Value src1, Value dst) {
         return greater_equal_value_numeric(src0,src1,dst);
     } else if (is_defined_value(src0) && is_defined_value(src1)) {
         /* Both sources can be converted to numeric values. */
+        if (src0->numeric)
+            return greater_equal_value_numeric_defined_bitstring(src0,src1,dst);
+        if (src1->numeric)
+            return lesser_value_numeric_defined_bitstring(src1,src0,dst);
         return greater_equal_value_defined_bitstring(src0,src1,dst);
     } else {
         /* Cannot compute (for now), simply undefines the destination. */
@@ -3192,6 +3398,10 @@ Value lesser_equal_value(Value src0, Value src1, Value dst) {
         return lesser_equal_value_numeric(src0,src1,dst);
     } else if (is_defined_value(src0) && is_defined_value(src1)) {
         /* Both sources can be converted to numeric values. */
+        if (src0->numeric)
+            return lesser_equal_value_numeric_defined_bitstring(src0,src1,dst);
+        if (src1->numeric)
+            return greater_value_numeric_defined_bitstring(src1,src0,dst);
         return lesser_equal_value_defined_bitstring(src0,src1,dst);
     } else {
         /* Cannot compute (for now), simply undefines the destination. */