Keresés

Ha belenezel a complex.rb-be, akkor lathatod, hogy az atdefinialja az altalad kiprobalt fuggvenyeket.

A Rubyban az egesz osztaly(/modul)hierarhia, a metodusok futasidoben lekerdezhetok es tetszolegesen modosithatok is.

Ez aranyos, ha behozom a komplex számokat, akkor rögtön megy a
Math::sqrt(-1)
Math::log(-1)
i=Complex(0,1)
Math::sin(2+i)
Bár ez számomra rejtélyes dolog, honnan tudja a Math, hogy az eredmény
komplex is lehet. Pedig eddig ezt írta (a sor eleje az irb prompt):

irb(main):002:0> sqrt(-1)
ArgumentError: square root for negative number
from (irb):2:in `sqrt'
from (irb):2
irb(main):003:0> log(-1)
NaN

Sorry, ez tenyleg az en hibam:

require "complex" a scriptbe, vagy
-r complex a parancssorbol segit...

Most már nem jelez hibát.
(De az end-eket továbbra sem szinezi helyesen a VIM text editor.)

Az interaktiv rubyban (irb) hiába írom be, hogy
a=Complex.polar(1,Math::PI)
nem találja a Complex modult. Milyen csomag kell ehhez Debian alatt?
Szkriptben is probáltam. Ezt írja:
uninitialized constant Complex (NameError)

Ja, es az FFT-hez annyi: a "vals" egy 2 az n-ediken meretu komplex szamokbol allo tomb.

Ha nincs kedved a html forrasban matatni (ami nem tul nagy ugy), elkuldhetem persze levelben is.

Az FFT azert nem mukodik, mert a html elnyelt egy kisebb jelet :(

Ha a lap (view source) forrasabol kimasolod, akkor mukodik.

A fuggvenyeket a

public_instance_methods
private_instance_methods
protacted_instance_methods

metodusokkal lehet lekerdezni. Ezek egy stringekbol allo tombot adnak vissza.

Egyebkent van egy csomo mas fuggveny amikkel az osztalyhierarchiat elkerdezni es manipulalni lehet pl ancestors, class_methods, ... Pelda:

puts (Math.private_instance_methods)
kiir egy hosszab listat.

Ha komolyabb dokumentaciot akarsz, akkor hasznalhatod a ri-t.
Ezt a http://www.pragmaticprogrammer.com/ruby/downloads/files/ri-0.8a.tgz
lap aljan levo linkrol lehet letolteni.

Egyebkent a Pragmatic Programmers laprol lehet letolteni a Ruby konyvuket is (pl. html-ben),
http://www.ruby.ch/ProgrammingRuby/htmlC/index.html
(Erdemes le wget-ezni az egeszet, en a lokalis valtozatot hasznalom.)

Ez tartalmaz egy nagyon szuper referenciat a Ruby beepitett osztalyairol.

Az abs egyebkent a szamok (Fixnum,Float...) metodusa. Hasznalata: (-1).abs.

Ezt persze a ri-vel gyorsan meg lehet talalni:
ri abs

Van a ri-nek egy grafikus felulete is: gtkri,
http://bocks.psych.purdue.edu/~pizman/myri/
de ezt meg nem probaltam.

Van még néhány problémám.

A régebben közölt FFT algoritmus nem működik nálam. Azt hiszem több az
end, mint kellene, de sajnos az FFT algoritmust nem ismerem, és igy nem
tudom javítani.

Van-e lehetőség kilistázni, hogy egy modulban milyen függvények vannak?
(Pythonban dir(math) kiírja a math modul függvényeit, osztályait és
változóit.) Pl. nem találom az abszolutérték függvényt. Nem Math::abs?
Hogyan tudom megkeresni?

-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0

Pár kellemes dolog (debian-unstable):
Az exerb (rubyból win32 futtathatóba konvertáló program) egyszerűen
telepíthető a honlapról, és működik.

Az irb csomag nekem tetszik. A pythonhoz hasonló interaktív felületet
ad.

Keszitettem egy Ruby szkriptet, ami Linux alatt audio CD-t rippel, leszedi a fajlok nevet es egyeb adatait a free CDDB-rol, beallitja a tag-aket, majd tomoritett ogg formatumban tarolja oket a vinyon. A program nem hoz letre temporalis (tomoritetlen) fajlokat, hanem rogton a tomoritett valtozatot menti. Gyakorlatilag a CDex funkcionalitasaval rendelkezik, csak nincs grafikus interface.

A mukodesehez szukseg van a cdparanoia, es a ogg encoder programokra, valamint a cddb-s ruby csomagra.

Az egesz fajl 200 sor korul van.

Aki szeretne egy valtozatot, az megdobhat egy maillel.

Hianyzik a

require "parsedate"

a programodbol.
(Parancssorbol ezt a -rparsedate kapcsoloval lehet elerni.)

Nekem ez minden tovabbi nelkul mukodik az aktualis Ruby disztribucioval.

Egy másik témánál írtál a dátumok kivonásáról, ezt azóta scriptbe is
írtam, de nem működik:

include ParseDate
puts parsedate("20:23")

Mi a hiba?

Ezt sikerul gyorsan osszehajitanom:

#!/usr/bin/env ruby

include Math

class Romberg

  def initialize(a,b,iterations,&block)

    @a,@b,@it,@f = Float(a),Float(b),iterations,block

    @memo = []

    (iterations+1).times { |i| @memo[i] = [] }

  end

  

  def trapez(r)

    n = 2**r

    h = (@b-@a)/n

    f = @f;

    sum = 0

    (n+1).times{ |i| sum+=f[@a+i*h] }

    (sum-(f[@a]+f[@b])/2)*h

  end

  def t(r,m)

    if (res = @memo[r][m])

      return res 

    end

    if m > 0

      x = t(r,m-1);

      @memo[r][m]=x+(x-t(r-1,m-1))/(4**m-1)

    else

      @memo[r][m]=trapez(r)

    end

  end

  def compute

    t(@it,@it) 

  end

end

def romberg(a,b,it=10,&block)

  Romberg.new(a,b,it,&block).compute

end

puts (romberg(0,1,5) { |x| x*x })

puts (romberg(.1,1,5) { |x| sin(x)/x })

Asszem C-ben boldogulnek vele :), az Ada-ban viszont generic-kel kellene kinlodni

Pontosan!

JAVA-ban interface-ként tudtam megoldani.

Ez az a bizonyos függvény-pointer, amit a FORTRAN-ban az EXTERNAL kulcsszóval definiálunk?

Pár napja írtam egy programot JAVA-ban.
Egyváltozós f(x) függvény numerikus integrálása [a,b] tartományban Romberg algoritmussal.

Az f(x) függvényt "paraméterként" kell megadni, definiálni az adott nyelv lehetőségein belül.

Az a,b tartomány valamint az iteráció adatai szintén paraméterként.

Ráment egy napom. :-(

Ti mit kináltok?

P.S.: Echte megoldás kell! Az XY csomag Romberg(f(x),a,b,n,m) függvényének meghívása nem ér!

Ok, beismerem, ez a Ruby standard installaciojaval nem megy.

Viszont, ha az ember veszi a faradtsagot, es installaja a bigfloat csomagot, utana:

ruby -rbigfloat -e 'puts BigFloat.PI(1000)'

Szamitsuk ki a pi-t 1000 szamjegy pontossaggal.
echo 'scale=1000; print 4*a(1),"\n"' | bc -l
(megjegyzes: az utolso szamjegy hibasak lehet a 4-gyel valo szorzas miatt)

NevemTeve irta, az ADA nagy szamok topikban:

> Altalaban nem szerencses dolog beleszeretni egy eszkozbe, plane minden mast lefikazni... elegansabb dolog egy feladatra fuggvenyt definialni, de persze lehet anelkul is
echo 'f=1;for (i=1;i<=300;++i) f*=i; print f,"\n"' | bc
igaz, nem sokkal gyorsabb a ruby-s valtozatnal.

Igen, a fikazas nem szep dolog. Bocs!

Viszont, szerintem szerencses dolog egy olyan eszkozt hasznalni, amely sokoldalu es sok celra hasznalhato, mert igy kevesebb dolgot kell megtanulni, masreszt a kulonbozo eszkozok kozotti interakcio (ami kicsit komplikaltabb esetben elofordulhat) is redukalhato. Ehhez persze kell egy eszkoz, amely alkalmas erre a szerepre.

Ennek demonstralasara javaslom a kovetkezo jatekot: irjatok akarmilyen (persze nem megoldhatatlan) problemat, amit kulonosen elegansan lehet perl,awk,m4,bc,(ba)sh vagy pythonnal megoldani. Szerintem legalabb ugyanolyan elegansan, gyorsan, vagy meg jobban megcsinalom ezt Rubyban.

Egy kis demo: numerikus matematika Rubyban

A kovetkezo ruby fuggveny egy komplex elemekbol allo vektor fourier transzformaltjat szamolja ki az k*log(k) futasideju Fast Fourier Transformation (FFT) algoritmus segitsegevel.

def fft(vals,n)

  size = 2**n

  vals.map! { |x| x/Math.sqrt(size) }

  j=0

  size.times do |i|

    vals[j],vals[i] = vals[i],vals[j] if i<=j

    m = size/2

    while (j>=m && m>1) do

      j-=m; m/=2

    end

    j+=m

  end

  k=1

  while(k    incr=2*k

    mul=Complex.polar(1,Math::PI/k)

    w=Complex.new(1)

    k.times do |i|

      i.step(size-1,incr) do |j|

        tmp=vals[j+k]*w

       vals[j+k],vals[j]=vals[j]-tmp,vals[j]+tmp

      end

      w *= mul;

    end

    k=incr

  end

end

Eloszor is:
A ruby nem nagy, fennt van egy ket perc alatt, minden linux disztribuciohoz ott van csomagkent es nem foglal tobbet ket-harom meganal. Meg modemmel is lejon par perc alatt.
Nem latom igazan a letjogosultsagat, hogy valaki avval sporoljon, hogy nem rakja fel a Rubyt, ha ki akarja probalni. Amint, lathattad a Linux-forumban (tippek trukkok), valaki akinek mondtam egy Rubys megoldast, 10 perc alatt megtalalta es felrakta a csomagot.
Ha valakinek akarsz adni egy programot odadhatod melle a ruby interpretert is exeben, nem nagy.

Ennek ellenere:

Exerb (Windows),
http://downloads.sourceforge.jp/exerb/1440/exerb-2.3.0.tar.gz

Ruby2C
http://easter.kuee.kyoto-u.ac.jp/~hiwada/ruby/rb2c/arc/rb2c- 0.6.1.tgz

Egyebkent minda ketto csak japan dokuval, es nem tudom mennyire stabilak es pontosan mit csinalnak.

Ha tenyleg packageles a gond, akkor tudok irni egy 20-soros C-programot, ami megoldja a kerdest (ez ugy mukodik, hogy az ember gyakorlatilag beforditja a Ruby scriptet egy konstans stringbe es felhivja ra a ruby_eval fuggvenyt. Persze ez beleforditja az egesz interpretert is.

Komolyabb kerdes az letitkositas, azaz, ha nem akarod, hogy a programod kivulrol elovashato legyen (a fenti megoldasokbol eleg jol lehet rekonstrualni az eredeti szkriptet). Erre is vannak fejlesztesek, de en az ilyennel filozofiai okokbol sem foglalkozom.

Van-e valamilyen módszer arra, hogy a ruby programokat futtatható fájlra
fordítsuk. Ugyanis az egyedüli nagyobb python programomnál az a gond, hogy
a felhasználónak akkor is Pythont kell telepítenie (a LaTeX mellett), ha
csak kipróbálni szeretné. Valamilyen fordítókról hallottam, de azok
állítólag majd az egész Pythont beleteszi.

Szóval van-e valamilyen forítója Linux ill. Windows alá?

Azoknak, akik tudnak nemetül:

A nepszerü c't magazin legujabb szamaban van egy haromoldalas cikk a Ruby-rol.

Nem tudom, nekem nem problema. En meg igy is könnyben olvasom mint a Pythont. Egyebkent ez a pelda kicsit extrem: a kiirasra, beolvasasra fajlkezelesre, regularis kifejezesektre a Ruby rengeteg modszert bocsajt rendelkezesre mindegyiknek megvan a maga erössege, de szerintem nem nehez öket megtanulni.

Mas dolgokra altalaban van "egy igaz ut".

Valahogy epp a keresztezese a Perl-nek es Pythonnak: a gyakran elöfordulo rutin dolgokra Perlnel is Perlebb Perl, a ritkabb koncepcionalisabb dolgokra Pythonnal is Pythonabb Python.

A Javaval es C++-al pont az a bajom, hogy nem birom a függvenyeket megjegyezni, mindig utana kell neznem. A Rubyban altalaban rögtön kitalalom, meg ha sosem olvastam a dokut, akkor is.

Kedves KoporShow!

Egy ideje érdeklődéssel figyelem a Ruby-t. És már régebben megtaláltam
cikkedet a linux.index.hu-n, de mivel egy nagyobb programot Pythonban
írtam, és újabbra nem szántam rá magam, maradtam annál.

Az az egyik aggályom, hogy ahhoz, hogy egy Ruby programot elolvassak,
meg kell értenem mindegyik formát:
puts "Hello Világ!"
printf ("%s %s!" ,'Hello','világ')
print "%s %s!" % ('Hello','világ')

Pythonnál elég az utolsót érteni.
Nincs sok ilyen benne? Vagy ez nem gond?

Üdvözlettel:
Árpi

Aki meg valami rendesebb ebvezetöt szeretne latni, az elolvashatja a kedvicsanlo Ruby-hoz cikkemet a

http://linux.index.hu/?site=program/ruby/ruby.html

cimen.

Nem cikizni akarlak, de sezrintem par csunyan formatalt ad hoc program, csak inkabb elrettenti az erdeklödöt, mint kedvet csinal. Egybekent persze mind igaz amit irsz.

ja, ez nem neked szól KoporShow, látom te már ismered a nyelvet.

A ruby könnyen bővíthető c nyelven (bár én nem értek a c-hez). A c-ben írt osztályok a sebességükön kívül semmiben sem különböznek a rubyban írtaktól.
Még nincs annyi minden rubyhoz, mint pl. a CPAN-ban, de már így is sok minden van.
Ruby Application Archive

Van hozzá pl. debugger, amit szintén rubyban írtak, összesen 823 sor, plus 160 sor a tracer osztály, amit használ.

Minden osztályváltozó private, tehát kívülről nem látható, viszont a setter/getter metódusok egyszerűen megadhatók:
class Test
attr_accessor :a
end
end
=
class Test
def a
return @a
end
def a=(value)
@a = value
end
end

Mondanom sem kell, az attr_accessor szintén egy metódus, ami szintén átdefiniálható (dirty checking)......

Ha a class Array kezdetű kódot végrehajtod egy ruby programban, azzal meg is változtattad az Array osztályt, azután már az új each függvényt használja minden tömb objektum, a lenti példában pl. az "a" objektum is, annak ellenére, hogy előbb lett definiálva, mint hogy az each-et hozzáadtam az Array-hoz.

Az nbsp; természetesen nem része a ruby szintakszisnak :-)

proxy.start("index.hu") do |http|
  puts( http.get("/index.html")[1] )
end

Ez a lényeges rész szvsz. a do utáni rész egy kódblokk, ami gyakorlatilag az utolsó (és mindig az utolsó) paraméter, amit átadsz a start függvénynek. Ezt egyszerűbb egy iteratorral leírni.
pl.:
a = [1, 2, 3]
a.each do |elem|
  puts elem
end
# output:
1
2
3

Megvalositasa kb.
class Array
def each
 nbsp;for i in 0..self.size
 nbsp; nbsp;yield self[i]
 nbsp;end
end
end

A yield-el tudod meghívni az átadott kódblokkot, átadva az aktuális tömbelemet paraméterként. Itt látszik, hogy a [] is egy metódusa az Array osztálynak.