Reg using hash of arrays in foreach loop

4,059

Expert 2GB

Assuming everything else is good with your code:

Expand|Select|Wrap|Line Numbers

 
open (OUT, ">>" , 'path/to/outfile.txt') or die "$!";

my @aa_split = split //, $aa;

foreach my $val (@{hash{@aa_split}}){

   print OUT "@{$val} ";

}

print " \n";

close OUT;

Oct 28 '08 #4

Assuming everything else is good with your code:

Expand|Select|Wrap|Line Numbers

open (OUT, ">>" , 'path/to/outfile.txt') or die "$!";

my @aa_split = split //, $aa;

foreach my $val (@{hash{@aa_split}}){

print OUT "@{$val} ";

}

print " \n";

close OUT;

Hi Kevin,
The code that you added, does not give the desired output of all permutation of the word "VEFCDAMP". This particular code is the one that I wrote as an extention of your previous code given in the thread ( http://bytes.com/forum/thread847179.html ) for fixed input like "VEFCDAMP" (your code is also pasted in this topic) . I tried here to extend the code for all possible input word (generalization) and the number of possible letter is only 20 (for my case) and the maximum size of any word never going to exceed 10 letters, thats why I thought of iterating only the desired letter in foreach loop to save computational time, otherwise I tried for all possible foreach loop for 20 letters and it goes on and on in my system.

Hope you can understand my problem by reading the previous thread and also this thread.

Thanks in advance,
B.Nataraj

Oct 29 '08 #5

4,059

Expert 2GB

I'm sorry but your current requirements are out of my range of experience. Trying to make a list of all possible permutations from an arbitrarily deep list of arrays is something I have no experience with.

Oct 29 '08 #6

410

Expert 256MB

Nataraj,

When you are taking input dynamically, it would be difficult to get all permutations if the length of input string varies. But if it is fixed at 8 as in VEFCDAMP, then you should be able to do it using 8 foreach loops as you have done in the second script.

Oct 29 '08 #7

Nataraj,

When you are taking input dynamically, it would be difficult to get all permutations if the length of input string varies. But if it is fixed at 8 as in VEFCDAMP, then you should be able to do it using 8 foreach loops as you have done in the second script.

Hi nithin & Kevin,
Ok then, Is there any other way to address this problem ? I mean otherthan using foreach loop.

Thanks ,
B.Nataraj

Oct 29 '08 #8

4,059

Expert 2GB

This is what I came up with although I am not sure its what you want and it means you will have to install the List::Permutor module and any of its dependencies.

This is a script with all extraneous code removed just so we can get the permutations given a list of letters.

Expand|Select|Wrap|Line Numbers

 
use List::Permutor;

my $seq = 'VF';

my %hash = ( 

   L => ['CTT','CTC','CTA','CTG','TTA','TTG'],

   S => ['TCT','TCC','TCA','TCG','AGT','AGC'],

   R => ['CGT','CGC','CGA','CGG','AGA','AGG'],

   V => ['GTT','GTC','GTA','GTG'],

   A => ['GCT','GCC','GCA','GCG'],

   G => ['GGT','GGC','GGA','GGG'],

   P => ['CCT','CCC','CCA','CCG'],

   T => ['ACT','ACC','ACA','ACG'],

   I => ['ATT','ATC','ATA'],

   F => ['TTT','TTC'],

   C => ['TGT','TGC'],

   Y => ['TAT','TAC'],

   Q => ['CAA','CAG'],

   N => ['AAT','AAC'],

   H => ['CAT','CAC'],

   E => ['GAA','GAG'],

   D => ['GAT','GAC'],

   K => ['AAA','AAG'],

   M => ['ATG'],

   W => ['TGG'],

);
 
my @loops = split '', $seq;

my @AoA;

foreach my $letter (@loops) {

   push @AoA, @{$hash{$letter}};

}

my $p = List::Permutor->new(@AoA);

{

   local $";

   while(my @set = $p->next) {

      print "@set\n";

   }

}

I used a very small list of letters (VF) because for a long string of letters all the possible premutations is a large number and takes a little while to run. Basically 'VF' has 6 unique codons, so there is a possible 720 unique permutations (UP) just for those:

UP = 1*2*3*4*5*6 = 720

if you add one more unique codon the number obviously grows exponentially to 5,040. You will probably be OK until you get into the range of 10 unique codons in which case the UP is 3,628,800. A fast computer could figure out the permutations quickly, but writing them all to a file is what will take time.

Oct 29 '08 #9

This is what I came up with although I am not sure its what you want and it means you will have to install the List::Permutor module and any of its dependencies.

This is a script with all extraneous code removed just so we can get the permutations given a list of letters.

Expand|Select|Wrap|Line Numbers

use List::Permutor;

my $seq = 'VF';

my %hash = (

   L => ['CTT','CTC','CTA','CTG','TTA','TTG'],

   S => ['TCT','TCC','TCA','TCG','AGT','AGC'],

   R => ['CGT','CGC','CGA','CGG','AGA','AGG'],

   V => ['GTT','GTC','GTA','GTG'],

   A => ['GCT','GCC','GCA','GCG'],

   G => ['GGT','GGC','GGA','GGG'],

   P => ['CCT','CCC','CCA','CCG'],

   T => ['ACT','ACC','ACA','ACG'],

   I => ['ATT','ATC','ATA'],

   F => ['TTT','TTC'],

   C => ['TGT','TGC'],

   Y => ['TAT','TAC'],

   Q => ['CAA','CAG'],

   N => ['AAT','AAC'],

   H => ['CAT','CAC'],

   E => ['GAA','GAG'],

   D => ['GAT','GAC'],

   K => ['AAA','AAG'],

   M => ['ATG'],

   W => ['TGG'],

);

my @loops = split '', $seq;

my @AoA;

foreach my $letter (@loops) {

   push @AoA, @{$hash{$letter}};

}

my $p = List::Permutor->new(@AoA);

{

   local $";

   while(my @set = $p->next) {

      print "@set\n";

   }

}

I used a very small list of letters (VF) because for a long string of letters all the possible premutations is a large number and takes a little while to run. Basically 'VF' has 6 unique codons, so there is a possible 720 unique permutations (UP) just for those:

UP = 1*2*3*4*5*6 = 720

if you add one more unique codon the number obviously grows exponentially to 5,040. You will probably be OK until you get into the range of 10 unique codons in which case the UP is 3,628,800. A fast computer could figure out the permutations quickly, but writing them all to a file is what will take time.

Hi Kevin,
Thanks once again for your help. It took some time for me to install the List::Permutor module into my system and so a delay in replying you, now your code is working fine but as you said it goes on exponential time for a larger size input. I have not much gone in detail of your code, Hope I soon understand it and will come back to you.

With Thanks,
B.Nataraj

Oct 30 '08 #10

Hi Kevin,
Thanks once again for your help. It took some time for me to install the List::Permutor module into my system and so a delay in replying you, now your code is working fine but as you said it goes on exponential time for a larger size input. I have not much gone in detail of your code, Hope I soon understand it and will come back to you.

With Thanks,
B.Nataraj

Hi Kevin,
Sorry about my last reply, I just carried away by seeing new code and implementing new module and running the code. Infact your new code is not doing the right job, To say it short to you , I wanted the output for the word "VF" (you took this word as sample in your code) like the one come out of the following code (This is also your code) , The total permutation would be 512.

Expand|Select|Wrap|Line Numbers

 use strict;

use warnings;

my @V=('GTT','GTC','GTA','GTG');

my @A=('GCT','GCC','GCA','GCG');

my @E=('GAA','GAG');

my @F=('TTT','TTC');

my @G=('GGT','GGC','GGA','GGG');

my @H=('CAT','CAC');

my $i = 1;

foreach my $v (@V) {

   foreach my $a (@A) {

      foreach my $e (@E) {

         foreach my $f (@F) {

            foreach my $g (@G) {

               foreach my $h (@H) {

                  print "$i $v$f\n";

                  $i++;

               }

            }

         }

      }

   }

}

Hope you can now better understand the problem. In mean time I am trying to change your code the way I wanted it is to be.

Thanks for your all help,
B.Nataraj

Oct 31 '08 #11

410

Expert 256MB

Hi Kevin,
Sorry about my last reply, I just carried away by seeing new code and implementing new module and running the code. Infact your new code is not doing the right job, To say it short to you , I wanted the output for the word "VF" (you took this word as sample in your code) like the one come out of the following code (This is also your code) , The total permutation would be 512.
Thanks for your all help,
B.Nataraj

The total permutation for 'VF' should not be 512. It will be 8. The script you have shown will just create multiple duplicates to produce 512 results, because of usage of unnecessary foreach loops.

Expand|Select|Wrap|Line Numbers

 
use strict; 

use warnings; 

my @V=('GTT','GTC','GTA','GTG'); 

my @A=('GCT','GCC','GCA','GCG'); 

my @E=('GAA','GAG'); 

my @F=('TTT','TTC'); 

my @G=('GGT','GGC','GGA','GGG'); 

my @H=('CAT','CAC'); 

my $i = 1; 
 
         foreach my $v (@V ){           

               foreach my $f (@F) { 

                  print "$i $v$f\n"; 

                  $i++; 

               } 

            }

However, I haven't tested the output using List::Permutor. I will check it in my free-time and compare the output.

-Nithin

Oct 31 '08 #12

The total permutation for 'VF' should not be 512. It will be 8. The script you have shown will just create multiple duplicates to produce 512 results, because of usage of unnecessary foreach loops.

Expand|Select|Wrap|Line Numbers

use strict;

use warnings;

my @V=('GTT','GTC','GTA','GTG');

my @A=('GCT','GCC','GCA','GCG');

my @E=('GAA','GAG');

my @F=('TTT','TTC');

my @G=('GGT','GGC','GGA','GGG');

my @H=('CAT','CAC');

my $i = 1;

         foreach my $v (@V ){

               foreach my $f (@F) {

                  print "$i $v$f\n";

                  $i++;

               }

            }

However, I haven't tested the output using List::Permutor. I will check it in my free-time and compare the output.

-Nithin

Hi Nithin,

Sorry about my careless mistake and thanks for correcting it. Looking forward your next reply.

B.Nataraj

Oct 31 '08 #13

4,059

Expert 2GB

The total permutation for 'VF' should not be 512. It will be 8. The script you have shown will just create multiple duplicates to produce 512 results, because of usage of unnecessary foreach loops.

Expand|Select|Wrap|Line Numbers

use strict;

use warnings;

my @V=('GTT','GTC','GTA','GTG');

my @A=('GCT','GCC','GCA','GCG');

my @E=('GAA','GAG');

my @F=('TTT','TTC');

my @G=('GGT','GGC','GGA','GGG');

my @H=('CAT','CAC');

my $i = 1;

         foreach my $v (@V ){

               foreach my $f (@F) {

                  print "$i $v$f\n";

                  $i++;

               }

            }

However, I haven't tested the output using List::Permutor. I will check it in my free-time and compare the output.

-Nithin

8? Then you are not talking about permutations. VF will produce 512 unique permutations with no duplicates assuming all 6 codons can be in all six positions of each permutation.

Using VF as an example, I think your requirements are:

V (first position)
F (second position)

So all the codons in @V can only ever occupy the first position of the permutations you desire. All codons in @F can only occupy the second position. There are only two positions because that is the number of letters/arrays. Using VFas the example, there can not be a permutation with TTT or TTC in the first position, for example:

TTTGTT
TTCGTT

Is that correct?

Oct 31 '08 #14

8? Then you are not talking about permutations. VF will produce 512 unique permutations with no duplicates assuming all 6 codons can be in all six positions of each permutation.

Using VF as an example, I think your requirements are:

V (first position)
F (second position)

So all the codons in @V can only ever occupy the first position of the permutations you desire. All codons in @F can only occupy the second position. There are only two positions because that is the number of letters/arrays. Using VFas the example, there can not be a permutation with TTT or TTC in the first position, for example:

TTTGTT
TTCGTT

Is that correct?

Hi Kevin,

Exactly... yea the position should not be interchanged.

Thanks,
B.Nataraj

Oct 31 '08 #15

410

Expert 256MB

Hi Kevin,

Exactly... yea the position should not be interchanged.

Thanks,
B.Nataraj

List::Permutor is not the module of choice then. It will produce all possible combinations/ orders of list elements. E.g for a list with elements - 'A', 'B', 'C'.,
the possible combinations are:
A, B, C
A, C, B
B, A, C
B, C, A
C, A, B
C, B, A

But, what you are looking for is something like A can be constituted by three possible sets of codons, B by two etc.
I believe there are Bio-Perl modules which do the job that you are looking for.

Oct 31 '08 #16

List::Permutor is not the module of choice then. It will produce all possible combinations/ orders of list elements. E.g for a list with elements - 'A', 'B', 'C'.,
the possible combinations are:
A, B, C
A, C, B
B, A, C
B, C, A
C, A, B
C, B, A

But, what you are looking for is something like A can be constituted by three possible sets of codons, B by two etc.
I believe there are Bio-Perl modules which do the job that you are looking for.

Hi Nithin,

Before coming to this forum, I tried possible code for the same in bioperl module and all possible code depository for any snippet to do my objective but my search ended in vein. Technically the approach is called "Back-translation"(bioinformatics term). More the Bioinformatics problem that I try to address here is so unique and rare and it may not be a regular requirement for many , that’s why I suppose that this is not there to find in bioperl. that’s how I started to develop my own code and sought the help from this forum. Anyhow I would try again there then.

Thanks ,
B.Nataraj

Oct 31 '08 #17

410

Expert 256MB

Hi Nithin,

Before coming to this forum, I tried possible code for the same in bioperl module and all possible code depository for any snippet to do my objective but my search ended in vein. Technically the approach is called "Back-translation"(bioinformatics term). More the Bioinformatics problem that I try to address here is so unique and rare and it may not be a regular requirement for many , that’s why I suppose that this is not there to find in bioperl. that’s how I started to develop my own code and sought the help from this forum. Anyhow I would try again there then.

Thanks ,
B.Nataraj

Here is one way of doing it. This code dynamically generates required foreach loops and executes the command.

Expand|Select|Wrap|Line Numbers

 
 my $seq = 'VF'; 

my %hash = (  

   L => ['CTT','CTC','CTA','CTG','TTA','TTG'], 

   S => ['TCT','TCC','TCA','TCG','AGT','AGC'], 

   R => ['CGT','CGC','CGA','CGG','AGA','AGG'], 

   V => ['GTT','GTC','GTA','GTG'], 

   A => ['GCT','GCC','GCA','GCG'], 

   G => ['GGT','GGC','GGA','GGG'], 

   P => ['CCT','CCC','CCA','CCG'], 

   T => ['ACT','ACC','ACA','ACG'], 

   I => ['ATT','ATC','ATA'], 

   F => ['TTT','TTC'], 

   C => ['TGT','TGC'], 

   Y => ['TAT','TAC'], 

   Q => ['CAA','CAG'], 

   N => ['AAT','AAC'], 

   H => ['CAT','CAC'], 

   E => ['GAA','GAG'], 

   D => ['GAT','GAC'], 

   K => ['AAA','AAG'], 

   M => ['ATG'], 

   W => ['TGG'], 

); 
 
my @loops = split '', $seq; 

my $cmd;

local $i=0;

my $vars;
 
foreach my $letter (@loops) {

    my ($str,$v)= createloop($letter);

    $vars.=$v;

    $cmd.=$str;

} 

$cmd=$cmd.'print'. " \"$vars\\n\";";  ## adding print statement

$cmd.= '}'x$i;       ### ending statement blocks
 
eval {eval $cmd; };   ## first eval returns statement block
 
##creating foreach loops 

sub createloop {

$i++;

my $var ='$a'.$i;

return ("foreach $var (qw(@{$hash{$_[0]}})) {",$var) ;
 
}

Oct 31 '08 #18

Here is one way of doing it. This code dynamically generates required foreach loops and executes the command.

Expand|Select|Wrap|Line Numbers

my $seq = 'VF';

my %hash = (

   L => ['CTT','CTC','CTA','CTG','TTA','TTG'],

   S => ['TCT','TCC','TCA','TCG','AGT','AGC'],

   R => ['CGT','CGC','CGA','CGG','AGA','AGG'],

   V => ['GTT','GTC','GTA','GTG'],

   A => ['GCT','GCC','GCA','GCG'],

   G => ['GGT','GGC','GGA','GGG'],

   P => ['CCT','CCC','CCA','CCG'],

   T => ['ACT','ACC','ACA','ACG'],

   I => ['ATT','ATC','ATA'],

   F => ['TTT','TTC'],

   C => ['TGT','TGC'],

   Y => ['TAT','TAC'],

   Q => ['CAA','CAG'],

   N => ['AAT','AAC'],

   H => ['CAT','CAC'],

   E => ['GAA','GAG'],

   D => ['GAT','GAC'],

   K => ['AAA','AAG'],

   M => ['ATG'],

   W => ['TGG'],

);

my @loops = split '', $seq;

my $cmd;

local $i=0;

my $vars;

foreach my $letter (@loops) {

    my ($str,$v)= createloop($letter);

    $vars.=$v;

    $cmd.=$str;

}

$cmd=$cmd.'print'. " \"$vars\\n\";";  ## adding print statement

$cmd.= '}'x$i;       ### ending statement blocks

eval {eval $cmd; };   ## first eval returns statement block

##creating foreach loops

sub createloop {

$i++;

my $var ='$a'.$i;

return ("foreach $var (qw(@{$hash{$_[0]}})) {",$var) ;

}

Hi Nithin,

Thank you very much for the code, it does great and meet my objective.
I really thankful for you and Kevin for extending your kind help to me.

You guys are doing really a fantastic job.

Thanks once again,
B.Nataraj

Oct 31 '08 #19

4,059

Expert 2GB

nithinpes has posted a very interesting solution, but I urge caution using it since eval will run any code it evaluates. Just make sure you don't accidently introduce something unwise into the eval block. Its fine as its written, but read up on eval before making any changes that might have serious side effects.

Oct 31 '08 #20

4,059

Expert 2GB

Heres a solution that does not use eval, but I would benchmark my code and nithinpes code when you get a chance and see if one is better than the other.

Expand|Select|Wrap|Line Numbers

 
use warnings;

use strict; 

my $seq = 'VF'; 

my %hash = (  

   L => ['CTT','CTC','CTA','CTG','TTA','TTG'], 

   S => ['TCT','TCC','TCA','TCG','AGT','AGC'], 

   R => ['CGT','CGC','CGA','CGG','AGA','AGG'], 

   V => ['GTT','GTC','GTA','GTG'], 

   A => ['GCT','GCC','GCA','GCG'], 

   G => ['GGT','GGC','GGA','GGG'], 

   P => ['CCT','CCC','CCA','CCG'], 

   T => ['ACT','ACC','ACA','ACG'], 

   I => ['ATT','ATC','ATA'], 

   F => ['TTT','TTC'], 

   C => ['TGT','TGC'], 

   Y => ['TAT','TAC'], 

   Q => ['CAA','CAG'], 

   N => ['AAT','AAC'], 

   H => ['CAT','CAC'], 

   E => ['GAA','GAG'], 

   D => ['GAT','GAC'], 

   K => ['AAA','AAG'], 

   M => ['ATG'], 

   W => ['TGG'], 

); 
 
my @letters = split '', $seq; 

my $loops = 1;

foreach my $L (@letters) {

   $loops *= @{$hash{$L}};

}

my @perms;

foreach my $S (@letters) {

   my @t = @{$hash{$S}};

   for my $i (0..$loops-1) {

      my $c = shift @t;

      $perms[$i] .= $c;

      push @t, $c;

   }

}

my $i = 1;

foreach my $s (@perms) {

   print $i++, " $s\n";

}

I'm not sure how efficient my use of "shift" and "push" is to loop through the arrays over and over the number of times necessary.

Oct 31 '08 #21

Heres a solution that does not use eval, but I would benchmark my code and nithinpes code when you get a chance and see if one is better than the other.

Expand|Select|Wrap|Line Numbers

use warnings;

use strict;

my $seq = 'VF';

my %hash = (

   L => ['CTT','CTC','CTA','CTG','TTA','TTG'],

   S => ['TCT','TCC','TCA','TCG','AGT','AGC'],

   R => ['CGT','CGC','CGA','CGG','AGA','AGG'],

   V => ['GTT','GTC','GTA','GTG'],

   A => ['GCT','GCC','GCA','GCG'],

   G => ['GGT','GGC','GGA','GGG'],

   P => ['CCT','CCC','CCA','CCG'],

   T => ['ACT','ACC','ACA','ACG'],

   I => ['ATT','ATC','ATA'],

   F => ['TTT','TTC'],

   C => ['TGT','TGC'],

   Y => ['TAT','TAC'],

   Q => ['CAA','CAG'],

   N => ['AAT','AAC'],

   H => ['CAT','CAC'],

   E => ['GAA','GAG'],

   D => ['GAT','GAC'],

   K => ['AAA','AAG'],

   M => ['ATG'],

   W => ['TGG'],

);

my @letters = split '', $seq;

my $loops = 1;

foreach my $L (@letters) {

   $loops *= @{$hash{$L}};

}

my @perms;

foreach my $S (@letters) {

   my @t = @{$hash{$S}};

   for my $i (0..$loops-1) {

      my $c = shift @t;

      $perms[$i] .= $c;

      push @t, $c;

   }

}

my $i = 1;

foreach my $s (@perms) {

   print $i++, " $s\n";

}

I'm not sure how efficient my use of "shift" and "push" is to loop through the arrays over and over the number of times necessary.

Hi Kevin,

Thanks for your new code and pointing out possible pitfall. In fact I am half way down my real work and another half way to pass on. I am making the remaining code and hopefully that wont be so difficult logic to make it out and all about string manipulation and once entire code is ready and I will be in a position to check yours and nithin for a real time problem and I hope can give you my feedback very soon.

B.Nataraj

Nov 1 '08 #22

Hi Kevin,

The last code you have posted, is in fact repeating the first four sequence as output but it make up to the desired 512 (for a input seqnence of VAEFGH) sequence as per rule. But the alternative code by Nithin is working just fine for creating all possible combination and there is no repetition.

I just happened to compare this bug in your code at the last stage of implementing in my entire code using your code as a starting point. I could not fix in it and possibly you can do it quickly so I am posting it to you once again.

Thanks,
B.Nataraj

Nov 5 '08 #23

(I tried to delete this message, but I could not do it)

Hi Kevin,
Sorry I did not mention my input sequence in my previous message, here it is "VAEFGH".

Thanks,
B.Nataraj

Nov 5 '08 #24

4,059

Expert 2GB

(I tried to delete this message, but I could not do it)

Hi Kevin,
Sorry I did not mention my input sequence in my previous message, here it is "VAEFGH".

Thanks,
B.Nataraj

hmmm...guess I made a logical error in the code I wrote. I'll look at it later today and see if I can find the error.

Nov 5 '08 #25

4,059

Expert 2GB

well, I can't get it to work. I think you are will need to use nithinpes code or wait and see if someone else can help or post on www.perlmonks.com and see if one of the members there has a suggestion.

Nov 6 '08 #26

Hi Kevin,
Ok, I will use nithin's code then.

Thanks,
B.Nataraj

Nov 6 '08 #27

Here is one way of doing it. This code dynamically generates required foreach loops and executes the command.

Expand|Select|Wrap|Line Numbers

my $seq = 'VF';

my %hash = (

   L => ['CTT','CTC','CTA','CTG','TTA','TTG'],

   S => ['TCT','TCC','TCA','TCG','AGT','AGC'],

   R => ['CGT','CGC','CGA','CGG','AGA','AGG'],

   V => ['GTT','GTC','GTA','GTG'],

   A => ['GCT','GCC','GCA','GCG'],

   G => ['GGT','GGC','GGA','GGG'],

   P => ['CCT','CCC','CCA','CCG'],

   T => ['ACT','ACC','ACA','ACG'],

   I => ['ATT','ATC','ATA'],

   F => ['TTT','TTC'],

   C => ['TGT','TGC'],

   Y => ['TAT','TAC'],

   Q => ['CAA','CAG'],

   N => ['AAT','AAC'],

   H => ['CAT','CAC'],

   E => ['GAA','GAG'],

   D => ['GAT','GAC'],

   K => ['AAA','AAG'],

   M => ['ATG'],

   W => ['TGG'],

);

my @loops = split '', $seq;

my $cmd;

local $i=0;

my $vars;

foreach my $letter (@loops) {

    my ($str,$v)= createloop($letter);

    $vars.=$v;

    $cmd.=$str;

}

$cmd=$cmd.'print'. " \"$vars\\n\";";  ## adding print statement

$cmd.= '}'x$i;       ### ending statement blocks

eval {eval $cmd; };   ## first eval returns statement block

##creating foreach loops

sub createloop {

$i++;

my $var ='$a'.$i;

return ("foreach $var (qw(@{$hash{$_[0]}})) {",$var) ;

}

Hi Nithinpes,
I am using your code posted by you in this thread for my work. Now I had a little problem in using your code to direct the output to a file. I could not do it since I could not understand the code properly, especially the eval statement and its contribution. Kindly help me to add an extra code to direct the generated sequence to save in a text file.

Thanks,
B.Nataraj

Nov 7 '08 #28