mgmg 1.5.1 → 1.5.4

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/optimize.rb

@@ -4,9 +4,9 @@ module Mgmg
 		InvList = [%w|帽子 フード サンダル|.freeze, %w|宝1 骨1 木1 木2 骨2|.freeze, %w|宝1 骨1 木1|.freeze].freeze
 		def phydef_optimize(str, smith, comp=smith, opt: Option.new)
 			best = if smith.nil? then
-				[str, str.poly(:phydef, opt: opt), str.poly(:magdef, opt: opt), str.poly(:cost, opt: opt)]
+				[str, str.poly(:phydef, opt:), str.poly(:magdef, opt:), str.poly(:cost, opt:)]
 			else
-				[str, str.build(smith, comp, opt: opt)]
+				[str, str.build(smith, comp, opt:)]
 			end
 			str = Mgmg.check_string(str)
 			ai = 0
@@ -23,7 +23,7 @@ module Mgmg
 			m = /([^\+]*\([^\(]+[綿皮]1\))\]*\Z/.match(str)
 			if m
 				if smith
-					if m[1].sub(/綿1\)/, '皮1)').build(smith, opt: opt).weight == m[1].sub(/皮1\)/, '綿1)').build(smith, opt: opt).weight
+					if m[1].sub(/綿1\)/, '皮1)').build(smith, opt:).weight == m[1].sub(/皮1\)/, '綿1)').build(smith, opt:).weight
 						skin = true
 					end
 				else
@@ -40,9 +40,9 @@ module Mgmg
 				while b
 					r = pd_apply_idx(str, a, b)
 					best = if smith.nil? then
-						pd_better(best, [r, r.poly(:phydef, opt: opt), r.poly(:magdef, opt: opt), r.poly(:cost, opt: opt)], opt.magdef_maximize)
+						pd_better(best, [r, r.poly(:phydef, opt:), r.poly(:magdef, opt:), r.poly(:cost, opt:)], opt.magdef_maximize)
 					else
-						pd_better(best, [r, r.build(smith, comp, opt: opt)], opt.magdef_maximize)
+						pd_better(best, [r, r.build(smith, comp, opt:)], opt.magdef_maximize)
 					end
 					b = pd_next_b(b)
 				end
@@ -58,9 +58,9 @@ module Mgmg
 					while b
 						r = pd_apply_idx(str, a, b)
 						best = if smith.nil? then
-							pd_better(best, [r, r.poly(:phydef, opt: opt), r.poly(:magdef, opt: opt), r.poly(:cost, opt: opt)], opt.magdef_maximize)
+							pd_better(best, [r, r.poly(:phydef, opt:), r.poly(:magdef, opt:), r.poly(:cost, opt:)], opt.magdef_maximize)
 						else
-							pd_better(best, [r, r.build(smith, comp, opt: opt)], opt.magdef_maximize)
+							pd_better(best, [r, r.build(smith, comp, opt:)], opt.magdef_maximize)
 						end
 						b = pd_next_b(b)
 					end
@@ -159,7 +159,7 @@ module Mgmg
 		
 		MwList = %w|綿 皮 骨 木 水|.freeze
 		def buster_optimize(str, smith, comp=smith, opt: Option.new)
-			best = ( smith.nil? ? [str, str.poly(:mag_das, opt: opt)] : [str, str.build(smith, comp, opt: opt)] )
+			best = ( smith.nil? ? [str, str.poly(:mag_das, opt:)] : [str, str.build(smith, comp, opt:)] )
 			str = Mgmg.check_string(str)
 			ai = -1
 			org = nil
@@ -174,7 +174,7 @@ module Mgmg
 			a = Array.new(ai){ [0, 0, 0] }
 			while a
 				r = bus_apply_idx(str, a)
-				best = bus_better(best, ( smith.nil? ? [r, r.poly(:mag_das, opt: opt)] : [r, r.build(smith, comp, opt: opt)] ))
+				best = bus_better(best, ( smith.nil? ? [r, r.poly(:mag_das, opt:)] : [r, r.build(smith, comp, opt:)] ))
 				a = bus_next_a(a)
 			end
 			best[0]

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/recipe.rb

@@ -30,7 +30,7 @@ module Mgmg
 			end
 		end
 		def option(**kw)
-			@option = temp_opt(*kw)
+			@option = temp_opt(**kw)
 			@option
 		end
 		def option=(new_option)
@@ -70,9 +70,9 @@ module Mgmg
 			smith, armor, comp = opt.smith_min, opt.armor_min, opt.comp_min if smith.nil?
 			case @recipe
 			when String
-				recipe.build(smith, comp, opt: opt)
+				recipe.build(smith, comp, opt:)
 			when Enumerable
-				recipe.build(smith, armor, comp, opt: opt)
+				recipe.build(smith, armor, comp, opt:)
 			else
 				raise BrokenRecipeError
 			end
@@ -82,16 +82,16 @@ module Mgmg
 			smith, armor, comp = opt.smith_min, opt.armor_min, opt.comp_min if smith.nil?
 			case @recipe
 			when String
-				recipe.show(smith, comp, para: para, opt: opt)
+				recipe.show(smith, comp, para:, opt:)
 			when Enumerable
-				recipe.show(smith, armor, comp, para: para, opt: opt)
+				recipe.show(smith, armor, comp, para:, opt:)
 			else
 				raise BrokenRecipeError
 			end
 		end
 		def search(target, para: @para, **kw)
 			opt = temp_opt(**kw)
-			@recipe.search(para, target, opt: opt)
+			@recipe.search(para, target, opt:)
 		end
 		private def correct_level(s, ac, x, opt)
 			if s.nil?
@@ -147,7 +147,7 @@ module Mgmg
 		def poly(para=@para, **kw)
 			opt = temp_opt(**kw)
 			if @recipe.kind_of?(String)
-				@recipe.poly(para, opt: opt)
+				@recipe.poly(para, opt:)
 			else
 				raise InvalidRecipeError, "Mgmg::Recipe#poly is available only for String recipes."
 			end
@@ -155,7 +155,7 @@ module Mgmg
 		def phydef_optimize(smith=nil, comp=smith, **kw)
 			opt = temp_opt(**kw)
 			if @recipe.kind_of?(String)
-				@recipe.phydef_optimize(smith, comp, opt: opt)
+				@recipe.phydef_optimize(smith, comp, opt:)
 			else
 				raise InvalidRecipeError, "Mgmg::Recipe#phydef_optimize is available only for String recipes."
 			end
@@ -163,7 +163,7 @@ module Mgmg
 		def buster_optimize(smith=nil, comp=smith, **kw)
 			opt = temp_opt(**kw)
 			if @recipe.kind_of?(String)
-				@recipe.buster_optimize(smith, comp, opt: opt)
+				@recipe.buster_optimize(smith, comp, opt:)
 			else
 				raise InvalidRecipeError, "Mgmg::Recipe#buster_optimize is available only for String recipes."
 			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|