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

То есть почему нельзя сделать так:

int a[10];
int b[10];
a = b;

Однако, если обернуть всё в структуру, то можно так:

struct {int array[10]; } a, b;
a = b;

Сломалось ли бы что-то в языке, если бы присвоение массивов a = b работало как условный memcpy(a, b, sizeof(b)) ?

1. Почему конструктор для valarray сделали не в том же стиле, что и vector.

valarray( const T& val, std::size_t count );

vector( size_type count, const T& value,
        const Allocator& alloc = Allocator() );

2. Почему слайсы valarray не являются stl контейнерами и для них нет итератора?

std::valarray<int> a(n);
...
for(auto x : a[std::slice(0, 50, 2)]){
    std::cout<<x<<"\n";
}

Сколько не бьюсь, не могу заставить gtk рисовать шрифты с суб-пиксельным разрешением. В font-config выбран 10-sub-pixel-rgb.conf

$ xrdb -query
Xft.dpi:	96
Xft.antialias:	true
Xft.rgba:	rgb
Xft.hinting:	true
Xft.hintstyle:	hintfull
Xft.lcdfilter:	lcdlight

В qt все выглядит так, как и должно быть, а вот gtk что-то не очень.

Gentoo freetype-2.7.1-r1 fontconfig-2.12.1

У меня одного шрифты стали сооовсем вырвиглазными после хваленого обновления до freetype 2.7 ?

Решите задачку. В семье двое детей. Известно, что как минимум один из них — мальчик, родившийся во вторник. Какая вероятность, что в семье есть девочка?

ЗЫ девочки рождаются с той же вероятностью, что и мальчики. Пол новорожденного ребёнка не зависит от пола родившихся детей до того.

ЗЗЫ задача интересна тем, что подталкивает ко многим рассуждениям для интересующихся теорией принятия решений, байесовскими задачам итд итп.

Где-то прочитал, что создание запутанного состояния в некотором смысле эквивалентно измерению состояния кубита. Мне это кажется достаточно понятным.

Рассмотрим систему из двух кубитов 1/√2(|0> - |1>)|0>.
Если к первому кубиту применить вентиль Адамара*, то получим |10>. Измерение первого кубита всегда даст 1. Тут все понятно. Теперь рассмотрим два варианта.

А) Перед тем как применить вентиль Адамара, выполним измерение первого кубита. В результате с равной вероятностью получим либо |00>, либо |10>. А после вентиля — 1/√2(|0> + |1>)|0> и 1/√2(|0> - |1>)|0> соответственно. Теперь измерение первого кубита после вентиля дает 0 или 1 c вероятностью 1/2.

Б) Вместо измерения первого кубита перед вентилем Адамара, применим к двум кубитам вентиль CNOT** и получим
1/√2(|0> - |1>)|0> -> 1/√2(|00> - |11>)
Теперь применим вентиль Адамара к первому кубиту и выйдет
1/2(|00> - |01> + |10> + |11>)

Опять получили, что первый кубит равен 0 или 1 с равной вероятностью. То есть связывание первого кубита со вторым в этом случае эквивалентно измерению первого кубита.

Вроде бы все понятно, но... Очень многие квантовые алгоритмы подразумевают, что если некоторая функция f вычислима на классическом компьютере, то она и вычислима на квантовом. Затем этот квантовый вычислитель как итерация или промежуточный этап в квантовом алгоритме применяется к системе запутанных кубит. Вопрос мой заключается в том, что произойдет, если внутри вычислителя f происходит связывание некоторых выходных кубитов функции f с некоторыми вспомогательными?

По моим прикидкам, алгоритм Гровера и алгоритм Дойча-Йожи не чувствительны к этому. Мой простейший пример с двумя кубитами показал, что это не всегда так. Вопрос - когда это не так?

* вентиль Адамара превращает ноль |0> в 1/√2(|0> + |1>), а единицу |1> в 1/√2(|0> + |1>)

** вентиль CNOT меняет значение второго бита на противоположное, если первый равен единице:

|00> -> |00>
|01> -> |01>
|10> -> |11>
|11> -> |10>

У меня два нубских вопроса

1) Почему sum определена через ленивый foldl, а не строгий foldl'?

sum = foldl (+) 0
sum' = foldl1' (+)

2) Я понимаю, почему данный код вылетает со stack overflow даже для строгой sum'.

print =<< (liftM sum' $ mapM (\_ -> randomNorm) [1..1000000])

Вопрос: как это дело переписать красиво, идиоматично и так, чтобы работало, конечно.

ЗЫ Это не принципиально, но randomNorm генерирует случайное нормально распределенное число

randomNorm :: IO Double
randomNorm = do
    u <- randomIO
    v <- randomIO
    return (sqrt ((-2) * log u) * cos (2*pi*v))

Мне необходимо оперировать достаточно сложными типами данных (Марковское поле).

В общем получается, что необходимо задавать граф, в вершинах и ребрах которого записаны данные, основанные на опять же массивах.

По сути применяемых алгоритмов, будет удобно работать с матрицей инцидентности графа. То есть получается массив массивов.

И теперь в общем вопрос, можно ли удобно работать с такой вот структурой, не имея двух вариантов типа данных, один немутабельный и один для ST?

Как эту дрянь отключить? Раньше отключалось в XOrg.conf. Сейчас х** его знает в каких тоннах xml оно спрятано? Гуглил, пытался твикать hal, udev, но все один черт. Помогите, плиз. А то уже просто не могу =(

ЗЫ Arch linux

Такая проблема.

Поставил slackware 13.0 (32бит) в качестве домашнего роутер/сервера. Ядро vmlinuz-huge-2.6.29.6

При любой сетевой нагрузке на сервер (через него качает что-то другая машина или он сам) проц сильно загружается. При этом процесс ksoftirqd/0 грузит больше чем на 20%.

Топ показывает вот такое распределение: 11.6%us, 40.9%sy, 0.0%ni, 0.3%id, 0.0%wa, 11.6%hi, 35.5%si, 0.0%st

В /proc/interrupts из подозрительного: 11: 1699331 XT-PIC-XT ohci_hcd:usb2, eth0, eth1

Раньше стоял генту и такого не наблюдалось.

Буду признателен за любую помощь

У меня есть ноутбук HP Compaq 6720s.

Если закрыть ноутбук при отключенном питании, он вешается намертво.

Раньше я эту проблему решал, запрещая загружать модули output и video. Я так делал в Arch и в Debian. Но новые ядра арч грузят их, внезависимости от запрета. И это создает проблему.

Но вот, что интересно, если загружен kde (4.3.2), то проблем никаких нет. Однако я хочу юзать fluxbox.

Что можно сделать, куда копать и что я упускаю? Спасибо.

Господа хаскелисты, как быть в таких ситуациях, когда наличие состояния фактически диктуется условиями задачи?

Например в игре это здоровье, положение на карте, патроны итд... Про монады State и IO я знаю, но при попытке упаковать состояние в какой-то тип, напарываюсь на проблему изменения лишь одного параметра.

Изучал по этому поводу чужие исходники и увидел такие вот жуткие вещи:

type GameState = (Tick, Gun, Bullets, Invaders, Bullets, Explosions, Score, Lives, Level)

getScore :: GameState -> Score

getScore (_, _, _, _, _, _, s, _, _) = s

modifyScoreInState :: GameState -> Score -> GameState

modifyScoreInState (tick, gun, gunBullets, invaders, invBullets, explosions, oldScore, lives, level) newScore

= (tick, gun, gunBullets, invaders, invBullets, explosions, newScore, lives, level)

Но что-то мне подсказывает, что это не найлучший подход. Тем более, если мне понадобится добавить параметр, то придется все переписывать =/

В общем наткнулся я на ссылку http://www.haskell.org/haskellwiki/Dynamic_programming_example

Решается там такая задача: есть упаковки монет по 6, 9 и 20. Количество упаковок не ограничено. Вопрос заключается в том, можно ли из этих упоковок получить ровно n монет?

Все вроде бы хорошо и красиво, но представленные по ссылке реализации работают ~100 раз медленнее Си. Сравнима производительность лишь последнего варианта, но не к каждой задаче применим такой подход.

Вопрос: как быть? =) Возможно ли эффективное динамическое программирование в Хаскель?

Интересует возможность создания и работы с двусвязными списками в Хаскеле. Описать соотв. тип я могу. Переделать обычный список в двусвязный тоже.

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

Или и вовсе такой тип данных не применим (плохо применим) в Хаскеле и стоит искать другие пути решения задачи?

В общем суть вот в чем. Начал я изучать хаскель. И вообще говоря, чем дальше, тем больше он мне нравится. И вроде бы все великолепно. ФП - очень классно. Система типов - ну просто великолепно.

Ну и есть одно но. Ленивость. Да, есть много примеров красивого применения ленивости, но по крайней мере на данном этапе вынужден признать, что мне ленивость чаще мешает, чем помогает. И на деле, если скажем в Си часто сталкиваемся с проблемой утечки памяти, то в хаскель с space leaks. Так вот.

Как правильно бороться/использовать в своих интересах лень хаскеля? И главное, есть ли книги, в которых эта тема найболее широко раскрыта?

Как заставить то его работать? У меня 2 звуковые карты.

00:1b.0 Audio device: Intel Corporation 82801G (ICH7 Family) High Definition Audio Controller (rev 01)

04:01.0 Multimedia audio controller: Creative Labs SB0400 Audigy2 Value

Откровенно говоря, первую(intel) я не использую. Интересует только вторая. На других дистрах я бы запускал alsaconf, однако прочитал, что из дебиана его успешно исключили и мол у вас и так все должно само работать. Но не работает.

Модуль для нее нужен snd_emu10k1 и он таки загружается.

Однако cat /proc/asound/cards:

0 [Intel ]: HDA-Intel - HDA Intel

HDA Intel at 0xe5000000 irq 16

Вообще не редставляю, что делать?

Короче посмотрел недавно "8 миля". Жутко пропер. В общем появилась тяга к унылому кино... Нужно еще что-то в том же духе. Можно тоже про тупых реперов. Можно не про реперов.. ну вы поняли...

Простая программка. Считает влоб (совсем влоб) x^(x*x) mod 1000 для списка чисел

import Data.List
import Control.Parallel
import Control.Parallel.Strategies

proc :: Int -> Int
proc x = foldl' f 1 [1..x*x]
where f z l = (z*x) `mod` 1000

xs = [1..1000]

main = print (parMap rwhnf proc xs)


Пробовал запускать с разными параметрами в духе:
./main +RTS -N1 -RTS
./main +RTS -N2 -RTS
./main +RTS -N2 -g2 -RTS

Машина с двумя ядрами, но в среднем, чем больше указываю N, тем пропорционально медленнее работает (быстрее всего -N1)
top показывает, что вроде бы работают оба ядра.

Подскажите пожалуйста, в чем может быть проблема?

ЗЫ компилирую с помощью ghc 6.10.1:
ghc --make main.hs -O2 -threaded

<тут длинная история про то, как я начал писать прогу на хаскелле, а она...>

В общем когда я выискивал суть проблемы, то увидел:

x :: [Double]
x = take 5000000 ([1..])

main = do
print (fromIntegral (length x))
print (sum x)

не быстро.. да... но работает.. нормально

x :: [Double]
x = take 5000000 ([1..])

main = do
print ((sum x) / (fromIntegral (length x)))

работает долго и падает с нехваткой стека. Даже, если выставить стек в 50МБ....

Наверняка я что-то фундаментально в хаскелле упустил. Но вот что?

Заметил, что любое приложение Qt автоматически отъедает около 2МБ (достаточно лишь вызова QApplication).

Интересно, можно ли это настроить? Искал в троллтеховсой документации и не нашел.

Понятно, что для большого проекта эти мегабайты может и не играют роли, но если куча маленьких, то вместе они жрут огого...

//Вот этого уже достаточно и 2MB нет =)

#include <QApplication>
int main(int argc, char *argv[]){
QApplication app(argc, argv);
return app.exec();
}