Пример #1
0
 @operator(
     value = {"percent_absolute_deviation"},
     content_type = IType.FLOAT,
     category = {IOperatorCategory.MAP_COMPARAISON},
     concept = {IConcept.STATISTIC})
 @doc(
     value =
         "percent absolute deviation indicator for 2 series of values: percent_absolute_deviation(list_vals_observe,list_vals_sim)",
     examples = {
       @example(
           value = "percent_absolute_deviation([200,300,150,150,200],[250,250,100,200,200])",
           isExecutable = false)
     })
 public static double percentAbsoluteDeviation(
     final IScope scope, final IList<Double> vals1, final IList<Double> vals2) {
   if (vals1 == null || vals2 == null) {
     return 1;
   }
   int nb = vals1.size();
   if (nb != vals2.size()) {
     return 0;
   }
   double sum = 0;
   double coeff = 0;
   for (int i = 0; i < nb; i++) {
     double val1 = Cast.asFloat(scope, vals1.get(i));
     double val2 = Cast.asFloat(scope, vals2.get(i));
     coeff += val1;
     sum += FastMath.abs(val1 - val2) * 100.0;
   }
   if (coeff == 0) {
     return 0;
   }
   return sum / coeff;
 }
Пример #2
0
  private static double computePo(
      final IScope scope,
      final IAgentFilter filter,
      final Map<Object, Integer> categoriesId,
      final GamaMatrix<Double> fuzzytransitions,
      final Double distance,
      final IList<Object> valsInit,
      final IList<Object> valsObs,
      final IList<Object> valsSim,
      final IAddressableContainer<Integer, IAgent, Integer, IAgent> agents,
      final int nbCat,
      final int nb,
      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++) {
      Object valObs = valsObs.get(i);
      Object valSim = valsSim.get(i);
      Object valInit = valsInit.get(i);
      int valObsId = categoriesId.get(valObs);
      int valSimId = categoriesId.get(valSim);
      int valInitId = categoriesId.get(valInit);
      IAgent agent = agents.get(scope, i);
      double[] XaXs =
          computeXaXs(
              scope,
              filter,
              categoriesId,
              agsId,
              valObsId,
              valSimId,
              valInitId,
              fuzzytransitions,
              distance,
              agent,
              valsInit,
              valsObs,
              valsSim,
              agents,
              nbCat);
      similarities.add(FastMath.min(XaXs[0], XaXs[1]));
    }
    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;
  }
Пример #3
0
 private static void computeXYCrispVector(
     final IScope scope,
     final Map<Object, Integer> categoriesId,
     final List<Object> categories,
     final IList<Object> vals1,
     final IList<Object> vals2,
     final GamaMatrix<Double> fuzzycategories,
     final int nbCat,
     final int nb,
     final double[][] crispVector1,
     final double[][] crispVector2,
     final double[] X,
     final double[] Y,
     final boolean[] sim,
     final IList<Object> weights) {
   for (int j = 0; j < nbCat; j++) {
     X[j] = 0;
     Y[j] = 0;
   }
   double total = 0;
   for (int i = 0; i < nb; i++) {
     double weight = weights == null ? 1.0 : Cast.asFloat(scope, weights.get(i));
     total += weight;
     Object val1 = vals1.get(i);
     Object val2 = vals2.get(i);
     int indexVal1 = categoriesId.get(val1);
     int indexVal2 = categoriesId.get(val2);
     X[indexVal1] += weight;
     Y[indexVal2] += weight;
     for (int j = 0; j < nbCat; j++) {
       crispVector1[i][j] = Cast.asFloat(scope, fuzzycategories.get(scope, indexVal1, j));
       crispVector2[i][j] = Cast.asFloat(scope, fuzzycategories.get(scope, indexVal2, j));
     }
     if (val1.equals(val2)) {
       sim[i] = true;
     } else {
       sim[i] = false;
     }
   }
   for (int j = 0; j < nbCat; j++) {
     X[j] /= total;
     Y[j] /= total;
   }
 }
Пример #4
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;
  }
Пример #5
0
  @operator(
      value = {"kappa"},
      content_type = IType.FLOAT,
      category = {IOperatorCategory.MAP_COMPARAISON},
      concept = {})
  @doc(
      value =
          "kappa indicator for 2 map comparisons: kappa(list_vals1,list_vals2,categories, weights). Reference: Cohen, J. A coefficient of agreement for nominal scales. Educ. Psychol. Meas. 1960, 20. ",
      examples = {
        @example(
            value =
                "kappa([cat1,cat1,cat2,cat3,cat2],[cat2,cat1,cat2,cat1,cat2],[cat1,cat2,cat3], [1.0, 2.0, 3.0, 1.0, 5.0])",
            isExecutable = false)
      })
  public static double kappa(
      final IScope scope,
      final IList<Object> vals1,
      final IList<Object> vals2,
      final List<Object> categories,
      final IList<Object> weights) {
    if (vals1 == null || vals2 == null) {
      return 1;
    }
    int nb = vals1.size();
    if (nb != vals2.size()) {
      return 0;
    }
    int nbCat = categories.size();
    double[] X = new double[nbCat];
    double[] Y = new double[nbCat];
    double[][] contigency = new double[nbCat][nbCat];
    for (int j = 0; j < nbCat; j++) {
      X[j] = 0;
      Y[j] = 0;
      for (int k = 0; k < nbCat; k++) {
        contigency[j][k] = 0;
      }
    }

    Map<Object, Integer> categoriesId = new TOrderedHashMap<Object, Integer>();
    for (int i = 0; i < nbCat; i++) {
      categoriesId.put(categories.get(i), i);
    }
    double total = 0;
    for (int i = 0; i < nb; i++) {
      double weight = weights == null ? 1.0 : Cast.asFloat(scope, weights.get(i));
      total += weight;
      Object val1 = vals1.get(i);
      Object val2 = vals2.get(i);
      int indexVal1 = categoriesId.get(val1);
      int indexVal2 = categoriesId.get(val2);
      X[indexVal1] += weight;
      Y[indexVal2] += weight;
      contigency[indexVal1][indexVal2] += weight;
    }
    for (int j = 0; j < nbCat; j++) {
      X[j] /= total;
      Y[j] /= total;
      for (int k = 0; k < nbCat; k++) {
        contigency[j][k] /= total;
      }
    }
    double po = 0;
    double pe = 0;
    for (int i = 0; i < nbCat; i++) {
      po += contigency[i][i];
      pe += X[i] * Y[i];
    }
    if (pe == 1) {
      return 1;
    }
    return (po - pe) / (1 - pe);
  }
Пример #6
0
  @operator(
      value = {"fuzzy_kappa_sim"},
      content_type = IType.FLOAT,
      category = {IOperatorCategory.MAP_COMPARAISON},
      concept = {IConcept.MAP})
  @doc(
      value =
          "fuzzy kappa simulation indicator for 2 map comparisons: fuzzy_kappa_sim(agents_list,list_vals1,list_vals2, output_similarity_per_agents,fuzzy_transitions_matrix, fuzzy_distance, weights). Reference: Jasper van Vliet, Alex Hagen-Zanker, Jelle Hurkens, Hedwig van Delden, A fuzzy set approach to assess the predictive accuracy of land use simulations, Ecological Modelling, 24 July 2013, Pages 32-42, ISSN 0304-3800, ",
      examples = {
        @example(
            value =
                "fuzzy_kappa_sim([ag1, ag2, ag3, ag4, ag5], [cat1,cat1,cat2,cat3,cat2],[cat2,cat1,cat2,cat1,cat2], similarity_per_agents,[cat1,cat2,cat3],[[1,0,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0,0],[0,0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0,0],[0,0,0,0,0,1,0,0,0],[0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,0,1]], 2,[1.0,3.0,2.0,2.0,4.0])",
            isExecutable = false)
      })
  public static double fuzzyKappaSimulation(
      final IScope scope,
      final IAddressableContainer<Integer, IAgent, Integer, IAgent> agents,
      final IList<Object> valsInit,
      final IList<Object> valsObs,
      final IList<Object> valsSim,
      final IList<Double> similarities,
      final List<Object> categories,
      final GamaMatrix<Double> fuzzytransitions,
      final Double distance,
      final IList<Object> weights) {
    if (agents == null) {
      return 1;
    }
    int nb = agents.length(scope);
    if (nb < 1) {
      return 1;
    }
    similarities.clear();
    int nbCat = categories.size();
    double[] nbObs = new double[nbCat];
    double[] nbSim = new double[nbCat];
    double[] nbInit = new double[nbCat];
    double[][] nbInitObs = new double[nbCat][nbCat];
    double[][] nbInitSim = new double[nbCat][nbCat];
    Map<Object, Integer> categoriesId = new TOrderedHashMap<Object, Integer>();

    Map<List<Integer>, Map<Double, Double>> XaPerTransition =
        new TOrderedHashMap<List<Integer>, Map<Double, Double>>();
    Map<List<Integer>, Map<Double, Double>> XsPerTransition =
        new TOrderedHashMap<List<Integer>, Map<Double, Double>>();
    Set<Double> Xvals = new HashSet<Double>();
    for (int i = 0; i < nbCat; i++) {
      categoriesId.put(categories.get(i), i);
    }

    for (int i = 0; i < nbCat; i++) {
      nbInit[i] = 0;
      nbObs[i] = 0;
      nbSim[i] = 0;
      for (int j = 0; j < nbCat; j++) {
        nbInitObs[i][j] = 0;
        nbInitSim[i][j] = 0;
      }
    }
    IAgentFilter filter = In.list(scope, agents);
    double total = 0;
    for (int i = 0; i < nb; i++) {
      double weight = weights == null ? 1.0 : Cast.asFloat(scope, weights.get(i));
      total += weight;

      int idCatInit = categoriesId.get(valsInit.get(i));
      int idCatObs = categoriesId.get(valsObs.get(i));
      int idCatSim = categoriesId.get(valsSim.get(i));
      nbInit[idCatInit] += weight;
      nbSim[idCatSim] += weight;
      nbObs[idCatObs] += weight;
      nbInitObs[idCatInit][idCatObs] += weight;
      nbInitSim[idCatInit][idCatSim] += weight;
    }
    double po =
        computePo(
            scope,
            filter,
            categoriesId,
            fuzzytransitions,
            distance,
            valsInit,
            valsObs,
            valsSim,
            agents,
            nbCat,
            nb,
            similarities,
            weights);
    double pe = 0;
    computeXaXsTransitions(
        scope,
        filter,
        fuzzytransitions,
        distance,
        agents,
        nbCat,
        XaPerTransition,
        XsPerTransition,
        Xvals);
    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<Integer>();
          ca.add(i);
          ca.add(j);
          ca.add(k);
          Map<Double, Double> pmuXa = XaPerTransition.get(ca);
          Map<Double, Double> pmuXs = XsPerTransition.get(ca);
          double emu = 0;
          for (Double xval : Xvals) {
            double XaVal = pmuXa == null || !pmuXa.containsKey(xval) ? 0 : pmuXa.get(xval);
            double XsVal = pmuXs == null || !pmuXs.containsKey(xval) ? 0 : pmuXs.get(xval);
            double proba = xval * XaVal * XsVal;
            emu += proba;
          }

          double poas = nbInit[i] == 0 ? 0 : nbInitObs[i][j] / nbInit[i] * nbInitSim[i][k] / total;
          pe += emu * poas;
        }
      }
    }
    if (pe == 1) {
      return 1;
    }
    return (po - pe) / (1 - pe);
  }
Пример #7
0
 @operator(
     value = {"kappa_sim"},
     content_type = IType.FLOAT,
     category = {IOperatorCategory.MAP_COMPARAISON},
     concept = {})
 @doc(
     value =
         "kappa simulation indicator for 2 map comparisons: kappa(list_valsInits,list_valsObs,list_valsSim, categories, weights). Reference: van Vliet, J., Bregt, A.K. & Hagen-Zanker, A. (2011). Revisiting Kappa to account for change in the accuracy assessment of land-use change models, Ecological Modelling 222(8)",
     examples = {
       @example(
           value =
               "kappa([cat1,cat1,cat2,cat2,cat2],[cat2,cat1,cat2,cat1,cat3],[cat2,cat1,cat2,cat3,cat3], [cat1,cat2,cat3],[1.0, 2.0, 3.0, 1.0, 5.0])",
           isExecutable = false)
     })
 public static double kappaSimulation(
     final IScope scope,
     final IList<Object> valsInit,
     final IList<Object> valsObs,
     final IList<Object> valsSim,
     final List<Object> categories,
     final IList<Object> weights) {
   if (valsInit == null || valsObs == null || valsSim == null) {
     return 1;
   }
   int nb = valsInit.size();
   if (nb != valsObs.size() || nb != valsSim.size()) {
     return 0;
   }
   int nbCat = categories.size();
   double[] O = new double[nbCat];
   double[][] contigency = new double[nbCat][nbCat];
   double[][] contigencyOA = new double[nbCat][nbCat];
   double[][] contigencyOS = new double[nbCat][nbCat];
   for (int j = 0; j < nbCat; j++) {
     O[j] = 0;
     for (int k = 0; k < nbCat; k++) {
       contigency[j][k] = 0;
       contigencyOA[j][k] = 0;
       contigencyOS[j][k] = 0;
     }
   }
   Map<Object, Integer> categoriesId = new TOrderedHashMap<Object, Integer>();
   for (int i = 0; i < nbCat; i++) {
     categoriesId.put(categories.get(i), i);
   }
   double total = 0;
   for (int i = 0; i < nb; i++) {
     double weight = weights == null ? 1.0 : Cast.asFloat(scope, weights.get(i));
     total += weight;
     Object val1 = valsObs.get(i);
     Object val2 = valsSim.get(i);
     Object valO = valsInit.get(i);
     int indexVal1 = categoriesId.get(val1);
     int indexVal2 = categoriesId.get(val2);
     int indexValO = categoriesId.get(valO);
     O[indexValO] += weight;
     contigency[indexVal1][indexVal2] += weight;
     contigencyOA[indexValO][indexVal1] += weight;
     contigencyOS[indexValO][indexVal2] += weight;
   }
   for (int j = 0; j < nbCat; j++) {
     for (int k = 0; k < nbCat; k++) {
       contigency[j][k] /= total;
       if (O[j] > 0) {
         contigencyOA[j][k] /= O[j];
         contigencyOS[j][k] /= O[j];
       }
     }
     O[j] /= total;
   }
   double po = 0;
   double pe = 0;
   for (int j = 0; j < nbCat; j++) {
     po += contigency[j][j];
     double sum = 0;
     for (int i = 0; i < nbCat; i++) {
       sum += contigencyOA[j][i] * contigencyOS[j][i];
     }
     pe += O[j] * sum;
   }
   if (pe == 1) {
     return 1;
   }
   return (po - pe) / (1 - pe);
 }