Прецессия орбиты - это чисто из-за погрешности вычислений, я так понял? Типа шаг большой и судя по всему метод не особо устойчивый, самый плюшевый (Ньютона).
Или всё же ОТО?     

Вот что у меня:
CFLAGS        = -pipe -O2 -Wall -W -D_REENTRANT $(DEFINES)
CXXFLAGS      = -pipe -O2 -Wall -W -D_REENTRANT $(DEFINES)

C++ (Qt)
size = 2000000
gm_NumSort : 2.45 sec
std::sort : 0.27 sec
 

C++ (Qt)
size = 20000000
gm_NumSort : 11.16 sec
std::sort : 3.3 sec
 

C++ (Qt)
size = 200000000
gm_NumSort : 31.8 sec
std::sort : 38.51 sec
 

CFLAGS        = -pipe -O3 -Wall -W -D_REENTRANT $(DEFINES)
CXXFLAGS      = -pipe -O3 -Wall -W -D_REENTRANT $(DEFINES)

C++ (Qt)
size = 2000000
gm_NumSort : 0.99 sec
std::sort : 0.27 sec
 

C++ (Qt)
size = 20000000
gm_NumSort : 5.6 sec
std::sort : 3.31 sec
 

C++ (Qt)
size = 200000000
gm_NumSort : 25.21 sec
std::sort : 38.76 sec
 

У меня AMD64 1.8 Гц а у вас?

Вот почитайте: http://www.cplusplus.com/reference/algorithm/sort/
А вообще, всё зависит от конкретной её реализации.
У меня:

C++ (Qt)
max@T1000:~$ g++ --version
g++ (Ubuntu 4.4.3-4ubuntu5) 4.4.3
 

Не спешите. Ваша оптимизация не даёт заметного выигрыша: результат примерно тот же (попробуйте запустить на вашей машине этот код):

C++ (Qt)
#include <iostream>
#include <cstring>
#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <cstdio>
#include "gm_num_sort.h"
 
using namespace std;
 
 
 
int main()
{
    srand(time(0));
    const unsigned int size = 2000000;
    int arr[size];
    for (int i = 0; i < size; ++i) {
        arr[i] = rand();
    }
 
    clock_t tStart = clock();
    gm_NumSort(arr, size);
    cout << "gm_NumSort : " << (float)(clock() - tStart) / CLOCKS_PER_SEC << " sec" << endl;
 
    for (int i = 0; i < size; ++i) {
        arr[i] = rand();
    }
 
    tStart = clock();
    sort(arr, arr+size);
    cout << "std::sort : " << (float)(clock() - tStart) / CLOCKS_PER_SEC << " sec" << endl;
 
    return 0;
}
 

У меня получается следующее (release -O2):

C++ (Qt)
gm_NumSort : 2.44 sec
std::sort : 0.27 sec
 

Однако, Ваш алгоритм действительно примерно в 1.5 раза быстрее в том случае, если числа относительно малы. Но если диапазон  [0, RAND_MAX) то выигрывает std::sort  

Вопрос: Так какова истинная сложность вашего алгоритма в действительности?  
  

А ещё хотел спросить:
В смысле кое-как? Как вы её компилировали?

Подправил.
Перед тем как будете компилировать, убедитесь, что путь указанный в plotter.pro, а именно

C++ (Qt)
LP2D_LIB = c:/lightplot2d-1.0.1/lib
LP2D_INCLUDE = c:/lightplot2d-1.0.1/include
 

действительно указаны правильно.
После компиляции, если всё правильно сделано, должен получиться exe шник, в папке bin. Но, он не запуститься, поскольку линковщик не сможет найти либы от lightplot2d. Не расстраивайтесь: нужно к экзешнику просто кинуть получившуюся dll (lightplot2d1.dll) и запустить Plotter заново.
Всё должно получиться)
 

Ну я не телепат) Поподробнее опишите ситуацию. Что за ось, как собирали, какие ошибки ну и т.д.   

Это понятно)

Почему тогда по времени почти на порядок выигрывает библиотечная std::sort? На сколько мне известно сложность там оценивается как O(N lnN). А время на сортировку в разы меньше?
Оценивалось это так:

C++ (Qt)
#include <iostream>
#include <cstring>
#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <cstdio>
#include <limits>
 
using namespace std;
 
extern void numsort   (int* arr, unsigned int size);
extern int  numunique (int* arr, unsigned int size);
extern void numsort   (unsigned int* arr, unsigned int size);
extern int  numunique (unsigned int* arr, unsigned int size);
 
unsigned char getbyte(int val, unsigned int digitpos) {
  if(digitpos == sizeof(int)) {
    return val>=0?1:0;
  }
 
  if(digitpos > 0) {
    val = val >> 8*digitpos;
  }
  val = val & 0xFF;
  return val;
}
 
void swap(unsigned int* val1, unsigned int* val2) {
  unsigned int val = *val1;
  *val1 = *val2;
  *val2 = val;
}
 
void digitsort(unsigned int* arr, unsigned int size, unsigned int digitpos) {
   unsigned int spos[256+1];
   unsigned int npos[256];
 
   memset(&spos, 0, (256+1)*sizeof(int));
   for(int i=0; i<size; ++i) {
     spos[getbyte(arr[i], digitpos)+1]++;
   }
   for(int i=0; i<256; ++i) {
     spos[i+1] += spos[i];
   }
   memcpy(&npos, &spos, 256*sizeof(int));
 
   unsigned int val1;
   unsigned int val2;
   for(int i=0; i<size;) {
     val1 = getbyte(arr[i], digitpos);
     if(i >= spos[val1] && i < npos[val1]) {
       i = npos[val1];
       continue;
     }
     if(i == npos[val1]) {
       npos[val1]++;
       ++i;
       continue;
     }
     val2 = getbyte(arr[npos[val1]], digitpos);
     while(val2 == val1) {
       npos[val1]++;
       val2 = getbyte(arr[npos[val1]], digitpos);
     }
     swap(&arr[i], &arr[npos[val1]]);
   }
 
   if(!digitpos) {return;}
   digitpos--;
   for(int i=0; i<256; ++i) {
     size = spos[i+1]-spos[i];
     if(!size) {continue;}
     digitsort(arr+spos[i], size, digitpos);
   }
}
 
void numsort(unsigned int* arr, unsigned int size) {
  if(!size) {return;}
  digitsort(arr, size, sizeof(int)-1);
}
 
void numsort(int* arr, unsigned int size) {
  if(!size) {return;}
  digitsort((unsigned int*)arr, size, sizeof(int));
}
 
int  numunique (unsigned int* arr, unsigned int size) {
  if(!size) {return 0;}
  digitsort(arr, size, sizeof(int)-1);
 
  int n = 1;
  unsigned int val = arr[0];
  for(int i=1; i<size; ++i) {
    if(val == arr[i]) {continue;}
    val = arr[i];
    if(i != n) {arr[n] = val;}
    ++n;
  }
 
  return n;
}
 
int  numunique (int* arr, unsigned int size) {
  if(!size) {return 0;}
  digitsort((unsigned int*)arr, size, sizeof(int));
 
  int n = 1;
  int val = arr[0];
  for(int i=1; i<size; ++i) {
    if(val == arr[i]) {continue;}
    val = arr[i];
    if(i != n) {arr[n] = val;}
    ++n;
  }
 
  return n;
}
 
int main()
{
    srand(time(0));
    const unsigned int size = 2000000;
    int arr[size];
    for (int i = 0; i < size; ++i) {
        arr[i] = rand();
    }
 
    clock_t tStart = clock();
    //numsort(arr, size);
    sort(arr, arr+size);
    cout << (float)(clock() - tStart) / CLOCKS_PER_SEC << endl;
 
    return 0;
}
 

   
 

Вы, перед тем как выкладывать, проверяли корректно ли работает этот алгоритм?

numsort - судя по всему сортирует массив, но увы не всегда верно
например если взять вот такой массив: int arr[] = { 1, 2, 6, -4, 0, -9 };     

А как оценивается сложность O(N) - по числу обращений к элементам массива или по числу сравнений?
Или как? 

Слава богу в моём случае решение нашлось достаточно быстро)

Как выяснилось, у нас в Университете есть специальный отдел: лицензирования и патентования (ну или как-то так.. дословно не помню) и весь геморрой по продвижению всего ентого дела они берут на себя, в том числе и оплату - частичную или полностью в зависимости кто является заявителем. От меня нужно пара заполненных бумажек: автореферат, машиночитабельный фрагмент кода ну и ещё пару бумаг и мои подписи в нужных местах. Всё остальное - это их заботы, а цена - универ получает права, по которым, в случае коммерческого интереса сей софтины с ним придётся делиться.
       

Спасибо за ссылку)

Это в первую очередь нужно, чтоб можно было к отчёту о проделанной работе прикрепить бумажку, где подтверждается, что есть законченный программный продукт, с помощью которого выполнялись расчёты которые в конечном счёте были опубликованы там-то и там-то..
Ну как-то так)) 

Выкладываю пример использования lightplot2d. (эдакий форк на  на одну из первых реализаций)
Пример требует предустановленного lightplot2d, разумеется.

С иконками, опять же туговато, так что кто может: буду признателен, если нарисуете)

Вечер добрый!

Хотелось бы услышать мнение тех, кому приходилось сталкиваться с сей проблемой.
Обрисую ситуацию:
Я написал программку, достаточно специфичную - для очень узкого круга пользователей. Нужно оформить авторское право на неё, чтоб была бумажка. Это нужно только лишь для того, чтоб отчитаться по гранту. Исходники в принципе открыты, да они уверен, не кому и не понадобятся (продавать её тоже в мыслях и не было). GUI написано на Qt, ядро на чистом C++.
Оформить это всё нужно в ближайшие 2 месяца. Да и авторские права, по всей видимости будут принадлежать университету.

Если кто-нибудь сталкивался с подобного рода процедурой, подскажите пожалуйста как это менее болезненно можно провернуть? Есть ли какие нить фишки? Подводные камни?

Заранее спасибо!   

Говорят оч помогает зарядка для глаз)
Ещё слышал, что зрение можно даже восстановить, если ежедневно её (зарядку) делать. Правда, я не проверял, но  наткнулся я на эту инфу на ентом форуме)) Из любопытства зайдя по ссылке в подписи у panAlexey. На том сайте есть видео лекции, где рассказывается, в частности, как можно восстановить зрение.

Вроде бы все аргументы указывают на то, что это реально возможно, но как я говорил, на себе не проверял)
   

Зачем так сложно)

Засуньте их в отдельный заголовочный файл, можете окружить это всё namespace и подключайте его (.h файл) туда, где эти константы будут нужны.

Обоснованные аргументы, обоснованные аргументы.. Всё гениальное - просто)