Mercury13

УРОВЕНЬ 1. ПРОГРАММНОЕ РИСОВАНИЕ. В экстремальном случае — программист сам рисует элементы управления, как на Canvas’е. Его опустим. Так, например, поступают в разработке игр, когда элементов мало, и они должны быть предельно стилизованы. Но и в таком случае лучше делать библиотеку объектов.

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

УРОВЕНЬ 2. ОБЪЕКТНАЯ БИБЛИОТЕКА. Часто ОС и/или система программирования имеют свою библиотеку элементов управления. В таком случае получается что-то типа.

program HomeMadeForm;

uses
  Vcl.Forms, Vcl.StdCtrls;

{$R *.res}

var
  fm : TForm;
  bt : TButton;

begin
  Application.Initialize;
  Application.MainFormOnTaskbar := True;

  fm := TForm.Create(nil);
  fm.Width := 400;
  fm.Height := 200;
  fm.Caption := 'Test';

  bt := TButton.Create(fm);
  bt.Parent := fm;
  bt.Caption := 'Go!';
  bt.Left := 150;
  bt.Top := 80;

  fm.ShowModal;
  fm.Free;
end.

УРОВЕНЬ 3. ВИЗУАЛЬНОЕ РИСОВАНИЕ. Наконец, существуют механизмы рисования форм: Qt Widgets, Qt Quick, VCL, WxWidgets, Windows Forms… В таком случае программист просто рисует форму, а про механизмы конструирования-позиционирования не думает. Создал форму, на неё поставил кнопку, к кнопке приделал событие OnClick — и вот уже при нажатии кнопки вызывается событие.


Существуют и HTML-подобные механизмы. Например, элементы HTML есть в Apache Cordova, обеих разновидностях Qt. Используют их, потому как удобно, но механизмы разбора HTML довольно сложны и потому не везде есть.

start "32-bit" cmd /c 2.bat

Тут есть два модификатора.

1. extern "C" — говорит, что функцию НЕ надо «козявить» на манер Си++, кодируя в имени её параметры наподобие h(int) → _Z1hi. Используется для доступа из Си++ к функциям, которые скомпилированы другим компилятором (Паскалем, Си…), а также для всяких там функций, которым надо дать фиксированное имя — например, функций DLL.

2. __declspec(dllimport). Это нужно для доступа к функциям DLL: линкер будет брать функции прямо из DLL, без создания *.lib или *.a (как минимум MinGW так работает). Языки, сильно привязанные к определённой ОС (например, Delphi) могут создавать свои ключевые слова для доступа, например, к DLL или COM.

procedure DoSomething(x : integer); cdecl;  external 'something.dll';

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

void* используется как указатель на сырые байтовые данные, не имеющие конкретного типа.
Обычно это используется…
1. В чтении-записи в файлы и на устройства, когда мы можем писать туда абсолютно любые типы.
2. В «многоликих» функциях, которые могут принимать данные разных типов (malloc/calloc, часть функций WinAPI и ODBC).
3. Как дескриптор — указатель, который запрещается разыменовывать. В Си для этого также часто используют указатель на недоопределённый тип, в Паскале с другими правилами эквивалентности типов — на пустой record. Но только пока не появится очередная многоликая функция вроде CloseHandle.
4. Для обеспечения т.н. замыкания — передачи callback’у контекста, откуда была вызвана функция, вызвавшая callback.

BOOL WINAPI EnumWindows(
  _In_ WNDENUMPROC lpEnumFunc,
  _In_ LPARAM      lParam
);

BOOL CALLBACK EnumWindowsProc(
  _In_ HWND   hwnd,
  _In_ LPARAM lParam
);

Вот этот LPARAM, который обычно определяется как какой-то указатель, и есть замыкание. Функция EnumWindows обещает передать его в функцию lpEnumFunc без изменений.
(В Си++ для этого также используют виртуальные интерфейсы, но такой метод, сами понимаете, языкозависим и не годится для межъязыкового API.)

Что происходит на стороне функции? Одно из двух (считаем, функция написана на ЯВУ).
1. Либо вызывается некая функция устройства, которая говорит: «записать 100 байт», и дальше уже работает железо.
2. Либо мы преобразуем void* в нужный нам тип и работаем с ним.

Типы указателям дают по трём причинам.
1. Вы забыли про операцию «разыменовать указатель». Чтобы его разыменовать, он должен иметь тип!
2. Чтобы не ошибаться и не переприсвоить несовместимые указатели.
3. Для полиморфизма — в Си++, давая delete x, мы даже можем не хранить, сколько байтов в блоке, поскольку мы знаем длину типа. (Есть ещё и виртуальные классы, но это другой вопрос.)

На x86 оба они — макроопределения для нестандартного соглашения вызова __stdcall.
На ARM они ничего не делают.

Соглашение вызова — это…
• как на уровне регистров мы вызываем функцию;
• кто подчищает стек за вызывающим;
• кто отвечает за восстановление регистров, если они менялись (или есть риск, что они менялись).

stdcall — вызов через стек, справа налево, за очистку стека отвечает функция, результат в eax (rax), функция отвечает за восстановление сегментных регистров, esp и ebp, программа за остальные.

На ARM используется соглашение cdecl. То же самое, но за очистку стека отвечает программа (что там на ARM с регистрами, я не в курсе).

Это так называемая асимптотическая сложность — сложность при n→∞.

Что никто не упомянул — так называемые символы Ландау.
a(n) = o(b(n)), (читается «о малое», «меньшего порядка чем»), если lim{n→∞}a/b = 0
a(n) = O(b(n)), (читается «о большое», «не большего порядка чем»), если a/b ограничено сверху (для дискретного n этого хватит, для непрерывного надо добавить «для какого-то n>N»).

Два символа Дональда Кнута дополняют символы Ландау.
a(n) = Ω(b(n)), если b(n) = O(a(n)). «Не меньшего порядка чем»
a(n) = Θ(b(n)), если a(n) = O(b(n)) и b(n) = O(a(n)). «Такого же порядка».

Ну а дальше идут простые пределы.
• axⁿ + bxⁿ⁻¹ + … = O(cx^k + dx^k−1 + …), если n ≤ k;
• те же два многочлена o(·), если n < k.
• те же два многочлена Θ(·), если n = k.
Константа не важна: во-первых, при n→∞ меньшая сложность рано или поздно перевесит меньшую константу. Во-вторых, особенности реализации того или иного алгоритма на том или ином компиляторе/железе (больше/меньше команд, лучше/хуже с кэшем) эту константу могут варьировать в широких пределах;

А значит, многочлен n(n−1)/2 = n²/2 − n/2 = Θ(n²).

Да, и ещё: вы спутали асимптотический порядок самогó многочлена и асимптотическую сложность его вычисления. Первое, как я уже сказал, n². Сложность вычисления в лоб — n+const = O(n). А «не в лоб» — «за константу» , O(1).

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

Так вот, для интерфейсов таких конструкторов, разумеется, не нужно.

Например, между абстрактным потоком и файлом Win32 может быть такая иерархия: Stream → HandleStream → File. Stream — интерфейс, даже если там есть что-то типа

// virtual
unsigned long long Stream::remainder() const { return size() - pos(); }

HandleStream содержит уже данные (дескриптор Win32), и это уже частично реализованный класс, который крутится вокруг этого дескриптора: в деструкторе вызов CloseHandle, конструктор может принимать дескриптор, полученный каким-то «левым» образом.

HandleStream::HandleStream(HANDLE aHandle) : fHandle(aHandle) {}
HandleStream::~HandleStream() { close(); }

void HandleStream::close()
{
  if (Handle != INVALID_HANDLE)  { // не помню, как там эта константа в Win32
    CloseHandle(fHandle);
    fHandle = INVALID_HANDLE;
  }
}

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

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

R² — это так называемый коэффициент детерминации. Как он работает?
Изначальная дисперсия переменной y будет D1.
Наладили модель — дисперсия модели D2, которая, надо полагать, меньше D1 (особенно если вся выборка обучающая, без экзаменационной; здравствуй, переобучение!).
Тогда R² = 1 − D2/D1 = (D1 − D2) / D1.

Дисперсия, как известно, измеряется в квадратных попугаях. И, кроме того, для независимых величин D(x+y) = Dx+Dy. Таким образом, √(D1 − D2) ~ √R² — это тот разброс, который мы объяснили моделью.

Но он, по-видимому, натягивает сову на глобус. В его модели объяснённый разброс — 0,780 (ещё и округлять не умеет), необъяснённый — √D2 ~ √(1 − R²) = 0,626, и в зависимости от того, что хочешь доказать, можно манипулировать статистикой в ту или иную сторону. Вот так я могу сказать, что с такими разбросами всего на 0,780 / (0,780+0,626) = 55% умение, и на 45% — удача. Так что нет, коэффициент детерминации, и точка. Повторяю, для независимых величин один разброс частично компенсируется другим, и D(x+y) = Dx+Dy. В квадратных попугаях.

Первое. То есть в какую сторону смотрит объектив и как он повёрнут вокруг оси.
Второе (указатель на центр камеры) — это вектор c.