/*************************************************************************************
Janne Koljonen
Vaasan yliopisto

Soft Computing
Sumeaa joukkoa kuvaava luokka.
**************************************************************************************/

import java.text.*;

public class SumeaJoukko
{
	private String nimi; // Sumean joukon nimi
	private Object[] alkiot; // Luokkaan kuuluvat alkiot. 
	// Alkioiden tulee korvata Object-luokan equals() ja toString() -metodit.

	private double[] asteet; // Alkioiden jäsenyysasteet tähän luokkaan, [0,1]


	// Muodostin, tyhjä joukko
	public SumeaJoukko(String nimi)
	{
		this.nimi=nimi;
	}


	// Muodostin (alkiot ja jäsenyysasteet)
	public SumeaJoukko(String nimi, Object[] alkiot, double[] asteet)
	{
		this(nimi);
		this.alkiot=alkiot;
		this.asteet=asteet;
	}

	public void lisaaAlkio(Object alkio, double aste)
	{
		// Jos alkoita on jo, kopioidaan vanhat alkiot uuteen taulukkoon
		if(alkiot!=null)
		{
			Object[] temp=new Object[alkiot.length+1];
			double[] temp2=new double[alkiot.length+1];
			for(int i=0; i<alkiot.length; i++)
			{
				temp[i]=alkiot[i];
				temp2[i]=asteet[i];
			}
			// Lisätään uusi alkio taulukon jatkeeksi
			temp[alkiot.length]=alkio;
			temp2[alkiot.length]=aste;
			alkiot=temp;
			asteet=temp2;
		}
		else
		{
			Object[] temp=new Object[1];
			double[] temp2=new double[1];
			temp[0]=alkio;
			temp2[0]=aste;
			alkiot=temp;
			asteet=temp2;
		}
	}

	public String haeNimi()
	{
		return nimi;
	}	

	public Object[] haeAlkiot()
	{
		return alkiot;
	}

	public double[] haeAsteet()
	{
		return asteet;
	}

	// Hakee alkion o indeksin taulukoissa, palauttaa -1, jos alkiota ei löydy.
	public int haeAlkio(Object o)
	{
		for(int i=0; i<this.alkiot.length; i++)
		{
			if(alkiot[i].equals(o))
			{
				return i;
			}
		}
		return -1;
	}

	// Hakee double-tyyppisen muuttujaa vastaavan lähimmän alkion indeksin taulukoissa ja palauttaa alkion jäsenyysasteen
	public double haeAste(double x)
	{
		double mindist=Double.MAX_VALUE;
		int tempi=0;
		for(int i=0; i<this.alkiot.length; i++)
		{
			double temp=((Double)alkiot[i]).doubleValue();
			if( Math.abs(temp-x)<mindist )
			{
				mindist=Math.abs(temp-x);
				tempi=i;
			}
		}
		return asteet[tempi];
	}

	// Laskee tämän sumean joukon ja parametrina annetun joukon välisen leikkauksen
	// Käyttää Sadehin min -operaatiota
	public SumeaJoukko intersect(SumeaJoukko B)
	{
		// Tehdään uusi tyhjä Sumea joukko
		SumeaJoukko temp=new SumeaJoukko(this.nimi+"_AND_"+B.nimi);

		// Lisätään alkioita ja lasketaan samalla alkoiden jäsenyysasteiden minimit joukoista this ja B.
		// Huomioidaan, että joukoissa voi olla eri alkoita. Kaikki alkiot lisätään uuteen joukkoon, mutta
		// jäsenyysaste voi olla 0.
		for(int i=0; i<this.alkiot.length; i++)
		{
			// Etsitään tämän joukon i's alkio joukosta B.
			int index=B.haeAlkio(this.alkiot[i]);
			if(index!=-1)
			{
				// Jos alkio löytyi, lisätään se uuteen joukkoon.
				// Jäsenyysarvoksi tulee jäsenyysarvojen minimi
				temp.lisaaAlkio(this.alkiot[i], Math.min(this.asteet[i],B.asteet[index]));
			}
			else
			{
				// Jos alkiota ei löytynyt, lisätään se uuteen joukkoon
				// jäsenyydellä 0.
				temp.lisaaAlkio(this.alkiot[i], 0);
			}
		}
		// Lopuksi haetaan vielä joukosta B alkiot, jotka eivät ole tässä joukossa
		for(int i=0; i<B.alkiot.length; i++)
		{
			// Etsitään joukon B i's alkio joukosta this.
			int index=this.haeAlkio(B.alkiot[i]);
			if(index!=-1)
			{
				// Jos alkio löytyi, ei tehdä mitään, koska alkio on jo uudessa joukossa.
			}
			else
			{
				// Jos alkiota ei löytynyt, lisätään se uuteen joukkoon
				// jäsenyydellä 0.
				temp.lisaaAlkio(B.alkiot[i], 0);
			}
		}

		return temp; 
	}


	// Laskee tämän sumean joukon ja parametrina annetun joukon välisen yhdiste
	// Käyttää Sadehin max -operaatiota
	public SumeaJoukko union(SumeaJoukko B)
	{
		// Tehdään uusi tyhjä Sumea joukko
		SumeaJoukko temp=new SumeaJoukko("OR");

		// Lisätään alkioita ja lasketaan samalla alkoiden jäsenyysasteiden maximit joukoista this ja B.
		// Huomioidaan, että joukoissa voi olla eri alkoita. Kaikki alkiot lisätään uuteen joukkoon, mutta
		// jäsenyysaste voi olla 1.
		for(int i=0; i<this.alkiot.length; i++)
		{
			// Etsitään tämän joukon i's alkio joukosta B.
			int index=B.haeAlkio(this.alkiot[i]);
			if(index!=-1)
			{
				// Jos alkio löytyi, lisätään se uuteen joukkoon.
				// Jäsenyysarvoksi tulee jäsenyysarvojen maximi
				temp.lisaaAlkio(this.alkiot[i], Math.max(this.asteet[i],B.asteet[index]));
			}
			else
			{
				// Jos alkiota ei löytynyt, lisätään se uuteen joukkoon
				// jäsenyydellä 1.
				temp.lisaaAlkio(this.alkiot[i], 1.0);
			}
		}
		// Lopuksi haetaan vielä joukosta B alkiot, jotka eivät ole tässä joukossa
		for(int i=0; i<B.alkiot.length; i++)
		{
			// Etsitään joukon B i's alkio joukosta this.
			int index=this.haeAlkio(B.alkiot[i]);
			if(index!=-1)
			{
				// Jos alkio löytyi, ei tehdä mitään, koska alkio on jo uudessa joukossa.
			}
			else
			{
				// Jos alkiota ei löytynyt, lisätään se uuteen joukkoon
				// jäsenyydellä 1.
				temp.lisaaAlkio(B.alkiot[i], 1.0);
			}
		}

		return temp; 
	}

	// Tulostaa tämän sumean joukon print/println -komentoja käytettäessä.
	public String toString()
	{
		NumberFormat nf=NumberFormat.getInstance();
		nf.setMaximumFractionDigits(2);
		String temp=this.nimi+"=\n";
		if(this.alkiot!=null)
		{
			for(int i=0; i<this.alkiot.length; i++)
			{
				temp+="{"+this.alkiot[i].toString()+", "+nf.format(this.asteet[i])+"},";
			}
		}
		else
		{
			temp+="tyhjä";
		}
		return temp;
	}

	// Korvaa Object-luokan clone()-metodin
	public Object clone()
	{
		Object[] tempalkiot=new Object[this.alkiot.length];
		double[] tempasteet=new double[this.asteet.length];
		for(int i=0; i<tempalkiot.length; i++)
		{
			tempalkiot[i]=this.alkiot[i];
			tempasteet[i]=this.asteet[i];
		}
		SumeaJoukko temp=new SumeaJoukko(new String(this.nimi), tempalkiot, tempasteet);
		return temp;
	}

	// Testataan tätä luokkaa
	public static void main(String[] args)
	{
		// Luodaan kaksi sumeaa joukkoa, joiden alkiot ovat merkkijonoja
		SumeaJoukko A=new SumeaJoukko("A");
		// Tulostetaan nyt vielä tyhjä joukko
		System.out.println(A);
		A.lisaaAlkio("a",0.8);
		A.lisaaAlkio("b",0.01);
		A.lisaaAlkio("c",1.0);
		A.lisaaAlkio("d",0.99);
		SumeaJoukko B=new SumeaJoukko("B");
		B.lisaaAlkio("a",0.7);
		B.lisaaAlkio("b",0.1);
		B.lisaaAlkio("d",0.5);
		B.lisaaAlkio("e",0.999);

		// Tulostetaan molemmat joukot
		System.out.println(A);
		System.out.println(B);

		// Lasketaan ja tulostetaan leikkausjoukko
		SumeaJoukko AandB=A.intersect(B);
		System.out.println(AandB);
	}
}