示例#1
1
  public static void sendMail(String mailMessage) {

    String to = "*****@*****.**";
    String from = "FlotaWeb";
    String host = "mail.arabesque.ro";

    Properties properties = System.getProperties();
    properties.setProperty("mail.smtp.host", host);

    Session session = Session.getDefaultInstance(properties);

    try {
      MimeMessage message = new MimeMessage(session);

      message.setFrom(new InternetAddress(from));

      message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

      message.setSubject("Distributie");

      message.setText(mailMessage);

      Transport.send(message);

    } catch (MessagingException e) {
      logger.error(Utils.getStackTrace(e));
    }
  }
  public void addProductFromCategory() {
    SelectSportProduct.click();
    Utils.sleep(1);

    AddToBasket.click();
    Utils.sleep(1);
  }
  public void printTopWords(int k, String betaFile) {
    Arrays.fill(m_parentSstat, 0);
    Arrays.fill(m_childSstat, 0);

    System.out.println("print top words");
    for (_Doc d : m_trainSet) {
      if (d instanceof _ParentDoc2) {
        // print out topic assignment of parent
        printParentTopicAssignment((_ParentDoc2) d);
        for (int i = 0; i < number_of_topics; i++)
          m_parentSstat[i] += m_logSpace ? Math.exp(d.m_topics[i]) : d.m_topics[i];
      } else if (d instanceof _ChildDoc2) {
        // print out topic assignment of child
        printChildTopicAssignment((_ChildDoc2) d);
        for (int i = 0; i < number_of_topics; i++)
          m_childSstat[i] += m_logSpace ? Math.exp(d.m_topics[i]) : d.m_topics[i];
      }
    }

    Utils.L1Normalization(m_parentSstat);
    Utils.L1Normalization(m_childSstat);

    String parentBetaFile = betaFile.replace(".txt", "parent.txt");
    String childBetaFile = betaFile.replace(".txt", "child.txt");

    printParentTopWords(k, parentBetaFile);
    printChildTopWords(k, childBetaFile);

    String parentParameterFile = parentBetaFile.replace("beta", "parameter");
    String childParameterFile = childBetaFile.replace("beta", "parameter");
    printParameter(parentParameterFile, childParameterFile);
  }
示例#4
0
  protected int gradientUpdate(_Query query) {
    double diff;
    int i, trainSize = 0;

    // Step 1: calculate the ranking score
    for (_QUPair pair : query.m_docList) pair.score(m_weight);
    m_eval.eval(query);

    // Step 2: accumulate the lambdas for each URL
    for (_QUPair pair : query.m_docList) {
      diff = 0;
      if (pair.m_worseURLs != null) {
        for (_QUPair worseURL : pair.m_worseURLs) { // force to moving up
          diff += Utils.logistic(worseURL.m_score - pair.m_score) * m_eval.delta(pair, worseURL);
          trainSize++;
        }
      }

      if (pair.m_betterURLs != null) {
        for (_QUPair betterURL : pair.m_betterURLs) { // force to moving down
          diff -= Utils.logistic(pair.m_score - betterURL.m_score) * m_eval.delta(betterURL, pair);
          trainSize++;
        }
      }

      // Step 3: update weight according to this URL
      if (diff != 0) {
        for (i = 0; i < pair.m_rankFv.length; i++) m_g[i] -= diff * pair.m_rankFv[i];
      }
    }

    return trainSize;
  }
示例#5
0
  protected void evaluate() {
    double r;

    m_obj = 0;
    m_perf = 0;
    m_misorder = 0;

    for (_Query query : m_queries) {
      // calculate ranking score with latest weight
      for (_QUPair pair : query.m_docList) pair.score(m_weight);

      if ((r = m_eval.eval(query)) >= 0) // ranking score should already be calculated
      m_perf += r;

      for (_QUPair pair : query.m_docList) {
        if (pair.m_worseURLs != null) {
          for (_QUPair worseURL : pair.m_worseURLs) {
            if ((r = Utils.logistic(pair.m_score - worseURL.m_score)) > 0) m_obj += Math.log(r);
            if (pair.m_score <= worseURL.m_score) m_misorder++;
          }
        }

        if (pair.m_betterURLs != null) {
          for (_QUPair betterURL : pair.m_betterURLs) {
            if ((r = Utils.logistic(betterURL.m_score - pair.m_score)) > 0) m_obj += Math.log(r);
            if (pair.m_score >= betterURL.m_score) m_misorder++;
          }
        }
      }
    }
    m_misorder /= 2;
  }
示例#6
0
  /**
   * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
   *
   * @param request servlet request
   * @param response servlet response
   * @throws ServletException if a servlet-specific error occurs
   * @throws IOException if an I/O error occurs
   */
  protected void processRequest(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    try (PrintWriter out = response.getWriter()) {
      EmployeeWrapper emp = (EmployeeWrapper) request.getSession().getAttribute("emp");
      String deleteButtonFormatingClass = request.getParameter("deleteButtonFormatingClass");
      String deleteButtonMethod = request.getParameter("deleteButtonMethod");
      String identifier = request.getParameter("identifier");
      try {
        switch (identifier) {
          case "p":
            out.print(
                utils.Utils.loadContacts(
                    emp.getGarage().getGarageId(), deleteButtonFormatingClass, deleteButtonMethod));
            break;
          case "f":
            out.print(
                utils.Utils.loadFaxList(
                    emp.getGarage().getGarageId(), deleteButtonFormatingClass, deleteButtonMethod));

            break;
          case "e":
            out.print(
                utils.Utils.loadEmailList(
                    emp.getGarage().getGarageId(), deleteButtonFormatingClass, deleteButtonMethod));

            break;
        }

      } catch (Exception ex) {
        ex.printStackTrace();
        out.print(ex.getMessage());
      }
    }
  }
示例#7
0
  private void runServer() {
    String logFile = properties.getProperty("logFile");
    Utils.setLogFile(logFile, Server.class.getName());
    int port = Integer.parseInt(properties.getProperty("port"));
    String ip = properties.getProperty("serverIp");

    Logger.getLogger(Server.class.getName())
        .log(Level.INFO, "Server started. Listening on: " + port + ", bound to: " + ip);
    try {
      serverSocket = new ServerSocket();
      serverSocket.bind(new InetSocketAddress(ip, port));
      do {
        Socket socket = serverSocket.accept(); // Important Blocking call
        Logger.getLogger(Server.class.getName()).log(Level.INFO, "Connected to a client");

        ClientHandler tmpClient = new ClientHandler(socket, this);
        clients.add(tmpClient);
        tmpClient.start();

      } while (keepRunning);
    } catch (IOException ex) {
      Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      Utils.closeLogger(Server.class.getName());
    }
  }
示例#8
0
  /**
   * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
   *
   * @param request servlet request
   * @param response servlet response
   * @throws ServletException if a servlet-specific error occurs
   * @throws IOException if an I/O error occurs
   */
  protected void processRequest(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    HttpSession session = request.getSession();
    Connection conn = Utils.getStoredConnection(session);
    Utilisateur loginedUser = Utils.getLoginedUser(session);
    int IDP = Integer.parseInt(request.getParameter("IDP"));
    Photo photo = DBUtils.GetInfoPhoto(conn, IDP);
    String errorString = (String) session.getAttribute("errorString");

    DBUtils.UpdateView(conn, IDP);

    ArrayList<Photo> ListInCart = null;
    ArrayList<Photo> ListLike = null;
    ArrayList<Photo> ListBuy = null;
    int Sum = 0;
    ArrayList<Album> ListAlbumUserLogined = new ArrayList<Album>();

    if (loginedUser != null) {
      errorString = null;
      ListLike = DBUtils.SearchPhotoAime(conn, loginedUser.getIDU());
      ListBuy = DBUtils.SearchPhotoAchete(conn, loginedUser.getIDU());
      ListInCart = DBUtils.SearchPhoto(conn, loginedUser.getIDU());
      ListAlbumUserLogined = DBUtils.LoadListAlbum(conn, loginedUser.getIDU());

      if (ListInCart != null) {
        for (Photo p : ListInCart) {
          Sum = Sum + p.getPrix();
        }
      }

      ArrayList<Album> ListAlbum = DBUtils.LoadListAlbum(conn, loginedUser.getIDU());
      ArrayList<Photo> ListPhotoOfUser = new ArrayList<Photo>();

      if (ListAlbum != null) {
        for (Album album : ListAlbum) {
          ListPhotoOfUser.addAll(DBUtils.LoadImage(conn, album.getIDA(), loginedUser.getIDU()));
        }
      }

      if (ListPhotoOfUser != null) {
        ListBuy.removeAll(ListPhotoOfUser);
        ListBuy.addAll(ListPhotoOfUser);
      }
    }

    request.setAttribute("photo", photo);
    request.setAttribute("ListBuy", ListBuy);
    request.setAttribute("ListLike", ListLike);

    request.setAttribute("errorString", errorString);
    request.setAttribute("ListInCart", ListInCart);
    request.setAttribute("Sum", Sum);
    request.setAttribute("ListAlbumUserLogined", ListAlbumUserLogined);

    RequestDispatcher view = request.getRequestDispatcher("viewimage.jsp");
    view.forward(request, response);
  }
示例#9
0
 /**
  * Devuelve 0, 2 o 4, segun las probabilidades dadas. Estas probabilidades var&iacute;n con el
  * nivel.
  *
  * @param p1 probabilidad de 0 en el nivel 1
  * @param p2 probabilidad de 2 en el nivel 1
  * @return 0, 2 o 4. Al azar
  */
 public static int ponderar(int p1, int p2) {
   int t = RANDOM.nextInt(100);
   p1 = Utils.dificultar(p1, true);
   p2 = Utils.dificultar(p2, true);
   // p1 *= (1 + (this.nivelActual() - 1) * .15);
   // p2 *= (1 + (this.nivelActual() - 1) * .15);
   if (t <= p1) return 0;
   if (t <= p1 + p2) return 2;
   return 4;
 }
示例#10
0
  private static void recomputeTrainTestSets(TrainAndTestReport r) { // TODO a nicer way? :)
    if (r instanceof TrainAndTestReportCrisp) {
      TrainAndTestReportCrisp rep = (TrainAndTestReportCrisp) r;
      double[] newFittedValues =
          Arrays.copyOfRange(rep.getFittedValues(), 0, rep.getNumTrainingEntries());
      double[] newForecastValsTest =
          Arrays.copyOfRange(
              rep.getFittedValues(), rep.getNumTrainingEntries(), rep.getFittedValues().length);
      rep.setFittedValues(newFittedValues);
      rep.setForecastValuesTest(newForecastValsTest);
      double[] newRealTrain =
          Arrays.copyOfRange(rep.getRealOutputsTrain(), 0, rep.getNumTrainingEntries());
      double[] newRealTest =
          Arrays.copyOfRange(
              rep.getRealOutputsTrain(),
              rep.getNumTrainingEntries(),
              rep.getRealOutputsTrain().length);
      rep.setRealOutputsTrain(newRealTrain);
      rep.setRealOutputsTest(newRealTest);
      rep.setErrorMeasures(
          ErrorMeasuresUtils.computeAllErrorMeasuresCrisp(
              Utils.arrayToList(newRealTrain),
              Utils.arrayToList(newRealTest),
              Utils.arrayToList(newFittedValues),
              Utils.arrayToList(newForecastValsTest),
              0)); // TODO I hope the 0 is not a problem
    } else if (r instanceof TrainAndTestReportInterval) {
      TrainAndTestReportInterval rep = (TrainAndTestReportInterval) r;
      List<Interval> newFittedValues =
          new ArrayList<>(rep.getFittedValues().subList(0, rep.getNumTrainingEntries()));
      List<Interval> newForecastValsTest =
          new ArrayList<>(
              rep.getFittedValues()
                  .subList(rep.getNumTrainingEntries(), rep.getFittedValues().size()));
      rep.setFittedValues(newFittedValues);
      rep.setForecastValuesTest(newForecastValsTest);

      List<Interval> realVals =
          Utils.zipLowerUpperToIntervals(rep.getRealValuesLowers(), rep.getRealValuesUppers());
      List<Interval> realValsTrain =
          new ArrayList<>(realVals.subList(0, rep.getNumTrainingEntries()));
      List<Interval> realValsTest =
          new ArrayList<>(realVals.subList(rep.getNumTrainingEntries(), realVals.size()));

      // TODO somehow add the actual distance and seasonality from params
      rep.setErrorMeasures(
          ErrorMeasuresUtils.computeAllErrorMeasuresInterval(
              realValsTrain,
              realValsTest,
              newFittedValues,
              newForecastValsTest,
              new WeightedEuclideanDistance(0.5),
              0));
    }
  }
示例#11
0
 @Override
 public void nextCycle() {
   super.nextCycle();
   final Set<NodeAddress> toRemove = new HashSet<NodeAddress>();
   // update member table, send alive messages
   for (final NodeAddress member : memberTable.keySet()) {
     final MemebrInfo ni = memberTable.get(member);
     if (Utils.getTime() - ni.lastMessageTime > lifeTimeThreshold) {
       toRemove.add(member);
       continue;
     }
     ni.aliveTime--;
     if (ni.aliveTime == 0) {
       ni.aliveTime = alivePeriod;
       sendMessage(new AliveMessage(getMessageTag(), network.getAddress(), member));
     }
   }
   memberTable.keySet().removeAll(toRemove);
   removeNeighbors(toRemove);
   // gossip
   for (final NodeAddress neighbor : getNeighbors()) {
     final MemebrInfo ni = memberTable.get(neighbor);
     ni.gossipTime--;
     if (ni.gossipTime == 0) {
       ni.gossipTime = gossipPeriod;
       final List<NodeAddress> memberList = new ArrayList<NodeAddress>(memberTable.keySet());
       memberList.remove(neighbor);
       Collections.shuffle(memberList, r);
       final List<NodeAddress> sublist =
           memberList.subList(0, Math.min(gossipSize, memberList.size()));
       sendMessage(
           new PartialMembershipViewMessage<Sizeable>(
               getMessageTag(),
               network.getAddress(),
               neighbor,
               new LinkedList<NodeAddress>(sublist)));
     }
   }
   // replace fallen neighbors from member view
   final Set<NodeAddress> neighbors = getNeighbors();
   if (neighbors.size() < neighborSize && neighborSize < memberTable.size()) {
     final TreeMap<NodeAddress, MemebrInfo> addCandidates =
         new TreeMap<NodeAddress, MemebrInfo>(memberTable);
     addCandidates.keySet().removeAll(getNeighbors());
     final Set<NodeAddress> minVal = Utils.findMinValueKeyGroup(addCandidates);
     for (final NodeAddress n : minVal) {
       if (neighbors.size() < neighborSize) {
         addNeighbor(n);
         network.send(
             new ConnectionRequestApprovedMessage<Sizeable>(
                 getMessageTag(), network.getAddress(), n));
       }
     }
   }
 }
  protected void finalEst() {
    for (int i = 0; i < this.number_of_topics; i++) {
      Utils.L1Normalization(m_parentTopicTermProb[i]);
      Utils.L1Normalization(m_childTopicTermProb[i]);
    }

    for (_Doc d : m_trainSet) {
      estThetaInDoc(d);
    }

    discoverSpecificComments();
  }
  static int[] getPixels(BufferedImage image) throws IOException, InterruptedException {
    // -----resize image
    BufferedImage resizedImage = Utils.resizeImage(image, 32, 32);
    //        ImageIO.write(resizeImageJpg, "jpg", new File("cat_32.jpg"));

    // -----convert to gray
    resizedImage = Utils.convertToGray(resizedImage);

    // -----get image pixels
    int[] pixels = Utils.getPixels(resizedImage);

    return pixels;
  }
  // log space
  public double calParentLogLikelihood(_ParentDoc2 pDoc) {
    double term1 = 0.0;
    double term2 = 0.0;

    term1 = Utils.lgamma(number_of_topics * d_alpha) - number_of_topics * Utils.lgamma(d_alpha);

    for (int k = 0; k < number_of_topics; k++) {
      term2 += Utils.lgamma(pDoc.m_sstat[k] + d_alpha);
    }
    term2 -= Utils.lgamma((double) (number_of_topics * d_alpha + pDoc.getDocLength()));

    return term1 + term2;
  }
示例#15
0
  /**
   * Check if <code>positionX</code> is between <code>positionA</code> and <code>positionB</code>.
   *
   * @param positionX position that we want to check if it's between other positions
   * @param positionA other position
   * @param positionB other position
   * @return <code>true</code> if positionX between other position and all position are on same
   *     line, otherwise <code>false</code>
   */
  public static boolean isPositionBetweenPositionsOnLine(
      int positionX, int positionA, int positionB) {

    // if positionX is not between other positions, it can't be between
    // them. Duh...
    boolean greaterThanBoth = (positionX > positionA) && (positionX > positionB);
    boolean lowertThanBoth = (positionX < positionA) && (positionX < positionB);

    if (greaterThanBoth || lowertThanBoth) {
      return false;
    }

    // all positions must be on same line
    boolean sameRank =
        (Utils.getRankFromPosition(positionX) == Utils.getRankFromPosition(positionA))
            && (Utils.getRankFromPosition(positionX) == Utils.getRankFromPosition(positionB));
    boolean sameFile =
        (Utils.getFileFromPosition(positionX) == Utils.getFileFromPosition(positionA))
            && (Utils.getFileFromPosition(positionX) == Utils.getFileFromPosition(positionB));

    if (sameFile || sameRank) {
      return true;
    } else {
      return false;
    }
  }
 private String getResponse(URL url) throws IOException {
   HttpURLConnection conn = (HttpURLConnection) url.openConnection();
   conn.setRequestMethod(httpMethod.name());
   conn.connect();
   InputStream is = conn.getInputStream();
   return Utils.readInput(is);
 }
示例#17
0
  @Override
  public View getView(final int position, View convertView, ViewGroup parent) {
    // TODO Auto-generated method stub

    final Holder holder = new Holder();
    View rowView = convertView;
    rowView = inflater.inflate(R.layout.contactlistitem, null);
    holder.tv = (TextView) rowView.findViewById(R.id.contactname);
    holder.img = (ImageView) rowView.findViewById(R.id.contactimage);
    holder.tv.setText(contactNames.get(position));

    holder.img.setImageBitmap(Utils.getFacebookPhoto(context, phoneNumber.get(position)));
    /*new AsyncTask<String, Void, Bitmap>() {

    	@Override
    	protected Bitmap doInBackground(String... params) {
    		return ;
    	}

    	@Override
    	protected void onPostExecute(Bitmap result) {
    		super.onPostExecute(result);

    	}
    }.execute();

    rowView.setOnClickListener(new OnClickListener() {
    	@Override
    	public void onClick(View v) {

    	}
    });*/

    return rowView;
  }
示例#18
0
  private SSLSocket criaSSLSocket(String host) throws Exception {

    KeyStore ks = Utils.getKeyStore("JKS");
    ks.load(new FileInputStream(keystore), byteSenha);

    KeyManagerFactory kmf = Utils.getKMFactory("SunX509");
    kmf.init(ks, byteSenha);

    SSLContext sslcontext = Utils.criaSSLContext("SSLv3");
    sslcontext.init(kmf.getKeyManagers(), null, null);

    SSLSocketFactory ssf = sslcontext.getSocketFactory();
    SSLSocket socket = (SSLSocket) ssf.createSocket(host, HTTPS_PORT);

    return socket;
  }
示例#19
0
  public void train() {
    double mu;
    int qid, i, j, pSize;
    for (int n = 0; n < m_maxIter; n++) {
      Utils.shuffle(m_order, m_trainingSize);
      qid = 0;
      while (qid < m_trainingSize) {
        pSize = 0;
        Arrays.fill(m_g, 0.0);

        for (j = 0; j < m_windowSize; j++) { // collect the gradients in mini-batch
          pSize += gradientUpdate(m_queries.get(m_order[qid % m_trainingSize]));
          qid++;
        }

        // Step 4: gradient from regularization
        for (i = 0; i < m_weight.length; i++) m_g[i] = m_g[i] / pSize + m_lambda * m_weight[i];

        mu = Math.random() * m_step;
        for (i = 0; i < m_weight.length; i++) m_weight[i] -= mu * m_g[i];
      }

      m_step *= m_shrinkage;
    }
  }
示例#20
0
  @Override
  public void run() {
    Integer second10 = second10Init;
    Integer second30 = second30Init;
    while (true) {
      second10--;
      second30--;

      MyRobot.getInstance().getMemory().forgetOldItems();

      if (second10 == 0) {
        second10 = second10Init;
        CommandDispatcher.getInstance().addCommand(new RobotGetOnOff());
        CommandDispatcher.getInstance().addCommand(new RobotCheckSensors());
        MyRobot.getInstance().getFaceController().updateFace();
      }

      if (second30 == 0) {
        second30 = second30Init;
        // CommandDispatcher.getInstance().addCommand(new CheckInternetConnection());
        // CommandDispatcher.getInstance().addCommand(new Alarm());
        // CommandDispatcher.getInstance().addCommand(new Test());
      }
      Utils.sleep(second);
    }
  }
  @Override
  public void run() {
    try {
      while (this.loggedIn()) {
        DataPacket packet = new DataPacket(Function.CREATE_RANDOM_ORDER);
        packet.cashier = this;
        packet = this.communicateWithServer(packet);
        if (packet == null) continue;

        this.addOrder(packet.order);

        int sleepAmount = (Utils.generateRandomNumber(4) + 3) * 1000;

        try {
          Thread.sleep(sleepAmount);
        } catch (InterruptedException e) {
        }

        // poll the order manager for any undelivered orders floating about
        DataPacket undeliveredOrderPacket = new DataPacket(Function.GET_UNDELIVERED_ORDER);
        DataPacket undeliveredOrderReturnPacket =
            this.communicateWithServer(undeliveredOrderPacket);
        if (undeliveredOrderReturnPacket.order != null)
          this.deliverOrder(undeliveredOrderReturnPacket.order);
      }
    } catch (Exception e) {
      System.out.println("Cashier.run: Error exception " + e.getMessage());
    }
  }
示例#22
0
 @Override
 protected void doFinalStuff() throws IOException {
   int numOfWords = WordsTool.getInstance().getIntegerMap().get(currFileName);
   double avgWordLength = (double) wordLengthSum / numOfWords;
   getDoubleMap().put(currFileName, Utils.getDouble(avgWordLength));
   super.doFinalStuff();
 }
示例#23
0
    public void actionPerformed(ActionEvent ev) {

      try {

        String[] logFiles = new String[] {"log"};

        JFileChooser chooser = new JFileChooser();
        chooser.setDialogTitle("Opening log file...");
        chooser.setMultiSelectionEnabled(false);
        chooser.addChoosableFileFilter(new SimpleFileFilter(logFiles, "Log files (*.log)"));
        chooser.setCurrentDirectory(workingDirectory);

        chooser.showOpenDialog(Utils.getActiveFrame());
        File file = chooser.getSelectedFile();
        logFilename = file.getAbsolutePath();
        System.out.println("Opened " + logFilename + "\n");

        File tmpDir = chooser.getCurrentDirectory();

        if (tmpDir != null) {
          workingDirectory = tmpDir;
        }

      } catch (Exception e) {
        System.err.println("Could not Open! \n");
      }
    }
示例#24
0
 public static ArrayList<TilePiece> initializePieces() {
   ArrayList<TilePiece> tps = new ArrayList<>();
   ArrayList<TilePieceSet> setupPieces = Utils.getTilePieceSetUp();
   for (TilePieceSet setPieces : setupPieces) {
     tps.addAll(setPieces.getTilePieces());
   }
   return tps;
 }
示例#25
0
 public LauncherDestructor(String type, String id, War w, WarStatistics statistics) {
   allListeners = new LinkedList<WarEventListener>();
   this.id = id;
   this.type = Utils.capitalize(type);
   this.statistics = statistics;
   this.warName = w.getWarName();
   this.w = w;
 }
  // p(w, z)=p(w|z)p(z)~~multinomial-dirichlet
  public void calLogLikelihood(int iter) {
    double logLikelihood = 0.0;
    double parentLogLikelihood = 0.0;
    double childLogLikelihood = 0.0;

    for (_Doc d : m_trainSet) {
      if (d instanceof _ParentDoc2) {
        parentLogLikelihood += calParentLogLikelihood((_ParentDoc2) d);
      } else {
        if (d instanceof _ChildDoc2) {
          childLogLikelihood += calChildLogLikelihood((_ChildDoc2) d);
        }
      }
    }

    double term1 = 0.0;
    double term2 = 0.0;
    double term3 = 0.0;
    double term4 = 0.0;
    for (int k = 0; k < number_of_topics; k++) {
      for (int n = 0; n < vocabulary_size; n++) {
        term3 += Utils.lgamma(d_beta + m_parentWordTopicSstat[k][n] + m_childWordTopicSstat[k][n]);
      }
      term4 -= Utils.lgamma(vocabulary_size * d_beta + m_parentSstat[k] + m_childSstat[k]);
    }

    term1 = number_of_topics * Utils.lgamma(vocabulary_size * d_beta);
    term2 = -number_of_topics * (vocabulary_size * Utils.lgamma(d_beta));

    parentLogLikelihood += term1 + term2 + term3 + term4;

    term1 = 0.0;
    term2 = 0.0;
    term3 = 0.0;
    term4 = 0.0;
    for (int k = 0; k < number_of_topics; k++) {
      for (int n = 0; n < vocabulary_size; n++) {
        term3 += Utils.lgamma(d_beta + m_parentWordTopicSstat[k][n] + m_childWordTopicSstat[k][n]);
      }
      term4 -= Utils.lgamma(vocabulary_size * d_beta + m_parentSstat[k] + m_childSstat[k]);
    }

    term1 = number_of_topics * Utils.lgamma(vocabulary_size * d_beta);
    term2 = -number_of_topics * (vocabulary_size * Utils.lgamma(d_beta));

    childLogLikelihood += term1 + term2 + term3 + term4;

    System.out.format("iter %d, parent log likelihood %.3f\n", iter, parentLogLikelihood);
    infoWriter.format("iter %d, parent log likelihood %.3f\n", iter, parentLogLikelihood);
    System.out.format("iter %d, child log likelihood %.3f\n", iter, childLogLikelihood);
    infoWriter.format("iter %d, child log likelihood %.3f\n", iter, childLogLikelihood);
    logLikelihood = parentLogLikelihood + childLogLikelihood;

    System.out.format("iter %d, log likelihood %.3f\n", iter, logLikelihood);
    infoWriter.format("iter %d, log likelihood %.3f\n", iter, logLikelihood);
  }
示例#27
0
    public void actionPerformed(ActionEvent ev) {

      Color c =
          ColorPicker.showDialog(
              Utils.getActiveFrame(), "Choose maximum branches color...", branchesMaxColor, true);

      if (c != null) branchesMaxColor = c;
    }
  /*
   * The constructor establishes the RuntimeContract between
   * the SQL-MR function and Aster Database. During query planning,
   * the function will constructed on a single node. During
   * query execution, it will be constructed and run on one or more nodes.
   */
  public ChiSquareTest(RuntimeContract contract) {
    // Read argument clauses into appropriate member variables.
    observedArgumentIdx =
        contract
            .getInputInfo()
            .getColumnIndex(contract.useArgumentClause("observed").getSingleValue());
    expectedArgumentIdx =
        contract
            .getInputInfo()
            .getColumnIndex(contract.useArgumentClause("expected").getSingleValue());
    accumulator = new Accumulator(contract);
    errorHandler =
        new ErrorHandler(
            this.getClass().getName(),
            Utils.getSingleBooleanFromParameter(contract, "stoponerror", false),
            Utils.getSingleIntFromParameter(contract, "log", Integer.MAX_VALUE));

    // Initialize the service
    chiSquareTest = new org.apache.commons.math3.stat.inference.ChiSquareTest();

    // Verify that the function accepts the given input schema.
    if (!SqlType.integer().equals(contract.getInputInfo().getColumnType(observedArgumentIdx))) {
      throw new IllegalUsageException(
          "\""
              + contract.useArgumentClause("observed").getSingleValue()
              + "\"  must be of type 'integer'");
    }
    if (!SqlType.doublePrecision()
        .equals(contract.getInputInfo().getColumnType(expectedArgumentIdx))) {
      throw new IllegalUsageException(
          "\""
              + contract.useArgumentClause("expected").getSingleValue()
              + "\"  must be a numeric type");
    }

    // Construct the output schema
    List<ColumnDefinition> outputColumns = new ArrayList<ColumnDefinition>();
    accumulator.constructOutputSchema(contract, outputColumns);
    outputColumns.add(new ColumnDefinition("pValue", SqlType.getType("double")));
    contract.setOutputInfo(new OutputInfo(outputColumns));

    // Complete the contract
    contract.complete();
  }
示例#29
0
 private void receiveEGTable() {
   int nBytes = (nBits - 1) / 8 + 1;
   try {
     for (int j = 0; j < nCols; j++)
       EGTable[j] = Utils.readBigInteger(nBytes * Wire.labelBitLength, ois);
   } catch (Exception e) {
     e.printStackTrace();
     System.exit(1);
   }
 }
示例#30
0
  @Override
  public TrainAndTestReport forecast(Map<String, List<Double>> data, Params parameters) {
    RandomWalkParams params = (RandomWalkParams) parameters;
    List<Double> allData = data.get(params.getColName());

    List<Double> dataToUse =
        allData.subList(params.getDataRangeFrom() - 1, params.getDataRangeTo());

    TrainAndTestReportCrisp report = new TrainAndTestReportCrisp(Model.RANDOM_WALK);

    int numTrainingEntries =
        Math.round(
            ((float) 100 / 100)
                * dataToUse
                    .size()); // TODO maybe take a different %age - e.g. to agree with the other
                              // models when avg
    report.setNumTrainingEntries(numTrainingEntries);

    List<Double> trainRealOutputs = new ArrayList<>(dataToUse.subList(0, numTrainingEntries));
    List<Double> testRealOutputs =
        new ArrayList<>(dataToUse.subList(numTrainingEntries, dataToUse.size()));
    List<Double> trainForecastOutputs = new ArrayList<>();
    trainForecastOutputs.add(Double.NaN);
    trainForecastOutputs.addAll(dataToUse.subList(0, numTrainingEntries - 1));
    List<Double> testForecastOutputs =
        new ArrayList<>(dataToUse.subList(numTrainingEntries - 1, dataToUse.size() - 1));

    report.setRealOutputsTrain(Utils.listToArray(trainRealOutputs));
    report.setRealOutputsTest(Utils.listToArray(testRealOutputs));

    report.setPlotCode(
        "plot.ts(c("
            + Utils.arrayToRVectorString(Utils.listToArray(trainForecastOutputs))
            + ","
            + Utils.arrayToRVectorString(Utils.listToArray(testForecastOutputs))
            + "))");

    report.setFittedValues(Utils.listToArray(trainForecastOutputs));
    report.setForecastValuesTest(Utils.listToArray(testForecastOutputs));

    ErrorMeasuresCrisp errorMeasures =
        ErrorMeasuresUtils.computeAllErrorMeasuresCrisp(
            trainRealOutputs,
            testRealOutputs,
            trainForecastOutputs,
            testForecastOutputs,
            params.getSeasonality());
    report.setErrorMeasures(errorMeasures);

    return report;
  }