Lab 4X - Intro to MOOS Programming HINTS

Transcription

1 Lab 4X - Intro to MOOS Programming HINTS Unmanned Marine Vehicle Autonomy, Sensing and Communications Spring, 2018 Michael Benjamin, mikerb@mit.edu Henrik Schmidt, henrik@mit.edu Department of Mechanical Engineering MIT, Cambridge MA Overview and Objectives 3 2 The podometry Exercise 3 3 The pprimefactor Exercise: Strongly recommended C++ Hints String Parsing String to Number, and Number to String Conversion Hint: Use STL Lists to Manage Unprocessed Entries The pprimefactor Exercise: Architecture Hints If Needed Calculating the set of Prime Factors for a Given Number Hint: Build a class to represent a prime number solution-in-progress

2 2

3 1 Overview and Objectives In the past years of 2.680, the Prime Factors lab stood out as one of the most time consuming labs of the course. But it also stood out as a lab that cemented some important understanding of how MOOS works, and what it takes to build MOOS apps. The act of building a MOOS app also helps gain insight into how existing MOOS apps work when needed in later labs. The bottom line is that we don t feel like we can remove the prime factors exercise without compromising key concepts we want you to have and you will need in later parts of the course. But we also want this lab to be more digestible in the one week you have to work on it (and other classes). So the compromise is to provide substantial hints. So, feel free to try this lab without the hints, but also feel free to use this lab addendum to guide your work. Even though these hints were not provided in previous years, much of the insight below was indeed discussed at the white board to help students along in previous years. 2 The podometry Exercise The only gotcha to be aware of in this exercise is that there are perhaps several updates to NAV X and NAV Y each time you read your mail. Each new position represents a new leg. Make sure your odometry calculation calculates each leg. 3 The pprimefactor Exercise: Strongly recommended C++ Hints 3.1 String Parsing In this lab you will need to do some fairly routing string parsing, using some tools that you may not want to re-invent from scratch. See the course wiki LabUpdates page for some tips on string parsing. Namely the below three functions: vector<string> parsestring(string, char); string bitestring(string, char); string stripblankends(string); They can be found here: String to Number, and Number to String Conversion In this lab you will need to perform some conversions between strings and numerical values. To represent a 64 bit integer you will want to use the type unsigned long int x = 0; In this lab, if you use the utimerscript script provided in the lab, the numbers will be posted to the variable NUM VALUE as string value. For example if the posting were: NUM VALUE=" ". To convert from the string, str=" " to an unsigned long int, use: 3

4 #include <cstdlib> // for the strtoul() function unsigned long int x = strtoul(str.c_str(), NULL, 0); In the other direction, converting numerical values into strings, you can use the C++ stringstream for this: // Include the stringstream header file #include <sstream>... // Create the biggest unsigned long int possibe unsigned long int ival = ; // Convert it to a string stringstream ss; ss << ival; string str = ss.str(); // Confirm it works cout << "Value:" << str << endl; 3.3 Hint: Use STL Lists to Manage Unprocessed Entries In this lab a key feature of the prime factorization handler is that it be able to handle (accept, solve and post) shorter numbers while the application may be still working on larger numbers. Here are two hints you may wish to consider: Create your own little C++ class for defining an entry. This may include the prime itself, the time received, partial results, and an indication of where the solution algorithm left off the last time this prime was worked on. See Section 4.2 below. Use an STL list (or similarly capable data structure if you want) for handling entries. The STL list is nice since it allows insertions at both ends, and deletions from both ends and the middle. Since lists are doubly linked, deletions from the middle are efficient, O(1), unlike deletions from the middle of say vectors. Review of Simple Usage of a List of Strings The first snippet below just reminds us how to declare, populate and iterate through an STL list of strings: 1 #include <list> 2 #include <string> 3 4 list<string> my_strings; 5 my_strings.push_back("apples"); 6 my_strings.push_back("watermelons"); 7 my_strings.push_back("pears"); 8 my_strings.push_back("blackberry"); 9 10 list<string>::iterator p; 4

5 11 for(p=my_strings.begin(); p!=my_strings.end(); p++) { 12 string str = *p; 13 if(str.length() > 6) 14 cout << "Long fruit name: " << str << endl; 15 } 16 cout << "List size: " << my_strings.size() << endl; The code above does not modify the list once it s been built, but detects list entries with string length longer than six characters. It should produce the output: Long fruit name: watermelons Long fruit name: blackberry List size: 4 Removing a List Item While Iterating Through the List Although the documentation for lists is quite good in most C++ text books or at cplusplus.com, the syntax for deletion of list items from the middle of the list, while iterating through may be a bit tricky so we cover it here. The next code segment is similar to the above example, but this time it removes elements of the list with string length greater than six: 1 #include <list> 2 #include <string> 3 4 list<string> my_strings; 5 my_strings.push_back("apples"); 6 my_strings.push_back("watermelons"); 7 my_strings.push_back("pears"); 8 my_strings.push_back("blackberry"); list<string>::iterator p; 11 for(p=my_strings.begin(); p!=my_strings.end(); ) { 12 string str = *p; 13 if(str.length() > 6) { 14 cout << "Removing long fruit: " << str << endl; 15 p = my_strings.erase(p); 16 } 17 else 18 ++p; 29 } 20 cout << "List size: " << my_strings.size() << endl; Note how line 11 has changed between the two listings. The p++ in the first listing is left out in the second listing. The iterator instead is incremented on line 18. This code should produce the below output. Removing long fruit: watermelons Removing long fruit: blackberry List size: 2 5

6 Accessing a Reference to a List Element vs a Copy In the above two examples, on line 12, the first thing done while iterating through the list of strings is to derefernce the contents of the iterator. The line: string str = *p; makes a copy of the string in the list. Let s suppose we wanted modify the strings in the list. For example we may want to go through the list of strings and truncate to ten characters, all strings greater than ten characters. You might be inclined to try something like: list<string>::iterator p; for(p=my_strings.begin(); p!=my_strings.end(); ) { string str = *p; if(str.length() > 10) { str = str.substr(0,10); } } The above will not work because we truncated a copy of the string in the list. This original list of strings may still contain strings of length greater than ten. You instead need to use the line: string& str = *p; The extra ampersand now means that str is the element/string in the list, not a copy of it. 4 The pprimefactor Exercise: Architecture Hints If Needed Sometimes the best strategy in building something complex is the identification of relatively easier distinct stages where each stage is (a) verifiable, (b) closer to the overall solution, and (c) doesn t require a bunch of re-working between each stage. With that in mind, we offer four distinct stages for the Prime Factors exercise. A non-moos C++ program to simply calculate the prime factors of a given number. A MOOS app to read the given number from mail, but each new number has its prime factors calculated completely before handling the next number. A MOOS app that reads a give number from its mail, puts it into a queue during the OnNewMail() mail handling method, and then handles one number at a time from the queue during the Iterate() method. Each number again is calculated to completion before proceeding to the next The final stage. Same as before, but each number on the queue is processed only a fixed number of steps. If all the primes are found within this fixed number of steps, it is removed from the queue, otherwise it is left on the queue until the next time the Iterate() method is invoked. But presumably new numbers may be added in the meanwhile as the OnNewMail() function is once again invoked. 6

7 4.1 Calculating the set of Prime Factors for a Given Number You can find several descriptions on the web of the algorithm for calculating the prime factors of a given number. We describe it in our own words here, partly because we want to emphasize the notion of partially calculating the answer. Initially this isn t our focus, but later on it will be important - we will want a algorithm that we can pause and resume where we left off. First, let s discuss the notion of the problem state. The state consists of two parts: A list L of prime factors, initially empty, A number N with a perhaps presently unknown set of prime factors. As the algorithm progresses, the state will evolve with the list L growing and the number N shrinking until L holds the list of prime factors, and N is 1. For example: L = {}, N=2310 <- Initial condition with input 2310 L = {2}, N=1155 L = {2,3}, N=385 L = {2,3,5}, N=77 L = {2,3,5,7}, N=11 L = {2,3,5,7,11}, N=1 <- Final condition, solution {2,3,5,7,11} How do you find the next prime factor at each stage? One simple way to do this is to iterate between i = 2 and the square root of N and checking if i divides evenly into N. Checking if a number divides evenly into another number, in C++, is done with the modulo operator % (a % b == 0) // if b divides evenly into a Going beyond the square root is redundant. For example checking whether (35%7)==0 would never be necessary since (35%5)==0 would have been caught first as i iterates higher and hits 5 before 7. You may notice that the simple for-loop has some inefficiencies in it. For example, checking if (N%4)==0 is not necessary if we already know (N%2)!=0. In fact that for-loop should only include prime numbers i=2,3,5,7,11,13... rather than i=2,3,4,5,6,7... Here it may become tempting to keep a look-up table of small primes to make your for-loop faster. Resist this temptation. This isn t what the lab is about, and it s not the huge performance boost that it would seem at the outset. This key aspect here for our lab is the idea of iterating step-by-step through a for-loop. Think of a step in the above algorithm as a single a%b calculation. Rather than proceeding from 2 to the square root of N without pause, the algorithm could instead be paused along the way, stopping at some number k between 2 and the square root of N. When the calculation resumes, the for-loop simply picks up where we left off. Normally we wouldn t be interested in calculating things in this manner, but this approach allows us to pause our work on big potentially-hard-to-solve numbers, to quickly handle an easy number that has arrived on the scene while working on that big number. Recursion This algorithm naturally lends itself to a recursive solution. A recursive algorithm is just one that calls itself as part of the algorithm, with a condition for termination. A well known one 7

8 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,... Fib(n) = Fib(n-1) + Fib(n-2) Fib(1) = 0 Fib(2) = 1 Primes(n) = k + Primes(n/k), if n is composite Primes(n) = n, if n is prime 4.2 Hint: Build a class to represent a prime number solution-in-progress It will be helpful to build a C++ class to store instances of partially calculated entries. One example of this class is given below, leaving the class implemenation up to you. Key parts of this class are: A holder of the original prime number (m orig), A holder of prime factors found so far (m factors), The index at which it was received (m received index), The index at which it was solved (m calculated index), The index in the for-loop to start searching for prime (m start index), A function for finding the next prime, given a maximum number of steps to search (factor()), A function for generating a string report of the results (getreport()), 8

9 class PrimeEntry { public: PrimeEntry(); ~PrimeEntry() {}; void setoriginalval(unsigned long int v); void setreceivedindex(unsigned int v) {m_received_index=v;}; void setcalculatedindex(unsigned int v) {m_calculated_index=v;}; void setdone(bool v) {m_done=v;}; bool bool done() {return(m_done);}; factor(unsigned long int max_steps); std::string getreport(); protected: unsigned long int unsigned long int bool unsigned int unsigned int m_start_index; m_orig; m_done; m_received_index; m_calculated_index; std::vector<unsigned long int> m_factors; }; #endif Your MOOS app may contain a list of such elements. It will grow as new mail comes in. And it will shrink during the Iterate() loop as work is done on each element. The Iterate() loop should try to perform some number of steps on each element, then scan the list for those marked as done. For any done element, remove it from the list, and generate a posting to the MOOSDB of the results. 9