As swampyankee points out it would appear that although you think you have an integer, in fact you have a floating point number as the internal representation so your 255 is stored as 254.999999 which when you apply int to it gets truncated and results in the behaviour described. Using sprintf instead of int will probably behave as you desire.

$i = sprintf "%.0f", 254.99;
print "$i\n";

# printf/sprintf rounds rather than truncates using %f
# however %d works just like int()
printf "Number %.3f int %d sprintf %.0f\n",$_/7,$_/7,$_/7 for 1..100;
[download]

I recommend My floating point comparison does not work. Why ? and particularly the article What Every Scientist Should Know About Floating-Point Arithmetic

That's a good suggestion, but beware that sprintf uses the round-to-even method of rounding.

$ perl -e 'printf "%.0f\n", 2.5;'
2
$ perl -e 'printf "%.0f\n", 1.5;'
2
[download]

To get the usual "round up" method, I usually use int with the value plus a half.

$ perl -le '$x=1.5;print int($x+.5)';
2
$ perl -le '$x=2.5;print int($x+.5)';
3
[download]

Your data aren't integers; they've values like 254.99, and int truncates; it doesn't round. In addition to showing the code, you're going to have to show the offending data, too.

You'll almost certainly have to show us what you are doing in the extraction before we can offer any kind of explaination or workaround. Like pictures, the code paints a thousand words.

Show us the dozen lines of code in a runnable sample required to reproduce the problem (including the one short line of XML data).

Tell us what you see output by the code and what you expected to see, otherwise our best advice to you is to adjust the plimwobble parameter on the frobtizit transform.

Oh, and remember to use strictures (use strict; use warnings;).

When you say that it reduces by one those values, do you mean that if you read in 255 you get 254? Or is it if you read in 256 you get 255?

You could help us out a great deal with a code snippet and a data snippet so we can see what you are talking about.

>perl -le"print substr +(reverse unpack 'B*', pack 'd', shift), 12" .1
1101100110011001100110011001100110011001100101011001
  ^^^^ period

>perl -le"printf '%.16e', shift" .1
1.0000000000000001e-001
                 ^ error
[download]

The error isn't always obvious at first since the system does a little bit of rounding automatically, but some errors can easily be noticed when the error is compounded through addition.

>perl -le"$x=.1; $n=$x*100;         print int $n"
10

>perl -le"$x=.1; $n+=$x for 1..100; print int $n"
9
[download]

Note: reverse is needed on x86 machines since they store floats in little-endian order.

sub round { map{ int($_ + 0.5) @_ }
[download]

I am putting the code:: i am using following function to figure out range of a variable.. $range_data= find_range($max_data,$min_data,$step_data); I am passing the max value, min value and resolution. The function would return the range. the function definition is::

sub find_range
    {
        my $max=$_[0];
        my $min=$_[1];
        my $step=$_[2];
        my @step_part;
        my $range;
        $range=($max-$min)/($step_real);
        return($range);
    }
[download]

now when I do: $range_int= int($range_data); and try to print range_data and range_int i get different values.specifically 65535 becomes 65534 and 255 becomes 254. Also I know range_data is 65535 and not 65534.99 . Can anyone help me.

Either the code you posted is not the code you are using or you should be using the strict pragma. You are initializing a variable $step but you are dividing by a variable $step_real.

Also, please post a complete, self-contained, short program that demonstrates the issue. You talk about variables with names like range_data and range_int but never show how and where they are used.