mgmg 1.4.0 → 1.5.0

data/lib/mgmg/equip.rb

@@ -9,7 +9,7 @@ module Mgmg
 			@total_cost = Vec[0, 0, 0]
 			@history, @min_levels = [self], Hash.new
 		end
-		attr_accessor :kind, :weight, :star, :main, :sub, :para, :element, :total_cost, :history, :min_levels
+		attr_accessor :kind, :weight, :star, :main, :sub, :para, :element, :total_cost, :history
 		def initialize_copy(other)
 			@kind = other.kind
 			@weight = other.weight
@@ -52,11 +52,20 @@ module Mgmg
 			end
 		end
 		
-		def min_level
+		def min_levels(w=1)
+			if w == 1
+				@min_levels
+			else
+				@min_levels.map do |key, value|
+					[key, Equip.min_level(key, w)]
+				end.to_h
+			end
+		end
+		def min_levels_max(w=1)
 			if @kind == 28
-				ret = [0, 0]
-				@min_levels.each do |str, ml|
-					if str.build(-1).kind < 8
+				ret = [-1, -1]
+				min_levels(w).each do |str, ml|
+					if str.build.kind < 8
 						if ret[0] < ml
 							ret[0] = ml
 						end
@@ -68,7 +77,7 @@ module Mgmg
 				end
 				ret
 			else
-				@min_levels.values.append(0).max
+				min_levels(w).values.append(-1).max
 			end
 		end
 		
@@ -91,6 +100,9 @@ module Mgmg
 		def mag_das
 			magic()+dex_as().quo(2)
 		end
+		def magic2
+			magic()*2
+		end
 		[:fire, :earth, :water].each.with_index do |s, i|
 			define_method(s){ @element[i] }
 		end
@@ -181,15 +193,9 @@ module Mgmg
 		def +(other)
 			self.dup.add!(other)
 		end
-		def coerce(other)
-			if other == 0
-				zero = self.class.new(28, 0, Vec.new(6, 0), 12, 12, Vec.new(9, 0), Vec.new(3, 0))
-				zero.history.clear
-				[zero, self]
-			else
-				raise TypeError, "Mgmg::Equip can't be coerced into other than 0"
-			end
-		end
+		Zero = self.new(28, 0, Vec.new(6, 0), 12, 12, Vec.new(9, 0), Vec.new(3, 0))
+		Zero.history.clear
+		Zero.freeze
 	end
 	
 	class << Equip
@@ -200,7 +206,7 @@ module Mgmg
 		end
 		private def build_sub0(stack, str)
 			SystemEquip.each do |k, v|
-				if Regexp.compile(k).match(str)
+				if SystemEquipRegexp[k].match(str)
 					stack << v
 					str = str.gsub(k, "<#{stack.length-1}>")
 				end
@@ -272,8 +278,8 @@ module Mgmg
 			unless kind
 				raise InvalidEquipClassError.new(m[1])
 			end
-			main_m, main_s, main_mc = parse_material(m[2])
-			sub_m, sub_s, sub_mc = parse_material(m[3])
+			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)
 			
@@ -293,7 +299,7 @@ module Mgmg
 			
 			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, str.min_level)
+			ret.min_levels.store(str, Equip.min_level(str))
 			ret
 		end
 		
@@ -303,31 +309,22 @@ module Mgmg
 				raise InvalidSmithError.new(str)
 			end
 			kind = EquipIndex[m[1].to_sym]
-			main_m, main_s, = parse_material(m[2])
-			sub_m, sub_s, = parse_material(m[3])
+			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
 		
-		private def parse_material(str)
-			m = /\A.+?(\d+)\Z/.match(str)
-			mat = MaterialIndex[str.to_sym]
-			if m.nil? || mat.nil?
-				raise InvalidMaterialError.new(str)
-			end
-			[mat, m[1].to_i, mat<90 ? mat.div(10) : 9]
-		end
-		
-		def min_comp(str, left_associative: true)
+		def min_comp(str, opt: Option.new)
 			str = Mgmg.check_string(str)
 			stack, str = minc_sub0([], str)
-			(minc_sub(stack, str, left_associative)[1]-1)*3
+			(minc_sub(stack, str, opt.left_associative)[1]-1)*3
 		end
 		private def minc_sub0(stack, str)
 			SystemEquip.each do |k, v|
-				if Regexp.compile(k).match(str)
+				if SystemEquipRegexp[k].match(str)
 					stack << v.star
 					str = str.gsub(k, "<#{stack.length-1}>")
 				end
@@ -349,14 +346,15 @@ module Mgmg
 			end
 		end
 		
-		def min_smith(str, left_associative: true)
+		def min_smith(str, opt: Option.new)
 			str = Mgmg.check_string(str)
 			stack, str = mins_sub0([], str)
-			(([mins_sub(stack, str, left_associative)]+stack).max-1)*3
+			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 Regexp.compile(k).match(str)
+				if SystemEquipRegexp[k].match(str)
 					stack << 0
 					str = str.gsub(k, "<#{stack.length-1}>")
 				end
@@ -370,7 +368,7 @@ module Mgmg
 			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)
-				1
+				0
 			else
 				mins_sub2(str)
 			end
@@ -384,8 +382,8 @@ module Mgmg
 			unless kind
 				raise InvalidEquipClassError.new(m[1])
 			end
-			main_m, main_s, main_mc = parse_material(m[2])
-			sub_m, sub_s, sub_mc = parse_material(m[3])
+			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

data/lib/mgmg/ir.rb

@@ -0,0 +1,400 @@
+module Mgmg
+	using Refiner
+	class IR
+		class Const
+			def initialize(value)
+				@value = value
+			end
+			attr_accessor :value
+			def initialize_copy(other)
+				@value = other.value
+			end
+			def evaluate(s, c)
+				@value
+			end
+			def evaluate3(s, a, c)
+				@value
+			end
+			def to_s
+				@value.to_s
+			end
+		end
+		class Smith
+			def initialize(sub9, coef, den, sa=nil)
+				@sub9, @coef, @den, @sa = sub9, coef, den, sa
+			end
+			attr_accessor :sub9, :coef, :den, :sa
+			def initialize_copy(other)
+				@sub9, @coef, @den, @sa = other.sub9, other.coef, other.den, other.sa
+			end
+			def evaluate(s, c)
+				((s+@sub9)*@coef).div(@den)
+			end
+			def evaluate3(s, a, c)
+				if @sa==:a
+					((a+@sub9)*@coef).div(@den)
+				else
+					((s+@sub9)*@coef).div(@den)
+				end
+			end
+			def to_s
+				if sa==:a
+					"[#{@coef}(a+#{@sub9})/#{den}]"
+				else
+					"[#{@coef}(s+#{@sub9})/#{den}]"
+				end
+			end
+		end
+		class Compose
+			def initialize(main, sub, equip9, coef, den)
+				@main, @sub, @equip9, @coef, @den = main, sub, equip9, coef, den
+			end
+			attr_accessor :main, :sub, :equip9, :coef, :den
+			def initialize_copy(other)
+				@main, @sub = other.main.dup, other.sub.dup
+				@equip9, @coef, @den = other.equip9, other.coef, other.den
+			end
+			def evaluate(s, c)
+				@main.evaluate(s, c) + ( ( @sub.evaluate(s, c) * (c+@equip9).div(2) ).cdiv(100) * @coef ).cdiv(@den)
+			end
+			def evaluate3(s, a, c)
+				@main.evaluate3(s, a, c) + ( ( @sub.evaluate3(s, a, c) * (c+@equip9).div(2) ).cdiv(100) * @coef ).cdiv(@den)
+			end
+			def to_s
+				ms, ss = @main.to_s, @sub.to_s
+				if ss == '0'
+					ms
+				else
+					if ms == '0'
+						"[[#{ss}[(c+#{@equip9})/2]/100]/#{@den}]"
+					else
+						"#{ms}+[[#{ss}[(c+#{@equip9})/2]/100]/#{@den}]"
+					end
+				end
+			end
+		end
+		class Multi
+			def initialize(body)
+				@body = body
+			end
+			attr_accessor :body
+			def initialize_copy(other)
+				@body = other.body.dup
+			end
+			def evaluate(s, c)
+				@body.sum do |e|
+					e.evaluate(s, c)
+				end
+			end
+			def evaluate3(s, a, c)
+				@body.sum do |e|
+					e.evaluate3(s, a, c)
+				end
+			end
+			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)]
+					else
+						unconsts = a.body.dup
+					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)])
+					else
+						unconsts.concat(b.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
+		def initialize(kind, star, main_m, sub_m, para, rein=[])
+			@kind, @star, @main, @sub, @para = kind, star, main_m, sub_m, para
+			add_reinforcement(rein)
+		end
+		def add_reinforcement(rein)
+			@rein = if rein.kind_of?(Array)
+				rein.map do |r|
+					Reinforcement.compile(r)
+				end
+			else
+				[Reinforcement.compile(rein)]
+			end
+			self
+		end
+		attr_accessor :kind, :star, :main, :sub, :para, :rein
+		def initialize_copy(other)
+			@kind = other.kind
+			@star = other.star
+			@main = other.main
+			@sub = other.sub
+			@para = other.para.dup
+			@rein = other.rein.dup
+		end
+		
+		def compose(other)
+			self.class.compose(self, other)
+		end
+		
+		def to_s
+			par = @para.map.with_index{|e, i| e.to_s=='0' ? nil : "#{Mgmg::Equip::ParamList[i]}:#{e.to_s}"}.compact
+			if @kind == 28
+				ep = @star.map.with_index{|e, i| e==0 ? nil : "#{Mgmg::Equip::EqPosList[i]}:#{e}"}.compact
+				"複数装備(#{ep.join(', ')})<#{par.join(', ')}>#{@rein.empty? ? '' : '{'+@rein.join(',')+'}'}"
+			else
+				"#{EquipName[@kind]}☆#{@star}(#{MaterialClass[@main]}#{MaterialClass[@sub]})<#{par.join(', ')}>#{@rein.empty? ? '' : '{'+@rein.join(',')+'}'}"
+			end
+		end
+		
+		def para_call(para, s, ac, x=nil)
+			if x.nil?
+				method(para).call(s, ac)
+			else
+				method(para).call(s, ac, x)
+			end
+		end
+		
+		%i|attack phydef magdef hp mp str dex speed magic|.each.with_index do |sym, i|
+			define_method(sym) do |s=nil, ac=s, x=nil|
+				ret = if s.nil?
+					@para[i]
+				elsif x.nil?
+					@para[i].evaluate(s, ac)
+				else
+					@para[i].evaluate3(s, ac, x)
+				end
+				@rein.each do |r|
+					if r.vec[i] != 0
+						ret *= (100+r.vec[i]).quo(100)
+					end
+				end
+				ret
+			end
+		end
+		def atkstr(s, ac, x=nil)
+			attack(s, ac, x)+str(s, ac, x)
+		end
+		def atk_sd(s, ac, x=nil)
+			attack(s, ac, x)+str(s, ac, x).quo(2)+dex(s, ac, x).quo(2)
+		end
+		def dex_as(s, ac, x=nil)
+			attack(s, ac, x).quo(2)+str(s, ac, x).quo(2)+dex(s, ac, x)
+		end
+		def mag_das(s, ac, x=nil)
+			magic(s, ac, x)+dex_as(s, ac, x).quo(2)
+		end
+		def magic2(s, ac, x=nil)
+			magic(s, ac, x)*2
+		end
+		def magmag(s, ac, x=nil)
+			magdef(s, ac, x)+magic(s, ac, x).quo(2)
+		end
+		def pmdef(s, ac, x=nil)
+			[phydef(s, ac, x), magmag(s, ac, x)].min
+		end
+		
+		def power(s, a=s, c=a.tap{a=s})
+			case @kind
+			when 0, 1
+				atk_sd(s, c)
+			when 2, 3
+				atkstr(s, c)
+			when 4
+				[dex_as(s, c), mag_das(s, c)].max
+			when 5
+				dex_as(s, c)
+			when 6, 7
+				[magic(s, c)*2, atkstr(s, c)].max
+			when 28
+				@para.enum_for(:sum).with_index do |e, i|
+					x = e.evaluate3(s, a, c)
+					@rein.each do |r|
+						if r.vec[i] != 0
+							x *= (100+r.vec[i]).quo(100)
+						end
+					end
+					x
+				end-((hp(s, a, c)+mp(s, a, c))*3.quo(4))
+			else
+				ret = @para.map.with_index do |e, i|
+					x = e.evaluate3(s, a, c)
+					@rein.each do |r|
+						if r.vec[i] != 0
+							x *= (100+r.vec[i]).quo(100)
+						end
+					end
+					x
+				end.max
+				if ret == magdef(s, a, c)
+					ret+magic(s, a, c).quo(2)
+				else
+					ret
+				end
+			end
+		end
+		def fpower(s, a=s, c=a.tap{a=s})
+			power(s, a, c).to_f
+		end
+		
+		def smith_cost(s, c=s, outsourcing=false)
+			if outsourcing
+				if @kind < 8
+					(@star**2)*2+@para.sum{|e| e.evaluate(s, c)}+hp(s, c).cdiv(4)-hp(s, c)+mp(s, c).cdiv(4)-mp(s, c)
+				else
+					(@star**2)+@para.sum{|e| e.evaluate(s, c)}+hp(s, c).cdiv(4)-hp(s, c)+mp(s, c).cdiv(4)-mp(s, c)
+				end
+			else
+				if @kind < 8
+					((@star**2)*2+@para.sum{|e| e.evaluate(s, c)}+hp(s, c).cdiv(4)-hp(s, c)+mp(s, c).cdiv(4)-mp(s, c)).div(2)
+				else
+					((@star**2)+@para.sum{|e| e.evaluate(s, c)}+hp(s, c).cdiv(4)-hp(s, c)+mp(s, c).cdiv(4)-mp(s, c)).div(2)
+				end
+			end
+		end
+		def comp_cost(s, c=s, outsourcing=false)
+			if outsourcing
+				[(@star**2)*5+@para.sum{|e| e.evaluate(s, c)}+hp().cdiv(4)-hp()+mp().cdiv(4)-mp(), 0].max.div(2)
+			else
+				[((@star**2)*5+@para.sum{|e| e.evaluate(s, c)}+hp().cdiv(4)-hp()+mp().cdiv(4)-mp()).div(2), 0].max.div(2)
+			end
+		end
+		alias :cost :comp_cost
+		
+		def add!(other)
+			if @kind == 28
+				if other.kind == 28
+					@star.add!(other.star)
+				else
+					@star[EquipPosition[other.kind]] += 1
+				end
+			else
+				@star = Vec.new(6, 0)
+				@star[EquipPosition[@kind]] = 1
+				@kind = 28
+				if other.kind == 28
+					@star.add!(other.star)
+				else
+					@star[EquipPosition[other.kind]] += 1
+				end
+			end
+			@main, @sub = 12, 12
+			@para = Array.new(9) do |i|
+				Multi.sum(self.para[i], other.para[i])
+			end
+			self
+		end
+		def +(other)
+			self.dup.add!(other)
+		end
+		Zero = self.new(28, Vec.new(6, 0), 12, 12, Array.new(9){Const.new(0)})
+	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)
+				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)
+				else
+					Mgmg::IR::Smith.new(Sub9[sub_m][i], coef[i], den, sa)
+				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)
+			end
+			new(equip.kind, equip.star, equip.main, equip.sub, para)
+		end
+	end
+end

data/lib/mgmg/optimize.rb

@@ -2,8 +2,12 @@ module Mgmg
 	module Optimize; end
 	class << Optimize
 		InvList = [%w|帽子 フード サンダル|.freeze, %w|宝1 骨1 木1 木2 骨2|.freeze, %w|宝1 骨1 木1|.freeze].freeze
-		def phydef_optimize(str, smith, comp=smith, left_associative: true, magdef_maximize: true)
-			best = ( smith.nil? ? [str, str.poly(:phydef), str.poly(:magdef), str.poly(:cost)] : [str, str.build(smith, comp)] )
+		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)]
+			else
+				[str, str.build(smith, comp, opt: opt)]
+			end
 			str = Mgmg.check_string(str)
 			ai = 0
 			while str.sub!(/(帽子|フード|サンダル)\([宝木骨][12][宝木骨]1\)/){
@@ -19,7 +23,7 @@ module Mgmg
 			m = /([^\+]*\([^\(]+[綿皮]1\))\]*\Z/.match(str)
 			if m
 				if smith
-					if m[1].sub(/綿1\)/, '皮1)').build(smith).weight == m[1].sub(/皮1\)/, '綿1)').build(smith).weight
+					if m[1].sub(/綿1\)/, '皮1)').build(smith, opt: opt).weight == m[1].sub(/皮1\)/, '綿1)').build(smith, opt: opt).weight
 						skin = true
 					end
 				else
@@ -35,7 +39,11 @@ module Mgmg
 				b = b0
 				while b
 					r = pd_apply_idx(str, a, b)
-					best = pd_better(best, ( smith.nil? ? [r, r.poly(:phydef), r.poly(:magdef), r.poly(:cost)] : [r, r.build(smith, comp)] ), magdef_maximize)
+					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)
+					else
+						pd_better(best, [r, r.build(smith, comp, opt: opt)], opt.magdef_maximize)
+					end
 					b = pd_next_b(b)
 				end
 				a = pd_next_a(a)
@@ -49,7 +57,11 @@ module Mgmg
 					b = b0
 					while b
 						r = pd_apply_idx(str, a, b)
-						best = pd_better(best, ( smith.nil? ? [r, r.poly(:phydef), r.poly(:magdef), r.poly(:cost)] : [r, r.build(smith, comp)] ), magdef_maximize)
+						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)
+						else
+							pd_better(best, [r, r.build(smith, comp, opt: opt)], opt.magdef_maximize)
+						end
 						b = pd_next_b(b)
 					end
 					a = pd_next_a(a)
@@ -102,7 +114,7 @@ module Mgmg
 				end
 				return pre
 			else
-				raise "Unexpected Error"
+				raise UnexpectedError
 			end
 		end
 		private def pd_apply_idx(str, a, b)
@@ -146,8 +158,8 @@ module Mgmg
 		end
 		
 		MwList = %w|綿 皮 骨 木 水|.freeze
-		def buster_optimize(str, smith, comp=smith, left_associative: true)
-			best = ( smith.nil? ? [str, str.poly(:mag_das)] : [str, str.build(smith, comp)] )
+		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)] )
 			str = Mgmg.check_string(str)
 			ai = -1
 			org = nil
@@ -162,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)] : [r, r.build(smith, comp)] ))
+				best = bus_better(best, ( smith.nil? ? [r, r.poly(:mag_das, opt: opt)] : [r, r.build(smith, comp, opt: opt)] ))
 				a = bus_next_a(a)
 			end
 			best[0]