/*
   * Recover the maximizing variables going back through the
   * maximizing bucket_tree; the variables are returned as an array
   * of markers (non-explanation variables get INVALID_INDEX).
   */
  private int[] backward_maximization() {
    int i, j;
    int bi = bucket_tree.length - 1;
    DiscreteFunction back_df;
    Bucket b = bucket_tree[bi];

    // If there are no explanation variables in the BayesNet, return null
    if (b.backward_pointers == null) return (null);

    // Initialize the markers for backward pointers with INVALID_INDEX
    int backward_markers[] = new int[bn.number_variables()];
    for (i = 0; i < backward_markers.length; i++) backward_markers[i] = BayesNet.INVALID_INDEX;

    // Initialize the marker for the last bucket
    backward_markers[b.variable.get_index()] = (int) (b.backward_pointers.get_value(0) + 0.5);

    // Go backwards through the bucket_tree
    for (i = (bi - 1); i >= 0; i--) {
      if (!bucket_tree[i].is_explanation()) break;
      back_df = bucket_tree[i].backward_pointers;
      // Skip null pointers (caused by evidence)
      if (back_df == null) continue;
      // Special treatment for bucket with only one value,
      // since it can be a bucket with only the bucket variable left
      if (back_df.number_values() == 1) {
        backward_markers[bucket_tree[i].variable.get_index()] = (int) (back_df.get_value(0) + 0.5);
        continue;
      }
      // Process the bucket
      j = back_df.get_position_from_indexes(bn.get_probability_variables(), backward_markers);
      backward_markers[bucket_tree[i].variable.get_index()] = (int) (back_df.get_value(j) + 0.5);
    }

    return (backward_markers);
  }
  /**
   * Distribute evidence in the BucketTree.
   *
   * @return true if successful; false if not.
   */
  public boolean distribute() {
    int i, j;
    boolean mark_non_conditioning[] = new boolean[bn.number_variables()];

    // First make sure the BucketTree has been reduced.
    if (unnormalized_result == null) reduce();
    // Second make sure there is more than one Bucket in the BucketTree.
    int last = bucket_tree.length - 1;
    if (last < 1) return (true);
    // Third, this method is used only if do_produce_clusters is true.
    if (do_produce_clusters == false) return (false);
    // Fourth, this method is use only if no explanatory variable was max'ed out.
    if (backward_pointers != null) return (false);

    // Go through the Bucket objects, from bottom to top,
    // to compute the new separator and cluster for each bucket.
    for (i = (last - 1); i >= 0; i--) { // Start from (last-1); last does not have child.
      // Check whether the Bucket has any valid content.
      if (bucket_tree[i].cluster == null) break;
      // Take the non-conditioning variables in a boolean array.
      for (j = 0; j < mark_non_conditioning.length; j++) mark_non_conditioning[j] = true;
      // OBS: The following piece of code will actually be less efficient than
      // necessary. It will count as "conditioning" any variable in the cluster
      // except the bucket variable. This will imply that some variables in the
      // separator will be normalized over without need, and the separator will
      // be larger than necessary.
      // OBS: this code was contributed by Wei Zhou ([email protected]),
      // who also detected the problem with the original code.
      // if (bucket_tree[i].cluster.number_variables() >
      // bucket_tree[i].non_conditioning_variables.size())
      for (j = 1; j < bucket_tree[i].cluster.number_variables(); j++) {
        mark_non_conditioning[(bucket_tree[i].cluster.get_variables())[j].get_index()] = false;
      }

      // The following piece of code does the right thing (compared to the
      // piece of code above): it selects the
      // minimum number of non-conditioning variables. To use this piece
      // of code, it will be necessary to create a "normalize" method that
      // normalizes with respect to a number of variables at at time.
      /*
      for (j=0; j<bucket_tree[i].cluster.number_variables(); j++) {
         mark_non_conditioning[ (bucket_tree[i].cluster.get_variables())[j].get_index() ] = false;
      }
      for (Enumeration e = bucket_tree[i].non_conditioning_variables.elements(); e.hasMoreElements(); ) {
         ProbabilityVariable pv = (ProbabilityVariable)(e.nextElement());
         mark_non_conditioning[pv.get_index() ] = true;
      } */

      // Update the separator.
      bucket_tree[i].separator =
          bucket_tree[i].child.cluster.sum_out(
              bn.get_probability_variables(), mark_non_conditioning);

      // Compute cluster using new separator (note that if separator
      // is null, the cluster had all variables already processed).
      if (bucket_tree[i].separator != null) {
        // OBS: the method here should normalize with respect to more
        // than one variable, to allow this algorithm to be more efficient!
        bucket_tree[i].cluster.normalize_first();
        // Now combine the cluster and the separator.
        bucket_tree[i].cluster =
            bucket_tree[i].cluster.multiply(
                bn.get_probability_variables(), bucket_tree[i].separator);
      }

      // Mark the Bucket as DISTRIBUTED.
      bucket_tree[i].bucket_status = Bucket.DISTRIBUTED;
    }
    // Indicate success.
    return (true);
  }