/// <summary>
/// Retourne si deux vecteurs sont parallèles
/// </summary>
/// <param name="gauche">Le vecteur de gauche dans l'éditeur</param>
/// <param name="droit">Le vecteur à droite dans l'éditeur</param>
/// <returns></returns>
static public bool EstParallèle(Vecteur gauche, Vecteur droit)
{
bool NonParallèle = true;
float[] ks = new float[gauche.NbDimensions];
for (int j = 0; j < gauche.NbDimensions; j++)
{
ks[j] = gauche[j] / droit[j];
}
int i = 0;
while (NonParallèle && i < ks.Length - 1)
{
if (ks[i] == ks[i + 1])
{
NonParallèle = false;
}
else
{
NonParallèle = true;
}
i++;
}
return(NonParallèle);
}
/// <summary>
/// S'occupe de calculer les différentes opérations sur les plans et les bases
/// </summary>
public void Calculer()
{
bool EstPlanOuEspace;
switch (typeVérif)
{
case VérificationBase.TEST_PLAN:
EstPlanOuEspace = Vecteur.EstUnPlan(new Vecteur(scriptVecteurGauche.GetDataVecteur), new Vecteur(scriptVecteurCentre.GetDataVecteur));
scriptRésultatPlan.AfficherRésultat(EstPlanOuEspace);
break;
case VérificationBase.TEST_ESPACE:
EstPlanOuEspace = Vecteur.EstUnEspace(new Vecteur(scriptVecteurGauche.GetDataVecteur), new Vecteur(scriptVecteurCentre.GetDataVecteur), new Vecteur(scriptVecteurDroite.GetDataVecteur));
scriptRésultatEspace.AfficherRésultat(EstPlanOuEspace);
break;
case VérificationBase.ÉCRITURE_VECTEUR_PLAN:
Vecteur résultatPlan = Vecteur.ÉcritureVecteurDansUnPlan(new Vecteur(scriptVecteurGauche.GetDataVecteur), new Vecteur(scriptVecteurCentre.GetDataVecteur), new Vecteur(scriptVecteurBas.GetDataVecteur));
scriptRésultatVecteur.AfficherRésultat(résultatPlan);
break;
case VérificationBase.ÉCRITURE_VECTEUR_ESPACE:
Vecteur résultatEspace = Vecteur.ÉcritureVecteurDansUnEspace(new Vecteur(scriptVecteurGauche.GetDataVecteur), new Vecteur(scriptVecteurCentre.GetDataVecteur), new Vecteur(scriptVecteurDroite.GetDataVecteur), new Vecteur(scriptVecteurBas.GetDataVecteur));
scriptRésultatVecteur.AfficherRésultat(résultatEspace);
break;
}
}
/// <summary>
/// Retourne le vecteur résultant de deux points.
/// </summary>
/// <param name="gauche">Le point de gauche</param>
/// <param name="droit">Le point de droite</param>
/// <returns>Retourne un vecteur</returns>
static public Vecteur VecteurDeuxPoints(Vecteur gauche, Vecteur droit)
{
Vecteur résultat = null;
résultat = Soustraire(droit, gauche);
return(résultat);
}
/// <summary>
/// Écris un vecteur dans un espace donné.
/// </summary>
/// <param name="gauche">Premier vecteur de l'espace.</param>
/// <param name="centre">Deuxième vecteur de l'espace.</param>
/// <param name="droit">Troisième vecteur de l'espace.</param>
/// <param name="bas">Vecteur que l'on désir écrire dans l'espace.</param>
/// <returns>Retourne un vecteur.</returns>
static public Vecteur ÉcritureVecteurDansUnEspace(Vecteur gauche, Vecteur centre, Vecteur droit, Vecteur bas)
{
float[] résultat = new float[bas.NbDimensions];
float[,] baseMatrice = new float[gauche.NbDimensions, 3];
float[,] vecteurBas = new float[bas.NbDimensions, 1];
if (EstUnEspace(new Vecteur(gauche.DataVecteur), new Vecteur(centre.DataVecteur), new Vecteur(droit.DataVecteur)) && gauche.NbDimensions == 3)
{
for (int i = 0; i < gauche.NbDimensions; i++)
{
baseMatrice[i, 0] = gauche[i];
}
for (int i = 0; i < centre.NbDimensions; i++)
{
baseMatrice[i, 1] = centre[i];
}
for (int i = 0; i < droit.NbDimensions; i++)
{
baseMatrice[i, 2] = droit[i];
}
for (int i = 0; i < bas.NbDimensions; i++)
{
vecteurBas[i, 0] = bas[i];
}
Matrice baseMatriceInverse = Matrice.MatriceInverse(new Matrice(baseMatrice));
Matrice matriceRésultat = Matrice.Produit(new Matrice(baseMatriceInverse.DataMatrice), new Matrice(vecteurBas));
for (int i = 0; i < matriceRésultat.NbLignes; i++)
{
résultat[i] = matriceRésultat[i, 0];
}
}
return(new Vecteur(résultat));
}
/// <summary>
/// Fait la vérification si deux vecteurs forment un plan
/// </summary>
/// <param name="gauche">Le vecteur de gauche dans l'éditeur</param>
/// <param name="centre">Le vecteur central dans l'éditeur</param>
/// <returns>si les vecteurs forment un plan</returns>
static public bool EstUnPlan(Vecteur gauche, Vecteur centre)
{
bool estUnPlan;
estUnPlan = EstNul(gauche) && EstNul(centre) && EstParallèle(gauche, centre);
return(estUnPlan);
}
/// <summary>
/// S'occupe d'initialiser composant et accède à leurs scripts pour pouvoir <para>
/// accéder à certaines fonctionnalités des objects</para>
/// </summary>
void Start()
{
vecteur = null;
GérerVecteur();
scriptGradateur = CtrlNbDimensions.GetComponent <GradateurControleur>();
scriptOperations = controleurOperations.GetComponent <OperationsControleurAbstrait>();
nbDimensionsVecteur = scriptGradateur.Valeur;
GénérationDesComposants();
zonesDeTexte = CtrlComposants.GetComponentsInChildren <InputField>();
ActivationDesPanneaux();
}
/// <summary>
/// Calcule la norme d'un vecteur
/// </summary>
/// <param name="gauche">Le vecteur de gauche dans l'éditeur</param>
/// <returns>La norme du vecteur</returns>
static public float CalculNorme(Vecteur gauche)
{
float résultat;
float intérieurRacine = 0;
float[] vecteurGauche = gauche.DataVecteur;
for (int i = 0; i < gauche.NbDimensions; i++)
{
intérieurRacine += Mathf.Pow(vecteurGauche[i], 2);
}
return(résultat = Mathf.Sqrt(intérieurRacine));
}
public void AfficherRésultat(Vecteur vecteurRésultat)
{
nbDimensionsVecteur = 0;
if (vecteurRésultat != null)
{
float[] dataRésultat = vecteurRésultat.DataVecteur;
nbDimensionsVecteur = dataRésultat.Length;
for (int i = 0; i < nbDimensionsVecteur; ++i)
{
textes[i].text = dataRésultat[i].ToString();
}
}
ActivationDesPanneaux();
}
/// <summary>
/// Divise tous les composants du vecteur par la norme de celui-ci
/// </summary>
/// <param name="gauche">Le vecteur de gauche dans l'éditeur</param>
/// <returns></returns>
static public Vecteur Normalisation(Vecteur gauche)
{
float[] résultat = new float[gauche.NbDimensions];
float[] vecteurGauche = gauche.DataVecteur;
float norme = CalculNorme(gauche);
for (int i = 0; i < gauche.NbDimensions; i++)
{
résultat[i] = vecteurGauche[i] / norme;
}
Vecteur résultatVecteur = new Vecteur(résultat);
return(résultatVecteur);
}
/// <summary>
/// Recherche l'information nécessaire sur les Game Objects
/// </summary>
void Start()
{
calculer = gameObject.GetComponentInChildren <Button>();
scriptVecteurGauche = EditeurVecteurGauche.GetComponent <VecteurControleur>();
scriptVecteurDroite = EditeurVecteurDroite.GetComponent <VecteurControleur>();
scriptGradateurDroit = scriptVecteurDroite.CtrlNbDimensions.GetComponent <GradateurControleur>();
scriptGradateurGauche = scriptVecteurGauche.CtrlNbDimensions.GetComponent <GradateurControleur>();
scriptScalaire = EditeurScalaire.GetComponent <ScalaireControleur>();
scriptResultatVecteur = ZoneResultatVectoriel.GetComponent <RésultatControleurVecteur>();
scriptRésultatNorme = ZoneNorme.GetComponent <RésultatControleurNorme>();
opérandeVecteurGauche = new Vecteur(scriptVecteurGauche.GetDataVecteur);
listOpérations = gameObject.GetComponentInChildren <Dropdown>();
IdentifierOpérationActive();
}
/// <summary>
/// Fait le produit par un scalaire d'un vecteur
/// </summary>
/// <param name="gauche">Le vecteur de gauche dans l'éditeur</param>
/// <param name="droite">Le scalaire à droite dans l'éditeur</param>
/// <returns>Le vecteur résultant</returns>
static public Vecteur ProduitVecteurScalaire(Vecteur gauche, float droite)
{
Vecteur résultat = null;
if (gauche != null)
{
float[] dataProduitScalaire = new float[gauche.NbDimensions];
float[] dataGauche = gauche.DataVecteur;
for (int i = 0; i < gauche.NbDimensions; ++i)
{
dataProduitScalaire[i] = dataGauche[i] * droite;
}
résultat = new Vecteur(dataProduitScalaire);
}
return(résultat);
}
/// <summary>
/// Fait le calcul sur le(s) vecteur(s) selon l'opération sélectionnée et affiche la valeur dans le vecteur réponse ou la norme
/// </summary>
public void Calculer()
{
Vecteur résultat = null;
bool retourneVecteur = true;
float résultatNorme = 0;
switch (opérationActive)
{
case OpérationsVectorielles.ADDITON:
résultat = Vecteur.Additionner(new Vecteur(scriptVecteurGauche.GetDataVecteur), new Vecteur(scriptVecteurDroite.GetDataVecteur));
retourneVecteur = true;
break;
case OpérationsVectorielles.SOUSTRACTION:
résultat = Vecteur.Soustraire(new Vecteur(scriptVecteurGauche.GetDataVecteur), new Vecteur(scriptVecteurDroite.GetDataVecteur));
retourneVecteur = true;
break;
case OpérationsVectorielles.PRODUIT_SCALAIRE:
résultat = Vecteur.ProduitVecteurScalaire(new Vecteur(scriptVecteurGauche.GetDataVecteur), scriptScalaire.Valeur);
retourneVecteur = true;
break;
case OpérationsVectorielles.CALCUL_NORME:
résultatNorme = Vecteur.CalculNorme(new Vecteur(scriptVecteurGauche.GetDataVecteur));
retourneVecteur = false;
break;
case OpérationsVectorielles.NORMALISATION:
résultat = Vecteur.Normalisation(new Vecteur(scriptVecteurGauche.GetDataVecteur));
retourneVecteur = true;
break;
case OpérationsVectorielles.VECTEUR_RÉSULTANT:
résultat = Vecteur.VecteurDeuxPoints(new Vecteur(scriptVecteurGauche.GetDataVecteur), new Vecteur(scriptVecteurDroite.GetDataVecteur));
retourneVecteur = true;
break;
}
if (retourneVecteur)
{
scriptResultatVecteur.AfficherRésultat(résultat);
}
else
{
scriptRésultatNorme.AfficherNorme(résultatNorme);
}
}
/// <summary>
/// Fait l'addition de deux vecteurs
/// </summary>
/// <param name="gauche">Le vecteur de gauche dans l'éditeur</param>
/// <param name="droite">Le vecteur de droite dans l'éditeur</param>
/// <returns>Un nouveau vecteur résultant</returns>
static public Vecteur Additionner(Vecteur gauche, Vecteur droite)
{
Vecteur résultat = null;
if (gauche != null && droite != null && gauche.NbDimensions == droite.NbDimensions)
{
float[] dataSomme = new float[gauche.NbDimensions];
float[] dataGauche = gauche.DataVecteur;
float[] dataDroite = droite.DataVecteur;
for (int i = 0; i < gauche.NbDimensions; ++i)
{
dataSomme[i] = dataGauche[i] + dataDroite[i];
}
résultat = new Vecteur(dataSomme);
}
return(résultat);
}
/// <summary>
/// Fait la soustraction de deux vecteurs
/// </summary>
/// <param name="gauche">Le vecteur de gauche dans l'éditeur</param>
/// <param name="droite">Le vecteur de droite dans l'éditeur</param>
/// <returns>Un nouveau vecteur résultant</returns>
static public Vecteur Soustraire(Vecteur gauche, Vecteur droite)
{
Vecteur résultat = null;
if (gauche != null && droite != null && gauche.NbDimensions == droite.NbDimensions)
{
float[] dataDifférence = new float[gauche.NbDimensions];
float[] dataGauche = gauche.DataVecteur;
float[] dataDroite = droite.DataVecteur;
for (int i = 0; i < gauche.NbDimensions; ++i)
{
dataDifférence[i] = dataGauche[i] - dataDroite[i];
}
résultat = new Vecteur(dataDifférence);
}
return(résultat);
}
/// <summary>
/// Crée un vecteur pour pouvoir faire des modifications sans changer l'original
/// </summary>
void GérerVecteur()
{
if (vecteur == null)
{
vecteur = new Vecteur(nbDimensionsVecteur);
}
else
{
float[] nouveauVecteur = new float[nbDimensionsVecteur];
float[] ancienVecteur = vecteur.DataVecteur;
int i = 0;
while (i < nbDimensionsVecteur && i < vecteur.NbDimensions)
{
nouveauVecteur[i] = ancienVecteur[i];
++i;
}
vecteur = new Vecteur(nouveauVecteur);
}
}
/// <summary>
/// Vérifie si un vecteur est non-nul
/// </summary>
/// <param name="gauche">Le vecteur de gauche dans l'éditeur</param>
/// <returns>si le vecteur est non-nul</returns>
static public bool EstNul(Vecteur gauche)
{
bool NonNul;
float sommeVérif = 0;
for (int i = 0; i < gauche.NbDimensions; i++)
{
sommeVérif += Mathf.Abs(gauche[i]);
}
if (sommeVérif == 0)
{
NonNul = false;
}
else
{
NonNul = true;
}
return(NonNul);
}
/// <summary>
/// Vérifie si trois vecteurs forment un base
/// </summary>
/// <param name="gauche">Le vecteur de gauche dans l'éditeur</param>
/// <param name="centre">Le vecteur central dans l'éditeur</param>
/// <param name="droite">Le vecteur de droite dans l'éditeur</param>
/// <returns>Si les vecteurs forment une base</returns>
static public bool EstUnEspace(Vecteur gauche, Vecteur centre, Vecteur droit)
{
bool estUnEspace;
float[,] matriceReprésentation = new float[gauche.NbDimensions, 3];
for (int i = 0; i < gauche.NbDimensions; i++)
{
matriceReprésentation[i, 0] = gauche[i];
}
for (int i = 0; i < centre.NbDimensions; i++)
{
matriceReprésentation[i, 1] = centre[i];
}
for (int i = 0; i < droit.NbDimensions; i++)
{
matriceReprésentation[i, 2] = droit[i];
}
estUnEspace = (Matrice.Déterminant(new Matrice(matriceReprésentation)) != 0);
return(estUnEspace);
}
