public code v1

2026-05-23 00:32:57 +02:00
commit 759a8968a2
4357 changed files with 163763 additions and 0 deletions
@@ -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>
@@ -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.method.linguistic.elicit</artifactId>
+  <version>1.0.0-SNAPSHOT</version>
+  <packaging>eclipse-plugin</packaging>
+  <name>[bundle] ELICIT</name>
+</project>
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>flintstones.method.linguistic.elicit</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>1779484362676</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>
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
@@ -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
@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1
@@ -0,0 +1,11 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %Bundle-Name
+Bundle-SymbolicName: flintstones.method.linguistic.elicit;singleton:=true
+Bundle-Version: 1.0.0.qualifier
+Automatic-Module-Name: flintstones.method.linguistic.twotuple
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Require-Bundle: flintstones.entity.validatedmethod,
+ flintstones.valuation.elicit,
+ flintstones.valuation.hesitant,
+ flintstones.helper.faq
@@ -0,0 +1,2 @@
+#Properties file for flintstones.method.linguistic.hesitant.twotuple
+Bundle-Name = ELICIT
@@ -0,0 +1,2 @@
+#Properties file for flintstones.method.linguistic.hesitant.twotuple
+Bundle-Name = ELICIT
@@ -0,0 +1,8 @@
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .,\
+               plugin.xml,\
+               OSGI-INF/,\
+               faq/
+
@@ -0,0 +1 @@
+Many real-world decision making problems present changing contexts in which uncertainty or vagueness appear. Such uncertainty has been often modeled based on linguistic information by using single linguistic terms. Dealing with linguistic information in decision making demands processes of computing with words whose main characteristic is to emulate human beings reasoning processes to obtain linguistic outputs from linguistic inputs. However, often single linguistic terms are limited or do not express properly the expert's knowledge, being necessary to elaborate richer linguistic expressions easy to understand and able to express greater amount of knowledge, as it is the case of the comparative linguistic expressions based on hesitant fuzzy linguistic terms sets. Nevertheless, current computational models for comparative linguistic expressions present limitations both from understandibility and precision points of view. The 2-tuple linguistic representation model stands out in these aspects because of its accuracy and interpretability dealing with linguistic terms, both related to the use of the symbolic translation, although 2-tuple linguistic values are still limited by the use of single linguistic terms. Therefore, the aim of this paper is to present a new fuzzy linguistic representation model for comparative linguistic expressions that takes advantage of the goodness of the 2-tuple linguistic representation model and improve the interpretability and accuracy of the results in computing with words processes, resulting the so-called Extended Comparative Linguistic Expressions with Symbolic Translation (ELICIT). Taking into account the proposed model, a new computing with words approach is presented and then applied to a decision making case study to show its performance and advantages in a real case by comparing with other linguistic decision approaches.
@@ -0,0 +1,3 @@
+# ELICIT Representation Model
+
+Many real-world decision making problems present changing contexts in which uncertainty or vagueness appear. Such uncertainty has been often modeled based on linguistic information by using single linguistic terms. Dealing with linguistic information in decision making demands processes of computing with words whose main characteristic is to emulate human beings reasoning processes to obtain linguistic outputs from linguistic inputs. However, often single linguistic terms are limited or do not express properly the expert's knowledge, being necessary to elaborate richer linguistic expressions easy to understand and able to express greater amount of knowledge, as it is the case of the comparative linguistic expressions based on hesitant fuzzy linguistic terms sets. Nevertheless, current computational models for comparative linguistic expressions present limitations both from understandibility and precision points of view. The 2-tuple linguistic representation model stands out in these aspects because of its accuracy and interpretability dealing with linguistic terms, both related to the use of the symbolic translation, although 2-tuple linguistic values are still limited by the use of single linguistic terms. Therefore, the aim of this paper is to present a new fuzzy linguistic representation model for comparative linguistic expressions that takes advantage of the goodness of the 2-tuple linguistic representation model and improve the interpretability and accuracy of the results in computing with words processes, resulting the so-called Extended Comparative Linguistic Expressions with Symbolic Translation (ELICIT). Taking into account the proposed model, a new computing with words approach is presented and then applied to a decision making case study to show its performance and advantages in a real case by comparing with other linguistic decision approaches.
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<plugin>
+   <extension
+         point="flintstones.method.extension">
+      <method
+            category="flintstones.entity.method.hesitant"
+            uid="flintstones.method.linguistic.hesitant.twotuple"
+            implementation="flintstones.method.linguistic.elicit.ELICITMethod">
+         <phase
+               uid="flintstones.method.common.unification.unification">
+         </phase>
+         <phase
+               uid="flintstones.method.common.phase.aggregation">
+         </phase>
+      </method>
+   </extension>
+
+</plugin>
@@ -0,0 +1,64 @@
+
+package flintstones.method.linguistic.elicit;
+
+import java.util.HashMap;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.services.nls.Translation;
+
+import flintstones.entity.method.Method;
+import flintstones.entity.validatedmethod.ValidatedMethod;
+import flintstones.entity.valuation.Valuation;
+import flintstones.helper.chainvalidator.ChainValidator;
+import flintstones.helper.chainvalidator.operation.method.ValuationTypeOperation;
+import flintstones.helper.faq.interfaces.IMarkdownFAQ;
+import flintstones.method.linguistic.elicit.messages.Messages;
+import flintstones.valuation.elicit.ELICIT;
+import flintstones.valuation.hesitant.HesitantValuation;
+
+public class ELICITMethod extends ValidatedMethod implements IMarkdownFAQ {
+
+	@Inject
+	@Translation
+	Messages messages;
+	
+	@Override
+	public String getName() {
+		return messages.Method_name;
+	}
+	
+	@Override
+	protected void reloadValidator() {
+		
+		validator = ContextInjectionFactory.make(ChainValidator.class, context);
+		
+		int numDomains = domainService.getAll().length;
+		String numDomainEntity = domainMessages.Domain_count;
+		
+		Valuation[] valuations = valuationService.getAll();
+		String valuationsEntity = valuationMessages.Valuation_entity;
+		ValuationTypeOperation valuationTypeOperator =
+				new ValuationTypeOperation(valuationsEntity, HesitantValuation.class.getSimpleName(), valuations);
+
+		validator.setReturn(this.getName())
+			.greaterThan(numDomainEntity, numDomains, 0)
+			.named("numDomains")//$NON-NLS-1$
+			.custom(valuationTypeOperator)
+			.named("valuations");//$NON-NLS-1$
+	}	
+
+
+	@Override
+	protected HashMap<String, Object> exportData() {
+		HashMap<String, Object> map = new HashMap<String, Object>();
+		map.put(Method.TYPE_OF_VALUATION, ELICIT.ID);
+		return map;
+	}
+
+	@Override
+	public String getFAQFile() {
+		return "faq/faq";
+	}
+}
@@ -0,0 +1,11 @@
+//This file has been auto-generated
+package flintstones.method.linguistic.elicit.messages;
+
+import org.eclipse.e4.core.services.nls.Message;
+
+@Message
+@SuppressWarnings("javadoc")
+public class Messages {
+	public String Method_name;
+	public String Method_description;
+}
@@ -0,0 +1,2 @@
+Method_name=ELICIT computational model
+Method_description=Method which uses hesitant complex terms which are represented by means of 2-tuple
@@ -0,0 +1,2 @@
+Method_name=Modelo computacional ELICIT
+Method_description=Method which uses hesitant complex terms which are represented by means of 2-tuple
				`@@ -0,0 +1 @@`
				Many real-world decision making problems present changing contexts in which uncertainty or vagueness appear. Such uncertainty has been often modeled based on linguistic information by using single linguistic terms. Dealing with linguistic information in decision making demands processes of computing with words whose main characteristic is to emulate human beings reasoning processes to obtain linguistic outputs from linguistic inputs. However, often single linguistic terms are limited or do not express properly the expert's knowledge, being necessary to elaborate richer linguistic expressions easy to understand and able to express greater amount of knowledge, as it is the case of the comparative linguistic expressions based on hesitant fuzzy linguistic terms sets. Nevertheless, current computational models for comparative linguistic expressions present limitations both from understandibility and precision points of view. The 2-tuple linguistic representation model stands out in these aspects because of its accuracy and interpretability dealing with linguistic terms, both related to the use of the symbolic translation, although 2-tuple linguistic values are still limited by the use of single linguistic terms. Therefore, the aim of this paper is to present a new fuzzy linguistic representation model for comparative linguistic expressions that takes advantage of the goodness of the 2-tuple linguistic representation model and improve the interpretability and accuracy of the results in computing with words processes, resulting the so-called Extended Comparative Linguistic Expressions with Symbolic Translation (ELICIT). Taking into account the proposed model, a new computing with words approach is presented and then applied to a decision making case study to show its performance and advantages in a real case by comparing with other linguistic decision approaches.