SystemVerilog Code to Generate the Pattern 5, -10, 15, -20, 25, ...

Welcome to VLSI 360, your go-to resource for VLSI design, verification, and SystemVerilog tutorials! Today, we’re tackling a common VLSI verification interview question: "Write a logic to generate the pattern 5, -10, 15, -20, 25, ..." in SystemVerilog. This pattern alternates between positive and negative numbers, increasing in magnitude by 10 each step. In this guide, we’ll provide a clear solution to help you understand the logic and excel in your interviews or projects. Let’s get started!

Question: Write a SystemVerilog Code to Generate a Pattern 5, -10, 15, -20, 25...

This pattern is a sequence of numbers that goes like this: 5, -10, 15, -20, 25, .... Let’s understand it:

• The numbers alternate: positive, negative, positive, negative, and so on.
• First number: 5 (positive), second number: -10 (negative), third number: 15 (positive), and so on.
• If we look at the values without the sign, they increase by 10 each time: 5, 10, 15, 20, 25, ....
• The pattern continues forever, but we’ll generate the first 20 numbers to keep things simple.

Our goal is to write SystemVerilog code to create this pattern. We’ll show you two methods: one using two variables to track the positive and negative numbers, and another using a single formula to calculate each number directly.

Method 1: Using Two Variables (Positive and Negative)

This method uses two variables to keep track of the positive and negative numbers separately. It’s easy to understand because we handle the positive and negative parts one at a time.

module tb;
  int arr[20];        // Array to store 20 numbers
  int val1 = -5;     // For positive numbers (starts at -5, adds 10 to get 5)
  int val2 = 0;      // For negative numbers (starts at 0, subtracts 10 to get -10)
  
  initial begin 
    for (int i = 0; i < 20; i++) begin
      if (i % 2 == 0) begin    // Even positions (0, 2, 4, ...): positive numbers
        val1 = val1 + 10;      // Add 10 each time (5, 15, 25, ...)
        arr[i] = val1;
      end
      else begin               // Odd positions (1, 3, 5, ...): negative numbers
        val2 = val2 - 10;      // Subtract 10 each time (-10, -20, -30, ...)
        arr[i] = val2;
      end
    end
    $display("%p", arr);       // Print the array
  end
endmodule

How It Works (Method 1):

• We make an array arr to store 20 numbers.
• We use val1 for positive numbers (like 5, 15, 25, ...). Start at -5, add 10 to get 5, then keep adding 10.
• We use val2 for negative numbers (like -10, -20, -30, ...). Start at 0, subtract 10 to get -10, then keep subtracting 10.
• A for loop runs 20 times:
  For even positions (like 0, 2, 4, ...), use val1 to get positive numbers.
• For odd positions (like 1, 3, 5, ...), use val2 to get negative numbers.
• Finally, we print the array.

Output (Method 1):

'{5, -10, 15, -20, 25, -30, 35, -40, 45, -50, 55, -60, 65, -70, 75, -80, 85, -90, 95, -100}

Method 2: Using a Single Formula

This method is even simpler because we use one formula to calculate each number based on its position. We don’t need two variables—just some math!

module tb;
  int arr[20];        // Array to store 20 numbers
  
  initial begin 
    for (int i = 0; i < 20; i++) begin
      if (i % 2 == 0) begin    // Even positions: positive
        arr[i] = 5 + 10 * (i/2);
      end
      else begin               // Odd positions: negative
        arr[i] = -10 * ((i+1)/2);
      end
    end
    $display("%p", arr);       // Print the array
  end
endmodule

How It Works (Method 2):

• We make an array arr to store 20 numbers.
• A for loop runs 20 times:
• For even positions (like 0, 2, 4, ...), we use the formula 5 + 10 * (i/2):
  • When i = 0, 5 + 10 * (0/2) = 5
  • When i = 2, 5 + 10 * (2/2) = 15
  • When i = 4, 5 + 10 * (4/2) = 25
• For odd positions (like 1, 3, 5, ...), we use the formula -10 * ((i+1)/2):
  • When i = 1, -10 * ((1+1)/2) = -10
  • When i = 3, -10 * ((3+1)/2) = -20
  • When i = 5, -10 * ((5+1)/2) = -30

• Finally, we print the array.

Output (Method 2):

'{5, -10, 15, -20, 25, -30, 35, -40, 45, -50, 55, -60, 65, -70, 75, -80, 85, -90, 95, -100}

Which Method is Better?

• Method 1 (Two Variables): This is easier to understand because you can see the positive and negative numbers being made step by step. It’s great for beginners.
• Method 2 (Single Formula): This is shorter and uses math to calculate the numbers directly. It’s faster to write but might be a little harder to understand at first.

Both methods give the same result, so you can use the one you like best!

Tips for Interviews

This question is common in VLSI verification interviews. Here are some extra questions you might get asked:

• Can you make the pattern go backward (like 25, -20, 15, -10, 5, ...)?
• Can you print the pattern without using an array, just showing each number one by one?
• How can you check if the pattern is correct using SystemVerilog?

For example, to check the pattern, you can compare each number in the array with the expected value using a loop after generating it.

SEO Keywords to Find This Post

We’ve used these keywords so you can find this post easily:

• SystemVerilog code for pattern 5 -10 15 -20 25
• Easy SystemVerilog alternating pattern 5 -10 15
• VLSI verification interview question for beginners
• SystemVerilog loop and array simple tutorial
• SystemVerilog pattern generation made easy