一定の周期でグループ化されている連番から、グループ番号と枝番を算出する方法。
┌──────────────────────────────────────┐
│                        Y座標                                               │
│      ┌─┬─┬─┬─┐                                                    │
│      │ 1│ 2│ 3│ 4│    1                                               │
│      ├─┼─┼─┼─┤                                                    │
│      │ 5│ 6│ 7│ 8│    2                                               │
│      └─┴─┴─┴─┘                                                    │
│ X座標   1   2   3   4                                                      │
└──────────────────────────────────────┘
例えば、上記の場合「7」は「2-3」(Y-X)みたいな感じに変換する方法。

単純に以下のようにやってしまうと、剰余がない場合にずれてしまう。
┌──────────────────────────────────────┐
│グループ番号 = (値 / グループ単位) + 1;  …商(端数切捨)                     │
│        枝番 = 値 % グループ単位;        …剰余                             │
└──────────────────────────────────────┘
上記の例でいえば、「8」は「2-0」ではなく「3-0」になってしまう。

よって、以下のように「-1」して0オリジンにしてから計算しなければならない。
┌──────────────────────────────────────┐
│                        商                                                  │
│      ┌─┬─┬─┬─┐                                                    │
│      │ 0│ 1│ 2│ 3│ 0                                                  │
│      ├─┼─┼─┼─┤                                                    │
│      │ 4│ 5│ 6│ 7│ 1                                                  │
│      └─┴─┴─┴─┘                                                    │
│  剰余   0   1   2   3                                                      │
└──────────────────────────────────────┘
つまり、以下のような感じになる。
┌──────────────────────────────────────┐
│グループ番号 = ((値 - 1) / グループ単位) + 1;  …商(端数切捨)               │
│        枝番 = ((値 - 1) % グループ単位) + 1;  …剰余                       │
└──────────────────────────────────────┘
注意が必要だ。

前回までCOUNT関数系の複数条件を扱ったが、SUM関数系の場合はどうするか？

すばり、地道にCASE文でやってしまう方法となりそうだ。
┌──────────────────────────────────────┐
│SELECT SUM(列)                                  AS `全ての集計`,            │
│       SUM(CASE WHEN 列 > 0 THEN 列 ELSE 0 END) AS `正数の集計`,            │
│       SUM(CASE WHEN 列 = 0 THEN 列 ELSE 0 END) AS `ゼロの集計`,            │
│       SUM(CASE WHEN 列 < 0 THEN 列 ELSE 0 END) AS `負数の集計`             │
│    FROM 表;                                                                │
└──────────────────────────────────────┘
もちろん条件は他の列とかを絡めたりしていろいろと対応できる。

前回の方法をSUM関数を使って行うこともできる。
┌──────────────────────────────────────┐
│SELECT SUM(TRUE)           AS `全ての件数(NULLを含む)`,                     │
│       SUM(列 IS NOT NULL) AS `全ての件数(NULLを除く)`,                     │
│       SUM(列 > 0)         AS `正数の集計`,                                 │
│       SUM(列 = 0)         AS `ゼロの集計`,                                 │
│       SUM(列 < 0)         AS `負数の集計`                                  │
│    FROM 表;                                                                │
└──────────────────────────────────────┘
これは「TRUE」が「1」、「FALSE」が「0」と換算されることを利用している。
(ちなみに「NULL」は「NULL」のままだが集計から除外されるのでほぼ「0」扱い)
  ・SELECT SUM(TRUE);              → 1
  ・SELECT SUM(FALSE);             → 0
  ・SELECT SUM(NULL);              → NULL
  ・SELECT COALESCE(SUM(NULL), 0); → 0

データが1件もない場合については、
こちらは(上記列全てが)「NULL」となってしまうので
念のため「COALESCE(,0)」で「0」変換の補正を付けてあげた方がより無難かも。
┌──────────────────────────────────────┐
│SELECT COALESCE(SUM(TRUE)          , 0) AS `全ての件数(NULLを含む)`,        │
│       COALESCE(SUM(列 IS NOT NULL), 0) AS `全ての件数(NULLを除く)`,        │
│       COALESCE(SUM(列 > 0)        , 0) AS `正数の集計`,                    │
│       COALESCE(SUM(列 = 0)        , 0) AS `ゼロの集計`,                    │
│       COALESCE(SUM(列 < 0)        , 0) AS `負数の集計`                     │
│    FROM 表;                                                                │
└──────────────────────────────────────┘
但し、データが1件以上あれば、条件に一致しなくても「0」となる。
＃正数が1件だけあっても、それで負数の集計ではFALSE(=0)が1件と換算されるので
  負数の集計が(0となり)NULLになることはない。

┌──────────────────────────────────────┐
│SELECT COUNT(*) FROM 表 WHERE 列 > 0;                                       │
│SELECT COUNT(*) FROM 表 WHERE 列 = 0;                                       │
│SELECT COUNT(*) FROM 表 WHERE 列 < 0;                                       │
└──────────────────────────────────────┘
上記を同時に行う方法。

┌──────────────────────────────────────┐
│SELECT COUNT(*)              AS `全ての件数(NULLを含む)`,                   │
│       COUNT(列)             AS `全ての件数(NULLを除く)`,                   │
│       COUNT(列 > 0 OR NULL) AS `正数の件数`,                               │
│       COUNT(列 = 0 OR NULL) AS `ゼロの件数`,                               │
│       COUNT(列 < 0 OR NULL) AS `負数の件数`                                │
│    FROM 表;                                                                │
└──────────────────────────────────────┘

COUNT関数はNULL以外の件数を数えるのだが、
これと以下の論理和条件(●)を駆使して、FALSEをNULLに置換させることにより
条件に一致するものだけをNULL以外としてカウントするという仕組みだ。
  ・(TRUE  AND TRUE ) → TRUE     ・(TRUE  OR  TRUE ) → TRUE
  ・(TRUE  AND FALSE) → FALSE    ・(TRUE  OR  FALSE) → TRUE
  ・(TRUE  AND NULL ) → NULL     ●(TRUE  OR  NULL ) → TRUE
  ・(FALSE AND FALSE) → FALSE    ・(FALSE OR  FALSE) → FALSE
  ・(FALSE AND NULL ) → FALSE    ●(FALSE OR  NULL ) → NULL
  ・(NULL  AND NULL ) → NULL     ・(NULL  OR  NULL ) → NULL

半角に変換して変化があるかで判定する。
┌──────────────────────────────────────┐
│If 値 = StrConv(値, vbNarrow) Then                                          │
│    MsgBox "半角のみ"                                                       │
│Else                                                                        │
│    MsgBox "全角を含む"                                                     │
│End If                                                                      │
└──────────────────────────────────────┘

ちなみにその逆で、半角を含むかの判定は以下のようになる。
┌──────────────────────────────────────┐
│If 値 = StrConv(値, vbWide) Then                                            │
│    MsgBox "全角のみ"                                                       │
│Else                                                                        │
│    MsgBox "半角を含む"                                                     │
│End If                                                                      │
└──────────────────────────────────────┘

配列の実体の場合
┌──────────────────────────────────────┐
│型   配列[添字];                                                            │
├──────────────────────────────────────┤
│memset(配列, 0, sizeof(配列));                                              │
│memset(配列, 0, sizeof(配列[0]) * 添字);                                    │
│memset(配列, 0, sizeof(型) * 添字);                                         │
│memset(配列, 0, 配列のサイズ);                                              │
├──────────────────────────────────────┤
│memcpy(コピー先の配列, 配列, sizeof(コピー先の配列));                       │
│memcpy(コピー先の配列, 配列, sizeof(配列[0]) * 添字);                       │
│memcpy(コピー先の配列, 配列, sizeof(型) * 添字);                            │
│memcpy(コピー先の配列, 配列, コピー先の配列のサイズ);                       │
│──────────────────────────────────────│
│memcpy(コピー先の配列のポインタ, 配列, sizeof(型) * 添字);                  │
│memcpy(コピー先の配列のポインタ, 配列, コピー先の配列のサイズ);             │
└──────────────────────────────────────┘

配列のポインタの場合
┌──────────────────────────────────────┐
│型*  配列のポインタ = 配列;                                                 │
├──────────────────────────────────────┤
│memset(配列のポインタ, 0, sizeof(型) * 添字);                               │
│memset(配列, 0, 配列のサイズ);                                              │
├──────────────────────────────────────┤
│memcpy(コピー先の配列のポインタ, 配列, sizeof(型) * 添字);                  │
│memcpy(コピー先の配列のポインタ, 配列, コピー先の配列のサイズ);             │
│──────────────────────────────────────│
│memcpy(コピー先の配列のポインタ, 配列のポインタ, sizeof(型) * 添字);        │
│memcpy(コピー先の配列のポインタ, 配列のポインタ, コピー先の配列のサイズ);   │
└──────────────────────────────────────┘

半角カタカナにどのようなものがあるかは、
シフトJISの半角カナの文字コード定義を参考にすればよいだろう。
                                           (カナは全角で記載してある) 
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
│  │_0│_1│_2│_3│_4│_5│_6│_7│_8│_9│_A│_B│_C│_D│_E│_F│
├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
│A_│  │。│「│」│、│・│ヲ│ァ│ィ│ゥ│ェ│ォ│ャ│ュ│ョ│ッ│
├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
│B_│ー│ア│イ│ウ│エ│オ│カ│キ│ク│ケ│コ│サ│シ│ス│セ│ソ│
├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
│C_│タ│チ│ツ│テ│ト│ナ│ニ│ヌ│ネ│ノ│ハ│ヒ│フ│ヘ│ホ│マ│
├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
│D_│ミ│ム│メ│モ│ヤ│ユ│ヨ│ラ│リ│ル│レ│ロ│ワ│ン│゛│゜│
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
『。「」、・ー゛゜』あたりが半角カナ記号といったところか。

シェル内で「cd」コマンドでカレントディレクトリを移動するように記述しても
実行した結果、実行時のままのディレクトリにいるということがある。

ということで、こういう場合でも移動できるようにする方法。
┌──────────────────────────────────────┐
│. ./シェル.sh                                                               │
└──────────────────────────────────────┘
先頭に「.」をつけるとよい。

但し、これは非推奨らしくいわば裏技のようだ。

「int」型と「unsigned int」型を比較する場合に、
キャストする必要があった場合、どちらをキャストすべきか？

  (1) 「(unsigned int)int_value ==      unsigned_int_value」
  (2) 「              int_value == (int)unsigned_int_value」

  (1) 「-1」が「65535(4294967295)」とみなされる
  (2) 「65535(4294967295)」が「-1」とみなされる

どちらかというと(1)の方が(2)よりも頻度が高いだろう。
ということで、30000にも満たないループインデックスとかを
「unsigned int」型(「size_t」など)と比較する場面があった場合には
(1)より(2)の方、つまり「int」型で比較した方がよいということになる。

但し、上記は如何なる場合にも通用する訳ではないので(30000を超える場合など)
注意のこと。

構造体(普通の型でもよいが)の配列数を縛りたい場合がある。

構造体の一部としての構造体であれば、こんな感じでできる。
┌──────────────────────────────────────┐
│typedef struct {                                                            │
│    構造体  変数[配列数];                                                   │
│} 配列型;                                                                   │
└──────────────────────────────────────┘

では、上記のように項目が一つしかない場合はもっとシンプルに書けないか？
このように書くらしい。
┌──────────────────────────────────────┐
│typedef 構造体 配列型[配列数];                                              │
└──────────────────────────────────────┘

ポインタ関数配列の定義といい、なんだかわかりません。
(たぶん理にはかなってるんだろうなぁ)