Keeper's blog

Информатика и ИКТ - ЕГЭ 2014 (C4)

2014-06-21T01:00:00.000+04:00

Довольно интересная задача С4 попалась в этом году в ЕГЭ по информатике и ИКТ. И, хотя, она оказалась проще, чем ряд задач прошлых лет, некоторые столкнулись с определенными трудностями при ее решении.
Приведу один из возможных эффективных способов ее решения.

Условие (примерное)
Спутник передает данные на землю, посылая их каждую минуту. Данные подаются в формате целого числа от 0 до 1000, количество значений не превышает 10000. Найти максимальное произведение значений, разница между которыми составляет не менее 7 минут.

Решение (Паскаль)

program c4;

const
  N_MAX = 1000; // Правая граница чисел
  MINS = 7; // Минимальное кол-во минут между данными
  D_C = 4; // кол-во символов под форматный вывод
  
var
  Data: array[1..MINS] of Real;
  i, j, N: Integer;
  max, maxPro: Real;

begin
  Write('N = '); Readln(N);
  
  randomize;
  for i := 1 to MINS do
  begin
    Data[i] := random(N_MAX + 1);
    Write(Data[i]:D_C:1, ' ');
  end;
    
  max := 0;
  maxPro := 0;
  for i := MINS + 1 to N do
  begin
    if Data[1] > max then
      max := Data[1];
      
    for j := 1 to MINS - 1 do
      Data[j] := Data[j + 1];
    Data[MINS] := random(N_MAX + 1);
    Write(Data[MINS]:D_C:1, ' ');
      
    if max * Data[MINS] > maxPro then
      maxPro := max * Data[MINS];
  end;
  
  Writeln;
  Writeln('Максимальное произведение = ', maxPro:D_C:1);
  
  readln;
end.

Краткие пояснения:

  { 
  * Алгоритм решения:
  * 
  * max - максимальное число в последовательности
  * maxPro - максимальное произведение
  * 
  * Первые MINS чисел заносим в массив
  * Далее:
  * 1) определяем max из первого элемента; 
  * 2) добавляем новый элемент в конец массива, предварительно сдвинув его
  *    на 1 элемент влево (1-й элемент больше не нужен, если там был max, мы его запомнили)
  * 3) определяем максимальное произведение из max и введенного эл-та (a[MINS])
  *    (соблюдая расстояние в MINS минут);
  * 
  * В программе ввод чисел реализован через генератор случайных чисел,
  * и может быть заменен на ручной ввод
  * }

Решение (Питон 3+)

import random, queue

N_MAX = 1000 
MINS = 7 
D_C = 4 

N = int(input('N = '));
  
# Используем очередь, поэтому перестановки далее будут лишними
# Можно использовать и списки - выбирайте сами
Data = queue.Queue(MINS)
for _ in range(MINS):
    Item = random.randint(0, N_MAX)
    Data.put(Item)
    print('{0:{D_C}.1f}'.format(Item, D_C = D_C), end = ' ')
 
maxItem = 0
maxPro = 0
for _ in range(MINS + 1, N + 1):
    Item = Data.get()
    if Item > maxItem:
        maxItem = Item
  
    Item = random.randint(0, N_MAX)
    Data.put(Item)
    print('{0:{D_C}.1f}'.format(Item, D_C = D_C), end = ' ')
  
    if maxItem * Item > maxPro:
        maxPro = maxItem * Item
        
print('\nМаксимальное произведение = {0:{D_C}.1f}'.format(maxPro, D_C = D_C), end = ' ')

input

Скриншот

Если у кого-нибудь есть более светлые идеи - предлагайте в комментариях.

Технология уничтожения

2014-01-19T02:01:00.000+04:00

Всё прогрессивное человечество, как нам говорят, абсолютно естественным образом приняло геев, их субкультуру, их право заключать браки, усыновлять детей и пропагандировать свою сексуальную ориентацию в школах и детских садах. Нам говорят, что всё это — естественный ход вещей.

Нам лгут.

Ложь о естественном ходе вещей опроверг американский социолог Джозеф Овертон, описавший технологию изменение отношения общества к некогда принципиальным для этого общества вопросам.

Прочитайте это описание и станет понятно, как легализуют гомосексуализм и однополые браки. Станет совершенно очевидно, что работа по легализации педофилии и инцеста будет завершена в Европе уже в ближайшие годы. Как и детская эвтаназия, кстати.

Что ещё можно вытащить оттуда в наш мир, используя технологию, описанную Овертоном?

Она работает безотказно.

***
Джозеф П. Овертон (1960-2003), старший вице-президент центра общественой политики Mackinac Center. Погиб в авиакатастрофе. Сформулировал модель изменения представления проблемы в общественном мнении, посмертно названную Окном Овертона.
***

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

Согласно Окну возможностей Овертона, для каждой идеи или проблемы в обществе существует т.н. окно возможностей. В пределах этого окна идею могут или не могут широко обсуждать, открыто поддерживать, пропагандировать, пытаться закрепить законодательно. Окно двигают, меняя тем самым веер возможностей, от стадии «немыслимое», то есть совершенно чуждое общественной морали, полностью отвергаемое до стадии «актуальная политика», то есть уже широко обсуждённое, принятое массовым сознанием и закреплённое в законах.

Это не промывание мозгов как таковое, а технологии более тонкие. Эффективными их делает последовательное, системное применение и незаметность для общества-жертвы самого факта воздействия.

Ниже я на примере разберу, как шаг за шагом общество начинает сперва обсуждать нечто неприемлемое, затем считать это уместным, а в конце концов смиряется с новым законом, закрепляющим и защищающим некогда немыслимое.

Возьмём для примера что-то совершенно невообразимое. Допустим, каннибализм, то есть идею легализовать право граждан на поедание друг друга. Достаточно жёсткий пример?

Но всем очевидно, что прямо сейчас (2014г.) нет возможности развернуть пропаганду каннибализма — общество встанет на дыбы. Такая ситуация означает, что проблема легализации каннибализма находится в нулевой стадии окна возможностей. Эта стадия, согласно теории Овертона, называется «Немыслимое». Смоделируем теперь, как это немысливое будет реализовано, пройдя все стадии окна возможностей.

ТЕХНОЛОГИЯ

Ещё раз повторю, Овертон описал ТЕХНОЛОГИЮ, которая позволяет легализовать абсолютно любую идею.

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

КАК ЭТО СМЕЛО!

Тема каннибализма пока ещё отвратительна и совершенно не приемлема в обществе. Рассуждать на эту тему нежелательно ни в прессе, ни, тем более, в приличной компании. Пока это немыслимое, абсурдное, запретное явление. Соответственно, первое движение Окна Овертона — перевести тему каннибализма из области немыслимого в область радикального.

У нас ведь есть свобода слова.

Ну, так почему бы не поговорить о каннибализме?

Учёным вообще положено говорить обо всём подряд — для учёных нет запретных тем, им положено всё изучать. А раз такое дело, соберём этнологический симпозиум по теме «Экзотические обряды племён Полинезии». Обсудим на нём историю предмета, введём её в научный оборот и получим факт авторитетного высказывания о каннибализме.

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

Окно Овертона уже двинулось. То есть уже обозначен пересмотр позиций. Тем самым обеспечен переход от непримиримо отрицательного отношения общества к отношению более позитивному.

Одновременно с околонаучной дискуссией непременно должно появиться какое-нибудь «Общество радикальных каннибалов». И пусть оно будет представлено лишь в интернете — радикальных каннибалов непременно заметят и процитируют во всех нужных СМИ.

Во-первых, это ещё один факт высказывания. А во-вторых, эпатирующие отморозки такого специального генезиса нужны для создания образа радикального пугала. Это будут «плохие каннибалы» в противовес другому пугалу — «фашистам, призывающим сжигать на кострах не таких, как они». Но о пугалах чуть ниже. Для начала достаточно публиковать рассказы о том, что думают про поедание человечины британские учёные и какие-нибудь радикальные отморозки иной природы.

Результат первого движения Окна Овертона: неприемлемая тема введена в оборот, табу десакрализовано, произошло разрушение однозначности проблемы — созданы «градации серого».

ПОЧЕМУ БЫ И НЕТ?

Следующим шагом Окно движется дальше и переводит тему каннибализма из радикальной области в область возможного.

На этой стадии продолжаем цитировать «учёных». Ведь нельзя же отворачиваться от знания? Про каннибализм. Любой, кто откажется это обсуждать, должен быть заклеймён как ханжа и лицемер.

Осуждая ханжество, обязательно нужно придумать каннибализму элегантное название. Чтобы не смели всякие фашисты навешивать на инакомыслящих ярлыки со словом на букву «Ка».

Внимание! Создание эвфемизма — это очень важный момент. Для легализации немыслимой идеи необходимо подменить её подлинное название.

Нет больше каннибализма.

Теперь это называется, например, антропофагия. Но и этот термин совсем скоро заменят ещё раз, признав и это определение оскорбительным.

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

Параллельно с игрой в имена происходит создание опорного прецедента — исторического, мифологического, актуального или просто выдуманного, но главное — легитимированного. Он будет найден или придуман как «доказательство» того, что антропофилия может быть в принципе узаконена.

«Помните легенду о самоотверженной матери, напоившей своей кровью умирающих от жажды детей?»

«А истории античных богов, поедавших вообще всех подряд — у римлян это было в порядке вещей!»

«Ну, а у более близких нам христиан, тем более, с антропофилией всё в полном порядке! Они до сих пор ритуально пьют кровь и едят плоть своего бога. Вы же не обвиняете в чём-то христианскую церковь? Да кто вы такие, чёрт вас побери?»

Главная задача вакханалии этого этапа — хотя бы частично вывести поедание людей из-под уголовного преследования. Хоть раз, хоть в какой-то исторический момент.

ТАК И НАДО

После того как предоставлен легитимирующий прецендент, появляется возможность двигать Окно Овертона с территории возможного в область рационального.

Это третий этап. На нём завершается дробление единой проблемы.

«Желание есть людей генетически заложено, это в природе человека»
«Иногда съесть человека необходимо, существуют непреодолимые обстоятельства»
«Есть люди, желающие чтобы их съели»
«Антропофилов спровоцировали!»
«Запретный плод всегда сладок»
«Свободный человек имеет право решать что ему есть»
«Не скрывайте информацию и пусть каждый поймёт, кто он — антропофил или антропофоб»
«А есть ли в антропофилии вред? Неизбежность его не доказана».

В общественном сознании искусственно создаётся «поле боя» за проблему. На крайних флангах размещают пугала — специальным образом появившихся радикальных сторонников и радикальных противников людоедства.

Реальных противников — то есть нормальных людей, не желающих оставаться безразличными к проблеме растабиурования людоедства — стараются упаковать вместе с пугалами и записать в радикальные ненавистники. Роль этих пугал — активно создавать образ сумасшедших психопатов — агрессивные, фашиствующие ненавистники антропофагии, призывающие жечь заживо людоедов, жидов, коммунистов и негров. Присутствие в СМИ обеспечивают всем перечисленным, кроме реальных противников легализации.

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

«Учёные» и журналисты на этом этапе доказывают, что человечество на протяжении всей своей истории время от времени поедало друг друга, и это нормально. Теперь тему антропофилии можно переводить из области рационального, в категорию популярного. Окно Овертона движется дальше.

В ХОРОШЕМ СМЫСЛЕ

Для популяризации темы каннибализма необходимо поддержать её поп-контентом, сопрягая с историческими и мифологическими личностями, а по возможности и с современными медиаперсонами.

Антропофилия массово проникает в новости и токшоу. Людей едят в кино широкого проката, в текстах песен и видеоклипах.

Один из приёмов популяризации называется «Оглянитесь по сторонам!»

«Разве вы не знали, что один известный композитор — того... антропофил?»

«А один всем известный польский сценарист — всю жизнь был антропофилом, его даже преследовали.»

«А сколько их по психушкам сидело! Сколько миллионов выслали, лишили гражданства!.. Кстати, как вам новый клип Леди Гаги «Eat me, baby»?

На этом этапе разрабатываемую тему выводят в ТОП и она начинает автономно самовоспроизводиться в массмедиа, шоубизнесе и политике.

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

Затем, в момент, когда уже всем стало скучно и обсуждение проблемы зашло в тупик, приходит специальным образом подобранный профессионал и говорит: «Господа, на самом деле всё совсем не так. И дело не в том, а вот в этом. И делать надо то-то и то-то» — и даёт тем временем весьма определённое направление, тенденциозность которого задана движением «Окна».

Для оправдания сторонников легализации используют очеловечивание преступников через создание им положительного образа через не сопряжённые с преступлением характеристик.

«Это же творческие люди. Ну, съел жену и что?»

«Они искренне любят своих жертв. Ест, значит любит!»

«У антропофилов повышенный IQ и в остальном они придерживаются строгой морали»

«Антропофилы сами жертвы, их жизнь заставила»

«Их так воспитали» и т.д.

Такого рода выкрутасы — соль популярных ток-шоу.

«Мы расскажем вам трагическую историю любви! Он хотел её съесть! А она лишь хотела быть съеденной! Кто мы, чтобы судить их? Быть может, это — любовь? Кто вы такие, чтобы вставать у любви на пути?!»

МЫ ЗДЕСЬ ВЛАСТЬ

К пятому этапу движения Окна Овертона переходят, когда тема разогрета до возможности перевести её из категории популярного в сферу актуальной политики.

Начинается подготовка законодательной базы. Лоббистские группировки во власти консолидируются и выходят из тени. Публикуются социологические опросы, якобы подтверждающие высокий процент сторонников легализации каннибализма. Политики начинают катать пробные шары публичных высказываний на тему законодательного закрепления этой темы. В общественное сознание вводят новую догму — «запрещение поедания людей запрещено».

Это фирменное блюдо либерализма — толерантность как запрет на табу, запрет на исправление и предупреждение губительных для общества отклонений.

Во время последнего этапа движения Окна из категории «популярное» в «актуальную политику» общество уже сломлено. Самая живая его часть ещё как-то будет сопротивляться законодательному закреплению не так давно ещё немыслимых вещей. Но в целом уже общество сломлено. Оно уже согласилось со своим поражением.

Приняты законы, изменены (разрушены) нормы человеческого существования, далее отголосками эта тема неизбежна докатится до школ и детских садов, а значит следующее поколение вырастет вообще без шанса на выживание. Так было с легализацией педерастии (теперь они требуют называть себя геями). Сейчас на наших глазах Европа легализует инцест и детскую эвтаназию.

КАК СЛОМАТЬ ТЕХНОЛГИЮ

Описанное Овертоном Окно возможностей легче всего движется в толерантном обществе. В том обществе, у которого нет идеалов, и, как следствие, нет чёткого разделения добра и зла.

Вы хотите поговорить о том, что ваша мать — шлюха? Хотите напечатать об этом доклад в журнале? Спеть песню. Доказать в конце концов, что быть шлюхой — это нормально и даже необходимо? Это и есть описанная выше технология. Она опирается на вседозволенность.

Нет табу.

Нет ничего святого.

Нет сакральных понятий, само обсуждение которых запрещено, а их грязное обмусоливание — пресекается немедленно. Всего этого нет. А что есть?

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

Ты думаешь, что в одиночку не сможешь ничего изменить?

Ты совершенно прав, в одиночку человек не может ни черта.

Но лично ты обязан оставаться человеком. А человек способен найти решение любой проблемы. И что не сумеет один — сделают люди, объединённые общей идеей. Оглянись по сторонам.

http://rvs.livejournal.com/27431.html

Дополнительные источники: http://businessmsk.livejournal.com/641375.html

Что бы сделали мы с Delphi XE5/XE6... - подводим итоги

2013-09-25T00:18:00.001+04:00

С некоторым запозданием подводим обещанные итоги летнего опроса.

Вот, пятерка пожеланий-победителей:

Исправить баги и "тормоза" в QC, в т.ч. переходящие от версии к версии (13).
Выпустить Delphi-Express, литературу по новым возможностям и современному состоянию языка/среды, в т.ч. на глубоком уровне; оптимизировать и повысить скорость исполняемых файлов; сделать компилятор под Linux (6).
Улучшить справочную систему (быстродействие, содержание) (5).
Снизить цены на Delphi/RAD Studio; усовершенствовать IDE (4).
Значительно расширить компонентную базу, добавить полноценные компоненты, а не урезанные версии, исправить существующие (например, TBalloonHint или Ribbon); провести качественный рефакторинг и нативные компоненты в FM; улучшить стабильность и скорость среды (3).

В скобках указано количество голосов, полученное путем группировки мнений авторов. В случае, если одно и тоже количество голосов набирало несколько позиций - им присваивалось одно и тоже место, а сами позиции разделялись точкой с запятой.

В пятерке явно выделяется желание увидеть пофикшеные баги, остальные пункты обладают примерно одинаковой степенью влияния. Наиболее неожиданным для меня является появление в топе наличия компилятора под Linux.

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

Numerics для Delphi & FPC (работа с большими числами)

2013-08-04T12:40:00.001+04:00

Сергей Касандров выпустил довольно интересный модуль для работы с большими числами в Delphi и FreePascal (сделано на чистом Паскале, без оптимизаций) - новость и архив. В архиве содержится исходный код модуля, а также тестовый проект и скомпилированные dll (32- и 64-битные).

Для предварительного ознакомления с реализацией код модуля (из архива) приведен ниже.

{ *********************************************************** }
{ *       Numerics(32/64).dll import for Pascal             * }
{ * ------------------------------------------------------- * }
{ *       set const LibName = 'numerics32.dll'              * }
{ *         to import numerics32.dll;                       * }
{ *       set const LibName = 'numerics64.dll'              * }
{ *         to import numerics64.dll;                       * }
{ *********************************************************** }

{
  Copyright (c) 2013 Sergey Kasandrov

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
}

unit Numerics;

{$IFDEF FPC}
  {$mode delphi}
{$ENDIF}

interface

uses Windows, SysUtils;

type
  TF_RESULT = LongInt;

const
                                              // = common microsoft codes =
  TF_S_OK           = TF_RESULT(0);           // Operation successful
  TF_S_FALSE        = TF_RESULT(1);           // Operation successful
  TF_E_FAIL         = TF_RESULT($80004005);   // Unspecified failure
  TF_E_INVALIDARG   = TF_RESULT($80070057);   // One or more arguments are not valid
  TF_E_NOINTERFACE  = TF_RESULT($80004002);   // No such interface supported
  TF_E_NOTIMPL      = TF_RESULT($80004001);   // Not implemented
  TF_E_OUTOFMEMORY  = TF_RESULT($8007000E);   // Failed to allocate necessary memory
  TF_E_UNEXPECTED   = TF_RESULT($8000FFFF);   // Unexpected failure

                                              // = TFL specific codes =
  TF_E_NOMEMORY     = TF_RESULT($A0000003);   // specific TFL memory error
  TF_E_LOADERROR    = TF_RESULT($A0000004);   // Error loading dll

{$IFDEF FPC}
type
  TBytes = array of Byte;
{$ENDIF}

type
  IBigNumber = interface

    function GetIsEven: Boolean; stdcall;
    function GetIsOne: Boolean; stdcall;
    function GetIsPowerOfTwo: Boolean; stdcall;
    function GetIsZero: Boolean; stdcall;
    function GetSign: Integer; stdcall;
    function GetSize: Integer; stdcall;

    function CompareNumber(Num: IBigNumber): Integer; stdcall;
    function CompareNumberU(Num: IBigNumber): Integer; stdcall;

    function AddNumber(Num: IBigNumber; var Res: IBigNumber): TF_RESULT; stdcall;
    function AddNumberU(Num: IBigNumber; var Res: IBigNumber): TF_RESULT; stdcall;
    function SubNumber(Num: IBigNumber; var Res: IBigNumber): TF_RESULT; stdcall;
    function SubNumberU(Num: IBigNumber; var Res: IBigNumber): TF_RESULT; stdcall;
    function MulNumber(Num: IBigNumber; var Res: IBigNumber): TF_RESULT; stdcall;
    function MulNumberU(Num: IBigNumber; var Res: IBigNumber): TF_RESULT; stdcall;
    function DivRemNumber(Num: IBigNumber; var Q, R: IBigNumber): TF_RESULT; stdcall;
    function DivRemNumberU(Num: IBigNumber; var Q, R: IBigNumber): TF_RESULT; stdcall;

    function AndNumber(Num: IBigNumber; var Res: IBigNumber): TF_RESULT; stdcall;
    function AndNumberU(Num: IBigNumber; var Res: IBigNumber): TF_RESULT; stdcall;
    function OrNumber(Num: IBigNumber; var Res: IBigNumber): TF_RESULT; stdcall;
    function OrNumberU(Num: IBigNumber; var Res: IBigNumber): TF_RESULT; stdcall;
    function XorNumber(Num: IBigNumber; var Res: IBigNumber): TF_RESULT; stdcall;

    function ShlNumber(Shift: Cardinal; var Res: IBigNumber): TF_RESULT; stdcall;
    function ShrNumber(Shift: Cardinal; var Res: IBigNumber): TF_RESULT; stdcall;

    function AssignNumber(var Res: IBigNumber): TF_RESULT; stdcall;
    function AbsNumber(var Res: IBigNumber): TF_RESULT; stdcall;
    function NegateNumber(var Res: IBigNumber): TF_RESULT; stdcall;
    function Pow(Value: Cardinal; var IRes: IBigNumber): TF_RESULT; stdcall;
    function PowU(Value: Cardinal; var IRes: IBigNumber): TF_RESULT; stdcall;
    function PowerMod(IExp, IMod: IBigNumber; var IRes: IBigNumber): TF_RESULT; stdcall;
    function SqrtNumber(var IRes: IBigNumber): TF_RESULT; stdcall;

    function ToLimb(var Value: UInt32): TF_RESULT; stdcall;
    function ToIntLimb(var Value: Int32): TF_RESULT; stdcall;
    function ToDec(P: PByte; var L: Integer): TF_RESULT; stdcall;
    function ToHex(P: PByte; var L: Integer; TwoCompl: Boolean): TF_RESULT; stdcall;
    function ToPByte(P: PByte; var L: Cardinal): TF_RESULT; stdcall;

    function CompareToLimb(B: UInt32): Integer; stdcall;
    function CompareToLimbU(B: UInt32): Integer; stdcall;
    function CompareToIntLimb(B: Int32): Integer; stdcall;
    function CompareToIntLimbU(B: Int32): Integer; stdcall;

    function AddLimb(Limb: LongWord; var Res: IBigNumber): TF_RESULT; stdcall;
    function AddLimbU(Limb: LongWord; var Res: IBigNumber): TF_RESULT; stdcall;
    function AddIntLimb(Limb: LongInt; var Res: IBigNumber): TF_RESULT; stdcall;

    function SubLimb(Limb: LongWord; var Res: IBigNumber): TF_RESULT; stdcall;
    function SubLimb2(Limb: LongWord; var Res: IBigNumber): TF_RESULT; stdcall;
    function SubLimbU(Limb: LongWord; var Res: IBigNumber): TF_RESULT; stdcall;
    function SubLimbU2(Limb: LongWord; var Res: LongWord): TF_RESULT; stdcall;
    function SubIntLimb(Limb: LongInt; var Res: IBigNumber): TF_RESULT; stdcall;
    function SubIntLimb2(Limb: LongInt; var Res: IBigNumber): TF_RESULT; stdcall;

    function MulLimb(Limb: LongWord; var Res: IBigNumber): TF_RESULT; stdcall;
    function MulLimbU(Limb: LongWord; var Res: IBigNumber): TF_RESULT; stdcall;
    function MulIntLimb(Limb: LongInt; var Res: IBigNumber): TF_RESULT; stdcall;

    function DivRemLimb(Limb: LongWord; var Q: IBigNumber; var R: IBigNumber): TF_RESULT; stdcall;
    function DivRemLimb2(Limb: LongWord; var Q: IBigNumber; var R: LongWord): TF_RESULT; stdcall;
    function DivRemLimbU(Limb: LongWord; var Q: IBigNumber; var R: LongWord): TF_RESULT; stdcall;
    function DivRemLimbU2(Limb: LongWord; var Q: LongWord; var R: LongWord): TF_RESULT; stdcall;
    function DivRemIntLimb(Limb: LongInt; var Q: IBigNumber; var R: LongInt): TF_RESULT; stdcall;
    function DivRemIntLimb2(Limb: LongInt; var Q: LongInt; var R: LongInt): TF_RESULT; stdcall;

    function ToDblLimb(var Value: UInt64): TF_RESULT; stdcall;
    function ToDblIntLimb(var Value: Int64): TF_RESULT; stdcall;
    function CompareToDblLimb(B: UInt64): Integer; stdcall;
    function CompareToDblLimbU(B: UInt64): Integer; stdcall;
    function CompareToDblIntLimb(B: Int64): Integer; stdcall;
    function CompareToDblIntLimbU(B: Int64): Integer; stdcall;
  end;

type
  BigCardinal = record
  private
    FNumber: IBigNumber;
  public
    function ToString: string;
    function ToHexString(Digits: Integer = 0; const Prefix: string = '';
                         TwoCompl: Boolean = False): string;
    function ToBytes: TBytes;
    function TryParse(const S: string; TwoCompl: Boolean = False): Boolean;
    procedure Free;

    class function Compare(const A, B: BigCardinal): Integer; static;
    function CompareTo(const B: BigCardinal): Integer; overload;

    class function Pow(const Base: BigCardinal; Value: Cardinal): BigCardinal; static;
    class function DivRem(const Dividend, Divisor: BigCardinal;
                          var Remainder: BigCardinal): BigCardinal; overload; static;

    class operator Explicit(const Value: BigCardinal): Cardinal;
    class operator Explicit(const Value: BigCardinal): Integer;
    class operator Explicit(const Value: BigCardinal): UInt64;
    class operator Explicit(const Value: BigCardinal): Int64;
    class operator Implicit(const Value: Cardinal): BigCardinal;
    class operator Implicit(const Value: UInt64): BigCardinal;
    class operator Explicit(const Value: Integer): BigCardinal;
    class operator Explicit(const Value: Int64): BigCardinal;
    class operator Explicit(const Value: TBytes): BigCardinal;
    class operator Explicit(const Value: string): BigCardinal;

    class operator Equal(const A, B: BigCardinal): Boolean; inline;
    class operator NotEqual(const A, B: BigCardinal): Boolean; inline;
    class operator GreaterThan(const A, B: BigCardinal): Boolean; inline;
    class operator GreaterThanOrEqual(const A, B: BigCardinal): Boolean; inline;
    class operator LessThan(const A, B: BigCardinal): Boolean; inline;
    class operator LessThanOrEqual(const A, B: BigCardinal): Boolean; inline;

    class operator Add(const A, B: BigCardinal): BigCardinal;
    class operator Subtract(const A, B: BigCardinal): BigCardinal;
    class operator Multiply(const A, B: BigCardinal): BigCardinal;
    class operator IntDivide(const A, B: BigCardinal): BigCardinal;
    class operator Modulus(const A, B: BigCardinal): BigCardinal;

    class operator LeftShift(const A: BigCardinal; Shift: Cardinal): BigCardinal;
    class operator RightShift(const A: BigCardinal; Shift: Cardinal): BigCardinal;

    class operator BitwiseAnd(const A, B: BigCardinal): BigCardinal;
    class operator BitwiseOr(const A, B: BigCardinal): BigCardinal;

    function CompareToCard(const B: Cardinal): Integer;
    function CompareToInt(const B: Integer): Integer;
    function CompareTo(const B: Cardinal): Integer; overload; inline;
    function CompareTo(const B: Integer): Integer; overload; inline;

    class operator Equal(const A: BigCardinal; const B: Cardinal): Boolean; inline;
    class operator Equal(const A: Cardinal; const B: BigCardinal): Boolean; inline;
    class operator Equal(const A: BigCardinal; const B: Integer): Boolean; inline;
    class operator Equal(const A: Integer; const B: BigCardinal): Boolean; inline;
    class operator NotEqual(const A: BigCardinal; const B: Cardinal): Boolean; inline;
    class operator NotEqual(const A: Cardinal; const B: BigCardinal): Boolean; inline;
    class operator NotEqual(const A: BigCardinal; const B: Integer): Boolean; inline;
    class operator NotEqual(const A: Integer; const B: BigCardinal): Boolean; inline;
    class operator GreaterThan(const A: BigCardinal; const B: Cardinal): Boolean; inline;
    class operator GreaterThan(const A: Cardinal; const B: BigCardinal): Boolean; inline;
    class operator GreaterThan(const A: BigCardinal; const B: Integer): Boolean; inline;
    class operator GreaterThan(const A: Integer; const B: BigCardinal): Boolean; inline;
    class operator GreaterThanOrEqual(const A: BigCardinal; const B: Cardinal): Boolean; inline;
    class operator GreaterThanOrEqual(const A: Cardinal; const B: BigCardinal): Boolean; inline;
    class operator GreaterThanOrEqual(const A: BigCardinal; const B: Integer): Boolean; inline;
    class operator GreaterThanOrEqual(const A: Integer; const B: BigCardinal): Boolean; inline;
    class operator LessThan(const A: BigCardinal; const B: Cardinal): Boolean; inline;
    class operator LessThan(const A: Cardinal; const B: BigCardinal): Boolean; inline;
    class operator LessThan(const A: BigCardinal; const B: Integer): Boolean; inline;
    class operator LessThan(const A: Integer; const B: BigCardinal): Boolean; inline;
    class operator LessThanOrEqual(const A: BigCardinal; const B: Cardinal): Boolean; inline;
    class operator LessThanOrEqual(const A: Cardinal; const B: BigCardinal): Boolean; inline;
    class operator LessThanOrEqual(const A: BigCardinal; const B: Integer): Boolean; inline;
    class operator LessThanOrEqual(const A: Integer; const B: BigCardinal): Boolean; inline;

    function CompareToUInt64(const B: UInt64): Integer;
    function CompareToInt64(const B: Int64): Integer;
    function CompareTo(const B: UInt64): Integer; overload; inline;
    function CompareTo(const B: Int64): Integer; overload; inline;

    class operator Equal(const A: BigCardinal; const B: UInt64): Boolean; inline;
    class operator Equal(const A: UInt64; const B: BigCardinal): Boolean; inline;
    class operator Equal(const A: BigCardinal; const B: Int64): Boolean; inline;
    class operator Equal(const A: Int64; const B: BigCardinal): Boolean; inline;
    class operator NotEqual(const A: BigCardinal; const B: UInt64): Boolean; inline;
    class operator NotEqual(const A: UInt64; const B: BigCardinal): Boolean; inline;
    class operator NotEqual(const A: BigCardinal; const B: Int64): Boolean; inline;
    class operator NotEqual(const A: Int64; const B: BigCardinal): Boolean; inline;
    class operator GreaterThan(const A: BigCardinal; const B: UInt64): Boolean; inline;
    class operator GreaterThan(const A: UInt64; const B: BigCardinal): Boolean; inline;
    class operator GreaterThan(const A: BigCardinal; const B: Int64): Boolean; inline;
    class operator GreaterThan(const A: Int64; const B: BigCardinal): Boolean; inline;
    class operator GreaterThanOrEqual(const A: BigCardinal; const B: UInt64): Boolean; inline;
    class operator GreaterThanOrEqual(const A: UInt64; const B: BigCardinal): Boolean; inline;
    class operator GreaterThanOrEqual(const A: BigCardinal; const B: Int64): Boolean; inline;
    class operator GreaterThanOrEqual(const A: Int64; const B: BigCardinal): Boolean; inline;
    class operator LessThan(const A: BigCardinal; const B: UInt64): Boolean; inline;
    class operator LessThan(const A: UInt64; const B: BigCardinal): Boolean; inline;
    class operator LessThan(const A: BigCardinal; const B: Int64): Boolean; inline;
    class operator LessThan(const A: Int64; const B: BigCardinal): Boolean; inline;
    class operator LessThanOrEqual(const A: BigCardinal; const B: UInt64): Boolean; inline;
    class operator LessThanOrEqual(const A: UInt64; const B: BigCardinal): Boolean; inline;
    class operator LessThanOrEqual(const A: BigCardinal; const B: Int64): Boolean; inline;
    class operator LessThanOrEqual(const A: Int64; const B: BigCardinal): Boolean; inline;

    class function DivRem(const Dividend: BigCardinal; Divisor: Cardinal;
                          var Remainder: Cardinal): BigCardinal; overload; static;
    class function DivRem(const Dividend: Cardinal; Divisor: BigCardinal;
                          var Remainder: Cardinal): Cardinal; overload; static;

    class operator Add(const A: BigCardinal; const B: Cardinal): BigCardinal;
    class operator Add(const A: Cardinal; const B: BigCardinal): BigCardinal;
    class operator Subtract(const A: BigCardinal; const B: Cardinal): BigCardinal;
    class operator Subtract(const A: Cardinal; const B: BigCardinal): Cardinal;
    class operator Multiply(const A: BigCardinal; const B: Cardinal): BigCardinal;
    class operator Multiply(const A: Cardinal; const B: BigCardinal): BigCardinal;
    class operator IntDivide(const A: BigCardinal; const B: Cardinal): BigCardinal;
    class operator IntDivide(const A: Cardinal; const B: BigCardinal): Cardinal;
    class operator Modulus(const A: BigCardinal; const B: Cardinal): Cardinal;
    class operator Modulus(const A: Cardinal; const B: BigCardinal): Cardinal;
  end;

  BigInteger = record
  private
    FNumber: IBigNumber;
    function GetSign: Integer;
  public
    function ToString: string;
    function ToHexString(Digits: Integer = 0; const Prefix: string = '';
                         TwoCompl: Boolean = False): string;
    function ToBytes: TBytes;
    function TryParse(const S: string; TwoCompl: Boolean = False): Boolean;
    procedure Free;

    property Sign: Integer read GetSign;

    class function Compare(const A, B: BigInteger): Integer; overload; static;
    class function Compare(const A: BigInteger; const B: BigCardinal): Integer; overload; static;
    class function Compare(const A: BigCardinal; const B: BigInteger): Integer; overload; static;
    function CompareTo(const B: BigInteger): Integer; overload; inline;
    function CompareTo(const B: BigCardinal): Integer; overload; inline;

    class function Abs(const A: BigInteger): BigInteger; static;
    class function Pow(const Base: BigInteger; Value: Cardinal): BigInteger; static;
    class function DivRem(const Dividend, Divisor: BigCardinal;
                          var Remainder: BigCardinal): BigCardinal; overload; static;

    class operator Implicit(const Value: BigCardinal): BigInteger; inline;
    class operator Explicit(const Value: BigInteger): BigCardinal; inline;

    class operator Explicit(const Value: BigInteger): Cardinal;
    class operator Explicit(const Value: BigInteger): UInt64;
    class operator Explicit(const Value: BigInteger): Integer;
    class operator Explicit(const Value: BigInteger): Int64;
    class operator Implicit(const Value: UInt32): BigInteger;
    class operator Implicit(const Value: UInt64): BigInteger;
    class operator Implicit(const Value: Int32): BigInteger;
    class operator Implicit(const Value: Int64): BigInteger;
    class operator Explicit(const Value: TBytes): BigInteger;
    class operator Explicit(const Value: string): BigInteger;

    class operator Equal(const A, B: BigInteger): Boolean; inline;
    class operator Equal(const A: BigInteger; const B: BigCardinal): Boolean; inline;
    class operator Equal(const A: BigCardinal; const B: BigInteger): Boolean; inline;
    class operator NotEqual(const A, B: BigInteger): Boolean; inline;
    class operator NotEqual(const A: BigInteger; const B: BigCardinal): Boolean; inline;
    class operator NotEqual(const A: BigCardinal; const B: BigInteger): Boolean; inline;
    class operator GreaterThan(const A, B: BigInteger): Boolean; inline;
    class operator GreaterThan(const A: BigInteger; const B: BigCardinal): Boolean; inline;
    class operator GreaterThan(const A: BigCardinal; const B: BigInteger): Boolean; inline;
    class operator GreaterThanOrEqual(const A, B: BigInteger): Boolean; inline;
    class operator GreaterThanOrEqual(const A: BigInteger; const B: BigCardinal): Boolean; inline;
    class operator GreaterThanOrEqual(const A: BigCardinal; const B: BigInteger): Boolean; inline;
    class operator LessThan(const A, B: BigInteger): Boolean; inline;
    class operator LessThan(const A: BigInteger; const B: BigCardinal): Boolean; inline;
    class operator LessThan(const A: BigCardinal; const B: BigInteger): Boolean; inline;
    class operator LessThanOrEqual(const A, B: BigInteger): Boolean; inline;
    class operator LessThanOrEqual(const A: BigInteger; const B: BigCardinal): Boolean; inline;
    class operator LessThanOrEqual(const A: BigCardinal; const B: BigInteger): Boolean; inline;

    class operator Add(const A, B: BigInteger): BigInteger;
    class operator Subtract(const A, B: BigInteger): BigInteger;
    class operator Multiply(const A, B: BigInteger): BigInteger;
    class operator IntDivide(const A, B: BigInteger): BigInteger;
    class operator Modulus(const A, B: BigInteger): BigInteger;

    class operator LeftShift(const A: BigInteger; Shift: Cardinal): BigInteger;
    class operator RightShift(const A: BigInteger; Shift: Cardinal): BigInteger;

    class operator BitwiseAnd(const A, B: BigInteger): BigInteger;
    class operator BitwiseOr(const A, B: BigInteger): BigInteger;
    class operator BitwiseXor(const A, B: BigInteger): BigInteger;

    function CompareToCard(const B: Cardinal): Integer;
    function CompareToInt(const B: Integer): Integer;
    function CompareTo(const B: Cardinal): Integer; overload; inline;
    function CompareTo(const B: Integer): Integer; overload; inline;
    class operator Equal(const A: BigInteger; const B: Cardinal): Boolean; inline;
    class operator Equal(const A: Cardinal; const B: BigInteger): Boolean; inline;
    class operator Equal(const A: BigInteger; const B: Integer): Boolean; inline;
    class operator Equal(const A: Integer; const B: BigInteger): Boolean; inline;
    class operator NotEqual(const A: BigInteger; const B: Cardinal): Boolean; inline;
    class operator NotEqual(const A: Cardinal; const B: BigInteger): Boolean; inline;
    class operator NotEqual(const A: BigInteger; const B: Integer): Boolean; inline;
    class operator NotEqual(const A: Integer; const B: BigInteger): Boolean; inline;
    class operator GreaterThan(const A: BigInteger; const B: Cardinal): Boolean; inline;
    class operator GreaterThan(const A: Cardinal; const B: BigInteger): Boolean; inline;
    class operator GreaterThan(const A: BigInteger; const B: Integer): Boolean; inline;
    class operator GreaterThan(const A: Integer; const B: BigInteger): Boolean; inline;
    class operator GreaterThanOrEqual(const A: BigInteger; const B: Cardinal): Boolean; inline;
    class operator GreaterThanOrEqual(const A: Cardinal; const B: BigInteger): Boolean; inline;
    class operator GreaterThanOrEqual(const A: BigInteger; const B: Integer): Boolean; inline;
    class operator GreaterThanOrEqual(const A: Integer; const B: BigInteger): Boolean; inline;
    class operator LessThan(const A: BigInteger; const B: Cardinal): Boolean; inline;
    class operator LessThan(const A: Cardinal; const B: BigInteger): Boolean; inline;
    class operator LessThan(const A: BigInteger; const B: Integer): Boolean; inline;
    class operator LessThan(const A: Integer; const B: BigInteger): Boolean; inline;
    class operator LessThanOrEqual(const A: BigInteger; const B: Cardinal): Boolean; inline;
    class operator LessThanOrEqual(const A: Cardinal; const B: BigInteger): Boolean; inline;
    class operator LessThanOrEqual(const A: BigInteger; const B: Integer): Boolean; inline;
    class operator LessThanOrEqual(const A: Integer; const B: BigInteger): Boolean; inline;

    function CompareToDoubleUInt(const B: UInt64): Integer;
    function CompareToDoubleInt(const B: Int64): Integer;
    function CompareTo(const B: UInt64): Integer; overload; inline;
    function CompareTo(const B: Int64): Integer; overload; inline;

    class operator Equal(const A: BigInteger; const B: UInt64): Boolean; inline;
    class operator Equal(const A: UInt64; const B: BigInteger): Boolean; inline;
    class operator Equal(const A: BigInteger; const B: Int64): Boolean; inline;
    class operator Equal(const A: Int64; const B: BigInteger): Boolean; inline;
    class operator NotEqual(const A: BigInteger; const B: UInt64): Boolean; inline;
    class operator NotEqual(const A: UInt64; const B: BigInteger): Boolean; inline;
    class operator NotEqual(const A: BigInteger; const B: Int64): Boolean; inline;
    class operator NotEqual(const A: Int64; const B: BigInteger): Boolean; inline;
    class operator GreaterThan(const A: BigInteger; const B: UInt64): Boolean; inline;
    class operator GreaterThan(const A: UInt64; const B: BigInteger): Boolean; inline;
    class operator GreaterThan(const A: BigInteger; const B: Int64): Boolean; inline;
    class operator GreaterThan(const A: Int64; const B: BigInteger): Boolean; inline;
    class operator GreaterThanOrEqual(const A: BigInteger; const B: UInt64): Boolean; inline;
    class operator GreaterThanOrEqual(const A: UInt64; const B: BigInteger): Boolean; inline;
    class operator GreaterThanOrEqual(const A: BigInteger; const B: Int64): Boolean; inline;
    class operator GreaterThanOrEqual(const A: Int64; const B: BigInteger): Boolean; inline;
    class operator LessThan(const A: BigInteger; const B: UInt64): Boolean; inline;
    class operator LessThan(const A: UInt64; const B: BigInteger): Boolean; inline;
    class operator LessThan(const A: BigInteger; const B: Int64): Boolean; inline;
    class operator LessThan(const A: Int64; const B: BigInteger): Boolean; inline;
    class operator LessThanOrEqual(const A: BigInteger; const B: UInt64): Boolean; inline;
    class operator LessThanOrEqual(const A: UInt64; const B: BigInteger): Boolean; inline;
    class operator LessThanOrEqual(const A: BigInteger; const B: Int64): Boolean; inline;
    class operator LessThanOrEqual(const A: Int64; const B: BigInteger): Boolean; inline;

    class function DivRem(const Dividend: BigInteger; const Divisor: Cardinal;
                          var Remainder: BigInteger): BigInteger; overload; static;
    class function DivRem(const Dividend: Cardinal; const Divisor: BigInteger;
                          var Remainder: Cardinal): BigInteger; overload; static;
    class function DivRem(const Dividend: BigInteger; const Divisor: Integer;
                          var Remainder: Integer): BigInteger; overload; static;
    class function DivRem(const Dividend: Integer; const Divisor: BigInteger;
                          var Remainder: Integer): Integer; overload; static;

    class operator Add(const A: BigInteger; const B: Cardinal): BigInteger;
    class operator Add(const A: Cardinal; const B: BigInteger): BigInteger;
    class operator Add(const A: BigInteger; const B: Integer): BigInteger;
    class operator Add(const A: Integer; const B: BigInteger): BigInteger;
    class operator Subtract(const A: BigInteger; const B: Cardinal): BigInteger;
    class operator Subtract(const A: Cardinal; const B: BigInteger): BigInteger;
    class operator Subtract(const A: BigInteger; const B: Integer): BigInteger;
    class operator Subtract(const A: Integer; const B: BigInteger): BigInteger;
    class operator Multiply(const A: BigInteger; const B: Cardinal): BigInteger;
    class operator Multiply(const A: Cardinal; const B: BigInteger): BigInteger;
    class operator Multiply(const A: BigInteger; const B: Integer): BigInteger;
    class operator Multiply(const A: Integer; const B: BigInteger): BigInteger;
  end;

type
  EBigNumberError = class(Exception)
  private
    FCode: TF_RESULT;
  public
    constructor Create(ACode: TF_RESULT; const Msg: string);
    property Code: TF_RESULT read FCode;
  end;

procedure BigNumberError(ACode: TF_RESULT; const Msg: string);

implementation

type
  TBigNumberFromUInt32 = function(var A: IBigNumber; Value: UInt32): TF_RESULT; stdcall;
  TBigNumberFromUInt64 = function(var A: IBigNumber; Value: UInt64): TF_RESULT; stdcall;
  TBigNumberFromInt32 = function(var A: IBigNumber; Value: Int32): TF_RESULT; stdcall;
  TBigNumberFromInt64 = function(var A: IBigNumber; Value: Int64): TF_RESULT; stdcall;
  TBigNumberFromPChar = function(var A: IBigNumber; P: PByte; L: Integer;
           CharSize: Integer; AllowNegative: Boolean; TwoCompl: Boolean): TF_RESULT; stdcall;
  TBigNumberFromPByte = function(var A: IBigNumber;
    P: PByte; L: Cardinal; AllowNegative: Boolean): TF_RESULT; stdcall;

var
  BigNumberFromUInt32: TBigNumberFromUInt32;
  BigNumberFromUInt64: TBigNumberFromUInt64;
  BigNumberFromInt32: TBigNumberFromInt32;
  BigNumberFromInt64: TBigNumberFromInt64;
  BigNumberFromPChar: TBigNumberFromPChar;
  BigNumberFromPByte: TBigNumberFromPByte;

{ EBigNumberError }

constructor EBigNumberError.Create(ACode: TF_RESULT; const Msg: string);
begin
  inherited Create(Msg);
  FCode:= ACode;
end;

procedure BigNumberError(ACode: TF_RESULT; const Msg: string);
begin
  raise EBigNumberError.Create(ACode, Msg);
end;

procedure HResCheck(Value: TF_RESULT; const ErrMsg: string); inline;
begin
  if Value <> S_OK then
    BigNumberError(Value, ErrMsg);
end;

{ BigCardinal }

function BigCardinal.ToString: string;
var
  BytesUsed: Integer;
  L, L1: Integer;
  P, P1: PByte;
  I: Integer;
  HR: TF_RESULT;

begin
  BytesUsed:= FNumber.GetSize;
// log(256) approximated from above by 41/17
  L:= (BytesUsed * 41) div 17 + 1;
  GetMem(P, L);
  try
    L1:= L;
    HR:= FNumber.ToDec(P, L1);
// -- kludge
    if HR = TF_E_INVALIDARG then begin
      FreeMem(P);
      L:= L1;
      GetMem(P, L);
      HR:= FNumber.ToDec(P, L1);
    end;
// -- end of kludge
    HResCheck(HR, 'BigCardinal -> string conversion error');
    SetLength(Result, L1);
    P1:= P;
    for I:= 1 to L1 do begin
      Result[I]:= Char(P1^);
      Inc(P1);
    end;
  finally
    FreeMem(P);
  end;
end;

function BigCardinal.ToHexString(Digits: Integer; const Prefix: string;
                         TwoCompl: Boolean): string;

var
  L, L1: Integer;
  P, P1: PByte;
  HR: TF_RESULT;
  I: Integer;

begin
  HR:= FNumber.ToHex(nil, L, TwoCompl);
  if HR = TF_E_INVALIDARG then begin
    GetMem(P, L);
    try
      L1:= L;
      HResCheck(FNumber.ToHex(P, L1, TwoCompl),
                       'BigCardinal -> hex string conversion error');
      if Digits < L1 then Digits:= L1;
      Inc(Digits, Length(Prefix));
      SetLength(Result, Digits);
      Move(Pointer(Prefix)^, Pointer(Result)^, Length(Prefix) * SizeOf(Char));
      P1:= P;
      I:= Length(Prefix);
      while I + L1 < Digits do begin
        Inc(I);
        Result[I]:= '0';
      end;
      while I < Digits do begin
        Inc(I);
        Result[I]:= Char(P1^);
        Inc(P1);
      end;
    finally
      FreeMem(P);
    end;
  end
  else
    BigNumberError(HR, 'BigCardinal -> hex string conversion error');
end;

function BigCardinal.ToBytes: TBytes;
var
  HR: TF_RESULT;
  L: Cardinal;

begin
  L:= 0;
  HR:= FNumber.ToPByte(nil, L);
  if (HR = TF_E_INVALIDARG) and (L > 0) then begin
    SetLength(Result, L);
    HR:= FNumber.ToPByte(Pointer(Result), L);
  end;
  HResCheck(HR, 'BigCardinal -> TBytes conversion error');
end;

function BigCardinal.TryParse(const S: string; TwoCompl: Boolean): Boolean;
begin
  Result:= BigNumberFromPChar(FNumber, Pointer(S), Length(S),
                              SizeOf(Char), False, TwoCompl) = TF_S_OK;
end;

procedure BigCardinal.Free;
begin
  FNumber:= nil;
end;

class function BigCardinal.Compare(const A, B: BigCardinal): Integer;
begin
  Result:= A.FNumber.CompareNumberU(B.FNumber);
end;

function BigCardinal.CompareTo(const B: BigCardinal): Integer;
begin
  Result:= Compare(Self, B);
end;

class function BigCardinal.Pow(const Base: BigCardinal; Value: Cardinal): BigCardinal;
begin
  HResCheck(Base.FNumber.PowU(Value, Result.FNumber), 'BigCardinal.Power');
end;

class function BigCardinal.DivRem(const Dividend, Divisor: BigCardinal;
                                  var Remainder: BigCardinal): BigCardinal;
begin
  HResCheck(Dividend.FNumber.DivRemNumberU(Divisor.FNumber,
            Result.FNumber, Remainder.FNumber),
            'BigCardinal.DivRem');
end;

class operator BigCardinal.Explicit(const Value: BigCardinal): Cardinal;
begin
  HResCheck(Value.FNumber.ToLimb(Result),
    'BigCardinal -> Cardinal conversion error');
end;

class operator BigCardinal.Explicit(const Value: BigCardinal): Integer;
begin
  HResCheck(Value.FNumber.ToIntLimb(Result),
    'BigCardinal -> Integer conversion error');
end;

class operator BigCardinal.Explicit(const Value: BigCardinal): UInt64;
begin
  HResCheck(Value.FNumber.ToDblLimb(Result),
    'BigCardinal -> UInt64 conversion error');
end;

class operator BigCardinal.Explicit(const Value: BigCardinal): Int64;
begin
  HResCheck(Value.FNumber.ToDblIntLimb(Result),
    'BigCardinal -> Int64 conversion error');
end;

class operator BigCardinal.Implicit(const Value: Cardinal): BigCardinal;
begin
  HResCheck(BigNumberFromUInt32(Result.FNumber, Value),
            'BigNumberFromLimb');
end;

class operator BigCardinal.Implicit(const Value: UInt64): BigCardinal;
begin
  HResCheck(BigNumberFromUInt64(Result.FNumber, Value),
            'BigNumberFromDblLimb');
end;

class operator BigCardinal.Explicit(const Value: Integer): BigCardinal;
begin
  if Value < 0 then
    BigNumberError(TF_E_INVALIDARG,
      'Integer -> BigCardinal conversion error')
  else begin
    HResCheck(BigNumberFromInt32(Result.FNumber, Value),
            'TBigNumber.FromInteger');
  end;
end;

class operator BigCardinal.Explicit(const Value: Int64): BigCardinal;
begin
  if Value < 0 then
    BigNumberError(TF_E_INVALIDARG,
      'Int64 -> BigCardinal conversion error')
  else begin
    HResCheck(BigNumberFromInt64(Result.FNumber, Value),
            'BigNumberFromDblIntLimb');
  end;
end;

class operator BigCardinal.Explicit(const Value: TBytes): BigCardinal;
begin
  HResCheck(BigNumberFromPByte(Result.FNumber,
            Pointer(Value), Length(Value), False),
    'TBytes -> BigCardinal conversion error');
end;

class operator BigCardinal.Explicit(const Value: string): BigCardinal;
begin
  HResCheck(BigNumberFromPChar(Result.FNumber, Pointer(Value), Length(Value),
                               SizeOf(Char), False, False),
    'string -> BigCardinal conversion error');
end;

class operator BigCardinal.Equal(const A, B: BigCardinal): Boolean;
begin
  Result:= Compare(A, B) = 0;
end;

class operator BigCardinal.NotEqual(const A, B: BigCardinal): Boolean;
begin
  Result:= Compare(A, B) <> 0;
end;

class operator BigCardinal.GreaterThan(const A, B: BigCardinal): Boolean;
begin
  Result:= Compare(A, B) > 0;
end;

class operator BigCardinal.GreaterThanOrEqual(const A, B: BigCardinal): Boolean;
begin
  Result:= Compare(A, B) >= 0;
end;

class operator BigCardinal.LessThan(const A, B: BigCardinal): Boolean;
begin
  Result:= Compare(A, B) < 0;
end;

class operator BigCardinal.LessThanOrEqual(const A, B: BigCardinal): Boolean;
begin
  Result:= Compare(A, B) <= 0;
end;

class operator BigCardinal.Add(const A, B: BigCardinal): BigCardinal;
begin
  HResCheck(A.FNumber.AddNumberU(B.FNumber, Result.FNumber),
            'BigCardinal.Add');
end;

class operator BigCardinal.Subtract(const A, B: BigCardinal): BigCardinal;
begin
  HResCheck(A.FNumber.SubNumberU(B.FNumber, Result.FNumber),
            'BigCardinal.Subtract');
end;

class operator BigCardinal.Multiply(const A, B: BigCardinal): BigCardinal;
begin
  HResCheck(A.FNumber.MulNumberU(B.FNumber, Result.FNumber),
            'BigCardinal.Multiply');
end;

class operator BigCardinal.IntDivide(const A, B: BigCardinal): BigCardinal;
var
  Remainder: IBigNumber;

begin
  HResCheck(A.FNumber.DivRemNumberU(B.FNumber, Result.FNumber, Remainder),
            'BigCardinal.IntDivide');
end;

class operator BigCardinal.Modulus(const A, B: BigCardinal): BigCardinal;
var
  Quotient: IBigNumber;

begin
  HResCheck(A.FNumber.DivRemNumberU(B.FNumber, Quotient, Result.FNumber),
            'BigCardinal.Modulus');
end;


class operator BigCardinal.LeftShift(const A: BigCardinal; Shift: Cardinal): BigCardinal;
begin
  HResCheck(A.FNumber.ShlNumber(Shift, Result.FNumber),
            'BigCardinal.Shl');
end;

class operator BigCardinal.RightShift(const A: BigCardinal; Shift: Cardinal): BigCardinal;
begin
  HResCheck(A.FNumber.ShrNumber(Shift, Result.FNumber),
            'BigCardinal.Shr');
end;

class operator BigCardinal.BitwiseAnd(const A, B: BigCardinal): BigCardinal;
begin
  HResCheck(A.FNumber.AndNumberU(B.FNumber, Result.FNumber),
            'BigCardinal.And');
end;

class operator BigCardinal.BitwiseOr(const A, B: BigCardinal): BigCardinal;
begin
  HResCheck(A.FNumber.OrNumberU(B.FNumber, Result.FNumber),
            'BigCardinal.Or');
end;

function BigCardinal.CompareToCard(const B: Cardinal): Integer;
begin
  Result:= FNumber.CompareToLimbU(B);
end;

function BigCardinal.CompareToInt(const B: Integer): Integer;
begin
  Result:= FNumber.CompareToIntLimbU(B);
end;

function BigCardinal.CompareTo(const B: Cardinal): Integer;
begin
  Result:= CompareToCard(B);
end;

function BigCardinal.CompareTo(const B: Integer): Integer;
begin
  Result:= CompareToInt(B);
end;

class operator BigCardinal.Equal(const A: BigCardinal; const B: Cardinal): Boolean;
begin
  Result:= A.CompareToCard(B) = 0;
end;

class operator BigCardinal.Equal(const A: Cardinal; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToCard(A) = 0;
end;

class operator BigCardinal.Equal(const A: BigCardinal; const B: Integer): Boolean;
begin
  Result:= A.CompareToInt(B) = 0;
end;

class operator BigCardinal.Equal(const A: Integer; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToInt(A) = 0;
end;

class operator BigCardinal.NotEqual(const A: BigCardinal; const B: Cardinal): Boolean;
begin
  Result:= A.CompareToCard(B) <> 0;
end;

class operator BigCardinal.NotEqual(const A: Cardinal; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToCard(A) <> 0;
end;

class operator BigCardinal.NotEqual(const A: BigCardinal; const B: Integer): Boolean;
begin
  Result:= A.CompareToInt(B) <> 0;
end;

class operator BigCardinal.NotEqual(const A: Integer; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToInt(A) <> 0;
end;

class operator BigCardinal.GreaterThan(const A: BigCardinal; const B: Cardinal): Boolean;
begin
  Result:= A.CompareToCard(B) > 0;
end;

class operator BigCardinal.GreaterThan(const A: Cardinal; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToCard(A) < 0;
end;

class operator BigCardinal.GreaterThan(const A: BigCardinal; const B: Integer): Boolean;
begin
  Result:= A.CompareToInt(B) > 0;
end;

class operator BigCardinal.GreaterThan(const A: Integer; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToInt(A) < 0;
end;

class operator BigCardinal.GreaterThanOrEqual(const A: BigCardinal; const B: Cardinal): Boolean;
begin
  Result:= A.CompareToCard(B) >= 0;
end;

class operator BigCardinal.GreaterThanOrEqual(const A: Cardinal; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToCard(A) <= 0;
end;

class operator BigCardinal.GreaterThanOrEqual(const A: BigCardinal; const B: Integer): Boolean;
begin
  Result:= A.CompareToInt(B) >= 0;
end;

class operator BigCardinal.GreaterThanOrEqual(const A: Integer; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToInt(A) <= 0;
end;

class operator BigCardinal.LessThan(const A: BigCardinal; const B: Cardinal): Boolean;
begin
  Result:= A.CompareToCard(B) < 0;
end;

class operator BigCardinal.LessThan(const A: Cardinal; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToCard(A) > 0;
end;

class operator BigCardinal.LessThan(const A: BigCardinal; const B: Integer): Boolean;
begin
  Result:= A.CompareToInt(B) < 0;
end;

class operator BigCardinal.LessThan(const A: Integer; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToInt(A) > 0;
end;

class operator BigCardinal.LessThanOrEqual(const A: BigCardinal; const B: Cardinal): Boolean;
begin
  Result:= A.CompareToCard(B) <= 0;
end;

class operator BigCardinal.LessThanOrEqual(const A: Cardinal; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToCard(A) >= 0;
end;

class operator BigCardinal.LessThanOrEqual(const A: BigCardinal; const B: Integer): Boolean;
begin
  Result:= A.CompareToInt(B) <= 0;
end;

class operator BigCardinal.LessThanOrEqual(const A: Integer; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToInt(A) >= 0;
end;

{--- Comparison with 64-bit integers ---}

function BigCardinal.CompareToUInt64(const B: UInt64): Integer;
begin
  Result:= FNumber.CompareToDblLimbU(B);
end;

function BigCardinal.CompareToInt64(const B: Int64): Integer;
begin
  Result:= FNumber.CompareToDblIntLimbU(B);
end;

function BigCardinal.CompareTo(const B: UInt64): Integer;
begin
  Result:= CompareToUInt64(B);
end;

function BigCardinal.CompareTo(const B: Int64): Integer;
begin
  Result:= CompareToInt64(B);
end;

class operator BigCardinal.Equal(const A: BigCardinal; const B: UInt64): Boolean;
begin
  Result:= A.CompareToUInt64(B) = 0;
end;

class operator BigCardinal.Equal(const A: UInt64; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToUInt64(A) = 0;
end;

class operator BigCardinal.Equal(const A: BigCardinal; const B: Int64): Boolean;
begin
  Result:= A.CompareToInt64(B) = 0;
end;

class operator BigCardinal.Equal(const A: Int64; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToInt64(A) = 0;
end;

class operator BigCardinal.NotEqual(const A: BigCardinal; const B: UInt64): Boolean;
begin
  Result:= A.CompareToUInt64(B) <> 0;
end;

class operator BigCardinal.NotEqual(const A: UInt64; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToUInt64(A) <> 0;
end;

class operator BigCardinal.NotEqual(const A: BigCardinal; const B: Int64): Boolean;
begin
  Result:= A.CompareToInt64(B) <> 0;
end;

class operator BigCardinal.NotEqual(const A: Int64; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToInt64(A) <> 0;
end;

class operator BigCardinal.GreaterThan(const A: BigCardinal; const B: UInt64): Boolean;
begin
  Result:= A.CompareToUInt64(B) > 0;
end;

class operator BigCardinal.GreaterThan(const A: UInt64; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToUInt64(A) < 0;
end;

class operator BigCardinal.GreaterThan(const A: BigCardinal; const B: Int64): Boolean;
begin
  Result:= A.CompareToInt64(B) > 0;
end;

class operator BigCardinal.GreaterThan(const A: Int64; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToInt64(A) < 0;
end;

class operator BigCardinal.GreaterThanOrEqual(const A: BigCardinal; const B: UInt64): Boolean;
begin
  Result:= A.CompareToUInt64(B) >= 0;
end;

class operator BigCardinal.GreaterThanOrEqual(const A: UInt64; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToUInt64(A) <= 0;
end;

class operator BigCardinal.GreaterThanOrEqual(const A: BigCardinal; const B: Int64): Boolean;
begin
  Result:= A.CompareToInt64(B) >= 0;
end;

class operator BigCardinal.GreaterThanOrEqual(const A: Int64; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToInt64(A) <= 0;
end;

class operator BigCardinal.LessThan(const A: BigCardinal; const B: UInt64): Boolean;
begin
  Result:= A.CompareToUInt64(B) < 0;
end;

class operator BigCardinal.LessThan(const A: UInt64; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToUInt64(A) > 0;
end;

class operator BigCardinal.LessThan(const A: BigCardinal; const B: Int64): Boolean;
begin
  Result:= A.CompareToInt64(B) < 0;
end;

class operator BigCardinal.LessThan(const A: Int64; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToInt64(A) > 0;
end;

class operator BigCardinal.LessThanOrEqual(const A: BigCardinal; const B: UInt64): Boolean;
begin
  Result:= A.CompareToUInt64(B) <= 0;
end;

class operator BigCardinal.LessThanOrEqual(const A: UInt64; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToUInt64(A) >= 0;
end;

class operator BigCardinal.LessThanOrEqual(const A: BigCardinal; const B: Int64): Boolean;
begin
  Result:= A.CompareToInt64(B) <= 0;
end;

class operator BigCardinal.LessThanOrEqual(const A: Int64; const B: BigCardinal): Boolean;
begin
  Result:= B.CompareToInt64(A) >= 0;
end;



class operator BigCardinal.Add(const A: BigCardinal; const B: Cardinal): BigCardinal;
begin
  HResCheck(A.FNumber.AddLimbU(B, Result.FNumber),
            'BigCardinal.AddLimbU');
end;

class operator BigCardinal.Add(const A: Cardinal; const B: BigCardinal): BigCardinal;
begin
  HResCheck(B.FNumber.AddLimbU(A, Result.FNumber),
            'BigCardinal.AddLimbU');
end;

class operator BigCardinal.Subtract(const A: BigCardinal; const B: Cardinal): BigCardinal;
begin
  HResCheck(A.FNumber.SubLimbU(B, Result.FNumber),
            'BigCardinal.SubLimbU');
end;

class operator BigCardinal.Subtract(const A: Cardinal; const B: BigCardinal): Cardinal;
begin
  HResCheck(B.FNumber.SubLimbU2(A, Result),
            'BigCardinal.SubLimbU2');
end;

class operator BigCardinal.Multiply(const A: BigCardinal; const B: Cardinal): BigCardinal;
begin
  HResCheck(A.FNumber.MulLimbU(B, Result.FNumber),
            'BigCardinal.MulLimbU');
end;

class operator BigCardinal.Multiply(const A: Cardinal; const B: BigCardinal): BigCardinal;
begin
  HResCheck(B.FNumber.MulLimbU(A, Result.FNumber),
            'BigCardinal.MulLimbU');
end;


class function BigCardinal.DivRem(const Dividend: BigCardinal;
               Divisor: Cardinal; var Remainder: Cardinal): BigCardinal;
begin
  HResCheck(Dividend.FNumber.DivRemLimbU(Divisor, Result.FNumber, Remainder),
            'BigCardinal.DivRemLimbU');
end;

class function BigCardinal.DivRem(const Dividend: Cardinal;
               Divisor: BigCardinal; var Remainder: Cardinal): Cardinal;
begin
  HResCheck(Divisor.FNumber.DivRemLimbU2(Dividend, Result, Remainder),
            'BigCardinal.DivRemLimbU2');
end;

class operator BigCardinal.IntDivide(const A: BigCardinal; const B: Cardinal): BigCardinal;
var
  Remainder: Cardinal;

begin
  HResCheck(A.FNumber.DivRemLimbU(B, Result.FNumber, Remainder),
            'BigCardinal.IntDivide');
end;

class operator BigCardinal.IntDivide(const A: Cardinal; const B: BigCardinal): Cardinal;
var
  Remainder: Cardinal;

begin
  HResCheck(B.FNumber.DivRemLimbU2(A, Result, Remainder),
            'BigCardinal.IntDivide');
end;

class operator BigCardinal.Modulus(const A: BigCardinal; const B: Cardinal): Cardinal;
var
  Quotient: IBigNumber;

begin
  HResCheck(A.FNumber.DivRemLimbU(B, Quotient, Result),
            'BigCardinal.Modulus');
end;


class operator BigCardinal.Modulus(const A: Cardinal; const B: BigCardinal): Cardinal;
var
  Quotient: Cardinal;

begin
  HResCheck(B.FNumber.DivRemLimbU2(A, Quotient, Result),
            'BigCardinal.Modulus');
end;

{ -------------------------- BigInteger -------------------------- }

function BigInteger.GetSign: Integer;
begin
  Result:= FNumber.GetSign;
end;

function BigInteger.ToString: string;
var
  BytesUsed: Integer;
  L, L1: Integer;
  P, P1: PByte;
  I: Integer;
  IsMinus: Boolean;
  HR: TF_RESULT;

begin
  BytesUsed:= FNumber.GetSize;
// log(256) approximated from above by 41/17
  L:= (BytesUsed * 41) div 17 + 1;
  GetMem(P, L);
  try
    L1:= L;
    HR:= FNumber.ToDec(P, L1);
// -- kludge
    if HR = TF_E_INVALIDARG then begin
      FreeMem(P);
      L:= L1;
      GetMem(P, L);
      HR:= FNumber.ToDec(P, L1);
    end;
// -- end of kludge
    HResCheck(HR, 'BigInteger -> string conversion error');
    IsMinus:= GetSign < 0;
    if IsMinus then Inc(L1);
    SetLength(Result, L1);
    I:= 1;
    if IsMinus then begin
      Result[1]:= '-';
      Inc(I);
    end;
    P1:= P;
    while I <= L1 do begin
      Result[I]:= Char(P1^);
      Inc(P1);
      Inc(I);
    end;
  finally
    FreeMem(P);
  end;
end;

function BigInteger.ToHexString(Digits: Integer; const Prefix: string;
                                TwoCompl: Boolean): string;
const
  ASCII_8 = 56;   // Ord('8')

var
  L, L1: Integer;
  P, P1: PByte;
  HR: TF_RESULT;
  Filler: Char;
  I: Integer;

begin
  Result:= '';
  HR:= FNumber.ToHex(nil, L, TwoCompl);
  if HR = TF_E_INVALIDARG then begin
    GetMem(P, L);
    try
      L1:= L;
      HResCheck(FNumber.ToHex(P, L1, TwoCompl),
                       'BigInteger -> hex string conversion error');
      if Digits < L1 then Digits:= L1;
      I:= 1;
      if (FNumber.GetSign < 0) and not TwoCompl then begin
        Inc(I);
        SetLength(Result, Digits + Length(Prefix) + 1);
        Result[1]:= '-';
      end
      else
        SetLength(Result, Digits + Length(Prefix));
      Move(Pointer(Prefix)^, Result[I], Length(Prefix) * SizeOf(Char));
      Inc(I, Length(Prefix));
      if Digits > L1 then begin
        if TwoCompl and (P[L1] >= ASCII_8) then Filler:= 'F'
        else Filler:= '0';
        while I + L1 <= Length(Result) do begin
          Result[I]:= Filler;
          Inc(I);
        end;
      end;
      P1:= P;
      while I <= Length(Result) do begin
        Result[I]:= Char(P1^);
        Inc(I);
        Inc(P1);
      end;
    finally
      FreeMem(P);
    end;
  end
  else
    BigNumberError(HR, 'BigInteger -> hex string conversion error');
end;

function BigInteger.ToBytes: TBytes;
var
  HR: TF_RESULT;
  L: Cardinal;

begin
  L:= 0;
  HR:= FNumber.ToPByte(nil, L);
  if (HR = TF_E_INVALIDARG) and (L > 0) then begin
    SetLength(Result, L);
    HR:= FNumber.ToPByte(Pointer(Result), L);
  end;
  HResCheck(HR, 'BigInteger -> TBytes conversion error');
end;

function BigInteger.TryParse(const S: string; TwoCompl: Boolean): Boolean;
begin
  Result:= BigNumberFromPChar(FNumber, Pointer(S), Length(S),
                              SizeOf(Char), True, TwoCompl) = TF_S_OK;
//  Result:= BigNumberFromPWideChar(FNumber, Pointer(S), Length(S),
//              True) = TF_S_OK;
end;

procedure BigInteger.Free;
begin
  FNumber:= nil;
end;

class function BigInteger.Compare(const A, B: BigInteger): Integer;
begin
  Result:= A.FNumber.CompareNumber(B.FNumber);
end;

class function BigInteger.Compare(const A: BigInteger; const B: BigCardinal): Integer;
begin
  Result:= A.FNumber.CompareNumber(B.FNumber);
end;

class function BigInteger.Compare(const A: BigCardinal; const B: BigInteger): Integer;
begin
  Result:= A.FNumber.CompareNumber(B.FNumber);
end;

function BigInteger.CompareTo(const B: BigInteger): Integer;
begin
  Result:= Compare(Self, B);
end;

function BigInteger.CompareTo(const B: BigCardinal): Integer;
begin
  Result:= Compare(Self, B);
end;

class function BigInteger.Abs(const A: BigInteger): BigInteger;
begin
  HResCheck(A.FNumber.AbsNumber(Result.FNumber), 'BigInteger.Abs');
end;

class function BigInteger.Pow(const Base: BigInteger; Value: Cardinal): BigInteger;
begin
  HResCheck(Base.FNumber.Pow(Value, Result.FNumber),
                        'BigInteger.Power');
end;

class function BigInteger.DivRem(const Dividend, Divisor: BigCardinal;
               var Remainder: BigCardinal): BigCardinal;
begin
  HResCheck(Dividend.FNumber.DivRemNumber(Divisor.FNumber,
            Result.FNumber, Remainder.FNumber),
            'BigInteger.DivRem');
end;

class operator BigInteger.Implicit(const Value: BigCardinal): BigInteger;
begin
  Result.FNumber:= Value.FNumber;
end;

class operator BigInteger.Explicit(const Value: BigInteger): BigCardinal;
begin
  if (Value.FNumber.GetSign < 0) then
      BigNumberError(TF_E_INVALIDARG, 'Negative value');
  Result.FNumber:= Value.FNumber;
end;

class operator BigInteger.Explicit(const Value: BigInteger): Cardinal;
begin
  HResCheck(Value.FNumber.ToLimb(Result),
    'BigInteger -> UInt32 conversion error');
end;

class operator BigInteger.Explicit(const Value: BigInteger): UInt64;
begin
  HResCheck(Value.FNumber.ToDblLimb(Result),
    'BigInteger -> UInt64 conversion error');
end;

class operator BigInteger.Explicit(const Value: BigInteger): Integer;
begin
  HResCheck(Value.FNumber.ToIntLimb(Result),
    'BigInteger -> Int32 conversion error');
end;

class operator BigInteger.Explicit(const Value: BigInteger): Int64;
begin
  HResCheck(Value.FNumber.ToDblIntLimb(Result),
    'BigInteger -> Int64 conversion error');
end;

class operator BigInteger.Implicit(const Value: UInt32): BigInteger;
begin
  HResCheck(BigNumberFromUInt32(Result.FNumber, Value),
            'BigNumberFromLimb');
end;

class operator BigInteger.Implicit(const Value: UInt64): BigInteger;
begin
  HResCheck(BigNumberFromUInt64(Result.FNumber, Value),
            'BigNumberFromDblLimb');
end;

class operator BigInteger.Implicit(const Value: Int32): BigInteger;
begin
  HResCheck(BigNumberFromInt32(Result.FNumber, Value),
            'BigNumberFromIntLimb');
end;

class operator BigInteger.Implicit(const Value: Int64): BigInteger;
begin
  HResCheck(BigNumberFromInt64(Result.FNumber, Value),
            'BigNumberFromDblIntLimb');
end;

class operator BigInteger.Explicit(const Value: TBytes): BigInteger;
begin
  HResCheck(BigNumberFromPByte(Result.FNumber,
            Pointer(Value), Length(Value), True),
            'TBytes -> BigInteger conversion error');
end;

class operator BigInteger.Explicit(const Value: string): BigInteger;
begin
//  HResCheck(BigNumberFromPWideChar(Result.FNumber, Pointer(Value),
//            Length(Value), True),
  HResCheck(BigNumberFromPChar(Result.FNumber, Pointer(Value), Length(Value),
                               SizeOf(Char), True, False),
            'string -> BigInteger conversion error');
end;

class operator BigInteger.Equal(const A, B: BigInteger): Boolean;
begin
  Result:= Compare(A, B) = 0;
end;

class operator BigInteger.Equal(const A: BigCardinal; const B: BigInteger): Boolean;
begin
  Result:= Compare(A, B) = 0;
end;

class operator BigInteger.Equal(const A: BigInteger; const B: BigCardinal): Boolean;
begin
  Result:= Compare(A, B) = 0;
end;

class operator BigInteger.NotEqual(const A, B: BigInteger): Boolean;
begin
  Result:= Compare(A, B) <> 0;
end;

class operator BigInteger.NotEqual(const A: BigCardinal; const B: BigInteger): Boolean;
begin
  Result:= Compare(A, B) <> 0;
end;

class operator BigInteger.NotEqual(const A: BigInteger; const B: BigCardinal): Boolean;
begin
  Result:= Compare(A, B) <> 0;
end;

class operator BigInteger.GreaterThan(const A, B: BigInteger): Boolean;
begin
  Result:= Compare(A, B) > 0;
end;

class operator BigInteger.GreaterThan(const A: BigInteger; const B: BigCardinal): Boolean;
begin
  Result:= Compare(A, B) > 0;
end;

class operator BigInteger.GreaterThan(const A: BigCardinal; const B: BigInteger): Boolean;
begin
  Result:= Compare(A, B) > 0;
end;

class operator BigInteger.GreaterThanOrEqual(const A, B: BigInteger): Boolean;
begin
  Result:= Compare(A, B) >= 0;
end;

class operator BigInteger.GreaterThanOrEqual(const A: BigInteger; const B: BigCardinal): Boolean;
begin
  Result:= Compare(A, B) >= 0;
end;

class operator BigInteger.GreaterThanOrEqual(const A: BigCardinal; const B: BigInteger): Boolean;
begin
  Result:= Compare(A, B) >= 0;
end;

class operator BigInteger.LessThan(const A, B: BigInteger): Boolean;
begin
  Result:= Compare(A, B) < 0;
end;

class operator BigInteger.LessThan(const A: BigInteger; const B: BigCardinal): Boolean;
begin
  Result:= Compare(A, B) < 0;
end;

class operator BigInteger.LessThan(const A: BigCardinal; const B: BigInteger): Boolean;
begin
  Result:= Compare(A, B) < 0;
end;

class operator BigInteger.LessThanOrEqual(const A, B: BigInteger): Boolean;
begin
  Result:= Compare(A, B) <= 0;
end;

class operator BigInteger.LessThanOrEqual(const A: BigInteger; const B: BigCardinal): Boolean;
begin
  Result:= Compare(A, B) <= 0;
end;

class operator BigInteger.LessThanOrEqual(const A: BigCardinal; const B: BigInteger): Boolean;
begin
  Result:= Compare(A, B) <= 0;
end;

class operator BigInteger.Add(const A, B: BigInteger): BigInteger;
begin
  HResCheck(A.FNumber.AddNumber(B.FNumber, Result.FNumber), 'BigInteger.Add');
end;

class operator BigInteger.Subtract(const A, B: BigInteger): BigInteger;
begin
  HResCheck(A.FNumber.SubNumber(B.FNumber, Result.FNumber), 'BigInteger.Subtract');
end;

class operator BigInteger.Multiply(const A, B: BigInteger): BigInteger;
begin
  HResCheck(A.FNumber.MulNumber(B.FNumber, Result.FNumber), 'BigInteger.Multiply');
end;

class operator BigInteger.IntDivide(const A, B: BigInteger): BigInteger;
var
  Remainder: IBigNumber;

begin
  HResCheck(A.FNumber.DivRemNumber(B.FNumber, Result.FNumber, Remainder),
            'BigInteger.IntDivide');
end;

class operator BigInteger.Modulus(const A, B: BigInteger): BigInteger;
var
  Quotient: IBigNumber;

begin
  HResCheck(A.FNumber.DivRemNumber(B.FNumber, Quotient, Result.FNumber),
            'BigInteger.Modulus');
end;

class operator BigInteger.LeftShift(const A: BigInteger; Shift: Cardinal): BigInteger;
begin
  HResCheck(A.FNumber.ShlNumber(Shift, Result.FNumber),
   'BigInteger.Shl');
end;

class operator BigInteger.RightShift(const A: BigInteger; Shift: Cardinal): BigInteger;
begin
  HResCheck(A.FNumber.ShrNumber(Shift, Result.FNumber),
   'BigInteger.Shr');
end;

class operator BigInteger.BitwiseAnd(const A, B: BigInteger): BigInteger;
begin
  HResCheck(A.FNumber.AndNumber(B.FNumber, Result.FNumber),
                       'BigInteger.And');
end;

class operator BigInteger.BitwiseOr(const A, B: BigInteger): BigInteger;
begin
  HResCheck(A.FNumber.OrNumber(B.FNumber, Result.FNumber),
                       'BigInteger.Or');
end;

class operator BigInteger.BitwiseXor(const A, B: BigInteger): BigInteger;
begin
  HResCheck(A.FNumber.XorNumber(B.FNumber, Result.FNumber),
                       'BigInteger.Xor');
end;

function BigInteger.CompareToCard(const B: Cardinal): Integer;
begin
  Result:= FNumber.CompareToLimb(B);
end;

function BigInteger.CompareToInt(const B: Integer): Integer;
begin
  Result:= FNumber.CompareToIntLimb(B);
end;

function BigInteger.CompareTo(const B: Cardinal): Integer;
begin
  Result:= CompareToCard(B);
end;

function BigInteger.CompareTo(const B: Integer): Integer;
begin
  Result:= CompareToInt(B);
end;

class operator BigInteger.Equal(const A: BigInteger; const B: Cardinal): Boolean;
begin
  Result:= A.CompareToCard(B) = 0;
end;

class operator BigInteger.Equal(const A: Cardinal; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToCard(A) = 0;
end;

class operator BigInteger.Equal(const A: BigInteger; const B: Integer): Boolean;
begin
  Result:= A.CompareToInt(B) = 0;
end;

class operator BigInteger.Equal(const A: Integer; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToInt(A) = 0;
end;

class operator BigInteger.NotEqual(const A: BigInteger; const B: Cardinal): Boolean;
begin
  Result:= A.CompareToCard(B) <> 0;
end;

class operator BigInteger.NotEqual(const A: Cardinal; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToCard(A) <> 0;
end;

class operator BigInteger.NotEqual(const A: BigInteger; const B: Integer): Boolean;
begin
  Result:= A.CompareToInt(B) <> 0;
end;

class operator BigInteger.NotEqual(const A: Integer; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToInt(A) <> 0;
end;

class operator BigInteger.GreaterThan(const A: BigInteger; const B: Cardinal): Boolean;
begin
  Result:= A.CompareToCard(B) > 0;
end;

class operator BigInteger.GreaterThan(const A: Cardinal; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToCard(A) < 0;
end;

class operator BigInteger.GreaterThan(const A: BigInteger; const B: Integer): Boolean;
begin
  Result:= A.CompareToInt(B) > 0;
end;

class operator BigInteger.GreaterThan(const A: Integer; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToInt(A) < 0;
end;

class operator BigInteger.GreaterThanOrEqual(const A: BigInteger; const B: Cardinal): Boolean;
begin
  Result:= A.CompareToCard(B) >= 0;
end;

class operator BigInteger.GreaterThanOrEqual(const A: Cardinal; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToCard(A) <= 0;
end;

class operator BigInteger.GreaterThanOrEqual(const A: BigInteger; const B: Integer): Boolean;
begin
  Result:= A.CompareToInt(B) >= 0;
end;

class operator BigInteger.GreaterThanOrEqual(const A: Integer; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToInt(A) <= 0;
end;

class operator BigInteger.LessThan(const A: BigInteger; const B: Cardinal): Boolean;
begin
  Result:= A.CompareToCard(B) < 0;
end;

class operator BigInteger.LessThan(const A: Cardinal; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToCard(A) > 0;
end;

class operator BigInteger.LessThan(const A: BigInteger; const B: Integer): Boolean;
begin
  Result:= A.CompareToInt(B) < 0;
end;

class operator BigInteger.LessThan(const A: Integer; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToInt(A) > 0;
end;

class operator BigInteger.LessThanOrEqual(const A: BigInteger; const B: Cardinal): Boolean;
begin
  Result:= A.CompareToCard(B) <= 0;
end;

class operator BigInteger.LessThanOrEqual(const A: Cardinal; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToCard(A) >= 0;
end;

class operator BigInteger.LessThanOrEqual(const A: BigInteger; const B: Integer): Boolean;
begin
  Result:= A.CompareToInt(B) <= 0;
end;

class operator BigInteger.LessThanOrEqual(const A: Integer; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToInt(A) >= 0;
end;


function BigInteger.CompareToDoubleUInt(const B: UInt64): Integer;
begin
  Result:= FNumber.CompareToDblLimb(B);
end;

function BigInteger.CompareToDoubleInt(const B: Int64): Integer;
begin
  Result:= FNumber.CompareToDblIntLimb(B);
end;

function BigInteger.CompareTo(const B: UInt64): Integer;
begin
  Result:= CompareToDoubleUInt(B);
end;

function BigInteger.CompareTo(const B: Int64): Integer;
begin
  Result:= CompareToDoubleInt(B);
end;

class operator BigInteger.Equal(const A: BigInteger; const B: UInt64): Boolean;
begin
  Result:= A.CompareToDoubleUInt(B) = 0;
end;

class operator BigInteger.Equal(const A: UInt64; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToDoubleUInt(A) = 0;
end;

class operator BigInteger.Equal(const A: BigInteger; const B: Int64): Boolean;
begin
  Result:= A.CompareToDoubleInt(B) = 0;
end;

class operator BigInteger.Equal(const A: Int64; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToDoubleInt(A) = 0;
end;

class operator BigInteger.NotEqual(const A: BigInteger; const B: UInt64): Boolean;
begin
  Result:= A.CompareToDoubleUInt(B) <> 0;
end;

class operator BigInteger.NotEqual(const A: UInt64; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToDoubleUInt(A) <> 0;
end;

class operator BigInteger.NotEqual(const A: BigInteger; const B: Int64): Boolean;
begin
  Result:= A.CompareToDoubleInt(B) <> 0;
end;

class operator BigInteger.NotEqual(const A: Int64; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToDoubleInt(A) <> 0;
end;

class operator BigInteger.GreaterThan(const A: BigInteger; const B: UInt64): Boolean;
begin
  Result:= A.CompareToDoubleUInt(B) > 0;
end;

class operator BigInteger.GreaterThan(const A: UInt64; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToDoubleUInt(A) < 0;
end;

class operator BigInteger.GreaterThan(const A: BigInteger; const B: Int64): Boolean;
begin
  Result:= A.CompareToDoubleInt(B) > 0;
end;

class operator BigInteger.GreaterThan(const A: Int64; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToDoubleInt(A) < 0;
end;

class operator BigInteger.GreaterThanOrEqual(const A: BigInteger; const B: UInt64): Boolean;
begin
  Result:= A.CompareToDoubleUInt(B) >= 0;
end;

class operator BigInteger.GreaterThanOrEqual(const A: UInt64; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToDoubleUInt(A) <= 0;
end;

class operator BigInteger.GreaterThanOrEqual(const A: BigInteger; const B: Int64): Boolean;
begin
  Result:= A.CompareToDoubleInt(B) >= 0;
end;

class operator BigInteger.GreaterThanOrEqual(const A: Int64; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToDoubleInt(A) <= 0;
end;

class operator BigInteger.LessThan(const A: BigInteger; const B: UInt64): Boolean;
begin
  Result:= A.CompareToDoubleUInt(B) < 0;
end;

class operator BigInteger.LessThan(const A: UInt64; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToDoubleUInt(A) > 0;
end;

class operator BigInteger.LessThan(const A: BigInteger; const B: Int64): Boolean;
begin
  Result:= A.CompareToDoubleInt(B) < 0;
end;

class operator BigInteger.LessThan(const A: Int64; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToDoubleInt(A) > 0;
end;

class operator BigInteger.LessThanOrEqual(const A: BigInteger; const B: UInt64): Boolean;
begin
  Result:= A.CompareToDoubleUInt(B) <= 0;
end;

class operator BigInteger.LessThanOrEqual(const A: UInt64; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToDoubleUInt(A) >= 0;
end;

class operator BigInteger.LessThanOrEqual(const A: BigInteger; const B: Int64): Boolean;
begin
  Result:= A.CompareToDoubleInt(B) <= 0;
end;

class operator BigInteger.LessThanOrEqual(const A: Int64; const B: BigInteger): Boolean;
begin
  Result:= B.CompareToDoubleInt(A) >= 0;
end;

class function BigInteger.DivRem(const Dividend: BigInteger;
               const Divisor: Cardinal; var Remainder: BigInteger): BigInteger;
begin
  HResCheck(Dividend.FNumber.DivRemLimb(Divisor, Result.FNumber, Remainder.FNumber),
            'BigCardinal.DivRemLimb');
end;

class function BigInteger.DivRem(const Dividend: Cardinal;
               const Divisor: BigInteger; var Remainder: Cardinal): BigInteger;
begin
  HResCheck(Divisor.FNumber.DivRemLimb2(Dividend, Result.FNumber, Remainder),
            'BigCardinal.DivRemLimb2');
end;

class function BigInteger.DivRem(const Dividend: BigInteger;
               const Divisor: Integer; var Remainder: Integer): BigInteger;
begin
  HResCheck(Dividend.FNumber.DivRemIntLimb(Divisor, Result.FNumber, Remainder),
            'BigCardinal.DivRemIntLimb');
end;

class function BigInteger.DivRem(const Dividend: Integer;
               const Divisor: BigInteger; var Remainder: Integer): Integer;
begin
  HResCheck(Divisor.FNumber.DivRemIntLimb2(Dividend, Result, Remainder),
            'BigCardinal.DivRemIntLimb2');
end;


class operator BigInteger.Add(const A: BigInteger; const B: Cardinal): BigInteger;
begin
  HResCheck(A.FNumber.AddLimb(B, Result.FNumber),
            'BigCardinal.AddLimb');
end;

class operator BigInteger.Add(const A: Cardinal; const B: BigInteger): BigInteger;
begin
  HResCheck(B.FNumber.AddLimb(A, Result.FNumber),
            'BigCardinal.AddLimb');
end;

class operator BigInteger.Add(const A: BigInteger; const B: Integer): BigInteger;
begin
  HResCheck(A.FNumber.AddIntLimb(B, Result.FNumber),
           'BigInteger.AddIntLimb');
end;

class operator BigInteger.Add(const A: Integer; const B: BigInteger): BigInteger;
begin
  HResCheck(B.FNumber.AddIntLimb(A, Result.FNumber),
            'BigInteger.AddIntLimb');
end;

class operator BigInteger.Subtract(const A: BigInteger; const B: Cardinal): BigInteger;
begin
  HResCheck(A.FNumber.SubLimb(B, Result.FNumber),
            'BigInteger.Subtract');
end;

class operator BigInteger.Subtract(const A: Cardinal; const B: BigInteger): BigInteger;
begin
  HResCheck(B.FNumber.SubLimb2(A, Result.FNumber),
            'BigInteger.Subtract');
end;

class operator BigInteger.Subtract(const A: BigInteger; const B: Integer): BigInteger;
begin
  HResCheck(A.FNumber.SubIntLimb(B, Result.FNumber),
            'BigInteger.Subtract');
end;

class operator BigInteger.Subtract(const A: Integer; const B: BigInteger): BigInteger;
begin
  HResCheck(B.FNumber.SubIntLimb2(A, Result.FNumber),
            'BigInteger.Subtract');
end;

class operator BigInteger.Multiply(const A: BigInteger; const B: Cardinal): BigInteger;
begin
  HResCheck(A.FNumber.MulLimb(B, Result.FNumber),
            'BigInteger.MulLimb');
end;

class operator BigInteger.Multiply(const A: Cardinal; const B: BigInteger): BigInteger;
begin
  HResCheck(B.FNumber.MulLimb(A, Result.FNumber),
            'BigInteger.MulLimb');
end;

class operator BigInteger.Multiply(const A: BigInteger; const B: Integer): BigInteger;
begin
  HResCheck(A.FNumber.MulIntLimb(B, Result.FNumber),
            'BigInteger.MulIntLimb');
end;

class operator BigInteger.Multiply(const A: Integer; const B: BigInteger): BigInteger;
begin
  HResCheck(B.FNumber.MulIntLimb(A, Result.FNumber),
            'BigInteger.MulIntLimb');
end;


// -------------------------------------------------------------- //

function BigNumberFrom32Stub(var A: IBigNumber; Value: UInt32): TF_RESULT; stdcall;
begin
  Result:= TF_E_LOADERROR;
end;

function BigNumberFrom64Stub(var A: IBigNumber; Value: UInt64): TF_RESULT; stdcall;
begin
  Result:= TF_E_LOADERROR;
end;

function BigNumberFromPCharStub(var A: IBigNumber; P: PByte; L: Integer;
           CharSize: Integer; AllowNegative: Boolean; TwoCompl: Boolean): TF_RESULT; stdcall;
begin
  Result:= TF_E_LOADERROR;
end;

function BigNumberFromPByteStub(var A: IBigNumber;
           P: PByte; L: Cardinal; AllowNegative: Boolean): TF_RESULT; stdcall;
begin
  Result:= TF_E_LOADERROR;
end;

const
{$IFDEF WIN64}
  LibName = 'numerics64.dll';
{$ELSE}
  LibName = 'numerics32.dll';
{$ENDIF}

var
  LibHandle: THandle = 0;

function LoadLib: Boolean;
begin
  if LibHandle <> 0 then begin
    Result:= True;
    Exit;
  end;
  Result:= False;
  LibHandle:= LoadLibrary(LibName);
  if LibHandle <> 0 then begin
    @BigNumberFromUInt32:= GetProcAddress(LibHandle, 'BigNumberFromLimb');
    @BigNumberFromUInt64:= GetProcAddress(LibHandle, 'BigNumberFromDblLimb');
    @BigNumberFromInt32:= GetProcAddress(LibHandle, 'BigNumberFromIntLimb');
    @BigNumberFromInt64:= GetProcAddress(LibHandle, 'BigNumberFromDblIntLimb');
    @BigNumberFromPChar:= GetProcAddress(LibHandle, 'BigNumberFromPChar');
    @BigNumberFromPByte:= GetProcAddress(LibHandle, 'BigNumberFromPByte');
    Result:= (@BigNumberFromUInt32 <> nil)
             and (@BigNumberFromUInt64 <> nil)
             and (@BigNumberFromInt32 <> nil)
             and (@BigNumberFromInt64 <> nil)
             and (@BigNumberFromPChar <> nil)
             and (@BigNumberFromPByte <> nil)
  end;
  if not Result then begin
    @BigNumberFromUInt32:= @BigNumberFrom32Stub;
    @BigNumberFromUInt64:= @BigNumberFrom64Stub;
    @BigNumberFromInt32:= @BigNumberFrom32Stub;
    @BigNumberFromInt64:= @BigNumberFrom64Stub;
    @BigNumberFromPChar:= @BigNumberFromPCharStub;
    @BigNumberFromPByte:= @BigNumberFromPByteStub;
  end;
end;

initialization
  LoadLib;

end.

CnPack IDE-Мастер: подсветка операторов управления потоком выполнения

2013-07-23T03:43:00.000+04:00

В меню CnPack -> Настройки IDE-расширений -> Подсветка синтаксиса появилась новая опция - "Выделять операторы упр. потоком выполнения":

При включенной опции такие конструкции как Exit/Abort/Break/Continue/Raise будут выделены:

Что бы сделали мы с Delphi XE5/XE6/...

2013-07-18T14:51:00.000+04:00

Уважаемые читатели блога и ленты Delphifeeds.ru!

Приглашаю всех неравнодушных к Delphi поучаствовать в следующем опросе. Задача такая - укажите в комментариях от 1 до 3 желаемых или просто необходимых фич в будущих версиях Delphi, которые с Вашей точки зрения способствовали бы развитию всестороннему продукта. Комментарии также могут относится к продукту не напрямую (например, рекомендация "проводить больше вебинаров"). Свои соображения я оставляю первым комментарием.

Старайтесь выражать мысли кратко и лаконично. В начале осени мы подведем итоги и составим "график желаний".

Как программно завершить работу, сделать перезагрузку, перевести компьютер в ждущий режим или выйти из системы в OS X?

2013-07-05T10:52:00.000+04:00

Одним из простых путей является использование объекта Cocoa NSAppleScript для запуска следующего скрипта:

tell application "Finder" to shut down

И, конечно, ‘to shut down’ может быть заменено на ‘to restart’, ‘to sleep’ или ‘to log out’.

В последних версиях Delphi NSAppleScript (или если быть более точным - его интерфейс) объявлен в модуле Macapi.Foundation. Увы, объявлен он не совсем точно (см. здесь), поэтому его необходимо немного подправить следующим образом:

uses
  Macapi.ObjectiveC, Macapi.CocoaTypes, Macapi.Foundation;
 
type
  NSAppleScript = interface(NSObject)
    ['{0AB1D902-25CE-4F0B-A3BE-C4ABEDEB88BC}']
    function compileAndReturnError(errorInfo: Pointer): Boolean; cdecl;
    function executeAndReturnError(errorInfo: Pointer): Pointer; cdecl;
    function executeAppleEvent(event: NSAppleEventDescriptor; error: Pointer): Pointer; cdecl;
    function initWithContentsOfURL(url: NSURL; error: Pointer): Pointer; cdecl;
    function initWithSource(source: NSString): Pointer; cdecl;
    function isCompiled: Boolean; cdecl;
    function source: NSString; cdecl;
  end;

  TNSAppleScript = class(TOCGenericImport<NSAppleScriptClass, NSAppleScript>)  

end;
 
procedure TForm1.Button1Click(Sender: TObject);
var
  Script: NSAppleScript;
  Error: Pointer;
begin
  Error := nil;
  Script := TNSAppleScript.Wrap(TNSAppleScript.Alloc.initWithSource(
    NSSTR('tell application "Finder" to shut down')));
  try
    if Script.executeAndReturnError(Error) = nil then
      raise EOSError.Create('AppleScript macro failed');
  finally
    Script.release;
  end;
end;

И все работает прекрасно.

Источник: http://delphihaven.wordpress.com/2013/07/04/programmatically-shutting-down-restarting-sleeping-or-logging-off-on-os-x/

Получение информации о системе в OSX и iOS с помощью Delphi (XE2, XE3, XE4) - Часть 2

2013-07-04T17:51:00.000+04:00

Данная статья является продолжением статьи Получение информации о системе в OSX и iOS с помощью Delphi (XE2, XE3, XE4) - Часть 1.

Внутри модуля Posix.SysSysctl (являющимся, как уже было сказано, трансляцией файла sysctl.h) можно обнаружить ряд массивов (CTL_NAMES, CTL_KERN_NAMES, CTL_HW_NAMES, CTL_USER_NAMES, CTL_VM_NAMES), которые содержат идентификаторы системной информации, рассмотренные нами в предыдущей статье. Используя их, можно построить идентификатор (параметр name) для передачи в функцию SysCtlByName.

В качестве примера, составить идентификатор для получения версии ядра можно следующим образом:

Name := PAnsiChar(CTL_NAMES[CTL_KERN].ctl_name + '.' + CTL_KERN_NAMES[KERN_VERSION].ctl_name); // Версия ядра

а затем вызвать SysCtlByName:

function KernelVersion: AnsiString;
var
  res: Integer;
  len: size_t;
  p, Name: PAnsiChar;
begin
  len := SizeOf(Result);
  Name := PAnsiChar(CTL_NAMES[CTL_KERN].ctl_name + '.' + CTL_KERN_NAMES[KERN_VERSION].ctl_name);
  res := SysCtlByName(Name, nil, @len, nil, 0);
    if (len > 0) and (res = 0)  then
    begin
      GetMem(p, len);
      try
        res := SysCtlByName(Name, p, @len, nil, 0);
        if res = 0 then
          Result := p;
      finally
        FreeMem(p);
      end;
    end;
end;

Используя эти массивы, можно получить много полезной, предусмотренной в них информации, попробуйте воспроизвести следующий проект:

{$APPTYPE CONSOLE}
 
{$R *.res}
 
uses
  System.Classes,
  System.Types,
  Posix.Errno,
  Posix.SysTypes,
  Posix.SysSysctl,
  System.SysUtils;
 
function GetsysctlIntValue(mib: TIntegerDynArray) : integer;
var
  len : size_t;
  res : integer;
begin
   len := sizeof(Result);
   res:=sysctl(@mib[0], 2, @Result, @len, nil, 0);
   if res<>0 then
    Result:=-1; // RaiseLastOSError;
end;
 
function GetsysctlInt64Value(mib: TIntegerDynArray) : Int64;
var
  len : size_t;
  res : integer;
begin
   len := sizeof(Result);
   res:=sysctl(@mib[0], 2, @Result, @len, nil, 0);
   if res<>0 then
     Result:=-1; //RaiseLastOSError;
end;
 
function GetsysctlStrValue(mib: TIntegerDynArray) : AnsiString;
var
  len : size_t;
  p   : PAnsiChar;
  res : integer;
begin
   Result:='';
   res:=sysctl(@mib[0], 2, nil, @len, nil, 0);
   if (len>0) and (res=0)  then
   begin
     GetMem(p, len);
     try
       res:=sysctl(@mib[0], 2, p, @len, nil, 0);
       if res=0 then
        Result:=p;
     finally
       FreeMem(p);
     end;
   end;
end;
 
procedure  ListKernelValues;
var
  mib : TIntegerDynArray;
  i   : Integer;
begin
 Writeln('High kernel limits');
 Writeln('------------------');
 for i:=0 to KERN_MAXID-1 do
 begin
    mib:=TIntegerDynArray.Create(CTL_KERN, i);
    case CTL_KERN_NAMES[i].ctl_type of
     CTLTYPE_NODE  :  Writeln(Format('%s.%-18s %s',[CTL_NAMES[CTL_KERN].ctl_name, CTL_KERN_NAMES[i].ctl_name, '[node]']));
     CTLTYPE_OPAQUE:  Writeln(Format('%s.%-18s %s',[CTL_NAMES[CTL_KERN].ctl_name, CTL_KERN_NAMES[i].ctl_name, '[structure]']));
     CTLTYPE_INT   :  Writeln(Format('%s.%-18s %d',[CTL_NAMES[CTL_KERN].ctl_name, CTL_KERN_NAMES[i].ctl_name, GetsysctlIntValue(mib)]));
     CTLTYPE_QUAD  :  Writeln(Format('%s.%-18s %d',[CTL_NAMES[CTL_KERN].ctl_name, CTL_KERN_NAMES[i].ctl_name, GetsysctlInt64Value(mib)]));
     CTLTYPE_STRING : Writeln(Format('%s.%-18s %s',[CTL_NAMES[CTL_KERN].ctl_name, CTL_KERN_NAMES[i].ctl_name, GetsysctlStrValue(mib)]));
    end;
 end;
 Writeln;
end;
 
procedure  ListGenericCPU_IO_Values;
var
  mib : TIntegerDynArray;
  i   : Integer;
begin
 Writeln('Generic CPU, I/O');
 Writeln('-----------------');
 for i:=0 to HW_MAXID-1 do
 begin
    mib:=TIntegerDynArray.Create(CTL_HW, i);
    case CTL_HW_NAMES[i].ctl_type of
     CTLTYPE_NODE  :  Writeln(Format('%s.%-18s %s',[CTL_NAMES[CTL_HW].ctl_name, CTL_HW_NAMES[i].ctl_name, '[node]']));
     CTLTYPE_OPAQUE:  Writeln(Format('%s.%-18s %s',[CTL_NAMES[CTL_HW].ctl_name, CTL_HW_NAMES[i].ctl_name, '[structure]']));
     CTLTYPE_INT   :  Writeln(Format('%s.%-18s %d',[CTL_NAMES[CTL_HW].ctl_name, CTL_HW_NAMES[i].ctl_name, GetsysctlIntValue(mib)]));
     CTLTYPE_QUAD  :  Writeln(Format('%s.%-18s %d',[CTL_NAMES[CTL_HW].ctl_name, CTL_HW_NAMES[i].ctl_name, GetsysctlInt64Value(mib)]));
     CTLTYPE_STRING : Writeln(Format('%s.%-18s %s',[CTL_NAMES[CTL_HW].ctl_name, CTL_HW_NAMES[i].ctl_name, GetsysctlStrValue(mib)]));
    end;
 end;
 Writeln;
end;
 
procedure  ListUserLevelValues;
var
  mib : TIntegerDynArray;
  i   : Integer;
begin
 mib:=TIntegerDynArray.Create(CTL_USER, 0);
 Writeln('User-level');
 Writeln('----------');
 for i:=0 to USER_MAXID-1 do
 begin
    mib[1]:=i;
    case CTL_USER_NAMES[i].ctl_type of
     CTLTYPE_NODE  :  Writeln(Format('%s.%-18s %s',[CTL_NAMES[CTL_USER].ctl_name, CTL_USER_NAMES[i].ctl_name, '[node]']));
     CTLTYPE_OPAQUE:  Writeln(Format('%s.%-18s %s',[CTL_NAMES[CTL_USER].ctl_name, CTL_USER_NAMES[i].ctl_name, '[structure]']));
     CTLTYPE_INT   :  Writeln(Format('%s.%-18s %d',[CTL_NAMES[CTL_USER].ctl_name, CTL_USER_NAMES[i].ctl_name, GetsysctlIntValue(mib)]));
     CTLTYPE_QUAD  :  Writeln(Format('%s.%-18s %d',[CTL_NAMES[CTL_USER].ctl_name, CTL_USER_NAMES[i].ctl_name, GetsysctlInt64Value(mib)]));
     CTLTYPE_STRING : Writeln(Format('%s.%-18s %s',[CTL_NAMES[CTL_USER].ctl_name, CTL_USER_NAMES[i].ctl_name, GetsysctlStrValue(mib)]));
    end;
 end;
 Writeln;
end;
 
procedure  ListVMValues;
var
  mib : TIntegerDynArray;
  i   : Integer;
begin
 Writeln('Virtual memory');
 Writeln('-------------');
 for i:=0 to VM_MAXID-1 do
 begin
    mib:=TIntegerDynArray.Create(CTL_VM, i);
    case CTL_VM_NAMES[i].ctl_type of
     CTLTYPE_NODE  :  Writeln(Format('%s.%-18s %s',[CTL_NAMES[CTL_VM].ctl_name, CTL_VM_NAMES[i].ctl_name, '[node]']));
     CTLTYPE_OPAQUE:  Writeln(Format('%s.%-18s %s',[CTL_NAMES[CTL_VM].ctl_name, CTL_VM_NAMES[i].ctl_name, '[structure]']));
     CTLTYPE_INT   :  Writeln(Format('%s.%-18s %d',[CTL_NAMES[CTL_VM].ctl_name, CTL_VM_NAMES[i].ctl_name, GetsysctlIntValue(mib)]));
     CTLTYPE_QUAD  :  Writeln(Format('%s.%-18s %d',[CTL_NAMES[CTL_VM].ctl_name, CTL_VM_NAMES[i].ctl_name, GetsysctlInt64Value(mib)]));
     CTLTYPE_STRING : Writeln(Format('%s.%-18s %s',[CTL_NAMES[CTL_VM].ctl_name, CTL_VM_NAMES[i].ctl_name, GetsysctlStrValue(mib)]));
    end;
 end;
 Writeln;
end;
 
begin
  try
    ListKernelValues;
    ListGenericCPU_IO_Values;
    ListUserLevelValues;
    ListVMValues;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Источник: http://theroadtodelphi.wordpress.com/2013/06/29/getting-system-information-in-osx-and-ios-using-delphi-xe2-xe3-xe4-part-2/

Получение информации о системе в OSX и iOS с помощью Delphi (XE2, XE3, XE4) - Часть 1

2013-07-03T22:36:00.004+04:00

В статье будут рассмотрены вопросы использования функций модулей sysctl, sysctlbyname и sysctlnametomib для получения информации о системе (параметры ядра, железа, сети, файловой системы, информации о компьютере и пользователе) в OSX и iOS.

sysctl

int sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen);

Модуль sysctl содержит функции для получения/установки системной информации; типы данных, возвращаемые функцией sysctl - целые числа (int32, int64), строки (AnsiString) и записи (records). Данная функция объявлена в модуле Posix.SysSysctl (SysSysctlAPI.inc).

Примечание: модуль Posix.SysSysctl - частичное портирование файла sysctl.h.

function sysctl(name: PInteger; namelen: cardinal; oldp: Pointer; oldlen: Psize_t; newp: Pointer; newlen: size_t): Integer; cdecl; external libc name _PU + 'sysctl';

name: указатель на Management Information Base (MIB), который "внутри" является массивом Integer. Каждый элемент массива должен быть заполнен значениями, связанными с какими-либо данными для чтения/записи. Количество элементов массива зависит от читаемой/записываемой информации, в большинстве случаев используется 2 первых значения: первый элемент отражает позицию данных в MIB (тип информации), второй содержит значение.

Существует несколько значений первого элемента в MIB (все они прописаны в модуле Posix.SysSysctl):

Идентификатор  Значение         Описание

CTL_DEBUG      $00000005        Debugging
CTL_VFS        $00000003        File system
CTL_HW         $00000006        Generic CPU, I/O
CTL_KERN       $00000001        High kernel limits
CTL_MACHDEP    $00000007        Machine dependent
CTL_NET        $00000004        Networking
CTL_USER       $00000008        User-level
CTL_VM         $00000002        Virtual memory

Итак, если нужно получить информацию о ядре, необходимо заполнить массив следующим образом:

var
  mib : array[0..1] of Integer;
  ...
  ...
 mib[0] := CTL_KERN;

Второй элемент массива связан с первым, его возможные значения также определены в модуле Posix.SysSysctl. Так, например, для получения величины максимального количества поддерживаемых процессов необходимо использовать значение KERN_MAXPROC($00000006).

var
  mib : array[0..1] of Integer;
  ...
  ...
  mib[0] := CTL_KERN;
  mib[1] := KERN_MAXPROC;

Теперь рассмотрим остальные параметры функции sysctl.
namelen: размер записи mib.
oldp: указатель на получаемые данные типа Integer, int64, AnsiString (MarshaledAString) или записью.
oldlen: размер параметра oldp.
newp: указатель на записываемые данные. Если ничего не изменяется - необходимо передать nil.
newlen: размер параметра newp.

С учетом рассмотренного выше, приведем функцию для получения величины максимального количества поддерживаемых процессов:

function MaxProcesses : Integer;
var
  mib: array[0..1] of Integer;
  res: Integer;
  len: size_t;
begin
 
  mib[0] := CTL_KERN;
  mib[1] := KERN_MAXPROC;
 
  len := sizeof(Result);
  res := sysctl(@mib, Length(mib), @Result, @len, nil, 0);
  if res <> 0 then
   RaiseLastOSError;
end;

Получить Int64-значение можно аналогично, в качестве примера рассмотрим код для получения размера установленной памяти, использую идентификаторы CTL_HW и HW_MEMSIZE.

function MemSize : Int64;
var
  mib: array[0..1] of Integer;
  res: Integer;
  len: size_t;
begin
  mib[0] := CTL_HW;
  mib[1] := HW_MEMSIZE;
 
  len := sizeof(Result);
  res := sysctl(@mib, Length(mib), @Result, @len, nil, 0);
  if res <> 0 then
   RaiseLastOSError;
end;

Для получения строкового значения, в первую очередь необходимо передать длину предполагаемой строки для создания буфера, сделать это можно следующим образом (передав nil в качестве параметра oldp):

sysctl(@mib, Length(mib), nil, @len, nil, 0)

Следующий пример демонстрирует получения строки (ASCII), используя функцию sysctl.

function KernelVersion : AnsiString;
var
  mib: array[0..1] of Integer;
  res: Integer;
  len: size_t;
  p: MarshaledAString; // в XE2 можно использовать PAnsiChar 
begin
  mib[0] := CTL_KERN;
  mib[1] := KERN_VERSION;
  // получаем размер буфера
  res := sysctl(@mib, Length(mib), nil, @len, nil, 0);
  if res<>0 then
    RaiseLastOSError;
   
  // устанавливаем размер буфера
  GetMem(p, len);
  try
    res := sysctl(@mib, Length(mib), p, @len, nil, 0);
    if res <> 0 then
      RaiseLastOSError;
    Result := p;
  finally
    FreeMem(p);
  end;
end;

Наконец, функцию sysctl можно использовать для получения записей, передавая указатель на заранее подготовленный record.
Рассмотрим пример получения значений тактовой частоты из ядра.

procedure GetClockInfo;
type
 clockinfo = record
    hz      : Integer;
    tick    : Integer;
    tickadj : Integer;
    stathz  : Integer;
    profhz  : Integer;
  end;
 
(*
struct clockinfo {
    int hz;     
    int tick;      
    int tickadj;
    int stathz;   
    int profhz; 
};
*)
 
var
  mib: array[0..1] of Integer;
  res: Integer;
  len: size_t;
  clock: clockinfo;
begin
  FillChar(clock, sizeof(clock), 0);
  mib[0] := CTL_KERN;
  mib[1] := KERN_CLOCKRATE;
  len := sizeof(clock);
  res := sysctl(@mib, Length(mib), @clock, @len, nil, 0);
  if res <> 0 then
    RaiseLastOSError;
  
  Writeln(Format('clock frequency             %d',[clock.hz]));
  Writeln(Format('micro-seconds per hz tick   %d',[clock.tick]));
  Writeln(Format('clock skew rate for adjtime %d',[clock.tickadj]));
  Writeln(Format('statistics clock frequency  %d',[clock.stathz]));
  Writeln(Format('profiling clock frequency   %d',[clock.profhz]));
end;

sysctlbyname

int sysctlbyname(const char *name, void *oldp, size_t *oldlenp, void *newp, size_t newlen);

Функция sysctlbyname работает по тому же принципу, что и sysctl, однако получение значений осуществляется путем передачи специального строкового идентификатора. Это в свою очередь позволяет избежать передачи в функцию mib-записи и ее размера.

function sysctlbyname(Name: MarshaledAString; oldp: Pointer; oldlen: Psize_t; newp: Pointer; newlen: size_t): Integer; cdecl; external libc name _PU + 'sysctlbyname';

name: идентификатор, определяющий возвращаемое значение и состоящий из двух "уровней".
В качестве элементов "первого" уровня, могут использоваться следующие идентификаторы:

Идентификатор  Строка

CTL_DEBUG      debug
CTL_VFS        vfs
CTL_HW         hw
CTL_KERN       kern
CTL_MACHDEP    machdep
CTL_NET        net
CTL_USER       user
CTL_VM         vm

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

В качестве примера рассмотрим следующие возможные значения, которые могут использоваться в качестве идентификатора name:

Идентификатор                   Тип 
         
kern.ostype                     string      
kern.osrelease                  string      
kern.osrevision                 integer     
kern.version                    string      
kern.maxvnodes                  integer      
kern.maxproc                    integer      
kern.maxfiles                   integer      
kern.argmax                     integer     
kern.securelevel                integer      
kern.hostname                   string       
kern.hostid                     integer      
kern.clockrate                  struct      
kern.posix1version              integer     
kern.ngroups                    integer     
kern.job_control                integer     
kern.saved_ids                  integer     
kern.link_max                   integer     
kern.max_canon                  integer     
kern.max_input                  integer     
kern.name_max                   integer     
kern.path_max                   integer     
kern.pipe_buf                   integer     
kern.chown_restricted           integer     
kern.no_trunc                   integer     
kern.vdisable                   integer     
kern.boottime                   struct      
vm.loadavg                      struct      
vm.swapusage                    struct      
machdep.console_device          dev_t       
net.inet.ip.forwarding          integer      
net.inet.ip.redirect            integer      
net.inet.ip.ttl                 integer      
net.inet.icmp.maskrepl          integer     
net.inet.udp.checksum           integer      
hw.machine                      string      
hw.model                        string      
hw.ncpu                         integer     
hw.byteorder                    integer     
hw.physmem                      integer     
hw.usermem                      integer     
hw.memsize                      integer     
hw.pagesize                     integer     
user.cs_path                    string      
user.bc_base_max                integer     
user.bc_dim_max                 integer     
user.bc_scale_max               integer     
user.bc_string_max              integer     
user.coll_weights_max           integer     
user.expr_nest_max              integer     
user.line_max                   integer     
user.re_dup_max                 integer     
user.posix2_version             integer     
user.posix2_c_bind              integer     
user.posix2_c_dev               integer     
user.posix2_char_term           integer     
user.posix2_fort_dev            integer     
user.posix2_fort_run            integer     
user.posix2_localedef           integer     
user.posix2_sw_dev              integer     
user.posix2_upe                 integer

Примечание: получить полный список поддерживаемых команд можно путем ввода sysctl -A в терминале операционной системы.

Приведенный ниже код показывает, как использовать SysCtlByName для получения количества установленных процессоров.

function NumberOfCPU: Integer;
var
  res: Integer;
  len: size_t;
begin
  len := SizeOf(Result);
  res := SysCtlByName('hw.ncpu', @Result, @len, nil, 0);
  if res <> 0 then
    RaiseLastOSError;
end;

Примечание: функция sysctl выполняется примерно в 3 раза быстрее, чем sysctlbyname, поэтому, если производительность является ключевым аспектом - лучше использовать sysctl.

sysctlnametomib

int sysctlnametomib(const char *name, int *mibp, size_t *sizep);

Функция sysctlnametomib заполняет mib по строковому идентификатору. Обычно, данная функция используется в приложениях, часто работающих с одними и теми же значениями.

function sysctlnametomib(name: MarshaledAString; mibp: PInteger; sizep: Psize_t): Integer; cdecl; external libc name _PU + 'sysctlnametomib';

name: строковый идентификатор значения (см. предыдущий пункт).
mibp: указатель на mib-запись.
sizep: указатель на длину mib-записи.

var
  mib : array[0..1] of Integer;
  res : Integer;
  len : size_t;
begin
  len := Length(mib);
  sysctlnametomib('hw.physicalcpu', @mib, @len);
  // теперь mib-запись правильно заполнена и готова для передачи в функцию sysctl

Error Handling
Все указанные выше функции возвращают 0, если выполнились успешно, и код ошибки в противном случае. Такой код может быть получен через Posix.Errno или с использованием функции GetLastError.

Возможные коды ошибок могут быть найдены в файле C:\Program Files (x86)\Embarcadero\RAD Studio\{ВЕРСИЯ}\source\rtl\posix\osx\ErrnoTypes.inc (при установке IDE по умолчанию).

И наконец, итоговый пример, задействующий все положения настоящей статьи:

{$APPTYPE CONSOLE}
 
uses
  //System.Classes,
  //System.Types,
  //Posix.Errno,
  Posix.SysTypes,
  Posix.SysSysctl,
  System.SysUtils;
 
//https://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man3/sysctl.3.html
//https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man8/sysctl.8.html
 
 
function NumberOfCPU: Integer;
var
  res: Integer;
  len: size_t;
begin
  len := SizeOf(Result);
  res := SysCtlByName('hw.ncpu', @Result, @len, nil, 0);
  if res <> 0 then
    RaiseLastOSError;
end;
 
 
function MaxProcesses: Integer;
var
  mib: array[0..1] of Integer;
  res: Integer;
  len: size_t;
begin
 
 mib[0] := CTL_KERN;
 mib[1] := KERN_MAXPROC;
 
 len := sizeof(Result);
 res := sysctl(@mib, Length(mib), @Result, @len, nil, 0);
 if res <> 0 then
   RaiseLastOSError;
end;
 
function MemSize : Int64;
var
  mib: array[0..1] of Integer;
  res: Integer;
  len: size_t;
begin
 mib[0] := CTL_HW;
 mib[1] := HW_MEMSIZE;
 
 len := sizeof(Result);
 res := sysctl(@mib, Length(mib), @Result, @len, nil, 0);
 if res <> 0 then
   RaiseLastOSError;
end; 
 
function KernelVersion : AnsiString;
var
  mib: array[0..1] of Integer;
  res: Integer;
  len: size_t;
  p: MarshaledAString; // в XE2 используйте PAnsiChar
begin
  mib[0] := CTL_KERN;
  mib[1] := KERN_VERSION;
  res := sysctl(@mib, Length(mib), nil, @len, nil, 0);
  if res <> 0 then
    RaiseLastOSError;

  GetMem(p, len);
  try
    res := sysctl(@mib, Length(mib), p, @len, nil, 0);
    if res <> 0 then
      RaiseLastOSError;
    Result := p;
  finally
    FreeMem(p);
  end;
end;
 
procedure GetClockInfo;
type
  clockinfo = record
    hz      : Integer;
    tick    : Integer;
    tickadj : Integer;
    stathz  : Integer;
    profhz  : Integer;
  end;
 
var
  mib: array[0..1] of Integer;
  res: Integer;
  len: size_t;
  clock: clockinfo;
begin
  FillChar(clock, sizeof(clock), 0);
  mib[0] := CTL_KERN;
  mib[1] := KERN_CLOCKRATE;
  len := sizeof(clock);
  res := sysctl(@mib, Length(mib), @clock, @len, nil, 0);
  if res <> 0 then
    RaiseLastOSError;
 
  Writeln(Format('clock frequency             %d',[clock.hz]));
  Writeln(Format('micro-seconds per hz tick   %d',[clock.tick]));
  Writeln(Format('clock skew rate for adjtime %d',[clock.tickadj]));
  Writeln(Format('statistics clock frequency  %d',[clock.stathz]));
  Writeln(Format('profiling clock frequency   %d',[clock.profhz]));
end;
 
begin
  try
    Writeln(Format('max processes     %d',[MaxProcesses]));
    Writeln(Format('number of cpus    %d',[NumberOfCPU]));
    Writeln(Format('physical ram size %s',[FormatFloat('#,', MemSize)]));
    Writeln(Format('Kernel Version    %s',[KernelVersion]));
    GetClockInfo;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Источник: http://theroadtodelphi.wordpress.com/2013/05/31/getting-system-information-in-osx-and-ios-using-delphi-xe2-xe3-xe4-part-1/

Что происходит с...

2013-06-23T03:07:00.000+04:00

...индексом Delphi?

http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

Delphi XE4 уже рядом

2013-04-16T01:23:00.000+04:00

Открыта регистрация на презентацию продукта: http://forms.embarcadero.com/forms/AMUSCA1304RADStudioLaunchWeb4-24

Интересно, с чем связано ускорение цикла выхода новых версий?

Qt QPropertyAnimation & FireMonkey Float Animation

2013-03-03T17:00:00.003+04:00

На днях наткнулся на занимательное видео:

Данную штуку можно сделать уже в Qt 4.6 (это примерно 2009 г.). Аналогичные эффекты доступны в Firemonkey (c 2011 г.). Вопрос к знатокам: как соотносится первое со вторым и чем одно лучше/хуже другого?

Вопросы производительности в конструкторах динамических массивов

2013-02-18T15:38:00.000+04:00

В Delphi Вы можете произвести инициализацию динамического массива двумя способами: вручную или используя "магический" конструктор:

...
type
   TIntegerArray = array of Integer;

procedure Test;
var 
   a : TIntegerArray;
begin
   // "Магический" конструктор
   a := TIntegerArray.Create(1, 2);

   // Инициализация вручную
   SetLength(a, 2);
   a[0] := 1;
   a[1] := 2;
end;

На выходе получаем абсолютно идентичные массивы, но во всем ли эти способы одинаковы?

В чем же разница?
Первый способ более лаконичен, но при этом чуть менее эффективен; в этом можно убедиться, посмотрев в окно CPU:

...
// "Магический" конструктор
TestUnit.pas.32: a := TIntegerArray.Create(1, 2);
00511335 8D45F8           lea eax,[ebp-$08]
00511338 8B15F0125100     mov edx,[$005112f0]
0051133E E89576EFFF       call @DynArrayClear   // кто-нибудь знает, зачем?
00511343 6A02             push $02
00511345 8D45F8           lea eax,[ebp-$08]
00511348 B901000000       mov ecx,$00000001
0051134D 8B15F0125100     mov edx,[$005112f0]
00511353 E87476EFFF       call @DynArraySetLength
00511358 83C404           add esp,$04
0051135B 8B45F8           mov eax,[ebp-$08]
0051135E C70001000000     mov [eax],$00000001
00511364 8B45F8           mov eax,[ebp-$08]
00511367 C7400402000000   mov [eax+$04],$00000002
0051136E 8B55F8           mov edx,[ebp-$08]
00511371 8D45FC           lea eax,[ebp-$04]
00511374 8B0DF0125100     mov ecx,[$005112f0]
0051137A E89576EFFF       call @DynArrayAsg

// Инициализация вручную
TestUnit.pas.35: SetLength(a, 2);
0051137F 6A02             push $02
00511381 8D45FC           lea eax,[ebp-$04]
00511384 B901000000       mov ecx,$00000001
00511389 8B15F0125100     mov edx,[$005112f0]
0051138F E83876EFFF       call @DynArraySetLength
00511394 83C404           add esp,$04
TestUnit.pas.36: a[0] := 1;
00511397 8B45FC           mov eax,[ebp-$04]
0051139A C70001000000     mov [eax],$00000001
TestUnit.pas.37: a[1] := 2;
005113A0 8B45FC           mov eax,[ebp-$04]
005113A3 C7400402000000   mov [eax+$04],$00000002

Перед тем как обвинить во всем компилятор, Вам следует чуть глубже понять разницу в приведенных способах инициализации массивов:

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

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

Больше деталей
Использование "магического" конструктора влечет за собой следующие издержки:

вызов DynArrayClear (не понимаю, зачем он здесь), освобождающий блок памяти, выделенный ранее для временного массива;
вызов DynArraySetLength, выделяющий новый блок памяти с последующим его обнулением;
вызов DynArrayAssign, приводящий к освобождению памяти, занимаемой текущим массивом (если он не пустой), а также локу счетчика ссылок и дополнительным инициализации и финализации временного массива.

В многопоточном приложении подобные дополнительные манипуляции с памятью и локи плачевно повлияют на производительность. Если Вы потестируете наш пример в многопоточной среде, то увидите, что при использовании "магического" конструктора выполнение кода сведется к однопоточному.
При ручной инициализации мы имеем только один вызов DynArraySetLength, и если массив не пустой, это может вообще не привести к выделению нового блока памяти (т.к. просто может быть уменьшен/увеличен существующий). Поэтому, если Вы инициализируете массив не один раз, ручная инициализация обойдется Вам дешевле.

Как сделать инициализатор лучше?
Мы увидели, что "магический" конструктор не является хорошим вариантом, но что если Вы хотите воспользоваться подобным удобным способом инициализации? На помощь приходят открытые массивы:

...
procedure InitializeArray(var a: TIntegerArray; const values: array of Integer);
begin
   SetLength(a, Length(values));
   if Length(values) > 0 then
      Move(values[0], a[0], Length(values)*SizeOf(Integer));
end;
...
InitializeArray(a, [1, 2]);

Указанная функция не будет эффективнее ручной инициализации: внутри будет происходить дополнительное копирование значений элементов. Однако, она убирает дополнительное выделение памяти и установку локов, поэтому больше подойдет для многопоточных приложений, будучи при этом компактной и лаконичной.
Обратите внимание, что для всех managed-типов (строк, интерфейсов и т.д.), которые System.Move не принимает в качестве аргумента, Вам понадобится использовать либо asm-хаки, либо инициализировать массив поэлементно (например, через цикл for-to-do), что во многих случаях сделает данный вариант неконкурентоспособным относительно ручного аналога.

Хотите еще лучше?
В общем случае, все приведенные выше подходы страдают от вызова довольно сложной процедуры SetLength (взгляньте на DynArraySetLength в System.pas и убедитесь), поэтому, если есть шанс, что динамический массив не изменится в размере, Вы можете выиграть сделав так:

...
if Length(a) <> Length(value) then
   SetLength(a, Length(Values));

Что может увеличить производительность до 10 раз.
Упс! А почему RTL этого не делает, спросите Вы?

Ответ прост - не может. Динамические массивы в Delphi - это не смесь простых типов и указателей, и SetLength - то место, где непосредственно проиходит определение, с чем мы имеем дело (для доп. изучения см. {1}, {2} и {3}).
В DWScript, например, динамические массивы - ссылочные типы, имеют больше возможностей, а их инициализация более компактна:

...
a := [1, 2];

А при использовании Smart Pascal в Chrome V8 или node.js Вам все-таки придется воспользоваться рассмотренными советами по оптимизации.

http://delphitools.info/2013/02/18/delphi-array-constructors-performance-or-lack-of/

Штриховка в TChart

2013-01-17T15:42:00.000+04:00

На днях коллега поинтересовался вопросом - а можно ли в стандартном TChart сделать что-то наподобии такого:

Гугл ответа не дал, поэтому пришлось думать над решением самому :). Нашлось оно довольно быстро следующим образом:

...
unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, VCLTee.TeEngine, VCLTee.Series,
  Vcl.ExtCtrls, VCLTee.TeeProcs, VCLTee.Chart, System.Generics.Collections;

type
  THatchDirection = (hdUp, hdDown);

  TForm1 = class(TForm)
    Chart1: TChart;
    procedure FormDestroy(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Chart1AfterDraw(Sender: TObject);
    procedure FormShow(Sender: TObject);
  private
    var
      FHatchDirectionList: TList<THatchDirection>;
    procedure DrawHatch(Series: TChartSeries; HatchDirection: THatchDirection);
    procedure AddInEquation(XStart, XEnd, XStep: Double; YFunc: TFunc<Double,
        Double>; AHatchDirection: THatchDirection; AColor: TColor);
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  // Содержит список направлений штриховок, индексация FHatchDirectionList[I} = Chart1.Series[I]
  FHatchDirectionList := TList<THatchDirection>.Create;
end;

procedure TForm1.FormShow(Sender: TObject);
begin
  FHatchDirectionList.Clear;
  Chart1.ClearChart;
  Chart1.View3D := False;

  // Прямая
  AddInEquation(0, 50, 1,
                function(x: Double): Double
                begin
                  Result := x;
                end,
                THatchDirection.hdDown, clRed);

  // Еще одна
  AddInEquation(0, 50, 1,
                function(x: Double): Double
                begin
                  Result := 50 - x;
                end,
                THatchDirection.hdDown, clBlue);

  // Парабола
  AddInEquation(10, 40, 1,
                function(x: Double): Double
                begin
                  Result := 0.2 * sqr(x - 25) + 8;
                end,
                THatchDirection.hdUp, clGreen);
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  FreeAndNil(FHatchDirectionList);
end;

procedure TForm1.DrawHatch(Series: TChartSeries; HatchDirection: THatchDirection);
const
  HATCH_SIZE = 10;
var
  i, k: Integer;
  XPos, YPos: Integer;
begin
  Chart1.Canvas.Pen.Color := Series.Color;
  Chart1.Canvas.Pen.Width := Series.Pen.Width - 1;
  case HatchDirection of
    hdUp:   k := -1;
    hdDown: k := 1;
  end;

  for i := 0 to Series.XValues.Count - 1 do
  begin
    XPos := Series.CalcXPosValue(Series.XValue[i]);
    YPos := Series.CalcYPosValue(Series.YValue[i]);
    Chart1.Canvas.Line(XPos, YPos, XPos, YPos + k*HATCH_SIZE);
  end;
end;

procedure TForm1.Chart1AfterDraw(Sender: TObject);
var
  i: Integer;
begin
  for i := 0 to FHatchDirectionList.Count - 1 do
    DrawHatch(Chart1.Series[i], FHatchDirectionList[i]);
end;

procedure TForm1.AddInEquation(XStart, XEnd, XStep: Double; YFunc: TFunc<Double, Double>;
  AHatchDirection: THatchDirection; AColor: TColor);
var
  i: Double;
  SR1: TLineSeries;
begin
  SR1 := TLineSeries.Create(Chart1);
  SR1.Color := AColor;
  SR1.Pen.Width := 3;
  i := XStart;
  while i <= XEnd do
  begin
    SR1.AddXY(i, YFunc(i));
    i := i + XStep;
  end;
  Chart1.AddSeries(SR1);
  FHatchDirectionList.Add(AHatchDirection);
end;

end.

Остановлюсь на нескольких моментах (этапы реализации):

Первым делом заводим тип штриховки (THatchDirection = (hdUp, hdDown)) и список (FHatchDirectionList: TList), хранящий ее состояния для каждой серии чарта.
Далее, при добавлении серии (неравенства) - AddInEquation (стоит обратить внимание на использование анонимных методов), добавляем тип штриховки.
И, наконец, в методе Chart1.AfterDraw "дорисовываем" к графикам штриховку в нужном направлении (соль - в методе DrawHatch).

Вот результат:

Проект можно воспроизвести, лишь кинув на форму TChart и заменив код формы на приведенный.

Вышла RAD Stuido XE3!

2012-09-03T19:03:00.000+04:00

Основная страница продукта сообщает, что вышла новая версия студии - RAD Studio XE3!

Что нового:

Полный список изменений есть в вики.

Скачать триал можно тут.

Как было обещано ранее, подведем итоги опроса "Голосуем за Delphi XE3 Express!", проводившегося практически все лето - с 4 июня по 3 сентября (дату выхода новой студии).

Итоги следующие: из 493 проголовавших 471 человек - ЗА выпуск Express-редакции Delphi (!), остальные 22 - против, или 96% против 4%., из которых более 50% проголосовали за серьезную функционльность:

Думаю, никто не будет спорить, что мнение комьюнити практически едингласное. Благодарю участников опроса (особенно тех, кто оставил интересные комментарии) и надеюсь на вашу дальнейшую активность!

Письмо с просьбой и результатами голования будут отправлены David'у I - посмотрим, на официальный отклик.

RAD Studio XE3 Preview

2012-08-22T15:12:00.002+04:00

И еще. Недавно была анонсирована программа The Embarcadero MVP Program (бывшая Embarcadero Community Evangalist, насколько я понял), и от России там уже присутствуют:

Александр Алексеев
Александр Божко
Андрей Терехов
Владислав Баженов

Поздравляем!

David I, Delphi users & Former employees

2012-08-09T12:49:00.002+04:00

Интересная баталия произошла в комментариях к данному посту в блоге http://www.deltics.co.nz, в том числе, с участием David I. Пост, кстати, тоже интересный.

Кроме того, в последнее время (один из них в том же посте) проскочили и комментарии бывших сотрудников (мифических или настоящих - загадка), которые в настоящее время удалены:

О проблемах СССР конца 50-х годов

2012-07-05T13:42:00.003+04:00

По своей профессии я весьма далек от политики и экономики и являюсь чистым технарем. Более 50 лет я занимаюсь созданием принципиально новых средств вычислительной техники или, как сейчас принято говорить, развитием компьютерных технологий. Недавно меня попросили написать статью об истории создания и развития того направления вычислительной техники, которым я занимаюсь всю жизнь. В ходе работы над этой статьей, систематизируя свои воспоминания и изучая ряд исторических материалов, я неожиданно для себя обнаружил, что в советской истории существует период феноменального развития науки, техники и экономики в целом.

Начиная с середины сороковых годов создается целый ряд инновационных отраслей, таких, как атомная, ракетная, вычислительная техника, электроника, где мы, как минимум, не уступали США, а зачастую и опережали. Все остальные страны были далеко позади.

Если атомная бомбы появилась в СССР в 1949 году, через 4 года после США, то первая в мире водородная бомба РДС-6 была уже советской. Первая в мире атомная электростанция была введена в эксплуатацию в СССР летом 1954 года, на год раньше, чем в Англии, и на 2 года раньше, чем в США. Только в СССР были созданы атомные ледоколы («Ленин» - 1959 г.). Единственный в мире самолет с атомным двигателем М-50А, поднявшийся в небо в 1960 году, был создан в СССР в ОКБ В.М. Мясищева. Лишь атомные подводные лодки появились в США в 1955 году, на 3 года раньше, чем в СССР.

Достижения СССР в ракетной технике и космонавтике, начиная с первого спутника, запущенного в октябре 1957 года, общеизвестны.

Уже в 1948 году, когда в США и Англии только разрозненные коллективы занимались разработкой единичных образцов компьютеров и в мире не было еще ни одного действующего изделия, в СССР по инициативе Сталина были созданы Институт точной механики и вычислительной техники (ИТМ и ВТ) АН СССР и Специальное конструкторское бюро N245 («СКБ-245»), как было написано в постановлении Правительства: «...для разработки и внедрения в производство средств вычислительной техники для систем управления оборонными объектами». В 1951 году создается первая советская цифровая вычислительная машина МЭСМ - сразу как промышленный образец. Следует заметить, что первые промышленные компьютеры в США (UNIVAC 1) и в Англии (Ferranti Mark 1) также появились в том же 1951 году. В 1953 году начинается серийное производство машин БЭСМ, «Стрела» и М-2 (для военных применений), которые находились на уровне лучших американских компьютеров того времени и существенно превосходили компьютеры других стран.

Следует отметить, что в 50-х годах и советская электроника была на высоком уровне. Промышленное производство полупроводниковых транзисторов в США началось в марте 1958 года фирмой Fairchild Corp. при цене $150 за штуку. А информация о характеристиках отечественных «кристаллических триодов» была помещена в шестом номере популярного журнала «Радио» за 1955 год, а в 1956 году, на два года раньше, чем в США, началось промышленное производство. Осенью 1957 года я, будучи студентом третьего курса ЛЭТИ, занимался на кафедре автоматики и телемеханики практической разработкой цифровых устройств на транзисторах П-16. К этому времени транзисторы в СССР были не только общедоступны, но и дешевы (в пересчете на американские деньги менее доллара за штуку).

Еще более поразительны успехи экономики в целом несмотря на полное отсутствие внешних кредитов и минимальные объемы нефтяных денег (газовых денег тогда не было). Уже в 1947 году промышленный потенциал СССР был полностью восстановлен, а в 1950 году он вырос более чем в 2 раза по отношению к довоенному 1940 году. Ни одна из стран, пострадавших в войне, к этому времени не вышла даже на довоенный уровень несмотря на мощные финансовые вливания со стороны США. Например, Япония достигла довоенного уровня лишь в 1955 году, хотя, если не считать ядерных бомбардировок, серьезных разрушений там не было. Лимитированное распределение продуктов по карточкам было отменено в СССР в 1947 году, а в Англии, несмотря на помощь США, лишь в 1954 году. В сентябрьском номере журнала «Нейшнл бизнес» ("National Business") за 1953 г. в статье Герберта Гарриса «Русские догоняют нас» отмечалось, что СССР по темпам роста экономической мощи опережает любую страну и что в настоящее время темпы роста в СССР в 2-3 раза выше, чем в США. Годом ранее кандидат в президенты США Стивенсон оценивал положение таким образом, что если темпы роста производства в сталинской России сохранятся, то к 1970 г. объем русского производства в 3-4 раза превысит американский. Заметим, что темпы роста советской экономики в послевоенный период были намного выше, чем в довоенный.

Но начиная с середины 50-х годов, ситуация резко меняется. Снижаются темпы роста, а в ряде областей возникают настоящие провалы. Вот как сказал об этом в 1991 году японский миллиардер Хероси Теравама, обращаясь к советским экономистам: «Вы не говорите об основном, о вашей первенствующей роли в мире. В 1939 году вы, русские, были умными, а мы, японцы, дураками. В 1949 году вы стали еще умнее, а мы были пока дураками. А в 1955 году мы поумнели, а вы превратились в пятилетних детей. Вся наша экономическая система практически полностью скопирована с вашей, с той лишь разницей, что у нас капитализм, частные производители, и мы более 15% роста никогда не достигали, а вы же при общественной собственности на средства производства достигали 30% и более. Во всех наших фирмах висят ваши лозунги сталинской поры». Из приведенного высказывания можно сделать ряд выводов. В 1939 году в СССР был разработан новый метод повышения эффективности экономики (МПЭ). МПЭ использовался в большинстве отраслей народного хозяйства. МПЭ являлся эффективным как для социалистического, так и для капиталистического уклада экономики, но для социалистического уклада эффективность МПЭ была выше более, чем в 2 раза. В 1955 году Япония заимствовала МПЭ, что и обеспечило ее бурный экономический рост за счет, прежде всего, инновационных технологий («японское чудо»), а СССР в том же году отказался от МПЭ, что обусловило последующую деградацию экономики. Итак, в СССР с 1939 по 1955 год применялся волшебный метод, обеспечивший беспрецедентный взлет экономики. Об этом методе в настоящее время не известно абсолютно ничего, хотя в те времена в СССР он применялся повсеместно.

Моя трудовая деятельность началась в 1958 году, когда МПЭ уже был ликвидирован, но я хорошо помню рассказы сослуживцев, работавших в те времена, когда МПЭ действовал. МПЭ являлся совокупностью хорошо продуманных материальных и моральных стимулов для активизации творческой активности масс, направленной на снижение себестоимости и повышение качества (улучшения характеристик) разрабатываемой или уже производимой продукции. Система стимулов варьировалась в зависимости от отрасли и типа предприятия. Однако в любом варианте эти стимулы не распространялись на начальников любого ранга. Возможно, для руководящих работников была отдельная система стимулов, но мне об этом неизвестно.

Материальные стимулы в организациях, занимавшихся разработками новой техники, заключались в коллективных и индивидуальных премиях, выплачиваемых сразу после приемки разрабатываемого изделия государственной комиссией (буквально в тот же день), если в акте комиссии отмечалось улучшение характеристик изделия по отношению к техническому заданию. Для каждой характеристики, включая время разработки изделия и стоимость разработки, имелась определенная премиальная шкала, известная разработчикам еще до начала проектирования. Например, за каждый сэкономленный килограмм веса изделия в ОКБ-590, где мне пришлось работать, выплачивалось 500 рублей (половина месячного оклада инженера). Эту премию получали все члены коллектива, участвующего в проекте, в одинаковом размере независимо от должности. Существовали и индивидуальные премии, необходимым условием выплаты которых являлось наличие рационализаторских предложений или заявок на изобретение, благодаря которым и стало возможным улучшение характеристик изделия. За каждую новацию авторам выплачивалась дополнительная сумма, кратная вознаграждению, полученному каждым членом коллектива, что не отменяло и обычных вознаграждений за экономический эффект, полученный от внедрения изобретения или рационализаторского предложения. Руководитель проекта, как правило, не занимавший административной должности, также получал дополнительную премию. Моральные стимулы заключались в том, что лица, обеспечившие коллективу получение таких премий, ускоренно продвигались по службе и в основном из их числа назначались руководители проектов. Одновременно применялись и обычные квартальные и годовые премии. Необходимо отметить и хороший моральный климат в научно-технических коллективах. К людям, способным к творческой работе, коллеги относились бережно, стараясь освободить их от рутинной работы без всяких указаний начальства, так как успехи одного распространялись на всех. Иными словами, человек человеку был другом. Здесь разработчики метода учли печальный опыт стахановского движения, когда успех одного больно бил по карману и статусу других и в коллективе начинался разлад.

При относительно небольших затратах эффективность МПЭ была исключительно высока во всех отраслях народного хозяйства. Даже в армии во время войны существовала жесткая шкала денежных выплат и наград за личное уничтожение техники или живой силы противника, а также нанесение иного урона (например, взятие в плен офицеров противника, обладающих важной информацией). В оборонной промышленности в годы войны одновременно с напряженной производственной деятельностью велась непрерывная работа по совершенствованию технологических процессов. Так, за 4 военных года себестоимость производства большинства образцов вооружений (самолеты, танки и т.д.) была снижена в 2-3 раза. Даже винтовка Мосина, разработанная еще в XIX веке, подешевела в 1,6 раза. МПЭ позволял в максимальной степени использовать творческую активность рядовых исполнителей и выявлять яркие таланты. МПЭ применялся и в сельском хозяйстве на уровне совхозов и МТС (машинно-тракторных станций). Об этом говорит известный факт, что М.С. Горбачев получил в семнадцатилетнем возрасте орден за уборку урожая.

Главной особенностью МПЭ являлось то, что при его использовании не только повышалась творческая активность большого числа людей и выявлялись таланты, но также изменялась психология всех членов коллектива, а также взаимоотношения в коллективе. Любой член коллектива осознавал свою значимость для общего процесса и с готовностью выполнял любую часть работы, даже в том случае, если эта работа не соответствовала его статусу. Взаимная доброжелательность, стремление оказать помощь друг другу были совершенно типичными чертами. По сути, каждый член коллектива считал себя личностью, а не винтиком сложного механизма. Изменялись и взаимоотношения начальников с подчиненными. Вместо приказов и указаний начальник стремился разъяснить каждому подчиненному, какую роль в общем деле играет та работа, которая ему поручается. По мере становления коллективов и формирования новой психологии сами материальные стимулы отходили на задний план и уже не являлись главной движущей силой. Полагаю, что разработчики МПЭ рассчитывали именно на такой эффект.

Все вышеизложенное я знаю не по рассказам очевидцев, а по личным впечатлениям. Хотя я пришел в ОКБ-590 в 1958 году, через 3 года после отмены МПЭ, но психология - вещь инерционная, и она сохранялась длительное время даже при отсутствии внешних стимулов. Первые три года я работал в лаборатории цифровых систем, где начал свою деятельность с нижней ступеньки - настройщика узлов бортовой цифровой вычислительной машины. Эта специальность считалась рабочей, и настройщики (два человека) работали на сдельной оплате, получая значительно больше инженеров, в то время как я работал на фиксированном окладе техника. Мое появление неизбежно приводило к финансовым потерям двух других настройщиков, поскольку число узлов было ограничено лишь опытными образцами, после изготовления которых настройщики занимались лишь ремонтом при существенно меньшей оплате. Тем не менее меня приняли очень тепло и в течение месяца знакомили с тонкостями процесса настройки. Отношение ко мне не изменилось и через пару месяцев, когда я стал настраивать в несколько раз больше узлов, чем мои коллеги, и впоследствии, когда закончилась массовая настройка узлов. То есть для обычных рабочих парней общее дело коллектива лаборатории (создание опытных образцов БЦВМ) было важнее их личных финансовых интересов.

Работа в качестве настройщика продолжалась недолго. Уже через несколько месяцев меня стали привлекать к инженерной работе, причем не только в качестве помощника. Характерной чертой лаборатории было полное отсутствие субординации. Все друг к другу обращались по именам, в том числе и к начальнику лаборатории. Этому способствовала и небольшая разница в возрасте сотрудников лаборатории, самому старшему из которых было менее 35 лет. Начальник лаборатории или руководитель группы не просто выдавали задание, а стремились донести до каждого члена коллектива цели этого задания и его роль для решения общей задачи. Рабочий день продолжался с 9 утра до 10-11 вечера, причем на чисто добровольной основе и без какой-либо дополнительной оплаты. Зато никто не контролировал время прихода и ухода сотрудников, что для режимных предприятий было совершенно нетипично.

В мае 1961 года меня перевели в лабораторию аналоговых систем и назначили руководителем важнейшего для организации (да и для страны) проекта. Эта лаборатория функционировала с момента основания организации в 1945 году. Поэтому сотрудники здесь были старше по возрасту. Но атмосфера была такая же. Лишь к начальнику лаборатории все обращались по имени и отчеству, но не из-за его должности, а из-за возраста и опыта. Он провел всю войну на фронте, и прямо из армии его откомандировали в только что образованное ОКБ. Из всего коллектива только я знал, что и как надо делать, поскольку являлся единственным специалистом в области цифровой техники. И ведущие инженеры с 10-15-летним стажем без какого либо внутреннего сопротивления выполняли роль подсобных рабочих, поскольку понимали, что это необходимо для дела. Снова напомню, что к этому времени никаких стимулов уже не было. И третье подразделение нашего конструкторского бюро, с которым мне приходилось тесно взаимодействовать, работало в таком же стиле.

Еще одна деталь. За все время работы в ОКБ-590 (в январе 1963 года оно было ликвидировано, а все сотрудники вместе с тематикой переведены в ОКБ-680, впоследствии НПО "Электроавтоматика") я ни разу не слышал слово "партия". Комната месткома была, а парткома не было. Только в 1963 году в новой организации я узнал, что в лаборатории было довольно много членов партии, и меня сразу же попытались сагитировать на вступление, но я уклонился. Иначе мне не удалось бы в 1964 году покинуть эту организацию. Кстати, начальник ОКБ-590 В.И. Ланердин был беспартийным. Говорили, что на пост начальника ОКБ Ланердина назначил лично Сталин, а до этого во время войны он работал в США, отвечая за поставки в СССР авиационной техники по ленд-лизу. К моменту назначения ему было не более 35 лет.

Люди старшего поколения помнят фильм М. Ромма "9 дней одного года", где была хорошо показана творческая атмосфера у физиков-ядерщиков. Могу определенно утверждать, что у нас в ОКБ-590 была такая же атмосфера. Правда, в новой организации эта атмосфера мгновенно исчезла, хотя люди остались те же самые. Сразу был введен жесткий режим. За пятиминутное опоздание лишали премии, а для того, чтобы отлучиться во время рабочего дня, надо было получать разрешение заместителя начальника по режиму. В итоге после 6 вечера никого в организации не оставалось. Более того, было запрещено оставаться работать по окончании рабочего дня. Правда, большую часть времени в 1963-1964 годах я и основная часть коллектива проводили в командировках, сначала в Москве на опытном заводе (где мне издалека приходилось видеть Сергея Хрущева), а затем в Смоленске на серийном заводе.

Об экономическом эффекте творческой атмосферы свидетельствует следующее. Мой первый проект вычислительного устройства для управления пусковыми ракетными установками для системы ПРО А-35 был выполнен за 2 года, если считать от момента получения технического задания до комплексных испытаний опытных образцов в реальных условиях. Аналогичный по сложности проект суперкомпьютера ЕС-2704 при вдвое большем по численности коллективе и том же руководителе выполнялся уже 6 лет (1982-1988). И еще один пример. При создании советского стратегического бомбардировщика Ту-4 в качестве образца был взят американский бомбардировщик Б-29. Работа по изучению доставленного в Москву Б-29 началась в июле 1945 года. Менее чем через год, в марте 1946-го, техническая документация была передана на серийный завод. В мае 1947 года состоялся первый полет. А с начала 1949 года бомбардировщик был принят на вооружение. В послесталинский период от начала разработки самолета до его серийного производства проходило 8-12 лет. Ну а сейчас и того больше.

Почему МПЭ эффективно использовался в СССР и Японии, а больше никто его перенимать не стал? Как было отмечено ранее, главным фактором МПЭ была причастность к общему делу, полезному для страны и общества в целом. При частной собственности этот фактор отсутствует, ибо главная польза идет хозяину. Япония же страна весьма специфичная. До конца двадцатого века для многих японцев фирма отождествлялась с семьей и потому польза для фирмы то же самое, что для семьи. По мере распространения западных ценностей в Японии этот менталитет стал утрачиваться, и эффективность МПЭ стала падать. И сейчас для экономики Японии характерна стагнация, хотя вряд ли кто-либо отменял МПЭ. По этим же причинам МПЭ невозможно возродить в современной России, где и государственные предприятия работают на частного хозяина (в данном случае свору чиновников).

В середине 50-х годов МПЭ был тихо и незаметно отменен. Премии при завершении проектов сохранились и даже увеличились, но потеряли всякую стимулирующую роль. Теперь величина премии зависела от должностного оклада и от субъективного мнения руководства и не зависела от качества изделия и его экономических параметров. Из технического задания исчезли требования по себестоимости продукции и стоимости разработки. Объем премии был фиксирован на уровне 2% от стоимости разработки. В результате стало выгодно не снижать, а, наоборот, повышать как стоимость разработки, так и себестоимость проектируемого изделия. На заводах из плановых заданий исчезло ранее обязательное требование к снижению себестоимости продукции, что сразу привело к прекращению любых работ по совершенствованию технологических процессов. В это же время устанавливаются верхние ограничения на величину сдельной оплаты труда, на размер вознаграждения за рационализаторские предложения и изобретения. Изменился и моральный климат в коллективах. Теперь зарплата однозначно определялась окладом и не зависела от качества работы как коллективной, так и индивидуальной. Возросла роль субъективных факторов при должностных повышениях, что приводило к зависти и склокам. Иными словами, человек человеку стал чужим, а иногда и врагом.

Отмена МПЭ больнее всего ударила по преподавателям технических вузов. Зарплата преподавателя состояла из двух частей - оклад преподавателя и оплата научной работы. Преподавательскую деятельность оплачивал вуз из своих бюджетных средств, а оплата научной деятельности шла за счет хоздоговорных НИР. Оклады преподавателей оставались неизменными с довоенных времен вплоть до 1991 года (с учетом десятикратной деноминации денег 1961 года). За научную работу после отмены МПЭ преподаватель получал половину ставки младшего или старшего научного сотрудника, меньше половины основного оклада. В годы же действия МПЭ научная составляющая зарплаты могла в разы превышать основной оклад при условии эффективного выполнения НИР. Известно, что зарплата некоторых профессоров достигала 20 тысяч рублей при основном окладе 4 тысячи. Недаром народная молва относила профессоров к самым богатым людям в СССР. Но и доценты были ненамного беднее, поскольку научная составляющая зарплаты не зависела от основного оклада. Хотя в гуманитарных вузах, скорее всего, преподаватели получали лишь основной оклад.

Итак, легкое незаметное воздействие привело к остановке главного двигателя советской экономики. Какое-то время движение продолжалось по инерции, затем началась деградация, и в конце 80-х годов экономика разрушилась окончательно. Учитывая глобальный характер применения МПЭ, отменить его мог только руководитель СССР, которым с 1953 года был Н.С. Хрущев. В настоящее время известно, что все без исключения действия Хрущева в области экономики имели крайне негативные последствия. Однако принято считать, что Хрущев действовал из благих побуждений («хотел как лучше, а получалось как всегда»), но терпел неудачи в силу слабого образования и импульсивного характера. Но ликвидация МПЭ была проведена очень точно, грамотно и, главное, незаметно для окружающих, включая, скорее всего, остальных руководителей страны. Здесь благих побуждений нельзя увидеть даже в микроскоп. Есть основания считать, что и другие действия Хрущева были столь же глубоко продуманы и имели единую цель, в том числе и знаменитый доклад на двадцатом съезде партии. Здесь уместно привести высказывание Молотова о Хрущеве, сделанное им в 80-е годы: «Хрущёв, он же сапожник в вопросах теории, он же противник марксизма-ленинизма, это же враг коммунистической революции, скрытый и хитрый, очень завуалированный».

http://worldcrisis.ru/crisis/993685

Голосуем за Delphi XE3 Express!

2012-06-04T22:50:00.000+04:00

Уважаемые читатели блога и ленты Delphifeeds.ru!

Прошу вас поучаствовать в голосовании, которое находится на любой странице данного блога в верхнем левом углу или в данном сообщении. Голосование продлится до 1 сентября (примерного выхода следующей версии Delphi).
Опрос создается с целью определить, нужна ли бесплатная редакция нашей любимой среды и языка разработки, в каком бы виде Вы ее хотели видеть и возможного взаимодействия с Embarcadero на предмет результатов голосования :)

В комментариях просьба написать развернутое мнение - причину голосования.

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

Нужна ли "Express"-версия Delphi XE3?

Экономические мотивы национализма (Л. Пайдиев)

2012-05-19T00:30:00.000+04:00

Национализм возник, не в последнюю очередь, по экономическим причинам — как инструмент получения преимуществ в конкурентной борьбе. Утверждение о том, что Нация и Буржуазия связаны между собой, стало общим местом. Но в чём именно их взаимосвязь и какие экономические выгоды приносит национализм обществу — об этом стоит сказать подробнее.

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

На войне всегда, в конце концов, выигрывают «Большие Батальоны». Задача любого вождя обеспечить себе большие и сплочённые батальоны и посеять смуту в чужих рядах. Тот, у кого есть миллиард, всегда раздавит того, у кого есть миллион, просто по закону больших чисел.

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

Третье
Капиталист ориентируется при принятии решений о развитии производства на показатели, измеряемые процентами от нормы прибыли. Но для общества цена его решения может быть несопоставимо выше. С уходом производства из данной страны или данного города теряются и налоги, и зарплата рабочих, и прибыль других капиталистов, обесценивается недвижимость. Значит, нужны институты, которые включат «сопутствующие» интересы общества в систему калькуляции собственных интересов капиталиста.

Четвертое
Бизнес невозможен без справедливого суда. Но за определённым уровнем экономических интересов справедливость суда испаряется для чужих. В Нигерии при нескольких тысячах долларах, в США при многомиллионных интересах Американского Народа. Счастье, если у тебя есть паспорт гражданина страны со справедливым судом. Это неубиенное конкурентное преимущество.

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

Почему? Хотя бы потому, что мировая торговля идёт по морям. Значит, нужны авианосцы. Враждебные страны надо плотно переформатировать или уничтожать со всем населением. Если врага не уничтожать до последнего человека, а менять, нужны и сухопутные войска. А это всё национальное государство.

Кому выгодна националистическая политика?
В национальном государстве царит Закон. Люмпенов нет. Ребёнок после школы спокойно приходит домой, девушка спокойно гуляет вечером. В процветающую страну едут туристы. Индустрия туризма выигрывает самой первой. Но главными выигравшими являются элиты данной страны. Опираясь на своё государство, как на мощный тыл, они могут претендовать на высокие места в мировой элите.

Наиболее зрим и осязаем выигрыш тех, кто делает деньги на недвижимости и сфере услуг. Вообще, все живущие с ренты, все, кто продаёт услуги здесь (домовладельцы, железнодорожники, газетчики, книгоиздатели, рестораторы), жизненно заинтересованы в существовании национального государства. Но больше всего заинтересованы местные финансисты. У них есть своя резервная валюта. Возможность создавать деньги из воздуха в кризисные моменты является решающим конкурентным преимуществом в страховом и инвестиционном бизнесе. В постиндустриальной экономике не производитель и не собственник капитала получает выгоды от глобализации, но тот, кто может мобилизовать капиталы для проектов того и другого, и застраховать их риски. Участие в инвестиционном и страховом бизнесе целиком и полностью зависит от близости к эмиссионному центру в периоды кризисов. Именно поэтому, каждый раз поднимаясь, Германия починяла себе Центробанк, и каждый раз после поражения у неё его отнимали. Именно это стратегическое преимущество демонстрирует экономика США последние годы.

Повседневная жизнь элиты становится более комфортной и безопасной. Одно дело, когда по делам ты спокойно вышел из дома и сам повёл машину по чистому городу, поел в кафе, где побеседовал с нужными людьми. Всё сделал сам. Как Сорос в Швейцарии. И другое дело — ехать с толпой охранников по грязному неуютному городу, застревая в пробках в компрадорском государстве. Всюду чужие и враждебные глаза. Поэтому элита так любит Лондон или Цюрих. Там они всегда могут вести частную жизнь. Хотя это города, где они всегда будут чужими.

Цена национального государства
Национальное государство, по определению, стоит дорого.

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

2. Государство эффективно защищает своих производителей на внешних и внутренних рынках. Это требует сильной армии и военно-морского флота (международная торговля идёт по морям), сильной разведки.

3. Для защиты внутреннего рынка нужна сильная и эффективная таможня. Унификация тарифов не допустима. Поскольку таможенные войны сегодня недопустимы, то надо прибегать к нетарифным методам. Это санитарный надзор, патентное право, провокации и т.п.

4. Квалифицированная рабочая сила. Человек как животное очень ленив. Бомж — это самое естественное и сладостное состояние человека на протяжении миллионов лет его истории (недавно бомжи, жившие в теплоцентрали, начали охотиться на людей и пожирать их). Воспитание человека «рисовой цивилизации» потребовало пары тысячелетий и управляемого естественного отбора. Воспитание техника и квалифицированного рабочего, тем более инженера, потребовало создания огромных дорогостоящих систем. Вне их человек вначале превращается в человека военной демократии (чечена), а потом в собирателя (бомжа).

5. Система социальной защиты. Свой человек, «брат во Христе» не должен помирать под забором.

6. Хорошее образование. Талантливый юноша должен получить образование. Тем более, что из «золотой молодёжи» работники получаются плохие, причём даже в вузах, имеющих многовековой опыт воспитания элитных лоботрясов.

Но всё это всё означает, что налоги в такой стране высоки! Очень высоки! Шведы и датчане — рекордсмены по налогам. Проповедь низких налогов в современном мире есть злонамеренная ложь. Это может обещать или лжец, или невежда. Или глава государства, которое может грабить соседей.

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

В национальном государстве царит нетерпимость к коррупции — как к разновидности предательства, измены Народу. Вместе с тем, проблема коррупции и забюрократизрованности служит наиболее распространенным возражением против принципов национального государства. Но коррупция далеко не так непобедима, как это у нас принято считать. И лучшее подтверждение тому — опыт состоявшихся национальных государств, которыми выработаны достаточно эффективные технические приемы. Назовем лишь самые простые и очевидные из них:

1. Соответствие официальных доходов реальным расходам. Если расходы не соответствуют официально декларируемым доходам — тюрьма. Причём расходы считаются по специальным методикам («если купил дорогую машину, значит, ел икру, а не «одной я корочкой питался»…). Цель этого механизма — не должно появляться никаких богачей ниоткуда. И в случае сомнений — тюрьма. Этого уже достаточно для того, чтобы резко ограничить коррупцию.

2. Независимая система регистрации преступлений, и поощрение людей, от премии до продвижения по службе, в соответствии с коэффициентом раскрываемости. Причём оба эти принципа реализуются одновременно. Был даже соответствующий Указ Президента Ельцина, который давал поручение Министерству внутренних дел разработать необходимую систему и который благополучно замотали в ведомстве Рушайло, а Контрольное управление Президента внимания на это не обратило.

Итак, институты национального государства сложно устроены и дорого стоят. Но отказавшиеся платить эту цену заплатят куда дороже. Только нации смогли создать богатые и процветающие государства, общества.

Или ты борешься за высокооплачиваемые рабочие места, или за рабочие места голодных негров. По мере развития экономики конкуренция на рынке низкоквалифицированного труда возрастает.

Если в России будет создано национальное государство — мы будем бороться за высокооплачиваемые рабочие места в сфере международных финансов. Если нет — за кусок хлеба с неграми: «Полдюжины кузнечиков и горсточка риса за 12-часовой рабочий день». Середины не будет.

Почему многим не нравится национальное государство?
Мне могут задать вопрос: если национализм столь выгоден в экономике, то почему же национальное государство не стало повсеместно господствующей формой общественного устройства?

Отвечу: именно поэтому. Эффективное государство начинает бороться за самые высокооплачиваемые рабочие места. И его бьют конкуренты. В том числе и применяя прямое насилие.

У национального государства есть могучий внешний враг — международный финансовый капитал. У международного финансового капитала быстро находится и союзник внутри. Этого внутреннего врага принято называть компрадорской буржуазией. Обычно это экспортёры сырья.

Здесь к месту вспомнить о рикардианском парадоксе. Математическому уму Рикардо принадлежит блестящее и безупречное доказательство преимущества свободной торговли. Известно, что в разных странах существуют разные пропорции между затратами на производство различных товаров. Допустим, затраты на производство компьютера в США эквивалентны затратам на производство 1 тонны нефти, а в России затратам на производство 3 тонн нефти. Тогда бросив все силы на нефтедобычу, Россия заработает втрое больше, чем бросив на производство компьютеров.

Таким образом, для экономики из двух товаров и двух стран каждой стране оказывается выгодней специализироваться на том товаре, относительные затраты на производство которого меньше относительных затрат на производство аналога в другой. При этом обе получают прибыль от внешнеторгового обмена. США при тех же затратах получат больше нефти, а Россия — больше компьютеров.

Для большего числа товаров и стран эта схема обобщается и усложняется, но неизменным остается главное открытие Рикардо: специализация позволяет каждой стране в условиях свободной торговли получать максимум того, что она может заработать при сложившейся экономической ситуации. Протекционизм же нарушает эти пропорции и страны получают меньше, чем могли бы. Следовательно, свобода торговли — главное условие получения максимальной прибыли каждой страной. Непонятно, с чем же здесь можно спорить?

И все же следует обратить внимание на одно обстоятельство. Рикардо доказывает, что свобода торговли выгодна всем при сложившихся экономических условиях. А условия эти таковы, что в Англии XIX в. технологический уровень промышленного производства выше, чем допустим в Германии или Франции. Этим последним оказывается выгодным специализироваться на производстве зерна и уничтожить свою промышленность. Продавая зерно, они получат в обмен на него из Англии больше промышленных продуктов, чем могут произвести сами. Прямая выгода.

Фридрих Лист первый внес в экономическую науку идею, что любое экономическое решение должно рассматриваться не только с точки зрения сегодняшней эффективности, но и с точки зрения его длительных и косвенных последствий. Позже Маршалл назовет эти косвенные последствия extemal economies. Но прямая выгода сегодня оборачивается консервацией отсталости и проигрышем завтра. Германия и Франция отставали во времена Листа от Англии лет на двадцать. В условиях свободы торговли они отстали бы навсегда.

Итак, свобода торговли консервирует сложившееся положение вещей — индустриальное лидерство одних и отсталость других. Цель же Листа заключается в том, чтобы вывести Германию из отсталости. А значит он — противник свободы торговли. Идеи Листа универсальны для всех стран догоняющего развития. Для этих стран неприменимы кажущиеся очевидными теоретические схемы лидеров мировой экономики. Для догоняющего развития нужна система специальных мер, одной из которых неизбежно оказывается протекционизм.

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

Стране выгодно, чтобы сырьё перерабатывалось внутри ее границ по всей технологической цепочке до высших форм. Тогда масса вновь созданной стоимости в стране будет больше, будет расти национальное богатство. Лес кругляк — до бумаги, газ — до этилена и пластмасс, руда до металла и машин. Но отдельному производителю сырья это не очень выгодно: страна, Нация будет платить ему всегда меньше, чем мировой рынок. К газовику приходит финансист Сити: «Из одного кубометра газа Я, Великий финансист, могу сделать гораздо больше продукции, денег, чем твоя Нация, ибо наша экономика эффективней на всех этапах его переработки использования. Поэтому я всегда заплачу за него больше, чем твоя Нация. Зачем тебе эти голодранцы? Кто они такие? Нация жалких генетических отбросов Человечества. Этих денег хватит тебе и на благотворительность, чтобы откупиться от твоего бога и твоей совести».

И компрадор продаёт свой Народ за замок под Лондоном и счета в банках Сити. Потом начинается похмелье. Добыча и экспорт сырья становится всё менее выгодным. Ибо его экспорт дотировала вся страна, разработавшая месторождения, построившая инфраструктуры. Теперь она этого не может. И экспорт уже идёт за деньги компрадора, на последнем издыхании. В Китае обычным у компрадора был дворец с каменным фасадом и стенами из досок. Он выглядел свирепым грабителем в глазах народа, а реально ему оставляли крохи. Эта история повторяется и в России. Драма разворачивается буквально в эти дни у нас на глазах.

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

В целом, без всей системы институтов национального государства, идеологией которых является братство нации, завоевание места под солнцем рынка невозможно. «Мы один народ на единой земле» — вот универсальная формула победы. «Мы — вместе. А враги — пусть убивают друг друга сами». Мощная идеология и богатая культура создают нацию. Под обаяние национальной культуры попадают огромные массы людей. Самые разные племена и национальности стремятся влиться в нацию. И тогда большая страна и национальное единство миллионов становятся реальными.

У России и русских всё это было. Наши силы подорваны, мы на грани вылета в небытие, но шанс ещё есть. Мы ещё можем собрать 200-миллионный народ.

--
http://www.apn.ru/publications/article17450.htm

Новые фишки в CnPack IDE-Мастере

2012-02-27T16:20:00.000+04:00

Недавно я рассказывал про редактор ImageList, и снова наступающие изменения в CnPack IDE-Мастере.

1. Добавилась настройка "Разделитель между процедурами и функциями":

Выглядит это следующим образом:

2. Добавились 2 команды - переход к следующему и предыдущему идентификатору в коде:

С ними все понятно и так.

Ждем новых фишек!

Hydra 4

2012-02-12T20:50:00.002+04:00

Очень интересная вещь, если кто не видел, рекомендую посмотреть:
http://www.remobjects.com/tv/hydra.aspx

RemObjects Hydra Overview

Introducing RemObjects Hydra 4

Mixing VCL & FireMonkey with RemObjects Hydra

Кроссплатформленная разработка: EXE + DLL

2011-10-20T00:08:00.000+04:00

Конвертируем проект: VCL->FireMonkey

2011-10-20T00:06:00.002+04:00

Идите в избирком и получите паспорт! (М. Делягин)

2011-10-07T15:33:00.000+04:00

Нелегитимность предстоящих нам в ближайшем будущем процедур назначения депутатов Госдумы, а затем – премьера Путина президентом России (разумеется, «при соблюдении высочайших демократических стандартов избирательных процедур»), как представляется, обусловлена, по меньшей мере, четырьмя причинами, каждой из которых было бы уже вполне достаточно.

Первая, и самая очевидная – гомерический масштаб фальсификаций, выявленный, насколько можно судить, в ходе многочисленных скандалов прошлых лет: от прямых показаний наблюдателей до результатов математического анализа голосов. Стоит вспомнить «казус Ингушетии», голоса которой были отданы «Единой России», хотя большинство избирателей затем написали заявления, что вовсе не ходили на выборы, и «казус Митрохина» (когда оказалось, что на участке, где голосовал он с женой, «Яблоку» не было отдано ни одного голоса вообще).

Вторая причина нелегитимности предстоящих выборов – вопиюще неравный, по мнению автора, доступ к агитационным возможностям: от «паровозов» в списках «Е..ной России» (!) до запугивания бизнесменов, финансирующих неугодных.

Третья – недопущение на выборы всех новых политических сил (вероятно, заподозренных в нелояльности к Администрации президента). Последней новой партией была «Родина» образца 2003 года (ставшая основой «Справедливой России» – «Правое дело» наследует даже не СПС, а еще гайдаровскому «Демвыбору»).

Российские политические партии мало меняются и несут свои «родимые пятна» на протяжении всей истории; поэтому допущенный на выборы политический спектр отражает реальность, дай Бог, начала 2000-х годов. Социально-политическая же структура общества меняется значительно быстрее, в результате чего огромная часть современных избирателей a prioriлишена даже возможности политического представительства: им просто не за кого голосовать.

Наконец, последнюю причину нелегитимности предстоящих выборов публично доказал в конце лета не кто-нибудь, а член Центризбиркома (от КПРФ), продемонстрировав, что голосование с использованием электронных урн позволяет точно установить, за кого голосовал тот или иной гражданин, что, строго говоря, представляется прямым нарушением тайны голосования, а с ней – и Конституции РФ.

Изложенное вполне очевидно основной части общества: понимание того, что так называемые «выборы» представляют собой не вполне пристойный спектакль, распространяется все более широко и захватывает даже прежде лояльные к власти социальные группы.

Сегодня мыслящую Россию объединяет один вопрос – что делать, чтобы продемонстрировать свое отношение к высочайшему безобразию?

Совет «наблюдай внимательно!» уже давно разоблачил себя как официальная пропаганда и напоминает издевательство, как и совет защищать свои политические права в суде.

Наиболее популярен ответ Навального «голосуй за меньшее зло»: за кого угодно, кроме «Партии жуликов и воров» (тм).

Другой рецепт стар, как мир: испорти бюллетень или забери его с собой.

Однако они слабы. Забрать выданный бюллетень с собой может и не получиться – строго говоря, это неправовое действие. Матерное ругательство, которое Вы напишете на бюллетене, не прочитает никто, кроме Вашей учительницы литературы, оказавшейся в избирательной комиссии. А проголосовав за кого бы ни было, Вы не поможете им (насколько можно судить, Ваш голос с легкостью перебросят «кому надо»), но лишь подтвердите своим приходом легитимность «выборов» и сделаете половину дела за фальсификаторов, обеспечив им явку.

Конечно, хороших ответов в таких ситуациях не бывает, но бывают более разумные.

Прежде всего, задача фальсификаторов выборов складывается из двух частей: обеспечение явки и «правильное» распределение голосов.

Хотя бы из простого человеческого злорадства не стоит делать за этих людей даже часть их работы: не стоит ходить на эти «голосуйки», прикидывающиеся выборами. Тем более что самим фактом прихода на них Вы – повторюсь – признаете их легитимность и свое согласие с ними.

Посмотрите официозные телеканалы: эти люди заботятся о Вас? Защищают Вас? И Вы – скорее всего – их на самом деле не выбирали даже в кошмарном сне.

Но «протест на диване» за пределами теплого круга персонажей «Нашей Раши», конечно, приемлем далеко не для всех.

Официальное исключение себя из списков избирателей, предложенное Лимоновым, не только слишком хлопотно и демонстративно: оно не проработано юридически. Законом оно предусмотрено, а вот инструкции для технического сотрудника избиркома, как это делать, нет. В результате Вы можете добиться своего (потратив массу сил и времени) в Москве, Питере и, может быть, Нижнем Новгороде, но в большинстве регионов России Вам этого сделать не удастся – просто технически. Кстати, даже в Москве попытка С. Удальцова вычеркнуть себя из списка «избирателей» довела его до суда, который отклонил его требование. И судью можно понять: как это – вычеркивать себя из списка, по сути дела, рабов? Какой же это раб, если он может самоисключиться?

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

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

Если Вы придете в избирком и объясните, что во время выборов будете в командировке или в гостях у друзей, и попросите выдать Вам открепительный талон – Вам невозможно будет отказать. Это рутинная бюрократическая процедура, отработанная до мелочей.

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

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

И справка об этом – открепительный талон с гербовой печатью – останется у Вас как паспорт подлинного, честного и ответственного перед своим народом и своей страной гражданина России. (Возможно, потом какие-то институты гражданской активности будут даже давать преимущества обладателю такого талона – своего рода «ветерану демократии».)

Кстати, вечером в день голосования полезно будет зайти на избирательный участок минут за 30 до его закрытия и проверить, не поставлена ли против Вашей фамилии подпись, свидетельствующая о том, что вы проголосовали. Если она есть – это доказательство фальсификации, можно писать заявление, настаивать на возбуждении уголовного дела против председателя комиссии и ее членов и отмене выборов на данном участке. Ничего этого, конечно, не будет, но панику Вы устроите, особенно, если таких, как Вы, будет несколько.

Если же у Вас совсем много сил и времени – не поленитесь, снимите видеорегистратором двери в избирательный участок в течение всего времени голосования. Если запись покажет, что в двери вошло (и вышло) семьсот человек, а «Е..ная Россия» получит на этом участке тысячу голосов — это будет еще одно убедительное и потому полезное доказательство фальсификации выборов.

Если же Вы симпатизируете какому-нибудь политику (такое бывает), то чем голосовать за него, напишите ему теплое личное письмо: голос, скорее всего, будет украден (или приписан), а письмо дойдет. Политикам редко приходится получать от обычных людей искренние слова одобрения, их ремесло жесткое и холодное, и они нуждаются в таких словах — а голоса на «голосуйках» они, насколько можно судить, получают не от Вас.

http://delyagin.ru/articles/19603.html