/*
================================================================================
  RPL/2 (R) version 4.1.32
  Copyright (C) 1989-2020 Dr. BERTRAND Joël

  This file is part of RPL/2.

  RPL/2 is free software; you can redistribute it and/or modify it
  under the terms of the CeCILL V2 License as published by the french
  CEA, CNRS and INRIA.
 
  RPL/2 is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
  for more details.
 
  You should have received a copy of the CeCILL License
  along with RPL/2. If not, write to info@cecill.info.
================================================================================
*/


#include "rpl-conv.h"


/*
================================================================================
  Fonction 'gegvl'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_gegvl(struct_processus *s_etat_processus)
{
	struct_objet				*s_objet_argument_1;
	struct_objet				*s_objet_argument_2;
	struct_objet				*s_objet_resultat;

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  GEGVL ");
		
		if ((*s_etat_processus).langue == 'F')
		{
			printf("(valeurs propres généralisées)\n\n");
		}
		else
		{
			printf("(generalized eigenvalues)\n\n");
		}

		printf("    2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("    1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("->  1: %s\n", d_VCX);

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}

	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
		{
			return;
		}
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_1) == d_erreur)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);

		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

/*
--------------------------------------------------------------------------------
  Les arguments sont des matrices carrées de mêmes dimensions
--------------------------------------------------------------------------------
*/

	if ((((*s_objet_argument_1).type == MIN) ||
			((*s_objet_argument_1).type == MRL) ||
			((*s_objet_argument_1).type == MCX)) &&
			(((*s_objet_argument_2).type == MIN) ||
			((*s_objet_argument_2).type == MRL) ||
			((*s_objet_argument_2).type == MCX)))
	{
		if (((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
				!= (*((struct_matrice *) (*s_objet_argument_1).objet))
				.nombre_colonnes) || ((*((struct_matrice *)
				(*s_objet_argument_2).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_colonnes) || ((*((struct_matrice *)
				(*s_objet_argument_1).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_lignes))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

			(*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
			return;
		}

		if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		valeurs_propres_generalisees(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_2).objet,
				(struct_matrice *) (*s_objet_argument_1).objet,
				(struct_vecteur *) (*s_objet_resultat).objet,
				NULL, NULL);

		if ((*s_etat_processus).erreur_systeme != d_ex)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*s_etat_processus).exception != d_ep) ||
				((*s_etat_processus).erreur_execution != d_ex))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);
			return;
		}
	}

/*
--------------------------------------------------------------------------------
  Type incompatible
--------------------------------------------------------------------------------
*/

	else
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);

		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
		return;
	}

	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);

	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			s_objet_resultat) == d_erreur)
	{
		return;
	}

	return;
}


/*
================================================================================
  Fonction 'gegv'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_gegv(struct_processus *s_etat_processus)
{
	struct_objet				*s_objet_argument_1;
	struct_objet				*s_objet_argument_2;
	struct_objet				*s_objet_resultat_1;
	struct_objet				*s_objet_resultat_2;
	struct_objet				*s_objet_resultat_3;

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  GEGV ");
		
		if ((*s_etat_processus).langue == 'F')
		{
			printf("(valeurs et vecteurs propres généralisés)\n\n");
		}
		else
		{
			printf("(generalized eigenvalues and eigenvectors)\n\n");
		}

		printf("    2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("    1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("->  3: %s\n", d_MCX);
		printf("    2: %s\n", d_MCX);
		printf("    1: %s\n", d_VCX);

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}

	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
		{
			return;
		}
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_1) == d_erreur)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);

		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

/*
--------------------------------------------------------------------------------
  Les arguments sont des matrices carrées de mêmes dimensions
--------------------------------------------------------------------------------
*/

	if ((((*s_objet_argument_1).type == MIN) ||
			((*s_objet_argument_1).type == MRL) ||
			((*s_objet_argument_1).type == MCX)) &&
			(((*s_objet_argument_2).type == MIN) ||
			((*s_objet_argument_2).type == MRL) ||
			((*s_objet_argument_2).type == MCX)))
	{
		if (((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
				!= (*((struct_matrice *) (*s_objet_argument_1).objet))
				.nombre_colonnes) || ((*((struct_matrice *)
				(*s_objet_argument_2).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_colonnes) || ((*((struct_matrice *)
				(*s_objet_argument_1).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_lignes))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

			(*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
			return;
		}

		if ((s_objet_resultat_1 = allocation(s_etat_processus, VCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((s_objet_resultat_2 = allocation(s_etat_processus, MCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((s_objet_resultat_3 = allocation(s_etat_processus, MCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		valeurs_propres_generalisees(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_2).objet,
				(struct_matrice *) (*s_objet_argument_1).objet,
				(struct_vecteur *) (*s_objet_resultat_1).objet,
				(struct_matrice *) (*s_objet_resultat_3).objet,
				(struct_matrice *) (*s_objet_resultat_2).objet);

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			return;
		}

		if (((*s_etat_processus).exception != d_ep) ||
				((*s_etat_processus).erreur_execution != d_ex))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat_1);
			liberation(s_etat_processus, s_objet_resultat_2);
			liberation(s_etat_processus, s_objet_resultat_3);

			return;
		}
	}

/*
--------------------------------------------------------------------------------
  Type incompatible
--------------------------------------------------------------------------------
*/

	else
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);

		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
		return;
	}

	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);

	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			s_objet_resultat_3) == d_erreur)
	{
		return;
	}

	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			s_objet_resultat_2) == d_erreur)
	{
		return;
	}

	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			s_objet_resultat_1) == d_erreur)
	{
		return;
	}

	return;
}


/*
================================================================================
  Fonction 'glegv'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_glegv(struct_processus *s_etat_processus)
{
	struct_objet				*s_objet_argument_1;
	struct_objet				*s_objet_argument_2;
	struct_objet				*s_objet_resultat_1;
	struct_objet				*s_objet_resultat_2;

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  GLEGV ");
		
		if ((*s_etat_processus).langue == 'F')
		{
			printf("(valeurs et vecteurs propres gauches généralisés)\n\n");
		}
		else
		{
			printf("(generalized eigenvalues and left eigenvectors)\n\n");
		}

		printf("    2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("    1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("->  2: %s\n", d_MCX);
		printf("    1: %s\n", d_VCX);

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}

	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
		{
			return;
		}
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_1) == d_erreur)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);

		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

/*
--------------------------------------------------------------------------------
  Les arguments sont des matrices carrées de mêmes dimensions
--------------------------------------------------------------------------------
*/

	if ((((*s_objet_argument_1).type == MIN) ||
			((*s_objet_argument_1).type == MRL) ||
			((*s_objet_argument_1).type == MCX)) &&
			(((*s_objet_argument_2).type == MIN) ||
			((*s_objet_argument_2).type == MRL) ||
			((*s_objet_argument_2).type == MCX)))
	{
		if (((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
				!= (*((struct_matrice *) (*s_objet_argument_1).objet))
				.nombre_colonnes) || ((*((struct_matrice *)
				(*s_objet_argument_2).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_colonnes) || ((*((struct_matrice *)
				(*s_objet_argument_1).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_lignes))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

			(*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
			return;
		}

		if ((s_objet_resultat_1 = allocation(s_etat_processus, VCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((s_objet_resultat_2 = allocation(s_etat_processus, MCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		valeurs_propres_generalisees(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_2).objet,
				(struct_matrice *) (*s_objet_argument_1).objet,
				(struct_vecteur *) (*s_objet_resultat_1).objet,
				(struct_matrice *) (*s_objet_resultat_2).objet,
				NULL);

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			return;
		}

		if (((*s_etat_processus).exception != d_ep) ||
				((*s_etat_processus).erreur_execution != d_ex))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat_1);
			liberation(s_etat_processus, s_objet_resultat_2);

			return;
		}
	}

/*
--------------------------------------------------------------------------------
  Type incompatible
--------------------------------------------------------------------------------
*/

	else
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);

		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
		return;
	}

	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);

	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			s_objet_resultat_2) == d_erreur)
	{
		return;
	}

	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			s_objet_resultat_1) == d_erreur)
	{
		return;
	}

	return;
}


/*
================================================================================
  Fonction 'gregv'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_gregv(struct_processus *s_etat_processus)
{
	struct_objet				*s_objet_argument_1;
	struct_objet				*s_objet_argument_2;
	struct_objet				*s_objet_resultat_1;
	struct_objet				*s_objet_resultat_2;

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  GREGV ");
		
		if ((*s_etat_processus).langue == 'F')
		{
			printf("(valeurs et vecteurs propres droits généralisés)\n\n");
		}
		else
		{
			printf("(generalized eigenvalues and right eigenvectors)\n\n");
		}

		printf("    2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("    1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("->  2: %s\n", d_MCX);
		printf("    1: %s\n", d_VCX);

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}

	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
		{
			return;
		}
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_1) == d_erreur)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);

		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

/*
--------------------------------------------------------------------------------
  Les arguments sont des matrices carrées de mêmes dimensions
--------------------------------------------------------------------------------
*/

	if ((((*s_objet_argument_1).type == MIN) ||
			((*s_objet_argument_1).type == MRL) ||
			((*s_objet_argument_1).type == MCX)) &&
			(((*s_objet_argument_2).type == MIN) ||
			((*s_objet_argument_2).type == MRL) ||
			((*s_objet_argument_2).type == MCX)))
	{
		if (((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
				!= (*((struct_matrice *) (*s_objet_argument_1).objet))
				.nombre_colonnes) || ((*((struct_matrice *)
				(*s_objet_argument_2).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_colonnes) || ((*((struct_matrice *)
				(*s_objet_argument_1).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_lignes))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

			(*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
			return;
		}

		if ((s_objet_resultat_1 = allocation(s_etat_processus, VCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((s_objet_resultat_2 = allocation(s_etat_processus, MCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		valeurs_propres_generalisees(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_2).objet,
				(struct_matrice *) (*s_objet_argument_1).objet,
				(struct_vecteur *) (*s_objet_resultat_1).objet,
				NULL,
				(struct_matrice *) (*s_objet_resultat_2).objet);

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			return;
		}

		if (((*s_etat_processus).exception != d_ep) ||
				((*s_etat_processus).erreur_execution != d_ex))
		{
			/*
			 * Problème dans la diagonalisation
			 */

			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat_1);
			liberation(s_etat_processus, s_objet_resultat_2);

			return;
		}
	}

/*
--------------------------------------------------------------------------------
  Type incompatible
--------------------------------------------------------------------------------
*/

	else
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);

		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
		return;
	}

	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);

	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			s_objet_resultat_2) == d_erreur)
	{
		return;
	}

	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			s_objet_resultat_1) == d_erreur)
	{
		return;
	}

	return;
}

// vim: ts=4