mgmg 1.5.3 → 1.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38cdc3b73d921d0af024b6a4e52401c2539dd3e06a300116054e6f6b0dca03d7
-  data.tar.gz: 4235ea18224761cdeced8d9026b8d27c9690093fb1116a7eb4a36827f3ea3c3c
+  metadata.gz: f3f377aff6ac79ec7111b1b81fcfc5148505ca5f57606be79192f832d80d7c92
+  data.tar.gz: 3cca84c8c97b44f18945d1817a921d42b7702f77a61dff4e8836a52f1a9a0f14
 SHA512:
-  metadata.gz: dac5f9bdd58018092822acba25a1f9e1c965ea6a1d3756b12903c081be4cf6761ba3eabb76326dc4d587f171ece4adc8d861d425368c3090a25c2c5faa036948
-  data.tar.gz: bcecf50fa423d798bf74da4f4968054c1200aa31f597750964fa0f34fb53439916bcc455d35f43a82a6e0701e902a4ecf527961eed758d7daacc67c622ccc93d
+  metadata.gz: 76db175b332d5c5d69ab12f171b734ceb82d4102151b19ce17e710e4776acaabe5e706f0b830eef251a664ae2d702b92d504af6409441da164dd64be1736a19f
+  data.tar.gz: aa9416fcbaca9dc1d631925c4b5b3eb946196d81aab90748567c3c638adba12bf6474a70f1c815806527afe334cad434d841ce19e22350816df443e4c485fbdc

data/CHANGELOG.md

@@ -144,3 +144,11 @@
 
 ## 1.5.3 2022/06/28
 - `Recipe#option`がキーワード引数を受け取れなかったバグを修正．
+
+## 1.5.4 2022/06/30
+- 既製品の探索を制御する`:include_system_equips`オプションを追加．
+	- 既製品を含まないレシピを計算するとき，これを偽に設定することで，高速化される．
+	- デフォルト値は`true`．ただし，既製品を含まないレシピ文字列を`to_recipe`すると，自動的に`false`に書き換える．
+- 一部のメソッドで計算結果をキャッシュすることで，同じ材料装備を含む大量のレシピを計算する場合に高速化された．
+	- `Mgmg.#clear_cache`ですべてのキャッシュをクリアできる．
+- 一部のオプションのデフォルト値をグローバルに変更するための定数ハッシュ`Mgmg::Option::Defaults`を追加．

data/lib/mgmg/cuisine.rb

@@ -22,6 +22,55 @@ module Mgmg
 			"料理[攻撃:#{self.attack}, 物防:#{self.phydef}, 魔防:#{self.magdef}]"
 		end
 		alias :inspect :to_s
+		
+		MainFood = {
+			'獣肉'         => Vec[10,  0,  0],
+			'ウッチ'       => Vec[ 0, 10, 10],
+			'ゴッチ'       => Vec[ 0, 12, 12],
+			'ガガッチ'     => Vec[ 0, 14, 14],
+			'ドランギョ'   => Vec[15, 15, 10],
+			'ドラバーン'   => Vec[20, 20, 15],
+			'フレドラン'   => Vec[50,  0,  0],
+			'アースドラン' => Vec[ 0, 50,  0],
+			'アクアドラン' => Vec[ 0,  0, 50],
+			'ダークドン'   => Vec[30, 30, 30],
+		}
+		SubFood = {
+			'氷酒'     => Vec[ 50,  70,  50],
+			'氷水酒'   => Vec[ 50,  90,  50],
+			'氷河酒'   => Vec[ 50, 110,  50],
+			'カエン酒' => Vec[ 70,  50,  70],
+			'爆炎酒'   => Vec[ 90,  50,  90],
+			'煉獄酒'   => Vec[110,  50, 110],
+		}
+		Cookery = {
+			'焼き' => Vec[50, 50, 30],
+			'蒸す' => Vec[30, 75, 75],
+		}
+		Cookery.store('丸焼き', Cookery['焼き'])
+		Cookery.store('すき焼き', Cookery['焼き'])
+		Cookery.store('焼く', Cookery['焼き'])
+		Cookery.store('焼', Cookery['焼き'])
+		Cookery.store('蒸し焼き', Cookery['蒸す'])
+		Cookery.store('ボイル', Cookery['蒸す'])
+		Cookery.store('蒸し', Cookery['蒸す'])
+		Cookery.store('蒸', Cookery['蒸す'])
+		
+		class << self
+			def cook(cookery_s, main_s, sub_s, level)
+				begin
+					c = Cookery[cookery_s]
+					m = MainFood[main_s]
+					s = SubFood[sub_s]
+					v = Vec[1, 1, 1]
+					v.e_mul!(m).e_mul!(c).e_mul!(s.dup.add!(100+level)).e_div!(10000)
+					new(v)
+				rescue
+					arg = [cookery_s, main_s, sub_s, level].inspect
+					raise ArgumentError, "Some of arguments for cooking seems to be wrong. #{arg} is given, but they should be [cookery (String), main food (String), sub food (String), cooking level (Integer)]. Not all of cookeries and foods are supported."
+				end
+			end
+		end
 	end
 	
 	SystemCuisine = {
@@ -72,55 +121,6 @@ module Mgmg
 		end
 	end
 	
-	MainFood = {
-		'獣肉'         => Vec[10,  0,  0],
-		'ウッチ'       => Vec[ 0, 10, 10],
-		'ゴッチ'       => Vec[ 0, 12, 12],
-		'ガガッチ'     => Vec[ 0, 14, 14],
-		'ドランギョ'   => Vec[15, 15, 10],
-		'ドラバーン'   => Vec[20, 20, 15],
-		'フレドラン'   => Vec[50,  0,  0],
-		'アースドラン' => Vec[ 0, 50,  0],
-		'アクアドラン' => Vec[ 0,  0, 50],
-		'ダークドン'   => Vec[30, 30, 30],
-	}
-	SubFood = {
-		'氷酒'     => Vec[ 50,  70,  50],
-		'氷水酒'   => Vec[ 50,  90,  50],
-		'氷河酒'   => Vec[ 50, 110,  50],
-		'カエン酒' => Vec[ 70,  50,  70],
-		'爆炎酒'   => Vec[ 90,  50,  90],
-		'煉獄酒'   => Vec[110,  50, 110],
-	}
-	Cookery = {
-		'焼き' => Vec[50, 50, 30],
-		'蒸す' => Vec[30, 75, 75],
-	}
-	Cookery.store('丸焼き', Cookery['焼き'])
-	Cookery.store('すき焼き', Cookery['焼き'])
-	Cookery.store('焼く', Cookery['焼き'])
-	Cookery.store('焼', Cookery['焼き'])
-	Cookery.store('蒸し焼き', Cookery['蒸す'])
-	Cookery.store('ボイル', Cookery['蒸す'])
-	Cookery.store('蒸し', Cookery['蒸す'])
-	Cookery.store('蒸', Cookery['蒸す'])
-	
-	class << Cuisine
-		def cook(cookery_s, main_s, sub_s, level)
-			begin
-				c = Cookery[cookery_s]
-				m = MainFood[main_s]
-				s = SubFood[sub_s]
-				v = Vec[1, 1, 1]
-				v.e_mul!(m).e_mul!(c).e_mul!(s.dup.add!(100+level)).e_div!(10000)
-				new(v)
-			rescue
-				arg = [cookery_s, main_s, sub_s, level].inspect
-				raise ArgumentError, "Some of arguments for cooking seems to be wrong. #{arg} is given, but they should be [cookery (String), main food (String), sub food (String), cooking level (Integer)]. Not all of cookeries and foods are supported."
-			end
-		end
-	end
-	
 	module_function def cuisine(*arg)
 		case arg.size
 		when 3

data/lib/mgmg/equip.rb

@@ -1,6 +1,8 @@
 module Mgmg
+	CacheMLS = Hash.new
 	using Refiner
 	class Equip
+		Cache, CacheML = Hash.new, Hash.new
 		ParamList = %w|攻撃 物防 魔防 HP MP 腕力 器用 素早 魔力|
 		ElementList = %w|火 地 水|
 		EqPosList = %w|武 頭 胴 腕 足 飾|
@@ -196,195 +198,203 @@ module Mgmg
 		Zero = self.new(28, 0, Vec.new(6, 0).freeze, 12, 12, Vec.new(9, 0).freeze, Vec.new(3, 0).freeze)
 		Zero.total_cost.freeze; Zero.history.clear.freeze
 		Zero.freeze
-	end
-	
-	class << Equip
-		def build(str, s_level, c_level, left_associative: true)
-			str = Mgmg.check_string(str)
-			stack, str = build_sub0([], str)
-			build_sub(stack, str, s_level, c_level, left_associative)
-		end
-		private def build_sub0(stack, str)
-			SystemEquip.each do |k, v|
-				if SystemEquipRegexp[k].match(str)
-					stack << v
-					str = str.gsub(k, "<#{stack.length-1}>")
-				end
+		
+		class << self
+			def build(str, s_level, c_level, left_associative: true, include_system_equips: true)
+				str = Mgmg.check_string(str)
+				stack = []
+				stack, str = build_sub0(stack, str) if include_system_equips
+				build_sub(stack, str, s_level, c_level, left_associative)
 			end
-			[stack, str]
-		end
-		private def build_sub(stack, str, s_level, c_level, lassoc)
-			if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
-				stack << build_sub(stack, m[2], s_level, c_level, lassoc)
-				build_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", s_level, c_level, lassoc)
-			elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
-				if c_level < 0
-					compose(build_sub(stack, m[1], s_level, c_level, lassoc), build_sub(stack, m[2], s_level, c_level, lassoc), 0, true)
-				else
-					compose(build_sub(stack, m[1], s_level, c_level, lassoc), build_sub(stack, m[2], s_level, c_level, lassoc), c_level, false)
+			private def build_sub0(stack, str)
+				SystemEquip.each do |k, v|
+					if SystemEquipRegexp[k].match(str)
+						stack << v
+						str = str.gsub(k, "<#{stack.length-1}>")
+					end
 				end
-			elsif m = /\A\<(\d+)\>\Z/.match(str)
-				stack[m[1].to_i]
-			else
-				if s_level < 0
-					smith(str, 0, true)
+				[stack, str]
+			end
+			private def build_sub(stack, str, s_level, c_level, lassoc)
+				if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
+					stack << build_sub(stack, m[2], s_level, c_level, lassoc)
+					build_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", s_level, c_level, lassoc)
+				elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
+					if c_level < 0
+						compose(build_sub(stack, m[1], s_level, c_level, lassoc), build_sub(stack, m[2], s_level, c_level, lassoc), 0, true)
+					else
+						compose(build_sub(stack, m[1], s_level, c_level, lassoc), build_sub(stack, m[2], s_level, c_level, lassoc), c_level, false)
+					end
+				elsif m = /\A\<(\d+)\>\Z/.match(str)
+					stack[m[1].to_i]
 				else
-					smith(str, s_level, false)
+					if s_level < 0
+						smith(str, 0, true)
+					else
+						smith(str, s_level, false)
+					end
 				end
 			end
-		end
-		
-		def compose(main, sub, level, outsourcing)
-			main_k, sub_k = main.kind, sub.kind
-			main_s, sub_s = main.star, sub.star
-			main_main, sub_main = main.main, sub.main
-			main_sub, sub_sub = main.sub, sub.sub
-			para = Vec.new(9, 0)
-			ele = Vec.new(3, 0)
-			
-			# 9パラメータ
-			coef = Equip9[main_k].dup
-			para[] = coef
-			para.add!(level).e_div!(2)
-			para.e_mul!(sub.para).e_div!(100)
-			coef.sub!(Equip9[sub_k])
-			coef.add!( 100 + (main_s-sub_s)*5 - ( ( main_main==sub_main && main_main != 9 ) ? 30 : 0 ) )
-			coef.add!(Material9[main_main]).sub!(Material9[sub_main])
-			coef.e_mul!(EquipFilter[main_k])
-			para.e_mul!(coef).e_div!( main_k==sub_k ? 200 : 100 )
-			para.add!(main.para)
 			
-			# エレメント
-			ele[] = sub.element
-			ele.e_mul!([75, level].min).e_div!( main_k==sub_k ? 200 : 100 )
-			ele.add!(main.element)
-			
-			ret = new(main_k, main.weight+sub.weight, main_s+sub_s, main_sub, sub_main, para, ele)
-			ret.total_cost.add!(main.total_cost).add!(sub.total_cost)
-			cc = ret.comp_cost(outsourcing)
-			ret.total_cost[1] += cc
-			ret.total_cost[main_k < 8 ? 0 : 2] += cc
-			ret.min_levels.merge!(main.min_levels, sub.min_levels)
-			ret.history = [*main.history, *sub.history, ret]
-			ret
-		end
-		
-		def smith(str, level, outsourcing)
-			str = Mgmg.check_string(str)
-			unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
-				raise InvalidSmithError.new(str)
-			end
-			kind = EquipIndex[m[1].to_sym]
-			unless kind
-				raise InvalidEquipClassError.new(m[1])
+			def compose(main, sub, level, outsourcing)
+				main_k, sub_k = main.kind, sub.kind
+				main_s, sub_s = main.star, sub.star
+				main_main, sub_main = main.main, sub.main
+				main_sub, sub_sub = main.sub, sub.sub
+				para = Vec.new(9, 0)
+				ele = Vec.new(3, 0)
+				
+				# 9パラメータ
+				coef = Equip9[main_k].dup
+				para[] = coef
+				para.add!(level).e_div!(2)
+				para.e_mul!(sub.para).e_div!(100)
+				coef.sub!(Equip9[sub_k])
+				coef.add!( 100 + (main_s-sub_s)*5 - ( ( main_main==sub_main && main_main != 9 ) ? 30 : 0 ) )
+				coef.add!(Material9[main_main]).sub!(Material9[sub_main])
+				coef.e_mul!(EquipFilter[main_k])
+				para.e_mul!(coef).e_div!( main_k==sub_k ? 200 : 100 )
+				para.add!(main.para)
+				
+				# エレメント
+				ele[] = sub.element
+				ele.e_mul!([75, level].min).e_div!( main_k==sub_k ? 200 : 100 )
+				ele.add!(main.element)
+				
+				ret = new(main_k, main.weight+sub.weight, main_s+sub_s, main_sub, sub_main, para, ele)
+				ret.total_cost.add!(main.total_cost).add!(sub.total_cost)
+				cc = ret.comp_cost(outsourcing)
+				ret.total_cost[1] += cc
+				ret.total_cost[main_k < 8 ? 0 : 2] += cc
+				ret.min_levels.merge!(main.min_levels, sub.min_levels)
+				ret.history = [*main.history, *sub.history, ret]
+				ret
 			end
-			main_m, main_s, main_mc = Mgmg.parse_material(m[2])
-			sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
-			para = Vec.new(9, 0)
-			ele = Vec.new(3, 0)
 			
-			# 9パラメータ
-			para[] = Equip9[kind]
-			para.e_mul!(Main9[main_m]).e_div!(100)
-			coef = Sub9[sub_m].dup
-			coef.add!(level)
-			para.e_mul!(coef).e_div!( main_mc==sub_mc ? 200 : 100 )
-			
-			# エレメント
-			ele[] = MainEL[main_m]
-			ele.e_mul!(SubEL[sub_m]).e_div!(6)
-			
-			# 重量
-			weight = ( ( EquipWeight[kind] + SubWeight[sub_m] - level.div(2) ) * ( MainWeight[main_m] ) ).div(10000)
-			
-			ret = new(kind, ( weight<1 ? 1 : weight ), (main_s+sub_s).div(2), main_mc, sub_mc, para, ele)
-			ret.total_cost[kind < 8 ? 0 : 2] += ret.smith_cost(outsourcing)
-			ret.min_levels.store(str, Equip.min_level(str))
-			ret
-		end
-		
-		def min_level(str, weight=1)
-			str = Mgmg.check_string(str)
-			unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
-				raise InvalidSmithError.new(str)
+			def smith(str, level, outsourcing)
+				str = Mgmg.check_string(str)
+				return Cache[str].dup if level==0 && Cache.has_key?(str)
+				unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
+					raise InvalidSmithError.new(str)
+				end
+				kind = EquipIndex[m[1].to_sym]
+				unless kind
+					raise InvalidEquipClassError.new(m[1])
+				end
+				main_m, main_s, main_mc = Mgmg.parse_material(m[2])
+				sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
+				para = Vec.new(9, 0)
+				ele = Vec.new(3, 0)
+				
+				# 9パラメータ
+				para[] = Equip9[kind]
+				para.e_mul!(Main9[main_m]).e_div!(100)
+				coef = Sub9[sub_m].dup
+				coef.add!(level)
+				para.e_mul!(coef).e_div!( main_mc==sub_mc ? 200 : 100 )
+				
+				# エレメント
+				ele[] = MainEL[main_m]
+				ele.e_mul!(SubEL[sub_m]).e_div!(6)
+				
+				# 重量
+				weight = ( ( EquipWeight[kind] + SubWeight[sub_m] - level.div(2) ) * ( MainWeight[main_m] ) ).div(10000)
+				
+				ret = new(kind, ( weight<1 ? 1 : weight ), (main_s+sub_s).div(2), main_mc, sub_mc, para, ele)
+				ret.total_cost[kind < 8 ? 0 : 2] += ret.smith_cost(outsourcing)
+				ret.min_levels.store(str, Equip.min_level(str))
+				Cache.store(str, ret.freeze) if level==0
+				ret.dup
 			end
-			kind = EquipIndex[m[1].to_sym]
-			main_m, main_s, = Mgmg.parse_material(m[2])
-			sub_m, sub_s, = Mgmg.parse_material(m[3])
 			
-			q, r = ((weight+1)*10000).divmod(MainWeight[main_m])
-			l = ( EquipWeight[kind] + SubWeight[sub_m] - q + ( r==0 ? 1 : 0 ) )*2
-			[(main_s-1)*3, (sub_s-1)*3, l].max
-		end
-		
-		def min_comp(str, opt: Option.new)
-			str = Mgmg.check_string(str)
-			stack, str = minc_sub0([], str)
-			(minc_sub(stack, str, opt.left_associative)[1]-1)*3
-		end
-		private def minc_sub0(stack, str)
-			SystemEquip.each do |k, v|
-				if SystemEquipRegexp[k].match(str)
-					stack << v.star
-					str = str.gsub(k, "<#{stack.length-1}>")
+			def min_level(str, weight=1)
+				str = Mgmg.check_string(str)
+				return CacheML[str] if CacheML.has_key?(str)
+				unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
+					raise InvalidSmithError.new(str)
 				end
+				kind = EquipIndex[m[1].to_sym]
+				main_m, main_s, = Mgmg.parse_material(m[2])
+				sub_m, sub_s, = Mgmg.parse_material(m[3])
+				
+				q, r = ((weight+1)*10000).divmod(MainWeight[main_m])
+				l = ( EquipWeight[kind] + SubWeight[sub_m] - q + ( r==0 ? 1 : 0 ) )*2
+				ret = [(main_s-1)*3, (sub_s-1)*3, l].max
+				CacheML.store(str, ret)
+				ret
 			end
-			[stack, str]
-		end
-		private def minc_sub(stack, str, lassoc)
-			if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
-				stack << minc_sub(stack, m[2], lassoc)[0]
-				minc_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", lassoc)
-			elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
-				a, _ = minc_sub(stack, m[1], lassoc)
-				b, _ = minc_sub(stack, m[2], lassoc)
-				[a+b, [a, b].max]
-			elsif m = /\A\<(\d+)\>\Z/.match(str)
-				[stack[m[1].to_i], 1]
-			else
-				[smith(str, 0, true).star, 1]
+			
+			def min_comp(str, opt: Option.new)
+				str = Mgmg.check_string(str)
+				stack = []
+				stack, str = minc_sub0(stack, str) if opt.include_system_equips
+				(minc_sub(stack, str, opt.left_associative)[1]-1)*3
 			end
-		end
-		
-		def min_smith(str, opt: Option.new)
-			str = Mgmg.check_string(str)
-			stack, str = mins_sub0([], str)
-			ret = (([mins_sub(stack, str, opt.left_associative)]+stack).max-1)*3
-			ret < 0 ? -1 : ret
-		end
-		private def mins_sub0(stack, str)
-			SystemEquip.each do |k, v|
-				if SystemEquipRegexp[k].match(str)
-					stack << 0
-					str = str.gsub(k, "<#{stack.length-1}>")
+			private def minc_sub0(stack, str)
+				SystemEquip.each do |k, v|
+					if SystemEquipRegexp[k].match(str)
+						stack << v.star
+						str = str.gsub(k, "<#{stack.length-1}>")
+					end
 				end
+				[stack, str]
 			end
-			[stack, str]
-		end
-		private def mins_sub(stack, str, lassoc)
-			if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
-				stack << mins_sub(stack, m[2], lassoc)
-				mins_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", lassoc)
-			elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
-				[mins_sub(stack, m[1], lassoc), mins_sub(stack, m[2], lassoc)].max
-			elsif m = /\A\<(\d+)\>\Z/.match(str)
-				0
-			else
-				mins_sub2(str)
+			private def minc_sub(stack, str, lassoc)
+				if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
+					stack << minc_sub(stack, m[2], lassoc)[0]
+					minc_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", lassoc)
+				elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
+					a, _ = minc_sub(stack, m[1], lassoc)
+					b, _ = minc_sub(stack, m[2], lassoc)
+					[a+b, [a, b].max]
+				elsif m = /\A\<(\d+)\>\Z/.match(str)
+					[stack[m[1].to_i], 1]
+				else
+					[smith(str, 0, true).star, 1]
+				end
 			end
-		end
-		private def mins_sub2(str)
-			str = Mgmg.check_string(str)
-			unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
-				raise InvalidSmithError.new(str)
+			
+			def min_smith(str, opt: Option.new)
+				str = Mgmg.check_string(str)
+				stack = []
+				stack, str = mins_sub0(stack, str) if opt.include_system_equips
+				ret = (([mins_sub(stack, str, opt.left_associative)]+stack).max-1)*3
+				ret < 0 ? -1 : ret
 			end
-			kind = EquipIndex[m[1].to_sym]
-			unless kind
-				raise InvalidEquipClassError.new(m[1])
+			private def mins_sub0(stack, str)
+				SystemEquip.each do |k, v|
+					if SystemEquipRegexp[k].match(str)
+						stack << 0
+						str = str.gsub(k, "<#{stack.length-1}>")
+					end
+				end
+				[stack, str]
+			end
+			private def mins_sub(stack, str, lassoc)
+				if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
+					stack << mins_sub(stack, m[2], lassoc)
+					mins_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", lassoc)
+				elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
+					[mins_sub(stack, m[1], lassoc), mins_sub(stack, m[2], lassoc)].max
+				elsif m = /\A\<(\d+)\>\Z/.match(str)
+					0
+				else
+					mins_sub2(str)
+				end
+			end
+			private def mins_sub2(str)
+				str = Mgmg.check_string(str)
+				unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
+					raise InvalidSmithError.new(str)
+				end
+				kind = EquipIndex[m[1].to_sym]
+				unless kind
+					raise InvalidEquipClassError.new(m[1])
+				end
+				main_m, main_s, main_mc = Mgmg.parse_material(m[2])
+				sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
+				[main_s, sub_s].max
 			end
-			main_m, main_s, main_mc = Mgmg.parse_material(m[2])
-			sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
-			[main_s, sub_s].max
 		end
 	end
 end

data/lib/mgmg/ir.rb

@@ -1,6 +1,7 @@
 module Mgmg
 	using Refiner
 	class IR
+		Cache = Hash.new
 		class Const
 			def initialize(value)
 				@value = value
@@ -94,44 +95,44 @@ module Mgmg
 			def to_s
 				@body.map(&:to_s).join('+')
 			end
-		end
-		class << Multi
-			def sum(a, b)
-				unconsts, const = [], Const.new(0)
-				case a
-				when Multi
-					if a.body[0].kind_of?(Const)
-						const.value += a.body[0].value
-						unconsts = a.body[1..(-1)]
+			class << self
+				def sum(a, b)
+					unconsts, const = [], Const.new(0)
+					case a
+					when Multi
+						if a.body[0].kind_of?(Const)
+							const.value += a.body[0].value
+							unconsts = a.body[1..(-1)]
+						else
+							unconsts = a.body.dup
+						end
+					when Const
+						const.value += a.value
 					else
-						unconsts = a.body.dup
+						unconsts << a
 					end
-				when Const
-					const.value += a.value
-				else
-					unconsts << a
-				end
-				case b
-				when Multi
-					if b.body[0].kind_of?(Const)
-						const.value += b.body[0].value
-						unconsts.concat(b.body[1..(-1)])
+					case b
+					when Multi
+						if b.body[0].kind_of?(Const)
+							const.value += b.body[0].value
+							unconsts.concat(b.body[1..(-1)])
+						else
+							unconsts.concat(b.body)
+						end
+					when Const
+						const.value += b.value
 					else
-						unconsts.concat(b.body)
+						unconsts << b
+					end
+					body = ( const.value == 0 ? unconsts : [const, *unconsts] )
+					case body.size
+					when 0
+						const
+					when 1
+						body[0]
+					else
+						new(body)
 					end
-				when Const
-					const.value += b.value
-				else
-					unconsts << b
-				end
-				body = ( const.value == 0 ? unconsts : [const, *unconsts] )
-				case body.size
-				when 0
-					const
-				when 1
-					body[0]
-				else
-					new(body)
 				end
 			end
 		end
@@ -315,87 +316,92 @@ module Mgmg
 		end
 		Zero = self.new(28, Vec.new(6, 0).freeze, 12, 12, Array.new(9){Const.new(0)}.freeze)
 		Zero.rein.freeze; Zero.freeze
-	end
-	class << IR
-		def build(str, left_associative: true, reinforcement: [])
-			str = Mgmg.check_string(str)
-			stack, str = build_sub0([], str)
-			build_sub(stack, str, left_associative).add_reinforcement(reinforcement)
-		end
-		private def build_sub0(stack, str)
-			SystemEquip.each do |k, v|
-				if SystemEquipRegexp[k].match(str)
-					stack << from_equip(v)
-					str = str.gsub(k, "<#{stack.length-1}>")
-				end
-			end
-			[stack, str]
-		end
-		private def build_sub(stack, str, lassoc)
-			if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
-				stack << build_sub(stack, m[2], lassoc)
-				build_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", lassoc)
-			elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
-				compose(build_sub(stack, m[1], lassoc), build_sub(stack, m[2], lassoc))
-			elsif m = /\A\<(\d+)\>\Z/.match(str)
-				stack[m[1].to_i]
-			else
-				smith(str)
-			end
-		end
 		
-		def compose(main, sub)
-			main_k, sub_k = main.kind, sub.kind
-			main_s, sub_s = main.star, sub.star
-			main_main, sub_main = main.main, sub.main
-			main_sub, sub_sub = main.sub, sub.sub
-			
-			coef = Equip9[main_k].dup
-			coef.sub!(Equip9[sub_k])
-			coef.add!( 100 + (main_s-sub_s)*5 - ( ( main_main==sub_main && main_main != 9 ) ? 30 : 0 ) )
-			coef.add!(Material9[main_main]).sub!(Material9[sub_main])
-			den = ( main_k==sub_k ? 200 : 100 )
-			para = Array.new(9) do |i|
-				if EquipFilter[main_k][i] == 0
-					main.para[i]
-				else
-					Mgmg::IR::Compose.new(main.para[i], sub.para[i], Equip9[main_k][i], coef[i], den)
+		class << self
+			def build(str, left_associative: true, reinforcement: [], include_system_equips: true)
+				str = Mgmg.check_string(str)
+				stack = []
+				stack, str = build_sub0(stack, str) if include_system_equips
+				build_sub(stack, str, left_associative).add_reinforcement(reinforcement)
+			end
+			private def build_sub0(stack, str)
+				SystemEquip.each do |k, v|
+					if SystemEquipRegexp[k].match(str)
+						stack << from_equip(v)
+						str = str.gsub(k, "<#{stack.length-1}>")
+					end
 				end
-			end
-			
-			new(main_k, main_s+sub_s, main_sub, sub_main, para)
-		end
-		def smith(str)
-			str = Mgmg.check_string(str)
-			unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
-				raise InvalidSmithError.new(str)
-			end
-			kind = EquipIndex[m[1].to_sym]
-			unless kind
-				raise InvalidEquipClassError.new(m[1])
-			end
-			main_m, main_s, main_mc = Mgmg.parse_material(m[2])
-			sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
-			sa = ( Mgmg::EquipPosition[kind] == 0 ? :s : :a )
-			
-			coef = Equip9[kind].dup
-			coef.e_mul!(Main9[main_m]).e_div!(100)
-			den = ( main_mc==sub_mc ? 200 : 100 )
-			para = Array.new(9) do |i|
-				if coef[i] == 0
-					Mgmg::IR::Const.new(0)
+				[stack, str]
+			end
+			private def build_sub(stack, str, lassoc)
+				if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
+					stack << build_sub(stack, m[2], lassoc)
+					build_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", lassoc)
+				elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
+					compose(build_sub(stack, m[1], lassoc), build_sub(stack, m[2], lassoc))
+				elsif m = /\A\<(\d+)\>\Z/.match(str)
+					stack[m[1].to_i]
 				else
-					Mgmg::IR::Smith.new(Sub9[sub_m][i], coef[i], den, sa)
+					smith(str)
 				end
 			end
 			
-			new(kind, (main_s+sub_s).div(2), main_mc, sub_mc, para)
-		end
-		def from_equip(equip)
-			para = equip.para.map do |value|
-				Mgmg::IR::Const.new(value)
+			def compose(main, sub)
+				main_k, sub_k = main.kind, sub.kind
+				main_s, sub_s = main.star, sub.star
+				main_main, sub_main = main.main, sub.main
+				main_sub, sub_sub = main.sub, sub.sub
+				
+				coef = Equip9[main_k].dup
+				coef.sub!(Equip9[sub_k])
+				coef.add!( 100 + (main_s-sub_s)*5 - ( ( main_main==sub_main && main_main != 9 ) ? 30 : 0 ) )
+				coef.add!(Material9[main_main]).sub!(Material9[sub_main])
+				den = ( main_k==sub_k ? 200 : 100 )
+				para = Array.new(9) do |i|
+					if EquipFilter[main_k][i] == 0
+						main.para[i]
+					else
+						Mgmg::IR::Compose.new(main.para[i], sub.para[i], Equip9[main_k][i], coef[i], den)
+					end
+				end
+				
+				new(main_k, main_s+sub_s, main_sub, sub_main, para)
+			end
+			def smith(str)
+				str = Mgmg.check_string(str)
+				return Cache[str].dup if Cache.has_key?(str)
+				unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
+					raise InvalidSmithError.new(str)
+				end
+				kind = EquipIndex[m[1].to_sym]
+				unless kind
+					raise InvalidEquipClassError.new(m[1])
+				end
+				main_m, main_s, main_mc = Mgmg.parse_material(m[2])
+				sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
+				sa = ( Mgmg::EquipPosition[kind] == 0 ? :s : :a )
+				
+				coef = Equip9[kind].dup
+				coef.e_mul!(Main9[main_m]).e_div!(100)
+				den = ( main_mc==sub_mc ? 200 : 100 )
+				para = Array.new(9) do |i|
+					if coef[i] == 0
+						Mgmg::IR::Const.new(0)
+					else
+						Mgmg::IR::Smith.new(Sub9[sub_m][i], coef[i], den, sa)
+					end
+				end
+				
+				ret = new(kind, (main_s+sub_s).div(2), main_mc, sub_mc, para)
+				Cache.store(str, ret.freeze)
+				ret.dup
+			end
+			def from_equip(equip)
+				para = equip.para.map do |value|
+					Mgmg::IR::Const.new(value)
+				end
+				new(equip.kind, equip.star, equip.main, equip.sub, para)
 			end
-			new(equip.kind, equip.star, equip.main, equip.sub, para)
 		end
 	end
 end

data/lib/mgmg/option.rb

@@ -1,11 +1,16 @@
 module Mgmg
 	class Option
+		Defaults = {
+			left_associative: true, include_system_equips: true,
+			smith_max: 10000, armor_max: 10000, comp_max: 10000
+		}
 		def initialize(
-			left_associative: true,
-			smith_min: nil, armor_min:nil, comp_min: nil, smith_max: 10000, armor_max: 10000, comp_max: 10000,
+			left_associative: Defaults[:left_associative],
+			smith_min: nil, armor_min:nil, comp_min: nil, smith_max: Defaults[:smith_max], armor_max: Defaults[:armor_max], comp_max: Defaults[:comp_max],
 			step: 1, magdef_maximize: true,
 			target_weight: 0, reinforcement: [], buff: nil,
-			irep: nil, cut_exp: Float::INFINITY
+			irep: nil, cut_exp: Float::INFINITY,
+			include_system_equips: Defaults[:include_system_equips]
 		)
 			@left_associative = left_associative
 			@smith_min = smith_min
@@ -27,9 +32,10 @@ module Mgmg
 			end
 			@irep = irep
 			@cut_exp = cut_exp
+			@include_system_equips = include_system_equips
 		end
 		attr_accessor :left_associative, :smith_min, :armor_min, :comp_min, :smith_max, :armor_max, :comp_max
-		attr_accessor :step, :magdef_maximize, :target_weight, :reinforcement, :irep, :cut_exp
+		attr_accessor :step, :magdef_maximize, :target_weight, :reinforcement, :irep, :cut_exp, :include_system_equips
 		def initialize_copy(other)
 			@left_associative = other.left_associative
 			@smith_min = other.smith_min
@@ -44,6 +50,7 @@ module Mgmg
 			@reinforcement = other.reinforcement.dup
 			@irep = other.irep
 			@cut_exp = other.cut_exp
+			@include_system_equips = other.include_system_equips
 		end
 		def update_sa_min(recipe, force=true)
 			case recipe
@@ -69,9 +76,11 @@ module Mgmg
 			self
 		end
 		def set_default(recipe, force: false)
+			@include_system_equips = false if @include_system_equips && !Mgmg::SystemEquipRegexp.values.any?{|re| re.match(recipe)}
 			update_sa_min(recipe, force)
 			@comp_min = recipe.min_comp(opt: self) if force || @comp_min.nil?
 			@irep = recipe.ir(opt: self) if force || @irep.nil?
+			
 			self
 		end
 		def buff
@@ -81,4 +90,10 @@ module Mgmg
 			@reinforcement = v
 		end
 	end
+	
+	module_function def option(recipe=nil, **kw)
+		ret = Option.new(**kw)
+		ret.set_default(recipe) unless recipe.nil?
+		ret
+	end
 end

data/lib/mgmg/poly.rb

@@ -1,6 +1,7 @@
 module Mgmg
 	using Refiner
 	class TPolynomial
+		Cache = Hash.new
 		def initialize(mat, kind, star, main_m, sub_m)
 			@mat, @kind, @star, @main, @sub = mat, kind, star, main_m, sub_m
 		end
@@ -285,71 +286,77 @@ module Mgmg
 				1
 			end
 		end
-	end
-	class << TPolynomial
-		ParamIndex = Hash.new
-		%i|attack phydef magdef hp mp str dex speed magic|.each.with_index do |s, i|
-			ParamIndex.store(s, i)
-			ParamIndex.store(i, i)
-			ParamIndex.store(Equip::ParamList[i], i)
-		end
-		def from_equip(equip, para)
-			new(Mat.new(1, 1, equip.para[ParamIndex[para]]), equip.kind, equip.star, equip.main, equip.sub)
-		end
-		def smith(str, para)
-			unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
-				raise ArgumentError.new("given string `#{str}' is unparsable as a smithing recipe")
+		
+		class << self
+			ParamIndex = Hash.new
+			%i|attack phydef magdef hp mp str dex speed magic|.each.with_index do |s, i|
+				ParamIndex.store(s, i)
+				ParamIndex.store(i, i)
+				ParamIndex.store(Equip::ParamList[i], i)
 			end
-			kind = EquipIndex[m[1].to_sym]
-			main_m, main_s, main_mc = Mgmg.parse_material(m[2])
-			sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
-			para = ParamIndex[para]
-			
-			c = ( Equip9[kind][para] * Main9[main_m][para] ).cdiv(100).quo( main_mc==sub_mc ? 200 : 100 )
-			new(Mat.v_array(c*Sub9[sub_m][para], c), kind, (main_s+sub_s).div(2), main_mc, sub_mc)
-		end
-		def compose(main, sub, para)
-			main_k, sub_k = main.kind, sub.kind
-			main_s, sub_s = main.star, sub.star
-			main_main, sub_main = main.main, sub.main
-			main_sub, sub_sub = main.sub, sub.sub
-			para = ParamIndex[para]
-			
-			if Equip9[main_k][para] == 0
-				c = 0.quo(1)
-			else
-				c = ( 100 + Equip9[main_k][para] - Equip9[sub_k][para] + Material9[main_main][para] - Material9[sub_main][para] +
-					(main_s-sub_s)*5 - ( ( main_main==sub_main && main_main != 9 ) ? 30 : 0 ) ).quo( main_k==sub_k ? 40000 : 20000 )
+			def from_equip(equip, para)
+				new(Mat.new(1, 1, equip.para[ParamIndex[para]]), equip.kind, equip.star, equip.main, equip.sub)
 			end
-			mat = main.mat.padd(sub.mat.pprod(Mat.h_array(c*Equip9[main_k][para], c)))
-			new(mat, main_k, main_s+sub_s, main_sub, sub_main)
-		end
-		def build(str, para, left_associative: true)
-			str = Mgmg.check_string(str)
-			_para = ParamIndex[para]
-			if _para.nil?
-				raise ArgumentError, "unknown parameter symbol `#{para.inspect}' given"
+			def smith(str, para)
+				key = [str.freeze, para].freeze
+				return Cache[key].dup if Cache.has_key?(key)
+				unless m = /\A(.+)\((.+\d+),?(.+\d+)\)\Z/.match(str)
+					raise ArgumentError.new("given string `#{str}' is unparsable as a smithing recipe")
+				end
+				kind = EquipIndex[m[1].to_sym]
+				main_m, main_s, main_mc = Mgmg.parse_material(m[2])
+				sub_m, sub_s, sub_mc = Mgmg.parse_material(m[3])
+				para = ParamIndex[para]
+				
+				c = ( Equip9[kind][para] * Main9[main_m][para] ).cdiv(100).quo( main_mc==sub_mc ? 200 : 100 )
+				ret = new(Mat.v_array(c*Sub9[sub_m][para], c), kind, (main_s+sub_s).div(2), main_mc, sub_mc)
+				Cache.store(key, ret.freeze)
+				ret.dup
 			end
-			stack, str = build_sub0([], str, _para)
-			build_sub(stack, str, _para, left_associative)
-		end
-		private def build_sub0(stack, str, para)
-			SystemEquip.each do |k, v|
-				stack << from_equip(v, para)
-				str = str.gsub(k, "<#{stack.length-1}>")
+			def compose(main, sub, para)
+				main_k, sub_k = main.kind, sub.kind
+				main_s, sub_s = main.star, sub.star
+				main_main, sub_main = main.main, sub.main
+				main_sub, sub_sub = main.sub, sub.sub
+				para = ParamIndex[para]
+				
+				if Equip9[main_k][para] == 0
+					c = 0.quo(1)
+				else
+					c = ( 100 + Equip9[main_k][para] - Equip9[sub_k][para] + Material9[main_main][para] - Material9[sub_main][para] +
+						(main_s-sub_s)*5 - ( ( main_main==sub_main && main_main != 9 ) ? 30 : 0 ) ).quo( main_k==sub_k ? 40000 : 20000 )
+				end
+				mat = main.mat.padd(sub.mat.pprod(Mat.h_array(c*Equip9[main_k][para], c)))
+				new(mat, main_k, main_s+sub_s, main_sub, sub_main)
 			end
-			[stack, str]
-		end
-		private def build_sub(stack, str, para, lassoc)
-			if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
-				stack << build_sub(stack, m[2], para, lassoc)
-				build_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", para, lassoc)
-			elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
-				compose(build_sub(stack, m[1], para, lassoc), build_sub(stack, m[2], para, lassoc), para)
-			elsif m = /\A\<(\d+)\>\Z/.match(str)
-				stack[m[1].to_i]
-			else
-				smith(str, para)
+			def build(str, para, left_associative: true, include_system_equips: true)
+				str = Mgmg.check_string(str)
+				_para = ParamIndex[para]
+				if _para.nil?
+					raise ArgumentError, "unknown parameter symbol `#{para.inspect}' given"
+				end
+				stack = []
+				stack, str = build_sub0(stack, str, _para) if include_system_equips
+				build_sub(stack, str, _para, left_associative)
+			end
+			private def build_sub0(stack, str, para)
+				SystemEquip.each do |k, v|
+					stack << from_equip(v, para)
+					str = str.gsub(k, "<#{stack.length-1}>")
+				end
+				[stack, str]
+			end
+			private def build_sub(stack, str, para, lassoc)
+				if m = /\A(.*\+?)\[([^\[\]]+)\](\+?[^\[]*)\Z/.match(str)
+					stack << build_sub(stack, m[2], para, lassoc)
+					build_sub(stack, "#{m[1]}<#{stack.length-1}>#{m[3]}", para, lassoc)
+				elsif m = ( lassoc ? /\A(.+)\+(.+?)\Z/ : /\A(.+?)\+(.+)\Z/ ).match(str)
+					compose(build_sub(stack, m[1], para, lassoc), build_sub(stack, m[2], para, lassoc), para)
+				elsif m = /\A\<(\d+)\>\Z/.match(str)
+					stack[m[1].to_i]
+				else
+					smith(str, para)
+				end
 			end
 		end
 	end

data/lib/mgmg/reinforce.rb

@@ -12,46 +12,45 @@ module Mgmg
 			'(' + @vec.map.with_index{|e, i| e==0 ? nil : "#{Equip::ParamList[i]}:#{e}"}.compact.join(', ') + ')'
 		end
 		alias :inspect :to_s
-	end
-	
-	#    スキル名                                   攻  物  防  HP  MP  腕  器  速  魔
-	Skill = {
-		'物防御UP'       => Reinforcement.new( Vec[  0, 10,  0,  0,  0,  0,  0,  0,  0] ),
-		'魔防御UP'       => Reinforcement.new( Vec[  0,  0, 10,  0,  0,  0,  0,  0,  0] ),
-		'腕力UP'         => Reinforcement.new( Vec[  0,  0,  0,  0,  0, 10,  0,  0,  0] ),
-		'メンテナンス'   => Reinforcement.new( Vec[ 50,  0,  0,  0,  0,  0,  0,  0,  0] ),
-		'ガードアップ'   => Reinforcement.new( Vec[  0, 50,  0,  0,  0,  0,  0,  0,  0] ),
-		'パワーアップ'   => Reinforcement.new( Vec[  0,  0,  0,  0,  0, 50,  0,  0,  0] ),
-		'デックスアップ' => Reinforcement.new( Vec[  0,  0,  0,  0,  0,  0, 50,  0,  0] ),
-		'スピードアップ' => Reinforcement.new( Vec[  0,  0,  0,  0,  0,  0,  0, 50,  0] ),
-		'マジックアップ' => Reinforcement.new( Vec[  0,  0,  0,  0,  0,  0,  0,  0, 50] ),
-		'オールアップ'   => Reinforcement.new( Vec[  0, 50,  0,  0,  0, 50, 50, 50, 50] ),
-	}
-	
-	class << Reinforcement
-		def cuisine(c)
-			Reinforcement.new( Vec[*(c.vec), *Array.new(6, 0)] )
-		end
-		def compile(arg)
-			case arg
-			when Reinforcement
-				arg
-			when Cuisine
-				cuisine(arg)
-			when String
-				if Skill.has_key?(arg)
-					Skill[arg]
-				elsif SystemCuisine.has_key?(arg)
-					cuisine(SystemCuisine[arg])
+		
+		#    スキル名                                   攻  物  防  HP  MP  腕  器  速  魔
+		Skill = {
+			'物防御UP'       => Reinforcement.new( Vec[  0, 10,  0,  0,  0,  0,  0,  0,  0] ),
+			'魔防御UP'       => Reinforcement.new( Vec[  0,  0, 10,  0,  0,  0,  0,  0,  0] ),
+			'腕力UP'         => Reinforcement.new( Vec[  0,  0,  0,  0,  0, 10,  0,  0,  0] ),
+			'メンテナンス'   => Reinforcement.new( Vec[ 50,  0,  0,  0,  0,  0,  0,  0,  0] ),
+			'ガードアップ'   => Reinforcement.new( Vec[  0, 50,  0,  0,  0,  0,  0,  0,  0] ),
+			'パワーアップ'   => Reinforcement.new( Vec[  0,  0,  0,  0,  0, 50,  0,  0,  0] ),
+			'デックスアップ' => Reinforcement.new( Vec[  0,  0,  0,  0,  0,  0, 50,  0,  0] ),
+			'スピードアップ' => Reinforcement.new( Vec[  0,  0,  0,  0,  0,  0,  0, 50,  0] ),
+			'マジックアップ' => Reinforcement.new( Vec[  0,  0,  0,  0,  0,  0,  0,  0, 50] ),
+			'オールアップ'   => Reinforcement.new( Vec[  0, 50,  0,  0,  0, 50, 50, 50, 50] ),
+		}
+		
+		class << self
+			def cuisine(c)
+				Reinforcement.new( Vec[*(c.vec), *Array.new(6, 0)] )
+			end
+			def compile(arg)
+				case arg
+				when Reinforcement
+					arg
+				when Cuisine
+					cuisine(arg)
+				when String
+					if Skill.has_key?(arg)
+						Skill[arg]
+					elsif SystemCuisine.has_key?(arg)
+						cuisine(SystemCuisine[arg])
+					else
+						raise InvalidReinforcementNameError, arg
+					end
 				else
-					raise InvalidReinforcementNameError, arg
+					raise ArgumentError, "The argument should be Mgmg::Cuisine or skill name String. (`#{arg}' is given)"
 				end
-			else
-				raise ArgumentError, "The argument should be Mgmg::Cuisine or skill name String. (`#{arg}' is given)"
 			end
 		end
 	end
-	
 	class Equip
 		def reinforce(*arg)
 			arg.each do |r|

data/lib/mgmg/utils.rb

@@ -153,10 +153,9 @@ module Mgmg
 	module_function def invexp3(exp, sa, comp)
 		Math.sqrt(exp - ((sa-1)**2) - (2*((comp-1)**2)) - 4).round + 1
 	end
-	module_function def option(recipe=nil, **kw)
-		ret = Option.new(**kw)
-		ret.set_default(recipe) unless recipe.nil?
-		ret
+	module_function def clear_cache
+		CacheMLS.clear; Equip::Cache.clear; Equip::CacheML.clear; TPolynomial::Cache.clear; IR::Cache.clear
+		nil
 	end
 	
 	CharacterList = /[^\(\)\+0123456789\[\]あきくしすたてなねのびりるイウガクグサジスタダチツデトドニノフブペボムラリルロンヴー一万二光兜典刀剣劣匠双古名吹咆品哮地大天太子安宝小帽弓弩当息悪戦手指斧書服木本杖業樹歴殺水氷法火炎牙物玉王産用界異的皮盾短石砕竜紫綿耳聖脛腕腿般良色衣袋覇質軍軽輝輪重量金鉄鎧闇陽靴額飾首骨鬼龍]/.freeze

data/lib/mgmg/version.rb

@@ -1,3 +1,3 @@
 module Mgmg
-	VERSION = "1.5.3"
+	VERSION = "1.5.4"
 end

data/lib/mgmg.rb

@@ -30,6 +30,13 @@ class String
 		end
 	end
 	def min_level(w=0, include_outsourcing=false, opt: Mgmg::Option.new)
+		key = [self.dup.freeze, w, include_outsourcing, opt.left_associative].freeze
+		return Mgmg::CacheMLS[key] if Mgmg::CacheMLS.has_key?(key)
+		ret = __min_level_sub(w, include_outsourcing, opt)
+		Mgmg::CacheMLS.store(key, ret)
+		ret
+	end
+	private def __min_level_sub(w, include_outsourcing, opt)
 		built = build(-1, opt:)
 		w = build(built.min_levels_max, -1, opt:).weight - w if w <= 0
 		return -1 if include_outsourcing && built.weight <= w
@@ -59,10 +66,10 @@ class String
 		Mgmg::Equip.min_comp(self, opt:)
 	end
 	def build(smith=-1, comp=smith, opt: Mgmg::Option.new)
-		Mgmg::Equip.build(self, smith, comp, left_associative: opt.left_associative).reinforce(*opt.reinforcement)
+		Mgmg::Equip.build(self, smith, comp, left_associative: opt.left_associative, include_system_equips: opt.include_system_equips).reinforce(*opt.reinforcement)
 	end
 	def ir(opt: Mgmg::Option.new)
-		Mgmg::IR.build(self, left_associative: opt.left_associative, reinforcement: opt.reinforcement)
+		Mgmg::IR.build(self, left_associative: opt.left_associative, reinforcement: opt.reinforcement, include_system_equips: opt.include_system_equips)
 	end
 	def poly(para=:cost, opt: Mgmg::Option.new)
 		case para
@@ -83,7 +90,7 @@ class String
 			md = self.poly(:magmag, opt:)
 			pd <= md ? pd : md
 		when :cost
-			if Mgmg::SystemEquip.has_key?(self)
+			if opt.include_system_equips and Mgmg::SystemEquip.has_key?(self) then
 				return Mgmg::TPolynomial.new(Mgmg::Mat.new(1, 1, 0.quo(1)), 28, 0, 12, 12)
 			end
 			built = self.build(-1, opt:)
@@ -94,7 +101,7 @@ class String
 			ret.mat.body[0][0] += const
 			ret
 		else
-			Mgmg::TPolynomial.build(self, para, left_associative: opt.left_associative)
+			Mgmg::TPolynomial.build(self, para, left_associative: opt.left_associative, include_system_equips: opt.include_system_equips)
 		end
 	end
 	def eff(para, smith, comp=smith, opt: Mgmg::Option.new)

data/reference.md

@@ -19,23 +19,23 @@
 
 `self`が解釈不能な場合，例外が発生します．また，製作Lvや完成品の☆制限のチェックを行っていないほか，本ライブラリでは`武器+防具`や`防具+武器`の合成も可能になっています．街の鍛冶・防具製作・道具製作屋に任せた場合をシミュレートする場合は製作Lvを負の値(`-1`など，負であれば何でもよい)にします(製作Lv0相当の性能を計算し，消費エレメント量は委託仕様となります)．
 
-`opt`は，`left_associative`のみ使用します．
+`opt`は，`left_associative`と`include_system_equips`のみ使用します．
 
 ## `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として計算した上で，消費エレメント量は街の製作屋に頼んだ場合の値を計算します．武器複数など，同時装備が不可能な場合でも，特にチェックはされません．
 
-`opt`は，`left_associative`のみ使用します．
+`opt`は，`left_associative`と`include_system_equips`のみ使用します．
 
 ## `String#min_weight(opt: Mgmg.option())`
 製作可能な最小重量を返します．基本的には合成回数+1ですが，既製品を含む場合はその限りではありません．
 
-製作を行うため，`opt`が指定可能ですが，特に結果には影響しません．
+`opt`は，`include_system_equips`のみ使用します．
 
 ## `String#max_weight(include_outsourcing=false, opt: Mgmg.option())`
 製作可能な最大重量を返します．`include_outsourcing`が真の場合，委託製作時の重量を返します．
 委託製作では，製作Lv0相当となるため，素材の☆による最低製作Lvで作るよりも重くなる場合があります．
 
-製作を行うため，`opt`が指定可能ですが，特に結果には影響しません．
+`opt`は，`include_system_equips`のみ使用します．
 
 ## `String#min_level(w=0, include_outsourcing=false, opt: Mgmg.option())`
 `self`を重量`w`以下で作るための最低製作Lvを返します．
@@ -60,12 +60,12 @@
 ## `Enumerable#min_levels(weight=1, opt: Mgmg.option())`
 すべての要素`str`に対する`str.min_levels`をマージした`Hash`を返します．
 
-製作を行うため，`opt`が指定可能ですが，特に結果には影響しません．
+`opt`は，`include_system_equips`のみ使用します．
 
 ## `Enumerable#min_levels_max(weight=1, opt: Mgmg.option())`
 `self.min_levels`から武器，防具それぞれに対する最大値を求め，`[必要最小鍛冶Lv, 必要最小防具製作Lv]`を返します．武器，防具の一方のみが含まれる場合，もう一方は`-1`になります．
 
-製作を行うため，`opt`が指定可能ですが，特に結果には影響しません．
+`opt`は，`include_system_equips`のみ使用します．
 
 ## `String#min_comp(opt: Mgmg.option())`，`Enumerable#min_comp(opt: Mgmg.option())`
 レシピ通りに合成するのに必要な道具製作Lvを返します．ただし，全体が「[]」で囲われているか，非合成レシピの場合，代わりに`-1`を返します．
@@ -79,7 +79,7 @@
 
 `Enumerable`の場合，すべての要素に対し，武器，防具それぞれの最大値を求め，`[必要最小鍛冶Lv, 必要最小防具製作Lv]`を返します．武器，防具の一方のみが含まれる場合，もう一方は`-1`になります．
 
-製作を行うため，`opt`が指定可能ですが，特に結果には影響しません．
+`opt`は，`include_system_equips`のみ使用します．
 
 ## `String#poly(para=:cost, opt: Mgmg.option())`
 レシピ文字列である`self`を解釈し，`para`で指定した9パラ値について，丸めを無視した鍛冶・防具製作Lvと道具製作Lvの2変数からなる多項式関数を示す`Mgmg::TPolynomial`クラスのインスタンスを生成し，返します．`para`は次のシンボルのいずれかを指定します．
@@ -96,17 +96,17 @@
 
 また，`:cost`を渡すことで，消費エレメント量に関する近似多項式を得られます．`self`に`"+"`が含まれていれば合成品とみなし，最後の合成に必要な地エレメント量を，それ以外では，武器なら消費火エレメント量を，防具なら消費水エレメント量を返します．ただし，`self`が既成品そのものの場合，零多項式を返します．
 
-`opt`は，`left_associative`のみ使用します．
+`opt`は，`left_associative`と`include_system_equips`のみ使用します．
 
 ## `String#ir(opt: Mgmg.option())`
 レシピ文字列である`self`を解釈し，9パラ値について，丸めを考慮した鍛冶・防具製作Lvと道具製作Lvの2変数からなる関数オブジェクトを保持する`Mgmg::IR`クラスのインスタンスを生成し，返します．詳しくは，[後述](#mgmgir)の`Mgmg::IR`クラスの説明を参照ください．
 
-`opt`は，`left_associative`と`reinforcement`を使用します．
+`opt`は，`left_associative`と`include_system_equips`，`reinforcement`を使用します．
 
 ## `Enumerable#ir(opt: Mgmg.option())`
 複数のレシピ文字列からなる`self`の各要素を製作し，そのすべてを装備したときの`Mgmg::IR`を返します．この場合，鍛冶Lv，防具製作Lv，道具製作Lvの3変数からなる関数オブジェクトを保持するものとして扱われます．各装備の種別に応じ，鍛冶Lvまたは防具製作Lvを適用し，9パラ値を計算します．
 
-`opt`は，`left_associative`と`reinforcement`を使用します．
+`opt`は，`left_associative`と`include_system_equips`，`reinforcement`を使用します．
 
 ## `String#smith_seach(para, target, comp, opt: Mgmg.option())`
 `para`の値が`target`以上となるのに必要な最小の鍛冶・防具製作Lvを二分探索で探索して返します．
@@ -441,21 +441,23 @@ alias として`*`があるほか`scalar(1.quo(value))`として`quo`，`/`，`s
 ## `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`など，内部的に使用|
+`Defaults`対応が「対応」となっているキーワード引数については，`Mgmg::Option::Defaults[:include_system_equips]=false`などとすることで，デフォルト値をグローバルに変更することができます．デフォルト値にかかわらず，メソッド呼び出し時に個別に指定すればその値が優先されます．
+
+|キーワード|デフォルト値|`Defaults`対応|意味|主なメソッド，備考|
+|:-|:-|:-|:-|:-|
+|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`など，内部的に使用|
+|include_system_equips|`true`|対応|レシピ解釈時に，既製品を受け付ける|`Mgmg::Option`を使用するすべてのメソッド|
 
 ## `Mgmg::Recipe`
 レシピ文字列，注目パラメータ，オプションをセットにして扱うためのクラスです．

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mgmg
 version: !ruby/object:Gem::Version
-  version: 1.5.3
+  version: 1.5.4
 platform: ruby
 authors:
 - KAZOON
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-28 00:00:00.000000000 Z
+date: 2022-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler