my $helix_1 = [[-1.115,   8.537,   7.075],
               [-2.745,   5.280,   7.165],
...
[download]

Update: As johnqq notes, I need to make things agree. I'd probably do

my @helix_1 = ([-1.115....
[download]

I think you probably need to de-reference $helix_1 as you have created a ref. to a list, not a list.

The first atom should be $helix_1->[0] and the z component $helix_1->[0]->[2].

There are other notations to do de-referencing but this is the style I find most readable.

Cheers,

JohnGG

You can get as complicated as you want, but if you just need to calculate distances from atom to atom, then it don't really matter what helix they belong to, does it? So maybe

%atoms = (
   A  => [ -1.115,  8.537,  7.075 ],
   B  => [ -2.745,  5.280,  7.165 ],
   C  => [ -0.777,  3.267,  7.329 ],
   D  => [ 1.610,  5.225, 10.885 ],
   E  => [ 0.296,  5.263, 10.912 ],
   K  => [ -0.696, 13.041, 22.357 ],
   L  => [ 1.152, 11.081, 23.082 ],
   M  => [ 2.200, 17.590, 18.424 ],
);
[download]

Update: As an example of making things more complicated, if you need to retain all of the information, maybe your data structure would look like this (hashes all the way down):

%helixes = (
  helix1 => { 
    A  => { x => -1.115,  y => 8.537,  z => 7.075 },
    B  => { x => -2.745,  y => 5.280,  z=> 7.165 },
    ...
  },
  helix2 => {
    K  => { x => -0.696, y => 13.041, z => 22.357 },
    L  => { x => 1.152, y => 11.081, z => 23.082 },
    M  => { x => 2.200, y => 17.590, z => 18.424 },
  },
);
[download]

i suggest the arrayref with constants X,Y,Z

use constant { X=>0, Y=>1, Z=>2};
[download]

Then you can access the distance with:

$helix1{A}[X];
[download]

It uses an AoHoAoH. Since you haven't indicated if this is a programming assignment within your biology course I haven't commented the code. It is more complicated then it needs to be but that is so that it can easily be adapted to meet unstated requirements. Please ask questions if you don't understand.

If there are going to be many helices, I'd use a hash of hashes, where each element is an array reference:

$atoms{HELIX1}{A} = [ ( -1.115,   8.537,   7.075)];
[download]

Each atom has 3 positions.
You could use an associative array (i.e. hash) of positions (e.g. (x => $x, y => $y, z => $z)), but that's probably overkill.
Each atom can easily be represented by an array of positions (e.g. ($x, $y, $z)).

Each helix is made of atoms.
If you wish to name your atoms, a helix can easily be represented by an associative array (i.e. hash) of atom (e.g. (K => $atom0, L => $atom1, M => $atom2)).
If numerical indexes are sufficient identification for atoms, each helix can easily be represented by an array of atom (e.g. ($atom0, $atom1, $atom2)).
Let's go with names, since you already have names for them.

my %helix1 = (
   A => [ -1.115,  8.537,  7.075 ],
   B => [ -2.745,  5.280,  7.165 ],
   C => [ -0.777,  3.267,  7.329 ],
   D => [  1.610,  5.225, 10.885 ],
   E => [  0.296,  5.263, 10.912 ],
);

my %helix2 = (
   K => [ -0.696, 13.041, 22.357 ],
   L => [  1.152, 11.081, 23.082 ],
   M => [  2.200, 17.590, 18.424 ],
);
[download]

Each distance is has two index (the 'from' atom in the first helix and the 'to' atom in the second helix), so you'll need a 2D structure. We (I) decided above to use named atoms, so your distance map will be a 2D hash (e.g. $distance{A}{K} = distance($helix1{A}, $helix2{K});).

To populate %distance, think nested foreach loops. Good luck!