/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package opennlp.tools.fca;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import org.apache.commons.collections.ListUtils;

import edu.stanford.nlp.io.EncodingPrintWriter.out;

public class BasicLevelMetrics {

	
	ConceptLattice cl;	
	ArrayList<ArrayList<Integer>> attributesExtent  = null; 
	ArrayList<ArrayList<Integer>> objectsIntent  = null; 
	ArrayList<Integer> attributes = null; 
	double[][] objectsSimilarityJ = null;
	double [][] objectsSimilaritySMC = null; 
					
	
	public BasicLevelMetrics (ConceptLattice cl){
		this.cl = cl;
		this.attributesExtent = null;
		objectsSimilarityJ = new double [cl.objectCount][cl.objectCount];
		objectsSimilaritySMC = new double [cl.objectCount][cl.objectCount];
	}
	
	public void setUp(){
		attributesExtent = new ArrayList<ArrayList<Integer>>();
		objectsIntent = new ArrayList<ArrayList<Integer>>();
		attributes = new ArrayList<Integer>();
		
		for (int i=0;i<cl.attributeCount;i++){
			attributesExtent.add((ArrayList<Integer>) cl.getAttributeExtByID(i));
			attributes.add(i);
		}	
		
		for (int i=0;i<cl.objectCount;i++){
			objectsIntent.add((ArrayList<Integer>) cl.getObjectIntByID(i));
		}
	
		double [] buf = new double[2];
		
		for (int i = 0; i < cl.objectCount; i++){
			for (int j = i + 1 ; j < cl.objectCount; j++){
					buf = simJ_SMC(objectsIntent.get(i), objectsIntent.get(j));	
					objectsSimilarityJ[i][j] = buf[0];
					objectsSimilarityJ[j][i] = buf[0];
					objectsSimilaritySMC[i][j] = buf[1];
					objectsSimilaritySMC[j][i] = buf[1];
			}
			objectsSimilarityJ[i][i] = 1;
			objectsSimilaritySMC[i][i] = 1;
		}
		
		//System.out.println("J");
		//System.out.println(Arrays.deepToString(objectsSimilarityJ));
		//System.out.println("SMC");
		//System.out.println(Arrays.deepToString(objectsSimilaritySMC));

	} 
	 
	//Utility functions for  Similarity approach (S)
	public double simSMC (ArrayList<Integer> intent1, ArrayList<Integer>intent2){
		int tp = (ListUtils.intersection(intent1,intent2)).size();
		ArrayList<Integer> fnlst = new ArrayList<Integer>();
		fnlst.addAll(this.attributes);
		fnlst.removeAll(ListUtils.union(intent1,intent2)); 
		int fn = fnlst.size();
		return (this.attributes.size()>0) ? 1.*(tp + fn)/this.attributes.size() : 0;
	}
	
	public double simJ (ArrayList<Integer> intent1, ArrayList<Integer>intent2){
		return 1.*(ListUtils.intersection(intent1,intent2)).size()/(ListUtils.union(intent1,intent2)).size() ;
	}
	
	public  double [] simJ_SMC(ArrayList<Integer> intent1, ArrayList<Integer>intent2){
		double simJ = 0;
		double simSMC = 0;	
		Set<Integer> intersection = new HashSet<Integer>(); 
		intersection.addAll(intent1);
		intersection.retainAll(intent2);
		
		Set<Integer> union = new HashSet<Integer>(); 
		union.addAll(intent1);
		union.addAll(intent2);
		int fn = 0;
		Set<Integer> unionOut = new HashSet<Integer>();
		unionOut.addAll(this.attributes);
		unionOut.removeAll(union);	
		simSMC = (this.attributes.size() > 0) ? 1.*(intersection.size() + unionOut.size())/this.attributes.size() : 0;
		simJ = (union.size() > 0) ? 1.*intersection.size()/union.size() : 0;
	    return new double[] {simJ, simSMC};
	}
	
	
	
	public double avgCohSMC (FormalConcept c){
		double sum = 0;
		if (c.extent.size() == 1)
			return 1.;//c.intent.size();
		if (c.extent.size() == 0)
			return 0.;
		else {
			for (Integer i:c.extent){
				for (Integer j: c.extent){
					if (i<j)
						sum+=objectsSimilaritySMC[i][j];
				}				
			}
			return (c.extent.size() > 1 ) ? 2.*sum/c.extent.size()/(c.extent.size()-1) : 0;// �� 2, ��� ��� ��������� ������
		}
	}
	
	public double avgCohJ (FormalConcept c){
		double sum = 0;
		if (c.extent.size() == 1)
			return 1.;//c.intent.size();
		if (c.extent.size() == 0)
			return 0.;
		else {
			for (Integer i:c.extent){
				for (Integer j: c.extent){
					if (i<j){
						sum+=objectsSimilarityJ[i][j];
					}
				}				
			}
			return (c.extent.size() > 1 ) ? 2.*sum/c.extent.size()/(c.extent.size()-1) : 0; 
		}
	}
	
	public double minCohJ (FormalConcept c){
		double min = Integer.MAX_VALUE,
				val = 0;
		
		for (Integer i:c.extent){
			for (Integer j: c.extent){
					val = objectsSimilarityJ[i][j];
					if (val<min)
						min = val;
			}				
		}
		return (min < Integer.MAX_VALUE) ? min : 0;
	}
	
	public double minCohSMC (FormalConcept c){
		double min = Integer.MAX_VALUE,
				val = 0;
		for (Integer i:c.extent){
			for (Integer j: c.extent){
					val = objectsSimilaritySMC[i][j];
					if (val<min)
						min = val;
			}				
		}
		return (min < Integer.MAX_VALUE) ? min : 0;
	}

	
	public double upperCohAvgByAvgJ(FormalConcept c, float tetta){
		//average alpha with average cohesion J
		double sum = 0;
		Set<Integer> upperNeighbors =c.parents;
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		for (Integer i: upperNeighbors){
			if (c.cohAvgJ > cl.conceptList.get(i).cohAvgJ){
				rightNeighborsNumber++;
				sum+=1.*cl.conceptList.get(i).cohAvgJ/c.cohAvgJ;	
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/upperNeighbors.size()>=tetta) ? 1 : 0;
			//truthDegree =  (float) Math.min(1.0, truthDegree);
			return (1-sum/rightNeighborsNumber)*truthDegree;
		}
	}
	
	public double upperCohAvgByMinJ(FormalConcept c,float tetta){
		//average alpha with min cohesion J
		double sum = 0;
		Set<Integer> upperNeighbors =c.parents;
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		for (Integer i: upperNeighbors){
			if (c.cohMinJ > cl.conceptList.get(i).cohMinJ){
				rightNeighborsNumber++;
				sum+=1.*cl.conceptList.get(i).cohMinJ/c.cohMinJ;	
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/upperNeighbors.size()>=tetta) ? 1 : 0;
			truthDegree =  (float) Math.min(1.0, truthDegree);
			return (1-sum/rightNeighborsNumber)*truthDegree;
		}
	}
	
	public double upperCohMinByAvgJ(FormalConcept c,float tetta){
		//min alpha whth average cohesion J
		double max = Integer.MIN_VALUE,
				val = 0; 
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		Set<Integer> upperNeighbors =c.parents;
		for (Integer i: upperNeighbors){
			if (c.cohAvgJ > cl.conceptList.get(i).cohAvgJ){
				rightNeighborsNumber++;
				val = 1.*cl.conceptList.get(i).cohAvgJ/c.cohAvgJ;	
				if (val>max)
					max = val;
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/upperNeighbors.size()>=tetta) ? 1 : 0;
			truthDegree =  (float) Math.min(1.0, truthDegree);
			return (1-max)*truthDegree;
		}		
	}
	
	public double upperCohMinByMinJ(FormalConcept c,float tetta){
		//min alpha whth average cohesion J
		double max = Integer.MIN_VALUE,
				val = 0; 
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		Set<Integer> upperNeighbors =c.parents;
		for (Integer i: upperNeighbors){
			if (c.cohMinJ > cl.conceptList.get(i).cohMinJ){
				rightNeighborsNumber++;
				val = 1.*cl.conceptList.get(i).cohMinJ/c.cohMinJ;	
				if (val>max)
					max = val;
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			//truthDegree = rightNeighborsNumber/tetta/upperNeighbors.size();
			truthDegree = (1.*rightNeighborsNumber/upperNeighbors.size()>=tetta) ? 1 : 0;
			truthDegree =  (float) Math.min(1.0, truthDegree);			
			return (1-max)*truthDegree;
		}		
	}
	
	public double upperCohAvgByAvgSMC(FormalConcept c,float tetta){
		//average alpha with average cohesion SMC
		double sum = 0;
		Set<Integer> upperNeighbors =c.parents;
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		for (Integer i: upperNeighbors){
			if (c.cohAvgSMC > cl.conceptList.get(i).cohAvgSMC){
				rightNeighborsNumber++;
				sum+=1.*cl.conceptList.get(i).cohAvgSMC/c.cohAvgSMC;		
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/upperNeighbors.size()>=tetta) ? 1 : 0;
			return (1-sum/rightNeighborsNumber)*truthDegree;
		}	
	}
	
	public double upperCohAvgByMinSMC(FormalConcept c,float tetta){
		//average alpha with min cohesion SMC
		double sum = 0;
		Set<Integer> upperNeighbors =c.parents;
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		for (Integer i: upperNeighbors){
			if (c.cohMinSMC > cl.conceptList.get(i).cohMinSMC){
				rightNeighborsNumber++;
				sum+=1.*cl.conceptList.get(i).cohMinSMC/c.cohMinSMC;		
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/upperNeighbors.size()>=tetta) ? 1 : 0;
			return (1-sum/rightNeighborsNumber)*truthDegree;
		}
	}
		
		
	public double upperCohMinByAvgSMC(FormalConcept c,float tetta){
		//min alpha whth average cohesion J
		
		double max = Integer.MIN_VALUE,
				val = 0; 
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		Set<Integer> upperNeighbors =c.parents;
		for (Integer i: upperNeighbors){
			if (c.cohAvgSMC > cl.conceptList.get(i).cohAvgSMC){
				rightNeighborsNumber++;
				val = 1.*cl.conceptList.get(i).cohAvgSMC/c.cohAvgSMC;	
				if (val>max)
					max = val;
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/upperNeighbors.size()>=tetta) ? 1 : 0;
			truthDegree =  (float) Math.min(1.0, truthDegree);
			return (1-max)*truthDegree;
		}			
	}
	
	public double upperCohMinByMinSMC(FormalConcept c,float tetta){
		//min alpha whth average cohesion J
		double max = Integer.MIN_VALUE,
				val = 0; 
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		Set<Integer> upperNeighbors =c.parents;
		for (Integer i: upperNeighbors){
			if (c.cohMinSMC > cl.conceptList.get(i).cohMinSMC){
				rightNeighborsNumber++;
				val = 1.*cl.conceptList.get(i).cohMinSMC/c.cohMinSMC;	
				if (val>max)
					max = val;
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/upperNeighbors.size()>=tetta) ? 1 : 0;
			truthDegree =  (float) Math.min(1.0, truthDegree);		
			return (1-max)*truthDegree;
		}		
	}
	

	
	public double lowerCohAvgByAvgJ(FormalConcept c,float tetta){
		double sum = 0;
		Set<Integer> lowerNeighbors =c.childs;
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		for (Integer i: lowerNeighbors){
			if (c.cohAvgJ < cl.conceptList.get(i).cohAvgJ){
				rightNeighborsNumber++;
				sum+=1.*c.cohAvgJ/cl.conceptList.get(i).cohAvgJ;
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/lowerNeighbors.size()>=tetta) ? 1 : 0;
			truthDegree =  (float) Math.min(1.0, truthDegree);
			return (sum/rightNeighborsNumber)*truthDegree;
		}
	}
	
	public double lowerCohAvgByMinJ(FormalConcept c,float tetta){
		double sum = 0;
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		Set<Integer> lowerNeighbors =c.childs;
		for (Integer i: lowerNeighbors){
			if (c.cohMinJ< cl.conceptList.get(i).cohMinJ){
				rightNeighborsNumber++;
				sum+=1.*c.cohMinJ/cl.conceptList.get(i).cohMinJ;
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			//truthDegree = rightNeighborsNumber/tetta/lowerNeighbors.size();
			truthDegree = (1.*rightNeighborsNumber/lowerNeighbors.size()>=tetta) ? 1 : 0;
			truthDegree =  (float) Math.min(1.0, truthDegree);
			return (sum/rightNeighborsNumber)*truthDegree;
		}			
	}
	
	public double lowerCohMinByAvgJ(FormalConcept c,float tetta){
		double min = Integer.MAX_VALUE,
				val = 0;
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		Set<Integer> lowerNeighbors =c.childs;
		for (Integer i: lowerNeighbors){
			if (c.cohAvgJ< cl.conceptList.get(i).cohAvgJ){
				rightNeighborsNumber++;
				val = 1.*c.cohAvgJ/cl.conceptList.get(i).cohAvgJ;
				if (val<min)
					min = val;	
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/lowerNeighbors.size()>=tetta) ? 1 : 0;
			truthDegree =  (float) Math.min(1.0, truthDegree);
			return (min)*truthDegree;
		}		
	}
	
	public double lowerCohMinByMinJ(FormalConcept c,float tetta){
		double min = Integer.MAX_VALUE,
				val = 0;
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		Set<Integer> lowerNeighbors =c.childs;
		for (Integer i: lowerNeighbors){
			if (c.cohMinJ< cl.conceptList.get(i).cohMinJ){
				rightNeighborsNumber++;
				val = 1.*c.cohMinJ/cl.conceptList.get(i).cohMinJ;
				if (val<min)
					min = val;	
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/lowerNeighbors.size()>=tetta) ? 1 : 0;
			truthDegree =  (float) Math.min(1.0, truthDegree);
			return (min)*truthDegree;
		}		
	}
	
	public double lowerCohAvgByAvgSMC(FormalConcept c,float tetta){
		double sum = 0;
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		Set<Integer> lowerNeighbors =c.childs;
		for (Integer i: lowerNeighbors){
			if (c.cohAvgSMC < cl.conceptList.get(i).cohAvgSMC){
				rightNeighborsNumber++;
				sum+=1.*c.cohAvgSMC/cl.conceptList.get(i).cohAvgSMC;	
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/lowerNeighbors.size()>=tetta) ? 1 : 0;
			truthDegree =  (float) Math.min(1.0, truthDegree);
			return (sum/rightNeighborsNumber)*truthDegree;
		}			
	}
	
	public double lowerCohAvgByMinSMC(FormalConcept c,float tetta){
		double sum = 0;
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		Set<Integer> lowerNeighbors =c.childs;
		for (Integer i: lowerNeighbors){
			if (c.cohMinSMC < cl.conceptList.get(i).cohMinSMC){
				rightNeighborsNumber++;
				sum+=1.*c.cohMinSMC/cl.conceptList.get(i).cohMinSMC;		
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/lowerNeighbors.size()>=tetta) ? 1 : 0;
			truthDegree =  (float) Math.min(1.0, truthDegree);
			return (sum/rightNeighborsNumber)*truthDegree;
		}			
	}
	
	public double lowerCohMinByAvgSMC(FormalConcept c,float tetta){
		double min = Integer.MAX_VALUE,
				val = 0;
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		Set<Integer> lowerNeighbors =c.childs;
		for (Integer i: lowerNeighbors){
			if (c.cohAvgSMC<=cl.conceptList.get(i).cohAvgSMC){
				rightNeighborsNumber++;
				val = 1.*c.cohAvgSMC/cl.conceptList.get(i).cohAvgSMC;	
				if (val<min)
					min = val;	
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/lowerNeighbors.size()>=tetta) ? 1 : 0;
			truthDegree =  (float) Math.min(1.0, truthDegree);
			return (min)*truthDegree;
		}		
	}
	
	
	public double lowerCohMinByMinSMC(FormalConcept c,float tetta){
		double min = Integer.MAX_VALUE,
				val = 0;
		int rightNeighborsNumber = 0;
		float truthDegree = 0;
		Set<Integer> lowerNeighbors =c.childs;
		for (Integer i: lowerNeighbors){
			if (c.cohMinSMC< cl.conceptList.get(i).cohMinSMC){
				rightNeighborsNumber++;
				val = 1.*c.cohMinSMC/cl.conceptList.get(i).cohMinSMC;
				if (val<min)
					min = val;	
			}
		}
		if (rightNeighborsNumber == 0)
			return 0;
		else{
			truthDegree = (1.*rightNeighborsNumber/lowerNeighbors.size()>=tetta) ? 1 : 0;
			return (min)*truthDegree;
		}		
	}
	
	
	//Similarity approach (S)
	//group of metrics: 
	// SMC avg_avg, avg_min, min_avg
	//   J avg_avg, avg_min, min_avg
	public void similarityGoguenNorm(){
		
		// ��� ������� �� ��������� �������� �� ���� �������� ������ � �����
		// ����� �����������  � ������� ������� ������ � �����
		double[] buf = new double[2];
		
		if (objectsSimilaritySMC == null)
			this.setUp();		
		
	//upper neighbors - alpha2
	//lower neighbors - alpha3
		for (FormalConcept c: cl.conceptList){	
			c.cohAvgJ = avgCohJ(c);
			c.cohMinJ = minCohJ(c);
			c.cohAvgSMC = avgCohSMC(c);
			c.cohMinSMC = minCohSMC(c);
			
		}
		for (FormalConcept c: cl.conceptList){
			float tetta = 1;
			c.blS_Jaa = (c.cohAvgJ != 0) ? c.cohAvgJ * upperCohAvgByAvgJ(c,tetta) * lowerCohAvgByAvgJ(c,tetta) : 0;
			c.blS_Jma = (c.cohMinJ != 0) ? c.cohMinJ * upperCohAvgByMinJ(c,tetta) * lowerCohAvgByMinJ(c,tetta) : 0;			
			c.blS_Jam = (c.cohAvgJ != 0) ? c.cohAvgJ * upperCohMinByAvgJ(c,tetta) * lowerCohMinByAvgJ(c,tetta) : 0;
			c.blS_Jmm = (c.cohMinJ != 0) ? c.cohMinJ * upperCohMinByMinJ(c,tetta) * lowerCohMinByMinJ(c,tetta) : 0;
			c.blS_SMCaa = (c.cohAvgSMC != 0) ? c.cohAvgSMC * upperCohAvgByAvgSMC(c,tetta) * lowerCohAvgByAvgSMC(c,tetta) : 0;
			c.blS_SMCma = (c.cohMinSMC != 0) ? c.cohMinSMC * upperCohAvgByMinSMC(c,tetta) * lowerCohAvgByMinSMC(c,tetta) : 0;
			c.blS_SMCam = (c.cohAvgSMC != 0) ? c.cohAvgSMC * upperCohMinByAvgSMC(c,tetta) * lowerCohMinByAvgSMC(c,tetta) : 0;
			c.blS_SMCmm = (c.cohMinSMC != 0) ? c.cohMinSMC * upperCohMinByMinSMC(c,tetta) * lowerCohMinByMinSMC(c,tetta) : 0;
		}	
	}
	
	//Cue validity approach (CV)
	public void cueValidity(){
		
		if (attributesExtent == null)
				this.setUp();
		
		ArrayList<Integer> attrExtent;
		Set<Integer> intersection;
		double sum = 0;
		for (FormalConcept c: cl.conceptList){
			sum = 0;
			for (Integer i: c.intent){
				intersection = new HashSet<Integer>();
				intersection.addAll(c.extent);
				attrExtent = attributesExtent.get(i);				
				intersection.retainAll(attrExtent);
				sum+=(double)intersection.size()*1./attrExtent.size();
				}	
			c.blCV = Double.isNaN(sum) ? 0 : sum;
			
		}			
	}
	//Category feature collocation approach
	public void categoryFeatureCollocation(){
		if (attributesExtent == null)
			this.setUp();
		
		ArrayList<Integer> attrExtent;
		Set<Integer> intersection;
		double sum = 0;
		int latticeSize = cl.conceptList.size();
		for (FormalConcept c: cl.conceptList){
			sum = 0;
			for (int i = 0; i < cl.attributeCount; i++){
				intersection = new HashSet<Integer>();
				intersection.addAll(c.extent);
				attrExtent = attributesExtent.get(i);				
				intersection.retainAll(attrExtent);
				sum+=(double)intersection.size()*1./attrExtent.size()*intersection.size()/c.extent.size();
				}	
			c.blCFC = Double.isNaN(sum) ? 0 : sum;
		}
	}
	
	//Category utility approach
	public void categoryUtility(){
		if (attributesExtent == null)
			this.setUp();
		
		ArrayList<Integer> attrExtent;
		Set<Integer> intersection;
		double sum = 0;
		int attrSize = cl.objectCount;
		int cExtentSize = 0;
		for (FormalConcept c: cl.conceptList){
			sum = 0;
			for (int i = 0; i < cl.attributeCount; i++){
				intersection = new HashSet<Integer>();
				intersection.addAll(c.extent);
				cExtentSize = c.extent.size();
				attrExtent = attributesExtent.get(i);				
				intersection.retainAll(attrExtent);
				sum+=(double)Math.pow(intersection.size()*1./cExtentSize,2)-Math.pow(1.*attrExtent.size()/attrSize,2);
				}	
			c.blCU =Double.isNaN(1.*cExtentSize/attrSize*sum) ? 0 : 1.*cExtentSize/attrSize*sum;
		}					
	}
	
	//Predictability approach (P)
	public void predictability(){
		
		if (attributesExtent == null)
			this.setUp();
		ArrayList<Integer> attributes = new ArrayList<Integer>();
		ArrayList<Integer> outOfIntent = new ArrayList<Integer>();
		Set<Integer> intersection;
		ArrayList<Integer> attrExtent;
		double sum, term;
		
		for (int i = 0; i< cl.attributeCount; i++){
			attributes.add(i);
		}
		for (FormalConcept c: cl.conceptList){
			sum = 0;
			outOfIntent = new ArrayList<Integer>();
			outOfIntent.addAll(attributes);
			outOfIntent.removeAll(c.intent);
			for (Integer y: outOfIntent){
				intersection = new HashSet<Integer>();
				intersection.addAll(c.extent);	
				attrExtent = attributesExtent.get(y);				
				intersection.retainAll(attrExtent);
				term = 1.*intersection.size()/c.extent.size();
				
				if (term > 0){
					sum-=term*Math.log(term);
				}
			}
			c.blP = Double.isNaN(1-sum/outOfIntent.size()) ? 0 : 1-sum/outOfIntent.size();
		}
		
	}
}