Programming – Page 3

CategoryProgramming

Unit Testing C# With Data in Visual Studio 2012

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.

Python Socketed Receiver

March 14, 2013 / Jack Concanon / 0 Comments

This is a quite cool little class I wrote for receiving log messages over sockets. It is launched as a thread and uses a python Queue to store messages for retrieval by consumers in your main program. It also means I can have multiple sockets for different log sources.

#!/bin/python2.6

import threading
from Queue import Queue
import socket

class LoggingReceiver(threading.Thread):

    def __init__(self, host, port):
        threading.Thread.__init__(self)
        self.host = host
        self.port = port
        self.msg_queue = Queue()
        self.running = True
        self.max_waiting_connections = 10
        self.daemon = True
        self.debug = True

    def run(self):
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        s.bind((self.host, self.port))
        s.listen(self.max_waiting_connections)
        while self.running:
            accepted_socket, address = s.accept()
            self.debug_msg('Received connection from {0}'.format(address))
            msg = ""
            while self.running:
                data = accepted_socket.recv(1024)
                if not data: 
                    break
                msg += data
            self.add_message(msg, address)
        s.close()

    def debug_msg(self, msg):
        if self.debug:
            print msg

    def add_message(self, msg, source):
        self.debug_msg('{0} sent message - {1}'.format(source, msg))
        self.msg_queue.put(msg)

    def get_message(self):
        if not self.msg_queue.empty():
            msg = self.msg_queue.get()
            self.msg_queue.task_done()
            return msg

    def flush_queue(self):
        while not self.queue.empty():
            self.msg_queue.get(block=True)
            self.msg_queue.task_done()

    def stop(self):
        self.debug_msg('Stopping main loop.')
        self.running = False

#!/bin/python2.6

import threading

from Queue import Queue

import socket

class LoggingReceiver(threading.Thread):

def __init__(self, host, port):

threading.Thread.__init__(self)

self.host = host

self.port = port

self.msg_queue = Queue()

self.running = True

self.max_waiting_connections = 10

self.daemon = True

self.debug = True

def run(self):

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

s.bind((self.host, self.port))

s.listen(self.max_waiting_connections)

while self.running:

accepted_socket, address = s.accept()

self.debug_msg('Received connection from {0}'.format(address))

msg = ""

while self.running:

data = accepted_socket.recv(1024)

if not data:

break

msg += data

self.add_message(msg, address)

s.close()

def debug_msg(self, msg):

if self.debug:

print msg

def add_message(self, msg, source):

self.debug_msg('{0} sent message - {1}'.format(source, msg))

self.msg_queue.put(msg)

def get_message(self):

if not self.msg_queue.empty():

msg = self.msg_queue.get()

self.msg_queue.task_done()

return msg

def flush_queue(self):

while not self.queue.empty():

self.msg_queue.get(block=True)

self.msg_queue.task_done()

def stop(self):

self.debug_msg('Stopping main loop.')

self.running = False

September 13, 2012

Today I learnt that it is programmer’s day, apparently we’re all supposed to get beer and pizza? I for one shall be celebrating by porting various tools from Linux to Solaris.

Correct Setup of Python Easy-Install

August 11, 2012 / Jack Concanon / 1 Comment

Starting work on some python driver development today for the ant+ system (more on this later) and had to install a bunch of Python modules that didn’t appear on the standard Ubuntu repos.

Python has a very easy package manager of it’s own called easy tools which is found in the python-setuptools package. But this isn’t everything you need, you’ll receive a lot of errors when trying to use easy tools such as –

msgpack/_msgpack.c:4:20: fatal error: Python.h: No such file or directory
compilation terminated.
error: Setup script exited with error: command ‘gcc’ failed with exit status 1

In order to resolve these errors you’ll need to ensure you have g++ installed as well as the python header and static library files. These two packages are called g++ and python2.7-dev. Change the python version depending on your preference or download the python-all-dev package.

Language Detection Algorithm

May 27, 2012 / Jack Concanon / 0 Comments

My thesis required dealing with large quantities of Twitter data and to make it easier for myself I decided to only use English language tweets. Due to the ‘interesting’ grammar and spelling that is frequently found on line a different algorithm to a standard dictionary test was required. This one checks for common English n-grams (letter groupings) and returns a value of how sure the input is English.

Here’s some examples:

Good morning everyone! : 66%
Im So Sick. Really in a bad Position : 50%
Thats the fear of unicorns : 100%
Gnt too com uma saudade daminha namorada vcs nao tem ideia :(((( : 0%
Ils testent les hologrammes pour faire des concerts par des morts. Bientôt même les pas morts feront des hologrammes et vous irez les voir. : 12%
il7ain ilnass ykhl9un men habat twitter o yntqlun to istagram=))!!! : 40%

from collections import Counter

class trigram:
    ngrams = ['the', 'and', 'tha', 'ent', 'ing', 'ion', 'tio', 'for',
        'nde', 'has', 'nce', 'edt', 'tis', 'oft', 'sth', 'men', ' th', 
        'he ', 'ed ', ' of', 'in ', 'to ', 'er ', 'as ', 'her', 'ng ',
        'of ', ' an', ' in']
    probability = 0.0

    def __init__(self):
        pass

    def parse_text(self, text):
        count = 0.0
        s = set()
        length = len(text.strip(' ').split())
        for i in range( len( text ) ): s.add( text[ i: i + 3 ] )
        c = Counter(s)
        for trigram in self.ngrams:
            try:
                count += c[trigram]
            except IndexError as e:
                pass
        if length > 0:
            self.probability = (count / length) * 100.0
        else:
            self.probability = 0
        return self.probability

    def get_probability(self):
        return self.probability

    def is_english(self):
        return (self.probability > 40)

from collections import Counter

class trigram:

ngrams = ['the', 'and', 'tha', 'ent', 'ing', 'ion', 'tio', 'for',

'nde', 'has', 'nce', 'edt', 'tis', 'oft', 'sth', 'men', ' th',

'he ', 'ed ', ' of', 'in ', 'to ', 'er ', 'as ', 'her', 'ng ',

'of ', ' an', ' in']

probability = 0.0

def __init__(self):

pass

def parse_text(self, text):

count = 0.0

s = set()

length = len(text.strip(' ').split())

for i in range( len( text ) ): s.add( text[ i: i + 3 ] )

c = Counter(s)

for trigram in self.ngrams:

try:

count += c[trigram]

except IndexError as e:

pass

if length > 0:

self.probability = (count / length) * 100.0

else:

self.probability = 0

return self.probability

def get_probability(self):

return self.probability

def is_english(self):

return (self.probability > 40)

Python Feed Forward Perceptron

May 27, 2012 / Jack Concanon / 1 Comment

I thought I would post a couple of useful bits of code from my final year of university.

The first is a feed forward perceptron written in Python. I tried to expand the examples on the internet as much as possible to help me understand how they work.

#!/usr/bin/python2.7

import random

class Perceptron:

    def __init__(self, weights=None, threshold=0.5):
        self.weights = weights
        self.threshold = threshold

    def activation(self, input_vector):
        # activation of the perceptron. 
        val = sum(value * self.weights[index] for index, value in enumerate(input_vector))
        if val > self.threshold:
            return 1
        else:
            return 0

    # learning rate is also the alpha
    def train(self, training_set, learning_rate = 0.1):
        # set the initial weights to random numbers in the range [-0.5,0.5] or 0
        self.weights = [0 for i in training_set[0][0]]

        while True:
            error_count = 0
            for input_vector, desired_output in training_set:
                print self.weights
                result = self.activation(input_vector)
                error = desired_output - result
                if error != 0:
                    error_count += 1
                    # weight training
                    for index, value in enumerate(input_vector):
                        #delta rule : learning rate * error * current value                    
                        self.weights[index] += (learning_rate * error * value)
            if error_count == 0:
                break

    def test(self, training_set):
        for input_vector, desired_result in training_set:
            if(self.activation(input_vector) != desired_result):
                return False
        return True

if __name__ == "__main__":

    # values for a AND gate.
    training_set_AND = [((0, 0), 0),
    ((0, 1), 0),
    ((1, 0), 0),
    ((-1, 1), 1)]

    training_set_OR = [((0,1), 1),
                       ((1,0), 1),
                       ((0,0), 0),
                       ((1,1), 1)]

    # values for a NAND gate.
    training_set_NAND = [((1, 0, 0), 1), 
                        ((1, 1, 0), 1), 
                        ((1, 0, 1), 1),
                        ((1, 1, 1), 0)
                        ]

    p = Perceptron(None, 0.5)
    p.train(training_set_AND, 0.1)
    print p.test(training_set_AND)

#!/usr/bin/python2.7

import random

class Perceptron:

def __init__(self, weights=None, threshold=0.5):

self.weights = weights

self.threshold = threshold

def activation(self, input_vector):

# activation of the perceptron.

val = sum(value * self.weights[index] for index, value in enumerate(input_vector))

if val > self.threshold:

return 1

else:

return 0

# learning rate is also the alpha

def train(self, training_set, learning_rate = 0.1):

# set the initial weights to random numbers in the range [-0.5,0.5] or 0

self.weights = [0 for i in training_set[0][0]]

while True:

error_count = 0

for input_vector, desired_output in training_set:

print self.weights

result = self.activation(input_vector)

error = desired_output - result

if error != 0:

error_count += 1

# weight training

for index, value in enumerate(input_vector):

#delta rule : learning rate * error * current value

self.weights[index] += (learning_rate * error * value)

if error_count == 0:

break

def test(self, training_set):

for input_vector, desired_result in training_set:

if(self.activation(input_vector) != desired_result):

return False

return True

if __name__ == "__main__":

# values for a AND gate.

training_set_AND = [((0, 0), 0),

((0, 1), 0),

((1, 0), 0),

((-1, 1), 1)]

training_set_OR = [((0,1), 1),

((1,0), 1),

((0,0), 0),

((1,1), 1)]

# values for a NAND gate.

training_set_NAND = [((1, 0, 0), 1),

((1, 1, 0), 1),

((1, 0, 1), 1),

((1, 1, 1), 0)

]

p = Perceptron(None, 0.5)

p.train(training_set_AND, 0.1)

print p.test(training_set_AND)

Pointless Error Messages

May 19, 2012 / Jack Concanon / 0 Comments

Gee, thanks Battlefield

So you’re sat there playing a game, about to pull off some spectacular moves and own some noobs when your game freezes, you fall through the floor and you are dumped back into the reality of the Windows Desktop. Quietly muttering some choice words about computers you discover a fantastic error message, informing you that ‘something went wrong’… Well, thanks error message, without your thoughtful take on everything I would have presumed to have teleported into a map that looks suspiciously like my desktop!

These error messages are becoming more and more common, and yes I fully understand that the alternative is the blue screen of death, which is equally unhelpful, but if you’re going to go to the effort of handling errors correctly without breaking everything why waste all that effort by just telling the user that something went wrong. How about, something went wrong and here is what it was?

Because I want a browser with sass

If it’s that important to try and hide the gory details of an error from the average user have a nice button called technical details. Average Joe isn’t going to click that, he still thinks an illegal operation involves the police.

How about some form of standard for displaying error messages? Maybe code red, yellow and green? Easy to understand for everyone.

Got any more examples of useless error messages?

Free Twitter Data Set

May 1, 2012 / Jack Concanon / 1 Comment

I needed a twitter data set for my thesis and struggled to find one that was freely available. I ended up downloading the data I needed so I thought I would release it here. It does come in a slightly annoying format which is a MongoDB dump file but it should be easy enough to extract to there and use it. The structure of each record is shown below.

So if you wanted to go over all records in the database you would do it like this –

from pymongo import Connection

if __name__ == "__main__":

    # connect to mongodb and get tweets collection
    db_connection = Connection()
    fyp_db = db_connection.fyp
    tweets_db = fyp_db.tweets
    num_tweets = 0

    for user_col in tweets_db.find():
        num_tweets += len(user_col['tweets'])
        for friend in user_col['friends']:
            if len(user_col['friends'][friend]) > 0:
                num_tweets += len(user_col['friends'][friend])

from pymongo import Connection

if __name__ == "__main__":

# connect to mongodb and get tweets collection

db_connection = Connection()

fyp_db = db_connection.fyp

tweets_db = fyp_db.tweets

num_tweets = 0

for user_col in tweets_db.find():

num_tweets += len(user_col['tweets'])

for friend in user_col['friends']:

if len(user_col['friends'][friend]) > 0:

num_tweets += len(user_col['friends'][friend])

Download Twitter Mongo Dump

CryENGINE 3

April 17, 2012 / Jack Concanon / 0 Comments

The latest version of the Crytek engine has been released, yet again pushing what you think is possible on current hardware. Another good bit of information is that Crysis 3 will be out next year. Unfortunately that means it will be released on the Xbox and the PS3 which seriously hampered the graphic performance in Crysis 2. Now if they were to focus on a PC only version we could really see some of the magic that the original Crysis brought to it. Fun fact, the original Crysis was being used as a benchmark in Custom PC magazine three years after it was released.

Check out the video here –

How awesome would it be to see Skyrim using this engine?

Code Golf Progress Bar

April 3, 2012 / Jack Concanon / 0 Comments

Had a go at some code golf today, went for this challenge: http://codegolf.stackexchange.com/questions/5382/create-an-ascii-progress-bar

Here is my solution which is 125 characters small.

a,b=raw_input().split()
a=int(a)
b=float(b)
c=int(a*b)
d="|"*c+" "*(a-c)
e=len(d)/2
print"["+d[:e]+`int(b*100)`+"%"+d[e:]+"]"

a,b=raw_input().split()

a=int(a)

b=float(b)

c=int(a*b)

d="|"*c+" "*(a-c)

e=len(d)/2

print"["+d[:e]+`int(b*100)`+"%"+d[e:]+"]"

So the output for this would be as such:

jack@Icarus:~/Projects/code golf$ python progress_bar.py 
10 0.7
[|||||70%||   ]
jack@Icarus:~/Projects/code golf$ python progress_bar.py 
10 0.56
[|||||56%     ]
jack@Icarus:~/Projects/code golf$ python progress_bar.py 
10 0.8
[|||||80%|||  ]

jack@Icarus:~/Projects/code golf$ python progress_bar.py

10 0.7

[|||||70%|| ]

jack@Icarus:~/Projects/code golf$ python progress_bar.py

10 0.56

[|||||56% ]

jack@Icarus:~/Projects/code golf$ python progress_bar.py

10 0.8

[|||||80%||| ]

Theme by Anders Norén — Up ↑

Categories

Meta

CategoryProgramming

Unit Testing C# With Data in Visual Studio 2012

Optimising C++ The STL Way

Vinaigrette Sort

Python Socketed Receiver

Correct Setup of Python Easy-Install

Language Detection Algorithm

Python Feed Forward Perceptron

Pointless Error Messages

Free Twitter Data Set

CryENGINE 3

Code Golf Progress Bar

Recent Comments