예제 #1
0
void __fastcall TDebug68k::StopClick(TObject *Sender)
{
        zx81_stop = !zx81_stop;
        if (zx81_stop) Stop->Caption="Run";
        else Stop->Caption="Stop";
        UpdateVals();
}
예제 #2
0
// Integer acceleration function.
void DiscreteAccelFilter::CalcSystem_Discrete(int64_t distance_to_target, int64_t v, int64_t goal_v, int64_t max_v, int64_t max_a)
{
	int64_t sign = signum(distance_to_target);
	int64_t gooda;
	// Compute our maximum acceleration
	if (sign * v + max_a > max_v) {
		gooda = sign * max_v - v;
	} else if (labs(v - goal_v) <= max_a && distance_to_target == 0) {
		gooda = goal_v - v;
		sign = signum(gooda);
	} else if (labs(distance_to_target) <= max_a) {
		gooda = distance_to_target - v;
	} else {
		gooda = sign * max_a;
	}
	
	// Loop while accelerating that way would throw us too far
	while (sign * (v + sd(v + gooda, max_a) - sd(goal_v, max_a) - distance_to_target) > 0) {
		gooda = gooda - sign;
	} 
	//convert from mm/timestep^2 to m/s^2
	UpdateVals(gooda/100.0,.01 /*1/100 second timestep*/);
}
예제 #3
0
// With the current scheme we store the larger i, j
// that can be aligned to mid_k in the optimal alignment.
void Phaser::UpdateGeneral(score_t ** curr_face,
                           score_t ** prev_face,
                           my_pair ** curr_check,
                           my_pair ** prev_check,
                           size_t i,
                           size_t j,
                           size_t k,
                           size_t mid_k,
                           bool mf,
                           bool ff,
                           bool cf,
                           char m_char,
                           char f_char,
                           char c_1,
                           char c_2) {
  size_t m = m_index(mf, ff, cf);
  score_t max_score;
  my_pair max_check;

  // only k decreases. Two deletions from C.
  score_t c_ins_1 =  prev_face[m_index(mf, ff, 0)][IJ(i, j)] + score(c_1, '-') + score(c_2, '-');
  score_t c_ins_2 =  prev_face[m_index(mf, ff, 1)][IJ(i, j)] + score(c_1, '-') + score(c_2, '-');
  my_pair check_1 = prev_check[m_index(mf, ff, 0)][IJ(i, j)];
  my_pair check_2 = prev_check[m_index(mf, ff, 1)][IJ(i, j)];

  if (c_ins_1 >= c_ins_2) {
    max_score = c_ins_1;
    max_check = check_1;
  } else {
    max_score = c_ins_2;
    max_check = check_2;
  }

  if (i > 0) {
    if (m_char == '-') {
      score_t p1 = curr_face[m_index(0, ff, cf)][IJ(i-1, j)];
      score_t p2 = curr_face[m_index(1, ff, cf)][IJ(i-1, j)];
      curr_face[m][IJ(i, j)] = std::max(p1, p2);
      if (k == mid_k) {
        curr_check[m][IJ(i, j)] = my_pair(i, j);
      } else if (k > mid_k) {
        curr_check[m][IJ(i, j)] = (p1 > p2) ?
            curr_check[m_index(0, ff, cf)][IJ(i-1, j)] :
            curr_check[m_index(1, ff, cf)][IJ(i-1, j)];
      }
      return;
    }
    // only i decreases. Single deletion from M.
    // TODO(Readability): This might be a one-level for over pre_mf.
    score_t ins_val;
    my_pair ins_check;
    ins_val   =  curr_face[m_index(0, ff, cf)][IJ(i-1, j)] + score(m_char, '-');
    ins_check = curr_check[m_index(0, ff, cf)][IJ(i-1, j)];
    UpdateVals(ins_val, ins_check, &max_score, &max_check);

    ins_val  =   curr_face[m_index(1, ff, cf)][IJ(i-1, j)] + score(m_char, '-');
    ins_check = curr_check[m_index(1, ff, cf)][IJ(i-1, j)];
    UpdateVals(ins_val, ins_check, &max_score, &max_check);

    // k and i decreases: single deletions from C, M aligns.
    for (bool pre_cf : {false, true}) {
      for (bool pre_mf : {false, true}) {
        score_t del_val  =   prev_face[m_index(pre_mf, ff, pre_cf)][IJ(i-1, j)] + score(c_1, m_char) + score(c_2, '-');  //  NOLINT
        my_pair del_check = prev_check[m_index(pre_mf, ff, pre_cf)][IJ(i-1, j)];
        UpdateVals(del_val, del_check, &max_score, &max_check);
      }
    }
  }

  if (j > 0) {
    if (f_char == '-') {
      score_t p1 = curr_face[m_index(mf, 0, cf)][IJ(i, j-1)];
      score_t p2 = curr_face[m_index(mf, 1, cf)][IJ(i, j-1)];
      curr_face[m][IJ(i, j)] = std::max(p1, p2);
      if (k == mid_k) {
        curr_check[m][IJ(i, j)] = my_pair(i, j);
      } else if (k > mid_k) {
        curr_check[m][IJ(i, j)] = (p1 > p2) ?
            curr_check[m_index(mf, 0, cf)][IJ(i, j-1)] :
            curr_check[m_index(mf, 1, cf)][IJ(i, j-1)];
      }
      return;
    }
    score_t ins_val;
    my_pair ins_check;
    // only j decreases. Single deletion from F.
    ins_val = curr_face[m_index(mf, 0, cf)][IJ(i, j-1)] + score(f_char, '-');
    ins_check = curr_check[m_index(mf, 0, cf)][IJ(i, j-1)];
    UpdateVals(ins_val, ins_check, &max_score, &max_check);

    ins_val = curr_face[m_index(mf, 1, cf)][IJ(i, j-1)] + score(f_char, '-');
    ins_check = curr_check[m_index(mf, 1, cf)][IJ(i, j-1)];
    UpdateVals(ins_val, ins_check, &max_score, &max_check);


    // k and j decreases: single deletions from C, F aligns.
    for (bool pre_cf : {false, true}) {
      for (bool pre_ff : {false, true}) {
        score_t del_val =   prev_face[m_index(mf, pre_ff, pre_cf)][IJ(i, j-1)] + score(c_1, '-') + score(c_2, f_char);  //  NOLINT
        my_pair del_check = prev_check[m_index(mf, pre_ff, pre_cf)][IJ(i, j-1)];
        UpdateVals(del_val, del_check, &max_score, &max_check);
      }
    }
  }

  if (i > 0 && j > 0) {
    for (bool pre_cf : {false, true}) {
      for (bool pre_ff : {false, true}) {
        for (bool pre_mf : {false, true}) {
          score_t aln_val = prev_face[m_index(pre_mf, pre_ff, pre_cf)][IJ(i-1, j-1)] + score(c_1, m_char) + score(c_2, f_char);  //  NOLINT
          my_pair aln_check = prev_check[m_index(pre_mf, pre_ff, pre_cf)][IJ(i-1, j-1)];
          UpdateVals(aln_val, aln_check, &max_score, &max_check);
        }
      }
    }  }

  curr_face[m][IJ(i, j)] = max_score;

  if (k == mid_k) {
    curr_check[m][IJ(i, j)] = my_pair(i, j);
  } else if (k > mid_k) {
    curr_check[m][IJ(i, j)] = max_check;
  }
}