Here's a simplistic mechanism that would probably benefit from using a GRT. It relies upon having a pre-ordered lookup table, here in the form of a simple space delimited string and the ordering is performed by the simple numerical comparision of the target position within the string.

#! perl -slw
use strict;

my $order = 'N CA C O CB CG CD1 CD2 CE1 CE2 CZ OH 2HB 3HB HD1 HD2 HE1 
+HE2 HH';


my @unordered = qw[ 2HB 3HB C CA CB CG CD1 CD2 CE1 CZ CE2 HE2 HE1 HH H
+D1 HD2 N O OH ];

print join' ', sort{ index( $order, $a ) <=> index( $order, $b ) } @un
+ordered;

__END__
P:\test>295668
N C CA O CB CG CD1 CD2 CE1 CE2 CZ OH 2HB 3HB HD1 HD2 HE1 HE2 HH
[download]

However, I suspect that you would like to not have to pre-construct the ordering of all possible compounds but would prefer their "weight" to be calculated according to your set of rules. That would be possible to do using a lookup hash mapping the symbols to weights and the some math to multiply by the number of hydrogens (terminology?).

To code this would require a clearer set of rules to work with. The only minor problem I see is parsing combined symbols -- do CA, CB, CD, CE, CZ break down into "C & A", "C & B"... etc. or are they intrinsic, but that is easily summountable.

Every atom name breaks down into 4 parts, which I already have broken up. The function atomName, simply returns the concatenation of all 4 parts.

Column 1 & 2 are the actual atomic element(1 or 2 letters, right-justified) except in the case of hydrogens, where column 1 is actually the number of the hydrogen.

Column 3 is the distance specified by a greek letter

Column 4, mostly empty, is the number of the heavy atom at the distance.

eg Leucine has two 'CD's so they are CD1 and CD2. the hydrogens respectively are: 1HD1, 2HD1, 3HD1, 1HD2, 2HD2 and 3HD3.

So weight can indeed be given. The highest weight would be given to atomnames that consist of the element only, N, C and O, and also to the 'first' Carbon, CA.

Thereafter, it matters little which heavy atom, only the distance is important, so the second tier of weights will be given to the distance: B,G,D,E,Z,H

Finally, the hydrogens are last, and their weights are threefold, their number followed by their distance, followed by their heavy atom number at that distance.

I'd started to 'weigh' things within the sortAtom function mentioned below this way:

foreach my $a (@names){
    if($a->atomName eq 'N'){
        $main{1}=$a;
    }elsif($a->atomName eq 'CA'){
        $main{2}=$a;
    }elsif($a->atomName eq 'C'){
        $main{3}=$a;
    }elsif($a->atomName eq 'O' || $a->atomName eq 'O\''){
        $main{4}=$a;
    }
    }
[download]

my aim was to then do this:

foreach my $i (sort {$a <=> $b} keys %main){
  push @values, $main{$i};
}
[download]

Is this what you're getting at browserUk?

Thanks
Sam

Sorry, but you are still couching this is terms I don't really understand. They may be second nature to you, but the terms, "distances, "N-terminals", "main chains" etc. all have a meaning to me, but not one that makes any sense in this context. You should try to phrase your questions in terms people without your specialist knowledge can understand if you are to get a good response.

Every atom name breaks down into 4 parts, which I already have broken up. The function atomName, simply returns the concatenation of all 4 parts.

Column 1 & 2 are the actual atomic element(1 or 2 letters, right-justified) except in the case of hydrogens, where column 1 is actually the number of the hydrogen.

Column 3 is the distance specified by a greek letter

Column 4, mostly empty, is the number of the heavy atom at the distance.

eg Leucine has two 'CD's so they are CD1 and CD2. the hydrogens respectively are: 1HD1, 2HD1, 3HD1, 1HD2, 2HD2 and 3HD3.

What this tells me is that you have the four parts that decide the sort order already separated, but that you are concatenating these together in order to sort them. This results in a variable length enitity, where

• the first 1 or two characters are a single element

  ....except that sometimes the first character actually is a number which acts as a multiplier.

• The 3rd character is the second element,

  ...except that if the first element is only a single character, then this element is actually in the second character position,

  unless of course the first element is a single character and is prefixed by this "multiplier" number in which case its back to the 3rd character position.

  What about the possibility that the first element is two characters (CA?) and is also prefixed by a "multiplier" number?

  Does this mean that the second element could also be in the 4th character position?

  Can the "multiplier" number be 2 digits long? Could the second element (one of your 6 single-character "distances") actually be located in either the 2nd, 3rd or 4th character position?

• The there is your 3rd element, which may or may not exist, but if it does, probably lives in the 4th character position, but you dont make it clear whether it might also be present when the first element is a single character that isn't preceeded by a "multiplier digit(s), so it maybe could be in the 3rd character position sometimes?

I realise that I have exaggerated this somewhat. It is possible to infer (or negate the possibilities) from your description, butthere are still enough left to make it extremely difficult to know where to begin in trying to help you.

Suffice to say, if the rest of your application could be bent to handling the attoms as arrays or hashes where the parts are separate, it would make the sorting easier. Never the less, I *think* that this would do the trick. It's a fairly standard ST in its basic layout, but the devil is in the details. The values used for the comparisons are numerical weights which are calculated in the first mapping.

The awkward part was n coming up with a mapping that spread the possible variations and combinations into a number space such that the result met your requirements. It uses two hash table lookups. The first %mainAtoms establishes the basic ordering in the range 1 .. 9. The second, %distances using floating point multipliers to map N[BGDEZH] to 10.0 .. 10 .5;  CA[BGDEZH] to 20.0 .. 20.5 and so on upto 5H[BGDEZH] to 90.0 .. 90.5. The third, numeric element of the atomNames is divided by 100 and added, thus providing the final arbitration.

#! perl -slw
use strict;

## Lookup table to map main atoms to a numerical value

my %mainAtoms = (
    ''  => 0,    N  => 1,  CA  => 2,   C  => 3,   O  => 4,
     H  => 5,  '2H' => 6, '3H' => 7, '4H' => 8, '5H' => 9
);

## Lookup table for "distance"  multiplier
## Using '' => 1 ensures that unadorned main atom weights
## remain in the range 1 to 9.
## Using 10.n  for the distance weights
## maps the weights to 10.0 .. 10.5 for N,
##                     20.0 .. 20.5 for CA etc.

my %distances = (
    '' => 1, B => 10.0, G => 10.1, D => 10.2,
    E => 10.3,  Z => 10.4, H => 10.5
);

## Some test data.

my @unordered = qw[
    2HB 3HB C CA CB CG CD1 CD2 CE1
    CZ CE2 HE2 HE1 HH HD1 HD2 N O OH
];

## The following is a 'standard' Swartzian Transform
## You have to read the blocks backwards to understand the process.

my @sorted = map{

## This just maps the original value back
## from the anonymous array created below

    $_->[ 1 ]

} sort {

## This sorts the anonymous arrays according to
## the numerical value in element 0 of the Anon. arrays
## This is the weight calculated below

    $a->[ 0 ] <=> $b->[ 0 ]

} map {

## The first part of the transform extracts the 3 fields
## from the catenated atomName into $1, $2, $3 or dies if it fails

    m[

        ( N | CA | O | C | (?: \d?H ) )
        ( [BGDEZH] )?
        ( \d  )?
    ]x or die "Failed to separate '$_'";

## This builds the anon. arrays. The atomName is in ->[ 1 ]
## The calculated weight is in ->[ 0 ]

    [
        $mainAtoms{ $1 }             ## 1 .. 9

        * $distances{ $2 || ''}      ## 1 or 10.x

        + ( $3 || 0 )/100            ## 0 or 0.0n

        , $_                         ## The atomName
    ]
} @unordered; ## The unordered data.

## Display the results

print join ' | ', @sorted;
__END__

P:\test>295668
N | CA | C | O | CB | CG | CD1 | CD2 | CE1 | CE2 | CZ | 
OH | HD1 | HD2 | HE1 | HE2 | HH | 2HB | 3HB
[download]

---

Examine what is said, not who speaks.

"Efficiency is intelligent laziness." -David Dunham
"When I'm working on a problem, I never think about beauty. I think only how to solve the problem. But when I have finished, if the solution is not beautiful, I know it is wrong." -Richard Buckminster Fuller
If I understand your problem, I can solve it! Of course, the same can be said for you.

I've never really understood anonymous subroutines, or inline subroutines, which is what you usually do with sort. But I imagine I should create a named subroutine that returns 1,0 or -1 according to my own criteria as listed above, am I right?

You are right there. Create a sub that when given any 2 atoms, returns 1 if the first is larger than the second, 0 if they are equal, or -1 if the first is smaller than the second, for whatever definition of larger, equal and smaller you are using. (Note: use $a and $b for the first and second atom given to the sub, as in my example below).

As for the inline/anonymous subs for sort, they are fairly simple. For example if you had:

sub foo {
   return $a cmp $b
}
my @sorted = sort foo @unsorted;
[download]

my @sorted = sort { return $a cmp $b } @unsorted;
[download]

my @sorted = sort { $a cmp $b } @unsorted;
[download]

That's pretty much all there is to using an anonymous sub with sort. Of course, if you are using the same sort in more than 1 place, it would be better to make a named sub, that way you only have to change 1 thing if you decide to sort differently later.

Ok, I think I understand a bit more now, but ive got more questions if you dont mind

OK, where do $a and $b come from, are they implicit within 'foo' or are they from 'sort' itself.

I ask because I have a slight OO problem, $a and $b in my case are actually unique reference numbers to atoms in: $self->{'atoms'}.

The function I do the sort in is in the same object and has '$self' defined, but if the 'foo' function resides in the same object, how do I pass $self, or else access the object's hash in order to access the atom objects themselves...

In other words, in foo, I really need to do this:

sub foo {
   return $self->{'atoms'}{$a}->atomName cmp $self->{'atoms'}{$b}->ato
+mName;
}
my @sorted = sort foo @unsorted;
[download]

Any pointers?
Cheers
Sam

Sorting functions are not that hard - don't be afraid, read the docs, try a simple one or two.

However the logic on something like this can get involved. I often like to transform the original value into a string that will sort easily using a very simple sort function.

In this case, I transform all atoms into a string that will sort ascabetically. A regex matches the different components of the name. Then we look up the sort values from a couple of handy hashes. Fill in default values (no value for a component means sort early).

Caveat: I know nothing about atoms, so I'm working purely from your description. I've two weighting hashes in the script. The one called 'main' doesn't correspond exactly to the 'main chain' bits described, but rather corresponds to the bit that isn't a greek or number part.

Well, the explanatory paragraph may not make sense, but hopefully the code will be clearer:

#!/usr/bin/perl -w

use strict;

my @unordered = qw( 
  2HB 3HB C CA CB CG CD1 
  CD2 CE1 CZ CE2 HE2 HE1
  HH HD1 HD2 N O OH
);

# weighting hashes
my %main = (
  N => '1',
  CA => '2',
  C => '3',
  O => '4', 
  S => '5',
  P => '6',
  H => '7',
);

my %greek = (
  B => '1',
  G => '2',
  D => '3',
  E => '4',
  Z => '5',
  H => '6', 
);

sub sortable {
  my $atom = shift;

  # get components
  $atom =~ /(\d)?(N|CA|C|O|S|P|H)(B|G|D|E|Z|H)?(\d)?/;
  my ($left,$main,$greek,$right) = ( $1, $2, $3, $4 );

  # get weights or use default early sorting values
  $main = $main ? $main{ $main } : '0';
  my $main_alone; # need to flag if main element is alone
  if ( $greek ) {
    $main_alone = '1';
    $greek = $greek{ $greek };
  } else {
    $main_alone = '0';
    $greek = '0';
  } 
  $left  ||= '0';
  $right ||= '0';

  # I assume that left numbers take precedence over right
  "$main_alone$main$greek$left$right";   
}

# use the string "cmp" operator - we are comparing strings,
# not numbers. We could have populated
# the weighting hashes with letters instead of numbers

my @ordered = sort { sortable( $a ) cmp sortable( $b ) } @unordered;

# if you have to get the value out of an object it would be:
# @ordered = sort { sortable( $a->AtomName ) cmp sortable( $b->AtomNam
+e ) } @unordered;

print join "\n", map { $_ ."\t". sortable( $_ ) } @ordered;
[download]

Which gives:

N       01000
CA      02000
C       03000
O       04000
CB      13100
CG      13200
CD1    13301
CD2    13302
CE1     13401
CE2     13402
CZ      13500
OH      14600
2HB     17120
3HB     17130
HD1     17301
HD2     17302
HE1     17401
HE2     17402
HH      17600
[download]

Woke up this morning thinking it could be much simpler. This time I do use a numeric sort:

#!/usr/bin/perl -w

use strict;

my @unordered = qw( 
  2HB 3HB C CA CB CG CD1 CD2 CE1 CZ CE2 HE2 HE1 HH HD1 HD2 N O OH
);

# change weighting
my %main = (
  N => 1, CA => 2, C => 3, O => 4, 
  S => 100, P => 200, H => 1000,
);

my %greek = (
  B => 1, G => 2, D => 3, E => 4, Z => 5, H => 6, 
);

sub sortable {
  my $atom = shift;
  $atom =~ /(\d)?(N|CA|C|O|S|P|H)(B|G|D|E|Z|H)?(\d)?/;

  # we may have empty groups, so quiet warnings
  no warnings 'uninitialized';

  # make a number that sorts
  # keep parts at different orders of magnitude so they don't conflict
  $main{ $2 } 
    + ( $greek{ $3 } * 100 ) 
    + ( $1 * 20 )
    + ( $4 * 10 );
}

# operator changed to numeric comparison 
my @ordered = sort { sortable( $a ) <=> sortable( $b ) } @unordered;

print join "\n", map { $_ ."\t". sortable( $_ ) } @ordered;
[download]

Gives:

N       1
CA      2
C       3
O       4
CB      103
CG      203
CD1     313
CD2     323
CE1     413
CE2     423
CZ      503
OH      604
2HB     1140
3HB     1160
HD1     1310
HD2     1320
HE1     1410
HE2     1420
[download]

Thats great, just what I started to work on, thanks so much!

Cheers
S