Constraint #49

Constraint for a variable i) on every 2nd randomization the value should be the reverse of the previous value ii) otherwise the value ranges from 500 to 10,000

First, let's clarify the constraint. We want a variable's value to range from 500 to 10,000 on every odd randomization. Additionally, on every odd randomization, the value should be the reverse of the previous randomized value.

To reverse a number mathematically, we use the modulus operator (%) with 10, as a decimal number system is based on 10 elements. Let's illustrate this with an example: if we have the number 3874, its reverse should be 4783.

Here's how the algorithm works:

1. Take the modulus of the number with 10 and store the result.
2. Remove the last digit from the number by dividing it by 10.
3. Repeat these steps until the input number becomes 0.

We can achieve this with a while loop, as the number of iterations depends on the number of digits in the input.

while(prev_d1) begin rev_data = (rev_data*10) + (prev_d1%10); prev_d1 = prev_d1/10; end

To achieve the specified behavior, we can use a constraint that handles odd and even randomizations differently. We'll use a flag to keep track of whether the current randomization is odd or even. Here's how we can do it:

We'll use a single bit variable count to track whether the current randomization is odd or even. We'll initialize it to 1 for odd randomization. Inside the constraint, we'll use an if statement to check the value of count. If it's 0 (even), we'll constrain the variable to be in the range [500:10000]. If it's 1 (odd), we'll constrain the variable to be equal to the reverse of the previous value by assigning the Calculated value on the post_randomize.

After each randomization, we'll toggle the value of count using a post_randomize function to ensure that the next randomization behaves correctly.

Explore the executable constraint below and be sure to check out the EDA link.

class sample;
  rand int data;
       int prev_d;
       int rev_data;
  	   bit count;
  
  constraint array_c {
    data inside {[500:10000]};
    if(count) 
      data == rev_data;
   }
  
  function void post_randomize();
    int prev_d1;
    count++;
    prev_d = data;
    prev_d1 = prev_d;
    rev_data = 0;
    while(prev_d1) begin
      rev_data = (rev_data*10) + (prev_d1%10);
      prev_d1 = prev_d1/10;
    end
  endfunction

endclass
                             
module top;
  sample s=new();
  
  initial begin
    $display("######## OUTPUT ########");
    repeat(3) begin
   		repeat(2) begin
      		assert(s.randomize());
      		$display("data = %0d \t\t",s.data);
    	end
      $display("");
    end
    $display("######## END ########");
  end
endmodule        

I appreciate your understanding of the methodology we've utilized to handle constraints and their real-world applications. Your support, through likes and reposts, will indeed encourage further exploration. I'm eagerly looking forward to engaging in meaningful discussions with you. Thank you! 😊🌟

Decoding of the Above Code:

In Class

• Class Declaration: Declares a class named "sample" containing a random integer variable "data" to store a number, an integer variable "prev_d" to store the previous value of "data", an integer variable "rev_data" to store the reverse of "data", and a bit variable "count".
• Random Variable Declaration:Declares a random integer variable named "data" within the "sample" class. The variable is declared as a random variable (rand), which means it will be randomized during object creation.Declares an integer variable named "prev_d" to store the previous value of "data".Declares an integer variable named "rev_data" to store the reverse of "data".Declares a bit variable named "count".

Constraint:

• array_c: Defines a constraint named "array_c" which imposes the following conditions on the "data" variable:The value of "data" must be in the range [500, 10000].If "count" is true (1), "data" must be equal to its reverse value, stored in "rev_data".

Function post_randomize():

• Increments the value of "count".
• Stores the current value of "data" in "prev_d".
• Computes the reverse of "data" and stores it in "rev_data".

In Module Top

• Instantiation of Class: Instantiates an object of the "sample" class named "s".
• Initial Block:Displays a header indicating the beginning of the output.Repeats 3 times:Repeats 2 times:Randomizes the data members of the object "s" according to the constraints specified in the class definition.Displays the value of "data".Displays a newline to separate the sets of "data" values.Displays a footer indicating the end of the output.

This program generates random values for the variable "data" and ensures that if "count" is true, "data" is equal to its reverse value. The output displays the generated values of "data".