Ruby 公差范围内的方程求解器

我正在尝试设计一个Ruby脚本，通过获取E24系列电阻器、E12和E6系列电容器和电感器的值来帮助RC/RL电路设计。基本上只是循环通过每一个可能的组合，方程是

F=1/（2*Pi*R*C）

[对于eg的RC电路]

---

我在这里追求的不是效率，而是可靠性。我需要它使用上面等式中的值循环通过电阻阵列和电容/电感阵列的每个组合（决不是全部3个），如果它在某个值的正负x%范围内，则返回它使用的阵列中的值。我可以为每个组合嵌套2个for循环，但我希望它不仅返回公差范围内的值，而且告诉我哪个值最接近（或精确）。

在定义

E24

、

E12

和

E6

数组、

特定值和所需的
增量之后，这应该可以工作：

F = lambda{ |i, r, c| 1 / ( 2 * i * r * c ) }

equation_solver = lambda {
  |equation, resistances, capacitances, inductances, desired_value, delta|
  resistances.find.with_object [] do |resistance, memo|
    capacitances.find.with_object memo do |capacitance, memo|
      inductances = E6.find{ |inductance|
        ( equation.(inductance, resistance, capacitance) - desired_value ).abs < delta
      } and memo << resistance << capacitance << inductance
    end
  end
}

desired_r_c_i = equation_solver.( F, E24, E12, E6, CERTAIN_VALUE, DELTA )

F=lambda{i，r，c | 1/（2*i*r*c）}
方程求解器=λ{
|方程，电阻，电容，电感，期望值，δ|
resistences.find.with_object[]do | resistance，memo|
电容量.查找.带对象备忘do |电容量，备忘|
电感=E6。查找{电感|
（方程式。（电感、电阻、电容）-所需的_值）。abs<δ
}和备忘录
$resArray=[1.0, 1.1, 1.2, 1.3, 1.5, 1.6, 1.8, 2.0, 2.2, 2.4, 2.7, 3.0, 3.3, 3.6, 3.9, 4.3, 4.7, 5.1, 5.6, 6.2, 6.8, 7.5, 8.2, 9.1,10, 11, 12, 13, 15, 16, 18, 20, 22, 24, 27, 30, 33, 36, 39, 43, 47, 51, 56, 62, 68, 75, 82, 91,100, 110, 120, 130, 150, 160, 180, 200, 220, 240, 270, 300, 330, 360, 390, 430, 470, 510, 560, 620, 680, 750, 820, 910,1000, 1100, 1200, 1300, 1500, 1600, 1800, 2000, 2200, 2400, 2700, 3000, 3300, 3600, 3900, 4300, 4700, 5100, 5600, 6200, 6800, 7500, 8200, 9100, 10000, 11000, 12000, 13000, 15000, 16000, 18000, 20000, 22000, 24000, 27000, 30000, 33000, 36000, 39000, 43000, 47000, 51000, 56000, 62000, 68000, 75000, 82000, 91000, 100000, 110000, 120000, 130000, 150000, 160000, 180000, 200000, 220000, 240000, 270000, 300000, 330000, 360000, 390000, 430000, 470000, 510000, 560000, 620000, 680000, 750000, 820000, 910000, 1000000, 1100000, 1200000, 1300000, 1500000, 1600000, 1800000, 2000000, 2200000, 2400000, 2700000, 3000000, 3300000, 3600000, 3900000, 4300000, 4700000, 5100000, 5600000, 6200000, 6800000, 7500000, 8200000, 9100000, 1000000]
$capArray=Array.new
$indArray=Array.new
$breakFreq=19*（10**3）
$tol=0.997
$PI=Math.atan2（0，-1）
def生成阵列（j，arr）
对于0…$resArray.size中的i
如果i%j==0
arr$breakFreq*$tol&n<$breakFreq*（2-$tol）
差异=100-（（n-$breakFreq）/$breakFreq）。绝对值
放置“电阻器：#{$resArray[i]}欧姆”
将“电容器：#{$capArray[j]。放置到_f}f”
将“置于#{diff}%之内”
放置“----------------”
结束
结束
结束
结束
def indTest（）
放置“RL电路估计”
对于0…$resArray.size中的i
对于0中的j…$indArray.size
n=$resArray[i]/（2*$PI*$indArray[j]）
如果n>$breakFreq*$tol&&n<$breakFreq*（2-$tol）
差异=（1-（（n-$breakFreq）/$breakFreq）.abs）*100
放置“电阻器：#{$resArray[i]}欧姆”
将“电感器：#{$indArray[j]。放置到_f}H”
将“置于#{diff}%之内”
放置“----------------”
结束
结束
结束
结束
makeArray（2$capArray）
makeArray（4$indArray）
船长（）
indTest（）
这是对代码的温和重构：

# I noticed that your resistance array is just the same set of values
# repeated with factors from 1 to 1000000, so this would be more concise
# way of defining it (and less prone to typing errors):
RES_ARRAY = [*-1..5].map{ |e| 10 ** e }.map{ |factor|
             [ 10, 11, 12, 13, 15, 16, 18, 20,
               22, 24, 27, 30, 33, 36, 39, 43,
               47, 51, 56, 62, 68, 75, 82, 91 ].map{ |e| e * factor }
           }.reduce( :+ )

# Global variables should be used very rarely. Constants should be written IN UPCASE:
CAP_ARRAY, IND_ARRAY = [], []
BREAK_FREQ = 19 * ( 10 ** 3 )

# Whole words should be used whenever possible in the code:
TOLERANCE = 0.997

# Methods should be named in snake_case:
def make_array( j, arr )
  # Let us use #each_slice and #map insterad of % and << operators:
  arr.each_slice( j ).map( &:first ).map{ |e| e * 1e-9 }
end

def cap_test
  puts "RC Circuit Estimation"
  for i in 0...RES_ARRAY.size
    for j in 0...CAP_ARRAY.size
      n = 1 / ( 2 * Math::PI * RES_ARRAY[ i ] * CAP_ARRAY[ j ] )
      if n > BREAK_FREQ * TOLERANCE and n < BREAK_FREQ * ( 2 - TOLERANCE )
        diff = 100 - ( ( n - BREAK_FREQ ) / BREAK_FREQ ).abs
        puts "Resistor:  #{RES_ARRAY[ i ]} Ohms"
        puts "Capacitor: #{CAP_ARRAY[ j ].to_f} F"
        puts "Within #{diff}%"
        puts "---------------------"
      end
    end
  end
end

def ind_test
  puts "RL Circuit Estimation"
  for i in 0...RES_ARRAY.size
    for j in 0...IND_ARRAY.size
      n = RES_ARRAY[ i ] / ( 2 * Math::PI * IND_ARRAY[ j ] )
      if n > BREAK_FREQ * TOLERANCE and n < BREAK_FREQ * ( 2 - TOLERANCE )
        diff = ( 1 - ( ( n - BREAK_FREQ ) / BREAK_FREQ ).abs ) * 100
        puts "Resistor:  #{RES_ARRAY[ i ]} Ohms"
        puts "Inductor: #{IND_ARRAY[ j ].to_f} H"
        puts "Within #{diff}%"
        puts "---------------------"
      end
    end
  end
end

make_array 2, CAP_ARRAY
make_array 4, IND_ARRAY
cap_Test()
ind_Test()

#我注意到您的电阻阵列是同一组值
#重复使用从1到1000000的因子，因此这将更加简洁
#定义它的方式（并且不太容易出现键入错误）：
RES|u数组=[*-1..5].map{e|10**e}.map{e}因子|
[ 10, 11, 12, 13, 15, 16, 18, 20,
22, 24, 27, 30, 33, 36, 39, 43,
47,51,56,62,68,75,82,91]
}.reduce（：+）
#全局变量应很少使用。常量应以UPCASE格式写入：
CAP_数组，IND_数组=[]，[]
中断频率=19*（10**3）
#代码中应尽可能使用完整的词语：
公差=0.997
#方法应以snake_为例命名：
def make_阵列（j，arr）
#让我们使用#每个#切片和#映射代替%和BREAK#u FREQ*公差和n中断频率*公差和n<中断频率*（2-公差）
差异=（1-（（n-中断频率）/中断频率.abs）*100
将“电阻：#{RES_阵列[i]}欧姆”放入
将“电感器：#{IND_数组[j]。放置到_f}H”
将“置于#{diff}%之内”
放置“----------------”
结束
结束
结束
结束
制作_数组2，CAP_数组
生成数组4，索引数组
cap_测试（）
ind_测试（）
我喜欢你的问题，但遗憾的是，我必须问你一个必须回答的问题：你尝试了什么？尽管如此，请向上投票。目前正在编写代码，将使用我的代码进行编辑…抱歉，我已经回答了，但直到现在我才注意到你的问题中从来没有提到全部3个？我希望我的回答对你有所帮助…那就是…r非常简洁，我使用ruby的时间还不够长，lambda和大括号的函数是什么？（注意…所有其他大括号）
#lambda
定义了你的函数。大括号初始化一个新数组。数组作为备忘录传递到
#
# I noticed that your resistance array is just the same set of values
# repeated with factors from 1 to 1000000, so this would be more concise
# way of defining it (and less prone to typing errors):
RES_ARRAY = [*-1..5].map{ |e| 10 ** e }.map{ |factor|
             [ 10, 11, 12, 13, 15, 16, 18, 20,
               22, 24, 27, 30, 33, 36, 39, 43,
               47, 51, 56, 62, 68, 75, 82, 91 ].map{ |e| e * factor }
           }.reduce( :+ )

# Global variables should be used very rarely. Constants should be written IN UPCASE:
CAP_ARRAY, IND_ARRAY = [], []
BREAK_FREQ = 19 * ( 10 ** 3 )

# Whole words should be used whenever possible in the code:
TOLERANCE = 0.997

# Methods should be named in snake_case:
def make_array( j, arr )
  # Let us use #each_slice and #map insterad of % and << operators:
  arr.each_slice( j ).map( &:first ).map{ |e| e * 1e-9 }
end

def cap_test
  puts "RC Circuit Estimation"
  for i in 0...RES_ARRAY.size
    for j in 0...CAP_ARRAY.size
      n = 1 / ( 2 * Math::PI * RES_ARRAY[ i ] * CAP_ARRAY[ j ] )
      if n > BREAK_FREQ * TOLERANCE and n < BREAK_FREQ * ( 2 - TOLERANCE )
        diff = 100 - ( ( n - BREAK_FREQ ) / BREAK_FREQ ).abs
        puts "Resistor:  #{RES_ARRAY[ i ]} Ohms"
        puts "Capacitor: #{CAP_ARRAY[ j ].to_f} F"
        puts "Within #{diff}%"
        puts "---------------------"
      end
    end
  end
end

def ind_test
  puts "RL Circuit Estimation"
  for i in 0...RES_ARRAY.size
    for j in 0...IND_ARRAY.size
      n = RES_ARRAY[ i ] / ( 2 * Math::PI * IND_ARRAY[ j ] )
      if n > BREAK_FREQ * TOLERANCE and n < BREAK_FREQ * ( 2 - TOLERANCE )
        diff = ( 1 - ( ( n - BREAK_FREQ ) / BREAK_FREQ ).abs ) * 100
        puts "Resistor:  #{RES_ARRAY[ i ]} Ohms"
        puts "Inductor: #{IND_ARRAY[ j ].to_f} H"
        puts "Within #{diff}%"
        puts "---------------------"
      end
    end
  end
end

make_array 2, CAP_ARRAY
make_array 4, IND_ARRAY
cap_Test()
ind_Test()