static void displayTriple(iface::rdf_api::Triple* aTriple)
{
std::wcout << L"Triple: Subject=";
ObjRef<iface::rdf_api::Resource> r(aTriple->subject());
displayNode(r);
std::wcout << L" Predicate=";
r = aTriple->predicate();
displayNode(r);
std::wcout << L" Object=";
ObjRef<iface::rdf_api::Node> n(aTriple->object());
displayNode(n);
std::wcout << std::endl;
}
/** Get the mesh from the rectangular bounding mesh of the billboard node, which is used for node picking. */
void CC3BillboardBoundingBoxArea::populateDisplayNode()
{
CC3Billboard* bbNode = (CC3Billboard*)m_pNode;
bbNode->ensureBoundingMesh();
CC3BoundingVolumeDisplayNode* dn = displayNode();
dn->setMesh( bbNode->getMesh() );
dn->setShouldCullBackFaces( false ); // Make it a two-sided rectangle
}
void displayContainer(iface::rdf_api::Container* aContainer, const std::wstring& aPrefix)
{
try
{
ObjRef<iface::rdf_api::Resource> ctype(aContainer->containerType());
std::wcout << aPrefix << "Container type = ";
displayNode(ctype);
std::wcout << std::endl;
}
catch (...) {}
ObjRef<iface::rdf_api::NodeIterator> it(aContainer->iterateChildren());
while (true)
{
ObjRef<iface::rdf_api::Node> n(it->getNextNode());
if (n == NULL) break;
std::wcout << aPrefix << "* ";
displayNode(n);
std::wcout << std::endl;
}
}
void QgsGrassEdit::displayMap()
{
QgsDebugMsg( "entered." );
mTransform = mCanvas->getCoordinateTransform();
// re-create pixmap - it's transparent by default
*mPixmap = QPixmap( mCanvas->size() );
mPixmap->fill( QColor( 0, 0, 0, 0 ) );
QPainter *painter = new QPainter();
painter->begin( mPixmap );
// Display lines
int nlines = mProvider->numLines();
QPen pen;
// TODO?: 2 loops, first lines, then points
for ( int line = 1; line <= nlines; line++ )
{
displayElement( line, mSymb[mLineSymb[line]], mSize, painter );
}
// Display nodes
int nnodes = mProvider->numNodes();
pen.setColor( QColor( 255, 0, 0 ) );
if ( mSymbDisplay[SYMB_NODE_1] || mSymbDisplay[SYMB_NODE_2] )
{
for ( int node = 1; node <= nnodes; node++ )
{
if ( mNodeSymb[node] == SYMB_NODE_0 )
continue; // do not display nodes with points only
displayNode( node, mSymb[mNodeSymb[node]], mSize, painter );
}
}
painter->end();
delete painter;
// porting mCanvas->update();
mCanvasEdit->update();
mRubberBandIcon->update();
mRubberBandLine->update();
}
void QgsGrassEdit::displayUpdated( void )
{
QgsDebugMsg( "entered." );
mTransform = mCanvas->getCoordinateTransform();
mProjectionEnabled = ( QgsProject::instance()->readNumEntry( "SpatialRefSys", "/ProjectionsEnabled", 0 ) != 0 );
QPainter *painter = new QPainter();
painter->begin( mPixmap );
// Display lines
int nlines = mProvider->numUpdatedLines();
for ( int i = 0; i < nlines; i++ )
{
int line = mProvider->updatedLine( i );
if ( !( mProvider->lineAlive( line ) ) )
continue;
displayElement( line, mSymb[mLineSymb[line]], mSize, painter );
}
// Display nodes
int nnodes = mProvider->numUpdatedNodes();
for ( int i = 0; i < nnodes; i++ )
{
int node = mProvider->updatedNode( i );
if ( !( mProvider->nodeAlive( node ) ) )
continue;
if ( mNodeSymb[node] == SYMB_NODE_0 )
continue; // do not display nodes with points only
displayNode( node, mSymb[mNodeSymb[node]], mSize, painter );
}
painter->end();
delete painter;
// porting mCanvas->update();
mCanvasEdit->update();
mRubberBandIcon->update();
mRubberBandLine->update();
}
void displayTable(struct hash* HT)
{
int i=0;
struct node* temp;
temp=(struct node*)malloc(sizeof(struct node));
for(i=0;i<BKT_NUM;i++)
{
temp=HT[i].head;
if(HT[i].count>0)
{
printf("\nIndex %d\n",HT[i].count);
displayNode(temp);
printf("--");
temp=temp->next;
}
else
continue;
printf("\n");
}
}
int main(int argc, char** argv)
{
/*==================================================*/
/* Variables */
data d;
int* M;
/* GLPK */
int *ia, *ja;
double *ar;
double z;
double *x;
int notZeroCount;
/* Misc */
int i, pos;
/* Check up */
if(argc != 2)
{
printf("ERROR : no data file !\n");
exit(1);
}
/* Initialization */
filereader(argv[1], &d);
if(d.nbjour < 1)
{
printf("Obvious...\n");
return 0;
}
M = (int*) malloc ((d.nbjour +1)* sizeof(int));
M[d.nbjour] = d.d[d.nbjour];
for (i = d.nbjour-1; i >=0; --i)
{
M[i] = d.d[i] + M[i+1];
}
/* Problem creation*/
glp_prob *prob;
prob = glp_create_prob();
glp_set_prob_name(prob, "ULS");
glp_set_obj_dir(prob, GLP_MIN);
glp_smcp parm;
glp_init_smcp(&parm);
parm.msg_lev = GLP_MSG_OFF;
glp_iocp parmip;
glp_init_iocp(&parmip);
parmip.msg_lev = GLP_MSG_OFF;
/* Number of constraints : 2 * nbjour +2 */
glp_add_rows(prob, 2*d.nbjour +2);
for (i = 1; i <= d.nbjour; ++i)
{
glp_set_row_bnds(prob, i, GLP_FX, d.d[i], d.d[i]);
}
for (i = d.nbjour+1; i <= 2*d.nbjour; ++i)
{
glp_set_row_bnds(prob, i, GLP_LO, 0, 0);
}
glp_set_row_bnds(prob, 2*d.nbjour+1, GLP_FX, 0.0, 0.0);
glp_set_row_bnds(prob, 2*d.nbjour+2, GLP_FX, 0.0, 0.0);
/* Number of variables : 3*(nbjour +1)*/
glp_add_cols(prob, 3*(d.nbjour+1));
for (i = 0; i < d.nbjour +1; ++i)
{
glp_set_col_bnds(prob, i*3 +1, GLP_LO, 0.0, 0.0);
glp_set_col_bnds(prob, i*3 +2, GLP_LO, 0.0, 0.0);
glp_set_col_bnds(prob, i*3 +3, GLP_DB, 0.0, 1.0);
}
for (i = 1; i <= 3*(d.nbjour+1); ++i)
{
glp_set_col_kind(prob, i, GLP_CV);
}
/* Coefficients of the economic function */
glp_set_obj_coef(prob, 1, 0);
glp_set_obj_coef(prob, 2, 0);
glp_set_obj_coef(prob, 3, 0);
for (i = 1; i <=d.nbjour; ++i)
{
glp_set_obj_coef(prob, 3*i+1, d.p[i]);
glp_set_obj_coef(prob, 3*i+2, d.h[i]);
glp_set_obj_coef(prob, 3*i+3, d.f[i]);
}
/* Matrix */
notZeroCount = 5 * d.nbjour + 2;
ia = (int *) malloc ((1+notZeroCount) * sizeof(int));
ja = (int *) malloc ((1+notZeroCount) * sizeof(int));
ar = (double *) malloc ((1+notZeroCount) * sizeof(double));
pos = 1;
for (i = 1; i <= d.nbjour; ++i)
{
ia[pos] = i;
ia[pos+1] = i;
ia[pos+2] = i;
ja[pos] = i*3-1;
ja[pos+1] = i*3+1;
ja[pos+2] = i*3+2;
ar[pos] = 1.0;
ar[pos+1] = 1.0;
ar[pos+2] = -1.0;
pos += 3;
}
for (i = 1; i <= d.nbjour; ++i)
{
ia[pos] = i + d.nbjour;
ia[pos+1] = i + d.nbjour;
ja[pos] = i*3+1;
ja[pos+1] = i*3+3;
ar[pos] = -1.0;
ar[pos+1] = M[i];
pos += 2;
}
ia[pos] = 2*d.nbjour +1;
ia[pos+1] = 2 * d.nbjour+2;
ja[pos] = 3*(d.nbjour+1)-1;
ja[pos+1] = 2;
ar[pos] = 1.0;
ar[pos+1] = 1.0;
pos += 2;
glp_load_matrix(prob, notZeroCount, ia, ja , ar);
/* Writing in a file */
glp_write_lp(prob, NULL, "ULS.lp");
/* Branch and bound */
node* res = branchAndBound(prob);
displayNode(res);
}
void parseFile(char * fileName)
{
char type;
char ch;
char buffer[1000];
char * name;
char * data;
int state;
int error;
int size;
int i;
FILE * f;
node * head;
node * nav;
type = 0;
ch = 1;
name = NULL;
data = NULL;
state = 0;
size = 0;
error = 0;
i = 0;
f = NULL;
head = NULL;
nav = NULL;
if(fileName == NULL)
{
printf("Error: No filename given.\n");
return;
}
f = fopen(fileName, "r");
if(f == NULL)
{
printf("Error: Could not open file.\n");
return;
}
for(i = 0; i < 1000; i++)
{
buffer[i] = 0;
}
while(ch != EOF)
{
/*printf("%c", ch);*/
ch = fgetc(f);
if(isalpha(ch)||isnumber(ch))
{
/*printf("%c", ch);*/
buffer[size] = ch;
size++;
if(state == 0)
{
state = 1;
}
}
else if(ch == ' ' && state == 1)
{
/*printf("type = %s\n", buffer);*/
type = getType(buffer, size);
if(type == 0)
{
printf("Error: Invalid type.\n");
return;
}
state = 2;
size = 0;
for(i = 0; i < 1000; i++)
{
buffer[i] = 0;
}
}
else if(ch == '=')
{
/*printf("name = %s\n", buffer);*/
if(type == 0)
{
printf("Error: Invalid type.\n");
return;
}
name = getName(buffer, size);
if(name == NULL)
{
printf("Error: Invalid Name.\n");
return;
}
/*printf("name = %s\n", name);*/
state = 3;
size = 0;
for(i = 0; i < 1000; i++)
{
buffer[i] = 0;
}
}
else if(ch == ';')
{
/*printf("data = %s\n", buffer);*/
if(name == NULL)
{
printf("Error: Invalid name.\n");
return;
}
if(type == 0)
{
printf("Error: Invalid type.\n");
return;
}
data = getData(buffer, size);
if(data == NULL)
{
printf("Error: Invalid data.\n");
free(name);
return;
}
/*printf("data = %s\n", data);*/
if(head == NULL)
{
head = createNode(name, data, type);
if(head == NULL)
{
printf("Error: Could not create head.\n");
return;
}
nav = head;
}
else
{
nav->next = createNode(name, data, type);
if(nav->next == NULL)
{
printf("Error: Could not create node.\n");
return;
}
nav = nav->next;
}
state = 0;
size = 0;
for(i = 0; i < 1000; i++)
{
buffer[i] = 0;
}
free(name);
free(data);
type = 0;
name = NULL;
data = NULL;
}
else
{
}
}
if(head == NULL)
{
return;
}
printf("Displaying data structure contents\n");
printf("==================================\n");
nav = head;
while(nav->next != NULL)
{
displayNode(nav);
nav = nav->next;
}
displayNode(nav);
printf("Destroying DataStructure.\n");
error = destroyDataStructure(head);
printf("Destruction Errors = %d.\n", error);
printf("\n");
}
