explicit BigNumber(string v) {
int i = 0;
if (v[i] == '-') {
sign = 1;
i++;
}
while (i < v.size()) {
if (isdigit(v[i])) {
integerPart.push_back(v[i]);
} else {
if (v[i] != '.')
throw std::runtime_error("NaN");
break;
}
i++;
}
if (v[i] == '.') {
i++;
while (i < v.size()) {
if (isdigit(v[i]))
fractionaryPart.push_back(v[i]);
else
throw std::runtime_error("NaN");
i++;
}
}
reverse(integerPart.begin(), integerPart.end());
if (fractionaryPart.size())
reverse(fractionaryPart.begin(), fractionaryPart.end());
}
bool __next_perm(vector<int>::iterator beg, vector<int>::iterator end) {
if (beg == end) {
return false;
}
vector<int>::iterator i = beg;
++i;
if (i == end) {
return false;
}
i = end;
--i;
for (;;) {
vector<int>::iterator ii = i;
--i;
if (*i < *ii) {
vector<int>::iterator j = end;
while (!(*i < *--j));
std::iter_swap(i, j);
reverse(ii, end);
return true;
}
if (i == beg) {
reverse(beg, end);
return false;
}
}
}
std::tuple<bool, vector<char>> addTwoVectors(vector<char> base,
vector<char> visitor) {
// TODO(alex): change these reverses
reverse(base.begin(), base.end());
reverse(visitor.begin(), visitor.end());
while (base.size() < visitor.size())
base.push_back('0');
while (visitor.size() < base.size())
visitor.push_back('0');
reverse(base.begin(), base.end());
reverse(visitor.begin(), visitor.end());
bool carry = 0;
for (int i = 0; i < base.size(); i++) {
base[i] += visitor[i] + carry - '0';
if (base[i] > '9') {
carry = 1;
base[i] -= '9';
} else {
carry = 0;
}
}
return make_tuple(carry, base);
}
void GerberImporter::merge_paths(multi_linestring_type &destination, const linestring_type& source)
{
if (!destination.empty())
{
multi_linestring_type::reverse_iterator ls;
for (ls = destination.rbegin(); ls != destination.rend(); ls++)
{
if (bg::equals(ls->back(), source.front()))
{
ls->insert(ls->end(), source.begin() + 1, source.end());
break;
}
else if (bg::equals(ls->back(), source.back()))
{
ls->insert(ls->end(), source.rbegin() + 1, source.rend());
break;
}
/*
* The following two cases does not happen very often, and they
* usually happen when the size of destination is small (often 2),
* therefore there shouldn't be the need to replace a standard
* linestring_type (std::vector) with a std::deque
*/
else if (bg::equals(ls->front(), source.front()))
{
reverse(ls->begin(), ls->end());
ls->insert(ls->end(), source.begin() + 1, source.end());
break;
}
else if (bg::equals(ls->front(), source.back()))
{
reverse(ls->begin(), ls->end());
ls->insert(ls->end(), source.rbegin() + 1, source.rend());
break;
}
}
if (ls == destination.rend())
{
destination.push_back(source);
}
}
else
{
destination.push_back(source);
}
}
string toString() {
string answer;
if (sign)
answer += "-";
string x = string(integerPart.data(), integerPart.size());
reverse(x.begin(), x.end());
answer += x;
if (fractionaryPart.size()) {
answer += ".";
string x = string(fractionaryPart.data(), fractionaryPart.size());
reverse(x.begin(), x.end());
answer += x;
}
return answer;
}
int findPositionOfMostMatches(
const string& first_string,
const string& second_string
) {
int number_of_possible_positions =
first_string.length() - second_string.length() + 1;
sequence<> literal_match_places(number_of_possible_positions);
for (int literal_index = 0;
literal_index < LITERALS_LENGTH;
++literal_index
) {
vector<int> first_polynomial =
binarizeStringByLiteral(first_string, LITERALS[literal_index]);
vector<int> second_polynomial =
binarizeStringByLiteral(second_string, LITERALS[literal_index]);
vector<int> product;
reverse(first_polynomial.begin(), first_polynomial.end());
multiplyWithFFT(first_polynomial, second_polynomial, &product);
literal_match_places +=
findMatchesByProduct(
product,
first_string.length(),
number_of_possible_positions
);
}
return literal_match_places.find_leftmost_max() + 1;
}
void reverseWords(string &s) {
int ls = s.size();
int i, j;
i = 0;
j = 0;
while (i < ls && s[i] == ' ') {
++i;
}
while (i < ls) {
while (i < ls && s[i] != ' ') {
s[j++] = s[i++];
}
if (i == ls) {
break;
}
while (i < ls && s[i] == ' ') {
++i;
}
s[j++] = ' ';
}
s.resize(j);
ls = s.size();
i = 0;
while (i < ls) {
while (i < ls && s[i] == ' ') {
++i;
}
if (i == ls) {
break;
}
j = i + 1;
while (j < ls && s[j] != ' ') {
++j;
}
reverse(s.begin() + i, s.begin() + j);
i = j;
}
while (s.size() > 0 && s.back() == ' ') {
s.pop_back();
}
reverse(s.begin(), s.end());
}
void buildPath(map<string, vector<string> > &father, vector<string> path,
const string &start, const string &word, vector<vector<string> > &result) {
path.push_back(word);
if (word == start) {
result.push_back(path);
reverse(result.back().begin(), result.back().end());
} else {
for (auto f : father[word]) {
buildPath(father, path, start, f, result);
}
}
path.pop_back();
}
int main(int argc, char *argv[])
{
string input_file;
// Check first argument if it exists for input file, otherwise ask user
if (argc > 1)
{
input_file = argv[1];
}
else
{
cout << "Please enter the path to your input file: " << endl;
cin >> input_file;
}
// Open input file and check if successfully opened
ifstream ifs(input_file);
if (!ifs)
{
cout << "Failed to open input file." << endl;
return 1;
}
string line;
while (getline(ifs, line))
{
unsigned int number_of_iterations = 0;
// If the length is one by default it's a palindrome
if (line.length() == 1)
{
cout << number_of_iterations << " " << line << endl;
continue;
}
while (!is_palindrome(line))
{
int original_number = stoi(line); // Convert line to an int
reverse(line.begin(), line.end()); // Reverse the order of line
int reversed_number = stoi(line);
int new_number = original_number + reversed_number;
line = to_string(new_number);
number_of_iterations++;
}
cout << number_of_iterations << " " << line << endl;
}
return 0;
}
vector<int> findClosestElements(vector<int>& arr, int k, int x) {
vector<int> res;
if (k <= 0) {
return res;
}
priority_queue<int, vector<int>, greater<int>> pq1;
priority_queue<int, vector<int>, less<int>> pq2;
int i;
for (i = 0; i < k; ++i) {
if (arr[i] >= x) {
pq2.push(arr[i]);
} else {
pq1.push(arr[i]);
}
}
int n = arr.size();
for (i = k; i < n; ++i) {
if (arr[i] >= x) {
pq2.push(arr[i]);
} else {
pq1.push(arr[i]);
}
if (pq1.empty()) {
pq2.pop();
} else if (pq2.empty()) {
pq1.pop();
} else if (x - pq1.top() > pq2.top() - x) {
pq1.pop();
} else {
pq2.pop();
}
}
int n1 = pq1.size();
while (!pq1.empty()) {
res.push_back(pq1.top());
pq1.pop();
}
while (!pq2.empty()) {
res.push_back(pq2.top());
pq2.pop();
}
reverse(res.begin() + n1, res.end());
return res;
}
string invertBoard(string board)
{
string tempBoard = board;
reverse(tempBoard.begin(), tempBoard.end());
// need a temp character
replace(tempBoard.begin(), tempBoard.end(), 'r', 't' );
replace(tempBoard.begin(), tempBoard.end(), 'R', 'T' );
replace(tempBoard.begin(), tempBoard.end(), 'b', 'r' );
replace(tempBoard.begin(), tempBoard.end(), 'B', 'R' );
replace(tempBoard.begin(), tempBoard.end(), 't', 'b' );
replace(tempBoard.begin(), tempBoard.end(), 'T', 'B' );
return tempBoard;
}
string multiplyTwoVectorsElementByElement(vector<int> &left, vector<int> &right){
vector<int> int_results;
for(int i = 0; i < left.size(); ++i){
int_results.emplace_back(left[i] * right[i]);
}
reverse(int_results.begin(), int_results.end());
string result = "";
for(int i = 0; i < int_results.size(); ++i){
result += intToString(int_results[i]);
if(i < int_results.size() - 1)
result += " ";
}
return result;
}
string convertToBase7(int num) {
static const int R = 7;
if (num < 0) {
return "-" +convertToBase7(-num);
}
if (num == 0) {
return "0";
}
string s = "";
while (num > 0) {
s.push_back(num % R + '0');
num /= R;
}
reverse(s.begin(), s.end());
return s;
}
PairStringBool SingleEntryParameters::createTemporaryDatabase ( bool randomFlag, bool reverseFlag, const string& tempDir ) const
{
static string key = genToLower ( genRandomString ( 10 ) );
PPTempFile pptf ( "", "" ); // Move the directory to the temporary directory
tempDBFullPath = pptf.getFullPathDir () + SLASH;
if ( tempDir.empty () ) {
tempDBFullPath += key;
}
else
tempDBFullPath += tempDir;
bool newDB;
if ( genCreateNewDirectory ( tempDBFullPath ) ) {
tempDBFullPath += SLASH;
tempDBFullPath += "UserProtein.fasta";
FILE* fp = gen_fopen_binary ( tempDBFullPath, "w", "Creating temporary database" );
for ( int i = 0 ; i < getNumEntries () ; i++ ) {
writeProteinEntry ( fp, names [i], userProteinSequence [i] );
}
gen_fclose ( fp, "Creating temporary database" );
if ( randomFlag || reverseFlag ) {
string suffix;
if ( randomFlag ) suffix = ".random.fasta";
if ( reverseFlag ) suffix = ".reverse.fasta";
FILE* fp = gen_fopen_binary ( tempDBFullPath.substr ( 0, tempDBFullPath.length () - 6 ) + suffix, "w", "Creating temporary database" );
for ( int i = 0 ; i < getNumEntries () ; i++ ) {
string p = userProteinSequence [i];
if ( randomFlag ) random_shuffle ( p.begin (), p.end () );
else reverse ( p.begin (), p.end () );
writeProteinEntry ( fp, names [i], p );
}
gen_fclose ( fp, "Creating temporary database" );
}
newDB = true;
}
else {
newDB = false;
tempDBFullPath += SLASH;
tempDBFullPath += "UserProtein.fasta";
}
return make_pair ( tempDBFullPath, newDB );
}
void find_neg_cycle1 (const vector<vector<double> >& moneyMatrix, vector<size_t>& cycle)
{
const size_t start_v = 0;
vector<double> distance (moneyMatrix.size (), 0.0);
vector<size_t> prev (moneyMatrix.size (), NOT_SET);
distance[start_v] = 1.0;
for (size_t i = 0; i < moneyMatrix.size (); ++i)
{
for (size_t v = 0; v < moneyMatrix.size (); ++v)
for (size_t u = 0; u < moneyMatrix.size (); ++u)
{
if (moneyMatrix[v][u] < 0.0)
continue;
if (distance[u] < distance[v] * moneyMatrix[v][u])
{
distance[u] = distance[v] * moneyMatrix[v][u];
prev[u] = v;
}
}
}
vector<bool> in_cycle (moneyMatrix.size (), false);
for (size_t i = 0; i < moneyMatrix.size (); ++i)
if (distance[i] > 1.0)
{
cycle.push_back (i);
in_cycle[i] = true;
size_t cur_v = prev[i];
while (cur_v != i && !in_cycle[cur_v])
{
cycle.push_back (cur_v);
in_cycle[cur_v] = true;
cur_v = prev[cur_v];
}
reverse (cycle.begin (), cycle.end ());
break;
}
}
vector<int> closestKValues(TreeNode* root, double target, int k) {
TreeIterator it1(root, target);
TreeReverseIterator it2(root, target);
if (it1.hasNext() && it2.hasNext() && it1.peek() == it2.peek()) {
(void)it1.next();
}
vector<int> v1, v2;
vector<int> res;
int i;
int c1, c2;
for (i = 0; i < k; ++i) {
if (!it1.hasNext() && !it2.hasNext()) {
break;
}
if (!it1.hasNext()) {
v2.push_back(it2.next());
continue;
}
if (!it2.hasNext()) {
v1.push_back(it1.next());
continue;
}
c1 = it1.peek();
c2 = it2.peek();
if (abs(c1 - target) < abs(c2 - target)) {
v1.push_back(it1.next());
} else {
v2.push_back(it2.next());
}
}
reverse(v1.begin(), v1.end());
res.insert(res.end(), v1.begin(), v1.end());
res.insert(res.end(), v2.begin(), v2.end());
v1.clear();
v2.clear();
return res;
}
int main (int argc, char* const argv[])
{
ifstream input_file(argv[1]);
string line;
if (input_file)
{
while (getline(input_file, line))
{
reverse(line.begin(), line.end());
line.erase(remove(line.begin(), line.end(), ' '), line.end());
int sum = 0;
for (int i = 0; i < line.size(); ++i)
{
int digit = line[i] - '0';
if ((i + 1) % 2 == 0)
{
digit *= 2;
if (digit > 9)
{
int digit_1 = digit / 10;
int digit_2 = digit % 10;
digit = digit_1 + digit_2;
}
}
sum += digit;
}
if (sum % 10 == 0)
cout << 1 << endl;
else
cout << 0 << endl;
}
input_file.close();
}
return 0;
}
void stringToIntNumbers(const vector<string> &strings, vector<int> &ints){
for(int i = 0; i < strings.size(); ++i){
ints.emplace_back(stringToInt(strings[i]));
}
reverse(ints.begin(), ints.end());
}
void TreeNode::generate_hme_model(fstream* save_stream) {
save_stream->write((char *) &is_leaf_, sizeof(is_leaf_));
if (is_leaf_) {
Matrix x_matrix;
Matrix response_vector;
x_matrix.reserve(rows_->size());
response_vector.reserve(rows_->size());
//divide onto y and x values
for (uint i = 0; i != rows_->size(); i++) {
vector<double>::iterator it = ++rows_->at(i)->begin();
x_matrix.push_back(vector<double>(it, rows_->at(i)->end()));
response_vector.push_back(vector<double>(rows_->at(i)->begin(), it));
}
Matrix transposed_x_matrix = transpose(x_matrix);
//remove const parameters
vector<uint> removed_const_parameters;
for (uint i = 0; i != transposed_x_matrix.size(); i++) {
bool ok = false;
for (uint j = 1; j != transposed_x_matrix[0].size(); j++) {
if (transposed_x_matrix[i][j] != transposed_x_matrix[i][0]) {
ok = true;
break;
}
}
if (!ok) {
transposed_x_matrix.erase(transposed_x_matrix.begin() + i);
removed_const_parameters.push_back(i + 1); //shift depends on insert const columb
--i;
}
}
//inserting const column
transposed_x_matrix.insert(transposed_x_matrix.begin(),
vector<double>(transposed_x_matrix[0].size(), 1.0));
vector<uint> korrelation_removed_parameters;
if (max_params_correlation_ < 1.0) {
//correlation calculate
//calculate avg_value
vector<double> avg_param_val;
avg_param_val.reserve(transposed_x_matrix.size());
for (uint i = 0; i != transposed_x_matrix.size(); i++) {
double val = 0;
for (uint j = 0; j != transposed_x_matrix[0].size(); j++) {
val += transposed_x_matrix[i][j];
}
avg_param_val.push_back(val / transposed_x_matrix[0].size());
}
//calculate sum_sqr_difference && diff matrix
vector<double> sum_sqr_dif;
sum_sqr_dif.reserve(transposed_x_matrix.size());
Matrix dif_matrix = matrix_utils::create_matrix(transposed_x_matrix.size(),
transposed_x_matrix[0].size());
for (uint i = 0; i != transposed_x_matrix.size(); i++) {
double val = 0;
for (uint j = 0; j != transposed_x_matrix[0].size(); j++) {
double tmp = transposed_x_matrix[i][j] - avg_param_val[i];
dif_matrix[i][j] = tmp;
val += tmp * tmp;
}
sum_sqr_dif.push_back(val);
}
for (uint i = 0; i != transposed_x_matrix.size(); i++) {
for (uint j = i + 1; j != transposed_x_matrix.size(); j++) {
double val = 0;
for (uint k = 0; k != transposed_x_matrix[0].size(); k++) {
val += dif_matrix[i][k] * dif_matrix[j][k];
}
val /= sqrt(sum_sqr_dif[i] * sum_sqr_dif[j]);
if (fabs(val) > max_params_correlation_) {
korrelation_removed_parameters.push_back(j);
dif_matrix.erase(dif_matrix.begin() + j);
transposed_x_matrix.erase(transposed_x_matrix.begin() + j);
j--;
}
}
}
}
vector<uint> removed_linear_dependenced_parameters = remove_linear_dependence_rows(
transposed_x_matrix);
// cann't remove first const column
if (removed_linear_dependenced_parameters.size()) {
assert(removed_linear_dependenced_parameters[0] > 0);
}
x_matrix = transpose(transposed_x_matrix);
vector<double> weight_vector =
transpose(
inversion(transposed_x_matrix * x_matrix)
* (transposed_x_matrix * response_vector))[0];
//place zeroes in place of removed parameters in reverse order
reverse(removed_linear_dependenced_parameters.begin(),
removed_linear_dependenced_parameters.end());
for (uint i = 0; i != removed_linear_dependenced_parameters.size(); i++) {
weight_vector.insert(weight_vector.begin() + removed_linear_dependenced_parameters[i],
0);
}
if (max_params_correlation_ < 1.0) {
reverse(korrelation_removed_parameters.begin(), korrelation_removed_parameters.end());
for (uint i = 0; i != korrelation_removed_parameters.size(); i++) {
weight_vector.insert(weight_vector.begin() + korrelation_removed_parameters[i], 0);
}
}
reverse(removed_const_parameters.begin(), removed_const_parameters.end());
for (uint i = 0; i != removed_const_parameters.size(); i++) {
weight_vector.insert(weight_vector.begin() + removed_const_parameters[i], 0);
}
for (uint i = 0; i != weight_vector.size(); i++) {
save_stream->write((char *) &weight_vector[i], sizeof(weight_vector[i]));
}
if (debug_output_) {
fstream outS("addit1.txt", std::ios_base::out | std::ios_base::app);
outS.setf(std::ios_base::fixed);
outS.precision(6);
Matrix weight_vector_test;
weight_vector_test.push_back(weight_vector);
weight_vector_test = transpose(weight_vector_test);
double sum = 0;
for (uint i = 0; i != rows_->size(); i++) {
Matrix xVC;
xVC.push_back(vector<double>(rows_->at(i)->begin() + 1, rows_->at(i)->end()));
xVC[0].insert(xVC[0].begin(), 1);
Matrix rez = xVC * weight_vector_test;
double tmp = rez[0][0] - rows_->at(i)->at(0);
sum += tmp * tmp;
}
outS << sum_sqr_difference_ << ' ' << sum << ' ' << rows_->size() << ' '
<< removed_linear_dependenced_parameters.size() << ' '
<< korrelation_removed_parameters.size() << ' '
<< removed_const_parameters.size() << endl;
outS.close();
/*outS.open("addit.txt", std::ios_base::out | std::ios_base::app);
outS << x_matrix.size() << '*' << x_matrix[0].size() << endl;
for (uint i = 0; i != x_matrix.size(); i++) {
outS << response_vector[i][0];
for (uint j = 0; j != x_matrix[i].size(); j++) {
outS << ' ' << x_matrix[i][j];
}
outS << endl;
}
outS << endl;
for (uint i = 0; i != weight_vector.size(); i++) {
outS << weight_vector[i] << ' ';
}
outS << endl << endl;
outS.close();*/
outS.open("weight.txt", std::ios_base::out | std::ios_base::app);
for (uint i = 0; i != weight_vector.size(); i++) {
outS << weight_vector[i] << ' ';
}
outS << endl;
outS.close();
}
} else {
//init gate with two oppositely directed vectors
double vector_length = 1;
double zero = 0;
double tmp = split_value_ * vector_length;
save_stream->write((char *) &tmp, sizeof(tmp));
for (int i = 1; i != split_index_; i++) {
save_stream->write((char *) &zero, sizeof(zero));
}
tmp = -vector_length;
save_stream->write((char *) &tmp, sizeof(tmp));
for (uint i = split_index_ + 1; i != rows_->at(0)->size(); i++) {
save_stream->write((char *) &zero, sizeof(zero));
}
left_child_->generate_hme_model(save_stream);
right_child_->generate_hme_model(save_stream);
}
}
void PFG::set_dac_recursive(state_sequent& the_sequence, state::iterator& the_state) {
state_sequent* a_sequence = dynamic_cast<state_sequent*>(*the_state);
// Am I a sequence? Yes? Go one sequence further
if (a_sequence != NULL) {
for(state_sequent::iterator child_state = a_sequence->begin(); child_state != a_sequence->end(); ++child_state)
set_dac_recursive(*a_sequence, child_state);
}
// I am not a sequence, but a state
else {
state* this_state = dynamic_cast<state*>(*the_state);
if (this_state == NULL)
throw pfg_exception( "state_atom in state_sequent not expected");
analogout* PFG_aout = NULL;
// find an analogout section with suitable id
state::iterator i = this_state->begin();
while(i!=this_state->end()) { // state members loop
analogout* aout = dynamic_cast<analogout*>(*i); // initialize new analogout
analogout* next_aout = dynamic_cast<analogout*>(*i++);
i--;
// This is for me, analogout is != NULL (there is an analogout) and has my ID
if (aout!=NULL && aout->id == id) {
if (PFG_aout == NULL) {
// save the informations
PFG_aout = aout;
}
// there is no place for me here
else {
throw pfg_exception( "found another DAC section, ignoring");
delete aout;
}
// remove the analog out section
this_state->erase(i++);
}
else {
++i;
}
} // state members loop
if (PFG_aout != NULL) { // state modifications
// check the length of the state
if (this_state->length < TIMING*41.0)
throw pfg_exception( "time is too short to save DAC information");
else {
// copy of original state
state* register_state = new state(*this_state);
ttlout* register_ttls = new ttlout();
register_ttls->id = 0;
register_state->length = TIMING;
register_state->push_back(register_ttls);
if (PFG_aout->dac_value > (pow(2.0, int(DAC_BIT_DEPTH-1))-1) )
throw pfg_exception("dac_value too high");
if ( abs(PFG_aout->dac_value) > pow(2.0, int(DAC_BIT_DEPTH-1)) )
throw pfg_exception("dac_value too low");
// now, insert the ttl information
vector<int> dac_word;
for (int j = 0; j < DAC_BIT_DEPTH ; j++) {
int bit = PFG_aout->dac_value & 1;
dac_word.push_back(bit);
cout << dac_word[j];
PFG_aout->dac_value >>= 1;
}
// need one clock cycle to read in bit
// latch enable (LE) should always be high while doing so
// except for the last bit
// reverse the bit pattern
reverse(dac_word.begin(), dac_word.end());
for (int i = 0; i < DAC_BIT_DEPTH; i++) {
register_ttls->ttls = (1 << DATA_BIT)*dac_word[i] + (1 << CLK_BIT) + (1 << LE_BIT);
the_sequence.insert(the_state,register_state->copy_new());
register_ttls->ttls = (1 << DATA_BIT)*dac_word[i] + (1 << LE_BIT);
the_sequence.insert(the_state,register_state->copy_new());
//std::cout << dac_word[i];
if (i == (DAC_BIT_DEPTH-1)) {// last bit => LE low, tell DAC to read the word in
register_ttls->ttls = 0; // 1<< DATA_BIT*bit;
the_sequence.insert(the_state,register_state->copy_new());
}
}
// shorten the remaining state
// and add LE high to this state
ttlout* ttls=new ttlout();
// 42nd pulse
this_state->length -= TIMING*41;
ttls->ttls = 1 << LE_BIT;
this_state->push_front(ttls);
delete register_state;
delete PFG_aout;
}
}
else {
ttlout* le_ttls=new ttlout();
le_ttls->ttls = 1 << LE_BIT;
this_state->push_back(le_ttls);
}
// end of state modifications
} // I was a state
void PFG::set_dac_recursive(state_sequent& the_sequence, state::iterator& the_state) {
state_sequent* a_sequence = dynamic_cast<state_sequent*>(*the_state);
// Am I a sequence? Yes? Go one sequence further
if (a_sequence != NULL) {
for(state_sequent::iterator child_state = a_sequence->begin();
child_state != a_sequence->end();
++child_state)
set_dac_recursive(*a_sequence, child_state);
}
// I am not a sequence, but a state
else {
state* this_state = dynamic_cast<state*>(*the_state);
if (this_state == NULL)
throw pfg_exception( "state_atom in state_sequent not expected");
analogout* PFG_aout = NULL;
// Find an analogout section with suitable id
state::iterator i = this_state->begin();
while(i!=this_state->end()) { // Begin state members loop
analogout* aout = dynamic_cast<analogout*>(*i); // Initialize new analogout
analogout* next_aout = dynamic_cast<analogout*>(*i++);
i--;
// This is for me, analogout is != NULL (there is an analogout) and has my ID
if (aout!=NULL && aout->id == id) {
if (PFG_aout == NULL) {
// Save the informations
PFG_aout = aout;
}
// There is no place for me here
else {
throw pfg_exception( "found another DAC section, ignoring");
delete aout;
}
// Remove the analogout section
this_state->erase(i++);
}
// Nothing to see, move on
else {
++i;
}
} // End state members loop
if (PFG_aout != NULL) { // Begin state modifications
// Check the length of the state
if (this_state->length < TIMING*41.0)
throw pfg_exception( "time is too short to save DAC information");
else {
// Copy of original state
state* register_state = new state(*this_state);
ttlout* register_ttls = new ttlout();
register_ttls->id = 0;
register_state->length = TIMING;
register_state->push_back(register_ttls);
// Return error if dac_value is out of bounds
if (PFG_aout->dac_value > (pow(2.0, int(DAC_BIT_DEPTH-1))-1) )
throw pfg_exception("dac_value too high");
if ( abs(PFG_aout->dac_value) > pow(2.0, int(DAC_BIT_DEPTH-1)) )
throw pfg_exception("dac_value too low");
// Now, create the bit pattern
vector<int> dac_word;
for (int j = 0; j < DAC_BIT_DEPTH ; j++) {
int bit = PFG_aout->dac_value & 1;
dac_word.push_back(bit);
PFG_aout->dac_value >>= 1;
}
// Reverse the bit pattern
reverse(dac_word.begin(), dac_word.end());
/*
Datasheet AD1862:
- Bit is read with rising edge of the CLK
- Word is read with falling edge of LE
The opto-coupler in the DAC20 are inverting the signal!
CLK is here inverted, the rest not. This does not affect functionality
because the inverse of a 2s complement is then just negative - 1:
Example:
5 bits:
15 --> 01111 -->inverting--> 10000 = -16
1 --> 00001 -->inverting--> 11110 = -2
0 --> 00000 -->inverting--> 11111 = -1
-1 --> 11111 -->inverting--> 00000 = 0
-2 --> 11110 -->inverting--> 00001 = 1
-16 --> 10000 -->inverting--> 01111 = 15
Latch enable is going high after 41st bit.
*/
// Transfer the bit pattern
for (int i = 0; i < DAC_BIT_DEPTH; i++) {
// Two states = one clock cycle to read in bit
// State 1
register_ttls->ttls=(1<<DATA_BIT)*dac_word[i]+(1<<CLK_BIT)+(1<<LE_BIT);
the_sequence.insert(the_state,register_state->copy_new());
// State 2
register_ttls->ttls = (1<<DATA_BIT)*dac_word[i]+(1<<LE_BIT);
the_sequence.insert(the_state,register_state->copy_new());
if (i == (DAC_BIT_DEPTH-1)) {
// Last bit => LE -> 0, prepare DAC to read the word in
register_ttls->ttls = 0;
the_sequence.insert(the_state,register_state->copy_new());
}
}
/*
Shorten the remaining state
and add LE high to this state.
The word is read in.
*/
ttlout* ttls=new ttlout();
// 42nd pulse
this_state->length -= TIMING*41;
// Here is the word read in
ttls->ttls = 1 << LE_BIT;
this_state->push_front(ttls);
delete register_state;
delete PFG_aout;
}
}
else {
ttlout* le_ttls=new ttlout();
le_ttls->ttls = 1 << LE_BIT;
this_state->push_back(le_ttls);
}
// End state modifications
} // I was a state
