[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 1941 - (view) (download) (as text)

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

aubreyja at gmail dot com
ViewVC Help
Powered by ViewVC 1.0.9