ベクトルの内積 (Inner product)

公式

C言語での実装

#include <stdio.h>

/* ---------------------------------------------
  ベクトルの内積を求める
  引数1: vec1 ベクトル1
  引数2: vec2 ベクトル2
  引数3: n ベクトルの要素数
  戻り値 ベクトルの内積
 ---------------------------------------------*/
double inner_product(double *vec1, double *vec2, int n) {
    int i;
    double s = 0.0;

    for ( i = 0; i < n; i++ ) {
        s += vec1[i] * vec2[i];
    }

    return s;
}

/* main */
int main(void)
{
    double a[] = {1.0, 2.0, 3.0};
    double b[] = {2.0, 3.0, 4.0};
    int n = 3;

    /* ベクトルの内積を求める */
    printf("内積: %.2f\n", inner_product(a, b, n));

    return 0;
}

実行例

内積: 20.00

ベクトルの長さ

公式

C言語での実装

#include <stdio.h>
#include <math.h>

/* ---------------------------------------------
  ベクトルの長さを求める
  引数1: vec ベクトル
  引数4: n ベクトルの要素数
  戻り値 vecの長さ
 ---------------------------------------------*/
double norm(double *vec, int n)
{
    int i;
    double s = 0.0;

    for ( i = 0; i < n; i++ ) {
        s += vec[i] * vec[i];
    }

    return sqrt(s);
}

/* main */
int main(void)
{
    double vec[] = {1.0, 2.0, 3.0};
    int n = 3;

    /* ベクトルの長さを求める */
    printf("ベクトルの長さ: %f\n", norm(vec, n));

    return 0;
}

実行例

ベクトルの長さ: 3.741657

ベクトルの差

公式

C言語での実装

#include <stdio.h>

/* ---------------------------------------------
  ベクトルの和を計算する
  引数1: vec1 ベクトル1
  引数2: vec2 ベクトル2
  引数3: sum ベクトルの和
  引数4: n ベクトルの要素数
  戻り値 sumの先頭アドレス
 ---------------------------------------------*/
double *diff_vector(double *vec1,
        double *vec2, double *diff, int n)
{
    while (n--)
        diff[n] = vec1[n] - vec2[n];
    return diff;
}

/* main */
int main(void)
{
    double vec1[] = {1.0, 2.0, 3.0};
    double vec2[] = {2.0, 4.0, 1.0};
    double diff[3];
    int i, n = 3;

    /* ベクトルの差を計算 */
    diff_vector(vec1, vec2, diff, n);

    for ( i = 0; i < n; i++ ) {
        printf("diff[%d] = %.2f\n", i, diff[i]);
    }

    return 0;
}

実行例

diff[0] = -1.00
diff[1] = -2.00
diff[2] = 2.00

ベクトルの和

公式

C言語での実装

#include <stdio.h>

/* ---------------------------------------------
  ベクトルの和を計算する
  引数1: vec1 ベクトル1
  引数2: vec2 ベクトル2
  引数3: sum ベクトルの和
  引数4: n ベクトルの要素数
  戻り値 sumの先頭アドレス
 ---------------------------------------------*/
double *sum_vector(double *vec1,
        double *vec2, double *sum, int n)
{
    while (n--)
        sum[n] = vec1[n] + vec2[n];
    return sum;
}

/* main */
int main(void)
{
    double vec1[] = {1.0, 2.0, 3.0};
    double vec2[] = {2.0, 4.0, 1.0};
    double sum[3];
    int i, n = 3;

    /* ベクトルの和を計算 */
    sum_vector(vec1, vec2, sum, n);

    for ( i = 0; i < n; i++ ) {
        printf("sum[%d] = %.2f\n", i, sum[i]);
    }

    return 0;
}

実行例

sum[0] = 3.00
sum[1] = 6.00
sum[2] = 4.00

三角形の重心(Triangle’s center of gravity)

公式

A(x1, y1)，B(x2, y2),C(x3, y3)のとき△ABCの重心Gの座標は

C言語での実装

#include <stdio.h>
#include <math.h>

/* ---------------------------------------------
   3点A,B,Cからなる三角形の重心を求める (2次元)
   引数1: A 点の座標1
   引数2: B 点の座標2
   引数3: C 点の座標3
   引数5: G 重心
   戻り値: 重心の先頭アドレス
 ---------------------------------------------*/
double *triangle_center_of_gravity(double A[2],
        double B[2], double C[2], double G[2])
{
    G[0] = (A[0] + B[0] + C[0]) / 3.0;
    G[1] = (A[1] + B[1] + C[1]) / 3.0;
    return G;
}

/* main */
int main(void)
{
    double A[] = {0.0, 1.0};
    double B[] = {-1.0, 0.0};
    double C[] = {1.0, 0.0};
    double G[2];

    triangle_center_of_gravity(A, B, C, G);
    printf("3点A,B,Cからなる三角形の重心G(%.2f, %.2f)\n",
        G[0], G[1]);

    return 0;
}

実行例

3点A,B,Cからなる三角形の重心G(0.00, 0.33)

外分点(externally dividing point)

公式

2点 P(x1, y1)，Q(x2, y2)について、線分PQをm:nに外分する点Rは

C言語での実装

#include <stdio.h>
#include <math.h>

/* ---------------------------------------------
   2点p1,p2からなる線分をm:nに外分する点を求める (2次元)
   引数1: P 点の座標1
   引数2: Q 点の座標2
   引数3: m m:nのm
   引数4: n m:nのn
   引数5: result 外分点
   戻り値: 1 正常終了，0 異常終了
 ---------------------------------------------*/
int divide_externally_2D(double P[2],
        double Q[2], int m, int n, double R[2])
{
    if (m - n == 0) return 0;

    R[0] = (-n * P[0] + m * Q[0]) / (m - n);
    R[1] = (-n * P[1] + m * Q[1]) / (m - n);

    return 1;
}

/* main */
int main(void)
{
    double P[] = {1.0, 3.0};
    double Q[] = {2.0, 4.0};
    double R[2];
    int m = 2;
    int n = 3;

    divide_externally_2D(P, Q, m, n, R);
    printf("線分PQを%d:%dに外分する点R(%.2f, %.2f)\n", 
        m, n, R[0], R[1]);

    return 0;
}

実行例

2点P,Qからなる線分を2:3に外分する点R(-1.00, 1.00)

内分点 (internally dividing point)

公式

2点 P(x1, y1)，Q(x2, y2)について、線分PQをm:nに内分する点Rは

C言語での実装

#include <stdio.h>
#include <math.h>
/* ---------------------------------------------
   2点P,Qからなる線分をm:nに内分する点を求める (2次元)
   引数1: P 点の座標1
   引数2: Q 点の座標2
   引数3: m m:nのm
   引数4: n m:nのn
   引数5: result 内分点
   戻り値: 1 正常終了，0 異常終了
 ---------------------------------------------*/
int divide_internally_2D(double P[2], 
        double Q[2], int m, int n, double R[2])
{
    if (m < 1 && n < 1) return 0;

    R[0] = (n * P[0] + m * Q[0]) / (m + n);
    R[1] = (n * P[1] + m * Q[1]) / (m + n);

    return 1;
}

/* main */
int main(void)
{
    double P[] = {1.0, 3.0};
    double Q[] = {2.0, 4.0};
    double R[2];
    int m = 2;
    int n = 3;

    divide_internally_2D(P, Q, m, n, R);
    printf("線分PQを%d:%dに内分する点R(%.2f, %.2f)\n", 
        m, n, R[0], R[1]);

    return 0;
}

実行例

線分PQをを2:3に内分する点R(1.40, 3.40)

2点間の距離 (Euclidean distance)

公式

2点 P(x1, y1)，Q(x2, y2)のとき

C言語での実装

#include <stdio.h>
#include <math.h>

/* ---------------------------------------------
  2点間の距離を求める
  引数1: p1 点の座標1
  引数2: p2 点の座標2
  引数3: n 次元数
  戻り値 p1とp2間の距離
 ---------------------------------------------*/
double distance(double *p1, double *p2, int n)
{
    int i;
    double distance = 0.0;

    for (i = 0; i < n; i++) {
        distance += (p2[i] - p1[i]) * (p2[i] - p1[i]);
    }
    return sqrt(distance);
}

/* main */
int main(void)
{
    double p1[] = {1.0, 2.0, 3.0};
    double p2[] = {1.0, 2.0, 4.0};
    double d;

    d = distance(p1, p2, 3);
    printf("2点間の距離:%f\n", d);

    return 0;
}

実行例

2点間の距離:1.000000

共分散 (covariance)

公式

C言語での実装

式(3) を実装。ゼロ除算を防ぐために、nが0(0以下)の場合は0を返すようにする。

#include <stdio.h>
#include <math.h>

/* ---------------------------------------------
  共分散を計算する
  引数1: x データ1
  引数2: y データ2
  引数3: n xとyの要素数
  戻り値 共分散
 ---------------------------------------------*/
double covariance(double *x, double *y, int n)
{
    int i;
    double sum_x = 0.0, sum_y = 0.0;
    double avg_x, avg_y;
    double sumprod = 0.0;

    if ( n < 1 ) return 0.0;

    for (i = 0; i < n; i++) {
        sum_x += x[i]; /* xの和 */
        sum_y += y[i]; /* yの和 */
        sumprod += x[i] * y[i];
    }

    avg_x = sum_x / (double)n; /* xの平均 */
    avg_y = sum_y / (double)n; /* yの平均 */
    return sumprod / (double)n - avg_x * avg_y; /* 共分散 */
}


/* main */
int main(void)
{
    double x[] = {1.0, 2.0, 3.0};
    double y[] = {1.0, 2.0, 3.0};
    double cov;

    cov = covariance(x, y, 3);
    printf("共分散:%f\n", cov);

    return 0;
}

実行例

共分散:0.666667

不偏分散 (unbiased variance)

公式

C言語での実装

式(2) を実装。ほぼ分散と同じ。 ゼロ除算を防ぐために、nが2未満の場合は0を返すようにする。

#include <stdio.h>
#include <math.h>

/* ---------------------------------------------
  不偏分散を計算する
  引数1: a データ
  引数2: n aの要素数
  戻り値 不偏分散
 ---------------------------------------------*/
double unbiased_variance(double *a, int n)
{
    int i;
    double sum = 0.0;
    double sqsum = 0.0;
    double avg;

    if ( n < 2 ) return 0.0;

    for (i = 0; i < n; i++) {
        sum += a[i]; /* 和 */
        sqsum += a[i] * a[i]; /* 平方和 */
    }

    avg = sum / (double)n; /* 平均 */
    return sqsum / (double)(n - 1) - avg * avg; /* 不偏分散 */
}

/* main */
int main(void)
{
    double numbers[] = {1.0, 2.0, 3.0};
    double u;

    u = unbiased_variance(numbers, 3);
    printf("不偏分散:%f\n", u);

    return 0;
}

実行例

不偏分散:0.3000000

組み合わせ (combination)

公式

異なるn個のものから異なるr個のものを選ぶ組み合わせの数は

今回は式(2)を実装。階乗 (factoral) で実装したfactorial関数を利用する。

C言語での実装

#include <stdio.h>

/* ---------------------------------------------
  階乗を計算する
  引数1: n 整数
  戻り値 階乗
 ---------------------------------------------*/
int factorial(int n)
{
    int fact = n;

    if (n <= 0) return 1;

    while (--n)
        fact *= n;

    return fact;
}

/* ---------------------------------------------
  組み合わせの総数を計算する
  引数1: n nCrのn
  引数2: r nCrのr
  戻り値 組み合わせの総数
 ---------------------------------------------*/
int combination(int n, int r)
{
    if (r <= 0) return 1;
    return factorial(n) / (factorial(r) * factorial(n - r));
}

/* main */
int main(void)
{
    int n = 5;
    int r = 3;
    int c;

    c = combination(n, r);
    printf("%dC%d = %d\n", n, r, c);

    return 0;
}

実行例

5C3 = 10

順列 (permutation)

公式

異なるn個のものからr個とって1列に並べる順列の数は

今回は式(2)を実装。階乗 (factoral) で実装したfactorial関数を利用する。

C言語での実装

#include <stdio.h>

/* ---------------------------------------------
  階乗を計算する
  引数1: n 整数
  戻り値 階乗
 ---------------------------------------------*/
int factorial(int n)
{
    int fact = n;

    if (n <= 0) return 1;

    while (--n)
        fact *= n;

    return fact;
}


/* ---------------------------------------------
  順列組み合わせの総数を計算する
  引数1: n nPrのn
  引数2: r nPrのr
  戻り値 順列組み合わせの総数
 ---------------------------------------------*/
int permutation(int n, int r)
{
    if (r <= 0) return 1;
    return factorial(n) / factorial(n - r);
}

/* main */
int main(void)
{
    int n = 5;
    int r = 3;
    int p;

    p = permutation(n, r);
    printf("%dP%d = %d\n", n, r, p);

    return 0;
}

実行例

5P3 = 60