spaceconstraint.cpp

ASP.NET 在线项目注册系统

	if(conflictsString==NULL){
		nbroken=0;
		for(int i=0; i<this->_nActivities; i++){	
			int ac=this->_activities[i];
			int parity=r.internalActivitiesList[ac].parity==PARITY_WEEKLY?2:1;
			int rm=c.rooms[ac];
			if(rm==UNALLOCATED_SPACE)
				continue;
		
			bool ok=true;
			for(int j=0; j<this->_nEquipments; j++){
				int eq=this->_equipments[j];
				if(!r.roomHasEquipment[rm][eq]){
					ok=false;
					break;
				}
			}

			if(!ok)
				nbroken+=parity;
		}
	}
		//with logging
	else{
		nbroken=0;
		for(int i=0; i<this->_nActivities; i++){	
			int ac=this->_activities[i];
			int parity=r.internalActivitiesList[ac].parity==PARITY_WEEKLY?2:1;
			int rm=c.rooms[ac];
			if(rm==UNALLOCATED_SPACE)
				continue;
			
			bool ok=true;
			for(int j=0; j<this->_nEquipments; j++){
				int eq=this->_equipments[j];
				if(!r.roomHasEquipment[rm][eq]){
					ok=false;
					break;
				}
			}

			if(!ok){
				if(conflictsString!=NULL){
					*conflictsString+=
						(QObject::tr("Space constraint subject requires equipments broken for room %1, activity with id %2")
						.arg(r.internalRoomsList[rm]->name)
						.arg(r.internalActivitiesList[ac].id));
					*conflictsString += ". ";
					*conflictsString += (QObject::tr("This increases the conflicts total by %1").arg(weight*parity));
					*conflictsString += "\n";
				}

				nbroken+=parity;
			}
		}
	}

	return int (ceil ( weight * nbroken ) );
}

bool ConstraintSubjectRequiresEquipments::isRelatedToActivity(Activity* a)
{
	if(a)
		;

	return false;
}

bool ConstraintSubjectRequiresEquipments::isRelatedToTeacher(Teacher* t)
{
	if(t)
		;

	return false;
}

bool ConstraintSubjectRequiresEquipments::isRelatedToSubject(Subject* s)
{
	if(this->subjectName==s->name)
		return true;
	return false;
}

bool ConstraintSubjectRequiresEquipments::isRelatedToSubjectTag(SubjectTag* s)
{
	if(s)
		;

	return false;
}

bool ConstraintSubjectRequiresEquipments::isRelatedToStudentsSet(Rules& r, StudentsSet* s)
{
	if(s)
		;
	if(&r)
		;

	return false;
}

bool ConstraintSubjectRequiresEquipments::isRelatedToEquipment(Equipment* e)
{
	return this->searchRequiredEquipment(e->name);
}

bool ConstraintSubjectRequiresEquipments::isRelatedToBuilding(Building* b)
{
	if(b)
		;

	return false;
}

bool ConstraintSubjectRequiresEquipments::isRelatedToRoom(Room* r)
{
	if(r)
		;

	return false;
}

/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////

ConstraintSubjectSubjectTagRequireEquipments::ConstraintSubjectSubjectTagRequireEquipments()
	: SpaceConstraint()
{
	this->type=CONSTRAINT_SUBJECT_SUBJECT_TAG_REQUIRE_EQUIPMENTS;
}

ConstraintSubjectSubjectTagRequireEquipments::ConstraintSubjectSubjectTagRequireEquipments(double w, bool c, const QString& subj, const QString& subt)
	: SpaceConstraint(w, c)
{
	this->type=CONSTRAINT_SUBJECT_SUBJECT_TAG_REQUIRE_EQUIPMENTS;
	this->subjectName=subj;
	this->subjectTagName=subt;
}

bool ConstraintSubjectSubjectTagRequireEquipments::computeInternalStructure(Rules& r)
{
	//This procedure computes the internal list of all the activities
	//which correspond to the subject of the constraint.
	//Computes also the internal list of indices of equipments
	
	this->_nActivities=0;
	for(int ac=0; ac<r.nInternalActivities; ac++)
		if(r.internalActivitiesList[ac].subjectName == this->subjectName
		 &&r.internalActivitiesList[ac].subjectTagName==this->subjectTagName){
			assert(this->_nActivities<MAX_ACTIVITIES_FOR_A_SUBJECT);
			this->_activities[this->_nActivities++]=ac;
		}
		
	this->_nEquipments=0;
	for(int eq=0; eq<r.nInternalEquipments; eq++)
		if(this->searchRequiredEquipment(r.internalEquipmentsList[eq]->name)){
			assert(this->_nEquipments<MAX_EQUIPMENTS_FOR_A_CONSTRAINT);
			this->_equipments[this->_nEquipments++]=eq;
		}
		
	return true;
}

void ConstraintSubjectSubjectTagRequireEquipments::addRequiredEquipment(const QString& equip)
{
	this->equipmentsNames.append(equip);
}

int ConstraintSubjectSubjectTagRequireEquipments::removeRequiredEquipment(const QString& equip)
{
	int tmp=this->equipmentsNames.remove(equip);
	return tmp;
}

bool ConstraintSubjectSubjectTagRequireEquipments::searchRequiredEquipment(const QString& equip)
{
	int tmp=this->equipmentsNames.findIndex(equip);
	if(tmp>=0)
		return true;
	else
		return false;
}

QString ConstraintSubjectSubjectTagRequireEquipments::getXmlDescription(Rules& r){
	if(&r!=NULL)
		;

	QString s="<ConstraintSubjectSubjectTagRequireEquipments>\n";
	s+="	<Weight>"+QString::number(weight)+"</Weight>\n";
	s+="	<Compulsory>";
	s+=yesNo(this->compulsory);
	s+="</Compulsory>\n";
	s+="	<Subject>"+protect(this->subjectName)+"</Subject>\n";
	s+="	<Subject_Tag>"+protect(this->subjectTagName)+"</Subject_Tag>\n";

	for(QStringList::Iterator it=this->equipmentsNames.begin(); it!=this->equipmentsNames.end(); it++)
		s+="	<Equipment>"+protect(*it)+"</Equipment>\n";
		
	s+="</ConstraintSubjectSubjectTagRequireEquipments>\n";

	return s;
}

QString ConstraintSubjectSubjectTagRequireEquipments::getDescription(Rules& r){
	if(&r!=NULL)
		;

	QString s="Subject subject tag require equipments"; s+=", ";
	s+=QObject::tr("W:%1").arg(this->weight);s+=", ";
	s+=QObject::tr("C:%1").arg(yesNoTranslated(this->compulsory));s+=", ";
	s+=QObject::tr("S:%1").arg(this->subjectName);s+=",";
	s+=QObject::tr("ST:%1").arg(this->subjectTagName);s+=",";

	for(QStringList::Iterator it=this->equipmentsNames.begin(); it!=this->equipmentsNames.end(); it++)
		s+=QObject::tr("E:%1").arg(*it); s+=",";

	return s;
}

QString ConstraintSubjectSubjectTagRequireEquipments::getDetailedDescription(Rules& r){
	if(&r!=NULL)
		;

	QString s=QObject::tr("Space constraint"); s+="\n";
	s+=QObject::tr("Subject subject tag require equipments"); s+="\n";
	s+=QObject::tr("Weight=%1").arg(this->weight);s+="\n";
	s+=QObject::tr("Compulsory=%1").arg(yesNoTranslated(this->compulsory));s+="\n";
	s+=QObject::tr("Subject=%1").arg(this->subjectName);s+="\n";
	s+=QObject::tr("Subject tag=%1").arg(this->subjectTagName);s+="\n";

	for(QStringList::Iterator it=this->equipmentsNames.begin(); it!=this->equipmentsNames.end(); it++){
		s+=QObject::tr("Equipment=%1").arg(*it); 
		s+="\n";
	}

	return s;
}

//critical function here - must be optimized for speed
int ConstraintSubjectSubjectTagRequireEquipments::fitness(
	SpaceChromosome& c,
	Rules& r,
	const int days[/*MAX_ACTIVITIES*/],
	const int hours[/*MAX_ACTIVITIES*/],
	QString* conflictsString)
{
	//if the matrix roomsMatrix is already calculated, do not calculate it again!
	if(crt_chrom!=&c || crt_rules!=&r){
		rooms_conflicts = c.getRoomsMatrix(r, days, hours, roomsMatrix);

		crt_chrom = &c;
		crt_rules = &r;
	}

	//Calculates the number of conflicts.
	//The fastest way seems to iterate over all activities
	//involved in this constraint (share the subject and subject tag of this constraint),
	//find the scheduled room and check to see if this
	//room is accepted or not.

	int nbroken;

	//without logging
	if(conflictsString==NULL){
		nbroken=0;
		for(int i=0; i<this->_nActivities; i++){	
			int ac=this->_activities[i];
			int parity=r.internalActivitiesList[ac].parity==PARITY_WEEKLY?2:1;
			int rm=c.rooms[ac];
			if(rm==UNALLOCATED_SPACE)
				continue;
		
			bool ok=true;
			for(int j=0; j<this->_nEquipments; j++){
				int eq=this->_equipments[j];
				if(!r.roomHasEquipment[rm][eq]){
					ok=false;
					break;
				}
			}

			if(!ok)
				nbroken+=parity;
		}
	}
	//with logging
	else{
		nbroken=0;
		for(int i=0; i<this->_nActivities; i++){	
			int ac=this->_activities[i];
			int parity=r.internalActivitiesList[ac].parity==PARITY_WEEKLY?2:1;
			int rm=c.rooms[ac];
			if(rm==UNALLOCATED_SPACE)
				continue;
		
			bool ok=true;
			for(int j=0; j<this->_nEquipments; j++){
				int eq=this->_equipments[j];
				if(!r.roomHasEquipment[rm][eq]){
					ok=false;
					break;
				}
			}

			if(!ok){
				if(conflictsString!=NULL){
					*conflictsString+=
						(QObject::tr("Space constraint subject subject tag require equipments broken for room %1, activity with id %2")
						.arg(r.internalRoomsList[rm]->name)
						.arg(r.internalActivitiesList[ac].id));
					*conflictsString += ". ";
					*conflictsString += (QObject::tr("This increases the conflicts total by %1").arg(weight*parity));
					*conflictsString += "\n";
				}

				nbroken+=parity;
			}
		}
	}

	return int (ceil ( weight * nbroken ) );
}

bool ConstraintSubjectSubjectTagRequireEquipments::isRelatedToActivity(Activity* a)
{
	if(a)
		;

	return false;
}

bool ConstraintSubjectSubjectTagRequireEquipments::isRelatedToTeacher(Teacher* t)
{
	if(t)
		;

	return false;
}

bool ConstraintSubjectSubjectTagRequireEquipments::isRelatedToSubject(Subject* s)
{
	if(this->subjectName==s->name)
		return true;
	return false;
}

bool ConstraintSubjectSubjectTagRequireEquipments::isRelatedToSubjectTag(SubjectTag* s)
{
	if(this->subjectTagName==s->name)
		return true;
	return false;
}

bool ConstraintSubjectSubjectTagRequireEquipments::isRelatedToStudentsSet(Rules& r, StudentsSet* s)
{
	if(s)
		;
	if(&r)
		;

	return false;
}

bool ConstraintSubjectSubjectTagRequireEquipments::isRelatedToEquipment(Equipment* e)
{
	return this->searchRequiredEquipment(e->name);
}

bool ConstraintSubjectSubjectTagRequireEquipments::isRelatedToBuilding(Building* b)
{
	if(b)
		;

	return false;
}

bool ConstraintSubjectSubjectTagRequireEquipments::isRelatedToRoom(Room* r)
{
	if(r)
		;

	return false;
}

/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////

ConstraintTeacherRequiresRoom::ConstraintTeacherRequiresRoom()
	: SpaceConstraint()
{
	this->type=CONSTRAINT_TEACHER_REQUIRES_ROOM;
}

ConstraintTeacherRequiresRoom::ConstraintTeacherRequiresRoom(double w, bool c, const QString& teach, const QString& room)
	: SpaceConstraint(w, c)
{
	this->type=CONSTRAINT_TEACHER_REQUIRES_ROOM;
	this->teacherName=teach;
	this->roomName=room;
}

bool ConstraintTeacherRequiresRoom::computeInternalStructure(Rules& r)
{
	//This procedure computes the internal list of all the activities
	//which correspond to the teacher of the constraint,	
	this->_nActivities=0;
	for(int ac=0; ac<r.nInternalActivities; ac++)
		for(QStringList::Iterator it=r.internalActivitiesList[ac].teachersNames.begin(); it!=r.internalActivitiesList[ac].teachersNames.end(); it++)
			if(*it == this->teacherName){
				assert(this->_nActivities<MAX_ACTIVITIES_FOR_A_TEACHER);
				this->_activities[this->_nActivities++]=ac;
			}
		
	this->_room = r.searchRoom(this->roomName);
	assert(this->_room>=0);
	
	return true;
}

QString ConstraintTeacherRequiresRoom::getXmlDescription(Rules& r){
	if(&r!=NULL)
		;

	QString s="<ConstraintTeacherRequiresRoom>\n";
	s+="	<Weight>"+QString::number(weight)+"</Weight>\n";
	s+="	<Compulsory>";
	s+=yesNo(this->compulsory);
	s+="</Compulsory>\n";
	s+="	<Teacher>"+protect(this->teacherName)+"</Teacher>\n";
	s+="	<Room>"+protect(this->roomName)+"</Room>\n";
		
	s+="</ConstraintTeacherRequiresRoom>\n";

	return s;
}

QString ConstraintTeacherRequiresRoom::getDescription(Rules& r){
	if(&r!=NULL)
		;

	QString s="Teacher requires room"; s+=", ";
	s+=QObject::tr("W:%1").arg(this->weight);s+=", ";
	s+=QObject::tr("C:%1").arg(yesNoTranslated(this->compulsory));s+=", ";
	s+=QObject::tr("T:%1").arg(this->teacherName);s+=",";
	s+=QObject::tr("R:%1").arg(this->roomName);s+=",";

	return s;
}

QString ConstraintTeacherRequiresRoom::getDetailedDescription(Rules& r){
	if(&r!=NULL)
		;

	QString s=QObject::tr("Space constraint"); s+="\n";
	s+=QObject::tr("Teacher requires room"); s+="\n";
	s+=QObject::tr("Weight=%1").arg(this->weight);s+="\n";
	s+=QObject::tr("Compulsory=%1").arg(yesNoTranslated(this->compulsory));s+="\n";
	s+=QObject::tr("Teacher=%1").arg(this->teacherName);s+="\n";
	s+=QObject::tr("Room=%1").arg(this->roomName);s+="\n";

	return s;
}

//critical function here - must be optimized for speed
int ConstraintTeacherRequiresRoom::fitness(
	SpaceChromosome& c,
	Rules& r,
	const int days[/*MAX_ACTIVITIES*/],
	const int hours[/*MAX_ACTIVITIES*/],
	QString* conflictsString)
{
	//if the matrix roomsMatrix is already calculated, do not calculate it again!
	if(crt_chrom!=&c || crt_rules!=&r){
		rooms_conflicts = c.getRoomsMatrix(r, days, hours, roomsMatrix);

		crt_chrom = &c;
		crt_rules = &r;
	}

	//Calculates the number of conflicts
	//The fastest way seems to iterate over all activities
	//involved in this constraint (share the teacher of this constraint)
	//and find the scheduled room and check to see if this
	//room is accepted or not

	int nbroken;

	//without logging
	if(conflictsString==NULL){
		nbroken=0;
		for(int i=0; i<this->_nActivities; i++){
			int ac=this->_activities[i];
			int parity=r.internalActivitiesList[ac].parity==PARITY_WEEKLY?2:1;
			int rm=c.rooms[ac];
			if(rm==UNALLOCATED_SPACE)
				continue;

			if(rm!=this->_room)
				nbroken+=parity;
		}
	}
	//with logging