Rectangle Class Reference

#include <Polygon.h>

Inheritance diagram for Rectangle:

Polygon ReferenceRectangle List of all members.

Public Member Functions

 Rectangle (GiNaC::ex p0, GiNaC::ex p1, string subscript="")
 Rectangle ()
virtual ~Rectangle ()
virtual int no_vertices ()
virtual GiNaC::ex vertex (int i)
virtual Line line (int i)
virtual GiNaC::ex repr (Repr_format format=SUBS_PERFORMED)
virtual string str ()
virtual GiNaC::ex integrate (GiNaC::ex f)

Detailed Description

Definition at line 113 of file Polygon.h.


Constructor & Destructor Documentation

Rectangle::Rectangle GiNaC::ex  p0,
GiNaC::ex  p1,
string  subscript = ""
 

Definition at line 512 of file Polygon.cpp.

References Polygon::p, and Polygon::subscript.

00512                                                                { 
00513   subscript = subscript_; 
00514 
00515   GiNaC::ex x0; 
00516   GiNaC::ex x1; 
00517   GiNaC::ex x2; 
00518   GiNaC::ex x3; 
00519 
00520   if (p0.nops() == 2 && p1.nops() == 2) { 
00521 
00522     x0 = GiNaC::lst(p0.op(0), p0.op(1)); 
00523     x1 = GiNaC::lst(p1.op(0), p0.op(1)); 
00524     x2 = GiNaC::lst(p1.op(0), p1.op(1)); 
00525     x3 = GiNaC::lst(p0.op(0), p1.op(1)); 
00526   
00527   }
00528   else if (p0.nops() == 3 && p1.nops() == 3) { 
00529     if ( p0.op(0) == p1.op(0) ) { 
00530 
00531       x0 = GiNaC::lst(p0.op(0), p0.op(1), p0.op(2)); 
00532       x1 = GiNaC::lst(p0.op(0), p1.op(1), p0.op(2)); 
00533       x2 = GiNaC::lst(p0.op(0), p1.op(1), p1.op(2)); 
00534       x3 = GiNaC::lst(p0.op(0), p0.op(1), p1.op(2)); 
00535     
00536     } else if ( p0.op(1) == p1.op(1) ) { 
00537 
00538       x0 = GiNaC::lst(p0.op(0), p0.op(1), p0.op(2)); 
00539       x1 = GiNaC::lst(p1.op(0), p0.op(1), p0.op(2)); 
00540       x2 = GiNaC::lst(p1.op(0), p0.op(1), p1.op(2)); 
00541       x3 = GiNaC::lst(p0.op(0), p0.op(1), p1.op(2)); 
00542  
00543     } else if ( p0.op(2) == p1.op(2) ) {       
00544 
00545       x0 = GiNaC::lst(p0.op(0), p0.op(1), p0.op(2)); 
00546       x1 = GiNaC::lst(p1.op(0), p0.op(1), p0.op(2)); 
00547       x2 = GiNaC::lst(p1.op(0), p1.op(1), p0.op(2)); 
00548       x3 = GiNaC::lst(p0.op(0), p1.op(1), p0.op(2)); 
00549 
00550     }
00551   } else {
00552     throw(std::invalid_argument("The points p0 and p1 must be of dimention either 2 or 3."));
00553   }
00554 
00555   p.insert(p.end(), x0); 
00556   p.insert(p.end(), x1); 
00557   p.insert(p.end(), x2); 
00558   p.insert(p.end(), x3); 
00559 
00560 }

Rectangle::Rectangle  )  [inline]
 

Definition at line 116 of file Polygon.h.

00116 {} 

virtual Rectangle::~Rectangle  )  [inline, virtual]
 

Definition at line 117 of file Polygon.h.

00117 {} 


Member Function Documentation

GiNaC::ex Rectangle::integrate GiNaC::ex  f  )  [virtual]
 

Reimplemented in ReferenceRectangle.

Definition at line 598 of file Polygon.cpp.

References Polygon::p, and repr().

Referenced by ReferenceRectangle::integrate(), and main().

00598                                           {
00599 
00600     int counter; 
00601     GiNaC::ex s_repr = repr(); 
00602 
00603     GiNaC::lst sub; 
00604     // perform substitution
00605     if ( p[0].nops() == 3) {
00606       sub = GiNaC::lst(s_repr.op(0), s_repr.op(1), s_repr.op(2));  
00607       counter = 3;  
00608     } else if ( p[0].nops() == 2) { 
00609       sub = GiNaC::lst(s_repr.op(0), s_repr.op(1));  
00610       counter = 2;  
00611     }
00612 
00613     GiNaC::ex D; 
00614     if (p[0].nops() == 2) { 
00615       D =  ( p[2].op(0) - p[0].op(0)) 
00616           *( p[2].op(1) - p[0].op(1)); 
00617     } else if (p[0].nops() == 3) { 
00618 
00619       if ( p[2].op(0) == p[0].op(0) ) {   
00620         D =  ( p[2].op(1) - p[0].op(1)) 
00621             *( p[2].op(2) - p[0].op(2)); 
00622       } 
00623       else if ( p[2].op(1) == p[0].op(1) ) {   
00624         D =  ( p[2].op(0) - p[0].op(0)) 
00625             *( p[2].op(2) - p[0].op(2)); 
00626       }
00627       else if ( p[2].op(2) == p[0].op(2) ) {   
00628         D =  ( p[2].op(0) - p[0].op(0)) 
00629             *( p[2].op(1) - p[0].op(1)); 
00630       }
00631     }
00632 
00633     GiNaC::ex intf = func.subs(sub); 
00634      
00635     intf = intf*D; 
00636 
00637     intf = GiNaC::integral(s_repr.op(counter).op(0), s_repr.op(counter).op(1), s_repr.op(counter).op(2), intf);  
00638     intf = eval_integ(intf); 
00639   
00640     counter++; 
00641     intf = GiNaC::integral(s_repr.op(counter).op(0), s_repr.op(counter).op(1), s_repr.op(counter).op(2), intf);  
00642     intf = eval_integ(intf); 
00643 
00644     counter++; 
00645     if ( counter <  s_repr.nops() ) { 
00646       intf = GiNaC::integral(s_repr.op(counter).op(0), s_repr.op(counter).op(1), s_repr.op(counter).op(2), intf);  
00647       intf = eval_integ(intf); 
00648     }
00649    
00650     return intf; 
00651 
00652 
00653 }

Line Rectangle::line int  i  )  [virtual]
 

Reimplemented in ReferenceRectangle.

Definition at line 568 of file Polygon.cpp.

References istr(), Polygon::p, and Polygon::subscript.

Referenced by ReferenceRectangle::line().

00568                            {
00569   if      ( i == 1) return Line(p[0],p[1], istr(subscript,i));  
00570   else if ( i == 2) return Line(p[1],p[2], istr(subscript,i));  
00571   else if ( i == 3) return Line(p[2],p[3], istr(subscript,i));  
00572   else if ( i == 4) return Line(p[3],p[0], istr(subscript,i));  
00573 }

int Rectangle::no_vertices  )  [virtual]
 

Reimplemented from Polygon.

Reimplemented in ReferenceRectangle.

Definition at line 562 of file Polygon.cpp.

00562 { return 4; }

GiNaC::ex Rectangle::repr Repr_format  format = SUBS_PERFORMED  )  [virtual]
 

Reimplemented in ReferenceRectangle.

Definition at line 575 of file Polygon.cpp.

References Polygon::p, x, y, and z.

Referenced by integrate(), main(), and ReferenceRectangle::repr().

00575                                            {
00576    GiNaC::lst ret;   
00577    GiNaC::symbol r("r"), s("s"), t("t"); 
00578    if ( p[0].nops() == 2) {
00579      ret.append( x == p[0].op(0) + r*( p[2].op(0) - p[0].op(0))); 
00580      ret.append( y == p[0].op(1) + s*( p[2].op(1) - p[0].op(1))); 
00581      ret.append( GiNaC::lst(r,0,1)); 
00582      ret.append( GiNaC::lst(s,0,1)); 
00583    } else if ( p[0].nops() == 3) {
00584      ret.append( x == p[0].op(0) + r*( p[2].op(0) - p[0].op(0))); 
00585      ret.append( y == p[0].op(1) + s*( p[2].op(1) - p[0].op(1))); 
00586      ret.append( z == p[0].op(1) + t*( p[2].op(2) - p[0].op(2))); 
00587      ret.append( GiNaC::lst(r,0,1)); 
00588      ret.append( GiNaC::lst(s,0,1)); 
00589      ret.append( GiNaC::lst(t,0,1)); 
00590    }
00591    return ret; 
00592 }

string Rectangle::str  )  [virtual]
 

Reimplemented from Polygon.

Reimplemented in ReferenceRectangle.

Definition at line 594 of file Polygon.cpp.

00594                         {
00595   return "Rectangle"; 
00596 }

GiNaC::ex Rectangle::vertex int  i  )  [virtual]
 

Reimplemented from Polygon.

Reimplemented in ReferenceRectangle.

Definition at line 564 of file Polygon.cpp.

References Polygon::p.

00564                                  {
00565   return p[i]; 
00566 }


The documentation for this class was generated from the following files:
Generated on Wed Apr 19 12:38:15 2006 for SyFi by  doxygen 1.4.4