- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
int error = (unsigned)-1;
int x, y, w, h;
x = y = w = h = error;
stream >> x >> y >> w >> h;
if(x == error || y == error || w == error || h == error)
...
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+14
int error = (unsigned)-1;
int x, y, w, h;
x = y = w = h = error;
stream >> x >> y >> w >> h;
if(x == error || y == error || w == error || h == error)
...
Не нашёл, как по-другому обрабатывать ошибки текстовых командах.
+16
// Lock the write mutex, to provide consistency of data
#define LOCK \
if (_ugb) { \
if (pthread_mutex_lock(&_write_mutex) == EINVAL) \
ASSERT(0); \
}
// Unlock write mutex when data sent
#define UNLOCK \
if (_ugb) { \
if (pthread_mutex_unlock(&_write_mutex) == EINVAL) \
ASSERT(0); \
}
// Пример использования
void socket::add_var(uint16_t code, const void *buffer, uint32_t length)
{
LOCK
try
{
DEBUG_I(Vblock, "Sending code 0x%X of size 0x%X\n", code, length);
send(&code, sizeof(code));
send(&length, sizeof(length));
send(buffer, length);
}
catch (const error & ve)
{
UNLOCK
DEBUG_E(Vblock, "Caught an exception!\n");
throw;
}
catch (...)
{
UNLOCK
}
UNLOCK
}
OK_BOOST_LOCK_A_MUTEX
+16
for(int i=0;i<World::size;i++)
{
for(int u=0;u<World::size;u++)
{
//Задаётся зерно для генерации случайных чисел
srand(GetTickCount()*i*u);
//Задаются случайные значения всем точкам от 0*0.1-10, до 100*0.1-10
World::data[i][u]=(rand()%100)*0.1f-10.0f;
}
}
http://habrahabr.ru/post/183986/
+20
#include <iostream>
enum Quiet { LOG };
template<typename T>
Quiet operator <<(Quiet o, T) {
return o;
}
static inline Quiet operator <<(Quiet o, std::ostream &(*)(std::ostream &)) {
return o;
}
int main() {
LOG << "Hello world!" << std::endl;
return 0;
}
Измыслил сегодня вот такую вот затычку для выключения логгирования
+21
class socket_exception
{
public:
char *buf;
int ret;
socket_exception()
{
buf=new char[10000];
ret=RET_OK;
}
socket_exception(char *b, int r)
{
buf=new char[10000];
snprintf(buf,9999,"%s",b);
ret=r;
}
socket_exception(vsocket_exception &ex)
{
buf=new char[10000];
snprintf(buf, 9999, "%s", ex.buf);
ret=ex.ret;
}
const char * what (){return buf;}
int get_ret(){return ret;}
~socket_exception(){delete[] buf;}
};
фрактал
+9
void SillyThread::run()
{
forever
{
// ... a test ...
}
}
void CrazyThread::run()
{
forever
{
if(qrand() % 2 == 0)
{
// ... a test ...
}
if(qrand() % 2 == 0)
{
// ... a test ...
}
if(qrand() % 2 == 0)
{
// ... a test ...
}
if(qrand() % 2 == 0)
{
// ... a test ...
}
if(qrand() % 2 == 0)
{
// ... a test ...
}
if(qrand() % 2 == 0)
{
// ... a test ...
}
if(qrand() % 2 == 0)
{
// ... a test ...
}
if(qrand() % 2 == 0)
{
// ... a test ...
}
if(qrand() % 2 == 0)
{
// ... a test ...
}
}
}
не совсем говно, но имена и структука прикололи. из кода стресс-теста PDF библиотеки poppler.
+17
int a=0;
while (a<=1 && a>=0) {
a--;
}
Я даже хз, что тут автор делает...
+18
std::tuple<std::vector<long double> , std::vector<std::vector<long double> > , std::vector<long double> >
inline
training(const std::size_t hidden_neurons,
const long double hlr,
const std::size_t epochs,
const std::vector< long double > train_ou,
const std::vector< std::vector< long double > >& train_in,
volatile bool * reset)
{
auto train_inp = train_in;
auto train_out = train_ou;
// std::cerr << "hidden_neurons: " << hidden_neurons << std::endl;
// std::cerr << "hlr: " << hlr << std::endl;
// std::cerr << "epochs: " << epochs << std::endl;
// std::cerr << "train_inp: " << train_inp << std::endl;
// std::cerr << "train_out: " << train_out << std::endl;
const auto mu_inp = mean( train_inp );
const auto sigma_inp = stand( train_inp );
train_inp = ( train_inp - mu_inp[ 0 ] ) / sigma_inp[ 0 ];
const auto mu_out = mean( train_out );
const auto sigma_out = stand( train_out );
train_out = ( train_out - mu_out ) / sigma_out;
const auto patterns = size( train_inp ).first;
std::cout << "patterns: " << patterns << std::endl;
auto bias = ones( patterns );
train_inp = merge( train_inp, bias );
const auto inputs = size( train_inp ).second;
std::vector< long double > err( epochs );
auto weight_input_hidden = ( randn( inputs, hidden_neurons) - 0.5l ) / 10.0l;
auto weight_hidden_output = ( randn( hidden_neurons ) - 0.5l ) / 10.0l;
for( std::size_t i = 0; i < epochs; ++i ) {
if ( *reset ) {
break;
}
const auto alr = hlr;
const auto blr = alr / 10.0;
for( std::size_t j = 0; j < patterns; ++j ){
const auto patnum = ( static_cast<std::size_t>( round( randd() * patterns + 0.5 ) ) - 1 ) % patterns;
const auto this_pat = train_inp[ patnum ];
const auto act = train_out[ patnum ];
const auto hval = feval( []( const long double & v ){ return std::tanh( v ); }, this_pat * weight_input_hidden );
const auto pred = hval * weight_hidden_output;
const auto error = pred - act;
const auto delta_HO = hval * error * blr;
weight_hidden_output = weight_hidden_output - delta_HO;
const auto m1 = weight_hidden_output * alr * error;
const auto m2 = 1.0l - (hval^2);
const auto m3 = dot_operator( m1, m2, std::multiplies< long double >());
const auto m4 = vec_to_vecvec( m3 );
const auto delta_IH = m4 * this_pat;
weight_input_hidden = weight_input_hidden - trans( delta_IH );
}
const auto p1 = feval( []( const long double& v ){ return std::tanh( v ); }, train_inp * weight_input_hidden );
const auto pred = weight_hidden_output * trans( p1 );
const auto error = pred - train_out;
const auto error_sq = error ^ 2;
err[ i ] = std::sqrt( std::accumulate( error_sq.cbegin(), error_sq.cend(), 0.0, std::plus<long double> () ) );
std::cerr << "err[ i ]: " << err[ i ] << ' ' << i << std::endl;
}
return std::move(std::make_tuple(weight_hidden_output, weight_input_hidden, err));
}
Велосипедостроение
+18
#include "math.h"
#include <iostream>
void Resolve(
float a, float b, float c, // коэффициенты уравнения
int& count, float x[2] // число корней, сами корни
// если корней нет, то значения x[0] и x[1] не определены
// если корень один, то значение x[1] не определено
// если корней бесконечно много, то вернуть INT_MAX
// предполагается, что a,b,c и корни по модулю не превосходят 1E10
)
{
const float MAXFREV = 1e-10f;
if (a==0.0 && b==0.0 && c==0.0)
{
count = INT_MAX;
} else
{
count = 0;
float d = b*b-4.0f*a*c;
if (d==0.0f)
{
if (2.0f*abs(a)>abs(b)*MAXFREV)
x[count++] = -b/(2.0f*a);
} else if (d>0.0f)
{
float num = -b - sqrt(d);
if (2.0f*abs(a)>abs(num)*MAXFREV)
x[count++] = num/(2.0f*a); // (-b-sqrt(d))/2a
if (abs(num)>2.0f*abs(c)*MAXFREV)
x[count++]=(2.0f*c)/num;
}
}
}
int main ()
{
float x[2];
int count;
Resolve (0.0001f,2.000f,0.001f, count, x);
std::cout << "count= " << count;
if (count<=2)
for (int i=0; i<count; ++i)
std::cout << ", x[" << i << "]= " << x[i];
std::cout<<std::endl;
return 0;
}
Просто решение квадратного уравнения.
На флоатах.
Числа подобраны так, что классическая формула лажает, выдавая второй корень -0.000596 вместо -0.0005
+10
// проверка содержимого массива кликов
for(;;)
{
// Поиск нуля
for(; massiv[car_massiv] != 0; car_massiv += 3);
// Выход если достигнут конец массива
if(car_massiv == car_base - 1) break;
car_massiv++;
// Сравниваем записи в обоих массивах
for(car_cl = 0;; car_cl += 2, car_massiv += 3)
{
// Производим перебор в поисках НЕ пустой клетки (НЕ "1")
for(i = i0 + di, j = j0 + dj; board[i][j] == 1 || (i == ib && j == jb); i += di, j +=dj);
// Если не координаты срубленно шашки, то выход
if(i != i2) break;
if(j != j2) break;
// Производим перебор пустых клеток в поисках координат клика
for(i = i2 + di, j = j2 + dj; (board[i][j] == 1 || (i == ib && j == jb)) && !(i == i1 && j == j1); i += di, j += dj);
// Если НЕ координаты клика, то выход
if(i != i1) break;
if(j != j1) break;
// Координаты срубаемой (на следующем этапе) шашки
i3 = massiv[car_massiv + 4];
j3 = massiv[car_massiv + 5];
...
...
}
}
Знакомый писал шашки, для себя. Местами попроще, но это просто убило