- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
- 09
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
int spectrumColor(float magn)
{
if (magn != magn) return 0xFF000000;
if ((magn <= -FLT_MAX && magn >= FLT_MAX)) return 0xFF000000;
const float minRange = -95.0f;
if (magn > minRange && magn <= (minRange + 10.0f))
return blendColor(0, 0x00004f, (magn - minRange) / 10.0f);
if (magn > (minRange + 10.0f) && magn <= (minRange + 20.0f))
return blendColor(0x00004f, 0x50007b, (magn - (minRange + 10.0f)) / 10.0f);
if (magn > (minRange + 20.0f) && magn <= (minRange + 30.0f))
return blendColor(0x50007b, 0x990076, (magn - (minRange + 20.0f)) / 10.0f);
if (magn > (minRange + 30.0f) && magn <= (minRange + 40.0f))
return blendColor(0x990076, 0xd20040, (magn - (minRange + 30.0f)) / 10.0f);
if (magn > (minRange + 40.0f) && magn <= (minRange + 50.0f))
return blendColor(0xd20040, 0xf51f00, (magn - (minRange + 40.0f)) / 10.0f);
if (magn > (minRange + 50.0f) && magn <= (minRange + 60.0f))
return blendColor(0xf51f00, 0xffaa00, (magn - (minRange + 50.0f)) / 10.0f);
if (magn > (minRange + 60.0f) && magn <= (minRange + 70.0f))
return blendColor(0xffaa00, 0xfff966, (magn - (minRange + 60.0f)) / 10.0f);
if (magn > (minRange + 70.0f) && magn <= (minRange + 80.0f))
return blendColor(0xfff966, 0xffffff, (magn - (minRange + 70.0f)) / 10.0f);
if (magn < minRange) return 0xFF000000;
if (magn >= (minRange + 80.0f)) return 0xFFFFFFFF;
return 0xFF000000;
}
Вот так в одной говноподелке считается цвет столбцов спектра для визуализации аудио.
Follow us!
Вообщем то первая же строчка меня и убила :)
http://ru.wikipedia.org/wiki/NaN
Т.е. если уж мы определили для него операцию, то оно должно быть числом, либо тогда уже не нужно было для него определять такую операцию. Смысл-то в том, что класс равенства нельзя определить так, чтобы выполнялось a != a, а что такое а - это уже в руке аллаха.
Именно так.
> с плавающей запятой даже. ;)
И далеко эта запятая уплыла? В нем нет ни мантиссы ни порядка, это сложно назвать числом.
А насчет неравенства NaN != NaN - NaNы бывают разные, поэтому, чтобы не запутывать логику, все NaNы не равны друг другу.
Но это создает противоречие, когда мы спрашиваем "а разные ли?" и вдруг получаем утвердительный ответ.
Если подойти к этой фразе формально - x || !x, что всегда истинно. Поэтому ответом будет "да".
Я хочу без исключений узнать, даст ли операция корректный результат. Сейчас способ есть - выполнить операцию и проверить результат на корректность. Всё это в режиме сопроцессора "не кидать исключения".
Просто есть такая тенденция в проектировании: сначала спроектировать все так, как будто оно всегда работает безотказно, а потом думать, что же делать, когда не работает.
Вам в Go, товарищ, только одна проблема (для тебя): там есть сборщик мусора.
но с++ позволит завести переменную одного типа - например, кортеж из типа1 и типа2, из которого ты потом получишь обе части - см. std::pair или более общий std::tuple
std::tie связывает _существующие_ переменные
go может и типы выводит. Допустим, есть функция (берёт 2 инта, возвращает int и error), стейтмент
создаст две переменные разных типов. Можно ещё так: Без шаблонов как-то оно грустновато, хоть язык довольно интересный, и стандартная либа доставляет.
почему они не подумали о тарасе?
Семантика немного сложнее (:= создаёт как минимум одну новую переменную, остальные может поменять, если они не в новом скопе), но суть такая. Тут каким-то местом замешан оберон, но я не знаю оный, и мне сложно судить.
Вот я и говорю, как ты в этом крестоблядском убогом недоязыке, базирующемся на допотопном недоассемблере, заведёшь в одной строке две переменные разных типов, как
file,err := os.Open("file.go")
?
В общем-то задача состоит в том, чтобы сделать преобразование амплитуды в цвет, как вот на этой картинке: http://upload.wikimedia.org/wikipedia/commons/c/c5/Spectrogram-19thC.png
Так передайте ему 2 цвета из таблички: [index] и [index+1] и (magn + 95.0) / 10.0 - index в качестве третьего аргумента.
2 случая меньше и больше этого отрезка останется рассмотреть отдельно
как-то так
неужели сам не видишь никаких закономерностей в копипастных строчках?
просто подумал, что меня неправильно поняли
я тоже быдо и делаю ифами
аж целых 5 ифов, дааа
а, не, 4
Код Тараса без модификаций - 2.6с.
Мой код с floor(e*(5*256)) - 1.8с.
Если убрать проверку index<0, время увеличивается до 3.4с. Вторая проверка на время не влияет.
P.S. 1.7 секунд выполняется int index = (int)(e*(5*256)), остальное в пределах погрешности.
http://gcc.gnu.org/ml/gcc/2001-10/msg01039.html
Unfortunately, I've noticed that casting from float/double to int on i386 can cause large performance hits when this operations is used often.
PS Зачем index >> 8 джва раза считать?
> mult[index >> 8] *
От этого умножения можно отказаться заменив индексы массива на сдвиги и хитрожопой маской поставив знак минус.
Я вам покушать принёс:
Примерно таким нехитрым образом можно вовсе отказаться от ветвлений и таблиц.
А то накал битоёбства недостаточно силён.
http://ideone.com/crluEj
Надо сложения поменять на ксоры. Тогда все будет хорошо.
P.S. По скорости получилось вдвое медленней http://govnokod.ru/12806#comment173275, по корректности - результаты совпадают.
Не понял. У кого?
Это я не ради скорости, а скорее для лулзов и из любви к битоёбству.
> Это я не ради скорости, а скорее для лулзов и из любви к битоёбству.
Да понятно, можно и base так переписать, чтобы убрать массив.
>Вдвое медленней моего.
Видать три-четыре такта из L1 и четыре на умножение быстрее чем полтора десятка элементарных операций.
Это в былые времена умножение было мееедленым.
> Зачем index >> 8 джва раза считать?
Ну если компилятор с этим не справится, то и остальной код будет таким говном, что проще переписать эту функцию полностью на асме.
можно чуть-чуть... думаю там где-нить десяток процентов можно выжать. 2 раза - потолок.
Просто размышлять над этим лень.
const int base[5] = {0x000000, 0x0000FF, 0xFF00FF, 0xFF0000, 0xFFFF00};
const int shifts[5] = {0, 16, 0, 8, 0};
...
return base[index >> 8] ^ ((index & 0xFF) << shifts[index >> 8];
Мой вариант выше.
Знак допиливается так:
(~m & mi) | ((a==4)<<31)
Издательство: Говнокод.ру, 2013 г.
Язык: Русский
Год издания: 2013
Под редакцией Борманда.
Книга предназначена в первую очередь для обучения детей байтоебству на каникулах. Автором рассматривается реализация нетривиальных задач на примитивных битовых командах, а также вопросы тонкой оптимизации кода.
Издание может заинтересовать широкий круг читателей с различным уровнем подготовки.
Для детей дошкольного и младшего школьного возраста.
Вы можете приобрести премиум-аккаунт.
result := c1 and $F0F0F0 + ((c2 and $F0F0F0 - c1 and $F0F0F0) * stage) shr 4.
stage - целое число от 0 до 16
правда стадий всего 16 и цвет выходит 12-битный, но всё равно очень оптимально получается
http://www.gamedev.ru/code/forum/?id=147090
Ну а так да, для многих применений достаточно подобных упрощеных формул.
А если тут перегрузка неравенства и что-то делается с magn? Или такого не бывает?
операции встроенных типов нельзя перегрузить
- Пошли ко мне домой.
- Сейчас, только шапочек прикуплю.