秋山好一です。
てらじま様、貴重なご助言ありがとうございました。
クラスター分析の、見苦しいdef 式を以下に追加しておきます。
改良すべき点がきっとある?とにかく正確に作動しています。
def cluster_pat(mat)
     ro = mat.length
     co = mat[0].length
     rc = (ro - co).abs     #co×coの正方行列
     mat.pop(rc)
     ro = mat.length
     mat01 = Array.new(ro) {|i| [] }
     mat02 = Array.new(ro) {|i| [] }
     count = 1
#-----行列要素がすべて -1 でtimesループ脱出---------
     ro.times do  #ループ開始
         yy = -1
         mat.each do |x|
             x.each do |y|
                 yy = 0 if y != yy
             end
         end
         break if yy == -1
#-------------------------------------------------
         q = []
         0.upto(ro-1) do |i|
             0.upto(co-1) do |j|
                 q << mat[i][j]
             end
         end
         cut = q.max
#----------弁別レベルに等しいか大きければ対応する要素を-1とする 
------------------
         0.upto(co-1) do |i|
             0.upto(co-1) do |j|
                 mat[i][j] = -1 if mat[i][j] >= cut
             end
         end
  #-------------------------------------------------------------
         printf("%i%s %s %1.2f %2s",count,"回目","識別レベル",cut, " ""\n")
         0.upto(co-1) do |i|
                     print("[",(i+65).chr,"]","  ")
         end
         puts ""
         0.upto(ro-1) do |i|
             0.upto(co-1) do |j|
                     mat01[i][j] = 0 if mat[i][j] != -1
                     mat01[i][j] = 1 if mat[i][j] == -1
                     printf("%2i %2s",mat01[i][j], " ")
             end
             puts ""
         end
#ここから先は、もっとスマートにきっとなる?
         mat02 = mat01.transpose    #列行入換え
#列の小さい方から大きい方へパターン探索
         f1 = []
         0.upto(ro-1) do |i|
             f = []
             f.push((i+65).chr)
             (i+1).upto(co-1) do |j|
                 f.push((j+65).chr) if mat02[i] == mat02[j]
             end
             f = f.uniq
             f1 << f  if f.length >= 2
         end
         f11 = []
         f111 = []
         n = 0
         f1.each do |x|
             f11[n] = x
             f111 << f11[n]
             n += 1
         end
#列の大きい方から小さい方へパターン探索
         b1 = []
         0.upto(ro-1) do |i|
             b = []
             b.push((ro-1-i+65).chr)
             (i+1).upto(co-1) do |j|
                 b.push((co-1-j+65).chr)  if mat02[co-1-i]  == 
mat02[co-1-j]
             end
             b = b.uniq
             b1 << b if b.length >= 2
         end
         b11 = []
         b111 = []
         n = 0
         b1.each do |x|
             b11[n] =  x
             b111 << b11[n]
             n += 1
         end
#-----------------------------------------------------------
         f111 = f111.uniq
         b111 = b111.uniq
         if (f111[0] & b111[0] != f111[0]) then
              p f111[0]  if f111[0] != nil
              p b111[0].reverse  if b111[0] != nil
         else
             p f111[0]  if f111[0] != nil
         end
             p f111[1]   if f111[1] != nil && f111[1] & b111[0] != f111[1]
         count += 1
     end
end
ーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー
てらじまと申します

 > 質問事項は、def文の連続というパターンは、rubyでは何か不自然/邪道なの 
で しょうか?ということです。

先ほどきしもとさんから返信があった通り、Rubyの文法上def文というものはあ 
りません。
defはメソッドを定義する時に使用します。

示されている例と

 > def文で、データを読み取ります。
 > def文で、類似度係数行列を作成します。
 > def文で、推移性行列を作成します。
 > def文で、類似関係(ファジィ同値関係)を表示します。

を拝見するに、
ご質問にあるdef文というのはメソッド呼び出しのことをさしているのでしょうか?

# メソッド定義
def foo(bar)
end

# メソッド呼び出し
foo(some_var) # <- これをdef文と呼んでいる?

(違っていたら以下は無視してください)

そうだとすると、ご質問の内容は
「(制御構造等を使用せず)単に定義したメソッドの呼び出しの連続で構成される 
スクリプトは不自然か?」
ということになるかと思いますが、
そのような作りそれ自体がRubyとして不自然だ、ということはないでしょう。

ただ、メソッド定義の内容によっては「つめこみすぎ」、
(メソッドを呼び出す側からすると「処理を隠しすぎ」)
となることもあります。

また、Rubyのオブジェクト指向的側面からは、
類似関係を処理するクラスを作成し、
たとえばCSVファイル名かなにかを受け取ってインスタンス化し、
必要に応じて、欲する形式の行列を取得する、
という作りのほうが自然になるかもしれません。

その場合の大枠は正木さんの返信にあるようなコードになると思います。

# この方針でいく場合「どこにどのように表示するか」は呼び出し側の都合であ 
ることが多いので
# 実際に表示する部分については類似関係処理クラスに含めない方がいいかもし 
れません