GeometricOptimization

GeometricOptimization[f,cons,vars]

正の多項式制約 cons に従って正の多項目的関数を最小化する変数 vars の正の値を求める．

GeometricOptimization[{a₀,b₀},{{a₁,b₁},…},{a_eq,b_eq}]

不等式制約と線形等式制約に従ってを最小化する正のベクトル x=^yを求める．

GeometricOptimization[…,"prop"]

解のどの特性"prop"を返すべきかを指定する．

GeometricOptimization

GeometricOptimization[f,cons,vars]

正の多項式制約 cons に従って正の多項目的関数を最小化する変数 vars の正の値を求める．

GeometricOptimization[{a₀,b₀},{{a₁,b₁},…},{a_eq,b_eq}]

不等式制約と線形等式制約に従ってを最小化する正のベクトル x=^yを求める．

GeometricOptimization[…,"prop"]

解のどの特性"prop"を返すべきかを指定する．

詳細とオプション

幾何学的最適化は幾何計画法(GP)および混合整数幾何計画法(MIGP)としても知られている．
幾何学的最適化は，面積，体積，電力等の最小化にしばしば使われる．
幾何学的最適化は主問題を解くを求める．
最小化

制約条件

ただし
単項式は，（ただし）のベキの積である．正多項式は単項式（ただし）の正の和である．
一般化された正多項式は，正多項式または一般化された正多項式の組合せである．

		正多項式
		一般化された正多項式の和
		一般化された正多項式の積
		一般化された正多項式の最大値
		一般化された正多項式の正の実数ベキ

正多項式は，以下のように，変換によって行列 ()と -ベクトル ( )に対応する．
同様の問題の定式化はを求めることである．ただし，が問題を解く．
最小化

制約条件

ただし
GeometricOptimization[{a₀,b₀},{{a₁,b₁},…},{a_eq,b_eq}]の a_iは行列，b_iはベクトル，a_eqは行列，はベクトルである．等式制約がない場合は，{a_eq,b_eq}は{}で与えることも省略することもできる．
主最小化問題には関連する最大化問題（ラグランジュ双対問題）がある．双対最大値は常に主最小値以下なので，下界を与える．双対マキシマイザは，制約条件の変化に対する最小値の感度を含む主問題の情報を与える．
幾何学的最適化問題は双対問題を持つ．
最大化

制約条件

ただし
錐最適化については強双対性が常に存在するので，主最小化問題に解がある場合は双対最大化問題にも解があり，双対最大値は主最小値に等しい．
次は，使用可能な解の特性"prop"である．

	"PrimalMinimizer"		f を最小化する vars={v₁,…}の値のリスト
	"PrimalMinimizerRules"		vars={v₁,…}の値を最小化する規則
	"PrimalMinimizerVector"		を最小化するベクトル
	"PrimalMinimumValue"		最小値
	"DualMaximizer"		を最大化するベクトルのリスト
	"DualMaximumValue"		双対最大値
	"DualityGap"		双対最適値と主最適値の差
	"Slack"		正多項式項の各単項式の値を与えるベクトル
	"ConstraintSensitivity"		の制約摂動に対する感度
	"ConstraintMatrices"		項についての行列
	"ObjectiveFunction"		目的関数
	"GeometricConstraints"		幾何学的制約のリスト
	{"prop₁","prop₂",…}		いくつかの解の特性

次は，使用可能なオプションである．

MaxIterations	Automatic	使用する反復の最大数
Method	Automatic	使用するメソッド
PerformanceGoal	$PerformanceGoal	パフォーマンスのどの面を最適化するか
Tolerance	Automatic	内部比較に使用する許容範囲

計算はMachinePrecisionに限定される．

例題

すべて開くすべて閉じる

例 (1)

外周が最大で1で縦の長さが横の長さの最大で半分になるようにして，長方形の面積を最大にする：

Wolfram Language code: GeometricOptimization[(1/w h), {2w + 2h ≤ 1, h ≤ (1/2)w}, {h, w}]

スコープ (12)

基本的な用法 (4)

行列を使って幾何の問題を指定する：

Wolfram Language code: GeometricOptimization[{{{-1, -1}}, {0}}, {{{{1, 0}, {0, 1}}, {0, 0}}, {{{1, -1}}, {Log[2]}}}]

問題について同等の目的関数と幾何学的制約を示す：

Wolfram Language code:

GeometricOptimization[{{{-1, -1}}, {0}}, {{{{1, 0}, {0, 1}}, {0, 0}}, {{{1, -1}}, {Log[2]}}}, {"ObjectiveFunction", "GeometricConstraints"}]

標準形式で与えられた等式制約がある幾何の問題を解く：

Wolfram Language code:

GeometricOptimization[(1/x z Sqrt[y ]) + 2.3x z + 4 x y z, {(1/3x^2y^2) + (4/3)(Sqrt[y ]/z) ≤ 1, x + 2 y + 3 z  ≤ 10, (1/2)x y == 1}, {x, y, z}]

一般化された正多項式で与えられた幾何の問題を解く：

Wolfram Language code:

GeometricOptimization[Sqrt[1 + x^2] + (1 + (y/z))^π, {(1/x) + (z/y) ≤ 5, ((x/y) + (y/z))^2.2 + x + y  ≤ 2}, {x, y, z}]

中間の正多項式形を得るために，アルゴリズムによって余分な変数が自動的に加えられる：

Wolfram Language code:

GeometricOptimization[Sqrt[1 + x^2] + (1 + (y/z))^π, {(1/x) + (z/y) ≤ 5, ((x/y) + (y/z))^2.2 + x + y  ≤ 2}, {x, y, z}, {"ObjectiveFunction", "GeometricConstraints"}]

ベクトル変数によって与えられた幾何の問題を解く：

Wolfram Language code:

GeometricOptimization[x.{{1, 2}, {3, 4}}.y, {VectorGreaterEqual[{x y, {1, 2}}], VectorLessEqual[{x + y, {3, 4}}]}, {Element[x, Vectors[2]], Element[y, Vectors[2]]}]

主モデル特性 (3)

標準的な正多項式の形で与えられた幾何の問題を解く：

Wolfram Language code: GeometricOptimization[x y + x z, {(4/5) Sqrt[y z] ≤ x^2, 1 ≤ 2Sqrt[x y ], (1/x z) ≤ 1}, {x, y, z}]

最小値と最小化ベクトルを得る：

Wolfram Language code:

GeometricOptimization[x y + x z, {(4/5) Sqrt[y z] ≤ x^2, 1 ≤ 2Sqrt[x y ], (1/x z) ≤ 1}, {x, y, z}, {"PrimalMinimumValue", "PrimalMinimizerVector"}]

問題の行列表現を示す：

Wolfram Language code:

GeometricOptimization[x y + x z, {(4/5) Sqrt[y z] ≤ x^2, 1 ≤ 2Sqrt[x y ], (1/x z) ≤ 1}, {x, y, z}, "ConstraintMatrices"]

一般化された正多項式で与えられた幾何の問題を解く：

Wolfram Language code: GeometricOptimization[Sqrt[x ^ 2 + 2 y ^ 3], {1 + Max[x, y] ≤ x y}, {x, y}]

導入された中間変数を含む変換された制約を得る：

Wolfram Language code:

symbolic = GeometricOptimization[Sqrt[x ^ 2 + 2 y ^ 3], {1 + Max[x, y] ≤ x y}, {x, y}, {"ObjectiveFunction", "GeometricConstraints"}]

これらは行列表現に対応する：

Wolfram Language code:

matrices = GeometricOptimization[Sqrt[x ^ 2 + 2 y ^ 3], {1 + Max[x, y] ≤ x y}, {x, y}, "ConstraintMatrices"];TableForm[Transpose[{Flatten[symbolic], Drop[matrices, -1]}], TableDepth -> 2]

行列形式で与えられた幾何の問題を解く：

Wolfram Language code:

objective = {{{0, 0, 1, 0, 0, 0}}, {0}};constraints = {{{{2, 0, 0, -1, 0, 0}, {0, 3, 0, -1, 0, 0}}, {0, Log[2]}}, {{{0, 0, -1, (1/2), 0, 0}}, {0}}, {{{-1, -1, 0, 0, 0, 0}, {-1, -1, 0, 0, 1, 0}}, {0, 0}}, {{{1, 0, 0, 0, 0, -1}}, {0}}, {{{0, 1, 0, 0, 0, -1}}, {0}}, {{{0, 0, 0, 0, -1, 1}}, {0}}};

Wolfram Language code: GeometricOptimization[objective, constraints]

形式変数を使って幾何の問題の記号形式を得る：

Wolfram Language code: GeometricOptimization[objective, constraints, {"ObjectiveFunction", "GeometricConstraints"}]

双対モデル特性 (2)

を求める．ただし，はに従ってを最小化する：

Wolfram Language code:

|                       |                       |
| --------------------- | --------------------- |
| a0  = {{-1, -1}}      | b0 = {0}              |
| a1 = {{1, 0}, {0, 3}} | b1 = {Log[2], Log[3]} |;

Wolfram Language code: GeometricOptimization[{Subscript[a, 0], Subscript[b, 0]}, {{Subscript[a, 1], Subscript[b, 1]}}]

双対問題は，に従ってを最大化するものである：

Wolfram Language code:

drules = ConicOptimization[-Subscript[b, 0].Subscript[λ, 0] + Indexed[(Subscript[t, 0]), {1}] - Subscript[b, 1].Subscript[λ, 1] + Indexed[(Subscript[t, 1]), {1}] + Indexed[(Subscript[t, 1]), {2}], {Transpose[Subscript[a, 0]].Subscript[λ, 0] + Transpose[Subscript[a, 1]].Subscript[λ, 1] == 0, Total[Subscript[λ, 0]] == 1, 
	{-Indexed[(Subscript[λ, 0]), {1}], Indexed[(Subscript[t, 0]), {1}] - Indexed[(Subscript[λ, 0]), {1}], 1}Underscript[, "DualExponentialCone"]0, {-Indexed[(Subscript[λ, 1]), {1}], Indexed[(Subscript[t, 1]), {1}] - Indexed[(Subscript[λ, 1]), {1}], Total[Subscript[λ, 1]]}Underscript[, "DualExponentialCone"]0, {-Indexed[(Subscript[λ, 1]), {2}], Indexed[(Subscript[t, 1]), {2}] - Indexed[(Subscript[λ, 1]), {2}], Total[Subscript[λ, 1]]}Underscript[, "DualExponentialCone"]0}, {Subscript[λ, 0]∈Vectors[1], Subscript[λ, 1]∈Vectors[2], Subscript[t, 0]∈Vectors[1], Subscript[t, 1]∈Vectors[2]}]

ConicOptimizationを使った定式化は，凸項を中間変数で置換し，以前使った双対指数錐制約に等しい制約条件を加える． ${-TemplateBox[{{(, {lambda, _, 1}, )}, j}, IndexedDefault],TemplateBox[{{(, {t, _, 1}, )}, j}, IndexedDefault]-TemplateBox[{{(, {lambda, _, 1}, )}, j}, IndexedDefault],1^.lambda_1}_(TemplateBox[{}, DualExponentialConeString])0$ は $xTemplateBox[{{(, {lambda, _, 1}, )}, j}, IndexedDefault] ⅇ^((TemplateBox[{{TemplateBox[{{(, {t, _, 1}, )}, j}, IndexedDefault], -, {(, {lambda, _, 1}, )}}, j}, IndexedDefault])/(-TemplateBox[{{(, {lambda, _, 1}, )}, j}, IndexedDefault])-1)<=1^.lambda_1 ∧-TemplateBox[{{(, {lambda, _, 1}, )}, j}, IndexedDefault]<=0$ を必要とする．

とは"DualMaximizer"特性からより簡単に得ることができる：

Wolfram Language code: GeometricOptimization[{Subscript[a, 0], Subscript[b, 0]}, {{Subscript[a, 1], Subscript[b, 1]}}, "DualMaximizer"]

強双対性があるので，双対最大値は主最小値に等しい：

Wolfram Language code:

{Exp[-(-Subscript[b, 0].Subscript[λ, 0] + Indexed[(Subscript[t, 0]), {1}] - Subscript[b, 1].Subscript[λ, 1] + Indexed[(Subscript[t, 1]), {1}] + Indexed[(Subscript[t, 1]), {2}])] /. drules, GeometricOptimization[{Subscript[a, 0], Subscript[b, 0]}, {{Subscript[a, 1], Subscript[b, 1]}}, "PrimalMinimumValue"]}

制約条件およびに従ってを最小化する：

Wolfram Language code: GeometricOptimization[(1/x y^2), {(2/x) ≤ 1, x^3y == 1}, {x, y}, {"PrimalMinimumValue", "PrimalMinimizerRules"}]

双対問題の解を得る：

Wolfram Language code: GeometricOptimization[(1/x y^2), {(2/x) ≤ 1, x^3y == 1}, {x, y}, {"DualMaximumValue", "DualMaximizer"}]

GeometricOptimizationには強双対性があるので，双対最大値は主最小値に等しい．その差は双対性のギャップと言われる：

Wolfram Language code: GeometricOptimization[(1/x y^2), {(2/x) ≤ 1, x^3y == 1}, {x, y}, {"DualityGap"}]

双対問題は問題の行列表現によって定義される：

Wolfram Language code:

{{Subscript[a, 0], Subscript[b, 0]}, {Subscript[a, 1], Subscript[b, 1]}, {Subscript[a, eq], Subscript[b, eq]}} = GeometricOptimization[(1/x y^2), {(2/x) ≤ 1, x^3y == 1}, {x, y}, "ConstraintMatrices"];
TableForm[Map[MatrixForm, {{Subscript[a, 0], Subscript[b, 0]}, {Subscript[a, 1], Subscript[b, 1]}, {Subscript[a, eq], Subscript[b, eq]}}, {2}], TableDepth -> 2, TableHeadings -> {{"{SubscriptBox[a, 0],SubscriptBox[b, 0]}", "{SubscriptBox[a, 1],SubscriptBox[b, 1]}", "{SubscriptBox[a, eq],SubscriptBox[b, eq]}"}}]

すべての項が単項式なので，行列のどれもが1行であり，双対ベクトルには1つの要素しかない．したがってである．を最大化することはを最小化することに等しい．また，指数関数が単調増加関数なので，これはを最小化することに等しい．したがって，双対問題は以下のように解くことができる：

Wolfram Language code:

LinearOptimization[-Subscript[b, eq].Subscript[λ, eq] - Subscript[b, 0].Subscript[λ, 0] - Subscript[b, 1].Subscript[λ, 1], {Transpose[Subscript[a, 0]].Subscript[λ, 0] + Transpose[Subscript[a, 1]].Subscript[λ, 1] + Transpose[Subscript[a, eq]].Subscript[λ, eq] == 0, Total[Subscript[λ, 0]] == 1, Subscript[λ, 0] 0, Subscript[λ, 1] 0}, {Subscript[λ, 0]∈Vectors[1], Subscript[λ, 1]∈Vectors[1], Subscript[λ, eq]∈Vectors[1]}]

主問題は，指数関数の単調性を使って線形最適化で解くこともできることに注意のこと：

Wolfram Language code:

yrule = LinearOptimization[Indexed[(Subscript[a, 0]), {1}].𝓎 + Indexed[(Subscript[b, 0]), {1}], {Indexed[(Subscript[a, 1]), {1}].𝓎 + Indexed[(Subscript[b, 1]), {1}] ≤ 0., Indexed[(Subscript[a, eq]), {1}].𝓎  + Indexed[(Subscript[b, eq]), {1}] == 0.}, 𝓎]

Wolfram Language code: Exp[{Indexed[(Subscript[a, 0]), {1}].𝓎 + Indexed[(Subscript[b, 0]), {1}] , 𝓎}] /. yrule

感度特性 (3)

箱のコストを100ドル未満にするという制約条件に従って，縦，横，高さの開放箱の体積を最大にする．底面のコストは単位面積あたり10ドルで，側面のコストは単位面積当たり1ドルである：

Wolfram Language code: rules = GeometricOptimization[(1/h w d), {10 * w * d + 1 * (2 h * w + 2 h * d) ≤ 100}, {h, w, d}]

Wolfram Language code: v = h w d /. rules

底面のコストを10％下げた場合に箱の体積が相対的にどのように変化するかを推測する：

Wolfram Language code:

sensitivity = GeometricOptimization[(1/h w d), {10 * w * d + 1 * (2 h * w + 2 h * d) ≤ 100}, {h, w, d}, "ConstraintSensitivity"]

底面のコストの内訳は，第2要素の最初の部分である（第1要素は目的関数に相当する）．なので感度は打ち消される：

Wolfram Language code: rδV = (-sensitivity[[2, 1]]) * (-.1)

Wolfram Language code: v1 = h w d /. GeometricOptimization[(1/h w d), {10 * (1 - .1) * w * d + 1 * (2 h * w + 2 h * d) ≤ 100}, {h, w, d}]

Wolfram Language code: (v1 - v) / v

縦，横，高さの箱の天面と底面あるいは側面についての制約条件を変えた場合に，この箱の最大体積が相対的にどのように変化するかを求める．体積を最大にすることは体積の逆数を最小にすることと同じである：

Wolfram Language code: objective = 1 / (h w d);

側面の総面積を以下に，天面と底面の面積を以下に制限する：

Wolfram Language code: areaConstraints[α_, β_] = {(2/α)(h * w + h * d) ≤ 1, (2/β)w * d ≤ 1};

さらに，縦横比の限界を加える：

Wolfram Language code: aspectRatioBounds = {1 / 2 ≤ h / w ≤ 2, 1 / 2 ≤ h / d ≤ 2, 1 / 2 ≤ w / d ≤ 2};

とが与えられた場合に体積を計算する関数を定義する：

Wolfram Language code:

v[α_, β_] := 1 / GeometricOptimization[objective, {areaConstraints[α, β], aspectRatioBounds}, {h, w, d}, "PrimalMinimumValue"]

についての最大体積を求める：

Wolfram Language code: v[38, 47]

のときの目的関数の制約条件に対する相対感度を得る：

Wolfram Language code:

sensitivities = GeometricOptimization[objective, {areaConstraints[38, 47], aspectRatioBounds}, {h, w, d}, "ConstraintSensitivity"]

面積の条件に関連するのは2番目と3番目である（最初のものは目的関数に関連している）：

Wolfram Language code: {Subscript[s, α], Subscript[s, β]} = sensitivities[[{2, 3}]];

に対する体積の相対変化はである：

Wolfram Language code: Subscript[s, β][[1]] / 47

これは，が少し変化しても{α,β}={38,47}の体積は変化しないことを意味する：

Wolfram Language code: v[38, 47.5] - v[38, 47]

が十分に小さければ，体積には影響しない：

Wolfram Language code: vb = Table[{β, v[38, β]}, {β, 1, 47}];ListPlot[vb]

感度は両対数プロット上の曲線の傾きである：

Wolfram Language code:

sb = Table[{β, Part[GeometricOptimization[objective, {areaConstraints[38, β], aspectRatioBounds}, {h, w, d}, "ConstraintSensitivity"], 3, 1]}, {β, 1, 47}];
ListLinePlot[{vb, sb}, ScalingFunctions -> {"Log10", "Log10"}, PlotRange -> All, PlotLegends -> {"V", "SubscriptBox[S, β]"}]

の2つの成分は相対する2組の側面から来ているので，体積の相対変化の合計は以下のようになる：

Wolfram Language code: Total[Subscript[s, α]] / 38

を.5増加させたことによる予測変化は以下の通りである：

Wolfram Language code: .5 * % * v[38, 47]

実際の変化は以下の通りである：

Wolfram Language code: v[38.5, 47] - v[38, 47]

感度は有限差分によっても確かめられる：

Wolfram Language code:

With[{h = 1.*^-3, α = 38, β = 47}, {(v[α + h, β] - v[α - h, β]/2 h v[α, β]), (v[α, β + h] - v[α, β - h]/2 h v[α, β])}]

制約条件に従ったとについてのの最小値の相対変化を求める：

Wolfram Language code:

{{Subscript[r, α], Subscript[r, β]}, {Subscript[r, 1]}, Subscript[r, eq]} = With[{α = 1, β = 2}, GeometricOptimization[α x ^ 2 + β y ^ 3, {(1 /x y) ≤ 1}, {x, y}, "ConstraintSensitivity"]]

有限差分を使ってであることを確かめる：

Wolfram Language code: f^ * [α_, β_] := GeometricOptimization[α x ^ 2 + β y ^ 3, {(1/x y) ≤ 1}, {x, y}, "PrimalMinimumValue"]

Wolfram Language code: Subscript[fd, α] = With[{h = 1.*^-3, α = 1}, (f^ * [1 + h, 2] - f^ * [1 - h, 2]/2 h f^ * [1, 2])]

同様にとであることを確かめる：

Wolfram Language code: Subscript[fd, β] = With[{h = 1.*^-3, β = 2}, β(f^ * [1, 2 + h] - f^ * [1, 2 - h]/2 h f^ * [1, 2])]

有限差分による推定は最適化の許容度内に収まっている：

Wolfram Language code: {Subscript[r, α] - Subscript[fd, α], Subscript[r, β] - Subscript[fd, β]}

アプリケーション (16)

基本的なモデリング変換 (1)

実行可能性を与える制約条件についての限界を決める：

Wolfram Language code:

GeometricOptimization[s1 * s2, {(1/3x^2y^2) + (4/3)(Sqrt[y ]/z) ≤ s1, x + 2 y + 3 z  ≤ s2, s1 ≥ 1, s2 ≥ 1, (1/2)x y == 1}, {x, y, z, s1, s2}]

この問題は実行可能である：

Wolfram Language code:

GeometricOptimization[(1/x z Sqrt[y ]) + 2.3x z + 4 x y z, {(1/3x^2y^2) + (4/3)(Sqrt[y ]/z) ≤ 1, x + 2 y + 3 z  ≤ 8, (1/2)x y == 1}, {x, y, z}]

この問題は実行可能ではない：

Wolfram Language code:

GeometricOptimization[(1/x z Sqrt[y ]) + 2.3x z + 4 x y z, {(1/3x^2y^2) + (4/3)(Sqrt[y ]/z) ≤ 1, x + 2 y + 3 z  ≤ 7, (1/2)x y == 1}, {x, y, z}]

幾何学的問題 (4)

面積4の長方形の対角線の長さを最小にする．ただし，横に縦の3倍を加えたものが7以下になるようにする：

Wolfram Language code: GeometricOptimization[Sqrt[w ^ 2 + h ^ 2], {w h == 4, w + 3h ≤ 7}, {w, h}]

体積の球状のスクープを入れるアイスクリームコーンをデザインする．スクープとコーンの半径は同じであるとする．アイスクリームが溶けたときにコーンにスクープ全体が入るようにしてコーンの表面積を最小にする：

Wolfram Language code: coneArea = π r (r + Sqrt[h^2 + r^2]);

Wolfram Language code: coneVolume = (π/3) h r^2 ;

Wolfram Language code: scoopVolume = (4/3)π r^3;

Wolfram Language code: GeometricOptimization[coneArea, {scoopVolume ≤ coneVolume, scoopVolume == V, V == 1}, {h, r}]

表面積が最大で1の楕円体の体積を最大にするを求める：

Wolfram Language code: volume = (4/3)π a b c;

の違いがあまりない場合は，のときの表面積は以下で近似される：

Wolfram Language code: surfaceArea = 4π ((a^pb^p + a^pc^p + b^p c^p/3))^1 / p /. p -> 1.6075;

体積をその逆数を最小にすることで最大にする：

Wolfram Language code: GeometricOptimization[1 / volume, surfaceArea ≤ 1, {a, b, c}]

予想通り，それは球である．軸の長さについての制限を加えると結果が変わる：

Wolfram Language code: GeometricOptimization[1 / volume, {surfaceArea ≤ 1, 2 b + 3c ≤ 1}, {a, b, c}]

Wolfram Language code: Graphics3D[Ellipsoid[{0, 0, 0}, {a, b, c} /. %]]

どの次元もその差が2倍以上にはならず，側面，天面，底面の総面積についての制約条件がある中で，縦，横，高さの箱の体積を最大にする：

Wolfram Language code:

GeometricOptimization[(1/h w d), {(1/2) ≤ (h/w) ≤ 2, (1/2) ≤ (d/w) ≤ 2, (1/2) ≤ (h/d) ≤ 2, 2 h * w + 2 h * d ≤ sideArea, 2w  * d  ≤ topArea, sideArea == 100, topArea == 40 }, {h, w, d}]

側面の総面積と底面と天面の合計が与えられると体積を返す関数を定義する：

Wolfram Language code:

volume[s_, t_] := 1 / GeometricOptimization[(1/h w d), {(1/2) ≤ (h/w) ≤ 2, (1/2) ≤ (d/w) ≤ 2, (1/2) ≤ (h/d) ≤ 2, 2 h * w + 2 h * d ≤ s, 2w  * d  ≤ t }, {h, w, d}, "PrimalMinimumValue"];
volume[100, 40]

体積の値の表を計算する：

Wolfram Language code: tradeOff = Outer[{##, volume[##]}&, 10 ^ Range[0., 2., .1], 10 ^ Range[0., 2., .1]];

体積を対数スケールによる側面および天面と底面の面積の関数として示す：

Wolfram Language code:

ListPlot3D[Flatten[tradeOff, 1], PlotRange -> All, ScalingFunctions -> {"Log10", "Log10", "Log10"}, MeshFunctions -> {#3&}, AxesLabel -> {s, t, V}]

さまざまな側面積の値について，体積と許される天面／底面の面積のトレードオフ曲線を示す：

Wolfram Language code:

ListLinePlot[tradeOff[[1 ;; -1 ;; 5, All, {2, 3}]], ScalingFunctions -> {"Log10", "Log10"}, 
	AxesLabel -> {"t", "V"}, PlotLegends -> Thread[Equal[s, tradeOff[[1 ;; -1 ;; 5, 1, 1]]]]]

行列問題 (2)

非負の実数項を持つ行列が与えられた場合に，同様の行列の平方和（フロベニウスのノルム平方）を最小にする正の項を持つ対角行列を求める：

Wolfram Language code:

n = 10;
A = BlockRandom[10 ^ RandomReal[{-5, 5}, {n, n}], RandomSeeding -> 1234];

d={d₁,…,d_n}がの対角項だとする．d_iは正なので，の各項は{1/d₁,…,1/d_n}となる．したがって，積の項はである：

Wolfram Language code:

drule = GeometricOptimization[Sum[Indexed[A, {i, j}]^2(Indexed[d, {i}]^2/Indexed[d, {j}]^2), {i, 1, n}, {j, 1, n}], {}, {d∈Vectors[n]}]

もとの行列とスケールされた行列のノルムを比較する：

Wolfram Language code: scaledA = DiagonalMatrix[d /. drule].A.DiagonalMatrix[1 / d /. drule];

Wolfram Language code: {Norm[A, "Frobenius"], Norm[scaledA, "Frobenius"]}

行列は相似なので，固有値は等しい：

Wolfram Language code: Eigenvalues[A] == Eigenvalues[scaledA]

は $x in TemplateBox[{}, Reals]^k$ のいくつかの変数に正の多項式要素を持つ $TemplateBox[{}, Reals]^(n x n)$ 行列であるとする．のスペクトル半径を最小にするを求める．スペクトル半径はの固有値の絶対値の最大値に等しい, ：

Wolfram Language code:

k   = 2;A = (⁠|                                 |                                   |                     |
| ------------------------------- | --------------------------------- | ------------------- |
| Indexed[x, {1}] Indexed[x, {2}] | (1/Indexed[x, {1}])               | 1 + Indexed[x, {2}] |
| Indexed[x, {2}]^2               | Indexed[x, {1}] + Indexed[x, {2}] | (1/Indexed[x, {2}]) |
| 1                               | Indexed[x, {1}]                   | Indexed[x, {2}]     |⁠);

スペクトル半径は，で計算できるペロン・フロベニウス(Perron–Frobenius)固有値と同じである：

Wolfram Language code:

rules = GeometricOptimization[λ, VectorLessEqual[{A.v, λ v}], {Element[x, Vectors[k]], Element[v, Vectors[Length[A]]], λ}]

以下は，スペクトル半径が最小の行列である：

Wolfram Language code: MatrixForm[Amin = A /. rules]

計算されたがスペクトル半径であることを確認する：

Wolfram Language code: Max[Abs[Eigenvalues[Amin]]]

ランダムに選んだのスペクトル半径と比較する：

Wolfram Language code: Table[Max[Abs[Eigenvalues[A /. x -> RandomReal[1, k]]]], {10}]

貯蔵タンクの設計 (1)

半径，高さ，縦横比の円筒形の貯蔵タンクの建設・運転費用を最小にする：

Wolfram Language code: designConstraints = {h ≤ 10, r ≤ 5, h / r ≤ 5};

建設費用は底面と側面の費用である：

Wolfram Language code:

baseCostPerUnitArea = 6;
surfaceCostPerUnitArea = 2;
constructionCost = baseCostPerUnitArea * π * r^2 + surfaceCostPerUnitArea * 2 π * r * h;

充填費用はタンク容量と注入量の比に比例するとみなされる：

Wolfram Language code:

Subscript[v, s] = 800;
Subscript[v, t] = π r^2 h;
fillingCost = 10 (Subscript[v, s]/Subscript[v, t]);

総費用を最小にする：

Wolfram Language code:

{cost, rules} = GeometricOptimization[constructionCost + fillingCost, designConstraints, {r, h}, {"PrimalMinimumValue", "PrimalMinimizerRules"}]

フロアプラン (1)

縦横比，長方形間の距離，相対的な配置の制約がある指定された面積の個の長方形を囲む，全体の面積が最小の長方形フロアを計設計する．

大きい長方形を Rectangle[{0,0},{H,W}]で，個々の小さい長方形を r_i=Rectangle[{x_i,y_i},{x_i+w_i,y_i+h_i}], i=1,…,n で表す．

各長方形の縦横比を，となるようにから（ただし）に制限する．

相対配置は，水平配置と垂直配置の2つの有向グラフで表すことができる．ij という辺がある場合は r_iは r_jの左（または下）にならなければならない：

長方形間の最小スペースをとする．に辺 ij があるとき，長方形はとなるように長方形の左にならなければならない．に辺 ij があるとき，長方形はとなるように長方形の下にならなければならない．次の関数で，グラフを横断しフロアの端になる長方形を説明することができる：

Wolfram Language code:

positionConstraints[g_, x_, w_, W_, s_, n_] := 
	Module[{u, l, cp, cl, cu, edgeConstraint}, 
	u[_] = True;
	l[_] = True;
	edgeConstraint[DirectedEdge[i_, j_]] := (
	u[i] = False;l[j] = False;x[i] + w[i] + s ≤ x[j]);
	cp = Map[edgeConstraint, EdgeList[g]];
	cl = Table[If[l[i], x[i] ≥ 0, Nothing], {i, n}];
	cu = Table[If[u[i], x[i] + w[i] ≤ W, Nothing], {i, n}];
	Join[cp, cl, cu]
	];

配置グラフ，面積，およびが与えられると，GeometricOptimizationを使う関数で規則を組み合せることができる：

Wolfram Language code:

planFloor[{gx_, gy_}, areas_, α_, s_] := 
	Block[{n = Length[areas], x, w, W, y, h, H}, 
	If[NumberQ[area], areas = ConstantArray[area, n]];
	horizontalConstraints = positionConstraints[gx, x, w, W, s, n];
	verticalConstraints = positionConstraints[gy, y, h, H, s, n];
	Subscript[x, all] = Array[x, n];
	Subscript[w, all] = Array[w, n];
	Subscript[y, all] = Array[y, n];
	Subscript[h, all] = Array[h, n];
	aspectConstraints = 1 / αSubscript[h, all] / Subscript[w, all]α;areaConstraints = Subscript[h, all] * Subscript[w, all] == areas;rules = GeometricOptimization[W * H, {horizontalConstraints, verticalConstraints, aspectConstraints,   areaConstraints}, Flatten[{W, H, Subscript[x, all], Subscript[w, all], Subscript[y, all], Subscript[h, all]}], Tolerance -> 0.0025];
	{Rectangle[{0, 0}, {W, H}] /. rules, AssociationMap[Function[Rectangle[{x[#], y[#]}, {x[#] + w[#], y[#] + h[#]}] /. rules], Range[n]]}]

次は，最初の長方形が他の2つの長方形の左側になり2番目の長方形が3番目の長方形の下になるような，3つの長方形の相対配置を表すグラフである：

Wolfram Language code:

Subscript[g, x] = Graph[Range[3], {12, 13}];
Subscript[g, y] = Graph[Range[3], {23}];

Wolfram Language code: plan = planFloor[{Subscript[g, x], Subscript[g, y]}, {3, 1, 1}, 2, 1]

次は，このプランを示す関数である：

Wolfram Language code:

showPlan[{big_, little_}] := Module[{showRectangle}, 
	showRectangle[key_, r : Rectangle[ll_, ur_]] := {LightGray, r, Black, Text[ToString[key], (ll + ur) / 2]};
	Graphics[{{EdgeForm[Thick], FaceForm[], big}, MapThread[showRectangle, {Keys[little], Values[little]}]}]]

Wolfram Language code: showPlan[plan]

次は，面積がランダムに割り当てられた10個の長方形についてのプランを示している：

Wolfram Language code:

Subscript[g, 10x] = Graph[Range[10], {12, 13, 14, 15, 16, 17, 23, 45, 23, 25, 27, 43, 45, 47, 65, 84, 94, 104, 106, 67, 89, 810}];
Subscript[g, 10y] = Graph[Range[10], {16, 17, 18, 19, 110, 24, 29, 46, 35, 57, 96, 910}];
areas = BlockRandom[RandomReal[1, 10], RandomSeeding -> "seed"];
showPlan[planFloor[{Subscript[g, 10x], Subscript[g, 10y]}, areas, 1.5, 0.1]]

構造最適化の問題 (3)

垂直荷重または水平荷重に従う最小重量のトラスを求める．トラスのバーは内半径，外半径，密度の中空のパイプである：

バーの長さはトラスの高さと幅を使って定義される．断面積はである．目的は重みを最小にすることである：

Wolfram Language code: weight = 2ρ A Sqrt[h^2 + w^2];

垂直荷重が適用された場合に各バーにかかる力は以下の通りである：

Wolfram Language code: verticalForceInBar = (Subscript[F, 1]Sqrt[h^2 + w^2]) / (2h);

水平荷重適用された場合に各バーにかかる力は以下の通りである：

Wolfram Language code: horizontalForceInBar = (Subscript[F, 2]Sqrt[h^2 + w^2]) / (2w);

バーにかかる力の合計は最大許容力を超えてはならない．ただし，は最大許容応力である：

Wolfram Language code: forceConstraints = {2verticalForceInBar ≤ σ A, 2horizontalForceInBar ≤ σ A};

トラスの高さと幅には制限がある：

Wolfram Language code: structureConstraints = {0.1 ≤ w ≤ 2, 0.1 ≤ h ≤ 2};

チューブは最低でも壁の厚さがなければならない．これは，（ただし）で達成できる．バーの面積と半径の関係はであるが，これは単項関数ではない．と制約条件を使うと，結果の制約条件は単項式になる：

Wolfram Language code: barConstraint = {(α r)^2 - r^2 ≤ A / (2π), Sqrt[r^2 + A / (2π)] ≤ Subscript[R, max]};

トラスのパラメータを指定する：

Wolfram Language code:

params  = {α -> 1.1, ρ -> 2700, σ -> 69000, Subscript[F, 1] -> 10^3, Subscript[F, 2] -> 10^3, Subscript[R, max] -> 5};

について解いて最適なトラスを得る：

Wolfram Language code:

res = GeometricOptimization[weight /. params, {forceConstraints, 
	structureConstraints, barConstraint} /. params, {h, w, r, A}]

を使ってバーの外半径を得る：

Wolfram Language code: Sqrt[(r ^ 2 + A / (2π))] /. res

垂直荷重に従う最小重量のトラスを求める．トラスの高さと幅は既知である．接合部の垂直位置は未知である：

を，それぞれバーおよびの断面積，をバーの密度とする．トラスの重みは以下で与えられる：

Wolfram Language code: weight = ρ(Subscript[A, 1]Sqrt[w^2 + (h - Subscript[y, b])^2] + Subscript[A, 2]Sqrt[w^2 + Subscript[y, b]^2]);

バーは伸長されている．を材料の引張応力とする．バーにかかる力は最大許容力を超えてはならない：

Wolfram Language code: barABConstraint = (P Sqrt[w^2 + (h - Subscript[y, b])^2] / h) ≤ Subscript[σ, t]Subscript[A, 1];

バーは圧縮されている．を材料の圧縮応力とする．にかかる力は最大許容力を超えてはならない：

Wolfram Language code: barBCConstraint = (P Sqrt[w^2 + Subscript[y, b]^2] / h) ≤ Subscript[σ, c]Subscript[A, 2];

パラメータを指定する：

Wolfram Language code: params = {ρ -> 7.7, Subscript[σ, t] -> 150 10 ^ 3, Subscript[σ, c] -> 100 10 ^ 3, h -> 2, w -> 1, P -> 100};

幾何最適化問題の特定の例は，の与えられた値について解くことができる．接合部の垂直位置が特定の範囲内にあると仮定して一連の問題を解く：

Wolfram Language code:

res = Table[{Subscript[y, b], GeometricOptimization[weight /. params
	, {barABConstraint, barBCConstraint} /. params, {Subscript[A, 1], Subscript[A, 2]}, "PrimalMinimumValue"]}, {Subscript[y, b], Subdivide[0.5, 1.5, 20]}];

最小の重みをプロットする：

Wolfram Language code: ListPlot[res, AxesLabel -> {"SubscriptBox[y, b]", "Weight"}]

最小の重みを与えるの特定の値を求める：

Wolfram Language code: yOpt = FindArgMin[Interpolation[res][x], {x, 0.5, 1.5}][[1]]

最適化された断面積とトラスの重みを求める：

Wolfram Language code:

GeometricOptimization[weight /. params /. Subscript[y, b] -> yOpt
	, {barABConstraint, barBCConstraint} /. params /. Subscript[y, b] -> yOpt, {Subscript[A, 1], Subscript[A, 2]}, {"PrimalMinimizerRules", "PrimalMinimumValue"}]

自由端上の垂直重みに従う，重みが最小の片持ち梁を設計する．この梁は単位長の個の部分からなっている．各部分の幅はで高さはである：

Wolfram Language code:

n = 16;
weight = w.h;

荷重によって梁はたわみ，梁の各部分にストレスがかかる．このストレスは最大許容応力より小さくなければならない：

Wolfram Language code: stressConstraints = Table[6 * i * F / (Indexed[w, i] * Indexed[h, i] ^ 2) ≤ Subscript[σ, max], {i, n}];

を部分の右端のたわみとする．自由端のたわみはで再帰的に求められる．はヤング率で傾きである．部分は固定されているのでである：

Wolfram Language code:

v[n + 1] = y = 0;
Do[v[i] = (12(i - 1 / 2) * (F / (Y * Indexed[w, i] * Indexed[h, i] ^ 3))) + v[i + 1], {i, n, 1, -1}];
Do[y += 6 * (i - 1 / 3) * (F / (Y * Indexed[w, i] * Indexed[h, i] ^ 3)) + v[i + 1], {i, n, 1, -1}];

梁の自由端のたわみは最大許容たわみ未満でなければならない：

Wolfram Language code: deflectionConstraint = y ≤ Subscript[y, max];

幅，高さ，縦横比は特定の範囲に制限されている：

Wolfram Language code: dimensionConstraints = {0.1w20, 0.1h6, 0.1h / w5};

パラメータを指定する：

Wolfram Language code: params = {Y -> 1, F -> 0.1, Subscript[σ, max] -> 1, Subscript[y, max] -> 10};

重みを最小にして個々の部分の次元を求める：

Wolfram Language code:

res = GeometricOptimization[weight, {stressConstraints, 
	deflectionConstraint, dimensionConstraints} /. params, {w∈Vectors[n], h∈Vectors[n]}]

片持ち梁を可視化する：

Wolfram Language code:

beamSegments = MapThread[Translate[Cuboid[{-1 / 2, -#1 / 2, -#2 / 2}, 
	{1 / 2, #1 / 2, #2 / 2}], {-#3, 0, 0}]&, {w, h, Range[0, n - 1]} /. res];
Graphics3D[{Opacity[0.5], beamSegments}, BoxRatios -> {3, 1, 1}]

回路の問題 (3)

デジタル回路ゲートのサイジング．回路内の遅延が最小となるような力と面積の制約条件に従って，指定された回路内のゲートの最適サイズを求める．7ゲート回路について考えてみる：

を各ゲートを広げるスケール因子とする：

Wolfram Language code: scalingConstraint = x1;

各ゲートが占める面積はこの倍率に比例すると考えられる．総回路面積は以下のようになる：

Wolfram Language code: circuitArea = Total[x];

ゲートの遷移によるエネルギー損失は，スケール因子，ゲートの遷移周波数，ゲート遷移におけるエネルギー損失に比例する：

Wolfram Language code:

transitionFrequency = {1, 0.8, 1, 0.7, 0.7, 0.5, 0.5};
energyLost = {1, 2, 1, 1.5, 1.5, 1, 2};
powerConsumed = (transitionFrequency * energyLost).x;

ゲートの入力容量は，ゲート6およびゲート7を除いてである．ゲート6およびゲート7の入力容量は10である：

Wolfram Language code: inputCapacitance = Join[Table[1 + Indexed[x, i], {i, 5}], {10, 10}];

ゲートの打込み抵抗はである：

Wolfram Language code: drivingResistance = Table[1 / Indexed[x, i], {i, 7}];

ゲートの容量は，その出力が接続されているゲート（ただしゲート6とゲート7を除く）の入力容量の合計である．出力ゲート6と7の容量はその入力容量と同じである：

Wolfram Language code:

connections = {{4}, {4, 5}, {5, 7}, {6, 7}, {7}, {6}, {7}};
gateCapacitance = Map[Total[inputCapacitance[[#]]]&, connections];

ゲートの遅延は，その打込み抵抗とゲート容量の積である：

Wolfram Language code: delay = drivingResistance * gateCapacitance;

目的は，回路が横断するあらゆる経路の組合せにおける最悪の遅延を最小にすることである：

Wolfram Language code:

paths = {{1, 4, 6}, {1, 4, 7}, {2, 4, 6}, {2, 4, 7}, {2, 5, 7}, {3, 5, 6}, {3, 7}};
objective = Max@@Map[Total[delay[[#]]]&, paths]

回路の面積は指定された最大許容面積未満でなければならない：

Wolfram Language code: areaConstraint = circuitArea ≤ aMax;

消費される電力は指定された最大許容電力未満でなければならない：

Wolfram Language code: powerConstraint = powerConsumed ≤ pMax;

最大許容面積と最大許容電力のさまざまな組合せについて最小面積を求める：

Wolfram Language code:

res = Table[{pMax, GeometricOptimization[objective, {scalingConstraint, 
	areaConstraint, powerConstraint}, x, "PrimalMinimumValue"]}, {aMax, {25, 50, 100}}, {pMax, 10, 100, 5}];

最適なトレードオフ曲線をプロットする：

Wolfram Language code: ListLinePlot[res, ...]

容量が既知である回路内の相互接続されたネットワークにおける本のワイヤ断片の幅を求める．以下のネットワーク内には5本のワイヤ断片がある：

各ワイヤ断片について，抵抗，容量である．はワイヤ特性に依存する正の定数，はワイヤの長さ，幅はである：

Wolfram Language code:

wireResistance = Table[Subscript[R, i] -> α(l / Indexed[w, i]), {i, 5}];
wireCapacitance = Table[Subscript[S, i] -> β * l * Indexed[w, i] + γ * l, {i, 5}];

モデルを使うと，各ワイヤは抵抗とコンデンサを使ってモデル化できる．結果のネットワークは抵抗・コンデンサネットワークになる：

モデルの新たな容量は，個々のネットワークの容量とワイヤ容量を合計することで得られる：

Wolfram Language code:

rcCapacitance = {Subscript[Overscript[c, ~], 0] -> Subscript[S, 1], Subscript[Overscript[c, ~], 1] -> Subscript[c, 1] + Subscript[S, 1] + Subscript[S, 2] + Subscript[S, 4], Subscript[Overscript[c, ~], 2] -> Subscript[c, 2] + Subscript[S, 2] + Subscript[S, 4], 
	Subscript[Overscript[c, ~], 3] -> Subscript[c, 3] + Subscript[S, 3], Subscript[Overscript[c, ~], 4] -> Subscript[c, 4] + Subscript[S, 4] + Subscript[S, 5], Subscript[Overscript[c, ~], 5] -> Subscript[c, 5] + Subscript[S, 5]} /. wireCapacitance;

エルモア(Elmore)遅延は電圧変化と新しい値への収束の遅延を測定する．各コンデンサのエルモア遅延はである．ただし，はコンデンサとの間の抵抗の集合である：

Wolfram Language code:

V = {...};
elmoreDelay = V.{Subscript[Overscript[c, ~], 0], Subscript[Overscript[c, ~], 1], Subscript[Overscript[c, ~], 2], Subscript[Overscript[c, ~], 3], Subscript[Overscript[c, ~], 4], Subscript[Overscript[c, ~], 5]} ;

目的は最大のエルモア遅延を最小にすることである：

Wolfram Language code: objective = Max@@elmoreDelay /. Join[wireResistance, rcCapacitance];

ワイヤは範囲内に収まるように制限されている：

Wolfram Language code: wireConstraint = 1w5;

総面積は最大許容面積を超えてはならない：

Wolfram Language code: areaConstraint = l * Total[w] ≤ Subscript[A, max];

パラメータを指定する：

Wolfram Language code:

params = {Subscript[R, 0] -> 0.1, l -> 1, α -> 1, β -> 1, γ -> 1, Subscript[A, max] -> 20, Subscript[c, 1] -> 10, Subscript[c, 2] -> 10, Subscript[c, 3] -> 10, Subscript[c, 4] -> 10, Subscript[c, 5] -> 10};

ワイヤの幅を求める：

Wolfram Language code:

GeometricOptimization[objective /. params, {wireConstraint, 
	areaConstraint} /. params, w∈Vectors[5]]

ベースの通過時間が最小化されるようなトランジスタの最適ドーピングプロファイルを求める．ドーピングプロファイルをとする．ただし，はベース幅である．をベースの通過時間とする．の関数としての簡約モデルはで与えられる．ただし，は定数である．とすると，個の等間隔に置かれた点を使って積分を離散化することができる：

Wolfram Language code:

M = 40;
c = Subscript[W, B] / (M + 1);
baseTransitTime = κ c^2 Sum[Indexed[v, i]^(Subscript[γ, 2] - 1) Sum[Indexed[v, j]^1 + Subscript[γ, 1] - Subscript[γ, 2], 
	{j, i, M + 1}], {i, 1, M + 1}];

ドーピング勾配制約は次のように近似できる：

Wolfram Language code:

dopingGradientConstraint = Table[(1 - α c) Indexed[v, i] ≤ 
	Indexed[v, i + 1] ≤ (1 + α c) Indexed[v, i], {i, 1, M}];

ドーピングプロファイルには上限と下限があり，初期状態と最終状態が指定されている：

Wolfram Language code:

dopingProfileConstraints = {Subscript[V, min]vSubscript[V, max], Indexed[v, 1] == Subscript[V, max], 
	Indexed[v, M + 1] == Subscript[V, min]};

パラメータを指定する：

Wolfram Language code:

params = {Subscript[V, min] -> 50, Subscript[V, max] -> 500, Subscript[γ, 1] -> 0.42, Subscript[γ, 2] -> 0.69, Subscript[W, B] -> 1, α -> 10, κ -> 1};

結果の幾何学的最適化問題を解いて最適ドーピングプロファイルを得る：

Wolfram Language code:

res = GeometricOptimization[baseTransitTime /. params, {dopingGradientConstraint, dopingProfileConstraints} /. params, v∈Vectors[M + 1]]

結果のプロファイルをプロットする：

Wolfram Language code: ListLinePlot[v /. res, PlotRange -> All]

電力制御 (1)

個の送電器が個の受電器に送電する総電力レベルを最小化する：

Wolfram Language code:

n = 5;
totalPower = Total[P];

受電器が送電器から受け取る電力はである．ただし，は，送電器から受電器までの経路利得である：

Wolfram Language code: powerReceived[G_, i_, j_] := G[[i, j]] Indexed[P, j];

受信器における信号電力はである：

Wolfram Language code: powerAtReceiver[G_, i_] := G[[i, i]] Indexed[P, i];

受信器における干渉電力は，を除くすべての送電器から受け取った総電力である：

Wolfram Language code:

interferencePower[G_, i_] := Sum[powerReceived[G, i, k], 
	{k, Complement[Range[n], {i}]}];

番目の受電器／送電器ペアの信号対干渉雑音比(SINR)はで与えられる．ただし，は受電器における雑音電力である：

Wolfram Language code: S[G_ ? MatrixQ, σ_ ? VectorQ, i_Integer] := powerAtReceiver[G, i] / (σ[[i]] + interferencePower[G, i]);

任意の受電器／送電器ペアのSINRには最小閾値がある，これを正多項式制約にするために，SINR制約の逆数を取る()：

Wolfram Language code: thresholdContraint[G_ ? MatrixQ, σ_ ? VectorQ] := Table[1 / S[G, σ, i] ≤ 1 / Subscript[S, min], {i, n}];

電力レベルには上限と下限がある：

Wolfram Language code: powerConstraint = Subscript[P, min]PSubscript[P, max];

パラメータを指定する：

Wolfram Language code:

SeedRandom[1234];
params = {G -> RandomReal[{0, 1}, {n, n}] + 2IdentityMatrix[n], σ -> ConstantArray[10, n], Subscript[S, min] -> 1, Subscript[P, min] -> 10, Subscript[P, max] -> 50};

電力レベルを求める：

Wolfram Language code:

GeometricOptimization[totalPower, {thresholdContraint[G, σ], 
	powerConstraint} //. params, P∈Vectors[n]]

Top

その他のラーニングリソース

テクニカルサポート

Wolframソリューション

教育のためのWolframソリューション

使い始める

Grow Your Skills

Wolframと繋がる

大人用の教育プログラム

若者のための教育プログラム

読む

GeometricOptimization

詳細とオプション

例題

例 (1)

スコープ (12)

基本的な用法 (4)

主モデル特性 (3)

双対モデル特性 (2)

感度特性 (3)

アプリケーション (16)

基本的なモデリング変換 (1)

幾何学的問題 (4)

行列問題 (2)

貯蔵タンクの設計 (1)

フロアプラン (1)

構造最適化の問題 (3)

回路の問題 (3)

電力制御 (1)

テキスト

CMS

APA

BibTeX

BibLaTeX

	最小化
	制約条件
	ただし

	最小化
	制約条件
	ただし

	最大化
	制約条件
	ただし

GeometricOptimization

詳細とオプション

例題

例 (1)

スコープ (12)

基本的な用法 (4)

主モデル特性 (3)

双対モデル特性 (2)

感度特性 (3)

アプリケーション (16)

基本的なモデリング変換 (1)

幾何学的問題 (4)

行列問題 (2)

貯蔵タンクの設計 (1)

フロアプラン (1)

構造最適化の問題 (3)

回路の問題 (3)

電力制御 (1)

関連項目

関連するガイド

履歴

テキスト

CMS

APA

BibTeX

BibLaTeX