Chapter 15 // Exercise 11 - Principles & Practice Using C++

In this exercise I am using Visual Studio 2017 and modified versions of the graphics files used throughout the chapters. You can find those versions through the link below.

Chapter 15 // Exercise 11

Find the average maximum temperatures for each month of the year for two or more locations (e.g., Cambridge, England, and Cambridge, Massachusetts; there are lots of towns called "Cambridge") and graph them together. As ever, be careful with axes, labels, use of color, etc.

Github: https://github.com/l-paz91/principles-practice/tree/master/Chapter%2015/Exercise%2011

I should've spend a lot longer on this instead of hacking something together but I really want to move onto the next chapter as graphing data is not my idea of fun...besides excel can do it much nicer and faster and there's got to be a C# library out there somewhere that allows you to call Excel graphs from within your code.

With that though, I'm finally onto the last graphics chapter.

Chapter 15 // Exercise 10 - Principles & Practice Using C++

In this exercise I am using Visual Studio 2017 and modified versions of the graphics files used throughout the chapters. You can find those versions through the link below.

Chapter 15 // Exercise 10

What kind of data is unsuitable for a line graph or a bar graph? Find an example and find a way of displaying it (e.g., as a collection of labelled points).

Github: https://github.com/l-paz91/principles-practice/blob/master/Chapter%2015/Exercise%2010

If you have a graph that is "x amount of people voted yes and y voted no"; this would make a great bar chart. However, charts such as "Age and time spent watching Filthy Frank" would make a better scatter graph. An example from Maths Is Fun; Icecream Sales and Temperature:

The red line is there due to my laziness with the notch spacing. If the top Y value is more than the length, you end up with teeny tiny gaps between each notch. 

Chapter 15 // Exercise 9 - Principles & Practice Using C++

In this exercise I am using Visual Studio 2017 and modified versions of the graphics files used throughout the chapters. You can find those versions through the link below.

Chapter 15 // Exercise 9

Find another data set of heights (an inch is 2.54cm) and graph them with your program from the previous exercise. For example, search the web for "height distribution" or "height of people in the United States" and ignore a lot of rubbish or ask your friends for their heights. Ideally, you don't have to change anything for the new data set. Calculating the scaling from the data is a key idea. Reading in labels from input also helps minimise changes when you want to reuse code.

Github: https://github.com/l-paz91/principles-practice/blob/master/Chapter%2015/exercise%209

For this one I quickly googled "height data set" on images then used the first image that came up. It contained height and weight pairs. I have no idea what unit they were in, I guessed kg and cm but they seem a bit low for that but whatever.

Chapter 15 // Exercise 8 - Principles & Practice Using C++

In this exercise I am using Visual Studio 2017 and modified versions of the graphics files used throughout the chapters. You can find those versions through the link below.

Chapter 15 // Exercise 8

Here is a collection of heights in centimetres together with the number of people in a group of that height (rounded to the nearest 5cm): (170, 7), (175,9), (180, 23), (185, 17), (190, 6), (195, 1). How would you graph that data? If you can't think of anything better, do a bar graph. Remember to provide axes and labels. Place the data in a file and read it from that file.

Github: https://github.com/l-paz91/principles-practice/tree/master/Chapter%2015/Exercise%208

I thought about doing a scatter graph as we have Marks already implemented. Then because it would be as "simple" as replacing the rectangles with marks I decided to create a new class that could hold x and y data but then through inheritance it could be given different functionality.

I also changed how the notches were drawn as originally they were set as ints, causing quite a bit of data lost due to rounding down. CustomGraph though draws axes to fit the window and has modifiable labels. How the data is drawn though is up to the child class.

This isn't the best graph in the world but it reads in from a file or a vector:

Chapter 15 // Exercise 6, 7 - Principles & Practice Using C++

In this exercise I am using Visual Studio 2017 and modified versions of the graphics files used throughout the chapters. You can find those versions through the link below.

Chapter 15 // Exercise 6, 7

6. Design and implement a bar graph class. Its basic data is a vector<double> holding N values, and each value should represented by a "bar" that is a rectangle where the height represents the value.
7. Elaborate the bar graph class to allow labeling of the graph itself and its individual bars. Allow the use of colour.

Github: https://github.com/l-paz91/principles-practice/tree/master/Chapter%2015/Exercise%206%2C%207

Exercise 6 - The basic bar graph with just bars set to certain heights:

This takes in a vector of doubles and resizes itself depending on the window size. The number of notches are also dependent on the size of the graph and how many bars there are.

Exercise 7 - It's not exactly excel but it'll do. The bars are coloured by random ints so occasional bars may be identical. The notch marking on the Y axis also isn't entirely accurate as it's rounded down in the Axis constructor but whatever. The bar labels and fill colours can be turned off by just providing a bool value and you can set the axis labels to anything once you've created the barchart object.

Chapter 15 // Exercise 5 - Principles & Practice Using C++

In this exercise I am using Visual Studio 2017 and modified versions of the graphics files used throughout the chapters. You can find those versions through the link below.

Chapter 15 // Exercise 5

"Animate" (as in section 15.5) the series 1-1/3+1/5-1/7+1/9-1/11+.... It is known as Leibniz's series and converges to pi/4.

Github: https://github.com/l-paz91/principles-practice/blob/master/Chapter%2015/Exercise%205

This took me a while to wrap my head around and I'm still not entirely convinced at how the lambda expression works but whatever.

So pi/4 == 0.7853989 (not precisely but you have to stop somewhere)

The problem with this exercise is that each frame looks identical as it gets closer to pi/4. Probably not the best function to graph. Either that or I've completely miscalculated.

Chapter 15 // Exercise 4 - Principles & Practice Using C++

In this exercise I am using Visual Studio 2017 and modified versions of the graphics files used throughout the chapters. You can find those versions through the link below.

Chapter 15 // Exercise 4

Graph a sine(sin()),  cosine (cos()), the sum of those (sin(x)+cos(x)), and the sum of the squares of those (sin(x)*sin(x)+cos(x)*cos(x)) on a single graph. Do provide axes and labels.

Github: https://github.com/l-paz91/principles-practice/blob/master/Chapter%2015/Exercise%204

.

Chapter 15 // Exercise 3 - Principles & Practice Using C++

In this exercise I am using Visual Studio 2017 and modified versions of the graphics files used throughout the chapters. You can find those versions through the link below.

Chapter 15 // Exercise 3

Modify Fct from the previous exercise to take an extra argument to control precision or whatever. make the type of that argument a template parameter for extra flexibility.

Github: Not done.

This was very confusing. I'm not good with templates; I don't particularly like them. By 'control precision' I thought he meant change doubles to ints or something but at the end of it all I have to convert the points into ints anyway as my version of Point only uses int.

And what does he want by it being a templated type? Would the precision mean "to this decimal place?" If it's templated, whats to stop someone from passing a string in? I'm so confused.

I've decided to just leave it as I don't understand what he wants me to do.

Chapter 15 // Exercise 2 - Principles & Practice Using C++

In this exercise I am using Visual Studio 2017 and modified versions of the graphics files used throughout the chapters. You can find those versions through the link below.

Chapter 15 // Exercise 2

Define a class Fct that is just like Function except that it stores its constructor arguments. Provide Fct with "reset" operations, so that you can use it repeatedly for different ranges, different functions, etc.

Github: https://github.com/l-paz91/principles-practice/tree/master/Chapter%2015/Exercise%202

In this one took me a while as I pondered over how to re-write the points that had already been added to a shape once it's drawn. I thought about deleting the shape and creating a new one but the easiest way was to simply provide a function in Shape that clears the points vector. That way no new shapes are made and StoredFct can just call Function.

Chapter 15 // Exercise 1 - Principles & Practice Using C++

In this exercise I am using Visual Studio 2017.

Chapter 15 // Exercise 1

Here is another way of defining a factorial function:

int fac(int n) { return n > 1 ? n *fac(n - 1) : 1; }  // factorial n!

It will do fac(4) by first deciding that since 4 > 1 it must be 4 * fac(3), and that's obviously 4 * 3 * fac(2), which again is 4 * 3 *2 * fac(1), which is 4 * 3 * 2 * 1. Try to see that it works. A function that calls itself is said to be recursive. The alternative implementation in section 15.5 is called iterative bcause it iterates through the values (using while). Verify that the recursive fac() works and gives the same results as the iterative fac() by calculating the factorial of 0, 1, 2, 3, 4, up until and including 20. Which implementation of fac() do you prefer, and why?

Github: https://github.com/l-paz91/principles-practice/blob/master/Chapter%2015/Exercise%201

When using int, at 13 this will begin to overflow and return the wrong numbers. 

I also did a quick benchmark test between the two functions and there isn't really any difference. I'd say half the time, the recursive function was faster by 0.002 nanoseconds. Sometimes iterative was a bit slower or recursive was slower. They seem to be pretty balanced speed-wise. 

I looked at the disassembly and realised why they perform the same; the compiler produces the exact same assembly for both functions. I've kept this code in so you can run it yourself a few times.

So it comes down to preference. I prefer the recursive as it's less code and at a glance; easier to reason about what's happening. A lot of people don't like the ternary operator though so I can understand why the iterative version would be chosen instead.