最速スクリプト言語決定戦！

おまいら、そろそろ最速スクリプト言語がどれなのか決定しませんか？
最初のお題は「たらいまわし関数」でGO

Haskell

Lazyなやつは反則

言語仕様的にはRubyでしょ。
どこかのコピペにもあったけど、新しいだけあって
他の言語を凌駕してる。

RubyはPythonやPerlに負けてなかったか？
http://www.bagley.org/〜doug/shootout/bench/ackermann/

http://www.bagley.org/%7Edoug/shootout/bench/ackermann/
こっちだな。

Rubyは言語仕様が基地外じみていることが賞賛されるのに、
C#は言語仕様がJavaより複雑だとして非難されている。
これはつまり、Ruby信者とJava厨の声が大きいということでしかない。
そういう基地外の妄想を真に受けないこと。

おまいら、速さを語って下さい。

本当に早さではなく速さなのか？
だったら語ることは何もない。

H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！
H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！
H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！
H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！
H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！
H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！
H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！
H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！ H・S・P！

>>9
スクリプトの実行速度比較。
Rubyは1.6.8だから遅い。1.8は速い、と言っている
信者も居るので、おまいら実測で語って下さい、と。

Ocaml

>>6
これ「たらいまわし」じゃないし。

int tarai(int x, int y, int z)
{
if (x <= y) return y;
return tarai(tarai(x - 1, y, z),
tarai(y - 1, z, x),
tarai(z - 1, x, y));
}

開発の期間、実行開始までの時間、付属ライブラリの効率、
何が最速なんだか。

>>1
スクリプト言語ってのはお手軽に処理を自動化するためのもんであって
よっぽどの事がない限り速度なんて問題にならんけどな。

>>14
それ再帰。

このスレは実行速度のみでスクリプト言語を評価するスレです。

それなら圧倒的にperlだな。
唯一parrotが動く言語だから

開発速度
・速い … Perl
・遅い … C
実行速度
・速い … C
・遅い … Perl

以上。〜終了〜

Cはスクリプト言語じゃねぇっす。

Lispは？

LispはOK。
Schemeも参戦可。
ただしネイティブコンパイルは認めない。

もう>>19で結論は出てるだろ
さっさと終了しろ。

どう考えてもschemeだな。

>>24
これだからperl厨は。

マシン語。終了。

Gaucheマンセー

>>17
こいつ何言ってんの？

Perl で Inline:::C 使うのが早いんじゃない。
実行速度が必要ならスクリプト言語使わんつーの。

>>29
オーバーヘッドがものすごかったり。

Ocamlなのは明らかなのにこれ以上何を語るの？

Perl最強！

この板caml信者多いな。学生だらけってことか。

ネイティブコンパイル不可なのでOcamlが本当に最速になるかどうか・・・。
The Great Computer Language Shootoutのページには出てない早い処理系が
ある言語もあるしね。

ていうか>>1なんか無視してコンパイルありで最速言語の話にしよう。

>>35
機械語
で終了。

機械語なんて書けねえだろ！高級言語オンリー！
つーわけでC。

*******************************************

　　　　　　　　　　　終　　　　　　　了

*******************************************

Cは低級言語。



＊＊＊＊＊＊＊＊＊＊＊よって再開＊＊＊＊＊＊＊＊＊＊＊＊＊

高級言語の定義すら知らない馬鹿が一匹

>>39
いや、あってるだろ。

>>38にとってCは理解しがたいコンピュータよりの言語だと言うだけの話だ。

そしてそれは一般人から見れば正しい見解であると思うが。

一般人って非プログラマのこと？
そんな視点に高級低級の定義を任せるのか？

>>38-39
新説を述べるときは説明責任を果たせ。

おまいら、スクリプト言語の速さについて語ってください。

Faster than a bullet

>>41
それじゃネタ振りとして>>6のサイトにある benchmark を最新の実装でテスト
して報告して下さい。話はそれから。

じゃ、>>41さん、おながいします。

私の見たい対戦カード、

　ピュアOOPL頂上対決：Ruby vs. Smalltalk
　関数型真の頂上対決：Ocaml vs. Scheme （←SchemeはGaucheで）
　次世代VM対決：Parrot vs. RubyVM　（まだ無理か）

　

｜　ピュアOOPL頂上対決：Ruby vs. Smalltalk
Smalltalk

|　関数型真の頂上対決：Ocaml vs. Scheme （←SchemeはGaucheで）
Haskell

｜次世代VM対決：Parrot vs. RubyVM　（まだ無理か）
どっちも vaporware なので引きわけ

>>46
>　関数型真の頂上対決：Ocaml vs. Scheme （←SchemeはGaucheで）
Haskell とか Clean では無い訳ね?

>>48
Lazyな奴は階級が違うという認識で・・・。

じゃあエキジビジョンマッチ：Haskell vs. Cleanもキボンヌ。

あー間違えた。
s/>>41/>>43/

>>51
エスケープしろよ・・・

え、(;´ Д｀)オレ？

仕方ないのでちっとも最新の実装じゃないが晒す。

tarai(12,6,0)の結果
（Rubyを1.0とした時の相対速度。小さいほど速い。）

Python2.2.2:　0.50
Ruby1.6.8:　　1.00
Perl5.8.1:　　1.12
CLISP2.29:　　1.80



・・・・・・Pythonマンセー。

12 6 0でたらい回すと俺のperlはコアダンプ吐いて死ぬ。

>>55
6 3 0でたらいまわせば？

なあ遅延評価とかいうのが鍵になってるそうだが、
そうするとはしょりのうまいスクリプトが一番早くなるのか？

まあ、それも早さなんだろうけど…

あらゆる場面で、ではないんだよな。

pikeっつうのもある

http://pike.ida.liu.se/

>>57
小細工なしの素直なコードで速度を競うのが一応このスレの趣旨。

>>60
初めて聞いた。

これをみると Lua ≒ Io < Perl < Python だな。
http://www.iolanguage.com/comparisons/Performance.html

Ｈｓｐは？

>>63
HSPでもいいけど
そろそろPerlに移行したらどうだい？
HSP習得できるなら
CでもC++でも習得できると思うぞ。
言語は言われてるほどそんなに変わらないよ。

えーっとスレを精読した結論として、WSHが最速っていうことでo.k?

BFだ！　ハード実装されたBFが一番早い！！
http://pc2.2ch.net/test/read.cgi/tech/1036013915/
時代はシェル・スクリプト・アクセラレーター

アセより読みずらいBF、WhiteSpace等は無しでおねがいします

とりあえず、ここで語ってる人って、
それぞれの言語使った事あるのかな？
漏れはPerlもHSPもRubyも使ったけど
一番、（・∀・）ｲｲ!! と思った言語は、

　l i n g o

・・・ああ、でも最速ではないですね。ゴメソ

Pikeなら使ってるが、正直英語のドキュメントすらかなり不足してる上に、
日本語の文献となると0ではない、つーレベルなんで勧めはしないな。
あと、正規表現まわりはかなり貧弱。

まぁ、画像まわりのライブラリが異常に強力だったりするが。

おまいら、マターリ話してないで、たらいまわしてください。

だったらテメーがコード書けや。人任せにすんなヴォケ。

ここは、１がぜんぶやるスレです

>>71
(　´ ∀｀)>>54は漏れ・・・・。

>>72
まだ自作自演しなきゃならないのか・・・。

ghc のある Haskell が最速ってことで。

変わったとこで Strongtalk (強い型付きの Smalltalk )

Tarai >> x: x <Int> y: y <Int> z: z <Int> ^ <Int>
　x <= y ifTrue: [^ y].
　^ self
　　x: (self x: x-1 y: y z: z)
　　y: (self x: y-1 y: z z: x)
　　z: (self x: z-1 y: x z: y)

Time millisecondsToRun: [Tarai x: 12 y: 6 z: 0]

=> 0.27 / (ruby 1.8.0 (2003-08-04) [i386-cygwin])

>>75
一桁間違えた…。

=> 0.027 / (ruby 1.8.0 (2003-08-04) [i386-cygwin]

>>75
対Ruby(1.8)比で0.27か。
Strongtalkって知らなかったけど結構速いね。

なに？0.027ですと？
爆速ですな。

Shootoutのページの数値から類推するにStrongtalkはOcamlと
いい勝負しそうな予感。

既出だけど比較のため。
GNU CLISP 2.31 (2003-09-01) (Common Lisp インタープリタ)

(defun tarai (x y z)
　(if (<= x y)
　　y
　　(tarai
　　　(tarai (1- x) y z)
　　　(tarai (1- y) z x)
　　　(tarai (1- z) x y))))

(time (tarai 12 6 0))

=> 1.8 / (ruby 1.8.0 (2003-08-04) [i386-cygwin])

Gauche 0.7.3 (Scheme インタープリタ)

(define (tarai x y z)
(if (<= x y)
　　y
　　(tarai
　　　(tarai (- x 1) y z)
　　　(tarai (- y 1) z x)
　　　(tarai (- z 1) x y))))

=> 0.45 / (ruby 1.8.0 (2003-08-04) [i386-cygwin])

ruby 1.00 (ruby 1.8.1 (2003-12-25) [i386-mswin32])
gosh 0.31 (gauche 0.7.1)
petite 0.14 (petite chez scheme 6.0a)

VisualWorks 7.1 (XEROX Smalltalk-80 の正統な継承者)

Tarai class >> x: x y: y z: z
　x <= y ifTrue: [^ y].
　^ self
　　x: (self x: x-1 y: y z: z)
　　y: (self x: y-1 y: z z: x)
　　z: (self x: z-1 y: x z: y)

Time millisecondsToRun: [Tarai x: 12 y: 6 z: 0]

=> 0.02 / (ruby 1.8.0 (2003-08-04) [i386-cygwin])


Squeak 3.6 (XEROX Smalltalk-80 の派生物の Apple Smalltalk の派生物)
(VisualWorks とコード同じ)

=> 0.2 / (ruby 1.8.0 (2003-08-04) [i386-cygwin])

もっさりとした印象の VisualWorks が Strongtalk 以上のパワーを発揮したのは
意外でした。Squeak はやはり、Smalltalk 勢の中ではへたれてる。

(define *memorize-table* '())
(define (memorize proc)
　(lambda args
　　(let ((x (assoc args *memorize-table*)))
　　　(if x (cdr x)
　　　　　(let ((result (apply proc args)))
　　　　　　(set! *memorize-table* (cons (cons args result) *memorize-table*))
　　　　　　result)))))

という感じのマクロ用意して

(define tarai
　(memorize ;; ←これ追加
　　(lambda (x y z)
　　　(if (<= x y) y
　　　 (tarai
　　　　 (tarai (- x 1) y z)
　　　　 (tarai (- y 1) z x)
　　　　 (tarai (- z 1) x y))))))

(tarai 12 6 0) ;; => 12
でほぼゼロになる。
まあ、メモ化は無しだよね。

マクロじゃなくて関数だった。

memoizeは参考記録ということで。
Smalltalkって結構速いなぁ。見直した。

Self 4.1.5

_AddSlots:
(| taraiX: x Y: y Z: z = (
x <= y ifTrue: [^ y].
^ taraiX: (taraiX: x-1 Y: y Z: z)
Y: (taraiX: y-1 Y: z Z: x)
Z: (taraiX: z-1 Y: x Z: y)) |)

[taraiX: 12 Y: 6 Z: 0] time

=> 0,45 / (ruby 1.8.1 (2003-12-25) [powerpc-darwin])

>83
Squeak はともかくVisualWorksやStrongtalk はネイティブ化してるでそ

>>88
てへっ。

Lua 5.0 Copyright (C) 1994-2003 Tecgraf, PUC-Rio

function tarai(x, y, z)
if x <= y then return y else return tarai(
tarai(x - 1, y, z), tarai(y - 1, z, x), tarai(z - 1, x, y)) end end

=> 0.30 / ruby 1.8.1 (2003-12-25) [i386-mswin32]

∩(´･ω･`)∩たらいまわせ！

Objective Caml version 3.07+2

let rec tarai x y z =
　　if x <= y then y
　　else tarai (tarai (x - 1) y z) (tarai (y - 1) z x) (tarai (z - 1) x y);;
Printf.printf "%d\n" (tarai 12 6 0)

=> 0.036 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

Gauche scheme interpreter, version 0.7.3
(define (tarai x y z)
　　(if (<= x y)
　　　　y
　　　　(tarai (tarai (- x 1) y z)
　　　　　　(tarai (- y 1) z x)
　　　　　　(tarai (- z 1) x y))))
(tarai 12 6 0 )

=> 0.097 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

Gaucheの結果が>>82とかなり違うなぁ。
噂に違わずOcaml速えぇ。

ところで、

ruby 1.8.1 (2003-12-25) [powerpc-darwin]
=> 0.99 / ruby 1.6.8 (2002-12-24) [powerpc-darwin7.0]

でした。
たらいまわし関数については1.6と1.8の実行速度に大きな差はないようだ。

参考までに(ruby 1.8.1 (2003-12-25) [i386-mswin32] )

自作Cインタプリタ 0.029　（直接ネイティブコードに翻訳）
VC7　　　　　　　　　0.011　 (/O2オプションのみ)

結局、0.1より下回るにはJITかネイティブへ変換するしかなさそうで、
VM駆動系は0.3〜0.2なら速い部類、Cのswitch-caseを使った実装では
0.2辺りが多分限界じゃないかと思う。ネイティブ変換しない形で速度を
追求するならforthやpetite-scheme、qscheme等が採用している、
threaded codeの形式にするしかないんじゃないか？
とか書いてたら、

>>92
>Gauche scheme interpreter, version 0.7.3
>=> 0.097 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]
なんでこんなに違いが・・
OS・環境にかなり左右されるのか、それとも7.1->7.3で何かあるのか。

>>81はGauche0.7.3で0.45なのでバージョンよりも
プロセッサ(i386 vs PowerPC)の違いが大きいみたいだな。

>>92のOcamlはネイティブコンパイルしてないし、
GaucheもVMだから、PowerPC系では早いVMなら
0.1を切ることができるみたいなり。

ついでにForthでやってみた。
gforth 0.6.2
=> 0.05 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

VM系ではやはりOcamlが最速か？

int tarai(int x, int y, int z)
　{
　if (x <= y) return y;
　return tarai(tarai(x - 1, y, z),
　　　　　　　　 tarai(y - 1, z, x),
　　　　　　　　 tarai(z - 1, x, y));
　}
丶────────────v──────────
　　　HEY！ YO！ slash !!
　　　　　　　　　　　　　　　　∧＿∧ 　sh !!　sh !!
　　　　　　　　　　bin !　　　（´∀｀　）　　　　　
　 　 　 　 　 　 ＿＿＿＿○＿＿＿つヾ＿＿
　 　 　 　 　 ／⊂二⊃／†：：† ／⊂二⊃ .／|
　　　　　　　|￣：：：￣.|￣￣￣|￣ ：：： ￣ |　.|
　　　　　　　| TARAI　|￣￣￣|MAWASHI.|　.|

CLISP の結果ってバイトコンパイルしたやつ？ VM の速度比較なら VM が
実行するバイトコードで計測してあげないと。実際、ロード時に勝手に
コンパイルするオプションがあるわけで、コンパイルした結果つかわない
と気の毒な気がするんだが…。（Ruby が無いので自分では比較できん）

>>95
自分もocaml入れて試してみた。
http://caml.inria.fr/distrib/ocaml-3.07/ocaml-3.07pl2-win-msvc.exe
ここのバイナリからocaml.exe
=>　0.12 / ruby 1.8.1 (2003-12-25) [i386-mswin32]

petite-schemeより少し速い、でもPowerPC程の差はなかった。
やっぱりＯＳかプロセッサに依存してるみたいね。
つーかRubyがよっぽどヘタる実装なのか。
それにしてもOCaml速えーな。

実行時バイトコードコンパイルするスクリプト処理系だとRuby比0.2ぐらいはでるってことは、
RubyもVM実装したら最大５倍速くなる可能性があるってことか？

ちなみにPike(7.4.31-Win32-Windows-NT-5.1.2600-i86pc)
=> 0.159 / ruby 1.8.1(2003-12-25)[i386-mswin32]

>>99
こんなのもある。
プロセッサごとにdirect,indirect,switchなどのthreaded VMの性能比較。

http://www.complang.tuwien.ac.at/forth/threading-v1/
http://www.complang.tuwien.ac.at/forth/threading/

Pentium系プロセッサはdirect threadedにしてもあまりVM性能があがらないのかな。

CLISPをコンパイルしてやってみた。

GNU CLISP 2.29 バイトコードコンパイル済み
=> 0.14 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

かなり速くなるね。

Rubyに　勝ったら　コイツで　報告♪
　　　Rubyに　負けたら　タライが　落ちる♪
丶────────────v──────────
　　　HEY！ YO！ slash !!
　　　　　　　　　　　　　 ∧＿∧ 　　　　sh !!　sh !!
　　　　　　　　bin !　　 （´∀｀　）　　　　　
　 　 　 　 　 　 ＿＿＿_ゝ つ＿つｿ＿＿＿＿
　 　 　 　 　 ／⊂二⊃)).†：：†..／⊂二⊃))／|
　　　　　　　|￣：：：￣.|￣￣￣|￣ ：：： ￣ |　.|
　　　　　　　| TARAI　|￣￣￣|MAWASHI.|　.|

ちなみにロード時コンパイルオプションでやってみると
0.15 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]
でした。
見直したぜ、CLISP。

自分もCLISP試してみた。(clisp-2.32-win32.zip)

(defun tarai (x y z)
　(if (<= x y) y
　　(tarai
　　　(tarai (- x 1) y z)
　　　(tarai (- y 1) z x)
　　　(tarai (- z 1) x y))))
(compile 'tarai) ;; ←これだけで良い？
で、
=> 1.8 / ruby 1.8.1 (2003-12-25) [i386-mswin32]
だった。
ppcは不思議な石だな・・

ところで、taraiだけベンチって意味あるのか疑問に思えてきたが。

ﾔﾊﾟｰﾘなぁ。Lisp の中では遅いと言われているけどいくらなんでもそこまで
遅いとは思わなかったんで。もつかれさまですた。

失礼
>>105のCLISPの1.8は0.18間違いでした。

ちなみに
Petite Chez Scheme Version 6.9b
0.089 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

ですた。

>>105
漏れのは起動時に-Cオプションをつけただけです。

BrainFuckでtaraiって書けるの？

Python 2.3.3 で試した。

=> 0.416 / ruby 1.8.1 [i386-cygwin]

ですた。まぁまぁの結果。

gforth-fast 0.6.2

: tarai { x y z }
　　x y <=
　　if
　　　　y
　　else
　　　　x 1- y z recurse
　　　　y 1- z x recurse
　　　　z 1- x y recurse recurse
　　then ;
12 6 0 tarai . cr bye

=> 0.02 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

ｷﾀ━━━━━━(ﾟ∀ﾟ)━━━━━━!!

丶────────────v──────────
　　　　　　　　　　　　　 |ｌ|＿＿＿ｌｌ||
　　　　　　　　　　　 |ｌ .／ｶﾅﾀﾞﾗｲ＼
　　　　　　　　　　　　 .|／￣￣￣＼| <<
　　　　　　　　　　　　　＼＿＿∧／从
　　　　　　　　GON !　　 （´Д｀ ；）
　 　 　 　 　 　 ＿＿＿_γ＿＿＿つｿ＿＿＿
　 　 　 　 　 ／⊂二⊃).∪：：†.／⊂二⊃))／|
　　　　　　　|￣：：：￣.|￣￣￣|￣ ：：： ￣ |　.|
　　　　　　　| TARAI　|￣￣￣|MAWASHI.|　.|

ｶﾅﾀﾞﾄﾞﾗｲ

本命のHaskellが出てないね。
他はだいたい出揃ったかな。

>>114
>>49

Hspは？

・・・ここにおいておきますね。

PHP 4.3.2 Zend Engine v1.3.0

<?php
function Tarai($x, $y, $z){
　if($x <= $y) return $y;
　return Tarai(Tarai($x - 1, $y, $z), Tarai($y - 1, $z, $x), Tarai($z - 1, $x, $y));
}
$r = Tarai(12,6,0);
print "Tarai(12,6,0): $r\n";
?>

1.7 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

もうたらいまわしはいいよ。

C++インタプリタとかいうCINTとかROOTとか
試して欲しいなあ。

藻前がやれ＞１１９

>>111
forthはthenの位置とかrecurseがｷﾓｲね
相互再帰とかどうなんの？

>>120
やりました。スタックオーバーフローで死にました。


再帰じゃないテスト無いの？

Nested Loops
http://www.bagley.org/~doug/shootout/bench/nestedloop/

これなんてどうだろう？
N = 16 で。

# ruby
n = 16
x = 0
n.times do
n.times do
n.times do
n.times do
n.times do
n.times do
x += 1
end
end
end
end
end
end
puts x

>>119
UnderC(1.2.9w)（Win32)
=> 0.266 / ruby 1.8.1(2003-12-25)[i386-mswin32]

…マイナーすぎか。

>>123
| n x |
n := 16.
x := 0.
n timesRepeat: [
　n timesRepeat: [
　　n timesRepeat: [
　　　n timesRepeat: [
　　　　n timesRepeat: [
　　　　　n timesRepeat: [x := x + 1]]]]]].
^ x

Squeak 3.6
　=> 0.58
/ ruby 1.8.1 (2003-12-25) [i386-cygwin]
Strongtalk 1.1.1
　=> 0.24 / 〃
VisualWorks 7.1
　=> 0.03 / 〃

>>123 マクロ展開で時間を無駄遣いしてるがまー誤差だろ。
わざわざ Ruby インスコしちまったぜ。
(defmacro nest (N nest-level &body body)
(if (<= nest-level 1)
`(loop repeat ,N do ,@body)
`(loop repeat ,N do (nest ,N ,(1- nest-level) ,@body))))

(defun test (&aux (x 0))
(nest 16 6 (incf x))
(print x))

(test)

=> 0.165 / ruby 1.8.1 (2003-12-25) [i386-freebsd4.9]

何LISP？

>>127 ｽﾏｿ一番大事な事を書き忘れたな…。Common Lisp 界最遅の CLISP ﾀｿです。
他のはコンパイラばっかなんで参戦できねー。

CMUCL の PYTHON なら良いんじゃない?
うちは Mac なので無理だけど。

CMUCL の Python は ネ イ テ ィ ブ コ ー ド コ ン パ イ ラ

php3,4,5 てどうよ。

>>126 ユーザビリティの低いクソコードじゃ速度で勝ってもしょうがないね

Self 4.2

_AddSlots: (|
　nestedLoops: n = (
　　| x <- 0 |
　　n do: [
　　　n do: [
　　　　n do: [
　　　　　n do: [
　　　　　　n do: [
　　　　　　　n do: [x: x+1]]]]]].
　 ^ x) |)

[nestedLoops: 16] time

=> 0.055 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

CLISP 2.32
マクロを使わずに命令的にそのまま。

(defun nestedLoops (n)
　(let ((x 0))
　 (loop repeat n do
　 (loop repeat n do
　 (loop repeat n do
　 (loop repeat n do
　 (loop repeat n do
　 (loop repeat n do (incf x)))))))
　
x))

(time (nestedloops 16))
=> 5.05 / ruby 1.8.1 (2003-12-25) [i386-cygwin]

(compile 'nestedloops)
(time (nestedloops 16))

=> 0.19 / ruby 1.8.1 (2003-12-25) [i386-cygwin]

>>130
そうだったっけ? ｽﾏｿ。
CMUCL はインタープリタ積んでるはずなんで、それ使ったラッテコとね。

ラッテコって何だろう・・・。

このスレのためにrubyインストールしたぜ。

Ｈｓｐは？

自分でやれよ

spidermonkey

function tarai(x, y, z) {
　　　if(x<=y) return y;
　　　return tarai(tarai(x-1, y, z),
　　　tarai(y-1, z, x),
　　　tarai(z-1, x, y));
}
print(tarai(12,6,0));

=> 3.50 / ruby 1.8.1 (2003-12-25) [i386-win32]

>>6
mawkってperlより全然速いんだね。awkファンとして嬉しい。
perlより遅いという評価が定着したのはgnuのせいだ。

Objective Caml version 3.07+2

let n = 16
let rec loopF x = function 0 -> x | i -> loopF (x+1) (i-1)
let rec loopE x = function 0 -> x | i -> loopE (loopF x n) (i-1)
let rec loopD x = function 0 -> x | i -> loopD (loopE x n) (i-1)
let rec loopC x = function 0 -> x | i -> loopC (loopD x n) (i-1)
let rec loopB x = function 0 -> x | i -> loopB (loopC x n) (i-1)
let rec loopA x = function 0 -> x | i -> loopA (loopB x n) (i-1);;
Printf.printf "%d\n" (loopA 0 n)

=> 0.054 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

一応CLISPとも比較
GNU CLISP 2.29 (-Cオプション)

(defmacro nest (N nest-level &body body)
(if (<= nest-level 1)
`(loop repeat ,N do ,@body)
`(loop repeat ,N do (nest ,N ,(1- nest-level) ,@body))))

(defun test (&aux (x 0))
(nest 16 6 (incf x))
(print x))

(test)

=> 0.13 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

さらにgforthとも・・・。
gforth-fast 0.6.2

16 value n
: nestedloop
　　0 n 0 do
　　　　n 0 do
　　　　　　n 0 do
　　　　　　　　n 0 do
　　　　　　　　　　n 0 do
　　　　　　　　　　　　n 0 do
　　　　　　　　　　　　　　1+
　　　　　　　　　　　　loop
　　　　　　　　　　loop
　　　　　　　　loop
　　　　　　loop
　　　　loop
　　loop
;
nestedloop . cr

=> 0.018 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

lua

n = 16
x = 0
for i = 1, n do
for j = 1, n do
for k = 1, n do
for l = 1, n do
for m = 1, n do
for o = 1, n do
x = x + 1
end
end
end
end
end
end
print(x)


=> 0.228 / ruby 1.8.0 (2003-08-04) [i386-cygwin]

http://sheepman.parfait.ne.jp/20030418.html#p05
これのruby版が早過ぎるんだが、どういうことなんでしょう
ネエティブコンパイルしたのに勝ったんだが・・・

引数でかくすればきっと負けてくれるでしょう。

くやしくて、ネエティブコンパイラの方でも、同じことやらせたらruby版に勝てた
ruby版より行数膨らみすぎたけど。

遅延評価の一旦を垣間見た気がした

>>145
Ruby で速いなら、ほかのではもっと速い？

Squeak 3.6

Tarai class >> x: x y: y z: z
　x value <= y value ifTrue: [^ y value].
　^ Tarai
　　x: [Tarai x: [x value - 1] y: y z: z]
　　y: [Tarai x: [y value - 1] y: z z: x]
　　z: [Tarai x: [z value - 1] y: x z: y]

Time millisecondsToRun: [Tarai x: [64] y: [32] z: [0]]

=> 0.001 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

速かった…(藁

>>148
yの評価を端折ればさらに３倍強(偶然?)。たぶんrubyも一緒。

Tarai class >> x: x y: y z: z
　| yValue |
　x value <= (yValue _ y value) ifTrue: [^ yValue].
　^ Tarai
　　x: [Tarai x: [x value - 1] y: y z: z]
　　y: [Tarai x: [yValue - 1] y: z z: x]
　　z: [Tarai x: [z value - 1] y: x z: y]

速度じゃないけど nested loop のソースを見ると >>142 のコードがｲｲね。
LISP ｶｺｲｲ。

Python 2.3.3 (2003-12-18) [i386-mswin32]

from itertools import repeat
n = 16
x = 0
for i in repeat(None, n):
  for i in repeat(None, n):
    for i in repeat(None, n):
      for i in repeat(None, n):
        for i in repeat(None, n):
          for i in repeat(None, n):
            x += 1
print x

=> 0.677 / ruby 1.8.1 (2003-12-25) [i386-mswin32]

微妙・・・

>>150
マクロがないので、悔し紛れにクロージャで(^_^;)

VisualWorks 7.2nc

| nestedLoops x |
nestedLoops := [ : n : nestLevel : proc |
　nestLevel = 0
　　ifTrue: [proc]
　　ifFalse: [
　　　nestedLoops
　　　　value: n
　　　　value: nestLevel-1
　　　　value: [n timesRepeat: proc]]].
x := 0.
(nestedLoops value: 16 value: 6 value: [x := x + 1]) value.
^ x

print it時にいろいろ叱られた末、速度も200%増しでｼｮﾎﾞｰﾝ
かえって分かりにくいし…

>>152
>>152
Squeakはブロックで再帰呼び出しができないので、メソッドで

Integer >> levels: n timesRepeat: aBlock
　self < 1 ifTrue: [↑ aBlock].
　↑ self-1 levels: n timesRepeat: [n timesRepeat: aBlock]

| x |
x ← 0.
(6 levels: 16 timesRepeat: [x ← x + 1]) value.
↑ x

こちらはなぜかちょびっと速くなる。

>>152-153
マクロなど羨しがるな。みっともない。同じオブジェクト指向な言語として恥ずかしいぞ。
「ループを 6 回繰り返すコードを書け」と書ける事になんの意味があると言うのだ。
オブジェクト指向は構文抽象よりもはるかに高尚でエレガントなのだ。
マクロは使用法によらず常に悪である。なぜならば、マクロはつまりユーザビリティが低いのだ。
マクロを使うとコードはわかりにくくなるからだ。

馬鹿にはね。

def nest(n, nest_level, &body)
return body if nest_level < 1
nest(n, nest_level-1) {n.times(&body)}
end

x = 0
nest(16, 6) {x += 1}.call
puts x

それは「ループを書くコード」じゃなくてただの「ループするコード」だって
わかって書いてるの？どうでもいいけど Ruby が良いのはもう十分理解ましたので
勘弁してください。

なんでちょっとでも言語ネタが出ると Ruby の話になるんだろう。
だれかﾏｲﾅｰ言語のベンチマークで本題に戻して〜

>>150
まくろって、つおい？

: nest { n d c }
　　d 0 do
　　　　n postpone literal 0 postpone literal postpone do
　　loop
　　c compile,
　　d 0 do
　　　　postpone loop
　　loop
;

: nestedloop 0 [ 16 6 ' 1+ nest ] ;

nestedloop . cr


=> 0.010 / ruby 1.8.1 (2003-12-25) [powerpc-darwin]

16が即値で展開されるためさらに速くなった。

>>159は
gforth-fast 0.6.2
でつ。

∩(´･ω･`)∩ｱｹﾞﾄｷﾏｽﾈ

(´･ω･`)ｱｶﾞｯﾃﾅｲｼ

荒れてしまって申し訳ない。 >>159 さん自分は厨なので LISP も Forth もちゃんと触った
事はないので聞かれても…

>>151

def nested(n):
    x = 0
    i_r = range(n)
    for a in i_r:
        for b in i_r:
            for c in i_r:
                for d in i_r:
                    for e in i_r:
                        for f in i_r:
                            x += 1
    print x

じゃ駄目なの？

Python 2.3
=> 0.370 / ruby 1.8.1 (2003-12-25) [i386-mswin32]

>>164
おいらが浅はかだっただけでつ(´・ω・｀)

gforthはnative並の速さだな
もしかして実行時コンパイル？

>>166
コンパイル時実行、
・・とForth界隈では呼ばれています。マクロじゃなくて。
でもこの「コンパイル」っていうのは、ForthではVMコード
生成のことを言ってるわけで、ネイティブコード生成ではないです。
gforth自体はVMで動作してます。

Forth ってすげぇ〜 VM 動作でこの速度かよ!! 恥ずかしながら
てっきり実行時にコンパイルしてるもんだと思ってた…

;; CMUCL で型指定付きでコンパイル
* (time (test))
; Evaluation took:
; 0.03 seconds of real time
; 0.023329 seconds of user run time
; 0.0 seconds of system run time
; 32,939,360 CPU cycles

;; インタプリタ起動時間込みでこれ．
$ time gforth-fast nest.f -e bye
16777216
gforth-fast nest.f -e bye 0.27s user 0.00s system 99% cpu 0.275 total

forth ｽｺﾞｲ
ﾏｼﾞｵｽｽﾒ
と思ったけど日常生活で使うにはやはり厳しい…

cmuclはネイティブコンパイラですね。
ForthだとbigForthがネイティブコンパイルできるんですが、
まあ、スレ違いということで。。。。

ディスコンパイルすればちゃんとVMとして残ってるのがわかる。
see nestedloop
: nestedloop
0 <4212491> <16> 0
DO 16 0
DO 16 0
DO 16 0
DO 16 0
DO 16 0
DO 1+
LOOP
LOOP
LOOP
LOOP
LOOP
LOOP ; ok

ただしプリミティブを見るとnativeコードになってる
see 1+
Code 1+
( $401ABB ) inc ecx \ $41
( $401ABC ) add ebx , # 4 \ $83 $C3 $4
( $401ABF ) jmp dword ptr FC [ebx] \ $FF $63 $FC
end-code

この最後の２行に注目すると、
( $401ABC ) add ebx , # 4 \ $83 $C3 $4
( $401ABF ) jmp dword ptr FC [ebx] \ $FF $63 $FC

direct threaderd codeという方法を使ってるのがわかる。（ebxがpcに相当）

綴り間違えた
s/threaderd/threaded/

ちなみにgforth0.6以降は、

>New threaded code execution method: primitive-centric (allows the following),
>hybrid direct/indirect threaded (easier portability), with dynamic superinstructions
> (typical speedup on Athlon: factor 2).

と書かれていてprimitive-centricという新しい手法を使っているらしい。
（詳細不明。。）

正直、動的型な言語だとまず型チェックとか入るから
いきなりinc ecxとか実行でけるforthがうらやましい。
つーことはecx何某はスタックトップの演算ということかな。
（あんま知らないので間違ってたらすまそ）

ecxはレジスタらしいね。
スタックトップ(TOS)をレジスタに割り当てるのはVMの高速化の常法。

>>170
そうです。型指定しないと generic-function (bignum かもしれないんで)
呼んじゃうので forth より遅かったです。でも良く考えたら最適化コンパイラ
じゃ構造がかわっちゃうかもしんないから >>171 を見てもそもそも比較に
なんないっすね…。

void main() {
int n=16;
int x=0;
int a,b,c,d,e,f;
for (a=0; a<n; a++){
for (b=0; b<n; b++){
for (c=0; c<n; c++){
for (d=0; d<n; d++){
for (e=0; e<n; e++){
for (f=0; f<n; f++){
x++;
}
}
}
}
}
}
printf("%d\n", x);
}

cint
=> 0.32 / ruby 1.8.1 (2003-12-25) [i386-mswin32]

あ、今Ｈｓｐで動作計測したんだけど
たぶん一番早いよコレ。マジすごすぎだわ。
諸事情によりくわしいことはいえないんだけどどれよりも早かった。ほんと。

かんじおべんきょうしろ。

あ、今BrainFuckで動作計測したんだけど
たぶん一番早いよコレ。マジすごすぎだわ。
諸事情によりくわしいことはいえないんだけどどれよりも早かった。ほんと。

Haskellをリクエストしている人がいたので参戦。
tarai (640, 320, 0)

module Main where
tarai :: Int -> Int -> Int -> Int
tarai x y z
  | x <= y  = y
  | otherwise = tarai (tarai (x - 1) y z) (tarai (y - 1) z x) (tarai (z -1) x y)
main = print $ tarai 640 320 0

ghc -O2 tarai.hs
./a.out  0.00s user 0.01s system 105% cpu 0.017 total

runhugs tarai.hs
runhugs tarai.hs  3.17s user 0.12s system 89% cpu 3.671 total
# やっぱりhugsは遅い。

ちなみに
http://sheepman.parfait.ne.jp/20030418.html#p05
のRuby版は(620, 320, 0)では終わらない。# 所詮偽物。

runhugsは起動だけで0.20秒ぐらいかかるから(12,6,0)で比べるのは
無意味。

>>181,182
>>49

>>183
そもそもGHCは実行ファイルはき出すコンパイラだし。

>>183
わかってるけど、最近Lazyが云々っていうレスが続いてたからね。

せっかくだから誰かCleanでHaskellに挑戦してくれ。

(´･ω･`)ﾎｼｭ

Cleanはネイティブコード吐くよ

GHC もネイティブコード吐くよ

�潟Tンファイナンスです。
全国即日スピード融資。
東京都知事認可済みの消費者金融です。
まずはHPをご覧ください。
http://sunfaina.fc2web.com/

スマン、たらいまわし関数って何？
まえ市役所に行ったらたらいまわしにされたけど、
それはおいといて、マジわからん。

>>191
>たらいまわし関数って何？

その「何？」って「何の役に立つのか？」って意味か？

・・・何の役にもたたんよ。

ちょうど市役所のたらいまわしシステムがベースです

たらいまわしの語源て何よ。
むかしむかし、タライを回す、おじいさんとおばあさんがいました。
みたいなお話キボンヌ。
つーか、たらいって何？

辞書引けカス。

>>192
「たらいまわし」は曲芸の名前。曲芸師が仰向けになって、足でタライを回す芸。
時には、二人の曲芸師がタライでキャッボールをすることもある。その様子が
役所などで「たらいまわし」そっくりな為。

なんか最近やけに他人の代わりに Google を使う事が多いような気がする。
こういう時代なのか・・・

たらい知らないやつがいるのか
芸人の上から降ってくるのが金（かな）だらい

真心ブラザーズの歌にもあるよね

あれは猿回しか

たらい回し関数で計れる性能って関数呼び出しですかね？

200ｹﾞﾄー
　　　　　　　　　,､　　　　　　　,､
　　　　 ,;''"";､　!　＼　　　　 / ヽ,
（ （　　(　O　;, '　　　`''"''''"''　　 ﾞ;.
　　　　 ';,　　 !;　　　　　　　　 　　 ;;
　　　　　';､　;;'　　　　Ｏ　　　　O 　;!　　>>199はハムスター。
　　　　　　';,　';,　＊　　┌―┐　　,;
　　　　　　　ﾞ:､`:､　　　 　　_ノ　 ,.;'
　　　　　　　　ヽ､　　　　　　　,,:　ヽ
　　　　　　　　 　 ';,.　　r'⌒''"　　　';,
　　　　　　　　　　,..;､.,　ヽ,,.　　　　　';,,
　　　　　　　　 　ﾉ｡o｡ ヽ　 ﾞ"''‐''"　　 ';,
　　　　　　（ （　 ;' ○ ;;,!､　　　　　　　　;,　　　　　　;`';,
　　　　　　　　 　 `ー‐' -"''-;,,､　　　　　;;i'"""ヽ､ノ　,;
　　　　　　　　　　　　　　　　　 ;;,　　　　 ,;;'⌒`:､,..,,;;''
　　　　　　　　　　　　　　　　　　';,　　　 ;;'
　　　　　　　　　　　　　　　　　　 (,,_,,_,,ノ

次期 Ruby が最強スクリプトってことでまとまったな。

なんてったってRPGツクールに搭載だもんな

実績、性能、将来性、ユーザビリティ、オブジェクト指向の純粋性、
すべてにおいて次期 Ruby は最強というわけか。

>>203
*次期* かよ…。_|￣|○　と、いちおうツッコンでおく。

きっとRuby 2.0はめっちゃ速いはずだよ

Ruby 2.0 は最強。他は負け組み。ﾌﾟﾌﾟﾌﾟ。

次期Perl
次期PHP
に続いて、次期Rubyもあるんだな・・・。

磁気HSPﾏﾀﾞｧ〜？

どの次期がいちばんはやいか競うスレはここでしょうか？

Slangが最強

>>210
アンインストールすると多くのディストリで不具合が起こったりするからな。最強だ。

>>211
それは最悪の間違いだろ。だいたい最速スレなんだから。
つまり今は遅いけど次期 Ruby の速度大幅アップにより
最速ということでファイナルアンサーだな。

今のところそれほど速くなる見込みは出てないけどね。

大丈夫。
信者が実行すると、脳内で時間が加速される仕様があるから。

　次　期　と　か　次　世　代　と　か　は　ど　う　で　も　い　い

Ruby is the shittest language in programming.

で次期Rubyっていつ出るの？

>>216
英語わからないなら無理して使おうとしない方がいいよ。

All your script language are belong to us!!

Perl から Ruby に乗り換えるとコードサイズは半分、開発期間は 1/4 になるそうです。

結論：開発速度は Ruby ガ最速

通信テストプログラムをrubyで書いたが楽だった。
思わずこっちの方を出荷したいとか思ってしまった。

ruby2perlを作れ
それで納品問題も解決

>>220ソースよこせこら

やーだね（ﾌﾟﾌﾟｫ

>>222
うちの仕事でperlなんて使ったらはったおされそうだｗ

>>223
http://pc2.2ch.net/test/read.cgi/tech/1074235226/927
の話だろう。妄信って怖いねぇ…。

慣れてる言語を使ったほうがそうでない言語を使うより、
質も開発速度も良いというだけじゃないかね。

t3x[ ttp://www.t3x.org ]出てこないな…
ま、この言語をTrackingしているのはオレだけか。

お前だけ。

一番表現力が豊かなのはActionScriptだけどな
早いかどうかは知らん

ActionScript って JavaScript とどう違うの？

>>231
JavaScriptの元になった別の規格があるらしいんだけど、
それにFlashのオブジェクトをガチャコンと結びつけたもの。
基本的にはJavaScriptと同じ

独特のスタイルとしては
deleteでGCによる強制回収が出来たり
色情報はColorでのみなど、専用オブジェクトにハンドラを渡す必要があったり
porototypeを利用したクラスの定義などが出来る

>>228
ちょっと覗いてみたけど、なんで最近の言語はみんな
英語にちがづけるんだ？？？

他人が綺麗に書いたソースは読みやすいかもしれんが、
自分が書くときにはこまる。

>>219
懐かしいな

>>232
thanx!!

ttp://www.webreference.com/programming/javascript/j_s/column2/

ECMAScript 1.0 edition 2 って事は、幾つかの差異を除けば、まんま JavaScript なんだね。

しかし藻前羅は神だな(ﾜﾛﾀ

最下位はＴＴＳに決定されますた

身の回りの小物は昔からずっとTcl/Tkで作ってるマイナー志向の俺。
おめーらは色々とスクリプトを乗り換えて来たと思うけど
やっぱりPerl->Rubyとか多いの？

Rubyは信者がｷﾓｲんで、まったりPython

http://shootout.alioth.debian.org/craps.php

まったりJavaScript

スクリプト言語に速度求める時点でアフォｗ

じゃあなんで上げたんやアホ

やっぱメジャーな言語に流れるのが一番いい
速度より時間の節約だよ

まあ、それはそれ。
このスレの趣旨はそれじゃない。

CPUとかGPUみたいに、典型的なベンチマークってないの？

ＨＳＰでＲＰＧ作りたいんですが、正直難しいと思います。
でもやりたいんです！！僕はＨＳＰでブロック崩し（アルカノイド）
ぐらいなら作ったことあります。
今のところ、オープニングまで作ったのですが、どなたか僕に
ＨＳＰの基礎からすべてを叩き込んでくれませんか？？
お願いします。

スレ違いだよアホ

でかいほど速い

Perl perl 15.9688
Python python 15.0060
Pike pike 14.3161
Lua lua 13.3868
Erlang hipe 13.2092
Python psyco 13.0327
Ruby ruby 11.6489
Awk 10.7199
Tcl 9.5188
Bash 6.6484
Emacs Lisp 5.5613

>>248
コピペだろ。
相手するとつけあがるぞ。

>>249
hipe, psyco って遅いのか。
何のテストしたの？

ＨＳＰでＲＰＧ作りたいんですが、正直難しいと思います。
でもやりたいんです！！僕はＨＳＰでブロック崩し（アルカノイド）
ぐらいなら作ったことあります。
今のところ、オープニングまで作ったのですが、どなたか僕に
ＨＳＰの基礎からすべてを叩き込んでくれませんか？？
お願いします。

>>251
http://shootout.alioth.debian.org/craps.php
のテスト全部の総得点

>>253 によると、開発効率、速度などの観点から、
ＭＬが最強ということでよろしいか。
F# 最強、ということでよろしいか。

>>254
上位にいるML系言語実装はスクリプタじゃなくてコンパイラだから
スレ違いじゃないの？

コード行数とかも評価対象に入れると
Perlがコンパイラ類と比べてもかなり上位に来るぞ

もいっこ、有名どころ。
http://www.bagley.org/~doug/shootout/craps.shtml

Language Implementation Score Missing
Cgcc7520
Forthgforth6372
Lualua6152
Pythonpython5780
Perlperl5770
Rubyruby5460
Eiffelse5124
Schemeguile3960

超ずれた鬱

Language Implementation Score Missing
C　　　　 gcc　　　　　752　　　0
Forth　　gforth　　　 637　　　2
Lua　　　lua　　　　　 615　　　2
Python　python　　　578　　　0
Perl　　　perl　　　　　577　　　0
Ruby　　 ruby　　　　546　　　0
Eiffel　　 se　　　　　512　　　 4
Scheme　guile　　　 396　　　0

ＨＳＰでＲＰＧ作りたいんですが、正直難しいと思います。
でもやりたいんです！！僕はＨＳＰでブロック崩し（アルカノイド）
ぐらいなら作ったことあります。
今のところ、オープニングまで作ったのですが、どなたか僕に
ＨＳＰの基礎からすべてを叩き込んでくれませんか？？
お願いします。

もうコピペは良いよ。

>>260
荒らし報告完了

>>259
ruby≒C ？？？

Groovy=愚ruby ???

rubyはあの遅さが一番印象に残っているんだが…
正直、あれより遅い言語ってあるの？

HSP > Ruby > ひまわり > TTS

>>263
No!!
Python　>= Perl >>>> Ruby !!!!

蛇>=真珠
って本当？

厨房くせーから蛇とか真珠とかいうなやハゲ

Ruby は如何するのだろう？

真珠は玉葱汁に遠く及ばん

Rubyは最低ランクのスクリプト言語なのに、なんでユーザーは厚かましいの？

HSP

Ruby は、ライブラリ使わなくても巨大整数が扱える。

Python もそうだけど。

Re:>275 そうだったのか。Pythonは殆ど知らないもので。

私はPythonの実行環境を持っているのに、Pythonを殆ど知らない。
こういう経験は無い？

Rubyはちょっとした最適化ぐらいやって欲しいよね
動的なのがジャマしてるの？

Groovy-1.0-beta-6で挑戦。

def tarai(x, y, z) {
if (x <= y) {
return y
} else {
return tarai(tarai(x-1, y, z),
tarai(y-1, z, x),
tarai(z-1, x, y))
}
}

println tarai(12, 6 ,0)

8.89 / ruby 1.8.1 (2003-12-25) [i386-cygwin]

遅いとは聞いてたが、まさかここまで・・・

JavaVMにコンパイルしるとどうなる？

やってみた。

2.79 / ruby 1.8.1 (2003-12-25) [i386-cygwin]

速くはなったけど、期待したほどではないな。

ちなみに以下のJavaコードだと、

public class JavaTarai {
public int tarai(int x, int y , int z) {
if (x <= y) {
return y;
} else {
return tarai(tarai(x-1, y, z),
tarai(y-1, z, x),
tarai(z-1, x, y));
}
}
public static void main(String[] args) {
JavaTarai tarai = new JavaTarai();
System.out.println(tarai.tarai(12, 6 ,0));
}
}

0.0028 / ruby 1.8.1 (2003-12-25) [i386-cygwin]

まあ当たり前か。

>>278
GC の性能改善するくらいかね。
ほとんどすべてのメソッドが再定義できるので、
定数畳み込みすら難しい
(1 + 1 でさえコードを全部調べないと 2 だとは言えない)。

Groovy-1.0-beta7が出てたんで再度やってみた。

事前コンパイル無し 2.83 / ruby 1.8.1 (2003-12-25) [i386-cygwin]
事前コンパイル済み 2.71 / ruby 1.8.1 (2003-12-25) [i386-cygwin]

事前コンパイル無しでの性能が大幅アップ。つうかこれまでが遅すぎた。

・・・たらい回し専用チューニングとかされてないよな(w

それにしてもJavaVM使っていながらrubyより遅いって、犯罪的では？
開発陣のやる気のなさが垣間見える。

>>284
まだ言語仕様自体も固まってない段階だから
最適化は後回しにしてるんだと思う。

>>281
2.79とかいう数字は何？

>>286

>>54

>>287
Tnx

でも、基準となる宝石コードはあるの？

よく見たら、確かにRuby以外はコードが明示されてるのに、基準のRubyコードが無いね。

私はこれでやりました。

def tarai( x, y, z )
　if x <= y
　　then y
　else tarai(tarai(x-1, y, z),
　　　　　　　tarai(y-1, z, x),
　　　　　　　tarai(z-1, x, y))
　end
end

puts tarai(12, 6, 0)

素朴な疑問ですが、この関数は初期値の組合せによっては、
無限ループとなりませんか？

たとえば、tarai(3,2,1) の場合

0回目：tarai(3,2,1)
1回目：tarai(tarai(2,2,1),tarai(1,1,3),tarai(0,3,2))
=tarai(2,1,3)
2回目：tarai(tarai(1,1,3),tarai(0,3,2),tarai(2,2,1))
=tarai(1,3,2)
3回目：tarai(tarai(0,3,2),tarai(2,2,1),tarai(1,1,3))
=tarai(3,2,1)

となり、最初の値と同じになってしまいます。

スマン、２回目で値３と決まってしまうことに気づいた。

スルーしてくれ。

Rubyでミリ秒取ってくるのどうやるの？

C言語で言うclock()か何かあればいいんだけど。

timeではかれ

Java の成績が良いのでふと思ったのですが、計算時間が優秀でも VM の起動時
間とかが遅いと用途によっては台無しですね。Java とか遅いですし。

皆さん、関数単位での計測なんでしょうか?

>>281
0.0028じゃなくて0.028じゃない？
そうじゃないとC系コンパイラより１０倍速くなってしまうよ。

確かに１桁間違ってますね。

あと、実行時間はCygwin bash shell上でtime使って測定してます。

>>117
ｐｈｐのソースは汚いなあ（ｗ
$がゴミみたい。

>>141
ﾅﾆｺﾚ?
もっと簡潔に書けないの？

>>181
結局haskellとかって、関数の括弧とっぱらたつっても
逆に優先度のための括弧が妙な具合に必要になったりするのね。
なんか本末転倒じゃない？


そういやHSPのソース無いな。
誰か参戦しろよ。

HSPって関数無いだろ。

マジで?
そんなんでよくゲーム作れるな。

Re:>299 ん？それじゃあ、 mes "hogehoge" とかは何なの？私は関数という言葉をよく知らないから教えて。

言葉を知りたければ辞書などを利用してはどうですか? ;-)

組み込み手続き

結局の所、タライ回し関数が早いということは、
スクリプト全体の性能のうち、どの部分が良いのですかね？

rubyが意外に健闘しているのが、意外だった。

あと、コンパイラを除くと今までのランクは
rubyが１位でOK？

>>304
関数呼び出しのオーバーヘッドかな？
>>305
rubyはむしろ最下位に近いわけですが。

まじめな話、一番良いと思われる、スクリプト言語ってなんですか？
自分は、理工系の数値計算の出身。
低水準言語のFortran及び、スクリプト言語はシェルを使用しています。
これから、勉強するならば、やはりPerlでしょうか？

やはりと思うならそのPerlにしとけよ（ｗ

perlちょっと触ってみて汚い文法に耐えられそうならそのまま使っとけ。
耐えられそうにないならPython, Rubyを検討すべし。
WindowsならVBS。

おれは、ruby -> perl と流れてきたんだが、
今は、 perl の次を探している。ｗ

>>310
Tclで。その次はSchemeで。

TCL は昔見たけど、勘弁Ｗ
スキームは、見たこともないｗ

>>310
おれと逆...
sh+sed+awk -> Perl -> Ruby
んでもってrubyの次さがしてる。
でも、RubyがUnixにデフォルトで入るのはいつだろ。。。

普通にECMAScriptで

なんで、ここでは、PHPは無視されがちなのかの？

PHPは、いいよ。

>>313
Freeware for Solaris には入ってるよ。
Linux も Redhat は入ってたと思った。

HSP

今まで書き溜めたツールとかライブラリを書き直すのが
めんどくさいので未だにtcl/tkですが・・・。

>>315
俺もphpは好きだけどイマイチ速度がね…
ココって最速スレだし。

php 4.3.9 Zend Engine v1.3.0
<?php
$n = ($argc == 2) ? $argv[1] : 1;
$x = 0;
for ($a=0; $a<$n; $a++)
for ($b=0; $b<$n; $b++)
for ($c=0; $c<$n; $c++)
for ($d=0; $d<$n; $d++)
for ($e=0; $e<$n; $e++)
for ($f=0; $f<$n; $f++)
$x++;
print "$x\n";
?>
1.66 / ruby 1.8.2 (2004-07-29) [i686-linux]

wsf形式はどれぐらい速い？

スクリプト選んだ時点で速さなどどうでもいい

え、おれは速いスクリプト選ぶよ？
自宅鯖のCGIなんかほとんどネイティブコンパイルしたのが動いてるし。
どうでもいいって奴はRubyみたいな最下位彷徨ってる哀れな言語使ってるだけじゃね？

速さと書きやすさを両立したOcaml選ぶだろ、普通。

スクリプトに速度を期待する方がおかしい

ネイティブコンパイルできるスクリプトって？

>>325
きっと >>322 の１行目と２行目は別の話なんだろう。

C言語のインタプリタ知らんの？

Ｃ言語のインタプリタはスクリプトなんですか？

そうだよ。

>>325
Java じゃない？

Re:>327 逆に、perl, Ruby, Python, JS, VBS などのコンパイラというのはあるのですか？

コンパイラとスクリプトの区別なんて不毛なことはやめとけ

Re:>332 いや、違いが明らかだからそもそも改めて区別しようなんて思わないのだが。

Perlをx86にするコンパイルできるコンパイラがあったら三万までは出す

落ち着いてしゃべれ

Perlは標準でCにトランスレートできるから
そっから最適化を吟味すればいいんじゃないかな。

Ocaml はスクリプトとは認めてもらえんのですか

いくら早くても、コードが見にくい言語は勘弁なｗ

rubyのことかー

奇形の上にも三年（＾＾）

22年

洩れはruby房ではないが、もっと遅いとおもってたよ。
関数呼出は、案外いいんでない。

構文は嫌いだけどｗ

でことは、ルビー最強でOK？

やっぱ最高はハスケル。
二番がルビー。
三番がパイソンだろ。

ハスケルとその他には超えられない壁がある。

>>342-344
Rubyスレに戻ってください
そして出てこないでください
ゴミ！

ハスケル？
初耳だという私は素人？

ハスケルはコンパイラでは？

静的型付けは反則にしない？

Haskellはスクリプトなんだろうか

またくだらない分類厨が沸いて出たな

ハスケルも仲間にいれてやれよ。


ぱーる、るびー、ぱいそん、ぴーえいちぴー、だけのスレかよ。

で結局たらいまわし関数ってなんなんだ。
ググっても「たらいまわし関数は竹内関数デス。意味はないデス」としか出てこねーぞ。

意味もなく重い関数ってだけで実際計算結果には何の意味もない。
関数呼び出しのオーバーヘッドが計測できる。
自分ならフィボナッチとかマンデルブロとかもう少し意味のある計算させるけどね。

プログラムを組み始めてから実行結果が出るまでのベンチマークをしてほしいね。

　　　　　　　　　　　　　　　　＼　│　／
　　　　　　　　　　　　　　　　　／￣＼　　 ／￣￣￣￣￣￣￣￣￣
　　　　　　　　　　　　　　　─（ ﾟ ∀ ﾟ ）＜　くっちゃらはぴはぴ！
　　　　　　　　　　　　　　　　　＼＿／　　 ＼＿＿＿＿＿＿＿＿＿
　　　　　　　　　　　　　　　　／　│　＼
　　　　　　　　　　　　　　　　　　　 ∩ ∧　∧　　／￣￣￣￣￣￣￣￣￣￣
￣￣￣￣￣￣￣￣＼∩ ∧　∧　＼（ ﾟ∀ﾟ）＜　くっちゃらはぴはぴ！
Ｐｙ厨〜〜〜〜！ 　　 ＞（ ﾟ∀ﾟ ）/ ｜　　　　/　＼＿＿＿＿＿＿＿＿＿＿
＿＿＿＿＿＿＿＿／ ｜　　　 〈　｜　　　｜
　　　　　　　　　　　　　 /　／＼_」　/　／＼」　　　　　　　　　　　　　 ￣　　　　 / ／

じゃあ rouge clone (ローグクローン) が出来上がるまでの早さで競うか。
キャラクタベースだから大抵の言語で作れるだろうし。

・プレイヤーは@
・モンスターはA-Za-zで、バリエーションは任意。
・地下10Fまでの横80x縦25の大きさの壁に囲まれた迷宮を毎回ランダム生成
下り階段>
上り階段<
壁#
迷宮内の照明や視点は任意。
その他細かいことは適当なアレンジで。

>>353
サンキュ。でも再帰とどう違うのかサッパリわかりません。
遅延評価ってのがある言語用のイディオムで手続き型だと再帰と同一視してよいもの？
遅延評価ってのでなぜ高速になるのかもサッパリわからんよ…。難しい。

例えるなら分数のようなもの

と極論をかましてみる

>>354,356
こっちでやってくれ。

最強開発速度言語決定戦
http://pc5.2ch.net/test/read.cgi/tech/1068545254/

>>357
例えば遅延評価式なら計算可能だけれど、無限再帰してしまう脱出不能な関数を考えてみて
そこで、無限再帰のはまり関数を「十分に重い関数」だと考えてみて。
そうすれば何処が高速化するのか分ると思う。

>>344
洩れは、パイパンのほうが（ry

Re:>361 そんなスクリプトあったっけ？初耳だな。

マジに聞くなよ童貞

ループの速さで競うとどうなるか？
とりあえず、1から、1000000までの整数を、一つごとに改行を入れて表示するプログラムは何で書くのが一番いいかを誰かレポートよろしく。

最速はOcamlです

他の言語がゴミの様だ！

Re:>365 Ocamlって何？

ﾌﾟｹﾞﾗｯﾁｮ

http://pclune.web.infoseek.co.jp/cgi-bin/item.cgi?item_id=KUROBOXHG&ctg_id=new&page=1

たらいまわし (12, 6, 0) の実行時間．単位は秒数
Windows2000 cygwin i686 866MHZ

gcc 3.3.3 O0 　　 0.41
gcc 3.3.3 O2 　　 0.36
gosh-0.8.1 　　 　8.74
clisp　　　　　　　 5.40
python-2.3.4 　　17.4
ruby-1.8.1　　　　23.9
perl-5.8.5　　 　　61.0

Perlよく知らないのでどなたか添削よろ

sub tarai
{
my ($x, $y, $z) = @_;

if ($x <= $y) {
return $y;
}
else {
return tarai(tarai($x-1, $y, $z),
tarai($y-1, $z, $x),
tarai($z-1, $x, $y));
}
}

print tarai(12, 6, 0);

添削以前のレベルだキケー！
人生やり直すのはできるだけ早い方がいいキケー！
プログラマーなんて夢は捨てて荷物まとめて国に帰った方がいいキケー！

>>369
スクリプト言語に限定すると、オブジェクト指向の方が早いのかねぇ？
タライ回し。

OOは関係ない
関数をまともに扱えるかどうかだと思う
Perlの関数はまともじゃないからね

>>373
いや、逆だろう？
まともに関数を組んでいる方が遅くなると思われ

違う？

>>372
>>369
> gosh-0.8.1 　　 　8.74
> clisp　　　　　　　 5.40
> python-2.3.4 　　17.4
> ruby-1.8.1　　　　23.9

goshもclispもオブジェクト指向じゃなくて関数型だとおもいますが。

>>375
>>373

>>334
x86 というわけじゃないけど、perl をコンパイルしたければ
perlcc を使えばいいんじゃないの？

前の仕事で perl でプログラムを書いていたんだけど
どうしても速度が遅くて、だけど C 等で書き直す時間がなかったので、
*.pl を perlcc でコンパイルしたものを実際には使った。
かなり速くなったよ。
以降のメンテは、
・perl スクリプトを修正し、perl のまま単体テスト
・perlcc でコンパイルしてから、生成された方を本番環境にリリース
ってやってたよ。

# なんかはずしたこと言っていたらごめんなさい

>>375
そうか？ clisp って一応 Meta Object Protocol もあるし
本格的にオブジェクト指向だと思うのだが．

まぁ、オブジェクト指向はオタク言語だからなぁｗ

久々に低レベルな煽りをみた

>>370
ほぼ限界まで添削してみた。

sub tarai{
return $_[0] > $_[1] ? tarai(tarai($_[0]-1,$_[1],$_[2]),
tarai($_[1]-1,$_[2],$_[0]),
tarai($_[2]-1,$_[0],$_[1])) : $_[1];
}

print tarai(12, 6, 0);

>>6のサイト潰れたね

Google の上位のを張っとく

http://shootout.alioth.debian.org/

http://dada.perl.it/shootout/

>>380
平静を装っているところが痛いｗ

今時スクリプト言語ですらオブジェクト指向ですよおじさん

>>385
real engineer は、オブジェクト指向を使わないw
これ定説。

>>386はバカ
これ定説。

いや、確かにオブジェクト指向は技術者向けではない。

究極のプログラミングはハードウェア制御だろ？
そんなものにオブジェクト指向使ったら(ry

MSILはオブジェクト指向アセンブラだ。
近い将来MSILに特化したオブジェクト指向CPUが出る。間違いない。

>>390
w

>>389
まぁ、技術者（といってもコンピュータとか分かる系）なら、
変に抽象化するオブジェクト指向は、かえって邪魔というのは良く聞く話。

その証拠に、オブジェクト指向言語で書かれたオブジェクト指向言語って皆無

>>392
Jythonとかは？

.　　　　　　　∧＿∧　 ／￣￣￣￣￣￣￣
　　　　　　　（；´Д｀）＜　すいませんすぐ片付けますんで。
　　-=≡ 　/　　　 ヽ　 ＼＿＿＿＿＿＿＿
.　　　　　 /|　|　　 |. |
　-=≡　/.　＼ヽ／＼＼_
　　　　/　　　 ヽ⌒)==ヽ_）=　∧＿∧
-= 　 /　/⌒＼.＼　||　　|| 　(´･ω･`) ←>>721
　　／ ／　　　 >　） || 　 ||　( つ旦O
　/　/ 　　　　/ ／＿||＿ ||　と＿)＿) ＿.
　し'　　　　　（＿つ￣(_））￣ (.)）￣ (_））￣(.)）

誤爆ｽﾏｿ

.　　　　　　　∧＿∧　 ／￣￣￣￣￣￣￣
　　　　　　　（；´Д｀）＜　すいませんすぐ片付けますんで。
　　-=≡ 　/　　　 ヽ　 ＼＿＿＿＿＿＿＿
.　　　　　 /|　|　　 |. |
　-=≡　/.　＼ヽ／＼＼_
　　　　/　　　 ヽ⌒)==ヽ_）=　∧＿∧
-= 　 /　/⌒＼.＼　||　　|| 　(´･ω･`) ←>>394-395
　　／ ／　　　 >　） || 　 ||　( つ旦O
　/　/ 　　　　/ ／＿||＿ ||　と＿)＿) ＿.
　し'　　　　　（＿つ￣(_））￣ (.)）￣ (_））￣(.)）

オブジェクト指向型は共同作業向け？

つーか
馬鹿向け

C++やJavaは馬鹿にはまだまだ難しい
Smalltalkにしときなさい

>>397
いや、それもよく言われることだが、特に向いていると言うわけでもない。
言葉は悪いが、「コンピュータ素人向け」とでもいうのだろうか？

まぁ、目的があって手段を問わない系だね。

# 馬鹿向けは、ワロタ

ここは窓際C厨の大活躍なスレですね

Cは北京原人向け

main :: IO ()
main = print (tarai 12 6 0)

tarai :: Int -> Int -> Int -> Int
tarai x y z
　| x <= y　　　= y
　| otherwise　 = tarai (tarai (x-1) y z)
　　　　　　　　　　　　(tarai (y-1) z x)
　　　　　　　　　　　　(tarai (z-1) x y)

>>401 は、マイクロソフト何とかしか使えんアフォｗ

C最強
#define tarai(x,y,z) (x<=y)?y:tarai(tarai(x-1,y,z),tarai(y-1,z,x),tarai(z-1,x,y))

>>404
それが何かわからんが、
その手のそれでLISPにかなう言語なんてあるのか。
つか、LISPに関しては噂しか聞いた事無いけど

ぬるぽ

Re:>405 LISPインタプリタに依存するのではないか？私もよく知らないが。

Cは北京原人向け

日本人は、中国に国力で負けｗ

中国という国は存在しない。
よって国でないものに国力などというものもない。
あると思うならそれは幻想である。

ミッドランド

なんか、このスレの住人のレベルが分かったようなwww
中国といい、オブジェクト指向といい、
アフォばっかりwww

↑このスレで一番のアフォ

で、どれが最速なの

Cは北京原人より速い

やっぱＣじゃないの？トータルバランスで。
すでに完成された言語で歴史があるから。
でもスクリプト言語って定義は何なの。要はプログラミング言語の
総称か？それとも....。

習得が簡単
インタプリタ
型チェックが緩い
ワンライナーが書ける
純粋であるよりは便利さを志向

などの特徴をより多く持つ言語たち。

Cは中国に国力で速いw

>>417
（付けたし）

ただし、オブジェクト指向を除くｗ

>>419
意味不明にバカなw厨発見

そんなに悔しがらなくてもｗｗｗｗｗ

悔しがってるのどっちだよ、バカじゃねーの？

各言語で１０億までの双子素数の組をファイル出力するプログラムの最速で勝負をつけたらどうなんだ？

プログラマーの脳みそも試される試練だろうな。
他の言語にいちゃもんつけるぐらいしかできないやつには厳しい。
ちなみに普通の素数の判定では総当りで判定するのはメモリは節約できるが、とてつもなく遅い。
素数全探索であるならば１０億まででSharp Note Mobile Athlon 1100+MHz級のＣＰＵで３分切れなきゃ遅いアルゴリズムだと思っていい。

お題の出し方に知恵の遅れを感じるな

GAME-Z80とかTTLはスクリプト言語に入りますか？

オマエはどう思う？

>>423
関数型言語はありですか？

つか最速言語決めるのにアルゴリズム知ってる奴が言語関係なく勝っちゃう課題にしてどうする

開発速度が最速っていう意味じゃないの？

それはこっちだ
http://pc5.2ch.net/test/read.cgi/tech/1068545254/

>>424
お前が作った総当りプログラムが222293を20000で割れるかどうか試さないことを祈ってる。

>>427
まあ、いいんじゃないか。

>>428
総当り方がメモリにはやさしいがスピードに関してはダメだ、というヒントは出した。
総当り方じゃないアルゴリズムといわれれば、どういうアルゴリズムかおのずと答えが出るよね？

ただし、普通のアルゴリズムでは壁が出てきますが。

その皮肉が理解できるほど
424が普通の頭を持ってるとも思えない

Cマガ読んでる人はもう解答が分かっているはずなわけですが

Sharpのノート買ってる時点で頭の程度が知れてる。
プログラマならIBMのThinkPad一択。

つーかCﾏｶﾞの宣伝かよ

>>433
ああ、残念。
俺はノートパソコン持っていないんだ。
これは単純素数計算で自称最速をいっている人の記録を参考にしただけ。
もちろんその人のパソコンでの記録。

１０億　１分５０秒を切る速さ
５０億　９分を切る
１００億　１７分５０秒を切る

とのこと。

>>423
スレ違い（←スレッドのテーマにそぐわない書き込みのこと）です。

>>436
じゃあ、最速を決めるほかにいい案があるというの？
それともここは自分の嫌いな言語を叩くスレになったの？

>>437
書き方が誤解されやすいんじゃないか？
423は単一アルゴリズムのつもりだけど、文章読むとアルゴリズムに選択の幅があるように思えてしまう。

423で言いたいのは、
・脳みそを試される試練＝この課題に最適なアルゴリズムが選べる
・遅いアルゴリズムだと思っていい＝最適なアルゴリズムのヒント（基準）
ってことで、その最適なアルゴリズムはおのずと１つになるってことだろ。

その最適な１つのアルゴリズムで、言語決定戦をしとうって話。

俺にはその最適なアルゴリズムは分からんがｗ

>>437
>>素数全探索であるならば１０億まででSharp Note Mobile Athlon 1100+MHz級のＣＰＵで３分切れなきゃ遅いアルゴリズムだと思っていい。
アルゴリズムによる速度差が出てくるようなお題では、スクリプト言語処理系の速度比較にならないじゃん。

最速言語は brainfsck 間違いない
もまいらも使ってみる事をオススメする
頭がすっきりするぞ

しょうがないなあ、
じゃあ、ほぼズバリな最適アルゴリズムのヒントを出すよ。

まず紙と鉛筆。１から１００まで紙に数字を書け。
まず１は線を引いて消しとけ。そして２に丸をつけろ。
そうしたら２以外の２の倍数の数字に線を引いて消しとけ。
その次の線が引かれていない数字は３だ。丸をつけて、他の３の倍数の数字を消せ。
これを繰り返せ。

これでいいよな？
まだそれ以外の部分でも問題は山積みだがな。
たとえば
１０億になると大規模な紙＝メモリを消費する。ページングを起こす＝大幅な速度低下なので、普通の機種ならページングを起こさない前提で作ること。
とか
掛け算かそれとも足し算か
とか

結局この手の競技は最終的にプログラマーのチューニングの根気も試され、それが秒単位ながらも着実に差が出るわけだが・・・

スレ違い

>>423
MS の JScript で書いてみたけど、どうやっても 3 分以内は無理そうだな・・・
喪前のアルゴリズムなら 3 分以内でいけるのか？

>>443
そりゃインタプリタ言語使った時点で間違い決定としか言わざる得ない。

423と漏れが同じスレッドで会話しているのかどうか、自信が無くなってきた・・・

まぁ、素数の問題は良いとしてもアルゴリズムを統一せんとあかんやろ？
例えば、アリストテレスのふるいなんてのはいいとおもうが。

あと、オブジェクト指向もふるっとくか？ｗ

最初から普通に
「6k±1の倍数を篩うエラトステネスの篩いで、10億までの素数をファイルに
　10進で書き出すってのはどう？」
って書いた方が建設的だったような気がする。
「アルゴリズム工夫してXXXでした」ってのは、スクリプト言語の速度とは関係ないし。

数値計算が得意な言語ばかりじゃないわけで。

なんじゃこのアホは >>423

スクリプトにはテキストフィルタ（ファイルIO、文字列処理）と
int32以下の数値計算の速度しか期待しないけどな。
まあ後は起動速度。

大阪（西梅田）、新宿（JR駅前）のそれぞれ一等地に
拠点を構え、業績急上昇中！未経験者大募集中！の
ソフトウェア開発会社
グリーンシステムを応援するＨＰです。
http://www.geocities.jp/grs_hp/

応援するスレはこちら！
http://school4.2ch.net/test/read.cgi/job/1077432387/

最高の会社にするため、みんな頑張ってます！

グリーンハウス＞＞＞＞＞＞＞＞グ(ry

main :: IO ()
main = print (tarai 12 6 0)

tarai :: Integral a => a -> a -> a -> a
tarai x y z
  | x <= y      = y
  | otherwise   = tarai (tarai (x-1) y z)
                        (tarai (y-1) z x)
                        (tarai (z-1) x y)

HSP

また論理的思考のできないバカがPOPしてるな

>>423
【えーっと･･･】

たらいは、もういいよｗ

ベタベタな方法で行数カウントしてみました。

perl test.pl
−−−−−−−−−−−−−−−ここから−−−−−−−−−−−−−−−
open IN, "/usr/share/dict/web2";
$i = 0;
while (<IN>) { $i++; }
print "$i\n";
−−−−−−−−−−−−−−−ここまで−−−−−−−−−−−−−−−

python test.py
−−−−−−−−−−−−−−−ここから−−−−−−−−−−−−−−−
f = file('/usr/share/dict/web2', 'r')
i = 0
for l in f:
i += 1
print i
−−−−−−−−−−−−−−−ここまで−−−−−−−−−−−−−−−

ruby (内容に自信なし...) test.rb
−−−−−−−−−−−−−−−ここから−−−−−−−−−−−−−−−
f = open("/usr/share/dict/web2", "r")
$i = 0
f.each_line() {|l|
$i += 1
}
print $i, "\n"
−−−−−−−−−−−−−−−ここまで−−−−−−−−−−−−−−−

結果

% time ./test.pl
235882
./test.pl 0.21s user 0.01s system 96% cpu 0.226 total
% time ./test.py
235882
./test.py 0.24s user 0.03s system 96% cpu 0.283 total
% time ./test.rb
235882
./test.rb 1.25s user 0.02s system 97% cpu 1.302 total

ruby が遅い理由が私のタコなプログラムなせいだったら、ごめんなさい。

以前、ruby は 0.8 をちゃんと扱える (0.80000000000000004 とならずに) と
書いてあったので、数値演算 ($i += 1) が遅いのか?

適材適所で切り替えられるといいんだけど...

ちなみに、python で

decimal (2.4) 使用
% time ./test2.py
235882
./test2.py 37.56s user 0.09s system 98% cpu 38.160 total

gmpy 使用
% time ./test3.py
235882
./test3.py 0.58s user 0.02s system 98% cpu 0.612 total

とそれなりに遅くなる。
＃ decimal 遅すぎ orz

>>458
ruby版、イテレータが重いみたい。
while ( f.gets ) do
$i += 1
end

のが速い。
それでもperlやpythonより遅かったけど。

あと、rubyは31bitまでの整数は即値で扱ってる。

>>458
これは反則？かなり速くなると思うよ
data = ''; open('/usr/share/dict/web2', 'rb'){|f|data = f.read}
data.concat "\n" if data[-1,1] != "\n"
p data.count("\n")

反則ならこういうのもあるけど
f = open "xxx"
f.readlines
print f.lineno, "\n"

それでもperlより遅いのは何故だ。

perl>>458版
real 0m0.046s
user 0m0.040s
sys 0m0.000s

ruby反則版
real 0m0.054s
user 0m0.050s
sys 0m0.000s

>>461
サンクスです。やってみました。
% time ./test2.rb
235882
./test2.rb 1.23s user 0.03s system 97% cpu 1.295 total

う〜ん、気持速くなったか...

>>462
こちらもサンクスです。やってみました。
% time ./test3.rb
235882
./test3.rb 0.07s user 0.01s system 99% cpu 0.078 total

速くなったが、perl や python でも「それだったら...」というのがありそう。

>>448 で、数値演算だけでないよ、とあったので、ファイル読み書きでも
やってみようかな、というのが元々の動機なので微妙ですね。

i++ を替えると応用が効くかなと思ってベタベタにしてあるんで...
＃ 言語に特化した方法で競うのも面白そうですが。

ごめん。462のが速い。

real 0m0.011s
user 0m0.010s
sys 0m0.000s

Rubyの高速化はいかに標準ライブラリ(＝ネイティブコード、可能ならば標準添付ライブラリも)を
使いこなせるかが鍵だと思う。

>>466
それはそうかも知れないけど、このスレの目的からはずれてるんじゃないかと

それはつまり、あんまりRubyで書くなと言ってるのと変わらないわけで、
すなわちRubyは使い物にならないということでは・・・？
まさか専用イテレーターまで遅いとは思わなかったが。

せめて>>458の単純な繰り返しぐらいは内部で専用ロジックでも用意して
高速に実行できるべきだよね。
悪評高いHSPでもそれぐらいのズルやってるでしょ？
まあ処理が複雑化すればそんなもの無いに等しくなるだろうけどね。

たまにRubyは言語仕様の制限で遅いのは仕方が無い、って言う人がいるけど、
それは言語設計が悪いことを示しているわけだよ。

ライブラリ使って「〜のが速い」って言うのはそのライブラリに完全に依存してるし
それはそのスクリプト言語の速さじゃない。
言い換えればライブラリを適用できない処理は全て遅いということになる。
今後も、その標準ライブラリは肥大化していくのかねえ。

ならばPythonも使い物にならないね。Perlより遅いのは間違いないから。

ｸｽｸｽ

>>468
近年稀に見る低レベルな釣りだな

ライブラリ使ってもPerlやPythonに勝てないなんて
これはもう日本発の言語らしく切腹するしかないな

>>467
標準の物を使っちゃ駄目となると何もできないわけだが…
標準なんだから使っても移植性に問題は出ないだろうし

うだうだ、うぜぇなぁ！
たかだかコンマ数秒の差だろう？

プログラム作る時の時間を考えてみろ、
rubyの方が１億倍ぐらい速いぜ！

　　　　　最　　高　　言　　語　　R　　u　　b　　y

Ruby is Namber one

>>468
大抵の場合、速くなくても困らない。
速度がほしいならスクリプト言語じゃなくて C で書くよ。

歳くってくると、C で書く根性がなくなってくる...

一瞬で終わるタスクなら差は気にしないけど、数倍の差があると 1時間が数時
間か... 同程度の手間で書けるんだったら、速いスクリプト言語の方がいい
なぁ、となってしまう。

1時間で書いて1秒で実行が終了するより、
10分で書いて1分で実行が終了するほうがまし

同じ処理を
10分で書いて 10分で終了する言語
10分で書いて 60分で終了する言語
どちらを選ぶ?

>>480
条件がそれしか提示されて無いなら当然前者を選ぶしか無いけど、

> 479 ：デフォルトの名無しさん：04/11/06 17:21:29
> 1時間で書いて1秒で実行が終了するより、
> 10分で書いて1分で実行が終了するほうがまし

これはつまり、Ｃ言語よりスクリプト言語の方がよい（場合が
多い）ということだ。

［例］Ruby＞＞＞C言語

> 480 ：デフォルトの名無しさん：04/11/06 17:25:54
> 同じ処理を
> 10分で書いて 10分で終了する言語
> 10分で書いて 60分で終了する言語
> どちらを選ぶ?

恐らく、どのスクリプト言語であろうとも、慣れて来れば
それなりの時間でコードを書けてしまう。（大差は無い）

となると、はやりスクリプト言語のなかでは実行速度が早い
ほうが良いということだ。

［例］Perl＞＞＞Ruby

［結論］Perl最強！！

何が有ろうとRubyが最強である事には変化がなくそれは永遠である。

>>483
偽 Ruby 厨なんだよね?
ウザいの通り越して、気味悪いんだけど。
Ruby 使っている方々が可哀想だ。

>>473
そうやって毎回似た様な処理をするライブラリを１つずつチェックするのか？
速いライブラリ探すのに手間が掛かるよりは
普通に書いた処理が普通に速いほうがいい

実際458から速い方法が見つかるまでかなり時間掛かってるし
この程度の処理を書くのに毎回あんな時間が掛かる様ではヤバイ

つまりRubyは処理系も開発速度も遅くなる傾向があることがここに証明された
○結論
Rubyマジヤバイ

>>458の事例から推測できる事は以下の通り

・Rubyは普通に書いたらPerlの４倍遅い。
・開発速度はPerlが5分だとすると、Rubyはその20倍は掛かる。

>>485
> 実際458から速い方法が見つかるまでかなり時間掛かってるし

こんな根拠にもならん根拠出してまで必死になっている理由がよくわからん。

ｸｽｸｽ

どちらかというとお前の人生における生産効率の低さが気になる。

＞普通に書いた処理が普通に速いほうがいい

まあねえ・・

>>485
RubyでPerlと同程度の実行効率を得るにはその20倍の時間が掛かる。

の方が適切かと。

ライブラリに頼るってことは自分（＝言語）に自信がない証拠。

20倍の根拠がマジで分からん。

得手不得手があるのは分かりきっているんだから、code 晒して実測した方が
このスレ的に面白いと思うんだが...

1つの事例でけなしあっても無駄なだけ。

>>493はいつもライブラリを使わないでプログラムを書いているわけですね。ｗ

>>492
なんでそんなに必死なの？・・・・

問題は、>>458が思いついたごく自然なコードでかなりの差が出たことだよ。
なるべくRubyが有利になるようにイテレーターを使ったりしていたにもかかわらず。

>>462, >>463が反則コードを書いてやっと追いつくが、
反則では比較にならない。

イテレータって速度を出すためのものだとでも思っているんだろうか？

Rubyに何か嫌な思い出でもあるんじゃね？

>>494
>>458の投稿時間から>>466の結論が出るまで掛かった時間が約１時間半。
Perlと比べて大雑把に20倍は掛かる見積もり。

同じ処理を
５分で書いて 0秒で終了する言語
１時間半で書いて 0秒で終了する言語
どちらを選ぶ?

Rubyコードの手直しには３人程度の人間が必要だったことも考慮したい。
それでも１時間半。

Ruby最強！！
`cat "/usr/share/dict/web2" | wc -l`

いや、だからそんなものが何で開発時間の根拠になるわけ？
なんか痛いを通り越して電波飛ばしているようにしか見えない。

501のせいで興ざめだな。

>>505
>>464の通り、458は他人が提案するまで速い方法を思いつかなかった。
これだけでRubyでの開発は困難だという証明になる。

いいよいいよ。
Rubyは無茶苦茶遅い。
それがいいたいんだろ。

どっかのスレで質問したときは Python と Ruby は同じくらいの速度だって
いわれたんですけど、あれは間違いだったのかな。
やっぱり Python のほうが Ruby より速いんだね。

Perlも反則とやらを使えば早くなるんだろ？
比較する意味ないって。

問題の提供から解答するまでruby信者がこのスレに常駐していることが前提ってことだろ？
そんなにひまな人が多いわけじゃないからな。

それと、ライブラリと入っても、Arrayオブジェクトだぜ？
普通の配列で、それを使って反則か？

Rubyが遅すぎるのはまつもとが遊んでるせい
奴の家に乗込め

>>511
>>498

アロケーションやGCの効率が影響するくらいメモリを使って、
I/Oもそれなりにあって、かつ簡単に移植できるベンチマーク、
どこかにないかな。

>>499
では>>458は何故イテレーターを使ったのかな。
おそらくRubyに準拠したスタイルで書きたかったんだろう。
それで遅いのはもはや罪であるとしか言い様がない。

別にイテレータは有利にならないし。

どのみちwhileでも遅いし。

>>514
ディレクトリツリー全検索して
各ディレクトリ（とそのサブディレクトリ）が保持する
ファイルサイズと割合を表示していくプログラムとか。

これrubyでもっと早くならない？
http://shootout.alioth.debian.org/bench/ary/

　　　　　　　　　　　　　　　　>>503,507,515
　　　　　　　　　　　　　　　　　　　　↓
　　　　　　　　　　 　 　 　 　 　 　 　　 ｶﾀｶﾀ＿＿＿_　＿＿＿
　　　　　　　　　　　　　　　　　　∧＿∧ 　 |｜＼　　 .＼　 |◎ |
　　　　　　　　　　　　　　　　　 <.#｀Д´>　 |｜　　|￣￣|　 |：[].|
　　　　　　　 　 　 ∧＿∧　┌（ 　 つ／￣.l｜ ／￣￣/　..| ＝|
　　 ∧＿∧　　　（　TДT）　|└ ヽ　|二二二」二二二二二二二二」
　　（　TДT）　　（　つ　つ 　￣］||_＿） 　 |　||　　　　　　　|　||
　　（つ　　つ　　/　 /　/　　 ／￣＼ 　 ／　|| 　 　　　　／　||
　　と＿）＿） 　（＿__）__）　 ◎ 　　　◎.[＿__||　　　　　.［＿__||
　　　　　　　　　 　 ∧
　　 ／￣￣￣￣￣　￣￣￣￣￣￣￣￣￣
　　 |　工作員よ、もういいんだ・・・・・・
　　 |　本当に良く頑張った・・・もう充分じゃないか・・・
　　 |　楽になっていいんだ・・・
　　 |　忘れるんだ・・・何事もなかったように・・・・・・

rubyはなんでこんなのが遅いの？ってのが結構あるから、
そこを地道に潰してけばpythonぐらいにはなるんじゃないの？
とりあえず>>519が遅い原因でも潰してみようぜ。

かなり強引だが、開発時間　＝　プログラムを解くために必要な思考時間　＝　プログラムの記述量として、
プログラムの要素数や行数を比べることのほうが適切だと思う。たとえば、Cだと
#include <stdio.h>
int main(void){
FILE *fp;
int ch;
fp = fopen(fname, "r");
while(1){
ch = fgetc(fp);
if(ch == EOF)break;
putchar(ch);
}
fclose(fp);
}
だいたいこうなるが、bashだと「cat $1」だ。
もちろん、変数名を縮めたり、適切に改行を入れなくても要素数(ifとかwhileとか)で考えるから無駄。もちろん可読性も。

>>519
RubyのArrayはあまり速くない。処理によってはString#[]の方が速かったりする

>>521
他の言語みたいに書くと洒落にならないほど遅くなるのは事実かも…
俺もCのコードを移植しようとしてとりあえず動く程度を作ってみたら無茶苦茶遅かった。
Rubyスレの面々にはかなわないと思うがちょっとやってみる。
手際は悪いのでしばらく待ってくれ

>>522
C言語だって短く書けと言われれば書けるだろ。

#include <stdio.h>
main() { int c; while ((c=getchar())!=EOF) putchar(c); }

bashで１からcat書けと言われたらこうは書けないし。

まともな速度にするためにパズルを解かなきゃいけないなんて、あほらしくね？

>>524
それは「cat $1」とは違う･･･

俺が反論するならCだって↓こうかけるだろといいたいところだ。
int main(int argc, char* argv[]) {
return execlp("cat", argv[1]);
}

使用できるライブラリの話をしだしたらとうてい公平な比較にはならない。

>>524
そうじゃなくて要素数だよ。
524のCで思考すると、
１．まず、標準ライブラリを持ってくる。
２．変数cを宣言する
３．取ってきた文字をcに入れて、EOFでない間繰り返す
４．文字を出力する
５．繰り返し終わり
みたいに考える。
対してbashは
１．引数に指定されたファイルを開く
で終わる。
この差が開発時間ではないのか？ってこと

勝ち負けとか煽るから話がそれてくるんだよ。
その言語の一番特徴的なコード書いて計測する。
ただそれだけの話だろ。

例えば手前の文字とxorして出力したいという事になるとbashではお手上げ

//encode
#include <stdio.h>
main() { int c,k=0; while ((c=getchar())!=EOF) putchar(key^c),key=c; }

//decode
#include <stdio.h>
main() { int c,k=0; while ((c=getchar())!=EOF) key^=c,putchar(key); }

それもう速度の話じゃなくなってるじゃん

うん。すれちがいだ。
スクリプトの速度を比較するなんて、あんまり意味の無いスレだな。

つまり仕様変更に弱いと

rubysaikyou!

>>521
いや、数行程度のベンチマークプログラムならものによって
Pythonが早かったりRubyが早かったりするが、ある程度の大きさの
プログラムならPythonのほうが遅くなることが多い。

>>521
ゴメソ…これ、かなりチューンされているわ。
プロファイラで追ってみたがこれ以上速くするのは俺の頭じゃムリポ…○|￣|＿

>>535
数値計算と Array の要素へのアクセスがほとんどだから
あれよりも速くするのは無理かと。
VM ベースになれば改善されるケースだと思う。

>>519の普通に書いた版だとどんな感じのコードになるの？

こんなもんかね。
n = Integer(ARGV.shift || 1)
x = Array.new(n){|i| i + 1 }
y = Array.new(n, 0)
1000.times do
  n.times do |i|
    y[i] += x[i]
  end
end
puts "#{y.first} #{y.last}"

Enumerable 大好き版。
n = Integer(ARGV.shift || 1)
x = Array.new(n){|i| i + 1 }
y = Array.new(n, 0)
1000.times{ y = y.zip(x).collect{|i, j| i + j } }
puts "#{y.first} #{y.last}"

>>498
そうなんだよね。
洩れはrubyつかうけど、やはり遅いと感じるよ。
しかも、文法がメチャ難しいｗ

>>538
これで、どれぐらい遅くなる？？？

もとリストでは、かな〜り早いと感じたけど。

>>539
> しかも、文法がメチャ難しいｗ
そうか。まあがんばれ。そのうち初心者を抜け出したときに
なんであんな簡単なので悩んでいたんだろうと思うときがくる。

>>540
Array に正順アクセスか逆順アクセスかの違いだけなので
そんなに違わない。

$ time ruby19 -v a.rb 9000
ruby 1.9.0 (2004-11-06) [i686-linux]
1000 9000000

real 0m12.557s
user 0m12.560s
sys 0m0.000s

$ time ruby19 -v b.rb 9000
ruby 1.9.0 (2004-11-06) [i686-linux]
1000 9000000

real 0m13.440s
user 0m13.440s
sys 0m0.000s

つーかそもそも逆順でアクセスしなきゃいけないのかな。
だとすれば n.times do |i| を n.downto(0) do |i| に。

やっぱRubyは最強だな

とうとうここまできたか↓
電車男で８０１（１ウホッ）
http://pie.bbspink.com/test/read.cgi/801/1099656889/

おまえら延々とスレ違いネタやってて恥ずかしくないのか？
ここ逝け
http://pc5.2ch.net/test/read.cgi/tech/1068545254/

糞スレ立てたのでよろしくね。

Python厨とRuby厨が仲直りするスレッド
http://pc5.2ch.net/test/read.cgi/tech/1099804004/

>>541
それは分かるけど、測定はあくまでも
その言語にとって一番自然or普通な書き方で勝負するものだ。

ライブラリ使って「速くなりました」って、アホかと思う。

”標準”ライブラリならその言語の一部だろう。

>>550
なら、インラインアセンブラを「標準」と歌えば
催促かい？ｗｗｗ

何か考えが浅いな。

551が何を言いたいのかわからんが
インラインアセンブラが書けるライブラリが
”標準添付”の言語なら別に問題ないだろ？

ばかばっか

インラインアセンブラってMicroSoft系のコンパイラでは”標準”だよな
Borland系なら別にアセンブラを用意しないといけないが・・・

>>555
Microsoft系のスクリプト言語というと JScript とか VBScript とかだけど、
よく知らないけどインラインアセンブラなんて無さそうな感じだよ・・・

それとも別スレの話題かなにか？

Forth なんかはスクリプト言語っぽいっちゃぽいし、アセンブラも書けそうな感じだけど
今日 PostScript 以外にメジャーな実装が無いか・・・

javaVM上のスクリプト系言語の「最遅」決定戦キボンヌ。
Jruby　, Jython, Groovy ...

ﾄﾞﾄﾞﾈｯﾄもキボンヌ

Groovy は遅いらしいな
自分で計ったことは無いけど

>>558
一版スクリプト言語での最遅言語ってのもオモロいかもなｗ

Rava

まぁ、意図的に遅くするのは簡単なので、
無意味だろうな。と釣られてみるw

AA略

rubyってうんこだったんだな
知らなかった

>>564
んなこったーない。

>>563
最速って企画でやらせて下から集計すればいいだけの話

rubyは早くなったな！

>>567
計った結果晒して！

数字だけで判断するんやったら小学生でもできる。

ばかだなあ
Ruby笑っちゃう程遅いよ

何と比べて遅いんだ？
ネタはいらん。

速度
C > Ruby ＞＞＞＞＞＞＞＞＞＞＞＞＞ C++ ＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞ Python ＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞ Ｊａｖａ ＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞ Ｐｅｒｌ

>>572 はぁ？




速度
Ruby ＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞ C ＞＞＞＞＞＞＞＞＞＞＞＞＞ C++ ＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞ Python ＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞ Ｊａｖａ ＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞ Ｐｅｒｌ

この期に及んでrubyが遅くないと信じている奴が居ること自体が信じられん。
ま、groovyよりは速い。それは認める。ｗ

2ch読んでC＞＞＞JAVA＞Python≧Rubyは分かった。

用途によってはPythonよりRubyの方が早いこともある程度。
Rubyはオブジェクト指向優先だから仕方ない。
Pythonとは目指す所が少し違うから。開発の規模も違うし。
JAVAもネイティブJAVAがまともに使えれば…
それでも漏れはJAVA嫌いだからつかわないけどｗ

で、Perlは、どの辺？全然ダメ？Ruby＞Perl位？
個人的に書き殴れるんで好きなんだけどね。
Web限定ならPHPの方がいいですが…
PHPもどの辺か教えてーー

>>575
なにを血迷ってるのか分かりませんが
C＞＞＞Python≧Ruby＞＞＞JAVA＞＞＞C++＞＞＞＞PHP＞＞＞＞Perl

つまらん。

>>575

マトモなレスだと思ったが、１点突っ込んでおく。

> Rubyはオブジェクト指向優先だから仕方ない。

何故だ？
基本的にオブジェクト指向は好きでないが（思考の邪魔）
速度的には中立な筈だ。

> で、Perlは、どの辺？全然ダメ？Ruby＞Perl位？
> 個人的に書き殴れるんで好きなんだけどね。

マジレスすると、Perlはメジャースクリプト言語の中では
上位クラスでしょうな。

# 煽りはスルーでよろしく。

なぜオブジェクト指向が思考の邪魔になるのか理解不能

おつむがたりないだけでせう

ねたでしょ

C>C++>JAVA>>>(省略)>>>lua>>>Perl>>>Python>>>Ruby>>>PHP

実際計ったらこんな感じだった

そういえば何でPHPみたいな糞が流行ってるんでしょうな

Ｒｕｂｙ ＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞ ＰＨＰ

>>583
web開発に特化しているだけあって、webでは使うと楽だよ。
言語の程度はともかくとして。

PHPはWeb用のCみたいな感じだね。Web以外の用途にはほとんど使う気しない。

そういえば何でHSPみたいな糞が流行ってるんでしょうな

↑馬鹿の一つ覚えﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ
ﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟﾌﾟ

↑馬鹿の一つ覚え

そういえば何で「↑馬鹿の一つ覚えﾌﾟﾌﾟﾌﾟ」みたいな糞が流行ってるんでしょうな

　　　　　---　　　　　最　　　高　　　言　　　語　　　R　　　u　　　b　　　y　　　---


.

LISPer いますか？

おれのいくスレはいつもRuby関係で荒れるな（ｗ
どうにかしろよ

>>592
いたらどうする

>>592
いるけど最速だの最高だの最強だのと主張する気はないぞ

LISPerは >>592 を除いてみんな大人

LISP って実用性が低いって本当ですか？

ねこみみです。

本家 Yahoo! のショッピングに Lisp が使われる程度には実用性がありません。

できる人間は道具を選ぶ権利がある。
そうでない人間は道具に従うことになる。

LISPって速いの？

Re:>601 LISPにはバイトコンパイルがあるから、微妙なところ。

ところで、C言語のインタプリタってどこにあるのですか？

これのことじゃないの？
ttp://root.cern.ch/root/Cint.html

ﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌ
ﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌ
ﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌ
ﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌﾌ

うちのperlで>>381がうまく動いてないみたいなんですが、
何が原因でしょうか？（いつまでたっても終わらない）
WindowsXPに入れたActivePerlです。
バージョンは

perl -v

This is perl, v5.8.2 built for MSWin32-x86-multi-thread
(with 25 registered patches, see perl -V for more detail)

Copyright 1987-2003, Larry Wall

Binary build 808 provided by ActiveState Corp. http://www.ActiveState.com
ActiveState is a division of Sophos.
Built Dec 9 2003 10:19:40

もっと小さい入力でやってみたら？
(12,6,0)じゃなくて(2,1,0)とか

(11,6,0)でやったら終わりました。

(12,6,0)ではスタック溢れか何かでしょうか？
でもインタプリタのくせにエラー出ないのはおかしいですよね。
Ctrl+Cで止めようとするとアクセス違反のダイアログが出るし。
これはPerlのバグ？
自分内でのPerlの信用度が低下しました。

ActivePerlの最新版5.8.4build 810でやっても同じでした。
ちゃんとテストしてないのかな。

cygwin だとちゃんと動くんだよね

~$ perl -v
This is perl, v5.8.5 built for cygwin-thread-multi-64int

そうでしたか。
この件でActiveStateの信用ガタ落ちしました。
もうあそこのは使わないことにします。
ありがとうございました。

Ｒｕｂｙ ＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞ Ｐｅｒｌ

cygwinのperlでやってみました。
おおざっぱですが
ruby 1.8.1 (2003-12-25) [i386-mswin32]は15秒
perl, v5.8.5 built for cygwin-thread-multi-64intは15秒
Gauche scheme interpreter, version 0.8.1 [euc-jp]は3秒
となりました。(WindowsXP Pro Pentium M1.6G)

Perl 版は >>381 より >>370 のほうが速い
配列の参照回数が減るから

ごめん>>613は忘れて

ごめん LISPer は忘れて。

ごめんこのスレは忘れて

CCleanは速いみたいだけど
ぜんぜん読めえや（ｗ
速さは言語難易度と比例するのか

　>　　スクリプト言語でいちばん速いのはどれでしょうか？
　>　　これって、トリビアの種になりますよね？よろしくお願いします。

>>618 Ruby 次期バージョン

LINGO

>>617
hellow world と １〜１０００まで合計するプログラムキボン！

>>617
アセンブラ最強伝説は揺るがないってことでフジワラ豆腐店〜

おまいらCやC++もスクリプト言語として考えて順列つけてるのか？
一応Cは除外したが。あとweb限定で考えてるけどいいんだよな？

そうすると　JAVA＞PHP＞Perl＞Python≧Ruby

Rubyに関してはオブジェクト指向を速度より優先して作ってるから遅くても仕方ない。
Pythonも速度を気にするならCで書いて、それを読みこめって感じだからね。
最近はJAVAのとこPHPに書き直したりしてるし、そこまで速度は変わらないようだ。

Ruby ＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞ Java

>>582

使いたいときに使いたい言語を使えば良い。それだけのこと。

使いたいときに使える言語がない。それだけのこと。

勉強せぃってヵ。

ハノイの塔で競うのはどうか
グラフ探索とか
ライブラリだけでできない様な処理がいい

ヾ( ﾟдﾟ)ﾉ゛ﾊﾔｸｶｹｰ

速度が必要ならCで書いて読み込めばいいっていわれても、
普段スクリプト言語使ってると、いまさらCで書くのが面倒で馬鹿馬鹿しくなってくるんだよな。

>>630
そうそう。近未来的なスクリプト言語では、
スクリプト ソースの中に拡張モジュールのコードを埋め込めるのがいい。
実行時に動的にコンパイルしてくれる。

実行時に毎回コンパイルすんの？

>>631
拡張モジュールかはともかく、
似たものは既にPerlにあるよ。

>>633
Ruby ＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞ Perl

>>632
どっかにキャッシュしておけばいい。

>>633
それはどうやってやるの？

30秒と経たないうちに反応があるというのも怖いな。

>>635 Inline.pm

>>637 情報ありがとう。面白そうだから調べてみる。

スクリプトの利便性を捨ててるよな＞Inline.pm
特定環境でしかｳｺﾞｶﾈｴだろ

Perlすごいね！
どうやってるんだろう！

って、動的な言語なら大したことねーですよ（ﾌﾟ

意味不明。馬鹿？

>>641
Ｒｕｂｙ ？？？？？？？？？＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞＞Ｐｅｒｌ

Perl6は何でも埋め込めるんでしょ

それはparrotではないのか。しかも違うし。

>>623
だ〜か〜ら〜
速度が遅いのをオブジェクト指向の性にするなって！

散々既出だろ、アフォ目

DOSコマンド最速

オブジェクト試行

オブジェクト女学院

オブジェクト奉行

オブジェクト趣向

オブジェクト太郎

オブジェクト仮面

>>648
ワロタｗ

あーあ、台無しだ

最強オブジェクト指向 Ruby

ぶち壊しトドメはこれにつきるね。＞るび

>>656
ストッパー、師範認定！

いまさらだが、実行速度を出すコーディングができるというのと、
普通にコーディングしたきの実行速度って違うよな。

あと、Perl で Inline::C 使うのと、
ネイティブコードになってる外部モジュール使うのって、あんま差ないよな。

>>658
前半、比較対象がそもそも違う。
後半、意味不明

配布されてるバイナリやmakefileをそのまま使わずに
CPUに最適化させるとかなり高速化するよな

>>660
何の話をしてる？

たまたま見つけたというかgoogleの最初のほうにあったのを貼っとく
http://www.lib.uchicago.edu/keith/crisis/benchmarks/tak/

うちの環境でそれやってみたけど
Perl 506678 microseconds per iteration
Python 1029786 microseconds per iteration
Tcl 1199482 microseconds per iteration
だったよ

ちなみにCは15513 microseconds per iterationだったよ

いろんな言語がparrotで実行されるようになったら、
ベンチマークの差もなくなってくるのかな。

Io試してみたけど遅いぞ

tarai := method(x, y, z,
　return if(x <= y, y,
　　thisBlock(
　　　thisBlock(x-1, y, z),
　　　thisBlock(y-1, z, x),
　　　thisBlock(z-1, x, y))))
tarai(12,6,0)

=> 2.5 / ruby 1.8.1 (2003-12-25) [i386-mswin32]

Ｉｏはこっから落としたやつ
http://www.iolanguage.com/Downloads/
IoDesktop-2004-12-16

http://www.iolanguage.com/Comparisons/Performance.html
ここのベンチも２年前のだからあてになんないね

まだ、タライ回しとかやってたのかｗ
もっと実用的なベンチマークは無いのか？

実用的なベンチって何？

MD5の実装

じゃ、ためしにソース晒せ

めんどくさいから文字列連結にしよう

タライ回しって、関数呼出ぐらいしか計れないよねぇ〜

function cat(l, r) { return l + r; }
var s = "", max = 1000000;
for (var i = 0; i < max; i++) { s = cat(s, i); }

>>669
LISP インタプリタ

LISP自体が（ry

あげてまで何がいいたいんだ？

>>677
彼はLISP使いに嫉妬するロートルプログラマー39歳

保守

>>678
貴方もLISP使いに嫉妬するﾛｰﾄﾙﾌﾟﾛｸﾞﾗﾏｰ39歳

たらい回し関数でGO!