Added missing javadoc

Author: jklein94

org-tweetyproject-arg-adf/src/main/java/org/tweetyproject/arg/adf/syntax/pl/Literal.java

@@ -26,7 +26,7 @@
  * The {@code Literal} interface represents a logical literal, which can be either a positive or negative
  * proposition. Literals are fundamental components in propositional logic and SAT solvers. They can be
  * used to construct clauses, represent assumptions, and encode constraints.
- * <p>
+ * 
  *
  * @author Mathias Hofer
  */

org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/examples/CheckIfSelfSupportingExample.java

@@ -29,11 +29,11 @@
 
 /**
  * This class demonstrates the use of the {@link EAFTheory} class to check for self-supporting sets of arguments.
- * <p>
+ * 
  * In this example, an extended argumentation framework (EAF) is created with a set of arguments and supports/attacks between them.
  * The goal is to check whether certain sets of arguments are self-supporting using the {@code checkIsSelfSupporting} method
  * of the {@link EAFTheory} class.
- * <p>
+ * 
  * @author Your Name
  */
 public class CheckIfSelfSupportingExample {

org-tweetyproject-arg-dung/src/main/java/org/tweetyproject/arg/dung/equivalence/kernel/EquivalenceKernel.java

@@ -99,6 +99,14 @@ public static EquivalenceKernel getStrongEquivalenceKernelForSemantics(Semantics
         }
     }
 
+        
+    /**
+     * Returns the strong expansion equivalence kernel for the given semantics.
+     *
+     * @param semantics the semantics
+     * @return the corresponding equivalence kernel
+     * @throws IllegalArgumentException if no kernel is defined for the given semantics
+     */
     public static EquivalenceKernel getStrongExpansionEquivalenceKernelForSemantics(Semantics semantics) {
         switch (semantics) {
             case SST,EA -> {

org-tweetyproject-arg-dung/src/main/java/org/tweetyproject/arg/dung/equivalence/kernel/LocalExpansionCompleteKernel.java

@@ -7,7 +7,16 @@
 import java.util.Collection;
 import java.util.HashSet;
 
+/**
+ * Equivalence kernel for local expansion under complete semantics.
+ */
 public class LocalExpansionCompleteKernel extends EquivalenceKernel {
+    /**
+     * Computes the redundant attacks for the given argumentation theory.
+     *
+     * @param theory the argumentation framework
+     * @return the collection of redundant attacks
+     */
     @Override
     public Collection<Attack> getRedundantAttacks(DungTheory theory) {
         Collection<Attack> attacks = new HashSet<>();

org-tweetyproject-arg-dung/src/main/java/org/tweetyproject/arg/dung/examples/QualifiedSemanticsReasonerExample.java

@@ -99,7 +99,7 @@ public static DungTheory example2() {
     /**
      * Creates and returns an example of a Dung argumentation framework (Dung
      * Theory).
-     * <p>
+     * 
      *
      * @return A {@link DungTheory} object representing the defined argumentation
      *         framework.

org-tweetyproject-arg-dung/src/main/java/org/tweetyproject/arg/dung/writer/TikzWriter.java

@@ -39,9 +39,18 @@
  */
 public class TikzWriter extends AbstractDungWriter {
 
+    /** Mapping from integer identifiers to arguments. */
     protected Argument[] intToArg;
+
+    /** Mapping from arguments to integer identifiers. */
     protected Map<Argument, Integer> argToInt;
 
+
+    /**
+     * Initializes the internal argument–identifier mappings.
+     *
+     * @param aaf the argumentation framework
+     */
     protected void initialize(DungTheory aaf) {
         // Initialize mapping from Argument to ID and vice versa
         intToArg = new Argument[aaf.size() + 1];
@@ -54,10 +63,27 @@ protected void initialize(DungTheory aaf) {
         }
     }
 
+    /**
+     * Computes a planar mapping of the given argumentation framework
+     * for a grid of the specified dimensions.
+     *
+     * @param aaf the argumentation framework
+     * @param width the grid width
+     * @param height the grid height
+    */
     protected void findPlanarMapping(DungTheory aaf, int width, int height) {
 
     }
 
+    /**
+     * Checks whether the given argumentation framework can be laid out sufficiently planar
+     * on a grid of the given dimensions.
+     *
+     * @param aaf the argumentation framework
+     * @param width the grid width
+     * @param height the grid height
+     * @return {@code true} if the layout is sufficiently planar, {@code false} otherwise
+     */
     protected boolean isSufficientlyPlanar(DungTheory aaf, int width, int height) {
         for (Argument argument : aaf) {
             Collection<Argument> neighboring = new HashSet<>();
@@ -126,7 +152,14 @@ public String write(DungTheory aaf, int width, int height) {
         writer.close();
         return out.toString();
     }
-
+    /**
+     * Writes TikZ code for the arguments arranged in a grid.
+     *
+     * @param aaf the collection of arguments
+     * @param width the grid width
+     * @param height the grid height
+     * @return a string containing the TikZ commands for arguments
+     */
     protected String writeArguments(Collection<Argument> aaf, int width, int height) {
         StringBuilder s = new StringBuilder();
         // Write arguments
@@ -190,6 +223,12 @@ protected String writeArgument(Argument arg) {
         }
     }
 
+    /**
+     * Writes TikZ code for all attacks in the given argumentation framework.
+     *
+     * @param aaf the argumentation framework
+     * @return a string containing the TikZ commands for attacks
+     */
     protected String writeAttacks(DungTheory aaf) {
         StringBuilder s = new StringBuilder();
         // Write attacks
@@ -211,10 +250,26 @@ protected String writeAttacks(DungTheory aaf) {
         return s.toString();
     }
 
+    /**
+     * Writes TikZ code for an attack between two arguments.
+     *
+     * @param argId1 the source argument identifier
+     * @param argId2 the target argument identifier
+     * @return a string containing the TikZ command for the attack
+     */
     protected String writeAttack(int argId1, int argId2) {
         return writeAttack(argId1, argId2, "single");
     }
 
+    /**
+     * Writes TikZ code for an attack between two arguments.
+     *
+     * @param argId1 the source argument identifier
+     * @param argId2 the target argument identifier
+     * @param mode the attack drawing mode
+     * @return a string containing the TikZ command for the attack
+     * @throws IllegalArgumentException if the mode is unknown
+    */
     protected String writeAttack(int argId1, int argId2, String mode) {
         return switch (mode) {
             case "single" -> String.format("\\attack{a%s}{a%s}%n", argId1, argId2);
@@ -224,6 +279,14 @@ protected String writeAttack(int argId1, int argId2, String mode) {
         };
     }
 
+    /**
+     * Writes TikZ code for self-attacks in the given argumentation framework.
+     *
+     * @param aaf the argumentation framework
+     * @param width the grid width
+     * @param height the grid height
+     * @return a string containing the TikZ commands for self-attacks
+     */
     protected String writeSelfAttacks(DungTheory aaf, int width, int height) {
         StringBuilder s = new StringBuilder();
         // Write self-attacks

org-tweetyproject-arg-explanations/src/main/java/org/tweetyproject/arg/explanations/examples/SequenceExplanationExample.java

@@ -27,12 +27,18 @@
 
 import java.util.Collection;
 
+
 /**
- * Example usage of sequence explanations
- *
- * @author Lars Bengel
- */
+* Runs an example demonstrating sequence explanations.
+*
+* @author Lars Bengel
+*/
 public class SequenceExplanationExample {
+    /**
+     * Runs an example demonstrating sequence explanations.
+     *
+     * @param args command-line arguments (not used)
+     */
     public static void main(String[] args) {
         AbstractSequenceExplanationReasoner reasoner = new DialecticalSequenceExplanationReasoner();
         DungTheory theory = new DungTheory();

org-tweetyproject-arg-explanations/src/main/java/org/tweetyproject/arg/explanations/examples/SufficientExplanationExample.java

@@ -29,6 +29,11 @@
  * @author Lars Bengel
  */
 public class SufficientExplanationExample {
+    /**
+     * Runs an example demonstrating sufficient explanation relevance.
+     *
+     * @param args command-line arguments (not used)
+     */
     public static void main(String[] args) {
         DungTheory theory = new DungTheory();
         Argument a = new Argument("a");

org-tweetyproject-arg-explanations/src/main/java/org/tweetyproject/arg/explanations/semantics/Explanation.java

@@ -47,7 +47,12 @@ public Argument getArgument() {
      */
     protected Explanation(Argument argument) {
         this.argument = argument;
-    }
+    }  
 
+    /**
+     * Returns the set-based explanation.
+     *
+     * @return the explanation as a collection of arguments
+     */
     public abstract Collection<Argument> getSetExplanation();
 }

org-tweetyproject-causal/src/main/java/org/tweetyproject/causal/examples/CausalReasoningExampleSurfer.java

@@ -38,8 +38,10 @@
  */
 public class CausalReasoningExampleSurfer {
     /**
+     * Runs a demonstration of argumentation-based causal reasoning.
      *
-     * @param args cmdline arguments (unused)
+     * @param args command-line arguments (not used)
+     * @throws StructuralCausalModel.CyclicDependencyException if the causal model is cyclic
      */
     public static void main(String[] args) throws StructuralCausalModel.CyclicDependencyException {
         // Background atoms