protected double getRawBranchRate(final Tree tree, final NodeRef node) {

    double rate = 0.0;
    double[] processValues = getProcessValues(tree, node);

    double totalTime = 0;
    if (indicatorParameter != null) {
      double absRate = rateParameter.getParameterValue(0);

      for (int i = 0; i < indicatorParameter.getDimension(); i++) {
        int index = (int) indicatorParameter.getParameterValue(i);
        if (index == 0) {
          rate += absRate * processValues[i];
        } else {
          rate +=
              (absRate * (1.0 + relativeRatesParameter.getParameterValue(index - 1)))
                  * processValues[i];
        }
        totalTime += processValues[i];
      }
    } else {
      for (int i = 0; i < rateParameter.getDimension(); i++) {
        rate += rateParameter.getParameterValue(i) * processValues[i];
        totalTime += processValues[i];
      }
    }
    rate /= totalTime;

    return rate;
  }
  protected double calculateLogFieldLikelihood() {

    if (!intervalsKnown) {
      // intervalsKnown -> false when handleModelChanged event occurs in super.
      wrapSetupIntervals();
      setupGMRFWeights();
      intervalsKnown = true;
    }

    double currentLike = 0;
    DenseVector diagonal1 = new DenseVector(fieldLength);
    DenseVector currentGamma = new DenseVector(popSizeParameter.getParameterValues());

    SymmTridiagMatrix currentQ =
        getScaledWeightMatrix(
            precisionParameter.getParameterValue(0), lambdaParameter.getParameterValue(0));
    currentQ.mult(currentGamma, diagonal1);

    //        currentLike += 0.5 * logGeneralizedDeterminant(currentQ) - 0.5 *
    // currentGamma.dot(diagonal1);

    currentLike +=
        0.5 * (fieldLength - 1) * Math.log(precisionParameter.getParameterValue(0))
            - 0.5 * currentGamma.dot(diagonal1);
    if (lambdaParameter.getParameterValue(0) == 1) {
      currentLike -= (fieldLength - 1) / 2.0 * LOG_TWO_TIMES_PI;
    } else {
      currentLike -= fieldLength / 2.0 * LOG_TWO_TIMES_PI;
    }

    return currentLike;
  }
 public double calculateWeightedSSE() {
   double weightedSSE = 0;
   double currentPopSize = popSizeParameter.getParameterValue(0);
   double currentInterval = coalescentIntervals[0];
   for (int j = 1; j < fieldLength; j++) {
     double nextPopSize = popSizeParameter.getParameterValue(j);
     double nextInterval = coalescentIntervals[j];
     double delta = nextPopSize - currentPopSize;
     double weight = (currentInterval + nextInterval) / 2.0;
     weightedSSE += delta * delta / weight;
     currentPopSize = nextPopSize;
     currentInterval = nextInterval;
   }
   return weightedSSE;
 }
    /** @return the lower limit of this hypervolume in the given dimension. */
    public Double getLowerLimit(int dimension) {

      if (dimension != 0)
        throw new RuntimeException("omega parameters have wrong dimension " + dimension);

      if (lowerOmega == null) return OMEGA_MIN_VALUE;
      else return lowerOmega.getParameterValue(dimension);
    }
  private void printInformtion(Parameter par) {
    StringBuffer sb = new StringBuffer("parameter \n");
    for (int j = 0; j < par.getDimension(); j++) {
      sb.append(par.getParameterValue(j));
    }

    Logger.getLogger("dr.evomodel").info(sb.toString());
  };
  public int[] connected(int i, Parameter clusteringParameter) {
    int n = clusteringParameter.getDimension();
    int[] visited = new int[n + 1];
    visited[0] = i + 1;
    int tv = 1;

    for (int j = 0; j < n; j++) {
      if (visited[j] != 0) {
        int curr = visited[j] - 1;

        /*look forward
         */

        int forward = (int) clusteringParameter.getParameterValue(curr);
        visited[tv] = forward + 1;
        tv++;
        // Check to see if is isn't already on the list

        for (int ii = 0; ii < tv - 1; ii++) {
          if (visited[ii] == forward + 1) {
            tv--;
            visited[tv] = 0;
          }
        }

        /*look back
         */
        for (int jj = 0; jj < n; jj++) {
          if ((int) clusteringParameter.getParameterValue(jj) == curr) {
            visited[tv] = jj + 1;
            tv++;

            for (int ii = 0; ii < tv - 1; ii++) {
              if (visited[ii] == jj + 1) {
                tv--;
                visited[tv] = 0;
              }
            }
          }
        }
      }
    }
    return visited;
  }
  public double getStatisticValue(int dim) {

    double val;

    // x is location count, y is location dimension
    int x = getColumnIndex(dim);
    int y = getRowIndex(dim);
    Parameter loc = locationsParameter.getParameter(x);

    if (y == 0) {
      val =
          loc.getParameterValue(y)
              + locationDriftParameter.getParameterValue(0) * offsetsParameter.getParameterValue(x);
    } else {
      val = loc.getParameterValue(y);
    }

    return val;
  }
Example #8
0
  protected void getDiagonalRates(double[] diagonalRates) {
    double kappa = substitutionModel.getKappa();
    double[] freq = substitutionModel.getFrequencyModel().getFrequencies();
    double mutationRate = mutationParameter.getParameterValue(0);
    double beta =
        0.5
            / ((freq[0] + freq[2]) * (freq[1] + freq[3])
                + kappa * (freq[0] * freq[2] + freq[1] * freq[3]));

    diagonalRates[0] = ((freq[1] + freq[3]) + freq[2] * kappa) * mutationRate * beta;
    diagonalRates[1] = ((freq[0] + freq[2]) + freq[3] * kappa) * mutationRate * beta;
    diagonalRates[2] = ((freq[1] + freq[3]) + freq[0] * kappa) * mutationRate * beta;
    diagonalRates[3] = ((freq[0] + freq[2]) + freq[1] * kappa) * mutationRate * beta;
  }
  public double logLhoodAllGeneTreesInSpeciesTree() {
    double[] llhoodcpts = new double[priorComponents.length];

    double totalweight = 0.0;
    for (int i = 0; i < priorComponents.length; i++) {
      totalweight += priorComponents[i].weight;
    }
    for (int i = 0; i < priorComponents.length; i++) {
      llhoodcpts[i] = Math.log(priorComponents[i].weight / totalweight);
      double sigma = popPriorScale.getParameterValue(0);
      double alpha = priorComponents[i].alpha;
      double beta = sigma * priorComponents[i].beta;
      llhoodcpts[i] += logLhoodAllGeneTreesInSpeciesSubtree(pionodes[rootn], alpha, beta);
    }
    return logsumexp(llhoodcpts);
  }
  /** change the parameter and return the hastings ratio. */
  public double doOperation() throws OperatorFailedException {

    double[] mean = sccs.getMode();
    double[] currentValue = parameter.getParameterValues();
    double[] newValue = new double[dim];

    Set<Integer> updateSet = new HashSet<Integer>();

    if (setSizeMean != -1.0) {
      final int listLength = Poisson.nextPoisson(setSizeMean);
      while (updateSet.size() < listLength) {
        int newInt = MathUtils.nextInt(parameter.getDimension());
        if (!updateSet.contains(newInt)) {
          updateSet.add(newInt);
        }
      }
    } else {
      for (int i = 0; i < dim; ++i) {
        updateSet.add(i);
      }
    }

    double logq = 0;
    for (Integer i : updateSet) {
      newValue[i] = mean[i] + scaleFactor * MathUtils.nextGaussian();
      if (UPDATE_ALL) {
        parameter.setParameterValueQuietly(i, newValue[i]);
      } else {
        parameter.setParameterValue(i, newValue[i]);
      }

      logq +=
          (NormalDistribution.logPdf(currentValue[i], mean[i], scaleFactor)
              - NormalDistribution.logPdf(newValue[i], mean[i], scaleFactor));
    }

    //        for (Integer i : updateSet) {
    //            parameter.setParameterValueQuietly(i, newValue[i]);
    //        }

    if (UPDATE_ALL) {
      parameter.setParameterValueNotifyChangedAll(0, parameter.getParameterValue(0));
    }

    return logq;
  }
 public double getBranchRate(final Tree tree, final NodeRef node) {
   return rateParameter.getParameterValue(0);
 }
  /** change the parameter and return the hastings ratio. */
  public final double doOperation() {

    int index = MathUtils.nextInt(links.getDimension());

    int oldGroup = (int) assignments.getParameterValue(index);

    /*
     * Set index customer link to index and all connected to it to a new assignment (min value empty)
     */
    int minEmp = minEmpty(modelLikelihood.getLogLikelihoodsVector());
    links.setParameterValue(index, index);
    int[] visited = connected(index, links);

    int ii = 0;
    while (visited[ii] != 0) {
      assignments.setParameterValue(visited[ii] - 1, minEmp);
      ii++;
    }

    /*
     * Adjust likvector for group separated
     */

    modelLikelihood.setLogLikelihoodsVector(oldGroup, getLogLikGroup(oldGroup));

    modelLikelihood.setLogLikelihoodsVector(minEmp, getLogLikGroup(minEmp));

    int maxFull = maxFull(modelLikelihood.getLogLikelihoodsVector());

    double[] liks = modelLikelihood.getLogLikelihoodsVector();
    /*
     * computing likelihoods of joint groups
     */

    double[] crossedLiks = new double[maxFull + 1];

    for (int ll = 0; ll < maxFull + 1; ll++) {
      if (ll != minEmp) {
        crossedLiks[ll] = getLogLik2Group(ll, minEmp);
      }
    }

    /*
     * Add logPrior
     */
    double[] logP = new double[links.getDimension()];

    for (int jj = 0; jj < links.getDimension(); jj++) {
      logP[jj] += depMatrix[index][jj];

      int n = (int) assignments.getParameterValue(jj);
      if (n != minEmp) {
        logP[jj] += crossedLiks[n] - liks[n] - liks[minEmp];
      }
    }

    logP[index] = Math.log(chiParameter.getParameterValue(0));

    /*
     * possibilidade de mandar p zero as probs muito pequenas
     */

    /*
     *  Gibbs sampling
     */

    this.rescale(logP); // Improve numerical stability
    this.exp(logP); // Transform back to probability-scale

    int k = MathUtils.randomChoicePDF(logP);

    links.setParameterValue(index, k);

    int newGroup = (int) assignments.getParameterValue(k);
    ii = 0;
    while (visited[ii] != 0) {
      assignments.setParameterValue(visited[ii] - 1, newGroup);
      ii++;
    }

    /*
     * updating conditional likelihood vector
     */
    modelLikelihood.setLogLikelihoodsVector(newGroup, getLogLikGroup(newGroup));
    if (newGroup != minEmp) {
      modelLikelihood.setLogLikelihoodsVector(minEmp, 0);
    }

    sampleMeans(maxFull);

    return 0.0;
  }
  public void sampleMeans(int maxFull) {

    double[][] means = new double[maxFull + 2][2];

    // sample mean vector for each cluster

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

      // Find all elements in cluster

      int ngroup = 0;
      for (int ii = 0; ii < assignments.getDimension(); ii++) {
        if ((int) assignments.getParameterValue(ii) == i) {
          ngroup++;
        }
      }

      if (ngroup != 0) {
        double[][] group = new double[ngroup][2];
        double[] groupMean = new double[2];

        int count = 0;
        for (int ii = 0; ii < assignments.getDimension(); ii++) {
          if ((int) assignments.getParameterValue(ii) == i) {
            group[count][0] = modelLikelihood.getData()[ii][0];
            group[count][1] = modelLikelihood.getData()[ii][1];
            groupMean[0] += group[count][0];
            groupMean[1] += group[count][1];
            count += 1;
          }
        }

        groupMean[0] /= ngroup;
        groupMean[1] /= ngroup;

        double kn = k0 + ngroup;
        double vn = v0 + ngroup;

        double[][] sumdif = new double[2][2];

        for (int jj = 0; jj < ngroup; jj++) {
          sumdif[0][0] += (group[jj][0] - groupMean[0]) * (group[jj][0] - groupMean[0]);
          sumdif[0][1] += (group[jj][0] - groupMean[0]) * (group[jj][1] - groupMean[1]);
          sumdif[1][0] += (group[jj][0] - groupMean[0]) * (group[jj][1] - groupMean[1]);
          sumdif[1][1] += (group[jj][1] - groupMean[1]) * (group[jj][1] - groupMean[1]);
        }

        double[][] TnInv = new double[2][2];
        TnInv[0][0] =
            T0Inv[0][0]
                + ngroup * (k0 / kn) * (groupMean[0] - m[0]) * (groupMean[0] - m[0])
                + sumdif[0][0];
        TnInv[0][1] =
            T0Inv[0][1]
                + ngroup * (k0 / kn) * (groupMean[1] - m[1]) * (groupMean[0] - m[0])
                + sumdif[0][1];
        TnInv[1][0] =
            T0Inv[1][0]
                + ngroup * (k0 / kn) * (groupMean[0] - m[0]) * (groupMean[1] - m[1])
                + sumdif[1][0];
        TnInv[1][1] =
            T0Inv[1][1]
                + ngroup * (k0 / kn) * (groupMean[1] - m[1]) * (groupMean[1] - m[1])
                + sumdif[1][1];

        Matrix Tn = new SymmetricMatrix(TnInv).inverse();

        double[] posteriorMean = new double[2];
        // compute posterior mean

        posteriorMean[0] = (k0 * m[0] + ngroup * groupMean[0]) / (k0 + ngroup);
        posteriorMean[1] = (k0 * m[1] + ngroup * groupMean[1]) / (k0 + ngroup);

        // compute posterior Precision
        double[][] posteriorPrecision =
            new WishartDistribution(vn, Tn.toComponents()).nextWishart();
        posteriorPrecision[0][0] *= kn;
        posteriorPrecision[1][0] *= kn;
        posteriorPrecision[0][1] *= kn;
        posteriorPrecision[1][1] *= kn;

        double[] sample =
            new MultivariateNormalDistribution(posteriorMean, posteriorPrecision)
                .nextMultivariateNormal();
        means[i][0] = sample[0];
        means[i][1] = sample[1];
      }
    }

    // Fill in cluster means for each observation

    for (int j = 0; j < assignments.getDimension(); j++) {
      double[] group = new double[2];
      group[0] = means[(int) assignments.getParameterValue(j)][0];
      group[1] = means[(int) assignments.getParameterValue(j)][1];

      modelLikelihood.setMeans(j, group);
    }
  }
  public double getLogLik2Group(int group1, int group2) {
    double L = 0.0;

    int ngroup1 = 0;
    for (int i = 0; i < assignments.getDimension(); i++) {
      if ((int) assignments.getParameterValue(i) == group1) {
        ngroup1++;
      }
    }

    int ngroup2 = 0;
    for (int i = 0; i < assignments.getDimension(); i++) {
      if ((int) assignments.getParameterValue(i) == group2) {
        ngroup2++;
      }
    }

    int ngroup = (ngroup1 + ngroup2);

    if (ngroup != 0) {
      double[][] group = new double[ngroup][2];

      double mean[] = new double[2];

      int count = 0;
      for (int i = 0; i < assignments.getDimension(); i++) {
        if ((int) assignments.getParameterValue(i) == group1) {
          group[count][0] = modelLikelihood.getData()[i][0];
          group[count][1] = modelLikelihood.getData()[i][1];
          mean[0] += group[count][0];
          mean[1] += group[count][1];
          count += 1;
        }
      }

      for (int i = 0; i < assignments.getDimension(); i++) {
        if ((int) assignments.getParameterValue(i) == group2) {
          group[count][0] = modelLikelihood.getData()[i][0];
          group[count][1] = modelLikelihood.getData()[i][1];
          mean[0] += group[count][0];
          mean[1] += group[count][1];
          count += 1;
        }
      }

      mean[0] /= ngroup;
      mean[1] /= ngroup;

      double kn = k0 + ngroup;
      double vn = v0 + ngroup;

      double[][] sumdif = new double[2][2];

      for (int i = 0; i < ngroup; i++) {
        sumdif[0][0] += (group[i][0] - mean[0]) * (group[i][0] - mean[0]);
        sumdif[0][1] += (group[i][0] - mean[0]) * (group[i][1] - mean[1]);
        sumdif[1][0] += (group[i][0] - mean[0]) * (group[i][1] - mean[1]);
        sumdif[1][1] += (group[i][1] - mean[1]) * (group[i][1] - mean[1]);
      }

      double[][] TnInv = new double[2][2];
      TnInv[0][0] =
          T0Inv[0][0] + ngroup * (k0 / kn) * (mean[0] - m[0]) * (mean[0] - m[0]) + sumdif[0][0];
      TnInv[0][1] =
          T0Inv[0][1] + ngroup * (k0 / kn) * (mean[1] - m[1]) * (mean[0] - m[0]) + sumdif[0][1];
      TnInv[1][0] =
          T0Inv[1][0] + ngroup * (k0 / kn) * (mean[0] - m[0]) * (mean[1] - m[1]) + sumdif[1][0];
      TnInv[1][1] =
          T0Inv[1][1] + ngroup * (k0 / kn) * (mean[1] - m[1]) * (mean[1] - m[1]) + sumdif[1][1];

      double logDetTn = -Math.log(TnInv[0][0] * TnInv[1][1] - TnInv[0][1] * TnInv[1][0]);

      L += -(ngroup) * Math.log(Math.PI);
      L += Math.log(k0) - Math.log(kn);
      L += (vn / 2) * logDetTn - (v0 / 2) * logDetT0;
      L += GammaFunction.lnGamma(vn / 2) + GammaFunction.lnGamma((vn / 2) - 0.5);
      L += -GammaFunction.lnGamma(v0 / 2) - GammaFunction.lnGamma((v0 / 2) - 0.5);
    }

    return L;
  }