MISRA C:2012 Rule 14.1

A loop counter shall not have essentially floating type

Description

Rule Definition

A loop counter shall not have essentially floating type¹ .

Rationale

When using a floating-point loop counter, accumulation of rounding errors can cause the actual number of iterations to be different than the number of iterations you expect. This rounding error can happen when a loop step that is not a power of the floating-point radix is rounded to a value that can be represented by a float.

Even if a loop with a floating-point loop counter appears to behave correctly on one implementation, it can give a different number of iterations on another implementation.

Polyspace Implementation

Polyspace^® reports a violation of this rule if a loop counter variable has an essentially floating type.

To determine if a variable is a loop counter, the checker considers only the controlling expression of the loop. In particular:

• If you use a floating point variable to break out of a loop but do not use this variable in the loop controlling expression, Polyspace does not consider this variable as a loop counter. For instance, in this example, the float type variable loopBreaker is not considered as a loop counter and its use in breaking out of the loop does not result in a violation of the rule:

  float loopBreaker = 0.0f; /* No violation raised */
  while(1) {
      if(loopBreaker > 5.0f)
          break;
      loopBreaker += 1.0f;
  }

• When determining if a variable is a loop counter, Polyspace does not check whether the variable varies monotonically for the duration of the loop or whether the variable changes at each step of the loop.

Troubleshooting

If you expect a rule violation but do not see it, refer to Diagnose Why Coding Standard Violations Do Not Appear as Expected.

Examples

for Loop Counters

int main(void){
    unsigned int counter = 0u;
    int result = 0;
    float foo;

    // Float loop counters
    for(float foo = 0.0f; foo < 1.0f; foo +=0.001f){/* Non-compliant*/
        ++counter;
    }

    float fff = 0.0f; 
    for(fff = 0.0f; fff <12.0f; fff += 1.0f){/* Non-compliant*/
        result++;
    }

    // Integer loop count
    for(unsigned int count = 0u; count < 1000u; ++count){/* Compliant */
        foo = (float) count * 0.001f;
    }
}

In this example, the three for loops show three different loop counters. The first and second for loops use float variables as loop counters, and therefore are not compliant. The third loop uses the integer count as the loop counter. Even though count is used as a float inside the loop, the variable remains an integer when acting as the loop index. Therefore, this for loop is compliant.

while Loop Counters

This example shows two while loops. The loops use floating-point variables in the while-loop conditions:

• The first while loop uses the floating-point variable foo in the loop condition and inside the loop. When foo is updated in the loop, floating-point rounding errors can cause unexpected behavior. Polyspace reports a violation.

• The second while loop uses the floating point array buffer and two integers iter1 and inter2 in the loop condition. Polyspace identifies iter1 and iter2 as the loop counters. Because these loop counters are not floating point variables, Polyspace does not report a violation.

int main(void){
    unsigned int iter1 =0;
    int iter2;
    float foo;
    double buffer[2];
    double tmp;

    foo = 0.0f;
    while (foo < 1.0f){/* Non-compliant - foo used as a loop counter */
        foo += 0.001f;  
    }
       
	//...
    while((iter1+1 < 2)&& (buffer[iter1]<buffer[iter2])){ //Compliant - loop counter is integer
		// swap buffer[iter1] and buffer[iter2]
        tmp = buffer[iter2];
        buffer[iter2] = buffer[iter1];
        buffer[iter1] = tmp;
        iter2 = iter1;
        iter1++;
    }
						
    return 1; 
}

Check Information

Group: Control Statement Expressions

Category: Required

AGC Category: Advisory

Version History

R2025a: Complex floating types now supported

Polyspace now reports violations if the type of loop counter is one of the following:

• Essentially real floating type

• Essentially complex floating type

• Floating pointer member of a structure

R2024a: Complex essential types now supported

To support MISRA C:2012 amendment 3, this rule now takes essentially real floating types and essentially complex floating types into account.

R2023a: Improved detection of loop counter

The rule checker correctly detects floating-point variables that are not the loop counter in a loop condition. For instance, this code uses the double array buffer in the while loop condition. Polyspace correctly recognizes that buffer is not the loop variable and does not report a violation.

int main(void){
    unsigned int iter1, iter2;
    double buffer[2];
    double tmp; 
	//...
    while((iter1+1 < 2)&& (buffer[iter1]<buffer[iter2])){ //Compliant - loop counter is integer
		// swap buffer[iter1] and buffer[iter2]
        tmp = buffer[iter2];
        buffer[iter2] = buffer[iter1];
        buffer[iter1] = tmp;
        iter2 = iter1;
        iter1++;
    }
						
    return 1; 
}