Shell Programming and Scripting

So, I'm making a little awk script that generates a range-based histogram of a set of numbers. I've stumbled onto a strange thing. Toward the end of the process, I have this test:

if ( bindex < s )

"bindex" is the "index" of my "bin" (the array element that gets incremented whenever a number in the appropriate range is found. "s" is the "start" value-- that is, everything below that value is lumped together in a single bin. Now, here's the weird thing. I knew that I should have particular output. My script's output was exactly 2 higher, so I added a troubleshooting line:

print bindex "\t" bin[bindex] "\t" s

That should tell me everything that the script thinks is less than my start value. Here's the output:

1750 30 2000
1875 227 2000
10250 1 2000
12625 1 2000

The correct answer really is 257, but the above would produce 259, and as you can see, my awk script believes that 12625 is less than 2000, as is 10250! What gives? Shouldn't this be purely numeric, and so purely numeric rules apply? If not, how do I get it to use only numeric rules, such that 12625 is greater than 2000 like all those math teachers were so convinced of? Many thanks in advance.

Not really sure if I got you right. If the correct answer is 257, then that's probably the sum of all the second columns, if the first column is less than third column.

Code:

awk '{if($1<$3) s+=$2}END{print s}' file

Perhaps some context will help. This is incomplete, of course. I haven't yet added outputs for all results-- I'm just working on the "lowest" bin and rudimentary output for the rest. Once that works, I'll finish it, which should be easy enough.

So, what I do is take a number and increment a particular "bin"-- an array element-- depending on the value of that number. That's handled by this line:

Code:

bin[ ( i * int(($0 - 1) / i) + i)]++

Now, sometimes it's useful to be able to lump together everything below a certain value. Since the index of the array is simply the number describing the histogram values contained in the bin, I can just tell the script, "take all array elements whose index is less than the user-specified start value and dump them all into a single bin". I do that by the simple numeric test I described above. The problem, though, is that those values are not being properly tested. Why in the world would this script believe that 10000 is less than 2000? As special troubleshooting output, I have the script tell me which "bins" it's putting in the "everything less than user threshold" group. It puts these lines at the top, followed by the "normal" output. Here's a sample of numbers such as those that it will be used to test, sorted for reader convenience:

Code:

139
384
515
552
556
2128
2183
2234
2277
2284
2331
2385
2879
3281
3327
5035
5294
9401
9948
11458
13363

As you can see, there are 5 values below 2000-- yet, for some reason, the test says that there are 3, and the 3 it gives are over 10000. It almost seems to be applying some sort of alphabetic test, not numeric.

To test, save the values above as, say, "testvals". Save the script below as "hist.awk" and run:

./hist.awk -v i="125" -v s="2000" testvals

Code:

#! /usr/bin/awk -f

        {
        bin[ ( i * int(($0 - 1) / i) + i)]++
        }

END     {
        for (bindex in bin)
                {
                if ( bindex < s )
                        {
                        print bindex "\t" bin[bindex] "\t" s
                        hist[less] = hist[less] + bin[bindex]
                        }
                else
                        {
                        hist[bindex] = bin[bindex]
                        }
                }
                print "less\t" hist[less]
        }

Any thoughts? I'm thoroughly confused.