[Bio] / FigKernelPackages / FileIOFunctions.pm Repository:
ViewVC logotype

Annotation of /FigKernelPackages/FileIOFunctions.pm

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.14 - (view) (download) (as text)

1 : chenry 1.14 use strict;
2 :     use FileHandle;
3 :     use Fcntl qw/:DEFAULT :seek :flock/;
4 :     use Symbol 'qualify_to_ref';
5 :    
6 :     my $have_fsync;
7 :     eval {
8 :     require File::Sync;
9 :     $have_fsync++;
10 :     };
11 :    
12 :    
13 :     #--- This function just prints the given array reference to file with a different array element on each line ---#
14 :     sub PrintArrayToFile {
15 :     my ($Filename,$ArrayRef,$Append) = @_;
16 :    
17 :     if (defined($Append) && $Append == 1) {
18 :     open (OUTPUT, ">>$Filename");
19 :     } else {
20 :     open (OUTPUT, ">$Filename");
21 :     }
22 :     foreach my $Item (@{$ArrayRef}) {
23 :     if (length($Item) > 0) {
24 :     print OUTPUT $Item."\n";
25 :     }
26 :     }
27 :     close(OUTPUT);
28 :     }
29 :    
30 :     sub PrintTwoDimensionalArrayToFile {
31 :     my ($Filename,$ArrayRef,$Delimiter) = @_;
32 :    
33 :     if (open (OUTPUT, ">$Filename")) {
34 :     foreach my $Item (@{$ArrayRef}) {
35 :     if (@{$Item} > 0) {
36 :     print OUTPUT join($Delimiter,@{$Item})."\n";
37 :     }
38 :     }
39 :     close(OUTPUT);
40 :     } else {
41 :     die "Cannot open $Filename: $!";
42 :     }
43 :     }
44 :    
45 :    
46 :     #--- This function removes the specified line from the file with the input filename if the line exists in the file ---#
47 :     sub RemoveSpecificLineFromFile {
48 :     my ($Filename,$DelLine,$Delimiter) = @_;
49 :    
50 :     #Note that I donot specify the delimiter to the file upload function because I want to preserve the entire content of the file
51 :     my $FileArray = &LoadSingleColumnFile($Filename,"");
52 :     my $Count = 0;
53 :     foreach my $Item (@{$FileArray}) {
54 :     my @Data = split(/$Delimiter/,$Item);
55 :     if ($Data[0] eq $DelLine) {
56 :     delete $FileArray->[$Count];
57 :     }
58 :     $Count++;
59 :     }
60 :     &PrintArrayToFile($Filename,$FileArray);
61 :     }
62 :    
63 :     #--- This function adds the input line to the file with the input filename if the line does not already exist in the file ---#
64 :     sub AddLineToFileUnique {
65 :     my ($Filename,$NewLine,$Delimiter) = @_;
66 :     my $FileArray = &LoadSingleColumnFile($Filename,$Delimiter);
67 :     my $LastLineLength = 0;
68 :     foreach my $Item (@{$FileArray}) {
69 :     $LastLineLength = length($Item);
70 :     if ($Item eq $NewLine) {
71 :     return;
72 :     }
73 :     }
74 :     if (open (OUTPUT, ">>$Filename")) {
75 :     if ($LastLineLength > 0) {
76 :     print OUTPUT "\n";
77 :     }
78 :     print OUTPUT $NewLine."\n";
79 :     close(OUTPUT);
80 :     } else {
81 :     die "Cannot open $Filename: $!";
82 :     }
83 :     }
84 :    
85 :     #--- This function saves the input hash back to a file where each data item is stored on a separate line with the file headings stored in the first column of data ---#
86 :     sub SaveHashToHorizontalDataFile {
87 :     my ($Filename,$Delimiter,$DataHashRef) = @_;
88 :    
89 :     if (!defined($DataHashRef->{"orderedkeys"})) {
90 :     my @Keys = keys(%{$DataHashRef});
91 :     push(@{$DataHashRef->{"orderedkeys"}},@Keys);
92 :     }
93 :    
94 :     if ($Filename eq "") {
95 :     open (HASHTOHORIZONTALOUTPUT, ">&STDOUT");
96 :     } else {
97 :     open (HASHTOHORIZONTALOUTPUT, ">$Filename");
98 :     }
99 :    
100 :     if (open (HASHTOHORIZONTALOUTPUT, ">$Filename")) {
101 :     my @ReactionKeys = @{$DataHashRef->{"orderedkeys"}};
102 :     foreach my $Item (@ReactionKeys) {
103 :     if (defined($DataHashRef->{"keytranslation"}) && defined($DataHashRef->{"keytranslation"}->{$Item})) {
104 :     $Item = $DataHashRef->{"keytranslation"}->{$Item};
105 :     }
106 :     if (defined($DataHashRef->{$Item}) && @{$DataHashRef->{$Item}} > 0) {
107 :     print HASHTOHORIZONTALOUTPUT $Item.$Delimiter.join($Delimiter,@{$DataHashRef->{"$Item"}})."\n";
108 :     }
109 :     }
110 :     close(HASHTOHORIZONTALOUTPUT);
111 :     } else {
112 :     die "Cannot open $Filename: $!";
113 :     }
114 :    
115 :     return $DataHashRef;
116 :     }
117 :    
118 :     #--- This function loads a file where each data item is stored on a separate line with the file headings stored in the first column of data ---#
119 :     sub LoadHorizontalDataFile {
120 :     my ($Filename,$Delimiter,$HeadingTranslation) = @_;
121 :    
122 :     my $DataHashRef = {};
123 :    
124 :     if (open (INPUT, "<$Filename")) {
125 :     while (my $Line = <INPUT>) {
126 :     chomp($Line);
127 :     my @Data = split(/$Delimiter/,$Line);
128 :     if (defined($HeadingTranslation) && defined($HeadingTranslation->{$Data[0]})) {
129 :     $DataHashRef->{"keytranslation"}->{$HeadingTranslation->{$Data[0]}} = $Data[0];
130 :     $Data[0] = $HeadingTranslation->{$Data[0]};
131 :     }
132 :     for (my $i=1; $i < @Data; $i++) {
133 :     $DataHashRef->{$Data[0]}->[$i-1] = $Data[$i];
134 :     }
135 :     if (@Data > 1) {
136 :     push(@{$DataHashRef->{"orderedkeys"}},$Data[0]);
137 :     }
138 :     }
139 :     close(INPUT);
140 :     } else {
141 :     die "Cannot open $Filename: $!";
142 :     }
143 :    
144 :     return $DataHashRef;
145 :     }
146 :    
147 :    
148 :     #--- This function loads a file containing a simple list and returns a reference to an array containing that list ---#
149 :     #--- Note that when a delimiter is supplied, each line in the file is broken up with the delimiter, and only the first element from each line is stored in the returned list ---#
150 :     sub LoadSingleColumnFile {
151 :     my ($Filename,$Delimiter) = @_;
152 :    
153 :     my $DataArrayRef = [];
154 :     if (open (INPUT, "<$Filename")) {
155 :     while (my $Line = <INPUT>) {
156 :     chomp($Line);
157 :    
158 :     if (length($Delimiter) > 0) {
159 :     my @Data = split(/$Delimiter/,$Line);
160 :     $Line = $Data[0];
161 :     }
162 :    
163 :     push(@{$DataArrayRef},$Line);
164 :     }
165 :     close(INPUT);
166 :     } else {
167 :     die "Cannot open $Filename: $!";
168 :     }
169 :     return $DataArrayRef;
170 :     }
171 :    
172 :     #--- This function loads a file containing multiple columns of data with no file headings ---#
173 :     sub LoadMultipleColumnFile {
174 :     my ($Filename,$Delimiter) = @_;
175 :    
176 :     my $DataArrayRefArrayRef = [];
177 :     if (open (INPUT, "<$Filename")) {
178 :     while (my $Line = <INPUT>) {
179 :     chomp($Line);
180 :     my $Data = [];
181 :     $Data->[0] = $Line;
182 :     if (length($Delimiter) > 0) {
183 :     @{$Data} = split(/$Delimiter/,$Line);
184 :     }
185 :     push(@{$DataArrayRefArrayRef},$Data);
186 :     }
187 :     close(INPUT);
188 :     } else {
189 :     die "Cannot open $Filename: $!";
190 :     }
191 :     return $DataArrayRefArrayRef;
192 :     }
193 :    
194 :     #--- This function loads a file containing multiple columns of data with file headings at the top ---#
195 :     sub LoadMultipleLabeledColumnFile {
196 :     my ($Filename,$ColumnDelimiter,$ItemDelimiter,$HeadingRowNumber) = @_;
197 :     if (!defined($HeadingRowNumber) || $HeadingRowNumber eq "") {
198 :     $HeadingRowNumber = 0;
199 :     }
200 :     my $DataHashRefArrayRef = [];
201 :     if (open (INPUT, "<$Filename")) {
202 :     my $Line = <INPUT>;
203 :     for (my $i=0; $i < $HeadingRowNumber; $i++) {
204 :     $Line = <INPUT>;
205 :     }
206 :     chomp($Line);
207 :     if (length($ColumnDelimiter) > 0) {
208 :     my @Headings = split(/$ColumnDelimiter/,$Line);
209 :     my $First = 1;
210 :     while ($Line = <INPUT>) {
211 :     chomp($Line);
212 :     my @Data = split(/$ColumnDelimiter/,$Line);
213 :     my $ArrayRefHashRef;
214 :     for (my $i=0; $i < @Headings; $i++) {
215 :     if (defined($Data[$i]) && length($Data[$i]) > 0) {
216 :     if (defined($ItemDelimiter) && length($ItemDelimiter) > 0) {
217 :     my @TempArray = split(/$ItemDelimiter/,$Data[$i]);
218 :     foreach my $Item (@TempArray) {
219 :     push(@{$ArrayRefHashRef->{$Headings[$i]}},$Item);
220 :     }
221 :     } else {
222 :     $ArrayRefHashRef->{$Headings[$i]}->[0] = $Data[$i];
223 :     }
224 :     }
225 :     }
226 :     if ($First == 1) {
227 :     $First = 0;
228 :     push(@{$ArrayRefHashRef->{"orderedkeys"}},@Headings);
229 :     }
230 :     push(@{$DataHashRefArrayRef},$ArrayRefHashRef);
231 :     }
232 :     }
233 :     close(INPUT);
234 :     } else {
235 :     die "Cannot open $Filename: $!";
236 :     }
237 :     return $DataHashRefArrayRef;
238 :     }
239 :    
240 :     sub PrintHashArrayToFile {
241 :     my ($Filename,$HashArrayRef,$HeaderRef,$ExtraHeaders) = @_;
242 :    
243 :     if (!defined($HeaderRef) || $HeaderRef == 0 || $HeaderRef eq "") {
244 :     if (!defined($HashArrayRef->[0]) || !defined($HashArrayRef->[0]->{"orderedkeys"})) {
245 :     return;
246 :     } else {
247 :     $HeaderRef = $HashArrayRef->[0]->{"orderedkeys"};
248 :     }
249 :     }
250 :    
251 :     if (open (HASHARRAYTOFILE, ">$Filename")) {
252 :     if (defined($ExtraHeaders)) {
253 :     print HASHARRAYTOFILE $ExtraHeaders;
254 :     }
255 :     print HASHARRAYTOFILE join(";",@{$HeaderRef})."\n";
256 :     for (my $i=0; $i < @{$HashArrayRef}; $i++) {
257 :     for (my $j=0; $j < @{$HeaderRef}; $j++) {
258 :     if ($j > 0) {
259 :     print HASHARRAYTOFILE ";";
260 :     }
261 :     if (defined($HashArrayRef->[$i]->{$HeaderRef->[$j]})) {
262 :     print HASHARRAYTOFILE join("|",@{$HashArrayRef->[$i]->{$HeaderRef->[$j]}});
263 :     }
264 :     }
265 :     print HASHARRAYTOFILE "\n";
266 :     }
267 :     close (HASHARRAYTOFILE);
268 :     }
269 :     }
270 :    
271 :     sub LoadTable {
272 :     my ($VariableHash,$Filename,$Delimiter,$ItemDelimiter,$HeadingLine,$HashColumns) = @_;
273 :    
274 :     #Checking that the table file exists
275 :     if (!-e $Filename) {
276 :     return undef;
277 :     }
278 :    
279 :     #Sanity checking input values
280 :     if (!defined($HeadingLine) || $HeadingLine eq "") {
281 :     $HeadingLine = 0;
282 :     }
283 :     if (!defined($Delimiter) || $Delimiter eq "") {
284 :     $Delimiter = ";";
285 :     }
286 :     if ($Delimiter eq "|") {
287 :     $Delimiter = "\\|";
288 :     }
289 :     if (!defined($ItemDelimiter) || $ItemDelimiter eq "") {
290 :     $ItemDelimiter = "";
291 :     } elsif ($ItemDelimiter eq "|") {
292 :     $ItemDelimiter = "\\|";
293 :     }
294 :    
295 :     #Loading the data table
296 :     my $Table;
297 :     my $Prefix;
298 :     my @Headings;
299 :     if (!open (TABLEINPUT, "<$Filename")) {
300 :     return undef;
301 :     }
302 :     my $Line = <TABLEINPUT>;
303 :     for (my $i=0; $i < $HeadingLine; $i++) {
304 :     $Prefix .= $Line;
305 :     $Line = <TABLEINPUT>;
306 :     }
307 :     chomp($Line);
308 :    
309 :     @Headings = split(/$Delimiter/,$Line);
310 :     while ($Line = <TABLEINPUT>) {
311 :     chomp($Line);
312 :     my @Data = split(/$Delimiter/,$Line);
313 :     my $ArrayRefHashRef;
314 :     for (my $i=0; $i < @Headings; $i++) {
315 :     if (defined($Data[$i]) && length($Data[$i]) > 0) {
316 :     if (defined($ItemDelimiter) && length($ItemDelimiter) > 0) {
317 :     my @TempArray = split(/$ItemDelimiter/,$Data[$i]);
318 :     foreach my $Item (@TempArray) {
319 :     push(@{$ArrayRefHashRef->{$Headings[$i]}},$Item);
320 :     }
321 :     } else {
322 :     $ArrayRefHashRef->{$Headings[$i]}->[0] = $Data[$i];
323 :     }
324 :     }
325 :     }
326 :     push(@{$Table->{"array"}},$ArrayRefHashRef);
327 :     }
328 :     close(TABLEINPUT);
329 :    
330 :     #Loading file IO parameters
331 :     $Table->{"file IO settings"}->{"filename"}->[0] = $Filename;
332 :     if ($Delimiter eq "\\|") {
333 :     $Delimiter = "|";
334 :     }
335 :     $Table->{"file IO settings"}->{"delimiter"}->[0] = $Delimiter;
336 :     if ($ItemDelimiter eq "\\|") {
337 :     $ItemDelimiter = "|";
338 :     }
339 :     $Table->{"file IO settings"}->{"item delimiter"}->[0] = $ItemDelimiter;
340 :     $Table->{"file IO settings"}->{"file prefix"}->[0] = $Prefix;
341 :     push(@{$Table->{"file IO settings"}->{"orderedkeys"}},@Headings);
342 :     #Replacing variables in variable columns with variable values and loading hash with hash column keys
343 :     foreach my $ItemData (@{$Table->{"array"}}) {
344 :     if (defined($HashColumns) && $HashColumns ne "") {
345 :     foreach my $Heading (@{$HashColumns}) {
346 :     if (defined($ItemData->{$Heading})) {
347 :     for (my $i=0; $i < @{$ItemData->{$Heading}}; $i++) {
348 :     push(@{$Table->{$ItemData->{$Heading}->[$i]}},$ItemData);
349 :     push(@{$Table->{"hash columns"}->{$Heading}->{$ItemData->{$Heading}->[$i]}},$ItemData);
350 :     }
351 :     }
352 :     }
353 :     }
354 :     }
355 :    
356 :     return $Table;
357 :     }
358 :    
359 :     sub SaveTable {
360 :     my ($TableRef) = @_;
361 :    
362 :     #Checking that a filename exists
363 :     if (!defined($TableRef->{"array"}) || !defined($TableRef->{"file IO settings"}->{"filename"}) || !defined($TableRef->{"file IO settings"}->{"orderedkeys"})) {
364 :     return -1;
365 :     }
366 :    
367 :     my $Filename = $TableRef->{"file IO settings"}->{"filename"}->[0];
368 :     my $Delimiter = ";";
369 :     my $ItemDelimiter = "|";
370 :     my $Prefix = "";
371 :     if (defined($TableRef->{"file IO settings"}->{"delimiter"})) {
372 :     $Delimiter = $TableRef->{"file IO settings"}->{"delimiter"}->[0];
373 :     if ($Delimiter eq "\\|" || $Delimiter eq "\|") {
374 :     $Delimiter = "|";
375 :     } elsif ($Delimiter eq "\\t") {
376 :     $Delimiter = "\t";
377 :     }
378 :     }
379 :     if (defined($TableRef->{"file IO settings"}->{"item delimiter"})) {
380 :     $ItemDelimiter = $TableRef->{"file IO settings"}->{"item delimiter"}->[0];
381 :     if ($ItemDelimiter eq "\\|" || $ItemDelimiter eq "\|") {
382 :     $ItemDelimiter = "|";
383 :     } elsif ($ItemDelimiter eq "\\t") {
384 :     $ItemDelimiter = "\t";
385 :     }
386 :     }
387 :     if (defined($TableRef->{"file IO settings"}->{"file prefix"})) {
388 :     $Prefix = $TableRef->{"file IO settings"}->{"file prefix"}->[0];
389 :     }
390 :    
391 :     #Opening the file
392 :     if (defined($TableRef->{"file IO settings"}->{"append"})) {
393 :     if (!open (SAVINGTABLE, ">>$Filename")) {
394 :     return -1;
395 :     }
396 :     } else {
397 :     if (!open (SAVINGTABLE, ">$Filename")) {
398 :     return -1;
399 :     }
400 :     }
401 :    
402 :     if (defined($Prefix)) {
403 :     print SAVINGTABLE $Prefix;
404 :     }
405 :     print SAVINGTABLE join($Delimiter,@{$TableRef->{"file IO settings"}->{"orderedkeys"}})."\n";
406 :     for (my $i=0; $i < @{$TableRef->{"array"}}; $i++) {
407 :     for (my $j=0; $j < @{$TableRef->{"file IO settings"}->{"orderedkeys"}}; $j++) {
408 :     if ($j > 0) {
409 :     print SAVINGTABLE $Delimiter;
410 :     }
411 :     if (defined($TableRef->{"array"}->[$i]->{$TableRef->{"file IO settings"}->{"orderedkeys"}->[$j]})) {
412 :     if(ref($TableRef->{"array"}->[$i]->{$TableRef->{"file IO settings"}->{"orderedkeys"}->[$j]}) eq 'ARRAY') {
413 :     print SAVINGTABLE join($ItemDelimiter,@{$TableRef->{"array"}->[$i]->{$TableRef->{"file IO settings"}->{"orderedkeys"}->[$j]}});
414 :     } else {
415 :     print SAVINGTABLE $TableRef->{"array"}->[$i]->{$TableRef->{"file IO settings"}->{"orderedkeys"}->[$j]};
416 :     }
417 :     }
418 :     }
419 :     print SAVINGTABLE "\n";
420 :     }
421 :     close (SAVINGTABLE);
422 :     }
423 :    
424 :     sub copy_table_row {
425 :     my ($InRow) = @_;
426 :    
427 :     my $NewRow;
428 :     my @Headings = keys(%{$InRow});
429 :     foreach my $Heading (@Headings) {
430 :     push(@{$NewRow->{$Heading}},@{$InRow->{$Heading}});
431 :     }
432 :    
433 :     return $NewRow;
434 :     }
435 :    
436 :     #--- This function loads a file with the following on each line: $A$Delimiter$B and maps $A to $B in the first returned hash reference and $B to $A in the second returned hash reference ---#
437 :     sub LoadSeparateTranslationFiles {
438 :     my ($Filename,$Delimiter) = @_;
439 :     my $HashReferenceForward = {};
440 :     my $HashReferenceReverse = {};
441 :    
442 :     if (open (INPUT, "<$Filename")) {
443 :     while (my $Line = <INPUT>) {
444 :     chomp($Line);
445 :     my @Data = split(/$Delimiter/,$Line);
446 :     if (@Data >= 2) {
447 :     if (!defined($HashReferenceForward->{$Data[0]})) {
448 :     $HashReferenceForward->{$Data[0]} = $Data[1];
449 :     }
450 :     if (!defined($HashReferenceForward->{$Data[1]})) {
451 :     $HashReferenceReverse->{$Data[1]} = $Data[0];
452 :     }
453 :     }
454 :     }
455 :     close(INPUT);
456 :     }
457 :    
458 :     return ($HashReferenceForward,$HashReferenceReverse);
459 :     }
460 :    
461 :     #--- This function breaks down the input filename into a directory, filename, and extension ---#
462 :     sub ParseFilename {
463 :     my ($Filename) = @_;
464 :    
465 :     my $Directory = "";
466 :     my $Extension = "";
467 :     if ($Filename =~ m/^(.+\/)([^\/]+)\.([^\.]+)/) {
468 :     $Directory = $1;
469 :     $Filename = $2;
470 :     $Extension = $3;
471 :     }
472 :    
473 :     return ($Filename,$Directory,$Extension);
474 :     }
475 :    
476 :     #--- This function compares the files listed in two separate directories and returns the list of new files and updated files ---#
477 :     sub CompareDirectories {
478 :     my ($NewDirectory,$OldDirectory,$ComparisonType) = @_;
479 :    
480 :     my $Command = "ls -la ".$NewDirectory." > ".$NewDirectory."FileList.txt";
481 :     system($Command);
482 :     $Command = "ls -la ".$OldDirectory." > ".$OldDirectory."FileList.txt";
483 :     system($Command);
484 :    
485 :     my $NewFileData = &LoadMultipleColumnFile($NewDirectory."FileList.txt","\\s");
486 :     my $OldFileData = &LoadMultipleColumnFile($OldDirectory."FileList.txt","\\s");
487 :    
488 :     my $UpdatedFiles = [];
489 :     my $NewFiles = [];
490 :    
491 :     my %FilenameHash;
492 :     foreach my $File (@{$OldFileData}) {
493 :     if ($ComparisonType eq "date") {
494 :     $FilenameHash{$File->[$#{$File}]} = $File->[$#{$File}-2].":".$File->[$#{$File}-1];
495 :     } elsif ($ComparisonType eq "size") {
496 :     $FilenameHash{$File->[$#{$File}]} = $File->[$#{$File}-3];
497 :     }
498 :     }
499 :     foreach my $File (@{$NewFileData}) {
500 :     if (defined($FilenameHash{$File->[$#{$File}]})) {
501 :     if ($ComparisonType eq "date" && $FilenameHash{$File->[$#{$File}]} ne $File->[$#{$File}-2].":".$File->[$#{$File}-1]) {
502 :     push(@{$UpdatedFiles},$File->[$#{$File}]);
503 :     } elsif ($ComparisonType eq "size" && $FilenameHash{$File->[$#{$File}]} ne $File->[$#{$File}-3]) {
504 :     push(@{$UpdatedFiles},$File->[$#{$File}]);
505 :     }
506 :     } else {
507 :     $FilenameHash{$File->[$#{$File}]} = $File->[$#{$File}-2].":".$File->[$#{$File}-1];
508 :     push(@{$NewFiles},$File->[$#{$File}]);
509 :     }
510 :     }
511 :    
512 :     return ($NewFiles,$UpdatedFiles);
513 :     }
514 :    
515 :     sub RemoveHFromFormula {
516 :     my ($Formula) = @_;
517 :     my @Data = split(/H/,$Formula);
518 :    
519 :     if (@Data == 1) {
520 :     return $Formula;
521 :     }
522 :    
523 :     while ($Data[1] =~ m/^\d/) {
524 :     $Data[1] = substr($Data[1],1);
525 :     }
526 :    
527 :     return $Data[0].$Data[1];
528 :     }
529 :    
530 :     sub CompareArrays {
531 :     my ($ArrayOne,$ArrayTwo) = @_;
532 :    
533 :     my $ArrayOneExtra = ();
534 :     my $ArrayTwoExtra = ();
535 :     my $ArrayOverlap = ();
536 :     my %ArrayTwoHash;
537 :    
538 :     for (my $i=0; $i < @{$ArrayOne}; $i++) {
539 :     my $Match = 0;
540 :     for (my $j=0; $j < @{$ArrayTwo}; $j++) {
541 :     if ($ArrayOne->[$i] eq $ArrayTwo->[$j]) {
542 :     $ArrayTwoHash{$ArrayOne->[$i]} = 1;
543 :     $Match = 1;
544 :     push(@{$ArrayOverlap},$ArrayOne->[$i]);
545 :     $j = @{$ArrayTwo};
546 :     }
547 :     }
548 :     if ($Match == 0) {
549 :     push(@{$ArrayOneExtra},$ArrayOne->[$i]);
550 :     }
551 :     }
552 :     for (my $j=0; $j < @{$ArrayTwo}; $j++) {
553 :     if (!defined($ArrayTwoHash{$ArrayTwo->[$j]})) {
554 :     push(@{$ArrayTwoExtra},$ArrayTwo->[$j]);
555 :     }
556 :     }
557 :    
558 :     return ($ArrayOneExtra,$ArrayTwoExtra,$ArrayOverlap);
559 :     }
560 :    
561 :     sub ReplaceLineSubstringsFromHash {
562 :     my ($Translation, $Line) = @_;
563 :    
564 :     my @Data = keys(%{$Translation});
565 :     for (my $i=0; $i < @Data; $i++) {
566 :     my $FindString = $Data[$i];
567 :     my $ReplaceString = $Translation->{$Data[$i]};
568 :     $Line =~ s/([\,\s\;\+\[])$FindString([\,\s\;\+\[])/$1$ReplaceString$2/g;
569 :     $Line =~ s/$FindString$/$ReplaceString/g;
570 :     $Line =~ s/^$FindString/$ReplaceString/g;
571 :     }
572 :    
573 :     return $Line;
574 :     }
575 :    
576 :     sub FindArrayElement {
577 :     my ($ArrayRef,$Value) = @_;
578 :    
579 :     if (!defined($ArrayRef)) {
580 :     return -1;
581 :     }
582 :    
583 :     for (my $i=0;$i < @{$ArrayRef};$i++) {
584 :     if ($ArrayRef->[$i] eq $Value) {
585 :     return $i;
586 :     }
587 :     }
588 :    
589 :     return -1;
590 :     }
591 :    
592 :     sub RemoveArrayElement {
593 :     my ($ArrayRef,$Value) = @_;
594 :    
595 :     for (my $i=0;$i < @{$ArrayRef};$i++) {
596 :     if ($ArrayRef->[$i] eq $Value) {
597 :     splice(@{$ArrayRef},$i,1);
598 :     $i--;
599 :     }
600 :     }
601 :    
602 :     return $ArrayRef;
603 :     }
604 :    
605 :     sub FormatNumber {
606 :     my ($OriginalNumber,$Digits,$ZeroEquivalence) = @_;
607 :    
608 :     if (abs($OriginalNumber) < $ZeroEquivalence) {
609 :     $OriginalNumber = "0.";
610 :     for (my $i=0; $i < $Digits;$i++) {
611 :     $OriginalNumber .= "0"
612 :     }
613 :     return $OriginalNumber
614 :     }
615 :    
616 :     if ($OriginalNumber > 1 || $OriginalNumber < -1) {
617 :     $OriginalNumber = $OriginalNumber*(10**$Digits);
618 :     $OriginalNumber = int($OriginalNumber + .5 * ($OriginalNumber <=> 0));
619 :     $OriginalNumber = $OriginalNumber/(10**$Digits);
620 :     return $OriginalNumber;
621 :     }
622 :    
623 :     my $Zeros = 0;
624 :     while (abs($OriginalNumber) < 10**$Zeros) {
625 :     $Zeros--;
626 :     }
627 :    
628 :     $OriginalNumber = $OriginalNumber*10**-$Zeros;
629 :     $OriginalNumber = $OriginalNumber*(10**$Digits);
630 :     $OriginalNumber = int($OriginalNumber + .5 * ($OriginalNumber <=> 0));
631 :     $OriginalNumber = $OriginalNumber/(10**$Digits);
632 :     if ($Zeros > -4) {
633 :     $OriginalNumber = $OriginalNumber/(10**-$Zeros);
634 :     } else {
635 :     $OriginalNumber .= "e".$Zeros;
636 :     }
637 :    
638 :     return $OriginalNumber;
639 :     }
640 :    
641 :     sub CountFileLines {
642 :     my ($filename) = @_;
643 :     my $lines = 0;
644 :     open(FILE, $filename) or die "Can't open `$filename': $!";
645 :     while(<FILE>) {
646 :     $lines++;
647 :     }
648 :     close FILE;
649 :     return $lines;
650 :     }
651 :    
652 :     sub ManipulateFormula {
653 :     my ($OriginalFormula) = @_;
654 :    
655 :     my %Atoms;
656 :     my $CurrentAtomType = "";
657 :     my $CurrentAtomNumber = "";
658 :     for (my $i=0; $i < length($OriginalFormula); $i++) {
659 :     my $CurrentLetter = substr($OriginalFormula,$i,1);
660 :     if ($CurrentLetter =~ m/[A-Z]/) {
661 :     if ($CurrentAtomType ne "") {
662 :     if ($CurrentAtomNumber eq "1") {
663 :     $CurrentAtomNumber = "";
664 :     }
665 :     $Atoms{$CurrentAtomType} = $CurrentAtomNumber;
666 :     }
667 :     $CurrentAtomType = $CurrentLetter;
668 :     $CurrentAtomNumber = "";
669 :     } elsif ($CurrentLetter =~ m/[a-z]/) {
670 :     $CurrentAtomType .= $CurrentLetter;
671 :     } elsif ($CurrentLetter =~ m/[\d]/) {
672 :     $CurrentAtomNumber .= $CurrentLetter;
673 :     } else {
674 :     if ($CurrentAtomType ne "") {
675 :     $Atoms{$CurrentAtomType} = $CurrentAtomNumber;
676 :     }
677 :     $CurrentAtomType = "";
678 :     }
679 :     }
680 :     if ($CurrentAtomType ne "") {
681 :     if ($CurrentAtomNumber eq "1") {
682 :     $CurrentAtomNumber = "";
683 :     }
684 :     $Atoms{$CurrentAtomType} = $CurrentAtomNumber;
685 :     }
686 :    
687 :     my @SortedAtoms = sort(keys(%Atoms));
688 :     my $StandardFormula;
689 :     my $CompareFormula;
690 :     for (my $i=0; $i < @SortedAtoms; $i++) {
691 :     $StandardFormula .= $SortedAtoms[$i];
692 :     $StandardFormula .= $Atoms{$SortedAtoms[$i]};
693 :     if ($SortedAtoms[$i] ne "H") {
694 :     $CompareFormula .= $SortedAtoms[$i];
695 :     $CompareFormula .= $Atoms{$SortedAtoms[$i]};
696 :     }
697 :     }
698 :    
699 :     return ($StandardFormula,$CompareFormula);
700 :     }
701 :    
702 :     sub ParseGPRFile {
703 :     my ($Filename,$ReactionData) = @_;
704 :    
705 :     my $GPRData = &LoadMultipleColumnFile($Filename,"\t");
706 :    
707 :     for (my $i=0; $i < @{$GPRData}; $i++) {
708 :     if (@{$GPRData->[$i]} >= 3) {
709 :     if (!defined($ReactionData->{$GPRData->[$i]->[2]})) {
710 :     $ReactionData->{$GPRData->[$i]->[2]}->{"ID"} = $GPRData->[$i]->[2];
711 :     }
712 :     if (length($GPRData->[$i]->[1]) > 0) {
713 :     $ReactionData->{$GPRData->[$i]->[2]}->{"EC"} = $GPRData->[$i]->[1];
714 :     }
715 :     for (my $j=4; $j < @{$GPRData->[$i]}; $j++) {
716 :     if (length($GPRData->[$i]->[$j]) > 0) {
717 :     if ($GPRData->[$i]->[$j] =~ m/_$/) {
718 :     $GPRData->[$i]->[$j] = chop($GPRData->[$i]->[$j]);
719 :     }
720 :     push(@{$ReactionData->{$GPRData->[$i]->[2]}->{"GENE ID"}},$GPRData->[$i]->[$j]);
721 :     }
722 :     }
723 :     }
724 :     }
725 :    
726 :     return ($ReactionData);
727 :     }
728 :    
729 :     sub ParseSBMLFile {
730 :     my ($Filename,$ReactionData,$CompoundData) = @_;
731 :    
732 :     my $SBMLData = &LoadSingleColumnFile($Filename,"");
733 :    
734 :     my $HandlingSpecies = 0;
735 :     my $HandlingReactions = 0;
736 :     my $HandlingReactants = 0;
737 :     my $HandlingProducts = 0;
738 :     my $ReactionID = "";
739 :     my $ReactionReactants = "";
740 :     my $ReactionSign = "";
741 :     my $ReactionProducts = "";
742 :     for (my $i=0; $i < @{$SBMLData}; $i++) {
743 :     if ($SBMLData->[$i] =~ m/^<listOfSpecies>/) {
744 :     $HandlingSpecies = 1;
745 :     } elsif ($SBMLData->[$i] =~ m/^<\/listOfSpecies>/) {
746 :     $HandlingSpecies = 0;
747 :     } elsif ($SBMLData->[$i] =~ m/^<listOfReactions>/) {
748 :     $HandlingReactions = 1;
749 :     } elsif ($SBMLData->[$i] =~ m/^<\/listOfReactions>/) {
750 :     $HandlingReactions = 0;
751 :     } elsif ($HandlingSpecies == 1 && $SBMLData->[$i] =~ m/^<species/) {
752 :     #Parsing out the compound ID
753 :     if ($SBMLData->[$i] =~ m/id="([^"]+)"/) {
754 :     my $ID = $1;
755 :     if ($ID =~ m/^_/) {
756 :     $ID = substr($ID,1);
757 :     }
758 :     if ($ID =~ m/_[a-z]$/) {
759 :     chop($ID);
760 :     chop($ID);
761 :     }
762 :     if (length($ID) > 0) {
763 :     #Parsing out the compound name
764 :     if (!defined($CompoundData->{$ID})) {
765 :     $CompoundData->{$ID}->{"ID"} = $ID;
766 :     }
767 :     if ($SBMLData->[$i] =~ m/name="([^"]+)"/) {
768 :     my $Name = $1;
769 :     if ($Name =~ m/^_/) {
770 :     $Name = substr($Name,1);
771 :     }
772 :     $Name =~ s/_/ /g;
773 :     if (length($Name) > 0 && (!defined($CompoundData->{$ID}->{"NAME"}) || &FindArrayElement($CompoundData->{$ID}->{"NAME"},$Name) == -1)) {
774 :     push(@{$CompoundData->{$ID}->{"NAME"}},$Name);
775 :     }
776 :     }
777 :     }
778 :     }
779 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<reaction/) {
780 :     $ReactionSign = " <=> ";
781 :     if ($SBMLData->[$i] =~ m/reversible="false"/) {
782 :     $ReactionSign = " => ";
783 :     }
784 :     if ($SBMLData->[$i] =~ m/id="([^"]+)"/) {
785 :     $ReactionID = $1;
786 :     if (length($ReactionID) > 0) {
787 :     if (!defined($ReactionData->{$ReactionID})) {
788 :     $ReactionData->{$ReactionID}->{"ID"} = $ReactionID;
789 :     }
790 :     if ($SBMLData->[$i] =~ m/name="([^"]+)"/) {
791 :     my $Name = $1;
792 :     if ($Name =~ m/^_/) {
793 :     $Name = substr($Name,1);
794 :     }
795 :     $Name =~ s/_/ /g;
796 :     if (length($Name) > 0 && (!defined($ReactionData->{$ReactionID}->{"NAME"}) || &FindArrayElement($ReactionData->{$ReactionID}->{"NAME"},$Name) == -1)) {
797 :     push(@{$ReactionData->{$ReactionID}->{"NAME"}},$Name);
798 :     }
799 :     }
800 :    
801 :     }
802 :     }
803 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<\/reaction>/) {
804 :     $ReactionID = "";
805 :     $ReactionReactants = "";
806 :     $ReactionSign = "";
807 :     $ReactionProducts = "";
808 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<html:p>EC Number:\s([^<]+)/) {
809 :     my $ECNumber = $1;
810 :     if (length($ECNumber) > 3 && (!defined($ReactionData->{$ReactionID}->{"EC"}) || &FindArrayElement($ReactionData->{$ReactionID}->{"EC"},$ECNumber) == -1)) {
811 :     push(@{$ReactionData->{$ReactionID}->{"EC"}},$ECNumber);
812 :     }
813 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<html:p>Confidence Level:\s([^<]+)/) {
814 :     my $Confidence = $1;
815 :     if (length($Confidence) > 0) {
816 :     $ReactionData->{$ReactionID}->{"CONFIDENCE"} = $Confidence;
817 :     }
818 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<html:p>LOCUS:/) {
819 :     $_ = $SBMLData->[$i];
820 :     my @GeneArray = /<html:p>LOCUS:([^\#]+)/g;
821 :     for (my $j=0; $j < @GeneArray; $j++) {
822 :     if (length($GeneArray[$j]) > 0 && (!defined($ReactionData->{$ReactionID}->{"GENES"}) || &FindArrayElement($ReactionData->{$ReactionID}->{"GENES"},$GeneArray[$j]) == -1)) {
823 :     push(@{$ReactionData->{$ReactionID}->{"GENES"}},$GeneArray[$j]);
824 :     }
825 :     }
826 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<listOfReactants>/) {
827 :     $HandlingReactants = 1;
828 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<\/listOfReactants>/) {
829 :     $HandlingReactants = 0;
830 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<listOfProducts>/) {
831 :     $HandlingProducts = 1;
832 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<\/listOfProducts>/) {
833 :     $HandlingProducts = 0;
834 :     if (length($ReactionID) > 0 && defined($ReactionData->{$ReactionID})) {
835 :     my $Equation = $ReactionReactants.$ReactionSign.$ReactionProducts;
836 :     $ReactionData->{$ReactionID}->{"EQUATION"} = $Equation;
837 :     }
838 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<speciesReference/) {
839 :     if ($SBMLData->[$i] =~ m/species="([^"]+)"/) {
840 :     my $SpeciesID = $1;
841 :     if ($SpeciesID =~ m/^_/) {
842 :     $SpeciesID = substr($SpeciesID,1);
843 :     }
844 :     my $Compartment = "";
845 :     if ($SpeciesID =~ m/_([a-z])$/) {
846 :     $Compartment = $1;
847 :     chop($SpeciesID);
848 :     chop($SpeciesID);
849 :     }
850 :     my $Stoichiometry = "";
851 :     if ($SBMLData->[$i] =~ m/stoichiometry="([^"]+)"/) {
852 :     $Stoichiometry = $1;
853 :     }
854 :     if (length($Stoichiometry) > 0 && length($SpeciesID) > 0) {
855 :     my $SpeciesString = "";
856 :     if ($Stoichiometry ne "1") {
857 :     $SpeciesString .= "(".$Stoichiometry.") ";
858 :     }
859 :     $SpeciesString .= "$SpeciesID";
860 :     if (length($Compartment) > 0 && $Compartment ne "c") {
861 :     $SpeciesString .= "[".$Compartment."]";
862 :     }
863 :     if ($HandlingReactants == 1) {
864 :     if (length($ReactionReactants) > 0) {
865 :     $ReactionReactants .= " + ";
866 :     }
867 :     $ReactionReactants .= $SpeciesString;
868 :     } elsif ($HandlingProducts == 1) {
869 :     if (length($ReactionProducts) > 0) {
870 :     $ReactionProducts .= " + ";
871 :     }
872 :     $ReactionProducts .= $SpeciesString;
873 :     }
874 :     }
875 :     }
876 :     }
877 :     }
878 :    
879 :     return ($ReactionData,$CompoundData);
880 :     }
881 :    
882 :     sub SearchTranslationDataForMatchingID {
883 :     my ($Filename,$SearchText) = @_;
884 :    
885 :     #Declaring the reference to the array where the results will ultimately be stored
886 :     my $MatchingIDs = ();
887 :    
888 :     #If the search text is blank or the input file does not exist, I return an empty array
889 :     if (length($SearchText) == 0 || !(-e $Filename)) {
890 :     return $MatchingIDs;
891 :     }
892 :    
893 :     #Loading the translation file
894 :     my %IDHash;
895 :     my $TranslationData = &LoadMultipleColumnFile($Filename,"\t");
896 :     my %UniqueKeysHash;
897 :     for (my $i=0; $i < @{$TranslationData}; $i++) {
898 :     if (@{$TranslationData->[$i]} >= 2) {
899 :     push(@{$UniqueKeysHash{$TranslationData->[$i]->[1]}},$TranslationData->[$i]->[0]);
900 :     }
901 :     }
902 :     #Searching through the keys of the translation file for my search text and storing matching ids in a hash
903 :     my @AllKeys = keys(%UniqueKeysHash);
904 :     for (my $i=0; $i < @AllKeys; $i++) {
905 :     if ($AllKeys[$i] =~ m/$SearchText/) {
906 :     for (my $j=0; $j < @{$UniqueKeysHash{$AllKeys[$i]}}; $j++) {
907 :     $IDHash{$UniqueKeysHash{$AllKeys[$i]}->[$j]} = 1;
908 :     }
909 :     }
910 :     }
911 :    
912 :     #Putting the matching hash keys into an array and sorting it
913 :     push(@{$MatchingIDs},keys(%IDHash));
914 :     if (defined($MatchingIDs)) {
915 :     @{$MatchingIDs} = sort(@{$MatchingIDs})
916 :     }
917 :    
918 :     return $MatchingIDs;
919 :     }
920 :    
921 :     sub BackupFile {
922 :     my ($CurrentFilename,$BackupFilename) = @_;
923 :    
924 :     if (-e $CurrentFilename) {
925 :     if (-e $BackupFilename) {
926 :     unlink($BackupFilename);
927 :     }
928 :     rename($CurrentFilename,$BackupFilename);
929 :     }
930 :     }
931 :    
932 :     sub Date {
933 :     my ($Time) = @_;
934 :     if (!defined($Time)) {
935 :     $Time = time();
936 :     }
937 :     my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime($Time);
938 :    
939 :     return ($mon+1)."/".($mday)."/".($year+1900);
940 :     }
941 :    
942 :     sub MergeArraysUnique {
943 :     my @ArrayRefs = @_;
944 :    
945 :     my $ResultArray = ();
946 :     my %EntryHash;
947 :     for (my $i=0; $i < @ArrayRefs; $i++) {
948 :     if (defined($ArrayRefs[$i])) {
949 :     for (my $j=0; $j < @{$ArrayRefs[$i]}; $j++) {
950 :     if (!defined($EntryHash{$ArrayRefs[$i]->[$j]})) {
951 :     push(@{$ResultArray},$ArrayRefs[$i]->[$j]);
952 :     $EntryHash{$ArrayRefs[$i]->[$j]} = 1;
953 :     }
954 :     }
955 :     }
956 :     }
957 :    
958 :     return $ResultArray
959 :     }
960 :    
961 :     #Opens up every file in a directory, searches each line for the search expression, and replaces the objects matching the search expression according to the translation hash
962 :     sub TranslateFileData {
963 :     my ($TranslationHash,$FilenameExpression,$SearchExpression,$Recursive,$MakeUnique,$SortLines) = @_;
964 :    
965 :     #Checking the search expression if one was provided
966 :     if (defined($SearchExpression) && length($SearchExpression) > 0) {
967 :     if (index($SearchExpression,"(") == -1 || index($SearchExpression,"(") == -1) {
968 :     $SearchExpression = "(".$SearchExpression.")";
969 :     }
970 :     }
971 :    
972 :     #Finding all matching filenames
973 :     my @MatchingFiles;
974 :     if ($Recursive == 1 && $FilenameExpression =~ m/\/$/) {
975 :     @MatchingFiles = &RecursiveGlob($FilenameExpression);
976 :     } else {
977 :     @MatchingFiles = glob($FilenameExpression);
978 :     }
979 :    
980 :     #Exiting if no matching filenames were found
981 :     if (@MatchingFiles == 0) {
982 :     print "No matching files!\n";
983 :     return;
984 :     }
985 :    
986 :     #Loading the translation file
987 :     if (!(-e $TranslationHash)) {
988 :     print "Could not find translation file: ".$TranslationHash."!\n";
989 :     return;
990 :     }
991 :     my ($Ignore,$ReverseTranslation) = &LoadSeparateTranslationFiles($TranslationHash,"\t");
992 :    
993 :     #Scanning through all matching filenames
994 :     my @TranslationKeys = keys(%{$ReverseTranslation});
995 :    
996 :     for (my $i=0; $i < @MatchingFiles; $i++) {
997 :     #Loading the file data into an array
998 :     my $FileData = &LoadSingleColumnFile($MatchingFiles[$i],"");
999 :     #Scanning through each fileline
1000 :     my $MatchCount = 0;
1001 :     for (my $j=0; $j < @{$FileData}; $j++) {
1002 :     if (defined($SearchExpression) && length($SearchExpression) > 0) {
1003 :     #This should be faster
1004 :     $_ = $FileData->[$j];
1005 :     my @MatchingGroups = /$SearchExpression/g;
1006 :     for (my $k=0; $k < @MatchingGroups;$k++) {
1007 :     if (defined($ReverseTranslation->{$MatchingGroups[$k]})) {
1008 :     $MatchCount++;
1009 :     my $VarOne = $MatchingGroups[$k];
1010 :     my $VarTwo = $ReverseTranslation->{$MatchingGroups[$k]};
1011 :     $FileData->[$j] =~ s/$VarOne/$VarTwo/;
1012 :     }
1013 :     }
1014 :     } else {
1015 :     #This will be slower
1016 :     for (my $k=0; $k < @TranslationKeys;$k++) {
1017 :     my $VarOne = $TranslationKeys[$k];
1018 :     my $VarTwo = $ReverseTranslation->{$TranslationKeys[$k]};
1019 :     $FileData->[$j] =~ s/$VarOne/$VarTwo/g;
1020 :     }
1021 :     }
1022 :    
1023 :     }
1024 :     #Saving the modified file data back to the file
1025 :     print $MatchingFiles[$i]."\n";
1026 :     print $MatchCount."\n";
1027 :     #Making the array unique if requested
1028 :     if (defined($MakeUnique) && $MakeUnique == 1) {
1029 :     $FileData = &MergeArraysUnique($FileData);
1030 :     }
1031 :     #Sort file lines
1032 :     if (defined($SortLines) && $SortLines == 1) {
1033 :     @{$FileData} = sort(@{$FileData});
1034 :     }
1035 :     &PrintArrayToFile($MatchingFiles[$i],$FileData);
1036 :     }
1037 :     }
1038 :    
1039 :     sub RecursiveGlob {
1040 :     my($path) = @_;
1041 :    
1042 :     my @FileList;
1043 :    
1044 :     ## append a trailing / if it's not there
1045 :     $path .= '/' if($path !~ /\/$/);
1046 :    
1047 :     ## loop through the files contained in the directory
1048 :     for my $eachFile (glob($path.'*')) {
1049 :     ## if the file is a directory
1050 :     if( -d $eachFile) {
1051 :     ## pass the directory to the routine ( recursion )
1052 :     push(@FileList,RecursiveGlob($eachFile));
1053 :     } else {
1054 :     push(@FileList,$eachFile);
1055 :     }
1056 :     }
1057 :    
1058 :     return @FileList;
1059 :     }
1060 :    
1061 :     sub PrintHashToFile {
1062 :     my($HashRef,$Filename) = @_;
1063 :    
1064 :     if ($Filename == "") {
1065 :     open (HASHOUTPUT, ">&STDOUT");
1066 :     } else {
1067 :     open (HASHOUTPUT, ">$Filename");
1068 :     }
1069 :     my @Headings = keys(%{$HashRef});
1070 :     my @FirstHeadings;
1071 :     my @SecondHeadings;
1072 :     for (my $i=0; $i < @Headings; $i++) {
1073 :     if (ref($HashRef->{$Headings[$i]}) eq "HASH") {
1074 :     my @SubHeadings = keys(%{$HashRef->{$Headings[$i]}});
1075 :     for (my $j=0; $j < @SubHeadings;$j++) {
1076 :     push(@FirstHeadings,$Headings[$i]);
1077 :     push(@SecondHeadings,$SubHeadings[$j]);
1078 :     }
1079 :     } else {
1080 :     push(@FirstHeadings,$Headings[$i]);
1081 :     push(@SecondHeadings,$Headings[$i]);
1082 :     }
1083 :     }
1084 :     #Printing headers
1085 :     print HASHOUTPUT "FIRST HEADING;";
1086 :     print HASHOUTPUT join(";",@FirstHeadings)."\n";
1087 :     print HASHOUTPUT "SECOND HEADING;";
1088 :     print HASHOUTPUT join(";",@SecondHeadings)."\n";
1089 :     #Printing the number of data entries
1090 :     print HASHOUTPUT "Number of entries;";
1091 :     for (my $i=0; $i < @FirstHeadings; $i++) {
1092 :     if ($i > 0) {
1093 :     print HASHOUTPUT ";";
1094 :     }
1095 :     if ($FirstHeadings[$i] ne $SecondHeadings[$i]) {
1096 :     if (defined($HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]})) {
1097 :     if (@{$HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]}} == 1) {
1098 :     print HASHOUTPUT $HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]}->[0];
1099 :     } else {
1100 :     my $NumEntries = @{$HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]}};
1101 :     print HASHOUTPUT $NumEntries;
1102 :     }
1103 :     } else {
1104 :     print HASHOUTPUT 0;
1105 :     }
1106 :     } else {
1107 :     if (defined($HashRef->{$FirstHeadings[$i]})) {
1108 :     if (@{$HashRef->{$FirstHeadings[$i]}} == 1) {
1109 :     print HASHOUTPUT $HashRef->{$FirstHeadings[$i]}->[0];
1110 :     } else {
1111 :     my $NumEntries = @{$HashRef->{$FirstHeadings[$i]}};
1112 :     print HASHOUTPUT $NumEntries;
1113 :     }
1114 :     } else {
1115 :     print HASHOUTPUT 0;
1116 :     }
1117 :     }
1118 :     }
1119 :     print HASHOUTPUT "\n";
1120 :     #Printing data
1121 :     my $Continue = 1;
1122 :     my $Count = 0;
1123 :     while($Continue == 1) {
1124 :     print HASHOUTPUT ($Count+1).";";
1125 :     $Continue = 0;
1126 :     for (my $i=0; $i < @FirstHeadings; $i++) {
1127 :     if ($FirstHeadings[$i] ne $SecondHeadings[$i]) {
1128 :     if (defined($HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]})) {
1129 :     if (@{$HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]}} > 1 && defined($HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]}->[$Count])) {
1130 :     print HASHOUTPUT $HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]}->[$Count];
1131 :     $Continue = 1;
1132 :     }
1133 :     }
1134 :     } else {
1135 :     if (defined($HashRef->{$FirstHeadings[$i]})) {
1136 :     if (@{$HashRef->{$FirstHeadings[$i]}} > 1 && defined($HashRef->{$FirstHeadings[$i]}->[$Count])) {
1137 :     print HASHOUTPUT $HashRef->{$FirstHeadings[$i]}->[$Count];
1138 :     $Continue = 1;
1139 :     }
1140 :     }
1141 :     }
1142 :     print HASHOUTPUT ";";
1143 :     }
1144 :     $Count++;
1145 :     print HASHOUTPUT "\n";
1146 :     }
1147 :     close(HASHOUTPUT);
1148 :     }
1149 :    
1150 :     sub CreateHistogramHash {
1151 :     my($ArrayRef) = @_;
1152 :    
1153 :     my $HashRef;
1154 :     for (my $i=0; $i < @{$ArrayRef}; $i++) {
1155 :     my @TempArray = split(/\|/,$ArrayRef->[$i]);
1156 :     for (my $j=0; $j < @TempArray; $j++) {
1157 :     if (defined($HashRef->{$TempArray[$j]})) {
1158 :     $HashRef->{$TempArray[$j]}->[0]++;
1159 :     } else {
1160 :     $HashRef->{$TempArray[$j]}->[0] = 1;
1161 :     }
1162 :     }
1163 :     }
1164 :    
1165 :     return $HashRef;
1166 :     }
1167 :    
1168 :     #init_hoh will take a directory like peg or rxn and create a hash of hashes
1169 :     #my $dir_all = '/disks/www/Network_Data/MinOrg';
1170 :     #$dir_peg = "$dir_all/peg";
1171 :     #%hoh_peg = &init_hoh($dir_peg);
1172 :     # $hoh_peg{'peg.1234'}{REACTIONS} will be an @array of reactions associated with peg.1234
1173 :     sub init_hoh{
1174 :     my $dir = shift @_;
1175 :     my %hash;
1176 :     opendir my $DH, $dir or die "cannot open '$dir' $!";
1177 :     while (my $file = readdir $DH ) {
1178 :     chomp $file;
1179 :     next if $file =~ /~$/;
1180 :     next if -d $file;
1181 :     open my $FH, "<", "$dir/$file" or die "Cannot open '$dir/$file' $!";
1182 :     while ( my $line = <$FH> ) {
1183 :     chomp $line;
1184 :     next if /^#/ || !length($line);
1185 :     my ($key, @values ) = split(/\t/, $line);
1186 :     $hash{ $file }{ $key } = \@values;
1187 :     }
1188 :     close $FH;
1189 :     }
1190 :     return %hash;
1191 :     }
1192 :    
1193 :     sub AddElementsUnique {
1194 :     my ($ArrayRef,@NewElements) = @_;
1195 :    
1196 :     my $ArrayValueHash;
1197 :     my $NewArray;
1198 :     if (defined($ArrayRef) && @{$ArrayRef} > 0) {
1199 :     for (my $i=0; $i < @$ArrayRef; $i++) {
1200 :     if (!defined($ArrayValueHash->{$ArrayRef->[$i]})) {
1201 :     push(@{$NewArray},$ArrayRef->[$i]);
1202 :     $ArrayValueHash->{$ArrayRef->[$i]} = @{$NewArray}-1;
1203 :     }
1204 :     }
1205 :     }
1206 :    
1207 :     my $NumberOfMatches = 0;
1208 :     for (my $i=0; $i < @NewElements; $i++) {
1209 :     if (length($NewElements[$i]) > 0 && !defined($ArrayValueHash->{$NewElements[$i]})) {
1210 :     push(@{$NewArray},$NewElements[$i]);
1211 :     $ArrayValueHash->{$NewElements[$i]} = @{$NewArray}-1;
1212 :     } else {
1213 :     $NumberOfMatches++;
1214 :     }
1215 :     }
1216 :    
1217 :     return ($NewArray,$NumberOfMatches);
1218 :     }
1219 :    
1220 :     sub PutArrayInHash {
1221 :     my (@ArrayRef) = @_;
1222 :    
1223 :     my $HashRef;
1224 :     for (my $i=0; $i < @ArrayRef; $i++) {
1225 :     $HashRef->{$ArrayRef[$i]} = $i;
1226 :     }
1227 :    
1228 :     return $HashRef;
1229 :     }
1230 :    
1231 :     sub RefineOrganismName {
1232 :     my ($Name) = @_;
1233 :    
1234 :     my @Temp = split(/\s/,$Name);
1235 :     if (@Temp >= 2) {
1236 :     $Name = substr(shift(@Temp),0,1).". ".lc(join(" ",@Temp));
1237 :     }
1238 :     $Name =~ s/str\.\s//g;
1239 :     my $Find = "subsp. ".$Temp[0];
1240 :     $Name =~ s/$Find//g;
1241 :    
1242 :     return $Name;
1243 :     }
1244 :    
1245 :     sub RemoveDuplicates {
1246 :     my (@OriginalArray) = @_;
1247 :    
1248 :     my %Hash;
1249 :     foreach my $Element (@OriginalArray) {
1250 :     $Hash{$Element} = 1;
1251 :     }
1252 :     @OriginalArray = sort(keys(%Hash));
1253 :    
1254 :     return @OriginalArray;
1255 :     }
1256 :    
1257 :     sub FormatCoefficient {
1258 :     my ($Original) = @_;
1259 :    
1260 :     #Converting scientific notation to normal notation
1261 :     if ($Original =~ m/[eE]/) {
1262 :     my $Coefficient = "";
1263 :     my @Temp = split(/[eE]/,$Original);
1264 :     my @TempTwo = split(/\./,$Temp[0]);
1265 :     if ($Temp[1] > 0) {
1266 :     my $Index = $Temp[1];
1267 :     if (defined($TempTwo[1]) && $TempTwo[1] != 0) {
1268 :     $Index = $Index - length($TempTwo[1]);
1269 :     if ($Index < 0) {
1270 :     $TempTwo[1] = substr($TempTwo[1],0,(-$Index)).".".substr($TempTwo[1],(-$Index))
1271 :     }
1272 :     }
1273 :     for (my $j=0; $j < $Index; $j++) {
1274 :     $Coefficient .= "0";
1275 :     }
1276 :     if ($TempTwo[0] == 0) {
1277 :     $TempTwo[0] = "";
1278 :     }
1279 :     if (defined($TempTwo[1])) {
1280 :     $Coefficient = $TempTwo[0].$TempTwo[1].$Coefficient;
1281 :     } else {
1282 :     $Coefficient = $TempTwo[0].$Coefficient;
1283 :     }
1284 :     } elsif ($Temp[1] < 0) {
1285 :     my $Index = -$Temp[1];
1286 :     $Index = $Index - length($TempTwo[0]);
1287 :     if ($Index < 0) {
1288 :     $TempTwo[0] = substr($TempTwo[0],0,(-$Index)).".".substr($TempTwo[0],(-$Index))
1289 :     }
1290 :     if ($Index > 0) {
1291 :     $Coefficient = "0.";
1292 :     }
1293 :     for (my $j=0; $j < $Index; $j++) {
1294 :     $Coefficient .= "0";
1295 :     }
1296 :     $Coefficient .= $TempTwo[0];
1297 :     if (defined($TempTwo[1])) {
1298 :     $Coefficient .= $TempTwo[1];
1299 :     }
1300 :     }
1301 :     $Original = $Coefficient;
1302 :     }
1303 :     #Removing trailing zeros
1304 :     if ($Original =~ m/(.+\..+)0+$/) {
1305 :     $Original = $1;
1306 :     }
1307 :     $Original =~ s/\.0$//;
1308 :    
1309 :     return $Original;
1310 :     }
1311 :    
1312 :     sub ParseProcessorNumber {
1313 :     my ($InProcessorNumber) = @_;
1314 :    
1315 :     my $NumberOfProcessors = 1;
1316 :     my $NoHup = 0;
1317 :     if (defined($InProcessorNumber)) {
1318 :     if ($InProcessorNumber =~ m/^NH(.+)/) {
1319 :     $NumberOfProcessors = $1;
1320 :     $NoHup = 1;
1321 :     } else {
1322 :     $NumberOfProcessors = $InProcessorNumber;
1323 :     }
1324 :     }
1325 :    
1326 :     return ($NoHup,$NumberOfProcessors);
1327 :     }
1328 :    
1329 : parrello 1.13 1;

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3