C++ Vecteur类代码示例

Vecteur<double> Capteur::StatsPropres()
// Algorithme :
{
	// Creation de la structure de retour et variables pratiques
	Vecteur<double> statsRetour;
	double total =	d1Resume[4] + d2Resume[4] + d3Resume[4] + d4Resume[4] +
					d5Resume[4] + d6Resume[4] + d7Resume[4];
	double statTrafic;

	// Remplissage
	for (int i = 0; i < TAILLE_RESUME - 1; i++)
	{
		if ( total != 0 )
		{
			statTrafic = ( d1Resume[i] + d2Resume[i] + d3Resume[i] + d4Resume[i] +
				d5Resume[i] + d6Resume[i] + d7Resume[i] ) / total;			
		}
		else
		{
			statTrafic = 0;
		}
		statsRetour.insererFin(statTrafic);
	}
	
	return statsRetour;

} //----- Fin de StatsPropres

void Particule::setPosInt(Vecteur pos)
{
    m_pos = pos;
    m_pos2 = pos;
    m_x = (int)pos.getX();
    m_y = (int)pos.getY();
}

Vecteur<int> Capteur::EmbouteillageJour( int d7 )
// Algorithme :
// Structure de retour :	Vecteur 0->23 : nombre d'embouteillage recense par heure
//							24->47 : nombre total de donnees par heure
{
	// Création structure de retour et variables pratiques
	Vecteur<int> donneesRetour;
	Vecteur<Evenement>* jour = nullptr;
	Trafic trafic;

	// Détermination de la branche dans laquelle prendre les données
	switch ( d7 )
	{
	case 1:
		jour = &d1Contenu;
		break;
	case 2:
		jour = &d2Contenu;
		break;
	case 3:
		jour = &d3Contenu;
		break;
	case 4:
		jour = &d4Contenu;
		break;
	case 5:
		jour = &d5Contenu;
		break;
	case 6:
		jour = &d6Contenu;
		break;
	case 7:
		jour = &d7Contenu;
		break;
	default:
		// Erreur : mauvaise demande de jour
		break;
	}  //----- Fin de switch ( d7 )

	// Init de la structure de retour
	for ( int i = 0; i < 48; i++ )
	{
		donneesRetour.insererFin(0);
	}

	// Parcours du tableau d'événements et remplissage de la structure de retour
	for (int i = 0; i < jour->GetTaille(); i++)
	{
		trafic = (*jour)[i].GetTrafic();
		if ( trafic == R || trafic == N )
		{
			donneesRetour[(*jour)[i].GetHeure()] += 1;
		}
		donneesRetour[(*jour)[i].GetHeure() + 24] += 1;		// TODO: plus rapide avec creation de variable ?
	}

	return donneesRetour;

} //----- Fin de EmbouteillageJour

	//produit vectoriel
	Vecteur operator^(const Vecteur & v) const
	{
		Vecteur res;
		res.x() = (*this).y()*v.z() - (*this).z()*v.y();
		res.y() = (*this).z()*v.x() - (*this).x()*v.z();
		res.z() = (*this).x()*v.y() - (*this).y()*v.x();
		return res;
	}

	//division par un scalaire
	Vecteur operator/ (double d) const
	{
		Vecteur res;
		res.x() = x()/d;
		res.y() = y()/d;
		res.z() = z()/d;
		return res;
	}

Vecteur_Creux Vecteur_Creux::operator+(const Vecteur_Creux& v2) const
{
    // pour stocker les indices utiles et les valeurs utiles du vecteur résultat
    int* ixres = new int[nbu + v2.nbu];
    int* utres = new int[nbu + v2.nbu];
    // pour calculer le nb de valeurs utiles du vecteur résultat
    int nbures = 0;

    // on parcourt en parallèle les indices utiles du vecteur 1 (l'objet courant)
    // et du vecteur 2 (v2)
      
    int i1 = 0, i2 = 0; // indices de parcours des vecteurs des indices utiles
    bool finVect1 = false, finVect2 = false;

    while (!finVect1 || !finVect2) {

        int ind_utile1, ind_utile2;
        if (!finVect1)
            ind_utile1 = vix.get_val(i1);
        if (!finVect2)
            ind_utile2 = v2.vix.get_val(i2);

        if ((ind_utile1 < ind_utile2 && !finVect1) || finVect2) {
            ixres[nbures] = ind_utile1;
            utres[nbures] = vut.get_val(i1);
            i1++;
        }
        else if (ind_utile1 == ind_utile2 && !finVect1 && !finVect2) {
            ixres[nbures] = ind_utile1;
            utres[nbures] = vut.get_val(i1) + v2.vut.get_val(i2);
            i1++; i2++;
        }
        else if ((ind_utile2 < ind_utile1 && !finVect2) || finVect1) {
            ixres[nbures] = ind_utile2;
            utres[nbures] = v2.vut.get_val(i2);
            i2++;
        }
        nbures++;
        if (i1 == nbu)
            finVect1 = true;
        if (i2 == v2.nbu)
            finVect2 = true;
    }

    // nb de valeurs réelles du vecteur résultat : max des 2 nb de valeurs réelles
    int nbrres = (nbr > v2.nbr)? nbr : v2.nbr;

    Vecteur vutres(utres, nbures);
    Vecteur vixres(ixres, nbures);
    Vecteur_Creux vres(vutres, vixres, nbrres);

    delete [] ixres;
    delete [] utres;

    return vres;
}

Vecteur XMLtoVecteur::xmlToVecteur(TiXmlElement* v) 
{
	Vecteur vecteur;
	
	vecteur.setP1(this->xmlToPoint(v->FirstChildElement()));
	
	vecteur.setP2(this->xmlToPoint(v->FirstChildElement()->NextSiblingElement()));

	return vecteur;	
}

void Camera::updateAngles() {
    // différence de position
    Vecteur delta = posTar - posCam;
    float r = delta.norm();

    // calcul des angles
    phi = asin(delta.getZ()/r);
    theta = 2*atan(delta.getX()/(delta.getY()+r*cos(phi)));
    phi *= 180 / M_PI;
    theta *= 180 / M_PI;
}

float calcTforIntersect(Vecteur ni, Point A, Point B, Point Pi, Point Pi1)
{
    Vecteur D = Vecteur(A, B);

    Vecteur W = Vecteur(Pi, A);

    float t = -1;
    float DdotNi = D.DotProduct(ni);
    if (DdotNi != 0)
        t = - W.DotProduct(ni) / DdotNi;
    return t;
}

Vecteur Vecteur::operator+(const Vecteur &vecteur2) const // Somme vectorielle
{
	assert(dim()==vecteur2.dim() && ref() == vecteur2.ref());
	
	Vecteur res(*this);
	
	for(int i=0 ; i<dim() ; i++)
	{
		res[i] += vecteur2[i];
	}
	
	return res;
}

Point Point::operator+(Vecteur &vecteur2) const // Somme vectorielle
{
    assert(dim()==vecteur2.dim() && ( (ref() && vecteur2.ref()) || (!ref() && !vecteur2.ref()) ));

    if(ref())
    {
        vecteur2.changerDeReferentiel(ref());
    }

    Point res(*this);

    for(int i=0 ; i<dim() ; i++)
    {
        res[i] += vecteur2[i];
    }

    return res;
}

void Point::changerDeReferentiel(Referentiel* newRef)
{
    if( ref_ && (ref_ != newRef) )
    {
        // Les deux origines sont exprimées dans le référentiel de référence
        Vecteur entreOrigines = ref()->origin() - newRef->origin();

        entreOrigines.changerDeReferentiel(newRef);

        if(!estNul())
        {
            Vecteur::changerDeReferentiel(newRef);
        }

        *this += entreOrigines;

        setRef(newRef);
    }
}

bool Vecteur::operator==(const Vecteur &vecteur2)// Test d'égalité
{
	if(this == &vecteur2)
	{
		return true;
	}
	
	if(dim() != vecteur2.dim())
	{
		return false;
	}
	
	changerDeReferentiel(vecteur2.ref());
	
	bool res = true;
	for(int i=0 ; i<dim() && res ; i++)
	{
		res &= (coord[i]==vecteur2[i]); // On pourrait peut-être introduire un seuil
	}
	return res;
}

Vecteur operator-(const Vecteur& v)
{
    return Vecteur(-v.getX(), -v.getY());
}

bool operator==(const Vecteur& a, const Vecteur& b)
{
    return (a.getX() == b.getX() && a.getY() == b.getY());
}