/**
  * Return Semantic Type of the concept code passed in
  *
  * @param conceptCode
  * @return
  */
 public String getSemanticType(String conceptCode) {
   Vector<String> code_vec = new Vector<String>();
   code_vec.add(conceptCode);
   HashMap<?, ?> map =
       DataUtils.getPropertyValuesForCodes(
           Constants.CODING_SCHEME_NAME, null, code_vec, SEMANTIC_TYPE);
   return (String) map.get(conceptCode);
 }
예제 #2
0
  /**
   * Delete {@code books} from Realm, along with any {@link RBookListItem}s which may exist for
   * them, and their cover images if they have them. Optionally delete the real files they were
   * imported from as well.
   *
   * @param realm Instance of Realm to use.
   * @param books Books to delete.
   * @param deleteRealFiles If true, also delete the books' corresponding files.
   */
  public static void deleteBooks(Realm realm, Collection<RBook> books, boolean deleteRealFiles) {
    // Null checks.
    if (books == null || books.isEmpty()) return;

    // If deleteRealFiles is true, check permissions before doing anything.
    if (deleteRealFiles
        && !Util.checkForStoragePermAndFireEventIfNeeded(R.id.action_execute_deferred)) {
      //noinspection unchecked    Defer this action while we ask for permission.
      setDeferredAction(params -> deleteBooks(realm, (Collection<RBook>) params[0], true), books);
      return;
    }

    List<String> relPaths = new ArrayList<>(books.size());
    // Delete what we created.
    realm.executeTransaction(
        tRealm -> {
          for (RBook book : books) {
            // Delete any RBookListItems which may exist for these books.
            tRealm
                .where(RBookListItem.class)
                .contains("book.relPath", book.relPath)
                .findAll()
                .deleteAllFromRealm();
            // Get the relative path of the book, in case we wish to delete the real files too.
            String relPath = book.relPath;
            relPaths.add(relPath);
            // Be sure to delete the cover file, if we have one.
            if (book.hasCoverImage) DataUtils.deleteCoverImage(relPath);
            // Delete the actual RBook from Realm.
            book.deleteFromRealm();
          }
        });

    // If the user wants us to, also try to delete the corresponding files from the device.
    if (deleteRealFiles) {
      for (String relPath : relPaths) {
        File file = Util.getFileFromRelPath(relPath);
        if (file != null) // noinspection ResultOfMethodCallIgnored
        file.delete();
      }
    }
  }
예제 #3
0
 /**
  * Convert the given object into a value appropriate for being defined as the value of a variable
  * in an XQuery. This will extract a sequence out of all database objects, convert collections and
  * arrays into sequences recursively, convert <code>null</code> into an empty sequence, and pass
  * other objects through untouched. Convertible objects that are defined in the JDK will be
  * automatically converted by eXist.
  *
  * @see org.exist.xquery.XPathUtil#javaObjectToXPath(Object, XQueryContext, boolean)
  * @param o the object to convert to a database value
  * @return the converted value, ready for assignment to an XQuery variable
  */
 @SuppressWarnings("unchecked")
 private Object convertValue(Object o) {
   if (o == null) return Collections.emptyList();
   if (o instanceof Resource) {
     try {
       return ((Resource) o).convertToSequence();
     } catch (UnsupportedOperationException e) {
       return o;
     }
   }
   List<Object> list = null;
   if (o instanceof Collection) list = new ArrayList<Object>((Collection) o);
   else if (o instanceof Object[]) list = new ArrayList<Object>(Arrays.asList((Object[]) o));
   if (list != null) {
     for (ListIterator<Object> it = list.listIterator(); it.hasNext(); ) {
       it.set(convertValue(it.next()));
     }
     return list;
   }
   return DataUtils.toXMLObject(o);
 }
예제 #4
0
  public void rtest4() {
    System.out.println("SHD\tP");
    //        System.out.println("MB1\tMB2\tMB3\tMB4\tMB5\tMB6");

    Graph mim = DataGraphUtils.randomSingleFactorModel(5, 5, 8, 0, 0, 0);

    Graph mimStructure = structure(mim);

    SemPm pm = new SemPm(mim);
    SemImInitializationParams params = new SemImInitializationParams();
    params.setCoefRange(0.5, 1.5);

    NumberFormat nf = new DecimalFormat("0.0000");

    int totalError = 0;
    int errorCount = 0;

    int maxScore = 0;
    int maxNumMeasures = 0;
    double maxP = 0.0;

    for (int r = 0; r < 1; r++) {
      SemIm im = new SemIm(pm, params);

      DataSet data = im.simulateData(1000, false);

      mim = GraphUtils.replaceNodes(mim, data.getVariables());
      List<List<Node>> trueClusters = MimUtils.convertToClusters2(mim);

      CovarianceMatrix _cov = new CovarianceMatrix(data);

      ICovarianceMatrix cov = DataUtils.reorderColumns(_cov);

      String algorithm = "FOFC";
      Graph searchGraph;
      List<List<Node>> partition;

      if (algorithm.equals("FOFC")) {
        FindOneFactorClusters fofc =
            new FindOneFactorClusters(cov, TestType.TETRAD_WISHART, 0.001f);
        searchGraph = fofc.search();
        searchGraph = GraphUtils.replaceNodes(searchGraph, data.getVariables());
        partition = MimUtils.convertToClusters2(searchGraph);
      } else if (algorithm.equals("BPC")) {
        TestType testType = TestType.TETRAD_WISHART;
        TestType purifyType = TestType.TETRAD_BASED2;

        BuildPureClusters bpc = new BuildPureClusters(data, 0.001, testType, purifyType);
        searchGraph = bpc.search();

        partition = MimUtils.convertToClusters2(searchGraph);
      } else {
        throw new IllegalStateException();
      }

      mimStructure = GraphUtils.replaceNodes(mimStructure, data.getVariables());

      List<String> latentVarList = reidentifyVariables(mim, data, partition, 2);

      Graph mimbuildStructure;

      Mimbuild2 mimbuild = new Mimbuild2();
      mimbuild.setAlpha(0.001);
      mimbuild.setMinClusterSize(3);

      try {
        mimbuildStructure = mimbuild.search(partition, latentVarList, cov);
      } catch (Exception e) {
        e.printStackTrace();
        continue;
      }

      mimbuildStructure = GraphUtils.replaceNodes(mimbuildStructure, data.getVariables());
      mimbuildStructure = condense(mimStructure, mimbuildStructure);

      //            Graph mimSubgraph = new EdgeListGraph(mimStructure);
      //
      //            for (Node node : mimSubgraph.getNodes()) {
      //                if (!mimStructure.getNodes().contains(node)) {
      //                    mimSubgraph.removeNode(node);
      //                }
      //            }

      int shd = SearchGraphUtils.structuralHammingDistance(mimStructure, mimbuildStructure);
      boolean impureCluster = containsImpureCluster(partition, trueClusters);
      double pValue = mimbuild.getpValue();
      boolean pBelow05 = pValue < 0.05;
      boolean numClustersGreaterThan5 = partition.size() != 5;
      boolean error = false;

      //            boolean condition = impureCluster || numClustersGreaterThan5 || pBelow05;
      //            boolean condition = numClustersGreaterThan5 || pBelow05;
      boolean condition = numClustered(partition) == 40;

      if (!condition && (shd > 5)) {
        error = true;
      }

      if (!condition) {
        totalError += shd;
        errorCount++;
      }

      //            if (numClustered(partition) > maxNumMeasures) {
      //                maxNumMeasures = numClustered(partition);
      //                maxP = pValue;
      //                maxScore = shd;
      //                System.out.println("maxNumMeasures = " + maxNumMeasures);
      //                System.out.println("maxScore = " + maxScore);
      //                System.out.println("maxP = " + maxP);
      //                System.out.println("clusters = " + clusterSizes(partition, trueClusters));
      //            }
      //            else
      if (pValue > maxP) {
        maxScore = shd;
        maxP = mimbuild.getpValue();
        maxNumMeasures = numClustered(partition);
        System.out.println("maxNumMeasures = " + maxNumMeasures);
        System.out.println("maxScore = " + maxScore);
        System.out.println("maxP = " + maxP);
        System.out.println("clusters = " + clusterSizes(partition, trueClusters));
      }

      System.out.print(
          shd
              + "\t"
              + nf.format(pValue)
              + " "
              //                            + (error ? 1 : 0) + " "
              //                            + (pBelow05 ? "P < 0.05 " : "")
              //                            + (impureCluster ? "Impure cluster " : "")
              //                            + (numClustersGreaterThan5 ? "# Clusters != 5 " : "")
              //                            + clusterSizes(partition, trueClusters)
              + numClustered(partition));

      System.out.println();
    }

    System.out.println("\nAvg SHD for not-flagged cases = " + (totalError / (double) errorCount));

    System.out.println("maxNumMeasures = " + maxNumMeasures);
    System.out.println("maxScore = " + maxScore);
    System.out.println("maxP = " + maxP);
  }
예제 #5
0
  public void rtest3() {
    Node x = new GraphNode("X");
    Node y = new GraphNode("Y");
    Node z = new GraphNode("Z");
    Node w = new GraphNode("W");

    List<Node> nodes = new ArrayList<Node>();
    nodes.add(x);
    nodes.add(y);
    nodes.add(z);
    nodes.add(w);

    Graph g = new EdgeListGraph(nodes);
    g.addDirectedEdge(x, y);
    g.addDirectedEdge(x, z);
    g.addDirectedEdge(y, w);
    g.addDirectedEdge(z, w);

    Graph maxGraph = null;
    double maxPValue = -1.0;
    ICovarianceMatrix maxLatentCov = null;

    Graph mim = DataGraphUtils.randomMim(g, 8, 0, 0, 0, true);
    //        Graph mim = DataGraphUtils.randomSingleFactorModel(5, 5, 8, 0, 0, 0);
    Graph mimStructure = structure(mim);
    SemPm pm = new SemPm(mim);

    System.out.println("\n\nTrue graph:");
    System.out.println(mimStructure);

    SemImInitializationParams params = new SemImInitializationParams();
    params.setCoefRange(0.5, 1.5);

    SemIm im = new SemIm(pm, params);

    int N = 1000;

    DataSet data = im.simulateData(N, false);

    CovarianceMatrix cov = new CovarianceMatrix(data);

    for (int i = 0; i < 1; i++) {

      ICovarianceMatrix _cov = DataUtils.reorderColumns(cov);
      List<List<Node>> partition;

      FindOneFactorClusters fofc = new FindOneFactorClusters(_cov, TestType.TETRAD_WISHART, .001);
      fofc.search();
      partition = fofc.getClusters();
      System.out.println(partition);

      List<String> latentVarList = reidentifyVariables(mim, data, partition, 2);

      Mimbuild2 mimbuild = new Mimbuild2();

      mimbuild.setAlpha(0.001);
      //            mimbuild.setMinimumSize(5);

      // To test knowledge.
      //            Knowledge knowledge = new Knowledge2();
      //            knowledge.setEdgeForbidden("L.Y", "L.W", true);
      //            knowledge.setEdgeRequired("L.Y", "L.Z", true);
      //            mimbuild.setKnowledge(knowledge);

      Graph mimbuildStructure = mimbuild.search(partition, latentVarList, _cov);

      double pValue = mimbuild.getpValue();
      System.out.println(mimbuildStructure);
      System.out.println("P = " + pValue);
      System.out.println("Latent Cov = " + mimbuild.getLatentsCov());

      if (pValue > maxPValue) {
        maxPValue = pValue;
        maxGraph = new EdgeListGraph(mimbuildStructure);
        maxLatentCov = mimbuild.getLatentsCov();
      }
    }

    System.out.println("\n\nTrue graph:");
    System.out.println(mimStructure);
    System.out.println("\nBest graph:");
    System.out.println(maxGraph);
    System.out.println("P = " + maxPValue);
    System.out.println("Latent Cov = " + maxLatentCov);
    System.out.println();
  }