view release on metacpan or  search on metacpan

lib/Acme/KeyboardMarathon.pm  view on Meta::CPAN

    $self->{k}->{$key} += $shift_distance;
  }

  # override
  $self->{k}->{"\a"} = 0; # alarm
  $self->{k}->{"\b"} = 0; # backspace
  $self->{k}->{"\e"} = 0; # escape
  $self->{k}->{"\f"} = 0; # form feed
  $self->{k}->{"\r"} = 0; # carriage return

  return $self;
}

# split is 2m27.476s for 9.3megs of text (9754400 chars)
sub distance {
  my $k = shift->{k};

  my $bint = Math::BigInt->bzero;
  my $int  = 0;

  for my $i (0 .. $#_) {
    croak "FAR OUT! A REFERENCE: $_[$i]" if ref $_[$i];

    for ( split '', $_[$i] ) {
      unless ( defined $k->{$_} ) {
        carp 'WHOAH! I DON\'T KNOW WHAT THIS IS: [' . sprintf('%2.2x',ord($_)) . " : $_] assigning it a 2.5 cm distance\n";

        $k->{$_} = 250;
      }

      $int += $k->{$_};

      # Hold the value in a native int until it reaches an unsafe limit.
      # Then add to the BigInt, this avoids repeated slow calls to badd.
      #
      # To play it safe, this value is the max signed 32bit int minus
      # the max distance a key can be (| - 550), i.e.
      #   2 ** 31 - 551 = 2_147_483_097
      if ( $int >= 2_147_483_097 ) {
        $bint->badd($int);

        $int = 0;
      }
    }
  }

  # Add whatever remaining value we have in the native int.
  $bint->badd($int);

  $bint->bdiv(100);

  return $bint->bstr;
}

# substr is 2m30.419s
#sub distance {
#  my $self = shift @_;
#  my $distance = Math::BigInt->bzero();
#  for my $i (0 .. $#_) {
#    croak "FAR OUT! A REFERENCE: $_[$i]" if ref $_[$i];
#    my $length = length($_[$i]) - 1;
#    for my $s ( 0 .. $length ) {
#      my $char = substr($_[$i],$s,1);
#      unless ( defined $self->{k}->{$char} ) {
#        carp "WHOAH! I DON'T KNOW WHAT THIS IS: [$char] at $s assigning it a 2.5 cm distance\n";
#        $self->{k}->{$char} = 250;
#      }
#      $distance += $self->{k}->{$char};
#    }
#  }
#  $distance /= 100;
#  return $distance->bstr();
#}

# Regex is 2m32.690s
#sub distance {
#  my $self = shift @_;
#  my $distance = Math::BigInt->bzero();
#  for my $i (0 .. $#_) {
#    croak "FAR OUT! A REFERENCE: $_[$i]" if ref $_[$i];
#    while ( $_[$i] =~ /(.)/gs ) {
#      my $char = $1;
#      unless ( defined $self->{k}->{$char} ) {
#        carp "WHOAH! I DON'T KNOW WHAT THIS IS: [$char] assigning it a 2.5 cm distance\n";
#        $self->{k}->{$char} = 250;
#      }
#      $distance += $self->{k}->{$char};
#    }
#  }
#  $distance /= 100;
#  return $distance->bstr();
#}


1;
__END__

=head1 NAME

Acme::KeyboardMarathon - How far have your fingers ran?

=head1 SYNOPSIS

  use Acme::KeyboardMarathon;    

  my $akm = new Acme::KeyboardMarathon;

  my $distance_in_cm = $akm->distance($bigtext);

NB: Included in this distribution is an example script (marathon.pl) that can
be used to calculate distance from files provided as arguments:

  $> ./marathon.pl foo.txt bar.txt baz.txt
  114.05 m

=head1 DESCRIPTION

Acme::KeyboardMarathon will calculate the approximate distance traveled by
your fingers to type a given string of text.

This is useful to see just how many meter/miles/marathons your fingers have
ran for you to type your latest piece of code or writing.