public code v1

bundles/flintstones.operator.unification.twotuple/.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

bundles/flintstones.operator.unification.twotuple/.polyglot.META-INF

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>flintstones.group</groupId>
+    <artifactId>flintstones.bundles</artifactId>
+    <version>1.0.0-SNAPSHOT</version>
+  </parent>
+  <artifactId>flintstones.operator.unification.twotuple</artifactId>
+  <version>1.0.0-SNAPSHOT</version>
+  <packaging>eclipse-plugin</packaging>
+  <name>[bundle] Unification 2-tuple</name>
+</project>

bundles/flintstones.operator.unification.twotuple/.project

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>flintstones.operator.unification.twotuple</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+	<filteredResources>
+		<filter>
+			<id>1779484362738</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+</projectDescription>

bundles/flintstones.operator.unification.twotuple/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8

bundles/flintstones.operator.unification.twotuple/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8

bundles/flintstones.operator.unification.twotuple/.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

bundles/flintstones.operator.unification.twotuple/META-INF/MANIFEST.MF

@@ -0,0 +1,18 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Unification 2-tuple
+Bundle-SymbolicName: flintstones.operator.unification.twotuple;singleton:=true
+Bundle-Version: 1.0.0.qualifier
+Automatic-Module-Name: flintstones.operator.unification.twotuple
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Require-Bundle: flintstones.operator.unification,
+ flintstones.domain.fuzzyset.unbalanced,
+ flintstones.valuation.hesitant,
+ flintstones.valuation.numeric,
+ flintstones.valuation.numeric.integer.interval,
+ flintstones.valuation.numeric.real.interval,
+ flintstones.valuation.unifiedValuation,
+ flintstones.valuation.twoTuple,
+ org.eclipse.e4.core.contexts,
+ org.eclipse.e4.core.di,
+ javax.inject

bundles/flintstones.operator.unification.twotuple/build.properties

@@ -0,0 +1,5 @@
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .,\
+               plugin.xml

bundles/flintstones.operator.unification.twotuple/plugin.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<plugin>
+   <extension
+         point="flintstones.operator.unification.extensionpoint">
+      <final_valuation
+            final_valuation_type="flintstones.valuation.twoTuple">
+         <source_valuation
+               implementation="flintstones.operator.unification.twotuple.UnificationTwoTupleHesitant"
+               source_valuation_type="flintstones.valuation.hesitant">
+         </source_valuation>
+         <source_valuation
+               implementation="flintstones.operator.unification.twotuple.UnificationTwoTupleInteger"
+               source_valuation_type="flintstones.valuation.integer">
+         </source_valuation>
+         <source_valuation
+               implementation="flintstones.operator.unification.twotuple.UnificationTwoTupleIntervalInteger"
+               source_valuation_type="flintstones.valuation.integer.interval">
+         </source_valuation>
+         <source_valuation
+               implementation="flintstones.operator.unification.twotuple.UnificationTwoTupleReal"
+               source_valuation_type="flintstones.valuation.real">
+         </source_valuation>
+         <source_valuation
+               implementation="flintstones.operator.unification.twotuple.UnificationTwoTupleIntervalReal"
+               source_valuation_type="flintstones.valuation.real.interval">
+         </source_valuation>
+         <source_valuation
+               implementation="flintstones.operator.unification.twotuple.UnificationTwoTupleUnbalanced"
+               source_valuation_type="flintstones.valuation.linguistic.unbalanced">
+         </source_valuation>
+         <source_valuation
+               implementation="flintstones.operator.unification.twotuple.UnificationTwoTupleLinguistic"
+               source_valuation_type="flintstones.valuation.linguistic">
+         </source_valuation>
+         <source_valuation
+               implementation="flintstones.operator.unification.twotuple.UnificationHierarchiesTwoTupleLinguistic"
+               source_valuation_type="flintstones.valuation.linguistic"
+               specific_method="flintstones.method.multigranular.lh.method">
+         </source_valuation>
+         <source_valuation
+               implementation="flintstones.operator.unification.twotuple.UnificationHierarchiesTwoTupleLinguistic"
+               source_valuation_type="flintstones.valuation.linguistic"
+               specific_method="flintstones.method.multigranular.elh">
+         </source_valuation>
+      </final_valuation>
+   </extension>
+
+</plugin>

bundles/flintstones.operator.unification.twotuple/src/flintstones/operator/unification/twotuple/UnificationHierarchiesTwoTupleLinguistic.java

@@ -0,0 +1,27 @@
+package flintstones.operator.unification.twotuple;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+
+import flintstones.domain.fuzzyset.FuzzySet;
+import flintstones.entity.domain.Domain;
+import flintstones.entity.valuation.Valuation;
+import flintstones.operator.unification.UnificationOperator;
+import flintstones.valuation.linguistic.LinguisticValuation;
+import flintstones.valuation.twoTuple.TwoTupleValuation;
+
+public class UnificationHierarchiesTwoTupleLinguistic extends UnificationOperator {
+	
+	@Inject
+	IEclipseContext context;
+
+	@Override
+	public Valuation unify(Domain unificationDomain, Valuation valuation) {
+		TwoTupleValuation transformed2Tuple = ContextInjectionFactory.make(TwoTupleValuation.class, context);
+		transformed2Tuple.setDomain((FuzzySet) valuation.getDomain());
+		transformed2Tuple.setLabel(((LinguisticValuation) valuation).getLabel());
+		return transformed2Tuple.transform((FuzzySet) unificationDomain);
+	}
+}

bundles/flintstones.operator.unification.twotuple/src/flintstones/operator/unification/twotuple/UnificationTwoTupleHesitant.java

@@ -0,0 +1,45 @@
+package flintstones.operator.unification.twotuple;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+
+import flintstones.domain.fuzzyset.FuzzySet;
+import flintstones.domain.fuzzyset.function.types.TrapezoidalFunction;
+import flintstones.domain.fuzzyset.semantic.IMembershipFunction;
+import flintstones.entity.domain.Domain;
+import flintstones.entity.valuation.Valuation;
+import flintstones.operator.unification.UnificationOperator;
+import flintstones.valuation.hesitant.HesitantValuation;
+import flintstones.valuation.unifiedValuation.UnifiedValuation;
+
+public class UnificationTwoTupleHesitant extends UnificationOperator {
+	
+	@Inject
+	IEclipseContext context;
+
+	@Override
+	public Valuation unify(Domain unificationDomain, Valuation valuation) {
+		FuzzySet unifiedDomain = this.unification(unificationDomain, valuation);
+		UnifiedValuation unifiedValuation = ContextInjectionFactory.make(UnifiedValuation.class, context);
+		unifiedValuation.setDomain(unifiedDomain);
+		return unifiedValuation.disunification(unifiedDomain);
+	}
+
+	public FuzzySet unification(Domain unificationDomain, Valuation valuation) {
+		FuzzySet unifiedDomain = (FuzzySet) ((FuzzySet) unificationDomain).clone();
+		int g = unifiedDomain.getLabelSet().getCardinality();
+	
+		TrapezoidalFunction tmf = ((HesitantValuation) valuation).calculateFuzzyEnvelope((FuzzySet) unificationDomain);
+		
+		FuzzySet fuzzysetF = (FuzzySet) unificationDomain;
+		FuzzySet valuationdomainF = (FuzzySet) valuation.getDomain();
+		for (int i = 0; i < g; i++) {
+			IMembershipFunction function = unifiedDomain.getLabelSet().getLabel(i).getSemantic();
+			unifiedDomain.setValue(i, function.maxMin(tmf, fuzzysetF, valuationdomainF));
+		}
+	
+		return unifiedDomain;
+	}
+}

bundles/flintstones.operator.unification.twotuple/src/flintstones/operator/unification/twotuple/UnificationTwoTupleInteger.java

@@ -0,0 +1,49 @@
+package flintstones.operator.unification.twotuple;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+
+import flintstones.domain.fuzzyset.FuzzySet;
+import flintstones.domain.fuzzyset.semantic.IMembershipFunction;
+import flintstones.entity.domain.Domain;
+import flintstones.entity.valuation.Valuation;
+import flintstones.helper.validator.Validator;
+import flintstones.operator.unification.UnificationOperator;
+import flintstones.valuation.numeric.NumericValuation;
+import flintstones.valuation.unifiedValuation.UnifiedValuation;
+
+public class UnificationTwoTupleInteger extends UnificationOperator {
+
+	@Inject
+	IEclipseContext context;
+	
+	@Override
+	public Valuation unify(Domain unificationDomain, Valuation valuation) {
+		FuzzySet unifiedDomain = this.unification(unificationDomain, valuation);
+		UnifiedValuation unifiedValuation = ContextInjectionFactory.make(UnifiedValuation.class, context);
+		unifiedValuation.setDomain(unifiedDomain);
+		return unifiedValuation.disunification(unifiedDomain);
+	}
+
+	public FuzzySet unification(Domain unificationDomain, Valuation valuation) {
+
+		Validator.notNull(unificationDomain);
+
+		if (!((FuzzySet) unificationDomain).isBLTS())
+			throw new IllegalArgumentException("Not BLTS fuzzy set");
+
+		FuzzySet unifiedDomain = (FuzzySet) unificationDomain.clone();
+		int cardinality = ((FuzzySet) unificationDomain).getLabelSet().getCardinality();
+		NumericValuation normalized = (NumericValuation) ((NumericValuation) valuation).normalized();
+
+		IMembershipFunction function;
+		for (int i = 0; i < cardinality; i++) {
+			function = unifiedDomain.getLabelSet().getLabel(i).getSemantic();
+			unifiedDomain.setValue(i, function.getMembershipValue(normalized.getValue()));
+		}
+
+		return unifiedDomain;
+	}
+}

bundles/flintstones.operator.unification.twotuple/src/flintstones/operator/unification/twotuple/UnificationTwoTupleIntervalInteger.java

@@ -0,0 +1,49 @@
+package flintstones.operator.unification.twotuple;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+
+import flintstones.domain.fuzzyset.FuzzySet;
+import flintstones.domain.fuzzyset.semantic.IMembershipFunction;
+import flintstones.entity.domain.Domain;
+import flintstones.entity.valuation.Valuation;
+import flintstones.helper.validator.Validator;
+import flintstones.operator.unification.UnificationOperator;
+import flintstones.valuation.numeric.integer.interval.IntegerIntervalValuation;
+import flintstones.valuation.unifiedValuation.UnifiedValuation;
+
+public class UnificationTwoTupleIntervalInteger extends UnificationOperator {
+
+	@Inject
+	IEclipseContext context;
+	
+	@Override
+	public Valuation unify(Domain unificationDomain, Valuation valuation) {
+		FuzzySet unifiedDomain = this.unification(unificationDomain, valuation);
+		UnifiedValuation unifiedValuation = ContextInjectionFactory.make(UnifiedValuation.class, context);
+		unifiedValuation.setDomain(unifiedDomain);
+		return unifiedValuation.disunification(unifiedDomain);
+	}
+
+	public FuzzySet unification(Domain unificationDomain, Valuation valuation) {
+
+		Validator.notNull(unificationDomain);
+
+		if (!((FuzzySet) unificationDomain).isBLTS())
+			throw new IllegalArgumentException("Not BLTS fuzzy set");
+
+		FuzzySet result = (FuzzySet) unificationDomain.clone();
+		int cardinality = ((FuzzySet) unificationDomain).getLabelSet().getCardinality();
+		IntegerIntervalValuation normalized = (IntegerIntervalValuation) ((IntegerIntervalValuation) valuation).normalized();
+
+		IMembershipFunction function;
+		for (int i = 0; i < cardinality; i++) {
+			function = result.getLabelSet().getLabel(i).getSemantic();
+			result.setValue(i, function.maxMin(normalized.getMax(), normalized.getMin()));
+		}
+		
+		return result;
+	}
+}

bundles/flintstones.operator.unification.twotuple/src/flintstones/operator/unification/twotuple/UnificationTwoTupleIntervalReal.java

@@ -0,0 +1,50 @@
+package flintstones.operator.unification.twotuple;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+
+import flintstones.domain.fuzzyset.FuzzySet;
+import flintstones.domain.fuzzyset.function.types.TrapezoidalFunction;
+import flintstones.domain.fuzzyset.semantic.IMembershipFunction;
+import flintstones.entity.domain.Domain;
+import flintstones.entity.valuation.Valuation;
+import flintstones.helper.validator.Validator;
+import flintstones.operator.unification.UnificationOperator;
+import flintstones.valuation.numeric.real.interval.RealIntervalValuation;
+import flintstones.valuation.unifiedValuation.UnifiedValuation;
+
+public class UnificationTwoTupleIntervalReal extends UnificationOperator{
+
+	@Inject
+	IEclipseContext context;
+	
+	@Override
+	public Valuation unify(Domain unificationDomain, Valuation valuation) {
+		FuzzySet unifiedDomain = this.unification(unificationDomain, valuation);
+		UnifiedValuation unifiedValuation = ContextInjectionFactory.make(UnifiedValuation.class, context);
+		unifiedValuation.setDomain(unifiedDomain);
+		return unifiedValuation.disunification(unifiedDomain);
+	}
+
+	public FuzzySet unification(Domain unificationDomain, Valuation valuation) {
+
+		Validator.notNull(unificationDomain);
+
+		if (!((FuzzySet) unificationDomain).isBLTS())
+			throw new IllegalArgumentException("Not BLTS fuzzy set");
+
+		FuzzySet result = (FuzzySet) unificationDomain.clone();
+		int cardinality = ((FuzzySet) unificationDomain).getLabelSet().getCardinality();
+		RealIntervalValuation normalized = (RealIntervalValuation) ((RealIntervalValuation) valuation).normalized();
+
+		IMembershipFunction function;
+		for (int i = 0; i < cardinality; i++) {
+			function = result.getLabelSet().getLabel(i).getSemantic();
+			result.setValue(i, ((TrapezoidalFunction) function).maxMin(normalized.getMax(), normalized.getMin()));
+		}
+		
+		return result;
+	}
+}

bundles/flintstones.operator.unification.twotuple/src/flintstones/operator/unification/twotuple/UnificationTwoTupleLinguistic.java

@@ -0,0 +1,51 @@
+package flintstones.operator.unification.twotuple;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+
+import flintstones.domain.fuzzyset.FuzzySet;
+import flintstones.domain.fuzzyset.semantic.IMembershipFunction;
+import flintstones.entity.domain.Domain;
+import flintstones.entity.valuation.Valuation;
+import flintstones.helper.validator.Validator;
+import flintstones.operator.unification.UnificationOperator;
+import flintstones.valuation.linguistic.LinguisticValuation;
+import flintstones.valuation.unifiedValuation.UnifiedValuation;
+
+public class UnificationTwoTupleLinguistic extends UnificationOperator {
+	
+	@Inject
+	IEclipseContext context;
+
+	@Override
+	public Valuation unify(Domain unificationDomain, Valuation valuation) {
+		FuzzySet unifiedDomain = this.unification(unificationDomain, valuation);
+		UnifiedValuation unifiedValuation = ContextInjectionFactory.make(UnifiedValuation.class, context);
+		unifiedValuation.setDomain(unifiedDomain);
+		return unifiedValuation.disunification(unifiedDomain);
+	}
+
+	public FuzzySet unification(Domain unificationDomain, Valuation valuation) {
+		
+		Validator.notNull(unificationDomain);
+
+		if (!((FuzzySet) unificationDomain).isBLTS())
+			throw new IllegalArgumentException("Not BLTS fuzzy set");
+		
+		FuzzySet fuzzysetF = (FuzzySet) unificationDomain;
+		FuzzySet valuationdomainF = (FuzzySet) valuation.getDomain();
+
+		FuzzySet unifiedDomain = (FuzzySet) ((FuzzySet) unificationDomain).clone();
+		int cardinality = unifiedDomain.getLabelSet().getCardinality();
+
+		IMembershipFunction function;
+		for (int i = 0; i < cardinality; i++) {
+			function = unifiedDomain.getLabelSet().getLabel(i).getSemantic();
+			unifiedDomain.setValue(i, function.maxMin(((LinguisticValuation) valuation).getLabel().getSemantic(), fuzzysetF, valuationdomainF)); 
+		}
+		
+		return unifiedDomain;
+	}
+}

bundles/flintstones.operator.unification.twotuple/src/flintstones/operator/unification/twotuple/UnificationTwoTupleReal.java

@@ -0,0 +1,49 @@
+package flintstones.operator.unification.twotuple;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+
+import flintstones.domain.fuzzyset.FuzzySet;
+import flintstones.domain.fuzzyset.semantic.IMembershipFunction;
+import flintstones.entity.domain.Domain;
+import flintstones.entity.valuation.Valuation;
+import flintstones.helper.validator.Validator;
+import flintstones.operator.unification.UnificationOperator;
+import flintstones.valuation.numeric.NumericValuation;
+import flintstones.valuation.unifiedValuation.UnifiedValuation;
+
+public class UnificationTwoTupleReal extends UnificationOperator {
+
+	@Inject
+	IEclipseContext context;
+	
+	@Override
+	public Valuation unify(Domain unificationDomain, Valuation valuation) {
+		FuzzySet unifiedDomain = this.unification(unificationDomain, valuation);
+		UnifiedValuation unifiedValuation = ContextInjectionFactory.make(UnifiedValuation.class, context);
+		unifiedValuation.setDomain(unifiedDomain);
+		return unifiedValuation.disunification(unifiedDomain);
+	}
+
+	public FuzzySet unification(Domain unificationDomain, Valuation valuation) {
+
+		Validator.notNull(unificationDomain);
+
+		if (!((FuzzySet) unificationDomain).isBLTS())
+			throw new IllegalArgumentException("Not BLTS fuzzy set");
+
+		FuzzySet unifiedDomain = (FuzzySet) unificationDomain.clone();
+		int cardinality = ((FuzzySet) unificationDomain).getLabelSet().getCardinality();
+		NumericValuation normalized = (NumericValuation) ((NumericValuation) valuation).normalized();
+
+		IMembershipFunction function;
+		for (int i = 0; i < cardinality; i++) {
+			function = unifiedDomain.getLabelSet().getLabel(i).getSemantic();
+			unifiedDomain.setValue(i, function.getMembershipValue(normalized.getValue()));
+		}
+
+		return unifiedDomain;
+	}
+}

bundles/flintstones.operator.unification.twotuple/src/flintstones/operator/unification/twotuple/UnificationTwoTupleUnbalanced.java

@@ -0,0 +1,177 @@
+package flintstones.operator.unification.twotuple;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+
+import flintstones.domain.fuzzyset.label.LabelLinguisticDomain;
+import flintstones.domain.fuzzyset.unbalanced.Unbalanced;
+import flintstones.domain.numeric.real.NumericRealDomain;
+import flintstones.entity.domain.Domain;
+import flintstones.entity.valuation.Valuation;
+import flintstones.operator.unification.UnificationOperator;
+import flintstones.valuation.linguistic.LinguisticValuation;
+import flintstones.valuation.twoTuple.TwoTupleValuation;
+
+public class UnificationTwoTupleUnbalanced extends UnificationOperator {
+
+	private static final int LEFT = 0;
+	private static final int RIGHT = 1;
+
+	private Unbalanced hgls;
+	private Unbalanced unificationDomain;
+
+	@Inject
+	IEclipseContext context;
+
+	@Override
+	public Valuation unify(Domain unificationDomain, Valuation valuation) {
+		this.unificationDomain = (Unbalanced) unificationDomain;
+
+		Map<Integer, Unbalanced> lhDomains = this.generateLHDomains(valuation);
+		return this.transformInto2Tuple(valuation, lhDomains);
+	}
+
+	public Map<Integer, Unbalanced> generateLHDomains(Valuation valuation) {
+		Map<Integer, Unbalanced> lhDomains = new HashMap<Integer, Unbalanced>();
+
+		if (unificationDomain != null) {
+
+			hgls = null;
+
+			int[] lh = ((Unbalanced) unificationDomain).getLh();
+
+			for (int i = 0; i < lh.length; i++) {
+				lhDomains.put(lh[i], generateDomain(lh[i]));
+
+				if (i == (lh.length - 1)) {
+					hgls = lhDomains.get(lh[i]);
+				}
+			}
+		}
+
+		return lhDomains;
+	}
+
+	public Valuation transformInto2Tuple(Valuation valuation, Map<Integer, Unbalanced> lhDomains) {
+		LabelLinguisticDomain label = null;
+
+		double alpha = 0;
+		if (valuation instanceof TwoTupleValuation) {
+			label = ((TwoTupleValuation) valuation).getLabel();
+			alpha = ((TwoTupleValuation) valuation).getAlpha();
+		} else if (valuation instanceof LinguisticValuation) {
+			label = ((LinguisticValuation) valuation).getLabel();
+		} else {
+			throw new IllegalArgumentException();
+		}
+
+		int pos = ((Unbalanced) unificationDomain).getLabelSet().getPos(label);
+		Map<Integer, Integer> domains = ((Unbalanced) unificationDomain).getLabel(pos);
+		int size = domains.size();
+
+		Unbalanced[] auxDomains = new Unbalanced[size];
+		LabelLinguisticDomain[] labels = new LabelLinguisticDomain[size];
+		int[] sizes = new int[size];
+
+		int i = 0;
+		for (Integer domainSize : domains.keySet()) {
+			auxDomains[i] = lhDomains.get(domainSize);
+			labels[i] = auxDomains[i].getLabelSet().getLabel(domains.get(domainSize));
+			sizes[i] = domainSize;
+			i++;
+		}
+
+		return transform(label, alpha, (size > 1), auxDomains, labels, sizes);
+	}
+
+	private Unbalanced generateDomain(int cardinality) {
+		String[] labels = new String[cardinality];
+		for (int i = 0; i < cardinality; i++) {
+			labels[i] = Integer.toString(i);
+		}
+
+		Unbalanced domain = ContextInjectionFactory.make(Unbalanced.class, context);
+		domain.setName("lh(" + labels.length + ")");
+		domain.createTrapezoidalFunction(labels);
+
+		return domain;
+	}
+
+	private Valuation transform(LabelLinguisticDomain label, double alpha, boolean brid, Unbalanced[] domains,
+			LabelLinguisticDomain[] labels, int[] sizes) {
+
+		Valuation result;
+
+		if ((!brid) || (alpha == 0)) {
+			if (brid) {
+				if (sizes[0] > sizes[1]) {
+					result = transformInDomain(domains[0], labels[0], alpha);
+				} else {
+					result = transformInDomain(domains[1], labels[1], alpha);
+				}
+			} else {
+				result = transformInDomain(domains[0], labels[0], alpha);
+			}
+		} else {
+			if (alpha > 0) {
+				if (smallSide(label) == RIGHT) {
+					if (sizes[0] > sizes[1]) {
+						result = transformInDomain(domains[0], labels[0], alpha);
+					} else {
+						result = transformInDomain(domains[1], labels[1], alpha);
+					}
+				} else {
+					if (sizes[0] > sizes[1]) {
+						result = transformInDomain(domains[1], labels[1], alpha);
+					} else {
+						result = transformInDomain(domains[0], labels[0], alpha);
+					}
+				}
+			} else {
+				if (smallSide(label) == RIGHT) {
+					if (sizes[0] > sizes[1]) {
+						result = transformInDomain(domains[1], labels[1], alpha);
+					} else {
+						result = transformInDomain(domains[0], labels[0], alpha);
+					}
+				} else {
+					if (sizes[0] > sizes[1]) {
+						result = transformInDomain(domains[0], labels[0], alpha);
+					} else {
+						result = transformInDomain(domains[1], labels[1], alpha);
+					}
+				}
+			}
+		}
+		return result;
+	}
+
+	private Valuation transformInDomain(Unbalanced domain, LabelLinguisticDomain label, double alpha) {
+		TwoTupleValuation result = ContextInjectionFactory.make(TwoTupleValuation.class, context);
+		result.build(domain, label, alpha);
+
+		if (domain != hgls)
+			result = result.transform(hgls);
+
+		return result;
+	}
+
+	private int smallSide(LabelLinguisticDomain l) {
+		NumericRealDomain center = l.getSemantic().getCenter();
+		NumericRealDomain coverage = l.getSemantic().getCoverage();
+
+		double left = center.getMin() - coverage.getMin();
+		double right = coverage.getMax() - center.getMax();
+
+		if (left > right) {
+			return RIGHT;
+		} else {
+			return LEFT;
+		}
+	}
+}