Exemplo n.º 1
0
 protected boolean beginExecution(final IScope scope) throws GamaRuntimeException {
   final IAgent agent = scope.getAgentScope();
   if (scope.interrupted()) {
     return false;
   }
   final Boolean enter = (Boolean) agent.getAttribute(ENTER);
   Map<String, Object> memory = (Map) agent.getAttribute(STATE_MEMORY);
   if (enter || memory == null) {
     memory = new THashMap();
     agent.setAttribute(STATE_MEMORY, memory);
   } else {
     for (final Map.Entry<String, Object> entry : memory.entrySet()) {
       scope.addVarWithValue(entry.getKey(), entry.getValue());
     }
   }
   if (enter) {
     if (enterActions != null) {
       enterActions.executeOn(scope);
     }
     if (agent.dead()) {
       return false;
     }
     agent.setAttribute(ENTER, false);
   }
   return true;
 }
Exemplo n.º 2
0
  private static Instances convertToInstances(
      final IScope scope,
      final IList<String> attributes,
      final IAddressableContainer<Integer, IAgent, Integer, IAgent> agents)
      throws GamaRuntimeException {
    FastVector attribs = new FastVector();
    for (String att : attributes) {
      attribs.addElement(new Attribute(att));
    }
    Instances dataset =
        new Instances(scope.getAgentScope().getName(), attribs, agents.length(scope));
    for (IAgent ag : agents.iterable(scope)) {

      int nb = attributes.size();
      double vals[] = new double[nb];
      for (int i = 0; i < nb; i++) {
        String attrib = attributes.get(i);
        Double var = Cast.asFloat(scope, ag.getDirectVarValue(scope, attrib));
        vals[i] = var;
      }
      Instance instance = new Instance(1, vals);
      dataset.add(instance);
    }
    return dataset;
  }
Exemplo n.º 3
0
  private static double[] computeXaXs(
      final IScope scope,
      final IAgentFilter filter,
      final Map<Object, Integer> categoriesId,
      final Map<IAgent, Integer> agsId,
      final int valObsId,
      final int valSimId,
      final int valInitId,
      final GamaMatrix<Double> fuzzytransitions,
      final Double distance,
      final IAgent agent,
      final IList<Object> valsInit,
      final IList<Object> valsObs,
      final IList<Object> valsSim,
      final IContainer.Addressable<Integer, IAgent> agents,
      final int nbCat) {
    double xa = 0.0;
    double xs = 0.0;
    double[] XaXs = new double[2];
    double sizeNorm = FastMath.sqrt(agent.getEnvelope().getArea());
    List<IAgent> neighbors =
        distance == 0 || filter == null
            ? new ArrayList<IAgent>()
            : new ArrayList<IAgent>(
                scope.getTopology().getNeighborsOf(scope, agent, distance, filter));

    Map<IAgent, Double> distancesCoeff = new TOrderedHashMap<IAgent, Double>();
    distancesCoeff.put(agent, 1.0);
    for (IAgent ag : neighbors) {
      double euclidDist = agent.getLocation().euclidianDistanceTo(ag.getLocation());
      distancesCoeff.put(ag, 1 / (1.0 + euclidDist / sizeNorm));
    }
    for (IAgent ag : distancesCoeff.keySet()) {
      int id = agsId.get(ag);
      Object valI = valsInit.get(id);
      Object valO = valsObs.get(id);
      Object valS = valsSim.get(id);
      int valOId = categoriesId.get(valO);
      int valSId = categoriesId.get(valS);
      int valIId = categoriesId.get(valI);
      double dist = distancesCoeff.get(ag);
      double valxatmp =
          fuzzyTransition(scope, fuzzytransitions, nbCat, valInitId, valSimId, valIId, valOId)
              * dist;
      double valxstmp =
          fuzzyTransition(scope, fuzzytransitions, nbCat, valInitId, valObsId, valIId, valSId)
              * dist;

      if (valxatmp > xa) {
        xa = valxatmp;
      }
      if (valxstmp > xs) {
        xs = valxstmp;
      }
    }

    XaXs[0] = xa;
    XaXs[1] = xs;
    return XaXs;
  }
Exemplo n.º 4
0
  protected String evaluateTransitions(final IScope scope) throws GamaRuntimeException {
    final IAgent agent = scope.getAgentScope();
    for (int i = 0; i < transitionsSize; i++) {
      final FsmTransitionStatement transition = transitions.get(i);

      if (transition.evaluatesTrueOn(scope)) {
        final String futureState = transition.getName();
        haltOn(scope);
        transition.executeOn(scope);
        scope.setAgentVarValue(agent, STATE, futureState);
        return futureState;
      }
    }
    if (!agent.dead()) {
      scope.saveAllVarValuesIn((Map) agent.getAttribute(STATE_MEMORY));
    }
    return name;
  }
Exemplo n.º 5
0
 @Override
 public IPopulation getPopulation(final IScope scope) {
   final IAgent a = scope.getAgentScope();
   IPopulation result = null;
   if (a != null) {
     // AD 19/09/13 Patch to allow experiments to gain access to the simulation populations
     result = a.getPopulationFor(this);
   }
   return result;
 }
Exemplo n.º 6
0
 @operator(
     value = {IKeyword.AT, "@"},
     type = ITypeProvider.FIRST_CONTENT_TYPE)
 @doc(
     deprecated =
         "The use of at on a species is deprecated, please use it one a population instead (list(species_name) instead of species_name)")
 public static IAgent at(final IScope scope, final ISpecies s, final GamaPoint val)
     throws GamaRuntimeException {
   return scope.getAgentScope().getPopulationFor(s).getAgent(scope, val);
 }
Exemplo n.º 7
0
  private static int buildRings(
      final IScope scope,
      final IAgentFilter filter,
      final Double distance,
      final List<Double> rings,
      final Map<Double, Integer> ringsPn,
      final IAddressableContainer<Integer, IAgent, Integer, IAgent> agents) {

    IList<ILocation> locs = GamaListFactory.create(Types.POINT);
    for (IAgent ag : agents.iterable(scope)) {
      locs.add(ag.getLocation());
    }
    ILocation centralLoc = (ILocation) Stats.getMean(scope, locs);
    IAgent centralAg = scope.getTopology().getAgentClosestTo(scope, centralLoc, filter);
    List<IAgent> neighbors =
        distance == 0 || filter == null
            ? new ArrayList<IAgent>()
            : new ArrayList<IAgent>(
                scope.getTopology().getNeighborsOf(scope, centralAg, distance, filter));

    for (IAgent ag : neighbors) {
      double dist = centralLoc.euclidianDistanceTo(ag.getLocation());
      if (dist == 0) {
        continue;
      }
      if (!rings.contains(dist)) {
        rings.add(dist);
        ringsPn.put(dist, 1);
      } else {
        ringsPn.put(dist, 1 + ringsPn.get(dist));
      }
    }
    Collections.sort(rings);

    for (int i = 1; i < rings.size(); i++) {
      double dist = rings.get(i);
      double dist1 = rings.get(i - 1);
      ringsPn.put(dist, ringsPn.get(dist) + ringsPn.get(dist1));
    }

    return rings.size();
  }
Exemplo n.º 8
0
 @Override
 public IList<ISpecies> getSubSpecies(final IScope scope) {
   IList<ISpecies> subspecies = GamaListFactory.create(Types.SPECIES);
   GamlModelSpecies model = (GamlModelSpecies) scope.getModel().getSpecies();
   for (ISpecies s : model.getAllSpecies().values()) {
     if (s.getParentSpecies() == this) {
       subspecies.add(s);
     }
   }
   return subspecies;
 }
Exemplo n.º 9
0
 @Override
 public IList listValue(final IScope scope, final IType contentsType, final boolean copy)
     throws GamaRuntimeException {
   // return getPopulation(scope).listValue(scope, contentsType);
   // hqnghi 16/04/14
   IPopulation pop = getPopulation(scope);
   if (pop == null) {
     pop = scope.getSimulationScope().getPopulationFor(contentsType.getName());
   }
   return pop.listValue(scope, contentsType, false);
   // end-hqnghi
 }
Exemplo n.º 10
0
  @operator(
      value = {"clustering_em"},
      content_type = IType.LIST,
      category = {IOperatorCategory.STATISTICAL},
      concept = {IConcept.STATISTIC})
  @doc(
      value =
          "A list of agent groups clustered by EM Algorithm based on the given attributes. Some paremeters can be defined: "
              + "max_iterations: the maximum number of iterations to perform;"
              + "num_clusters: the number of clusters; minStdDev: minimum allowable standard deviation",
      examples = {
        @example(
            value =
                "clustering_em([ag1, ag2, ag3, ag4, ag5],[\"size\",\"age\", \"weight\"],[\"max_iterations\"::10, \"num_clusters\"::3])",
            equals = "for example, can return [[ag1, ag3], [ag2], [ag4, ag5]]",
            isExecutable = false)
      },
      see = {
        "clustering_xmeans",
        "clustering_simple_kmeans",
        "clustering_farthestFirst",
        "clustering_DBScan",
        "clustering_cobweb"
      })
  public static IList<IList<IAgent>> primClusteringEM(
      final IScope scope,
      final IAddressableContainer<Integer, IAgent, Integer, IAgent> agents,
      final IList<String> attributes,
      final GamaMap<String, Object> parameters) {
    EM em = new EM();
    em.setSeed(Cast.asInt(scope, scope.getRandom().getSeed()));

    if (parameters != null) {
      try {

        if (parameters.containsKey("max_iterations")) {
          em.setMaxIterations(Cast.asInt(scope, parameters.get("max_iterations")));
        }
        if (parameters.containsKey("num_clusters")) {
          em.setNumClusters(Cast.asInt(scope, parameters.get("num_clusters")));
        }
        if (parameters.containsKey("minStdDev")) {
          em.setMinStdDev(Cast.asFloat(scope, parameters.get("minStdDev")));
        }
      } catch (Exception e) {

      }
    }
    IList<IList<IAgent>> groupes = clusteringUsingWeka(scope, em, attributes, agents);
    return groupes;
  }
Exemplo n.º 11
0
 @Override
 public GamaMap mapValue(
     final IScope scope, final IType keyType, final IType contentsType, final boolean copy)
     throws GamaRuntimeException {
   final IList<IAgent> agents = listValue(scope, contentsType, false);
   // Default behavior : Returns a map containing the names of agents as keys and the agents
   // themselves as values
   final GamaMap result =
       GamaMapFactory.create(Types.STRING, scope.getModelContext().getTypeNamed(getName()));
   for (final IAgent agent : agents.iterable(scope)) {
     result.put(agent.getName(), agent);
   }
   return result;
 }
Exemplo n.º 12
0
  @operator(
      value = {"clustering_cobweb"},
      content_type = IType.LIST,
      category = {IOperatorCategory.STATISTICAL},
      concept = {IConcept.STATISTIC})
  @doc(
      value =
          "A list of agent groups clusteredby CobWeb Algorithm based on the given attributes. Some paremeters can be defined: "
              + "acuity: minimum standard deviation for numeric attributes; "
              + "cutoff: category utility threshold by which to prune nodes seed",
      examples = {
        @example(
            value =
                "clustering_cobweb([ag1, ag2, ag3, ag4, ag5],[\"size\",\"age\", \"weight\"],[\"acuity\"::3.0, \"cutoff\"::0.5)",
            equals = "for example, can return [[ag1, ag3], [ag2], [ag4, ag5]]",
            isExecutable = false)
      },
      see = {
        "clustering_xmeans",
        "clustering_em",
        "clustering_farthestFirst",
        "clustering_simple_kmeans",
        "clustering_cobweb"
      })
  public static IList<IList<IAgent>> primClusteringCobweb(
      final IScope scope,
      final IAddressableContainer<Integer, IAgent, Integer, IAgent> agents,
      final IList<String> attributes,
      final GamaMap<String, Object> parameters) {
    Cobweb cobweb = new Cobweb();
    cobweb.setSeed(Cast.asInt(scope, scope.getRandom().getSeed()));

    if (parameters != null) {
      try {
        if (parameters.containsKey("acuity")) {
          cobweb.setAcuity(Cast.asFloat(scope, parameters.get("acuity")));
        }
        if (parameters.containsKey("cutoff")) {
          cobweb.setCutoff(Cast.asFloat(scope, parameters.get("cutoff")));
        }
      } catch (Exception e) {
      }
    }

    IList<IList<IAgent>> groupes = clusteringUsingWeka(scope, cobweb, attributes, agents);

    return groupes;
  }
Exemplo n.º 13
0
 public int getDate(IScope scope) {
   return scope.getClock().getCycle();
 }
Exemplo n.º 14
0
  private static double computeSimilarity(
      final IScope scope,
      final IAgentFilter filter,
      final Double distance,
      final IList<Object> vals1,
      final IList<Object> vals2,
      final IAddressableContainer<Integer, IAgent, Integer, IAgent> agents,
      final int nbCat,
      final int nb,
      final double[][] crispVector1,
      final double[][] crispVector2,
      final boolean[] sim,
      final double[][] fuzzyVector1,
      final double[][] fuzzyVector2,
      final IList<Double> similarities,
      final IList<Object> weights) {
    Map<IAgent, Integer> agsId = new TOrderedHashMap<IAgent, Integer>();
    for (int i = 0; i < agents.length(scope); i++) {
      agsId.put(agents.get(scope, i), i);
    }

    for (int i = 0; i < nb; i++) {
      if (sim[i]) {
        similarities.add(1.0);
      } else {
        IAgent agent = agents.get(scope, i);
        // double sizeNorm = agent.getPerimeter() / 4.0;
        double sizeNorm = FastMath.sqrt(agent.getEnvelope().getArea());
        List<IAgent> neighbors =
            distance == 0 || filter == null
                ? new ArrayList<IAgent>()
                : new ArrayList<IAgent>(
                    scope.getTopology().getNeighborsOf(scope, agent, distance, filter));

        Map<IAgent, Double> distancesCoeff = new TOrderedHashMap<IAgent, Double>();
        distancesCoeff.put(agent, 1.0);
        for (IAgent ag : neighbors) {
          double euclidDist = agent.getLocation().euclidianDistanceTo(ag.getLocation());
          distancesCoeff.put(ag, 1 / (1.0 + euclidDist / sizeNorm));
        }
        for (int j = 0; j < nbCat; j++) {
          double max1 = 0.0;
          double max2 = 0.0;
          for (IAgent ag : neighbors) {
            int id = agsId.get(ag);
            double val1 = crispVector1[id][j] * distancesCoeff.get(ag);
            double val2 = crispVector2[id][j] * distancesCoeff.get(ag);

            if (val1 > max1) {
              max1 = val1;
            }
            if (val2 > max2) {
              max2 = val2;
            }
          }
          fuzzyVector1[i][j] = max1;
          fuzzyVector2[i][j] = max2;
        }
        double s1Max = -1 * Double.MAX_VALUE;
        double s2Max = -1 * Double.MAX_VALUE;

        for (int j = 0; j < nbCat; j++) {
          double s1 = FastMath.min(fuzzyVector1[i][j], crispVector2[i][j]);
          double s2 = FastMath.min(fuzzyVector2[i][j], crispVector1[i][j]);
          if (s1 > s1Max) {
            s1Max = s1;
          }
          if (s2 > s2Max) {
            s2Max = s2;
          }
        }
        similarities.add(FastMath.min(s1Max, s2Max));
      }
    }
    double meanSimilarity = 0;
    double total = 0;
    for (int i = 0; i < nb; i++) {
      double weight = weights == null ? 1.0 : Cast.asFloat(scope, weights.get(i));
      double val = weight * similarities.get(i);
      total += weight;
      meanSimilarity += val;
    }
    meanSimilarity /= total;
    return meanSimilarity;
  }
Exemplo n.º 15
0
  @operator(
      value = {"clustering_xmeans"},
      content_type = IType.LIST,
      category = {IOperatorCategory.STATISTICAL},
      concept = {IConcept.STATISTIC})
  @doc(
      value =
          "A list of agent groups clustered by X-Means Algorithm based on the given attributes. Some paremeters can be defined: bin_value: value given for true value of boolean attributes; cut_off_factor: the cut-off factor to use;"
              + "distance_f: The distance function to use. 4 possible distance functions: euclidean (by default) ; 'chebyshev', 'manhattan' or 'levenshtein'; "
              + "max_iterations: the maximum number of iterations to perform; max_kmeans: the maximum number of iterations to perform in KMeans; max_kmeans_for_children: the maximum number of iterations KMeans that is performed on the child centers;"
              + "max_num_clusters: the maximum number of clusters; min_num_clusters: the minimal number of clusters",
      examples = {
        @example(
            value =
                "clustering_xmeans([ag1, ag2, ag3, ag4, ag5],[\"size\",\"age\", \"weight\", \"is_male\"],[\"bin_value\"::1.0, \"distance_f\"::\"manhattan\", \"max_num_clusters\"::10, \"min_num_clusters\"::2])",
            equals = "for example, can return [[ag1, ag3], [ag2], [ag4, ag5]]",
            isExecutable = false)
      },
      see = {
        "clustering_simple_kmeans",
        "clustering_em",
        "clustering_farthestFirst",
        "clustering_DBScan",
        "clustering_cobweb"
      })
  public static IList<IList<IAgent>> primClusteringXMeans(
      final IScope scope,
      final IAddressableContainer<Integer, IAgent, Integer, IAgent> agents,
      final IList<String> attributes,
      final GamaMap<String, Object> parameters)
      throws GamaRuntimeException {
    XMeans xmeans = new XMeans();
    xmeans.setSeed(Cast.asInt(scope, scope.getRandom().getSeed()));

    if (parameters != null) {
      if (parameters.containsKey("bin_value")) {
        xmeans.setBinValue(Cast.asFloat(scope, parameters.get("bin_value")));
      }
      if (parameters.containsKey("cut_off_factor")) {
        xmeans.setCutOffFactor(Cast.asFloat(scope, parameters.get("cut_off_factor")));
      }

      if (parameters.containsKey("distance_f")) {
        String distanceFct = Cast.asString(scope, parameters.get("distance_f"));
        if (distanceFct.equals("chebyshev")) {
          xmeans.setDistanceF(new ChebyshevDistance());
        } else if (distanceFct.equals("manhattan")) {
          xmeans.setDistanceF(new ManhattanDistance());
        } else if (distanceFct.equals("levenshtein")) {
          xmeans.setDistanceF(new EditDistance());
        }
      }
      if (parameters.containsKey("max_iterations")) {
        try {
          xmeans.setMaxIterations(Cast.asInt(scope, parameters.get("max_iterations")));
        } catch (Exception e) {
        }
      }
      if (parameters.containsKey("max_kmeans")) {
        xmeans.setMaxKMeans(Cast.asInt(scope, parameters.get("max_kmeans")));
      }
      if (parameters.containsKey("max_kmeans_for_children")) {
        xmeans.setMaxKMeansForChildren(
            Cast.asInt(scope, parameters.get("max_kmeans_for_children")));
      }
      if (parameters.containsKey("max_num_clusters")) {
        xmeans.setMaxNumClusters(Cast.asInt(scope, parameters.get("max_num_clusters")));
      }
      if (parameters.containsKey("min_num_clusters")) {
        xmeans.setMinNumClusters(Cast.asInt(scope, parameters.get("min_num_clusters")));
      }
    }

    IList<IList<IAgent>> groupes = clusteringUsingWeka(scope, xmeans, attributes, agents);

    return groupes;
  }
Exemplo n.º 16
0
  private static void computeXaXsTransitions(
      final IScope scope,
      final IAgentFilter filter,
      final GamaMatrix<Double> fuzzytransitions,
      final Double distance,
      final IContainer<Integer, IAgent> agents,
      final int nbCat,
      final Map<List<Integer>, Map<Double, Double>> XaPerTransition,
      final Map<List<Integer>, Map<Double, Double>> XsPerTransition,
      final Set<Double> Xvals) {

    IList<ILocation> locs = GamaListFactory.create(Types.POINT);
    for (IAgent ag : agents.iterable(scope)) {
      locs.add(ag.getLocation());
    }
    ILocation centralLoc = (ILocation) Stats.getMean(scope, locs);
    if (filter != null) {
      IAgent centralAg = scope.getTopology().getAgentClosestTo(scope, centralLoc, filter);
      List<IAgent> neighbors =
          distance == 0
              ? new ArrayList<IAgent>()
              : new ArrayList<IAgent>(
                  scope.getTopology().getNeighborsOf(scope, centralAg, distance, filter));
      double sizeNorm = FastMath.sqrt(centralAg.getEnvelope().getArea());

      Map<IAgent, Double> distancesCoeff = new TOrderedHashMap<IAgent, Double>();
      distancesCoeff.put(centralAg, 1.0);
      for (IAgent ag : neighbors) {
        double euclidDist = centralAg.getLocation().euclidianDistanceTo(ag.getLocation());
        double dist = 1 / (1.0 + euclidDist / sizeNorm);
        distancesCoeff.put(ag, dist);
      }

      for (int i = 0; i < nbCat; i++) {
        for (int j = 0; j < nbCat; j++) {
          for (int k = 0; k < nbCat; k++) {
            List<Integer> ca = new ArrayList();
            ca.add(i);
            ca.add(j);
            ca.add(k);
            double xa = 0;
            double xs = 0;
            for (IAgent ag : distancesCoeff.keySet()) {
              double dist = distancesCoeff.get(ag);
              double xatmp = fuzzyTransition(scope, fuzzytransitions, nbCat, i, k, i, j) * dist;
              double xstmp = fuzzyTransition(scope, fuzzytransitions, nbCat, i, j, i, k) * dist;
              if (xatmp > xa) {
                xa = xatmp;
              }
              if (xstmp > xs) {
                xs = xstmp;
              }
            }
            if (xa > 0) {

              Map<Double, Double> mapxa = XaPerTransition.get(ca);
              if (mapxa == null) {
                mapxa = new TOrderedHashMap<Double, Double>();
                mapxa.put(xa, 1.0);
                XaPerTransition.put(ca, mapxa);
              } else {
                if (mapxa.containsKey(xa)) {
                  mapxa.put(xa, mapxa.get(xa) + 1.0);
                } else {
                  mapxa.put(xa, 1.0);
                }
              }
              Xvals.add(xa);
            }
            if (xs > 0) {
              Map<Double, Double> mapxs = XsPerTransition.get(ca);
              if (mapxs == null) {
                mapxs = new TOrderedHashMap<Double, Double>();
                mapxs.put(xs, 1.0);
                XsPerTransition.put(ca, mapxs);
              } else {
                if (mapxs.containsKey(xa)) {
                  mapxs.put(xs, mapxs.get(xs) + 1.0);
                } else {
                  mapxs.put(xs, 1.0);
                }
              }
              Xvals.add(xs);
            }
          }
        }
      }
    }
  }
Exemplo n.º 17
0
 @Override
 public Object value(final IScope scope) {
   //		return scope.getSimulationScope();
   IAgent sc = scope.getAgentScope();
   return sc.getScope().getRoot().getScope().getSimulationScope();
 }
Exemplo n.º 18
0
  @operator(
      value = {"clustering_simple_kmeans"},
      content_type = IType.LIST,
      category = {IOperatorCategory.STATISTICAL},
      concept = {IConcept.STATISTIC})
  @doc(
      value =
          "A list of agent groups clustered by K-Means Algorithm based on the given attributes. Some paremeters can be defined: "
              + "distance_f: The distance function to use. 4 possible distance functions: euclidean (by default) ; 'chebyshev', 'manhattan' or 'levenshtein'; "
              + "dont_replace_missing_values: if false, replace missing values globally with mean/mode; max_iterations: the maximum number of iterations to perform;"
              + "num_clusters: the number of clusters",
      examples = {
        @example(
            value =
                "clustering_simple_kmeans([ag1, ag2, ag3, ag4, ag5],[\"size\",\"age\", \"weight\"],[\"distance_f\"::\"manhattan\", \"num_clusters\"::3])",
            equals = "for example, can return [[ag1, ag3], [ag2], [ag4, ag5]]",
            isExecutable = false)
      },
      see = {
        "clustering_xmeans",
        "clustering_em",
        "clustering_farthestFirst",
        "clustering_DBScan",
        "clustering_cobweb"
      })
  public static IList<IList<IAgent>> primClusteringSimpleKMeans(
      final IScope scope,
      final IAddressableContainer<Integer, IAgent, Integer, IAgent> agents,
      final IList<String> attributes,
      final GamaMap<String, Object> parameters) {
    SimpleKMeans kmeans = new SimpleKMeans();
    kmeans.setSeed(Cast.asInt(scope, scope.getRandom().getSeed()));

    if (parameters != null) {
      try {
        if (parameters.containsKey("distance_f")) {
          String distanceFct = Cast.asString(scope, parameters.get("distance_f"));
          if (distanceFct.equals("chebyshev")) {
            kmeans.setDistanceFunction(new ChebyshevDistance());
          } else if (distanceFct.equals("manhattan")) {
            kmeans.setDistanceFunction(new ManhattanDistance());
          } else if (distanceFct.equals("levenshtein")) {
            kmeans.setDistanceFunction(new EditDistance());
          }
        }
        if (parameters.containsKey("dont_replace_missing_values")) {
          kmeans.setDontReplaceMissingValues(
              Cast.asBool(scope, parameters.get("dont_replace_missing_values")));
        }
        if (parameters.containsKey("max_iterations")) {
          kmeans.setMaxIterations(Cast.asInt(scope, parameters.get("max_iterations")));
        }
        if (parameters.containsKey("num_clusters")) {
          kmeans.setNumClusters(Cast.asInt(scope, parameters.get("num_clusters")));
        }
      } catch (Exception e) {
      }
    }

    IList<IList<IAgent>> groupes = clusteringUsingWeka(scope, kmeans, attributes, agents);

    return groupes;
  }