target[0]<\/code> is 24, the tolerance is 10 percent of that value, or 2.4. As long as the comparison value, sample[0]<\/code>, is within the range of 24 ±2.4, the values match.<\/p>\nWhen the values get larger, the percentage increases and so does the tolerance. If target[9]<\/code> is set to 95, then its 10 percent tolerance is 95 ±9.5. The value of sample[9]<\/code> can be in the range of 85.5 (int<\/em> 85) to 104.5 (int<\/em> 105) and the fuzzy match passes.<\/p>\nHere is sample code, based on the code from last week’s Lesson<\/a>:<\/p>\n\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n\r\n#define COUNT 10\r\n#define TRUE 1\r\n#define FALSE 0\r\n\r\nint main()\r\n{\r\n int target[COUNT] = { 24, 28, 32, 45, 50,\r\n 66, 67, 70, 80, 95 };\r\n int sample[COUNT] = { 26, 26, 30, 42, 50,\r\n 61, 67, 75, 85, 99 };\r\n int x,match,variation;\r\n float tolerance;\r\n\r\n match = TRUE; \/* initialize match *\/<\/span>\r\n tolerance = 0.10; \/* percentage tolerance *\/<\/span>\r\n\r\n \/* compare arrays *\/<\/span>\r\n for(x=0; x<COUNT; x++)\r\n {\r\n variation = abs(target[x]-sample[x]);\r\n if( (float)variation > (float)target[x]*tolerance)\r\n {\r\n match = FALSE;\r\n break;\r\n }\r\n }\r\n\r\n \/* display results *\/<\/span>\r\n if(match)\r\n printf(\"The arrays are similar, within %.f%% tolerance\\n\",\r\n tolerance*100);\r\n else\r\n printf(\"The arrays are not similar, within %.f%% tolerance\\n\",\r\n tolerance*100);\r\n\r\n return(0);\r\n}<\/pre>\nThe float<\/em> variable tolerance<\/code> is set to the fuzz factor, the percentage value that the comparison can fluctuate. It’s set to 0.10<\/code> in Line 18, which is 10 percent.<\/p>\nRemember that percentages are decimal values: 50 percent is 0.50 not 50.0.<\/p><\/blockquote>\n
The for<\/em> loop at Line 21 plows through each of the two arrays’ elements. At Line 23 in the loop, the difference between each elements’ values is calculated. The abs()<\/em> function sets a positive value difference.<\/p>\nThe if<\/em> comparison at Line 24 multiplies the original array element’s value by the tolerance<\/code> percentage. When the result is greater than the value of variation<\/code>, the match fails. The values of variation<\/code> and element[x]<\/code> are typecast to float<\/em> variables so that the result is calculated accurately.<\/p>\nLines 33 and 36, both display the results and display the percentage value used for the comparison.<\/p>\n
Here is a sample run:<\/p>\n
The arrays are similar, within 10% tolerance<\/code><\/pre>\nYou can set the value of variable tolerance<\/code> to another percentage in Line 18. So if you want to use 5 percent, set the value to 0.05<\/code>.<\/p>\nIn this sample code, however, anything less than 10 percent tolerance fails the match. That’s because the smaller values in the samples require a higher tolerance than the larger values. Discrete values make more sense for this type of comparison, still it’s puzzling when you look at Figure 1 and see how similar the lines are that a 10 percent tolerance doesn’t result in a positive fuzzy match.<\/p>\n
![\"Figure](\"http:\/\/c-for-dummies.com\/blog\/wp-content\/uploads\/2016\/08\/0903-figure1.png\")
Figure 1. The two data sets graphed as lines.<\/p><\/div>\n
The solution is to add another level of forgiveness. I cover that fuzzy feature in next week’s Lesson<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"A better way to calculate the fuzz<\/em> in a match might be to use a percentage instead of a discrete value. Continue reading