place and connect two diagrams in recursive composition More...

#include <recSchema.h>

Inheritance diagram for recSchema:

Collaboration diagram for recSchema:

Public Member Functions
virtual void	place (double ox, double oy, int orientation)
	The two subschema are placed centered vertically, s2 on top of s1. More...

virtual void	draw (device &dev)
	Draw the two subschema s1 and s2 as well as the implicit feedback delays between s1 and s2. More...

virtual point	inputPoint (unsigned int i) const
	The input points s1 ~ s2. More...

virtual point	outputPoint (unsigned int i) const
	The output points s1 ~ s2. More...

virtual void	collectTraits (collector &c)
	Draw the two subschema s1 and s2 as well as the feedback connections between s1 and s2, and the feedfrom connections beetween s2 and s1. More...

Public Member Functions inherited from schema
	schema (unsigned int inputs, unsigned int outputs, double width, double height)

virtual	~schema ()

double	width () const

double	height () const

unsigned int	inputs () const

unsigned int	outputs () const

void	beginPlace (double x, double y, int orientation)

void	endPlace ()

bool	placed () const

double	x () const

double	y () const

int	orientation () const

Private Member Functions
	recSchema (schema s1, schema s2, double width)
	Constructor of a recursive schema (s1 ~ s2). More...

void	drawDelaySign (device &dev, double x, double y, double size)
	Draw the delay sign of a feedback connection. More...

void	collectFeedback (collector &c, const point &src, const point &dst, double dx, const point &out)
	Draw a feedback connection between two points with an horizontal displacement dx. More...

void	collectFeedfront (collector &c, const point &src, const point &dst, double dx)
	Draw a feedfrom connection between two points with an horizontal displacement dx. More...

Private Attributes
schema *	fSchema1

schema *	fSchema2

vector< point >	fInputPoint

vector< point >	fOutputPoint

Friends
schema *	makeRecSchema (schema s1, schema s2)
	Creates a new recursive schema (s1 ~ s2). More...

Detailed Description

place and connect two diagrams in recursive composition

Definition at line 33 of file recSchema.h.

Constructor & Destructor Documentation

recSchema::recSchema	(	schema *	s1,
		schema *	s2,
		double	width
	)

private

Constructor of a recursive schema (s1 ~ s2).

The two components are supposed to have the same width.

Definition at line 48 of file recSchema.cpp.

References fInputPoint, fOutputPoint, schema::inputs(), schema::outputs(), and schema::width().

     :   schema( s1->inputs() - s2->outputs(),
                 s1->outputs(),
                 width,
                 s1->height() + s2->height() ),
         fSchema1(s1),
         fSchema2(s2)
 {
     // this version only accepts legal expressions of same width
     assert(s1->inputs() >= s2->outputs());
     assert(s1->outputs() >= s2->inputs());
     assert(s1->width() >= s2->width());
 
     // create the input and output points
     for (unsigned int i=0; i<inputs(); i++)     fInputPoint.push_back(point(0,0));
     for (unsigned int i=0; i<outputs(); i++)    fOutputPoint.push_back(point(0,0));
 
 }

Here is the call graph for this function:

Member Function Documentation

void recSchema::collectFeedback	(	collector &	c,
		const point &	src,
		const point &	dst,
		double	dx,
		const point &	out
	)

private

Draw a feedback connection between two points with an horizontal displacement dx.

Definition at line 202 of file recSchema.cpp.

References collector::addInput(), collector::addOutput(), collector::addTrait(), dWire, kLeftRight, schema::orientation(), point::x, and point::y.

Referenced by collectTraits().

 {
     double  ox = src.x + ((orientation()==kLeftRight) ? dx : -dx);
     double  ct = (orientation()==kLeftRight) ? dWire/2 : -dWire/2;
 
     point   up(ox, src.y-ct);
     point   br(ox+ct/2.0, src.y);
 
     c.addOutput(up);
     c.addOutput(br);
     c.addInput(br);
 
     c.addTrait(trait(up, point(ox, dst.y)));
     c.addTrait(trait(point(ox, dst.y), point(dst.x, dst.y)));
     c.addTrait(trait(src,br));
     c.addTrait(trait(br,out));
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void recSchema::collectFeedfront	(	collector &	c,
		const point &	src,
		const point &	dst,
		double	dx
	)

private

Draw a feedfrom connection between two points with an horizontal displacement dx.

Definition at line 226 of file recSchema.cpp.

References collector::addTrait(), kLeftRight, schema::orientation(), point::x, and point::y.

Referenced by collectTraits().

 {
     double  ox = src.x + ((orientation()==kLeftRight) ? -dx : dx);
 
     c.addTrait(trait(point(src.x, src.y), point(ox, src.y)));
     c.addTrait(trait(point(ox, src.y), point(ox, dst.y)));
     c.addTrait(trait(point(ox, dst.y), point(dst.x, dst.y)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void recSchema::collectTraits ( collector & c )

virtual

Draw the two subschema s1 and s2 as well as the feedback connections between s1 and s2, and the feedfrom connections beetween s2 and s1.

Implements schema.

Definition at line 162 of file recSchema.cpp.

References collector::addTrait(), collectFeedback(), collectFeedfront(), schema::collectTraits(), dWire, fSchema1, fSchema2, inputPoint(), schema::inputPoint(), schema::inputs(), outputPoint(), schema::outputPoint(), schema::outputs(), and schema::placed().

 {
     assert(placed());
 
     // draw the two subdiagrams
     fSchema1->collectTraits(c);
     fSchema2->collectTraits(c);
 
     // draw the feedback connections to each fSchema2 input
     for (unsigned int i=0; i<fSchema2->inputs(); i++) {
         collectFeedback(c, fSchema1->outputPoint(i), fSchema2->inputPoint(i), i*dWire, outputPoint(i));
     }
 
     // draw the non recursive output lines
     for (unsigned int i=fSchema2->inputs(); i<outputs(); i++) {
         point p = fSchema1->outputPoint(i);
         point q = outputPoint(i);
         c.addTrait(trait(p,q));     // in->out order
     }
 
     // draw the input lines
     unsigned int skip = fSchema2->outputs();
     for (unsigned int i=0; i<inputs(); i++) {
         point p = inputPoint(i);
         point q = fSchema1->inputPoint(i+skip);
         c.addTrait(trait(p,q));     // in->out order
     }
 
     // draw the feedfront connections from each fSchema2 output
     for (unsigned int i=0; i<fSchema2->outputs(); i++) {
         collectFeedfront(c, fSchema2->outputPoint(i), fSchema1->inputPoint(i), i*dWire);
     }
 }

Here is the call graph for this function:

void recSchema::draw ( device & dev )

virtual

Draw the two subschema s1 and s2 as well as the implicit feedback delays between s1 and s2.

Implements schema.

Definition at line 129 of file recSchema.cpp.

References schema::draw(), drawDelaySign(), dWire, fSchema1, fSchema2, schema::inputs(), kLeftRight, schema::orientation(), schema::outputPoint(), schema::placed(), point::x, and point::y.

 {
     assert(placed());
 
     // draw the two subdiagrams
     fSchema1->draw(dev);
     fSchema2->draw(dev);
 
     // draw the implicit feedback delay to each fSchema2 input
     double dw = (orientation()==kLeftRight) ? dWire : -dWire;
     for (unsigned int i=0; i<fSchema2->inputs(); i++) {
         const point& p = fSchema1->outputPoint(i);
         drawDelaySign(dev, p.x + i*dw, p.y, dw/2);
 
     }
 }

Here is the call graph for this function:

void recSchema::drawDelaySign	(	device &	dev,
		double	x,
		double	y,
		double	size
	)

private

Draw the delay sign of a feedback connection.

Definition at line 149 of file recSchema.cpp.

References device::trait().

Referenced by draw().

 {
     dev.trait(x-size/2, y, x-size/2, y-size);
     dev.trait(x-size/2, y-size, x+size/2, y-size);
     dev.trait(x+size/2, y-size, x+size/2, y);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

point recSchema::inputPoint ( unsigned int i ) const

virtual

The input points s1 ~ s2.

Implements schema.

Definition at line 110 of file recSchema.cpp.

References fInputPoint.

Referenced by collectTraits().

 {
     return fInputPoint[i];
 }

Here is the caller graph for this function:

point recSchema::outputPoint ( unsigned int i ) const

virtual

The output points s1 ~ s2.

Implements schema.

Definition at line 119 of file recSchema.cpp.

References fOutputPoint.

Referenced by collectTraits().

 {
     return fOutputPoint[i];
 }

Here is the caller graph for this function:

void recSchema::place	(	double	ox,
		double	oy,
		int	orientation
	)

virtual

The two subschema are placed centered vertically, s2 on top of s1.

The input and output points are computed.

Implements schema.

Definition at line 71 of file recSchema.cpp.

References schema::beginPlace(), schema::endPlace(), fInputPoint, fOutputPoint, fSchema1, fSchema2, schema::height(), schema::inputPoint(), schema::inputs(), kLeftRight, kRightLeft, schema::outputPoint(), schema::outputs(), schema::place(), schema::width(), point::x, and point::y.

 {
     beginPlace(ox, oy, orientation);
 
     double dx1 = (width() - fSchema1->width())/2;
     double dx2 = (width() - fSchema2->width())/2;
 
     // place the two sub diagrams
     if (orientation == kLeftRight) {
         fSchema2->place(ox+dx2, oy, kRightLeft);
         fSchema1->place(ox+dx1, oy+fSchema2->height(), kLeftRight);
     } else {
         fSchema1->place(ox+dx1, oy, kRightLeft);
         fSchema2->place(ox+dx2, oy+fSchema1->height(), kLeftRight);
     }
 
 
     // adjust delta space to orientation
     if (orientation == kRightLeft) { dx1 = -dx1; }
 
     // place input points
     for (unsigned int i=0; i<inputs(); i++) {
         point p = fSchema1->inputPoint(i+fSchema2->outputs());
         fInputPoint[i] = point(p.x-dx1, p.y);
     }
 
     // place output points
     for (unsigned int i=0; i<outputs(); i++) {
         point p = fSchema1->outputPoint(i);
         fOutputPoint[i] = point(p.x+dx1, p.y);
     }
 
     endPlace();
 }

Here is the call graph for this function:

Friends And Related Function Documentation

schema* makeRecSchema	(	schema *	s1,
		schema *	s2
	)

friend

Creates a new recursive schema (s1 ~ s2).

The smallest component is enlarged to the width of the other. The left and right horizontal margins are computed according to the number of internal connections.

Definition at line 34 of file recSchema.cpp.

 {
     schema* a = makeEnlargedSchema(s1, s2->width());
     schema* b = makeEnlargedSchema(s2, s1->width());
     double  m = dWire * max(b->inputs(), b->outputs());
     double  w = a->width() + 2*m;
 
     return new recSchema(a,b,w);
 }