spaceconstraint.cpp

ASP.NET 在线项目注册系统

	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;

			if(rm!=this->_room){
				if(conflictsString!=NULL){
					*conflictsString+=
						(QObject::tr("Space constraint teacher requires room broken for teacher %1, room %2, activity with id=%3")
						.arg(this->teacherName)
						.arg(this->roomName)
						.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 ConstraintTeacherRequiresRoom::isRelatedToActivity(Activity* a)
{
	if(a)
		;

	return false;
}

bool ConstraintTeacherRequiresRoom::isRelatedToTeacher(Teacher* t)
{
	if(this->teacherName==t->name)
		return true;
	return false;
}

bool ConstraintTeacherRequiresRoom::isRelatedToSubject(Subject* s)
{
	if(s)
		;

	return false;
}

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

	return false;
}

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

	return false;
}

bool ConstraintTeacherRequiresRoom::isRelatedToEquipment(Equipment* e)
{
	if(e)
		;

	return false;
}

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

	return false;
}

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

	return false;
}

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

ConstraintTeacherSubjectRequireRoom::ConstraintTeacherSubjectRequireRoom()
	: SpaceConstraint()
{
	this->type=CONSTRAINT_TEACHER_SUBJECT_REQUIRE_ROOM;
}

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

bool ConstraintTeacherSubjectRequireRoom::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++){
		if(r.internalActivitiesList[ac].subjectName!=this->subjectName)
			continue;
		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 ConstraintTeacherSubjectRequireRoom::getXmlDescription(Rules& r){
	if(&r!=NULL)
		;

	QString s="<ConstraintTeacherSubjectRequireRoom>\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+="	<Subject>"+protect(this->subjectName)+"</Subject>\n";
	s+="	<Room>"+protect(this->roomName)+"</Room>\n";
		
	s+="</ConstraintTeacherSubjectRequireRoom>\n";

	return s;
}

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

	QString s="Teacher subject 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("S:%1").arg(this->subjectName);s+=",";
	s+=QObject::tr("R:%1").arg(this->roomName);s+=",";

	return s;
}

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

	QString s=QObject::tr("Space constraint"); s+="\n";
	s+=QObject::tr("Teacher subject 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("Subject=%1").arg(this->subjectName);s+="\n";
	s+=QObject::tr("Room=%1").arg(this->roomName);s+="\n";

	return s;
}

//critical function here - must be optimized for speed
int ConstraintTeacherSubjectRequireRoom::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
	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;

			if(rm!=this->_room){
				if(conflictsString!=NULL){
					*conflictsString+=
						(QObject::tr("Space constraint teacher subject requires room broken for teacher %1, subject %2, room %3, activity with id=%4")
						.arg(this->teacherName)
						.arg(this->subjectName)
						.arg(this->roomName)
						.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 ConstraintTeacherSubjectRequireRoom::isRelatedToActivity(Activity* a)
{
	if(a)
		;

	return false;
}

bool ConstraintTeacherSubjectRequireRoom::isRelatedToTeacher(Teacher* t)
{
	if(this->teacherName==t->name)
		return true;
	return false;
}

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

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

	return false;
}

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

	return false;
}

bool ConstraintTeacherSubjectRequireRoom::isRelatedToEquipment(Equipment* e)
{
	if(e)
		;

	return false;
}

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

	return false;
}

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

	return false;
}

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

ConstraintMinimizeNumberOfRoomsForStudents::ConstraintMinimizeNumberOfRoomsForStudents()
	: SpaceConstraint()
{
	this->type=CONSTRAINT_MINIMIZE_NUMBER_OF_ROOMS_FOR_STUDENTS;
}

ConstraintMinimizeNumberOfRoomsForStudents::ConstraintMinimizeNumberOfRoomsForStudents(double w, bool c)
	: SpaceConstraint(w, c)
{
	this->type=CONSTRAINT_MINIMIZE_NUMBER_OF_ROOMS_FOR_STUDENTS;
}

bool ConstraintMinimizeNumberOfRoomsForStudents::computeInternalStructure(Rules& r)
{
	if(&r!=NULL)
		;
	/*do nothing*/
	
	return true;
}

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

	QString s = "<ConstraintMinimizeNumberOfRoomsForStudents>\n";
	s += "	<Weight>"+QString::number(this->weight)+"</Weight>\n";
	s += "	<Compulsory>";
	s += yesNo(this->compulsory);
	s += "</Compulsory>\n";
	s += "</ConstraintMinimizeNumberOfRoomsForStudents>\n";
	return s;
}

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

	QString s=QObject::tr("Minimize number of rooms for students");s+=",";
	s+=(QObject::tr("W:%1").arg(this->weight));s+=", ";
	s+=(QObject::tr("C:%1").arg(yesNoTranslated(this->compulsory)));s+=", ";

	return s;
}

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

	QString s=QObject::tr("Space constraint");s+="\n";
	s+=QObject::tr("Minimize number of rooms for each students set");s+="\n";
	s+=(QObject::tr("Weight=%1").arg(this->weight));s+="\n";
	s+=(QObject::tr("Compulsory=%1").arg(yesNoTranslated(this->compulsory)));s+="\n";

	return s;
}

//critical function here - must be optimized for speed
int ConstraintMinimizeNumberOfRoomsForStudents::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;
	}

	assert(r.internalStructureComputed);

	int nbroken=0;
	
	//without logging
	if(conflictsString==NULL){
		nbroken=0;
	
		for(int i=0; i<r.nInternalSubgroups; i++)
			for(int j=0; j<r.nInternalRooms; j++)
				subgroupsRooms[i][j]=false;
			
		for(int i=0; i<r.nInternalActivities; i++){
			if(c.rooms[i]!=UNALLOCATED_SPACE){
				for(int j=0; j<r.internalActivitiesList[i].nSubgroups; j++){
					int k=r.internalActivitiesList[i].subgroups[j];
					subgroupsRooms[k][c.rooms[i]]=true;
				}
			}
		}
	
		int total[MAX_TOTAL_SUBGROUPS];
		for(int i=0; i<r.nInternalSubgroups; i++)
			total[i]=0;
		
		for(int i=0; i<r.nInternalSubgroups; i++)
			for(int j=0; j<r.nInternalRooms; j++)
				if(subgroupsRooms[i][j])
					total[i]++;
				
		for(int i=0; i<r.nInternalSubgroups; i++)
			if(total[i]>1)
				nbroken+=total[i]-1;
	}
	//with logging
	else{
		nbroken=0;
	
		for(int i=0; i<r.nInternalSubgroups; i++)
			for(int j=0; j<r.nInternalRooms; j++)
				subgroupsRooms[i][j]=false;
			
		for(int i=0; i<r.nInternalActivities; i++){
			if(c.rooms[i]!=UNALLOCATED_SPACE){
				for(int j=0; j<r.internalActivitiesList[i].nSubgroups; j++){
					int k=r.internalActivitiesList[i].subgroups[j];
					subgroupsRooms[k][c.rooms[i]]=true;
				}
			}	
		}
	
		int total[MAX_TOTAL_SUBGROUPS];
		for(int i=0; i<r.nInternalSubgroups; i++)
			total[i]=0;
		
		for(int i=0; i<r.nInternalSubgroups; i++)
			for(int j=0; j<r.nInternalRooms; j++)
				if(subgroupsRooms[i][j])
					total[i]++;
				
		for(int i=0; i<r.nInternalSubgroups; i++)
			if(total[i]>1){
				nbroken+=total[i]-1;
	
				if(conflictsString!=NULL){
					*conflictsString+=
						QObject::tr("Space constraint minimize number of rooms for students broken for subgroup %1, number of rooms=%2")
						.arg(r.internalSubgroupsList[i]->name)
						.arg(total[i]);
					*conflictsString += ". ";
					*conflictsString += (QObject::tr("This increases the conflicts total by %1").arg(weight*(total[i]-1)));
					*conflictsString += "\n";
				}
			}
	}

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

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

	return false;
}

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

	return false;
}

bool ConstraintMinimizeNumberOfRoomsForStudents::isRelatedToSubject(Subject* s)
{
	if(s)
		;

	return false;
}

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

	return false;