c++ – Acodemics

Tagc++

Merry Christmas!

Merry Christmas from me at Acodemics!

Here’s a little bit of code that will make snowfall in your terminal, it’s awkward on purpose 🙂

#include <iostream>
#include <time.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>

int main() {
    const int w = 80; const int h = 24;
    uint16_t a[h][w] = {0x2000};
    for(;;) {
        for(int i = 0; i < h-1; ++i) {
            for(int j = 0; j < w; ++j) {
                if(!i && !(rand() % 5))
                    a[0][j] = 0x2A00;
                std::cout << char(a[i][j] >> 8);
                if(a[i][j] == 0x2A00) {
                    a[i+1][j] = 0x2A01;
                    a[i][j] = 0x2000;
                }
            }
            std::cout << std::endl;
        }
        for(int i = 0; i < h; ++i)
            for(int j = 0; j < w; ++j)
                a[i][j] &= 0xFF00;
        usleep(250000);
    }
    return 0;
}

#include <iostream>

#include <time.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <stdint.h>

int main() {

const int w = 80; const int h = 24;

uint16_t a[h][w] = {0x2000};

for(;;) {

for(int i = 0; i < h-1; ++i) {

for(int j = 0; j < w; ++j) {

if(!i && !(rand() % 5))

a[0][j] = 0x2A00;

std::cout << char(a[i][j] >> 8);

if(a[i][j] == 0x2A00) {

a[i+1][j] = 0x2A01;

a[i][j] = 0x2000;

}

std::cout << std::endl;

}

for(int i = 0; i < h; ++i)

for(int j = 0; j < w; ++j)

a[i][j] &= 0xFF00;

usleep(250000);

}

return 0;

}

C# DateTimePicker in PropertyGrid

March 20, 2014 / Jack Concanon / 1 Comment

Property grids are great for quickly giving users an interface for interacting with objects in WPF but customising them is not obvious. Luckily it is possible by extending the UIEditor class to launch custom GUI controls.

In this example I wanted to customise the default DateTime handler of PropertyGrid to include hours, minutes and seconds as unfortunately it only shows the date by default. The following class shows how to extend UIEditor in order to launch a pop-up DateTimePicker when the user selects the item.

using System;
using System.ComponentModel;
using System.Drawing.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;

namespace Util
{
    public class DateTimePickerEditor : UITypeEditor
    {

        IWindowsFormsEditorService editorService;
        DateTimePicker picker = new DateTimePicker();

        public DateTimePickerEditor()
        {
            picker.Format = DateTimePickerFormat.Custom;
            picker.CustomFormat = "dd/MM/yyyy HH:mm:ss";
        }

        public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
        {
            return UITypeEditorEditStyle.DropDown;
        }

        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            if (provider != null)
            {
                this.editorService = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
            }

            if (this.editorService != null)
            {
                picker.Value = value;
                this.editorService.DropDownControl(picker);
                value = picker.Value;
            }

            return value;
        }
    }
}

using System;

using System.ComponentModel;

using System.Drawing.Design;

using System.Windows.Forms;

using System.Windows.Forms.Design;

namespace Util

{

public class DateTimePickerEditor : UITypeEditor

{

IWindowsFormsEditorService editorService;

DateTimePicker picker = new DateTimePicker();

public DateTimePickerEditor()

{

picker.Format = DateTimePickerFormat.Custom;

picker.CustomFormat = "dd/MM/yyyy HH:mm:ss";

}

public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)

{

return UITypeEditorEditStyle.DropDown;

}

public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)

{

if (provider != null)

{

this.editorService = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;

}

if (this.editorService != null)

{

picker.Value = value;

this.editorService.DropDownControl(picker);

value = picker.Value;

}

return value;

}

Then in order to add that to your property grid, add the following to the DateTime item in the class used by the PropertyGrid –

[DisplayName("Start Time"), EditorAttribute(typeof(DateTimePickerEditor), typeof(UITypeEditor))]
public DateTime StartTime
{
    get { return startTime; }
    set { startTime = value; }
}

[DisplayName("Start Time"), EditorAttribute(typeof(DateTimePickerEditor), typeof(UITypeEditor))]

public DateTime StartTime

{

get { return startTime; }

set { startTime = value; }

}

The key part here is the EditorAttribute.

Update

Here’s a great article explaining custom UITypeEditors in more detail – http://bobpowell.net/TypeEditors.aspx

Compare Lists in C# Unit Tests

September 16, 2013 / Jack Concanon / 0 Comments

A small thing that caught me out today, while writing a unit test for C# I wanted to check that a list was returned in the expected order and used Assert.AreEqual to compare them, this kept failing despite the two lists being exactly the same.

It turns out that there is a separate CollectionsAssert class that is to be used for lists or any form of C# collection and that is due to the List<T> class not overriding the Equals method, the AreEqual function will just check the references instead.

Here is an example of a working unit test comparing two lists.

using System;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace TestFunctions
{
    [TestClass]
    public class SortedTupleDictionaryTest
    {
        [TestMethod]
        public void TestSortedDictionaryTupleOrder()
        {
            SortedDictionary<Tuple<int, int, int>, string> dict = new SortedDictionary<Tuple<int, int, int>, string>();
            dict.Add(Tuple.Create(1, 1, 1), "apple");
            dict.Add(Tuple.Create(1, 2, 1), "chair");
            dict.Add(Tuple.Create(1, 1, 2), "bear");
            dict.Add(Tuple.Create(2, 2, 1), "deer");

            List<Tuple<int, int, int>> expected = new List<Tuple<int, int, int>>();
            expected.Add(Tuple.Create(1, 1, 1));
            expected.Add(Tuple.Create(1, 1, 2));
            expected.Add(Tuple.Create(1, 2, 1));
            expected.Add(Tuple.Create(2, 2, 1));

            CollectionAssert.AreEqual(expected, dict.Keys);

        }
    }
}

using System;

using System.Collections.Generic;

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace TestFunctions

{

[TestClass]

public class SortedTupleDictionaryTest

{

[TestMethod]

public void TestSortedDictionaryTupleOrder()

{

SortedDictionary<Tuple<int, int, int>, string> dict = new SortedDictionary<Tuple<int, int, int>, string>();

dict.Add(Tuple.Create(1, 1, 1), "apple");

dict.Add(Tuple.Create(1, 2, 1), "chair");

dict.Add(Tuple.Create(1, 1, 2), "bear");

dict.Add(Tuple.Create(2, 2, 1), "deer");

List<Tuple<int, int, int>> expected = new List<Tuple<int, int, int>>();

expected.Add(Tuple.Create(1, 1, 1));

expected.Add(Tuple.Create(1, 1, 2));

expected.Add(Tuple.Create(1, 2, 1));

expected.Add(Tuple.Create(2, 2, 1));

CollectionAssert.AreEqual(expected, dict.Keys);

}

Unit Testing and Code Coverage Results in Jenkins CI

August 16, 2013 / Jack Concanon / 0 Comments

Unit testing is great, code coverage is great and continuous integration servers are great; but what isn’t great is combining all three into something useful!

If you are coding in Java then code coverage is fantastically simple but what if you use C++ and GoogleTest and want the same level of graphification? Luckily it is also simple if you know how – so you’re in the right place.

The scenario here is that you have a C++ project being built on a Jenkins/Hudson continuous integration setup and you also use Google Test for your unit tests. The software required for this is GCC 4.7 which should contain a tool called gcov, this will create the actual coverage files for your executable but will require some additional linker and library options to be added to your build scripts or make files. The final piece of software required is called gcovr, this is a Python script that is designed to read the output files from gcov linked executables and convert it into an XML format that can be read by the Cobertura plugin in Jenkins/Hudson.

It is a good idea to add a separate make target for coverage as it requires the executables to be built with no optimisation and a lot of debug symbols, so not very useful for production environments.

Add the following to your CPPFLAGS –

-fprofile-arcs -ftest-coverage -O0

1	-fprofile-arcs -ftest-coverage -O0

And this to your LDFLAGS

-lgcov

-lgcov

So for example you could have a section in your makefile that looks like this (assuming the test target builds your unit test.) –

coverage: CPPFLAGS += -fprofile-arcs -ftest-coverage -O0
coverage: LDFLAGS += -lgcov
coverage: test

coverage: CPPFLAGS += -fprofile-arcs -ftest-coverage -O0

coverage: LDFLAGS += -lgcov

coverage: test

After you have run the coverage build target you then have to run the test executable, this generates .gcov files that describe which lines of code are covered and by what functions.

Then ensure that you can access the gcovr script and run it with the following arguments –

./test
chmod a+x ./gcovr
./gcovr --gcov-exclude=".*gtest.*" -x -d &gt; coverage.xml

./test

chmod a+x ./gcovr

./gcovr --gcov-exclude=".*gtest.*" -x -d > coverage.xml

The –gcov_exlcude will remove any unnecessary parsing of files from the GoogleTest framework. The output is placed into the coverage.xml file which can then be accessed from Jenkins by adding a new Post-Build Action from the job configuration page.

Unit Testing C# With Data in Visual Studio 2012

May 16, 2013 / Jack Concanon / 0 Comments

When writing unit tests it is likely you will need to include some additional input files containing data or settings etc. If you’re trying to include some data for a C# unit test and are using Visual Studio 2012 follow this guide –

Add a separate folder for data to the project then ‘add an existing item’ and select your files.
In the Solution Explorer, navigate to your newly added file, right click and go to properties.
Set ‘Copy to Output Directory’ to an appropriate option.
When you want to use this data in a unit test add the following before the function – [DeploymentItem(“Data”, “Data”)]

The line in the last step will copy all data from Data in your build directory to the a new folder in the test directory.

I presume that these instructions will apply to older versions of Visual Studio.

Optimising C++ The STL Way

May 16, 2013 / Jack Concanon / 0 Comments

A co worker emailed out an interesting question, how would we optimise the following piece of code –

// Returns the average of k smallest values from the array arr of size n.
// The original order of elements in arr is not guaranteed to be preserved.
float average_of_k_smallest(float* arr, int n, int k)
{
    assert(k > 0 && k <= n);

    std::sort(arr, arr + n);
    float s = 0.0f;
    for (int i = 0; i < k; i++) s += arr[i];
    return s/k;
}

// Returns the average of k smallest values from the array arr of size n.

// The original order of elements in arr is not guaranteed to be preserved.

float average_of_k_smallest(float* arr, int n, int k)

{

assert(k > 0 && k <= n);

std::sort(arr, arr + n);

float s = 0.0f;

for (int i = 0; i < k; i++) s += arr[i];

return s/k;

}

The code looks fast, light and up to the job right? Sure, it will work fine and it will be reasonably fast, but it can always be faster. The first obvious waste of time is with the sort; sorts are lengthy beasts and as much as possible should be done to minimise their impact. The aim of this function is to get the average of the k smallest values in the array, imagine if the array is ten thousand elements big and you only need the average of the two smallest? Sorting that entire array just to get two values is a waste of time.

So, how do we optimise this? My lecturer at university always used to tell us how good the STL is and that it was nearly always better and faster than anything we can write. The obvious solution is to move away from the primitive programming shown in the above function and see what the STL can do for us; luckily enough there are several great functions that do exactly what we want. The first great time saver is the partial sort which simply sorts the array in such a way that the range we specify contains the sorted elements but anything above that middle point is left unsorted. Simply using this method would save a large amount of time over the original method of doing a full sort.

The only requirement of these improvements is to change the function parameters to accept a vector rather than a float array, luckily there were no rules set in the original question!

In order to show that these changes would be faster I wrote some code to prove it. It runs the old function and the new function ten thousand times with the same data and calculates the time taken based on clock cycles. The quicker the better. Take note that the time also includes creating a copy of the input array. If we just pass in the array it will be sorted in place so in reality we are testing how quick it is on already sorted data.

#include <iostream>
#include <ctime>
#include <vector>
#include <algorithm>
#include <iterator>
#include <numeric>
#include <cassert>

using namespace std;

const int ARRAY_SIZE = 10000;
const int FIND_SMALLEST = 300;
const int RUN_N_TIMES = 10000;

float average_of_k_smallest(float* arr, int n, int k);
float average_of_k_smallest_partial_sort(vector<float> arr, int n);

int main(int argc, char* argv[]) {

    clock_t begin, end;
    float res;

    srand(time(NULL));
    float array[ARRAY_SIZE];
    vector<float> array_v(ARRAY_SIZE);
    // load the array with random data
    for(int i = 0; i < ARRAY_SIZE; ++i) {
        array[i] = (float)rand()/(float)RAND_MAX; // random numbers from 0..1
        array_v[i] = array[i];
    }

    begin = clock();
    for(int i = 0; i < RUN_N_TIMES; ++i) {
        // Make a copy of the array due to array being passed by reference.
        float array_copy[ARRAY_SIZE];
        copy(&array[0], &array[ARRAY_SIZE], &array_copy[0]);
        res = average_of_k_smallest(array_copy, ARRAY_SIZE, FIND_SMALLEST);
    }
    end = clock();
    cout << "Original function: (" << res << ") " << (float)(end - begin)/CLOCKS_PER_SEC << " sec" << endl;

    begin = clock();
    for(int i = 0; i < RUN_N_TIMES; ++i) {
        // Make a copy of the array
        vector<float> array_copy(array_v);
        res =average_of_k_smallest_partial_sort(array_copy, FIND_SMALLEST);
    }
    end = clock();

    cout << "STL function: (" << res << ") " << (float)(end - begin)/CLOCKS_PER_SEC << " sec" << endl;

    return 0;
}

// Returns the average of k smallest values from the array arr of size n.
// The original order of elements in arr is not guaranteed to be preserved.
float average_of_k_smallest(float *arr, int n, int k) {
    assert(k > 0 && k <= n);
    std::sort(arr, arr + n);
    float s = 0.0f;
    for (int i = 0; i < k; i++) s += arr[i];
    return s/k;
}

float average_of_k_smallest_partial_sort(vector<float> arr_v, int k) {
    partial_sort(arr_v.begin(), arr_v.begin()+k, arr_v.end());
    float sum = accumulate(arr_v.begin(), arr_v.begin()+k, 0.0);
    return sum/k;
}

#include <iostream>

#include <ctime>

#include <vector>

#include <algorithm>

#include <iterator>

#include <numeric>

#include <cassert>

using namespace std;

const int ARRAY_SIZE = 10000;

const int FIND_SMALLEST = 300;

const int RUN_N_TIMES = 10000;

float average_of_k_smallest(float* arr, int n, int k);

float average_of_k_smallest_partial_sort(vector<float> arr, int n);

int main(int argc, char* argv[]) {

clock_t begin, end;

float res;

srand(time(NULL));

float array[ARRAY_SIZE];

vector<float> array_v(ARRAY_SIZE);

// load the array with random data

for(int i = 0; i < ARRAY_SIZE; ++i) {

array[i] = (float)rand()/(float)RAND_MAX; // random numbers from 0..1

array_v[i] = array[i];

}

begin = clock();

for(int i = 0; i < RUN_N_TIMES; ++i) {

// Make a copy of the array due to array being passed by reference.

float array_copy[ARRAY_SIZE];

copy(&array[0], &array[ARRAY_SIZE], &array_copy[0]);

res = average_of_k_smallest(array_copy, ARRAY_SIZE, FIND_SMALLEST);

}

end = clock();

cout << "Original function: (" << res << ") " << (float)(end - begin)/CLOCKS_PER_SEC << " sec" << endl;

begin = clock();

for(int i = 0; i < RUN_N_TIMES; ++i) {

// Make a copy of the array

vector<float> array_copy(array_v);

res =average_of_k_smallest_partial_sort(array_copy, FIND_SMALLEST);

}

end = clock();

cout << "STL function: (" << res << ") " << (float)(end - begin)/CLOCKS_PER_SEC << " sec" << endl;

return 0;

}

// Returns the average of k smallest values from the array arr of size n.

// The original order of elements in arr is not guaranteed to be preserved.

float average_of_k_smallest(float *arr, int n, int k) {

assert(k > 0 && k <= n);

std::sort(arr, arr + n);

float s = 0.0f;

for (int i = 0; i < k; i++) s += arr[i];

return s/k;

}

float average_of_k_smallest_partial_sort(vector<float> arr_v, int k) {

partial_sort(arr_v.begin(), arr_v.begin()+k, arr_v.end());

float sum = accumulate(arr_v.begin(), arr_v.begin()+k, 0.0);

return sum/k;

}

And the results speak for themselves, across ten thousand iterations of each function the STL function is generally twice as fast.

Original function: (0.0157705) 20.56 sec
STL function: (0.0157705) 7.75 sec

Vinaigrette Sort

May 15, 2013 / Jack Concanon / 0 Comments

When programming in C for embedded systems where memory, disk usage and CPU usage are all very strict there are several ‘rules’ in place such as not use dynamically allocated arrays; this ensures that you can retain more control over memory management.

In a recent experience I had a fixed size array which was always populated below capacity, this array needed to be sorted which would normally leave my zero initialised elements at the start of my array and mess up my loop logic further on in the program.

I had an idea that I could use my sort comparison function to do two things – the first is the original sort purpose of ordering my elements, the second would be to move all unused elements to the end of the array.

Guess what, it’s very simple! I present the vinaigrette sort (so called because the oil and vinegar separate into layers in a vinaigrette).

/* Vinaigrette sort example.
   Author: Jack Concanon
   Date:   14/05/2013
   Website: www.acodemics.co.uk
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

const int BUF_SIZE = 14;
const int NUM_SENSORS = 7;

typedef struct {
    unsigned int id;
    float value;
} Data;

void printBuffer(Data *buf, unsigned size);
int compare(const void *elem1, const void *elem2);

int main(int argc, char* argv[]) {

    Data d[BUF_SIZE];
    memset(d, 0, sizeof(Data)*BUF_SIZE); // Important to zero the array.
    srand(time(NULL));

    unsigned i;
    for(i = 0; i < NUM_SENSORS; ++i) {
        d[i].id = rand(); // random ID number.
        d[i].value = rand(); // random sample value.
    }

    printf("-------- Unsorted array --------\n");
    printBuffer(d, BUF_SIZE);

    // The Magic
    // Sort the d array by ID but at the same time
    //   bubble empty elements to the end.
    qsort(d, BUF_SIZE, sizeof(Data), compare);

    printf("\n\n-------- Sorted By ID --------\n");
    printBuffer(d, BUF_SIZE); 

    return 0;
}

int compare(const void *elem1, const void *elem2) {
    const Data *da = elem1;
    const Data *db = elem2;
    if(db->id == 0) { return -1; }  // Move empty elements to the end
    //if(da->id == 0) { return 1; } // Force empty structs to bubble to beginning.

    if(da->id > db->id) { return 1; }
    if(da->id < db->id) { return -1; }
    return 0;
}

void printBuffer(Data *buf, unsigned size) {
    // loop 'size' times over buf and print.
    unsigned i = 0;
    for(i = 0; i < size; ++i) {
        printf("%d %f\n", buf[i].id, buf[i].value);
    }
}

/* Vinaigrette sort example.

Author: Jack Concanon

Date: 14/05/2013

Website: www.acodemics.co.uk

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

const int BUF_SIZE = 14;

const int NUM_SENSORS = 7;

typedef struct {

unsigned int id;

float value;

} Data;

void printBuffer(Data *buf, unsigned size);

int compare(const void *elem1, const void *elem2);

int main(int argc, char* argv[]) {

Data d[BUF_SIZE];

memset(d, 0, sizeof(Data)*BUF_SIZE); // Important to zero the array.

srand(time(NULL));

unsigned i;

for(i = 0; i < NUM_SENSORS; ++i) {

d[i].id = rand(); // random ID number.

d[i].value = rand(); // random sample value.

}

printf("-------- Unsorted array --------\n");

printBuffer(d, BUF_SIZE);

// The Magic

// Sort the d array by ID but at the same time

// bubble empty elements to the end.

qsort(d, BUF_SIZE, sizeof(Data), compare);

printf("\n\n-------- Sorted By ID --------\n");

printBuffer(d, BUF_SIZE);

return 0;

}

int compare(const void *elem1, const void *elem2) {

const Data *da = elem1;

const Data *db = elem2;

if(db->id == 0) { return -1; } // Move empty elements to the end

//if(da->id == 0) { return 1; } // Force empty structs to bubble to beginning.

if(da->id > db->id) { return 1; }

if(da->id < db->id) { return -1; }

return 0;

}

void printBuffer(Data *buf, unsigned size) {

// loop 'size' times over buf and print.

unsigned i = 0;

for(i = 0; i < size; ++i) {

printf("%d %f\n", buf[i].id, buf[i].value);

}

It is as simple as modifying the compare function required by the qsort function. Check if a field in your struct (or your data) is zero and therefore unused and then declare it as ‘greater’ than any comparison. I did find that an older GCC version (3.7) required the line as described in the above source code, GCC 4.7 compiled and ran as required with just the one comparison.

Note the memset line, if you leave the array uninitialised then the compare won’t have anything defined to search for that would signify an unused element.

Reading a CSV File in C++

March 8, 2010 / Jack Concanon / 0 Comments

This is an example of how to read a CSV file in C++, the while loop and the struct will need to be changed according to how your CSV file is set up. In mine I only require the name and id so use two getlines in the while loop. This most likely could be optimised in some way.

/*
 The CSV data

john, 1
paul, 2
frank, 3
sarah, 4
jones, 5
jack, 6

*/

#include <iostream>
#include <sstream>
#include <fstream>
#include <string>

using namespace std;

struct employees {
	string name;
	int id;
};

int main ()
{
	employees emp[6]; //array of employee structs
	employees employee; //temp employee struct for use in the while loop
    ifstream inFile("test.csv"); //our file
    string line;
    int linenum = 0;

    while (getline (inFile, line))
    {
        istringstream linestream(line);
        string item;

		//use this to get up to the first comma
		getline(linestream, item, ',');
		employee.name = item;

		//convert to a string stream and then put in id.
		getline(linestream, item, ',');
		stringstream ss(item);
		ss >> employee.id;

		//add the new employee data to the database
		emp[linenum] = employee;

		linenum++;
    }

	//output the employee data.
	for(int i = 0; i < 6; i++) 
	{
		cout << "name: " << emp[i].name << " id: " << emp[i].id << endl;
	}

    return 0;
}

The CSV data

john, 1

paul, 2

frank, 3

sarah, 4

jones, 5

jack, 6

#include <iostream>

#include <sstream>

#include <fstream>

#include <string>

using namespace std;

struct employees {

string name;

int id;

};

int main ()

{

employees emp[6]; //array of employee structs

employees employee; //temp employee struct for use in the while loop

ifstream inFile("test.csv"); //our file

string line;

int linenum = 0;

while (getline (inFile, line))

{

istringstream linestream(line);

string item;

//use this to get up to the first comma

getline(linestream, item, ',');

employee.name = item;

//convert to a string stream and then put in id.

getline(linestream, item, ',');

stringstream ss(item);

ss >> employee.id;

//add the new employee data to the database

emp[linenum] = employee;

linenum++;

}

//output the employee data.

for(int i = 0; i < 6; i++)

{

cout << "name: " << emp[i].name << " id: " << emp[i].id << endl;

}

return 0;

}

Theme by Anders Norén — Up ↑

Categories

Meta

Tagc++

Merry Christmas!

C# DateTimePicker in PropertyGrid

Compare Lists in C# Unit Tests

Unit Testing and Code Coverage Results in Jenkins CI

Unit Testing C# With Data in Visual Studio 2012

Optimising C++ The STL Way

Vinaigrette Sort

Reading a CSV File in C++

Recent Comments