小编use*_*029的帖子

给定一个定义顶级类的gem,它与我编写的一些代码冲突,是否可以以这样的方式要求gem,使其所有类都分组在我可以定义的模块中？例如,如果unsafe_gem定义了一个类:

class Word
  # ... some code
end

我需要这样的东西:

class Word
  # My word class.
end

module SafeContainer
  # This obviously doesn't work
  # (i.e. the gem still defines ::Word).
  require 'unsafe_gem'
end

这样我就可以区分:

Word.new # => The class I defined.
SafeContainer::Word.new # => The class defined by the gem.

一些进一步的细节:我的代码(例如'Word'类)已经包装在它自己的命名空间中.但是,我希望能够为用户提供启用"语法糖"形式的选项,这使得某些类可以在顶级命名空间下直接访问.但是,这会与我正在使用的一个宝石创建一个名称冲突,它定义了一个顶级类.目前提出的解决方案都不起作用,因为宝石实际上依赖于其全球定义的类; 因此,取消定义课程打破了宝石.当然,gem有多个文件,单独要求将其文件放入模块似乎是一个非常脆弱的解决方案.目前,我发现的唯一解决方法是:

begin
  # Require the faulty gem.
  require 'rbtagger'
rescue 
  # If syntactic sugar is enabled...
  if NAT.edulcorated?
    # Temporarily remove the sugar for the clashing class.
    Object.const_unset(:Word); …

我有以下课程:

class User
  code1 = Proc.new { }
  code2 = lambda { }

  define_method :test do
    self.class.instance_eval &code1
    self.class.instance_eval &code2
  end
end

User.new.test

为什么第二个instance_eval失败并出现wrong number of arguments (1 for 0)错误？

假设一个类需要加载一个外部库,这需要一些时间来加载,因此只应加载一次.对此的两个自然解决方案是使用单例模式或单稳态模式.在Ruby的特定上下文中,这些解决方案中是否有任何优势？

例如:

# Using a Singleton class
require 'singleton'

class Parser
  include Singleton

    def initialize
      @parser = load_external_library
    end

    def parse(sentence)
      @parser.parse(sentence)
    end
end

# Then calling using...
Parser.instance.parse(sentence)

与:

# Using a Monostate class

class Parser
    def self.parse(sentence)
      @@parser ||= load_external_library
      @@parser.parse(sentence)
    end
end

# Then calling using...
Parser.parse(sentence)

由于第二种语法更清晰,在Ruby中使用Singleton有什么好处吗？

我一直在摆弄Mongo,但无法让这个简单的例子起作用.我只是想要检索集合中的所有文档:

require 'mongoid'

# configuration ...    

class Category

  include Mongoid::Document
  field :name, type: String

end

Category.each do |test|
  puts test.inspect
end

我收到错误: undefined method 'each' for Category:Class (NoMethodError).

已建立与数据库的连接,名为的集合categories包含一些文档.

我试图__synchtreads()在Ruby中"复制"CUDA 函数的行为.具体来说,我有一组N需要执行某些代码的线程,然后所有线程都在执行的中间点等待,然后继续执行其余的业务.例如:

x = 0

a = Thread.new do
  x = 1
  syncthreads()  
end

b = Thread.new do 
  syncthreads()
  # x should have been changed
  raise if x == 0
end

[a,b].each { |t| t.join }

我需要使用哪些工具来完成此任务？我尝试使用全局哈希,然后休眠,直到所有线程都设置了一个标志,表明他们已经完成了代码的第一部分.我无法让它正常工作; 它导致了挂起和死锁.我想我需要使用的组合Mutex并ConditionVariable,但我不能确定,为什么/如何.

编辑: 50次观看,没有答案!看起来像赏金的候选人......

我想知道如何在shell中创建一个"全屏"窗口的外观,如在vim,emacs等中.是否可以在Ruby中以编程方式执行此操作？那将是平台依赖的？

编辑:我不是在寻找如何使我的shell全屏显示.我正在寻找隐藏之前输入的命令的方法,并用应用程序"填充"shell屏幕.这是安装人员.

我想转换由PTB样式的标记生成器生成的一系列语素:

["The", "house", "is", "n't", "on", "fire", "."]

一句话:

"The house isn't on fire."

什么是明智的方法来实现这一目标？

我有以下信号要处理（原始数据）：

我想处理信号以消除异常值以获得“平滑”曲线。注意：我不想更改任何实际值，我只对去除虚假点感兴趣。一个特定的要求是曲线“环绕”（即曲线的起点应与其终点相邻）。一张图片可能更有帮助（我已经手动追踪黑线来说明）：

到目前为止，我已经尝试根据与移动平均线的距离对函数进行阈值处理，但失败得很惨。我也尝试过基于此计算一阶导数和阈值，这也无济于事。关于如何达到预期结果的任何想法？我仍然相信我在这里缺少一个相对简单的解决方案。我正在使用 Python/NumPy/SciPy。

我试图让彩虹语法高亮库与标记的降价渲染引擎一起工作.该marked文档指出通过以下配置选项支持语法高亮显示:

marked.setOptions({
  highlight: function(code, lang) {
    return highlighter.javascript(code);
  }
});

的rainbow 源代码表示传入的字符串以突出显示通过下面的语法被支撑:

Rainbow.color(code, lang, success);

关于如何把两者放在一起,我有点不知所措.具体来说,success是一个异步调用的回调,我不能简单地从回调Rainbow.color内的代码返回值highlight.这将如何实现？

我想在加权有向图上找到最小生成树(MST).我一直在尝试使用Chu-Liu/Edmond的算法,我已经用Python实现了这个算法(下面的代码).可以在此处找到对算法的简单,清晰的描述.我有两个问题.

1. Edmond的算法是否可以保证收敛于解决方案？

   我担心删除一个循环会增加另一个循环.如果发生这种情况,算法将继续尝试永久删除循环.

   我似乎找到了这种情况的例子.输入图如下所示(在代码中).该算法永远不会完成,因为它在周期[1,2]和[1,3]以及[5,4]和[5,6]之间切换.添加到图中以解决循环[5,4]的边创建了循环[5,6],反之亦然,对于[1,2]和[1,3]也类似.

   我应该注意到,我不确定我的实施是否正确.

2. 为了解决这个问题,我介绍了一个临时补丁.当删除边以移除循环时,我会从我们正在搜索MST的基础图G中永久删除该边.因此,不能再添加该边缘,这应该可以防止算法卡住.有了这个改变,我保证找到一个MST吗？

   我怀疑人们可以找到一个病态的案例,这一步将导致一个不是MST的结果,但我无法想到一个.它似乎适用于我尝试过的所有简单测试用例.

码:

import sys

# --------------------------------------------------------------------------------- #

def _reverse(graph):
    r = {}
    for src in graph:
        for (dst,c) in graph[src].items():
            if dst in r:
                r[dst][src] = c
            else:
                r[dst] = { src : c }
    return r

# Finds all cycles in graph using Tarjan's algorithm
def strongly_connected_components(graph):
    """
    Tarjan's Algorithm (named for its discoverer, Robert Tarjan) is a graph theory algorithm
    for finding the strongly connected components …