Воз­вра­ща­ясь к теме вы­зо­ва на­тив­ных мо­ду­лей из Python (те­перь это в Lin­ux, но в Win­dows прин­ци­пи­аль­ных раз­ли­чий быть не долж­но).

В Python есть очень по­лез­ный мо­дуль для ра­бо­ты с мас­си­ва­ми, на­зы­ва­ет­ся он, как не стран­но, ar­ray. Это не един­ствен­ный мо­дуль для ра­бо­ты с мас­си­ва­ми, но он очень удо­бен, если необ­хо­ди­мо об­ме­ни­вать­ся мас­си­ва­ми с про­грам­ма­ми на C/C++ (на­при­мер OpenGL тек­стур­ку скор­мить, или про­сто все тя­же­лые вы­чис­ле­ния на C/C++ на­пи­сать):

(далее...)

Во­об­ще ис­поль­зо­ва­ние dll из Python осо­бой про­бле­мой не яв­ля­ет­ся, для это­го есть мо­дуль ctypes, ко­то­рый, на­чи­ная с Python 2.5, вхо­дит в со­став это­го са­мо­го Python’а. Но по ка­кой-то за­га­доч­ной при­чине даже вез­де­су­щий Google не смог най­ти при­ме­ра связ­ки "своя dll" + "своя python про­грам­ма", а там есть неко­то­рые неоче­вид­ные граб­ли: ко­гда "своя dll" бу­дет под­клю­чать­ся к чему угод­но, но Python бу­дет ра­пор­то­вать:

ValueError: Procedure called with not enough arguments (N bytes missing)
or wrong calling convention

Или го­во­рить, что он ва­ших функ­ций в упор не ви­дит.

Так что, как го­во­рят буд­ди­сты, на бла­го всех жи­вых су­ществ!

(далее...)

Это ста­тья по­свя­ще­на про­стым чис­лам и эф­фек­тив­ным спо­со­бам их вы­чис­ле­ния. Сра­зу ска­жу, что те ал­го­рит­мы, ко­то­рые тут при­ве­де­ны, яв­ля­ют­ся весь­ма и весь­ма нетри­ви­аль­ны­ми и са­мо­му мне не да­ва­лись до­воль­но дол­го, но в ито­ге я их всё-таки при­ду­мал, на­пи­сал и спе­шу по­де­лить­ся со все­ми вами. Ис­ход­ные тек­сты в ста­тье бу­дут при­ве­де­ны на язы­ках C# и Haskell.

Про­стое чис­ло – это на­ту­раль­ное чис­ло боль­ше еди­ни­цы, ко­то­рое име­ет ров­но два де­ли­те­ля: еди­ни­цу и само это чис­ло.

Ре­ше­то Эра­то­сфе­на – древ­ний, но при этом весь­ма эф­фек­тив­ный и до сих пор ши­ро­ко ис­поль­зу­е­мый ал­го­ритм по­ис­ка всех про­стых чи­сел не пре­вос­хо­дя­щих неко­то­ро­го N.

За­пи­шем под­ряд все чис­ла от 2 до N. Даль­ше вы­черк­нем из это­го спис­ка все чис­ла крат­ные 2, ис­клю­чая саму двой­ку, по­том вы­черк­нем все чис­ла крат­ные 3, ис­клю­чая само чис­ло 3, чис­ло 4 уже вы­черк­ну­то, вы­чер­ки­ва­ем чис­ла крат­ные 5 и т.д. Про­дол­жа­ем этот про­цесс, пока квад­рат оче­ред­но­го чис­ла не пре­вы­сит N.

Са­мая про­стая про­грамм­ная ре­а­ли­за­ция это­го ал­го­рит­ма вы­гля­дит сле­ду­ю­щим об­ра­зом:

(далее...)

Было это в са­мом-са­мом на­ча­ле мо­е­го изу­че­ния функ­ци­о­наль­ных язы­ков. Чи­тая SICP (рус­ский пе­ре­вод) я по­нял что та­кое за­мы­ка­ние :) . По­про­бую это опи­сать. За­мы­ка­ние кон­тек­ста - спо­соб­ность лямб­да функ­ции со­хра­нять кон­текст, в ко­то­ром она была опре­де­ле­на. Это свой­ство лямб­да функ­ций мож­но ис­поль­зо­вать для хра­не­ния дан­ных, т.е. неко­то­рые дан­ные мож­но хра­нить в виде функ­ций. Из­вле­кать эти дан­ные мож­но с по­мо­щью дру­гих функ­ций. По­про­бу­ем разо­брать­ся (на при­ме­ре хра­не­ние пары):

pair a b = \fnc -> fnc a b
first p = p (\a b -> a)
second p = p (\a b -> b)

Итак, опре­де­ля­ем пару как лямб­да функ­цию от од­но­го ар­гу­мен­та (этим ар­гу­мен­том впо­след­ствии бу­дет дру­гая функ­ция), этот ар­гу­мент при­ме­ня­ет­ся к чле­нам пары. Функ­ция по­лу­че­ния пер­во­го чле­на пары бу­дет функ­ци­ей од­но­го ар­гу­мен­та, ко­то­рая бу­дет при­ме­нять этот ар­гу­мент к лямб­да функ­ции двух ар­гу­мен­тов

\a b -> a

Функ­ция по­лу­че­ния вто­ро­го чле­на пары опре­де­ля­ет­ся ана­ло­гич­но.

Те­перь мы мо­жем опре­де­лить пару

some_pair = pair 1 2

И про­ве­рить как ра­бо­та­ют функ­ции first и sec­ond

> first some_pair
1
> second some_pair
2

Итак, мно­го-мно­го ма­ло­по­нят­но­го тек­ста на рус­ском, и все­го три про­стые строч­ки на Haskell’е :)

Здрав­ствуй­те до­ро­гие!

Во-пер­вых, раз­ре­ши­те всех по­здра­вить с на­сту­пив­шим Но­вым 2006 Го­дом! Сча­стья, уда­чи, успе­хов всем в но­вом году!

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

Это опять за­да­ча о рас­ста­нов­ке фер­зей, на сей раз за­ни­ма­ем­ся толь­ко под­счё­том ко­ли­че­ства воз­мож­ных рас­ста­но­вок:

(далее...)

Клас­си­че­ская фор­му­ли­ров­ка этой за­да­чи зву­чит так: най­ти все ва­ри­ан­ты рас­ста­нов­ки фер­зей на дос­ке 8 на 8 та­ких, что фер­зи не бьют друг дру­га. Обоб­щим её для дос­ки N на N.

(далее...)

Всё-таки функ­ци­о­наль­ные язы­ки – это со­всем па­рал­лель­ная все­лен­ная. И один из са­мых па­рал­лель­ных язы­ков в ней – Haskell.

За­хо­те­лось нам вве­сти в про­грам­му бес­ко­неч­ный спи­сок про­стых чи­сел:

(далее...)

Ваш по­кор­ный слу­га за­нял­ся изу­че­ни­ем Lisp’а (вер­нее Scheme). Чума про­сто! Хо­ти­те спи­сок из функ­ций? Лег­ко:

(define func-list (list (lambda (x) (* x x))
                        (lambda (x) (+ x x))))
((car func-list) 4) => 16