mgmg 1.4.2 → 1.5.0

data/lib/mgmg.rb

@@ -7,79 +7,106 @@ require_relative './mgmg/ir'
 require_relative './mgmg/system_equip'
 require_relative './mgmg/cuisine'
 require_relative './mgmg/reinforce'
+require_relative './mgmg/option'
 require_relative './mgmg/search'
 require_relative './mgmg/optimize'
 
 class String
-	def min_level(w=1)
-		Mgmg::Equip.min_level(self, w)
+	def min_weight(opt: Mgmg::Option.new)
+		build(build(opt: opt).min_levels_max, opt: opt).weight
 	end
-	def min_levels(w=1, left_associative: true)
-		build(-1, -1, left_associative: left_associative).min_levels(w)
+	def max_weight(include_outsourcing=false, opt: Mgmg::Option.new)
+		if include_outsourcing
+			build(-1, opt: opt).weight
+		else
+			build(min_smith(opt: opt), opt: opt).weight
+		end
+	end
+	def min_level(w=0, include_outsourcing=false, opt: Mgmg::Option.new)
+		built = build(-1, opt: opt)
+		w = build(built.min_levels_max, -1, opt: opt).weight - w if w <= 0
+		return -1 if include_outsourcing && built.weight <= w
+		ms = min_smith(opt: opt)
+		return ms if build(ms, opt: opt).weight <= w
+		ary = [ms]
+		4.downto(1) do |wi| # 単品の最大重量は[斧|重鎧](金10石10)の5
+			built.min_levels(wi).values.each do |v|
+				(ary.include?(v) or ary << v) if ms < v
+			end
+		end
+		ary.sort.each do |l|
+			return l if build(l, opt: opt).weight <= w
+		end
+		raise ArgumentError, "w=`#{w}' is given, but the minimum weight for the recipe is `#{min_weight(opt: opt)}'."
+	end
+	def min_levels(w=1, opt: Mgmg::Option.new)
+		build(opt: opt).min_levels(w)
 	end
-	def min_smith(left_associative: true)
-		Mgmg::Equip.min_smith(self, left_associative: left_associative)
+	def min_levels_max(w=1, opt: Mgmg::Option.new)
+		min_levels(w, opt: opt).values.append(-1).max
 	end
-	def min_comp(left_associative: true)
-		Mgmg::Equip.min_comp(self, left_associative: left_associative)
+	def min_smith(opt: Mgmg::Option.new)
+		Mgmg::Equip.min_smith(self, opt: opt)
 	end
-	def build(smith=-1, comp=smith, left_associative: true)
-		Mgmg::Equip.build(self, smith, comp, left_associative: left_associative)
+	def min_comp(opt: Mgmg::Option.new)
+		Mgmg::Equip.min_comp(self, opt: opt)
 	end
-	def ir(left_associative: true, reinforcement: [])
-		Mgmg::IR.build(self, left_associative: left_associative, reinforcement: reinforcement)
+	def build(smith=-1, comp=smith, opt: Mgmg::Option.new)
+		Mgmg::Equip.build(self, smith, comp, left_associative: opt.left_associative).reinforce(*opt.reinforcement)
 	end
-	def poly(para=:cost, left_associative: true)
-		la = left_associative
+	def ir(opt: Mgmg::Option.new)
+		Mgmg::IR.build(self, left_associative: opt.left_associative, reinforcement: opt.reinforcement)
+	end
+	def poly(para=:cost, opt: Mgmg::Option.new)
 		case para
 		when :atkstr
-			self.poly(:attack, left_associative: la) + self.poly(:str, left_associative: la)
+			self.poly(:attack, opt: opt) + self.poly(:str, opt: opt)
 		when :atk_sd
-			self.poly(:attack, left_associative: la) + self.poly(:str, left_associative: la).quo(2) + self.poly(:dex, left_associative: la).quo(2)
+			self.poly(:attack, opt: opt) + self.poly(:str, opt: opt).quo(2) + self.poly(:dex, opt: opt).quo(2)
 		when :dex_as
-			self.poly(:dex, left_associative: la) + self.poly(:attack, left_associative: la).quo(2) + self.poly(:str, left_associative: la).quo(2)
+			self.poly(:dex, opt: opt) + self.poly(:attack, opt: opt).quo(2) + self.poly(:str, opt: opt).quo(2)
 		when :mag_das
-			self.poly(:magic, left_associative: la) + self.poly(:dex_as, left_associative: la).quo(2)
+			self.poly(:magic, opt: opt) + self.poly(:dex_as, opt: opt).quo(2)
 		when :magmag
-			self.poly(:magdef, left_associative: la) + self.poly(:magic, left_associative: la).quo(2)
+			self.poly(:magdef, opt: opt) + self.poly(:magic, opt: opt).quo(2)
 		when :pmdef
-			pd = self.poly(:phydef, left_associative: la)
-			md = self.poly(:magmag, left_associative: la)
+			pd = self.poly(:phydef, opt: opt)
+			md = self.poly(:magmag, opt: opt)
 			pd <= md ? pd : md
 		when :cost
 			if Mgmg::SystemEquip.keys.include?(self)
 				return Mgmg::TPolynomial.new(Mgmg::Mat.new(1, 1, 0.quo(1)), 28, 0, 12, 12)
 			end
-			built = self.build(-1)
+			built = self.build(-1, opt: opt)
 			const = (built.star**2) * ( /\+/.match(self) ? 5 : ( built.kind < 8 ? 2 : 1 ) )
-			ret = poly(:attack, left_associative: la) + poly(:phydef, left_associative: la) + poly(:magdef, left_associative: la)
-			ret += poly(:hp, left_associative: la).quo(4) + poly(:mp, left_associative: la).quo(4)
-			ret += poly(:str, left_associative: la) + poly(:dex, left_associative: la) + poly(:speed, left_associative: la) + poly(:magic, left_associative: la)
+			ret = poly(:attack, opt: opt) + poly(:phydef, opt: opt) + poly(:magdef, opt: opt)
+			ret += poly(:hp, opt: opt).quo(4) + poly(:mp, opt: opt).quo(4)
+			ret += poly(:str, opt: opt) + poly(:dex, opt: opt) + poly(:speed, opt: opt) + poly(:magic, opt: opt)
 			ret.mat.body[0][0] += const
 			ret
 		else
-			Mgmg::TPolynomial.build(self, para, left_associative: la)
+			Mgmg::TPolynomial.build(self, para, left_associative: opt.left_associative)
 		end
 	end
-	def eff(para, smith, comp=smith, left_associative: true)
-		a = build(smith, comp, left_associative: left_associative).para_call(para)
-		b = build(smith+1, comp, left_associative: left_associative).para_call(para)
-		c = build(smith, comp+2, left_associative: left_associative).para_call(para)
+	def eff(para, smith, comp=smith, opt: Mgmg::Option.new)
+		a = build(smith, comp, opt: opt).para_call(para)
+		b = build(smith+1, comp, opt: opt).para_call(para)
+		c = build(smith, comp+2, opt: opt).para_call(para)
 		sden = smith==0 ? 1 : 2*smith-1
 		cden = comp==0 ? 4 : 8*comp
 		[(b-a).quo(sden), (c-a).quo(cden)]
 	end
-	def peff(para, smith, comp=smith, left_associative: true)
-		poly(para, left_associative: left_associative).eff(smith, comp)
+	def peff(para, smith, comp=smith, opt: Mgmg::Option.new)
+		poly(para, opt: opt).eff(smith, comp)
 	end
-	def show(smith=-1, comp=smith, left_associative: true, para: :power, reinforcement: [])
-		rein = case reinforcement
+	def show(smith=-1, comp=smith, para: :power, opt: Mgmg::Option.new)
+		rein = case opt.reinforcement
 		when Array
-			reinforcement.map{|r| Mgmg::Reinforcement.compile(r)}
+			opt.reinforcement.map{|r| Mgmg::Reinforcement.compile(r)}
 		else
-			[Mgmg::Reinforcement.compile(reinforcement)]
+			[Mgmg::Reinforcement.compile(opt.reinforcement)]
 		end
-		built = self.build(smith, comp, left_associative: left_associative).reinforce(*rein)
+		built = build(smith, comp, opt: opt)
 		pstr = '%.3f' % built.para_call(para)
 		pstr.sub!(/\.?0+\Z/, '')
 		puts "Building"
@@ -88,37 +115,39 @@ class String
 		puts "with levels (#{smith}, #{comp})#{rein} yields (#{pstr}, #{built.total_cost})"
 		puts "  #{built}"
 	end
-	def phydef_optimize(smith=nil, comp=smith, left_associative: true, magdef_maximize: true)
-		Mgmg::Optimize.phydef_optimize(self, smith, comp, left_associative: left_associative, magdef_maximize: magdef_maximize)
+	def phydef_optimize(smith=nil, comp=smith, opt: Mgmg::Option.new)
+		Mgmg::Optimize.phydef_optimize(self, smith, comp, opt: opt)
 	end
-	def buster_optimize(smith=nil, comp=smith, left_associative: true)
-		Mgmg::Optimize.buster_optimize(self, smith, comp, left_associative: left_associative)
+	def buster_optimize(smith=nil, comp=smith, opt: Mgmg::Option.new)
+		Mgmg::Optimize.buster_optimize(self, smith, comp, opt: opt)
 	end
 end
 module Enumerable
-	def build(smith=-1, armor=smith, comp=armor.tap{armor=smith}, left_associative: true)
-		self.sum do |str|
-			m = /\A\[*([^\+]+)/.match(str)
-			if Mgmg::EquipPosition[m[1].build(0).kind] == 0
-				str.build(smith, comp, left_associative: left_associative)
+	def build(smith=-1, armor=smith, comp=armor.tap{armor=smith}, opt: Mgmg::Option.new)
+		opt = opt.dup
+		rein = opt.reinforcement
+		opt.reinforcement = []
+		self.sum(Mgmg::Equip::Zero) do |str|
+			if Mgmg::EquipPosition[str.build(opt: opt).kind] == 0
+				str.build(smith, comp, opt: opt)
 			else
-				str.build(armor, comp, left_associative: left_associative)
+				str.build(armor, comp, opt: opt)
 			end
-		end
+		end.reinforce(*rein)
 	end
-	def ir(left_associative: true, reinforcement: [])
-		self.sum do |str|
-			str.ir(left_associative: left_associative)
-		end.add_reinforcement(reinforcement)
+	def ir(opt: Mgmg::Option.new)
+		self.sum(Mgmg::IR::Zero) do |str|
+			str.ir(opt: opt)
+		end.add_reinforcement(opt.reinforcement)
 	end
-	def show(smith=-1, armor=smith, comp=armor.tap{armor=smith}, left_associative: true, para: :power, reinforcement: [])
-		rein = case reinforcement
+	def show(smith=-1, armor=smith, comp=armor.tap{armor=smith}, para: :power, opt: Mgmg::Option.new)
+		rein = case opt.reinforcement
 		when Array
-			reinforcement.map{|r| Mgmg::Reinforcement.compile(r)}
+			opt.reinforcement.map{|r| Mgmg::Reinforcement.compile(r)}
 		else
-			[Mgmg::Reinforcement.compile(reinforcement)]
+			[Mgmg::Reinforcement.compile(opt.reinforcement)]
 		end
-		built = self.build(smith, armor, comp, left_associative: left_associative).reinforce(*rein)
+		built = self.build(smith, armor, comp, opt: opt)
 		pstr = '%.3f' % built.para_call(para)
 		pstr.sub!(/\.?0+\Z/, '')
 		puts "Building"
@@ -127,14 +156,75 @@ module Enumerable
 		puts "with levels (#{smith}, #{armor}, #{comp})#{rein} yields (#{pstr}, #{built.total_cost})"
 		puts "  #{built}"
 	end
-	def min_levels(w=1, left_associative: true)
-		build(-1, -1, -1, left_associative: left_associative).min_levels(w)
+	def min_weight(opt: Mgmg::Option.new)
+		build(*build(opt: opt).min_levels_max, -1, opt: opt).weight
+	end
+	def max_weight(include_outsourcing=false, opt: Mgmg::Option.new)
+		if include_outsourcing
+			build(-1, opt: opt).weight
+		else
+			build(*min_smith(opt: opt), -1, opt: opt).weight
+		end
+	end
+	def min_weights(opt: Mgmg::Option.new)
+		weapons, armors = [], []
+		each do |str|
+			if Mgmg::EquipPosition[str.build(opt: opt).kind] == 0
+				weapons << str
+			else
+				armors << str
+			end
+		end
+		[weapons.min_weight(opt: opt), armors.min_weight(opt: opt)]
+	end
+	def max_weights(include_outsourcing=false, opt: Mgmg::Option.new)
+		weapons, armors = [], []
+		each do |str|
+			if Mgmg::EquipPosition[str.build(opt: opt).kind] == 0
+				weapons << str
+			else
+				armors << str
+			end
+		end
+		[weapons.max_weight(include_outsourcing, opt: opt), armors.max_weight(include_outsourcing, opt: opt)]
+	end
+	def min_level(ws=0, wa=ws, include_outsourcing=false, opt: Mgmg::Option.new)
+		weapons, armors = [], []
+		each do |str|
+			if Mgmg::EquipPosition[str.build(opt: opt).kind] == 0
+				weapons << str
+			else
+				armors << str
+			end
+		end
+		ms, ma = min_smith(opt: opt)
+		rs = min_level_sub(ws, ms, 0, weapons, include_outsourcing, opt: opt)
+		ra = min_level_sub(wa, ma, 1, armors, include_outsourcing, opt: opt)
+		[rs, ra]
+	end
+	private def min_level_sub(w, ms, i, recipe, include_outsourcing, opt: Mgmg::Option.new)
+		built = recipe.build(opt: opt)
+		w = recipe.build(built.min_levels_max[i], opt: opt).weight - w if w <= 0
+		return -1 if include_outsourcing && built.weight <= w
+		return ms if build(ms, opt: opt).weight <= w
+		ary = [ms]
+		4.downto(1) do |wi|
+			built.min_levels(wi).values.each do |v|
+				(ary.include?(v) or ary << v) if ms << v
+			end
+		end
+		ary.sort.each do |l|
+			return l if recipe.build(l, opt: opt).weight <= w
+		end
+		raise ArgumentError, "w#{%w|s a|[i]}=`#{w}' is given, but the minimum weight for the #{%w|weapon(s) armor(s)|[i]} is `#{recipe.min_weight(opt: opt)}'."
+	end
+	def min_levels(w=1, opt: Mgmg::Option.new)
+		build(opt: opt).min_levels(w)
 	end
-	def min_level(w=1, left_associative: true)
-		ret = [0, 0]
-		build(-1, -1, -1, left_associative: left_associative).min_levels(w).each do |str, level|
-			m = /\A\[*([^\+]+)/.match(str)
-			if Mgmg::EquipPosition[m[1].build(0).kind] == 0
+	def min_levels_max(w=1, opt: Mgmg::Option.new)
+		ret = [-1, -1]
+		min_levels(w, opt: opt).each do |str, level|
+			if Mgmg::EquipPosition[str.build(opt: opt).kind] == 0
 				ret[0] = [ret[0], level].max
 			else
 				ret[1] = [ret[1], level].max
@@ -142,12 +232,11 @@ module Enumerable
 		end
 		ret
 	end
-	def min_smith(left_associative: true)
-		ret = [0, 0]
+	def min_smith(opt: Mgmg::Option.new)
+		ret = [-1, -1]
 		self.each do |str|
-			s = Mgmg::Equip.min_smith(str, left_associative: left_associative)
-			m = /\A\[*([^\+]+)/.match(str)
-			if Mgmg::EquipPosition[m[1].build(0).kind] == 0
+			s = Mgmg::Equip.min_smith(str, opt: opt)
+			if Mgmg::EquipPosition[str.build(opt: opt).kind] == 0
 				ret[0] = [ret[0], s].max
 			else
 				ret[1] = [ret[1], s].max
@@ -155,9 +244,9 @@ module Enumerable
 		end
 		ret
 	end
-	def min_comp(left_associative: true)
+	def min_comp(opt: Mgmg::Option.new)
 		self.map do |str|
-			Mgmg::Equip.min_comp(str, left_associative: left_associative)
-		end.max
+			Mgmg::Equip.min_comp(str, opt: opt)
+		end.append(-1).max
 	end
 end

data/mgmg.gemspec

@@ -35,9 +35,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", ">= 2.1.2"
-  spec.add_development_dependency "rake", ">= 13.0.1"
-  spec.add_development_dependency "irb", ">= 1.2.3"
+  spec.add_development_dependency "bundler", ">= 2.3.16"
+  spec.add_development_dependency "rake", ">= 13.0.6"
+  spec.add_development_dependency "irb", ">= 1.4.1"
   
-  spec.required_ruby_version = '>= 2.4.0'
+  spec.required_ruby_version = '>= 3.1.0'
 end

data/reference.md

@@ -1,12 +1,12 @@
 # リファレンス
 本ライブラリで定義される主要なメソッドを以下に解説します．
 
-## `String#build(smith=-1, comp=smith, left_associative: true)`
+## `String#build(smith=-1, comp=smith, opt: Mgmg.option())`
 レシピ文字列である`self`を解釈し，鍛冶・防具製作Lvを`smith`，道具製作Lvを`comp`として鍛冶・防具製作及び武器・防具合成を行った結果を[後述](#mgmgequip)の`Mgmg::Equip`クラスのインスタンスとして生成し，返します．例えば，
 ```ruby
 '[杖(水玉10火玉5)+本(骨10鉄1)]+[本(水玉5綿2)+杖(骨10鉄1)]'.build(112, 176)
 ```
-のようにします．基本的に`[]`による合成順序の指定が必要ですが，不確定の場合，`left_associative`が真なら左結合，偽なら右結合として解釈します．
+のようにします．基本的に`[]`による合成順序の指定が必要ですが，不確定の場合，`opt.left_associative`が真なら左結合，偽なら右結合として解釈します．
 ```ruby
 '法衣(綿10皮10)+歴戦の服'
 ```
@@ -14,33 +14,69 @@
 
 `self`が解釈不能な場合，例外が発生します．また，製作Lvや完成品の☆制限のチェックを行っていないほか，本ライブラリでは`武器+防具`や`防具+武器`の合成も可能になっています．街の鍛冶・防具製作・道具製作屋に任せた場合をシミュレートする場合は製作Lvを負の値(`-1`など，負であれば何でもよい)にします(製作Lv0相当の性能を計算し，消費エレメント量は委託仕様となります)．
 
-## `Enumerable#build(smith=-1, armor=smith, comp=armor.tap{armor=smith}, left_associative: true)`
-複数のレシピ文字列からなる`self`の各要素を製作し，そのすべてを装備したときの`Mgmg::Equip`を返します．製作では`鍛冶Lv=smith`, `防具製作Lv=armor`, `道具製作Lv=comp`とします．1つしか指定しなければすべてそのLv，2つなら1つ目を`smith=armor`，2つ目を`comp`に，3つならそれぞれの値とします．`left_associative`はそのまま`String#build`に渡されます．製作Lvが負の場合，製作Lv0として計算した上で，消費エレメント量は街の製作屋に頼んだ場合の値を計算します．武器複数など，同時装備が不可能な場合でも，特にチェックはされません．
+`opt`は，`left_associative`のみ使用します．
 
-## `String#min_level(weight=1)`
-`self`を`weight`以下で作るための最低製作Lvを返します．`build`と異なり，合成や既成品は解釈できません．また，素材の☆による最低製作Lvとのmaxを返すため，街の鍛冶・防具製作屋に頼んだ場合の重量は`self.build.weight`で確認する必要があります．`weight`を省略した場合，重量1となる製作Lvを返します．
+## `Enumerable#build(smith=-1, armor=smith, comp=armor.tap{armor=smith}, opt: Mgmg.option())`
+複数のレシピ文字列からなる`self`の各要素を製作し，そのすべてを装備したときの`Mgmg::Equip`を返します．製作では`鍛冶Lv=smith`, `防具製作Lv=armor`, `道具製作Lv=comp`とします．1つしか指定しなければすべてそのLv，2つなら1つ目を`smith=armor`，2つ目を`comp`に，3つならそれぞれの値とします．製作Lvが負の場合，製作Lv0として計算した上で，消費エレメント量は街の製作屋に頼んだ場合の値を計算します．武器複数など，同時装備が不可能な場合でも，特にチェックはされません．
 
-## `String#min_levels(weight=1, left_associative: true)`
+`opt`は，`left_associative`のみ使用します．
+
+## `String#min_weight(opt: Mgmg.option())`
+製作可能な最小重量を返します．基本的には合成回数+1ですが，既製品を含む場合はその限りではありません．
+
+製作を行うため，`opt`が指定可能ですが，特に結果には影響しません．
+
+## `String#max_weight(include_outsourcing=false, opt: Mgmg.option())`
+製作可能な最大重量を返します．`include_outsourcing`が真の場合，委託製作時の重量を返します．
+委託製作では，製作Lv0相当となるため，素材の☆による最低製作Lvで作るよりも重くなる場合があります．
+
+製作を行うため，`opt`が指定可能ですが，特に結果には影響しません．
+
+## `String#min_level(w=0, include_outsourcing=false, opt: Mgmg.option())`
+`self`を重量`w`以下で作るための最低製作Lvを返します．
+`w`が`0`以下の場合，`self.min_weight-w`を指定した場合と同じになります．
+
+`include_outsourcing`が真の場合，委託製作で目標重量が達成可能な場合，`-1`を返します．
+偽の場合，返り値の最小値(`w`が`self.max_weight`以上の場合)は素材の☆による最低製作Lvになります．
+
+`w`が最小重量より小さい場合，`ArgumentError`となります．製作を行うため，`opt`が指定可能ですが，特に結果には影響しません．
+
+## `String#min_levels(weight=1, opt: Mgmg.option())`
 合成レシピの各鍛冶・防具製作品に対して，レシピ文字列をキー，重量1で作製するために必要な製作Lvを値とした`Hash`を返します．重量はすべての装備について同じ値しか指定できません．
-最大値は，`self.build.min_level`によって得られます．
 
-## `Enumerable#min_levels(weight=1, left_associative: true)`
+製作を行うため，`opt`が指定可能ですが，特に結果には影響しません．
+
+## `Enumerable#max_weight(include_outsourcing=false, opt: Mgmg.option())`，`Enumerable#min_weight(opt: Mgmg.option())`
+製作可能な最大・最小重量を返します．`opt`を含め，`String#max_weight`，`String#min_weight`と同様です．
+
+## `Enumerable#max_weights(include_outsourcing=false, opt: Mgmg.option())`，`Enumerable#min_weights(opt: Mgmg.option())`
+`self`を武器の集合と防具の集合に分け，`[武器の最大・最小重量, 防具の最大・最小重量]`を返します．その他は`String#max_weight`，`String#min_weight`と同様です．
+
+## `Enumerable#min_levels(weight=1, opt: Mgmg.option())`
 すべての要素`str`に対する`str.min_levels`をマージした`Hash`を返します．
 
-## `Enumerable#min_level(weight=1, left_associative: true)`
-`self.min_levels`から武器，防具それぞれに対する最大値を求め，`[必要最小鍛冶Lv, 必要最小防具製作Lv]`を返します．武器，防具の一方のみが含まれる場合，もう一方は`0`になります．
+製作を行うため，`opt`が指定可能ですが，特に結果には影響しません．
+
+## `Enumerable#min_levels_max(weight=1, opt: Mgmg.option())`
+`self.min_levels`から武器，防具それぞれに対する最大値を求め，`[必要最小鍛冶Lv, 必要最小防具製作Lv]`を返します．武器，防具の一方のみが含まれる場合，もう一方は`-1`になります．
 
-## `String#min_comp(left_associative: true)`，`Enumerable#min_comp(left_associative: true)`
-レシピ通りに合成するのに必要な道具製作Lvを返します．ただし，全体が「[]」で囲われているか，非合成レシピの場合，代わりに`0`を返します．
+製作を行うため，`opt`が指定可能ですが，特に結果には影響しません．
+
+## `String#min_comp(opt: Mgmg.option())`，`Enumerable#min_comp(opt: Mgmg.option())`
+レシピ通りに合成するのに必要な道具製作Lvを返します．ただし，全体が「[]」で囲われているか，非合成レシピの場合，代わりに`-1`を返します．
 
 `Enumerable`の場合，すべての要素に対する最大値を返します．
 
-## `String#min_smith(left_associative: true)`，`Enumerable#min_smith(left_associative: true)`
-レシピ通りに製作するのに必要な鍛冶・防具製作Lvを返します．製作物の重量については考慮せず，鍛冶・防具製作に必要な☆条件を満たすために必要な製作Lvを返します．
+`opt`は，`left_associative`のみ使用します．
+
+## `String#min_smith(opt: Mgmg.option())`，`Enumerable#min_smith(opt: Mgmg.option())`
+レシピ通りに製作するのに必要な鍛冶・防具製作Lvを返します．製作物の重量については考慮せず，鍛冶・防具製作に必要な☆条件を満たすために必要な製作Lvを返します．既製品のみから構成される場合は`-1`になります．
+
+`Enumerable`の場合，すべての要素に対し，武器，防具それぞれの最大値を求め，`[必要最小鍛冶Lv, 必要最小防具製作Lv]`を返します．武器，防具の一方のみが含まれる場合，もう一方は`-1`になります．
 
-`Enumerable`の場合，すべての要素に対し，武器，防具それぞれの最大値を求め，`[必要最小鍛冶Lv, 必要最小防具製作Lv]`を返します．
+製作を行うため，`opt`が指定可能ですが，特に結果には影響しません．
 
-## `String#poly(para=:cost, left_associative: true)`
+## `String#poly(para=:cost, opt: Mgmg.option())`
 レシピ文字列である`self`を解釈し，`para`で指定した9パラ値について，丸めを無視した鍛冶・防具製作Lvと道具製作Lvの2変数からなる多項式関数を示す`Mgmg::TPolynomial`クラスのインスタンスを生成し，返します．`para`は次のシンボルのいずれかを指定します．
 ```ruby
 :attack, :phydef, :magdef, :hp, :mp, :str, :dex, :speed, :magic
@@ -55,78 +91,98 @@
 
 また，`:cost`を渡すことで，消費エレメント量に関する近似多項式を得られます．`self`に`"+"`が含まれていれば合成品とみなし，最後の合成に必要な地エレメント量を，それ以外では，武器なら消費火エレメント量を，防具なら消費水エレメント量を返します．ただし，`self`が既成品そのものの場合，零多項式を返します．
 
-## `String#ir(left_associative: true, reinforcement: [])`
+`opt`は，`left_associative`のみ使用します．
+
+## `String#ir(opt: Mgmg.option())`
 レシピ文字列である`self`を解釈し，9パラ値について，丸めを考慮した鍛冶・防具製作Lvと道具製作Lvの2変数からなる関数オブジェクトを保持する`Mgmg::IR`クラスのインスタンスを生成し，返します．詳しくは，[後述](#mgmgir)の`Mgmg::IR`クラスの説明を参照ください．
 
-`reinforcement`には，[後述](#mgmgequipreinforcearg)の`Mgmg::Equip#reinforce`に渡す引数と同様のものを，一つの配列にまとめて渡します．強化が一つだけの場合，その引数を裸で渡すこともできます．
+`opt`は，`left_associative`と`reinforcement`を使用します．
 
-## `Enumerable#ir(left_associative: true, reinforcement: [])`
+## `Enumerable#ir(opt: Mgmg.option())`
 複数のレシピ文字列からなる`self`の各要素を製作し，そのすべてを装備したときの`Mgmg::IR`を返します．この場合，鍛冶Lv，防具製作Lv，道具製作Lvの3変数からなる関数オブジェクトを保持するものとして扱われます．各装備の種別に応じ，鍛冶Lvまたは防具製作Lvを適用し，9パラ値を計算します．
 
-## `String#smith_seach(para, target, comp, smith_min=nil, smith_max=10000, left_associative: true, cut_exp: Float::INFINITY, min_smith: false, irep: nil, reinforcement: [])`
+`opt`は，`left_associative`と`reinforcement`を使用します．
+
+## `String#smith_seach(para, target, comp, opt: Mgmg.option())`
 `para`の値が`target`以上となるのに必要な最小の鍛冶・防具製作Lvを二分探索で探索して返します．
-道具製作Lvは`comp`で固定，鍛冶・防具製作Lvを`smith_min`と`smith_max`で挟み込んで探索します．
+道具製作Lvは`comp`で固定，鍛冶・防具製作Lvを`opt.smith_min`と`opt.smith_max`で挟み込んで探索します．
 
-`smith_min`が`nil`のとき，`min_smith`が真なら重量を問わず☆的に必要な最小の鍛冶・防具製作Lv (`self.min_smith`)，偽なら最小重量で製作するのに必要な鍛冶・防具製作Lv (`self.build.min_level`)を使用します．
-`smith_min<smith_max`でないとき，`smith_max`で`para`が`target`以上でないときは`ArgumentError`となります．
+`opt.smith_min`のデフォルト値は重量`opt.target_weight`で製作するのに必要な鍛冶・防具製作Lv (`self.min_level(opt.target_weight)`)です．
+`opt.target_weight`のデフォルト値は`0`で，`0`以下の場合の挙動は[前述](#stringmin_levelw0-include_outsourcingfalse-opt-mgmgoption)の`String#min_level`を参照してください．
+`opt.smith_min<opt.smith_max`でないとき，`opt.smith_max`で`para`が`target`以上でないときは`ArgumentError`となります．
 
 `para`は，`Mgmg::Equip`のメソッド名をシンボルで指定(`:power, :fpower`も可)します．
 反転などの影響で，探索範囲において`para`の値が(広義)単調増加になっていない場合，正しい結果を返しません．
-`cut_exp`以下の経験値で`target`以上を達成できない場合，`Mgmg::SearchCutException`を発生します．
+`opt.cut_exp`以下の経験値で`target`以上を達成できない場合，`Mgmg::SearchCutException`を発生します．
 
-`irep`に`Mgmg::IR`オブジェクトが渡された場合，`self`を無視して`irep`を使って探索します．
-`reinforcement`が渡された場合，`para`を強化された値として計算します．`irep`が指定されている場合は無視されます．
+`opt`は，上記の他に`left_associative`，`reinforcement`，`irep`を使用します．
 
-## `String#comp_search(para, target, smith, comp_min=nil, comp_max=10000, left_associative: true, irep: nil, reinforcement: [])`
+## `String#comp_search(para, target, smith, opt: Mgmg.option())`
 `String#smith_seach`とは逆に，鍛冶・防具製作Lvを固定して最小の道具製作Lvを探索します．
-`comp_min`が`nil`のときは，製作に必要な最小の道具製作Lv (`self.min_comp`)を使用します．
+探索の起点である`opt.comp_min`のデフォルト値は，製作に必要な最小の道具製作Lv (`self.min_comp`)です．
 その他は`String#smith_seach`と同様です．
 
-## `String#search(para, target, smith_min=nil, comp_min=nil, smith_max=10000, comp_max=10000, left_associative: true, step: 1, cut_exp: Float::INFINITY, min_smith: false, irep: nil, reinforcement: [])`
-`c_min=comp_search(para, target, smith_max, comp_min, comp_max)` から `c_max=comp_search(para, target, smith_max, comp_min, comp_max)` まで，`step`ずつ動かして，
+`opt`は，`comp_min`，`comp_max`，`left_associative`，`reinforcement`，`irep`を使用します．
+
+## `String#search(para, target, opt: Mgmg.option())`
+`c_min=comp_search(para, target, opt.smith_max, opt: opt)` から `c_max=comp_search(para, target, opt.smith_min, opt: opt)` まで，`opt.step`ずつ動かして，
 `smith_search`を行い，その過程で得られた最小経験値の鍛冶・防具製作Lvと道具製作Lvからなる配列を返します．
-レシピ中の，対象パラメータの種別値がすべて奇数，または全て偶数であるなら，`step`を`2`にしても探索すべき範囲を網羅できます．
+レシピ中の，対象パラメータの種別値がすべて奇数，または全て偶数であるなら，`opt.step`を`2`にしても探索すべき範囲を網羅できます．
 その他は`String#smith_seach`と同様です．
 
-## `Enumerable#search(para, target, smith_min=nil, armor_min=nil, comp_min=nil, smith_max=10000, armor_max=10000, comp_max=10000, left_associative: true, cut_exp: Float::INFINITY, min_smith: false, irep: nil, reinforcement: [])`
+`opt`は，`String#smith_search`または`String#comp_search`で使われるすべてのパラメータを使用します．
+
+## `Enumerable#search(para, target, opt: Mgmg.option())`
 複数装備の組について，`para`の値が`target`以上となる最小経験値の`[鍛冶Lv，防具製作Lv，道具製作Lv]`を返します．
 武器のみなら防具製作Lvは`0`，防具のみなら鍛冶Lvは`0`，合成なしなら道具製作Lvは`0`となります．
-その他は`String#smith_seach`と同様です．
 
-## `Mgmg.#find_lowerbound(a, b, para, start, term, smith_min_a: nil, smith_min_b: nil, armor_min_a: nil, armor_min_b: nil, min_smith: false, reinforcement: [])`
+`opt.smith_min`および`opt.armor_min`のデフォルト値は，武器・防具の各総重量を`opt.target_weight`で製作するのに必要な鍛冶・防具製作Lv (`self.min_level(*opt.target_weight)`)です．`opt.target_weight`には2要素からなる配列を指定しますが，整数が与えられた場合，それを2つ並べた配列と同等のものとして扱います．合計重量を指定することにはならないので注意してください．`opt.target_weight`のデフォルト値は`0`です．
+
+その他は，`String#smith_seach`と同様です．
+
+## `Mgmg.#find_lowerbound(a, b, para, start, term, opt_a: Mgmg.option(), opt_b: Mgmg.option())`
 レシピ`a`とレシピ`b`について，`para`の値を目標値以上にする最小経験値の組において，目標値`start`における優劣が逆転する目標値の下限を探索し，返します．
 返り値は`[逆転しない最大目標値, 逆転時の最小para値]`です．前者は逆転目標値の下限，後者は，目標値が前者よりも少しだけ大きいときの`para`値です．
 ここで，最小経験値が小さい方，または最小経験値が同じなら，そのときの`para`値が大きい方をよりよいものと解釈します．
 `term`は`start`より大きい値とします．目標値`term`における優劣が，目標値`start`における優劣と同じ場合，`Mgmg::SearchCutException`を発生します．
 `a`と`b`は`String`でもその`Enumerable`でも構いません．
 
-`smith_min_a`，`smith_min_b`，`armor_min_a`，`armor_min_b`は，それぞれ`a`と`b`の探索最小鍛冶・防具製作Lvを指定します．`a`，`b`が`String`の場合，防具についても`smith_min_a`，`smith_min_b`を指定します．`Enumerable`の場合は，鍛冶と防具製作についてそれぞれ指定します．
-これらが`nil`で，`min_smith`が真ならば，重量を無視した製作可能最小Lvが指定されます．`min_smith`が偽(デフォルト)ならば，最小重量で製作可能な製作Lvが指定されます．重量を無視した製作可能Lvでの重量が3で，重量が2以下となる製作Lvで探索したい場合などは，`smith_min_a`，`smith_min_b`，`armor_min_a`，`armor_min_b`を具体的に指定してください．
+`opt_a`，`opt_b`には，それぞれ`a`と`b`に関するオプションパラメータを指定します．`smith_min`，`armor_min`，`min_smith`，`left_associative`，`reinforcement`，`irep`を使用します．
 
-## `Mgmg.#find_upperbound(a, b, para, start, term, smith_min_a: nil, smith_min_b: nil, armor_min_a: nil, armor_min_b: nil, min_smith: false, reinforcement: [])`
+## `Mgmg.#find_upperbound(a, b, para, start, term, opt_a: Mgmg.option(), opt_b: Mgmg.option())`
 `Mgmg.#find_lowerbound`とは逆に，目標値を下げながら，優劣が逆転する最大の目標値を探索し，返します．返り値は`[逆転する最大目標値, 逆転前の最小para値]`です．目標値が，前者よりも少しでも大きいと逆転が起こらず(逆転する目標値の上限)，少しだけ大きい時の`para`値が後者になります．
 
-## `String#eff(para, smith, comp=smith, left_associative: true)`
+`opt_a`，`opt_b`は，`Mgmg.#find_lowerbound`と同様です．
+
+## `String#eff(para, smith, comp=smith, opt: Mgmg.option())`
 [`smith`を1上げたときの`para`値/(`smith`を1上げるのに必要な経験値), `comp`を1上げたときの`para`値/(`comp`を2上げるのに必要な経験値)]を返します．
 `para`は，`Mgmg::Equip`のメソッド名をシンボルで指定(`:power, :fpower`も可)します．
 
-## `String#peff(para, smith, comp=smith, left_associative: true)`
-近似多項式における偏微分値を使用した場合の，`String#eff`と同様の値を返します．`self.poly(para, left_associative: left_associative).eff(smith, comp)`と等価です．
+`opt`は`String#build`にそのまま渡されます．
+
+## `String#peff(para, smith, comp=smith, opt: Mgmg.option())`
+近似多項式における偏微分値を使用した場合の，`String#eff`と同様の値を返します．`self.poly(para, opt: opt).eff(smith, comp)`と等価です．
 
-## `String#phydef_optimize(smith=nil, comp=smith, left_associative: true, magdef_maximize: true)`
+`opt`は`String#poly`にそのまま渡されます．
+
+## `String#phydef_optimize(smith=nil, comp=smith, opt: Mgmg.option())`
 反転物防装備の反転材の種別，素材の最適化を行い，修正したレシピを返します．
 `smith`，`comp`は探索を行う製作レベルを表し，`smith`が`nil`の場合，近似多項式で最適化を行います．近似多項式では，道具製作レベルの次数が高い項の係数を最適化します．
-物防を最大化するレシピのうち，`magdef_maximize`が真なら魔防を最大化する組み合わせ，偽ならコストを最小化(≒魔防を最小化)する組み合わせを探索します．
+物防を最大化するレシピのうち，`opt.magdef_maximize`が真なら魔防を最大化する組み合わせ，偽ならコストを最小化(≒魔防を最小化)する組み合わせを探索します．
 ある範囲での全数探索を行うため，段数の多いレシピでは計算量が膨大になるほか，厳密な最適化を保証するものではなく，今後のアップデートで解が変わるような変更が入る可能性があります．
 
-## `String#buster_optimize(smith=nil, comp=smith, left_associative: true)`
+`opt`は，上記の`magdef_maximize`が使われるほか，`String#build`または`String#poly`にそのまま渡されます．
+
+## `String#buster_optimize(smith=nil, comp=smith, opt: Mgmg.option())`
 `String#phydef_optimize`の魔力弓版で，反転材の素材の最適化を行い，修正したレシピを返します．
 
+`opt`は，`String#build`または`String#poly`にそのまま渡されます．
+
 ## `Mgmg.#exp(smith, armor, comp=armor.tap{armor=0})`
 鍛冶Lvを0から`smith`に，防具製作Lvを0から`armor`に，道具製作Lvを0から`comp`に上げるのに必要な総経験値を返します．鍛冶Lvと防具製作Lvは逆でも同じです．
 
 ## `Mgmg::Equip`
-[前述](#stringbuildsmith-1-compsmith-left_associative-true)の`String#build`によって生成される装備品のクラスです．複数装備の合計値を表す「複数装備」という種別の装備品の場合もあります．以下のようなインスタンスメソッドが定義されています．
+[前述](#stringbuildsmith-1-compsmith-opt-mgmgoption)の`String#build`によって生成される装備品のクラスです．複数装備の合計値を表す「複数装備」という種別の装備品の場合もあります．以下のようなインスタンスメソッドが定義されています．
 
 ## `Mgmg::Equip#to_s`
 ```ruby
@@ -212,7 +268,7 @@
 レシピ中の，鍛冶・防具製作物の文字列をキー，重量`weight`で生成するのに必要な最小レベルを値とした`Hash`を返します．
 「複数装備」の場合，各装備の`min_levels`をマージした`Hash`を返します．
 
-## `Mgmg::Equip#min_level(weight=1)`
+## `Mgmg::Equip#min_levels_max(weight=1)`
 `min_levels(weight)`の値の最大値を返します．「複数装備」の場合，`[鍛冶の必要レベル，防具製作の必要レベル]`を返します．
 
 ## `Mgmg::Equip#reinforce(*arg)`
@@ -236,7 +292,7 @@
 |オールアップ|物防，腕力，器用，素早，魔力x1.5|本アクティブ|
 
 ## `Mgmg::TPolynomial`
-[前述](#stringpolyparacost-left_associative-true)の`String#poly`によって生成される二変数多項式のクラスです．最初のTはtwo-variableのTです．以下のようなメソッドが定義されています．
+[前述](#stringpolyparacost-opt-mgmgoption)の`String#poly`によって生成される二変数多項式のクラスです．最初のTはtwo-variableのTです．以下のようなメソッドが定義されています．
 
 ## `Mgmg::TPolynomial#to_s(fmt=nil)`
 鍛冶・防具製作LvをS，道具製作LvをCとして，`self`を表す数式文字列を返します．係数`coeff`を文字列に変換する際，`fmt`の値に応じて次の方法を用います．
@@ -282,7 +338,7 @@ alias として`*`があるほか`scalar(1.quo(value))`として`quo`，`/`，`s
 一方のみが欲しい場合，`Mgmg::TPolynomial#smith_eff(smith, comp=smith)`，`Mgmg::TPolynomial#smith_eff(smith, comp=smith)`が使えます．
 
 ## `Mgmg::IR`
-[前述](#stringirleft_associative-true-reinforcement-)の`String#ir`または`Enumerable#ir`によって生成される，9パラ値を計算するための，2変数または3変数の関数オブジェクトを保持するクラスです．`Mgmg::IR`では，`Mgmg::Equip`と異なり，重量，EL値，総消費エレメントを取り扱いません．
+[前述](#stringiropt-mgmgoption)の`String#ir`または`Enumerable#ir`によって生成される，9パラ値を計算するための，2変数または3変数の関数オブジェクトを保持するクラスです．`Mgmg::IR`では，`Mgmg::Equip`と異なり，重量，EL値，総消費エレメントを取り扱いません．
 
 ## `Mgmg::IR#to_s`
 例えば，「斧(牙9皮9)+短剣(鉄9皮2)」のレシピに対して，
@@ -372,3 +428,26 @@ alias として`*`があるほか`scalar(1.quo(value))`として`quo`，`/`，`s
 調理法，主食材，副食材，料理Lvを指定し，対応する料理の効果の**概算値**を計算します．計算式は [Wikiの記述](https://wikiwiki.jp/guruguru/%E3%82%A2%E3%82%A4%E3%83%86%E3%83%A0/%E9%A3%9F%E7%B3%A7%E5%93%81#y1576f2d) に基づきますが，正確ではないことがわかっています．例えば，`('蒸す', 'アースドラン', '氷河酒', 27)`の物防は87ですが，この計算式では88になります．調理法，主食材，副食材は文字列で，料理Lvは整数で指定します．
 
 調理法は「焼き」か「蒸す」，主食材は「獣肉」「ウッチ」「ゴッチ」「ガガッチ」「ドランギョ」「ドラバーン」「フレドラン」「アースドラン」「アクアドラン」「ダークドン」，副食材は「氷酒」「氷水酒」「氷河酒」「カエン酒」「爆炎酒」「煉獄酒」のみ対応しています．攻撃，物防，魔防の強化を考える場合，これらで十分と判断しての選択となっています．なお，副食材の数値は，Wikiの表で順番が間違っていると思われる部分を修正しています．
+
+## `Mgmg::Option`
+多くのメソッドのオプション引数をまとめるクラスです．このクラスのインスタンスを使ってそれぞれのメソッドに引き渡します．
+
+## `Mgmg.#option(recipe=nil, **kw)`
+`kw`はキーワード引数本体です．定義されているキーワードと意味，使用される主なメソッドは下表の通りです．デフォルト値は簡易的な表示であり，細かい点では不正確です．
+`recipe`にレシピ`String`または`Enumerable`を渡すと，そのレシピを使ってデフォルト値を具体化しますが，各メソッドで自動的に具体化されるため，通常は必要ありません．
+
+|キーワード|デフォルト値|意味|主なメソッド，備考|
+|:-|:-|:-|:-|
+|left_associative|`true`|レシピ文字列を左結合で解釈する|`Mgmg::Option`を使用するすべてのメソッド|
+|smith_min|`recipe.min_level(target_weight)`|鍛冶Lvに関する探索範囲の最小値|`String#search`など|
+|armor_min|`recipe.min_level(*target_weight)[1]`|防具製作Lvに関する探索範囲の最小値|`Enumerable#search`など．`String`系では代わりに`smith_min`を使う|
+|comp_min|`recipe.min_comp`|道具製作Lvに関する探索範囲の最小値|`String#search`など|
+|smith_max, armor_max, comp_max|`10000`|各製作Lvの探索範囲の最大値|`String#search`など|
+|target_weight|`0`|`smith_min`のデフォルト値計算に使う目標重量|`String#search`など|
+|step|`1`|探索時において道具製作Lvを動かす幅|`String#search`など|
+|magdef_maximize|`true`|目標を魔防最大(真)かコスト最小(偽)にするためのスイッチ|`String#phydef_optimize`|
+|reinforcement|`[]`|[前述](#mgmgequipreinforcearg)の`Mgmg::Equip#reinforce`による強化リスト|一部を除くすべてのメソッド|
+|buff|`[]`|`reinforcement`のエイリアス|どちらか一方のみを指定する|
+|irep|`recipe.ir()`|`Mgmg::IR`の使い回しによる高速化|`String#search`など，内部的に使用|
+|cut_exp|`Float::INFINITY`|探索時の総経験値の打ち切り値|`String#search`など，内部的に使用|
+