[system] / trunk / pg / macros / PGasu.pl Repository:
ViewVC logotype

Annotation of /trunk/pg/macros/PGasu.pl

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : gage 1834 =head1 NAME
2 : gage 1064
3 : gage 1834 PSasu.pl -- located in the pg/macros directory
4 : apizer 1080
5 : gage 1834 =head1 SYNPOSIS
6 :    
7 :    
8 :     Macros contributed by John Jones
9 :    
10 :     =cut
11 :    
12 :    
13 : gage 1064 # Answer evaluator which always marks things correct
14 : gage 1834
15 :     =head3 auto_right()
16 :    
17 :    
18 :     =cut
19 :    
20 : gage 1064 sub auto_right {
21 :     my $ae = std_str_cmp("");
22 : apizer 1080
23 : gage 1064 my $ans_eval = sub {
24 :     my $tried = shift;
25 :     my $ans_hash = &$ae($tried);
26 :     $ans_hash->{score} = 1;
27 :     return $ans_hash;
28 :     };
29 :     return $ans_eval;
30 :     }
31 :    
32 :     # Evaluate in tth mode
33 :    
34 : gage 1834 =head3 tthev()
35 :    
36 :    
37 :    
38 :     =cut
39 :    
40 : gage 1064 sub tthev {
41 :     my $cmt = shift;
42 : apizer 1080
43 : gage 1064 $mdm = $main::displayMode;
44 :     $main::displayMode = 'HTML_tth';
45 :     $cmt = EV3($cmt);
46 :     $cmt =~ s/\\par/<P>/g;
47 :     $cmt =~ s/\\noindent//g;
48 :     $main::displayMode =$mdm;
49 :     $cmt
50 :     }
51 :    
52 : gage 1834 =head3 no_decs()
53 :    
54 :    
55 :    
56 :     =cut
57 :    
58 :    
59 : gage 1064 sub no_decs {
60 :     my ($old_evaluator) = @_;
61 :    
62 :     my $msg= "Your answer contains a decimal. You must provide an exact answer, e.g. sqrt(5)/3";
63 :     $old_evaluator->install_pre_filter(must_have_filter(".", 'no', $msg));
64 :     $old_evaluator->install_post_filter(\&raw_student_answer_filter);
65 :    
66 :     return $old_evaluator;
67 :     }
68 :    
69 : gage 1834 =head3 must_include()
70 :    
71 :    
72 :    
73 :     =cut
74 :    
75 : gage 1064 sub must_include {
76 :     my ($old_evaluator) = shift;
77 :     my $muststr = shift;
78 :    
79 :     $old_evaluator->install_pre_filter(must_have_filter($muststr));
80 :     $old_evaluator->install_post_filter(\&raw_student_answer_filter);
81 :     return $old_evaluator;
82 :     }
83 : gage 1834 =head3 no_trig_fun()
84 : gage 1064
85 : gage 1834
86 :    
87 :     =cut
88 :    
89 : gage 1064 sub no_trig_fun {
90 :     my ($ans) = shift;
91 :     my $new_eval = fun_cmp($ans);
92 :     my ($msg) = "Your answer to this problem may not contain a trig function.";
93 :     $new_eval->install_pre_filter(must_have_filter("sin", 'no', $msg));
94 :     $new_eval->install_pre_filter(must_have_filter("cos", 'no', $msg));
95 :     $new_eval->install_pre_filter(must_have_filter("tan", 'no', $msg));
96 :     $new_eval->install_pre_filter(must_have_filter("sec", 'no', $msg));
97 :     $new_eval->install_pre_filter(must_have_filter("csc", 'no', $msg));
98 :     $new_eval->install_pre_filter(must_have_filter("cot", 'no', $msg));
99 :    
100 :     return $new_eval;
101 :     }
102 :    
103 : gage 1834 =head3 no_trig()
104 : gage 1064
105 : gage 1834
106 :    
107 :     =cut
108 :     =head3 no_trig()
109 :    
110 :    
111 :    
112 :     =cut
113 :    
114 : gage 1064 sub no_trig {
115 :     my ($ans) = shift;
116 :     my $new_eval = num_cmp($ans);
117 :     my ($msg) = "Your answer to this problem may not contain a trig function.";
118 :     $new_eval->install_pre_filter(must_have_filter("sin", 'no', $msg));
119 :     $new_eval->install_pre_filter(must_have_filter("cos", 'no', $msg));
120 :     $new_eval->install_pre_filter(must_have_filter("tan", 'no', $msg));
121 :     $new_eval->install_pre_filter(must_have_filter("sec", 'no', $msg));
122 :     $new_eval->install_pre_filter(must_have_filter("csc", 'no', $msg));
123 :     $new_eval->install_pre_filter(must_have_filter("cot", 'no', $msg));
124 :    
125 :     return $new_eval;
126 :     }
127 :    
128 : gage 1834 =head3 exact_no_trig()
129 :    
130 :    
131 :    
132 :     =cut
133 :    
134 : gage 1064 sub exact_no_trig {
135 :     my ($ans) = shift;
136 :     my $old_eval = num_cmp($ans);
137 :     my $new_eval = no_decs($old_eval);
138 :     my ($msg) = "Your answer to this problem may not contain a trig function.";
139 :     $new_eval->install_pre_filter(must_have_filter("sin", 'no', $msg));
140 :     $new_eval->install_pre_filter(must_have_filter("cos", 'no', $msg));
141 :     $new_eval->install_pre_filter(must_have_filter("tan", 'no', $msg));
142 :     $new_eval->install_pre_filter(must_have_filter("sec", 'no', $msg));
143 :     $new_eval->install_pre_filter(must_have_filter("csc", 'no', $msg));
144 :     $new_eval->install_pre_filter(must_have_filter("cot", 'no', $msg));
145 :    
146 :     return $new_eval;
147 :     }
148 :    
149 : gage 1834
150 :     =head3 must_have_filter()
151 :    
152 :    
153 :    
154 :     # First argument is the string to have, or not have
155 :     # Second argument is optional, and tells us whether yes or no
156 :     # Third argument is the error message to produce (if any).
157 :    
158 :     =cut
159 :    
160 :    
161 : gage 1064 # First argument is the string to have, or not have
162 :     # Second argument is optional, and tells us whether yes or no
163 :     # Third argument is the error message to produce (if any).
164 :     sub must_have_filter {
165 :     my $str = shift;
166 :     my $yesno = shift;
167 :     my $errm = shift;
168 :    
169 :     $str =~ s/\./\\./g;
170 :     if(!defined($yesno)) {
171 :     $yesno=1;
172 :     } else {
173 :     $yesno = ($yesno eq 'no') ? 0 :1;
174 :     }
175 :    
176 :     my $newfilt = sub {
177 :     my $num = shift;
178 :     my $process_ans_hash = ( ref( $num ) eq 'AnswerHash' ) ? 1 : 0 ;
179 :     my ($rh_ans);
180 :     if ($process_ans_hash) {
181 :     $rh_ans = $num;
182 :     $num = $rh_ans->{original_student_ans};
183 :     }
184 :     my $is_ok = 0;
185 : apizer 1080
186 : gage 1064 return $is_ok unless defined($num);
187 : apizer 1080
188 : gage 1064 if (($yesno and ($num =~ /$str/)) or (!($yesno) and !($num=~ /$str/))) {
189 :     $is_ok = 1;
190 :     }
191 : apizer 1080
192 : gage 1064 if ($process_ans_hash) {
193 :     if ($is_ok == 1 ) {
194 :     $rh_ans->{original_student_ans}=$num;
195 :     return $rh_ans;
196 :     } else {
197 :     if(defined($errm)) {
198 :     $rh_ans->{ans_message} = $errm;
199 :     $rh_ans->{student_ans} = $rh_ans->{original_student_ans};
200 :     # $rh_ans->{student_ans} = "Your answer was \"$rh_ans->{original_student_ans}\". $errm";
201 :     $rh_ans->throw_error('SYNTAX', $errm);
202 :     } else {
203 :     $rh_ans->throw_error('NUMBER', "");
204 :     }
205 :     return $rh_ans;
206 :     }
207 : apizer 1080
208 : gage 1064 } else {
209 :     return $is_ok;
210 :     }
211 :     };
212 :     return $newfilt;
213 :     }
214 :    
215 : gage 1834 =head3 raw_student_answer_filter()
216 :    
217 :    
218 :    
219 :     =cut
220 :    
221 :    
222 : gage 1064 sub raw_student_answer_filter {
223 :     my ($rh_ans) = shift;
224 :     # warn "answer was ".$rh_ans->{student_ans};
225 :     $rh_ans->{student_ans} = $rh_ans->{original_student_ans}
226 :     unless ($rh_ans->{student_ans} =~ /[a-zA-Z]/);
227 : apizer 1080 # warn "2nd time ... answer was ".$rh_ans->{student_ans};
228 :    
229 : gage 1064 return $rh_ans;
230 :     }
231 :    
232 : gage 1834 =head3 no_decimal_list()
233 :    
234 :    
235 :    
236 :     =cut
237 :    
238 :    
239 : gage 1064 sub no_decimal_list {
240 :     my ($ans) = shift;
241 :     my (%jopts) = @_;
242 :     my $old_evaluator = number_list_cmp($ans);
243 :    
244 :     my $answer_evaluator = sub {
245 :     my $tried = shift;
246 :     my $ans_hash;
247 :     if ( ref($old_evaluator) eq 'AnswerEvaluator' ) { # new style
248 :     $ans_hash = $old_evaluator->evaluate($tried);
249 :     } elsif (ref($old_evaluator) eq 'CODE' ) { #old style
250 :     $ans_hash = &$old_evaluator($tried);
251 :     }
252 :     if(defined($jopts{'must'}) && ! ($tried =~ /$jopts{'must'}/)) {
253 :     $ans_hash->{score}=0;
254 :     $ans_hash->setKeys( 'ans_message' => 'Your answer needs to be exact.');
255 :     }
256 :     if($tried =~ /\./) {
257 :     $ans_hash->{score}=0;
258 :     $ans_hash->setKeys( 'ans_message' => 'You may not use decimals in your answer.');
259 :     }
260 :     return $ans_hash;
261 :     };
262 :     return $answer_evaluator;
263 :     }
264 :    
265 :    
266 : gage 1834 =head3 no_decimals()
267 :    
268 :    
269 :    
270 :     =cut
271 :    
272 :    
273 : gage 1064 sub no_decimals {
274 :     my ($ans) = shift;
275 :     my (%jopts) = @_;
276 :     my $old_evaluator = std_num_cmp($ans);
277 :    
278 :     my $answer_evaluator = sub {
279 :     my $tried = shift;
280 :     my $ans_hash;
281 :     if ( ref($old_evaluator) eq 'AnswerEvaluator' ) { # new style
282 :     $ans_hash = $old_evaluator->evaluate($tried);
283 :     } elsif (ref($old_evaluator) eq 'CODE' ) { #old style
284 :     $ans_hash = &$old_evaluator($tried);
285 :     }
286 :     if(defined($jopts{'must'}) && ! ($tried =~ /$jopts{'must'}/)) {
287 :     $ans_hash->{score}=0;
288 :     $ans_hash->setKeys( 'ans_message' => 'Your answer needs to be exact.');
289 :     }
290 :     if($tried =~ /\./) {
291 :     $ans_hash->{score}=0;
292 :     $ans_hash->setKeys( 'ans_message' => 'You may not use decimals in your answer.');
293 :     }
294 :     return $ans_hash;
295 :     };
296 :     return $answer_evaluator;
297 :     }
298 :    
299 : gage 1834 =head3 log_switcheroo()
300 :    
301 :    
302 :    
303 :     =cut
304 :    
305 :    
306 : gage 1064 sub log_switcheroo {
307 :     my $foo = shift;
308 :    
309 :     $foo =~ s/log(?!ten)/logten/gi;
310 :     return $foo;
311 :     }
312 :    
313 :     # only used below, so assumes it is being applied to num_cmp
314 :     sub log_switcheroo_filter {
315 :     my ($rh_ans) = shift;
316 :     $rh_ans->{student_ans} = log_switcheroo($rh_ans->{student_ans});
317 :    
318 :     return $rh_ans;
319 :     }
320 :    
321 : gage 1834 =head3 log10_cmp()
322 :    
323 :    
324 :    
325 :     =cut
326 :    
327 :    
328 :    
329 : gage 1064 sub log10_cmp {
330 :     my(@stuff) = @_;
331 :     $stuff[0] = log_switcheroo($stuff[0]);
332 :     my ($ae) = num_cmp(@stuff);
333 :     $ae->install_pre_filter(\&log_switcheroo_filter);
334 :     return $ae;
335 :     }
336 :    
337 : gage 1834
338 :     =head3 with_comments()
339 :    
340 :    
341 :     # Wrapper for an answer evaluator which can also supply comments
342 :    
343 :     =cut
344 :    
345 : gage 1064 # Wrapper for an answer evaluator which can also supply comments
346 : gage 1834
347 :    
348 : gage 1064 sub with_comments {
349 :     my ($old_evaluator, $cmt) = @_;
350 : apizer 1080
351 : gage 1064 # $mdm = $main::displayMode;
352 :     # $main::displayMode = 'HTML_tth';
353 :     # $cmt = EV2($cmt);
354 :     # $main::displayMode =$mdm;
355 : apizer 1080
356 : gage 1064 my $ans_evaluator = sub {
357 :     my $tried = shift;
358 :     my $ans_hash;
359 :    
360 :     if ( ref($old_evaluator) eq 'AnswerEvaluator' ) { # new style
361 :     $ans_hash = $old_evaluator->evaluate($tried);
362 :     } elsif (ref($old_evaluator) eq 'CODE' ) { #old style
363 :     $ans_hash = &$old_evaluator($tried);
364 :     } else {
365 :     warn "There is a problem using the answer evaluator";
366 :     }
367 : apizer 1080
368 : gage 1064 if($ans_hash->{score}>0) {
369 :     $ans_hash -> setKeys( 'ans_message' => $cmt);
370 :     }
371 :     return $ans_hash;
372 :     };
373 :    
374 :     $ans_evaluator;
375 :     }
376 :    
377 : gage 1834
378 :     =head3 pc_evaluator()
379 :    
380 :    
381 :     # Wrapper for multiple answer evaluators, it takes a list of the following as inputs
382 :     # [answer_evaluator, partial credit factor, comment]
383 :     # it applies evaluators from the list until it hits one with positive credit,
384 :     # weights it by the partial credit factor, and throws in its comment
385 :    
386 :    
387 :     =cut
388 :    
389 :    
390 : gage 1064 # Wrapper for multiple answer evaluators, it takes a list of the following as inputs
391 :     # [answer_evaluator, partial credit factor, comment]
392 :     # it applies evaluators from the list until it hits one with positive credit,
393 :     # weights it by the partial credit factor, and throws in its comment
394 :    
395 :     sub pc_evaluator {
396 :     my ($evaluator_list) = @_;
397 : apizer 1080
398 : gage 1064 my $ans_evaluator = sub {
399 :     my $tried = shift;
400 :     my $ans_hash;
401 :     for($j=0;$j<scalar(@{$evaluator_list}); $j++) {
402 :     my $old_evaluator = $evaluator_list->[$j][0];
403 :     my $cmt = $evaluator_list->[$j][2];
404 :     my $weight = $evaluator_list->[$j][1];
405 :    
406 :     if ( ref($old_evaluator) eq 'AnswerEvaluator' ) { # new style
407 :     $ans_hash = $old_evaluator->evaluate($tried);
408 :     } elsif (ref($old_evaluator) eq 'CODE' ) { #old style
409 :     $ans_hash = &$old_evaluator($tried);
410 :     } else {
411 :     warn "There is a problem using the answer evaluator";
412 :     }
413 : apizer 1080
414 : gage 1064 if($ans_hash->{score}>0) {
415 :     $ans_hash -> setKeys( 'ans_message' => $cmt);
416 :     $ans_hash->{score} *= $weight;
417 :     return $ans_hash;
418 :     };
419 :     };
420 :     return $ans_hash;
421 :     };
422 : apizer 1080
423 : gage 1064 $ans_evaluator;
424 :     }
425 :    
426 : gage 1834 =head3 nicestring
427 :    
428 :    
429 :    
430 :     =cut
431 :    
432 :    
433 : gage 1064 sub nicestring {
434 :     my($thingy) = shift;
435 :     my(@coefs) = @{$thingy};
436 :     my $n = scalar(@coefs);
437 :     $thingy = shift;
438 :     my(@others);
439 :     if(defined($thingy)) {
440 :     @others = @{$thingy};
441 :     } else {
442 :     my($j);
443 :     for $j (1..($n-2)) {
444 :     $others[$j-1] = "x^".($n-$j);
445 :     }
446 :     if($n>=2) { $others[$n-2] = "x";}
447 :     $others[$n-1] = "";
448 :     }
449 :     my($j, $k)=(0,0);
450 :     while(($k<$n) && ($coefs[$k]==0)) {$k++;}
451 :     if($k==$n) {return("0");}
452 :     my $ans;
453 :     if($coefs[$k]==1) {$ans = ($others[$k]) ? "$others[$k]" : "1";}
454 :     elsif($coefs[$k]== -1) {$ans = ($others[$k]) ? "- $others[$k]" : "-1"}
455 :     else { $ans = "$coefs[$k] $others[$k]";}
456 :     $k++;
457 :     for $j ($k..($n-1)) {
458 :     if($coefs[$j] != 0) {
459 :     if($coefs[$j] == 1) {
460 :     $ans .= ($others[$j]) ? "+ $others[$j]" : "+ 1";
461 :     } elsif($coefs[$j] == -1) {
462 :     $ans .= ($others[$j]) ? "- $others[$j]" : "-1";
463 :     } else {
464 :     $ans .= "+ $coefs[$j] $others[$j]";
465 :     }
466 :     }
467 :     }
468 :     return($ans);
469 :     }
470 :    
471 :    
472 : gage 1834 =head3 displaymat
473 :    
474 :    
475 :    
476 :     =cut
477 :    
478 :    
479 : gage 1064 sub displaymat {
480 :     my $tmpp = shift;
481 :     my %opts = @_;
482 :     my @myrows = @{$tmpp};
483 :     my $numrows = scalar(@myrows);
484 :     my @arow = $myrows->[0];
485 :     my ($number)= scalar(@arow); #number of columns in table
486 :     my $out;
487 :     my $j;
488 :     my $align1=''; # alignment as a string
489 :     my @align; # alignment as a list
490 :     if(defined($opts{'align'})) {
491 :     $align1= $opts{'align'};
492 :     @align = split //, $opts{'align'};
493 :     } else {
494 :     for($j=0; $j<$number; $j++) {
495 :     $align[$j] = "c";
496 :     $align1 .= "c";
497 :     }
498 :     }
499 :    
500 :     $out .= beginmatrix($align1);
501 :     $out .= matleft($numrows);
502 :     for $j (@myrows) {
503 :     $out .= matrow($j, @align);
504 :     }
505 :     $out .= matright($numrows);
506 :     $out .= endmatrix();
507 :     $out;
508 :     }
509 :    
510 : gage 1834 =head3 beginmatrix
511 :    
512 :    
513 :    
514 :     =cut
515 :    
516 :    
517 : gage 1064 sub beginmatrix {
518 :     my ($aligns)=shift; #alignments of columns in table
519 :     # my %options = @_;
520 :     my $out = "";
521 :     if ($displayMode eq 'TeX') {
522 :     $out .= "\n\\(\\displaystyle\\left(\\begin{array}{$aligns} \n";
523 :     }
524 :     elsif ($displayMode eq 'Latex2HTML') {
525 :     $out .= "\n\\begin{rawhtml} <TABLE BORDER=0>\n\\end{rawhtml}";
526 :     }
527 :     elsif ($displayMode eq 'HTML' || $displayMode eq 'HTML_tth' || $displayMode eq 'HTML_dpng') {
528 :     $out .= "<TABLE BORDER=0>\n"
529 :     }
530 : apizer 1080 else {
531 : gage 1064 $out = "Error: beginmatrix: Unknown displayMode: $displayMode.\n";
532 :     }
533 :     $out;
534 :     }
535 :    
536 :    
537 : gage 1834 =head3 matleft
538 :    
539 :    
540 :    
541 :     =cut
542 :    
543 :    
544 :    
545 : gage 1064 sub matleft {
546 :     my $numrows = shift;
547 :     if ($displayMode eq 'TeX') {
548 :     return "";
549 :     }
550 :     my $out='';
551 :     my $j;
552 :    
553 :     if(($displayMode eq 'HTML_dpng') || ($displayMode eq 'Latex2HTML')) {
554 :     # if($numrows>12) { $numrows = 12; }
555 :     if($displayMode eq 'Latex2HTML') { $out .= '\begin{rawhtml}'; }
556 :     $out .= "<tr><td nowrap=\"nowrap\" align=\"left\">";
557 :     if($displayMode eq 'Latex2HTML') { $out .= '\end{rawhtml}'; }
558 :     # $out .= "<img alt=\"(\" src = \"".
559 :     # $main::imagesURL."/left$numrows.png\" >";
560 :     # return $out;
561 :     $out .= '\(\left.\begin{array}{c}';
562 :     for($j=0;$j<$numrows;$j++) { $out .= ' \\\\'; }
563 :     $out .= '\end{array}\right(\)';
564 : apizer 1080
565 : gage 1064 if($displayMode eq 'Latex2HTML') { $out .= '\begin{rawhtml}'; }
566 :     $out .= "<td><table border=0 cellspacing=5>\n";
567 :     if($displayMode eq 'Latex2HTML') { $out .= '\end{rawhtml}'; }
568 :     return $out;
569 :     }
570 :     $out = "<tr><td nowrap=\"nowrap\" align=\"left\"><font face=\"symbol\"><br />";
571 :     for($j=0;$j<$numrows;$j++) {
572 :     $out .= "<br />";
573 :     }
574 :     $out .= "</font></td>\n";
575 :     $out .= "<td><table border=0 cellspacing=5>\n";
576 :     return $out;
577 :     }
578 :    
579 : gage 1834
580 :     =head3 matright
581 :    
582 :    
583 :    
584 :     =cut
585 :    
586 :    
587 : gage 1064 sub matright {
588 :     my $numrows = shift;
589 :     my $out='';
590 :     my $j;
591 : apizer 1080
592 : gage 1064 if ($displayMode eq 'TeX') {
593 :     return "";
594 :     }
595 :    
596 :     if(($displayMode eq 'HTML_dpng') || ($displayMode eq 'Latex2HTML')) {
597 :     if($displayMode eq 'Latex2HTML') { $out .= '\begin{rawhtml}'; }
598 :     $out .= "</table><td nowrap=\"nowrap\" align=\"right\">";
599 :     if($displayMode eq 'Latex2HTML') { $out .= '\end{rawhtml}'; }
600 : apizer 1080
601 : gage 1064 # $out .= "<img alt=\"(\" src = \"".
602 :     # "/webwork_system_html/images"."/right$numrows.png\" >";
603 :     $out .= '\(\left)\begin{array}{c}';
604 :     for($j=0;$j<$numrows;$j++) { $out .= ' \\\\'; }
605 :     $out .= '\end{array}\right.\)';
606 :     return $out;
607 :     }
608 :    
609 :     $out .= "</table>";
610 :     $out .= "<td nowrap=\"nowrap\" align=\"left\"><font face=\"symbol\"><br />";
611 :     for($j=0;$j<$numrows;$j++) {
612 :     $out .= "<br />";
613 :     }
614 :     $out .= "</font></td>\n";
615 :     return $out;
616 :     }
617 :    
618 : gage 1834 =head3 endmatrix
619 :    
620 :    
621 :    
622 :     =cut
623 :    
624 :    
625 : gage 1064 sub endmatrix {
626 :     my $out = "";
627 :     if ($displayMode eq 'TeX') {
628 :     $out .= "\n\\end{array}\\right)\\)\n";
629 :     }
630 :     elsif ($displayMode eq 'Latex2HTML') {
631 :     $out .= "\n\\begin{rawhtml} </TABLE >\n\\end{rawhtml}";
632 :     }
633 :     elsif ($displayMode eq 'HTML' || $displayMode eq 'HTML_tth' || $displayMode eq 'HTML_dpng') {
634 :     $out .= "</TABLE>\n";
635 :     }
636 :     else {
637 :     $out = "Error: PGchoicemacros: endtable: Unknown displayMode: $displayMode.\n";
638 :     }
639 :     $out;
640 :     }
641 :    
642 :    
643 : gage 1834 =head3 matrow
644 :    
645 :    
646 :    
647 :     =cut
648 :    
649 :    
650 :    
651 : gage 1064 sub matrow {
652 :     my $elements = shift;
653 :     my @align = @_;
654 :     my @elements = @{$elements};
655 :     my $out = "";
656 :     if ($displayMode eq 'TeX') {
657 :     while (@elements) {
658 :     $out .= shift(@elements) . " &";
659 :     }
660 :     chop($out); # remove last &
661 :     $out .= "\\\\ \n";
662 :     # carriage returns must be added manually for tex
663 :     }
664 :     elsif ($displayMode eq 'Latex2HTML') {
665 :     $out .= "\n\\begin{rawhtml}\n<TR>\n\\end{rawhtml}\n";
666 :     while (@elements) {
667 :     $out .= " \n\\begin{rawhtml}\n<TD> \n\\end{rawhtml}\n" . shift(@elements) . " \n\\begin{rawhtml}\n</TD> \n\\end{rawhtml}\n";
668 :     }
669 :     $out .= " \n\\begin{rawhtml}\n</TR> \n\\end{rawhtml}\n";
670 :     }
671 :     elsif ($main::displayMode eq 'HTML' || $main::displayMode eq 'HTML_tth' || $displayMode eq 'HTML_dpng') {
672 :     $out .= "<TR><td nowrap=\"nowrap\">\n";
673 :     while (@elements) {
674 :     my $myalign;
675 :     #do {$myalign = shift @align;} until($myalign ne "|");
676 :     $myalign = shift @align;
677 :     if($myalign eq "|") {
678 :     $out .= '<td> | </td>';
679 :     } else {
680 :     if($myalign eq "c") { $myalign = "center";}
681 :     if($myalign eq "l") { $myalign = "left";}
682 :     if($myalign eq "r") { $myalign = "right";}
683 :     $out .= "<TD nowrap=\"nowrap\" align=\"$myalign\">" . shift(@elements) . "</TD>";
684 :     }
685 :     }
686 :     $out .= "<td>\n</TR>\n";
687 :     }
688 :     else {
689 :     $out = "Error: matrow: Unknown displayMode: $main::displayMode.\n";
690 :     }
691 :     $out;
692 :     }
693 :    
694 :    
695 :     ## Local Variables:
696 :     ## mode: CPerl
697 :     ## font-lock-mode: t
698 :     ## End:

aubreyja at gmail dot com
ViewVC Help
Powered by ViewVC 1.0.9