Results for: "module_function"

The Benchmark module provides methods to measure and report the time used to execute Ruby code.

• Measure the time to construct the string given by the expression "a"*1_000_000_000:

  require 'benchmark'
  
  puts Benchmark.measure { "a"*1_000_000_000 }
  

  On my machine (OSX 10.8.3 on i5 1.7 GHz) this generates:

  0.350000   0.400000   0.750000 (  0.835234)

  This report shows the user CPU time, system CPU time, the sum of the user and system CPU times, and the elapsed real time. The unit of time is seconds.

• Do some experiments sequentially using the bm method:

  require 'benchmark'
  
  n = 5000000
  Benchmark.bm do |x|
    x.report { for i in 1..n; a = "1"; end }
    x.report { n.times do   ; a = "1"; end }
    x.report { 1.upto(n) do ; a = "1"; end }
  end
  

  The result:

      user     system      total        real
  1.010000   0.000000   1.010000 (  1.014479)
  1.000000   0.000000   1.000000 (  0.998261)
  0.980000   0.000000   0.980000 (  0.981335)

• Continuing the previous example, put a label in each report:

  require 'benchmark'
  
  n = 5000000
  Benchmark.bm(7) do |x|
    x.report("for:")   { for i in 1..n; a = "1"; end }
    x.report("times:") { n.times do   ; a = "1"; end }
    x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
  end
  

The result:

              user     system      total        real
for:      1.010000   0.000000   1.010000 (  1.015688)
times:    1.000000   0.000000   1.000000 (  1.003611)
upto:     1.030000   0.000000   1.030000 (  1.028098)

• The times for some benchmarks depend on the order in which items are run. These differences are due to the cost of memory allocation and garbage collection. To avoid these discrepancies, the bmbm method is provided. For example, to compare ways to sort an array of floats:

  require 'benchmark'
  
  array = (1..1000000).map { rand }
  
  Benchmark.bmbm do |x|
    x.report("sort!") { array.dup.sort! }
    x.report("sort")  { array.dup.sort  }
  end
  

  The result:

  Rehearsal -----------------------------------------
  sort!   1.490000   0.010000   1.500000 (  1.490520)
  sort    1.460000   0.000000   1.460000 (  1.463025)
  -------------------------------- total: 2.960000sec
  
              user     system      total        real
  sort!   1.460000   0.000000   1.460000 (  1.460465)
  sort    1.450000   0.010000   1.460000 (  1.448327)

• Report statistics of sequential experiments with unique labels, using the benchmark method:

  require 'benchmark'
  include Benchmark         # we need the CAPTION and FORMAT constants
  
  n = 5000000
  Benchmark.benchmark(CAPTION, 7, FORMAT, ">total:", ">avg:") do |x|
    tf = x.report("for:")   { for i in 1..n; a = "1"; end }
    tt = x.report("times:") { n.times do   ; a = "1"; end }
    tu = x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
    [tf+tt+tu, (tf+tt+tu)/3]
  end
  

  The result:

               user     system      total        real
  for:      0.950000   0.000000   0.950000 (  0.952039)
  times:    0.980000   0.000000   0.980000 (  0.984938)
  upto:     0.950000   0.000000   0.950000 (  0.946787)
  >total:   2.880000   0.000000   2.880000 (  2.883764)
  >avg:     0.960000   0.000000   0.960000 (  0.961255)

Timeout long-running blocks

Synopsis

require 'timeout'
status = Timeout::timeout(5) {
  # Something that should be interrupted if it takes more than 5 seconds...
}

Description

Timeout provides a way to auto-terminate a potentially long-running operation if it hasn’t finished in a fixed amount of time.

Previous versions didn’t use a module for namespacing, however timeout is provided for backwards compatibility. You should prefer Timeout.timeout instead.

Copyright

Copyright

© 2000 Network Applied Communication Laboratory, Inc.

Copyright

© 2000 Information-technology Promotion Agency, Japan

Specifies a Specification object that should be activated. Also contains a dependency that was used to introduce this activation.

WIN32OLE_EVENT objects controls OLE event.

WIN32OLE_PARAM objects represent param information of the OLE method.

WIN32OLE_RECORD objects represents VT_RECORD OLE variant. Win32OLE returns WIN32OLE_RECORD object if the result value of invoking OLE methods.

If COM server in VB.NET ComServer project is the following:

Imports System.Runtime.InteropServices
Public Class ComClass
    Public Structure Book
        <MarshalAs(UnmanagedType.BStr)> _
        Public title As String
        Public cost As Integer
    End Structure
    Public Function getBook() As Book
        Dim book As New Book
        book.title = "The Ruby Book"
        book.cost = 20
        Return book
    End Function
End Class

then, you can retrieve getBook return value from the following Ruby script:

require 'win32ole'
obj = WIN32OLE.new('ComServer.ComClass')
book = obj.getBook
book.class # => WIN32OLE_RECORD
book.title # => "The Ruby Book"
book.cost  # => 20

WIN32OLE_TYPE objects represent OLE type libarary information.

WIN32OLE_TYPELIB objects represent OLE tyblib information.

WIN32OLE_VARIANT objects represents OLE variant.

Win32OLE converts Ruby object into OLE variant automatically when invoking OLE methods. If OLE method requires the argument which is different from the variant by automatic conversion of Win32OLE, you can convert the specfied variant type by using WIN32OLE_VARIANT class.

param = WIN32OLE_VARIANT.new(10, WIN32OLE::VARIANT::VT_R4)
oleobj.method(param)

WIN32OLE_VARIANT does not support VT_RECORD variant. Use WIN32OLE_RECORD class instead of WIN32OLE_VARIANT if the VT_RECORD variant is needed.

The parent class for all constructed encodings. The value attribute of a Constructive is always an Array. Attributes are the same as for ASN1Data, with the addition of tagging.

SET and SEQUENCE

Most constructed encodings come in the form of a SET or a SEQUENCE. These encodings are represented by one of the two sub-classes of Constructive:

• OpenSSL::ASN1::Set

• OpenSSL::ASN1::Sequence

Please note that tagged sequences and sets are still parsed as instances of ASN1Data. Find further details on tagged values there.

Example - constructing a SEQUENCE

int = OpenSSL::ASN1::Integer.new(1)
str = OpenSSL::ASN1::PrintableString.new('abc')
sequence = OpenSSL::ASN1::Sequence.new( [ int, str ] )

Example - constructing a SET

int = OpenSSL::ASN1::Integer.new(1)
str = OpenSSL::ASN1::PrintableString.new('abc')
set = OpenSSL::ASN1::Set.new( [ int, str ] )

See Net::HTTPGenericRequest for attributes and methods.

Switch that can omit argument.

Represents a specification retrieved via the rubygems.org API.

This is used to avoid loading the full Specification object when all we need is the name, version, and dependencies.

A GitSpecification represents a gem that is sourced from a git repository and is being loaded through a gem dependencies file through the git: option.

Represents a possible Specification object returned from IndexSet. Used to delay needed to download full Specification objects when only the name and version are needed.

A LocalSpecification comes from a .gem file on the local filesystem.

The LockSpecification comes from a lockfile (Gem::RequestSet::Lockfile).

A LockSpecification’s dependency information is pre-filled from the lockfile.

The Resolver::SpecSpecification contains common functionality for Resolver specifications that are backed by a Gem::Specification.