prepress-tips

構造と処理を別の言語で書いて組合せる２

最終更新：2009年03月29日 22:20

prepress-tips

- view

管理者のみ編集可

　構造を日本語プログラムで処理を通常のプログラム言語で書いて組合せる
　方法を実利用できるようにしました。 java と perl が使えます。

最終更新日時： 2009/03/29

javaで

perlで

※ ここのtxtをソースに変換するプログラムは → codeLayouter
※ htmlとjavascriptでの利用を検討したものは → 構造と処理を別の言語で書いて組合せる３

Edit

javaで

wgc_index.txt ‥ 処理の全体の構造
wgc_java.txt ‥ javaによる処理の詳細
my_java_lib.txt ‥ ライブラリから
ソース言語に変換
perl codeLayouter.pl wgc_index.txt
（出力ファイル名 wgc.java は wgc_java.txt 内の /name文で指定）
wgc.java ‥ ソース言語に変換された結果

wgc_index.txt

/name wgc問題

? したいことは ‥

    ? wgc問題を解く
        / タイトル を表示する
        / 初期状態 からgoal_seekerで解く
        / 解 を表示する

    ? 初期状態
        / 状態 ( "wgcf" ) を戻す

? goalseekerを使うにあたって ‥

    ? ゴールか
        / ""か
    ? 連れて行けるものは
        / fがある ならば どれか１つ を戻す
        / そうでなければ 反対側 のどれか１つ を戻す
    ? ( a )を連れて行くと
        / 新しい状態を用意する
        / fがある ならば fとaを除く
        / そうでなければ fとaを加える
        / 新しい状態 を戻す
    ? 制約を満たしているか
        / fがある ならば wgのどちらかがある かつ gcのどちらかがある を戻す
        / そうでなければ wgがともにない かつ gcがともにない を戻す

    ? ゴールですること
        / 解 に 状態の推移 を加える
    ? 新しい状態ですること
        / 状態 を 状態の推移 に加える
    ? 前の状態に戻すには
        / 状態の推移 から最後の状態を除く
    ? 状態を一意に表現するには
        / 状態の文字列を分解・ソートして並べ直す

/use 処理の詳細 / wgc_java.txt
/use ライブラリ / my_java_lib.txt

my_java_lib.txt

/? 構文

    ** ( ？？ )ならば( ？？ ) / if( $1 ) { $2 }
    ** そうでなければ( ？ ) / else { $1 }
    ** ( ？ )を戻す / return $1 ;
    ** かつ / &&

/name my_java_lib

import java.util.ArrayList;
import java.util.Iterator;

? メッセージを表示する / class Msg

    ? ( m )を表示する / static void Msg.msg( String m )
        System.out.println( m );

    ? ( m )を表示する / static void Msg.msg( ArrayList m )
        Iterator it = m.iterator();
        while( it.hasNext() ) { System.out.println( it.next() ); }

? モデルの解を求める / class GoalSeeker

    ? / GoalSeeker ( State state, StateProcessor p )
        processor = p;
        twice = new ArrayList();
        goal_seeker ( state );

    /+ / StateProcessor processor
    /+ / ArrayList twice

    ? / void goal_seeker ( State state )
        if( state == null ) { return; }
        if( twice.contains( processor.unique( state ) ) ) { return; }
        if( ! processor.constraint( state ) ) { return; }
        if( processor.goal( state ) ) { processor.goal_lambda( state ); return; }
        processor.lambda( state );
        twice.add( processor.unique( state ) );
        String[] actions = processor.Actions( state );
        for( int i = 0; i < actions.length; i++ ) {
            String a = actions[ i ];
            if( a.equals( "" ) ) { continue; }
            State new_state = processor.Delta( state, a );
            goal_seeker( new_state );
        }
        twice.remove( processor.unique( state ) );
        processor.lambda_back( state );

? / abstract class State
    String state;
    public String toString() { return state; }

? / abstract class StateProcessor
    abstract boolean goal( State state );
    abstract void goal_lambda( State state );
    abstract void lambda( State state );
    abstract void lambda_back( State state );
    abstract String[] Actions( State state );
    abstract State Delta( State state, String action );
    abstract boolean constraint( State state );
    abstract String unique( State state );

wgc_java.txt

/name my_java_lib / wgc.java

/name wgc問題 / wgc.java

package wgc;
import java.util.Arrays;

? したいことは ‥ / class Wgc

    * wgc問題を解く / public static void main ( String[] args )

    ? タイトル / static String title()
        return "狼・山羊・キャベツの川渡し問題";

    ? ( state )からgoal_seekerで解く / static void solve( State state )
        answer_array = new ArrayList();
        new GoalSeeker( state, new WgcProcessor( answer_array ) );

    ? 解 / static ArrayList answer()
        / 解の配列 を戻す
    ? 解の配列 / static ArrayList answer_array

    * 初期状態 / static WgcState InitialState()

? 状態 / class WgcState extends State

    ? 状態 *[(]( s )[)] / new WgcState( String s )
        super();
        state = s;

    ? / public String toString()
        return state;

? goalseekerを使うにあたって ‥ / class WgcProcessor extends StateProcessor

    * ゴールか / boolean goal( State state )
    * 連れて行けるものは / String[] Actions( State state )
    * ( a )を連れて行くと / State Delta( State state, String a )
    * 制約を満たしているか / boolean constraint( State state )
    * ゴールですること /void goal_lambda( State state )
    * 新しい状態ですること / void lambda( State state )
    * 前の状態に戻すには / void lambda_back( State state )
    * 状態を一意に表現するには / String unique( State state )

    * _状態_ /
        state.state

    * ""か /
        / _状態_ .equals( "" ) を戻す

    ? fがある / boolean f_in( State state )
        / _状態_ .matches( ".*f.*" ) を戻す

    * どれか１つ /
        / _状態_ のどれか１つ

    ? 反対側 / String opposite( State state )
            / String b = _状態_
            String a = "wgcf";
            if( b.length() == 0 ) { return a; }
            return a.replaceAll( "[" + b + "]", "" );

    ? ( s )のどれか１つ / String[] one_of( String s )
            return s.split( "" );

    * 新しい状態を用意する /
            state = new WgcState( state.state );

    * fとaを除く /
            state.state = state.state.replaceAll( "[f" + a + "]", "" );

    * fとaを加える /
            state.state += a.equals( "f" ) ? "f" : "f" + a ;

    * 新しい状態 /
            state

    * wgのどちらかがある /
            state.state.matches( ".*[wg].*" )

    * gcのどちらかがある /
            state.state.matches( ".*[gc].*" )

    * wgがともにない /
            ! state.state.matches( ".*(w.*g|g.*w).*" )

    * gcがともにない /
            ! state.state.matches( ".*(g.*c|c.*g).*" )

    * 解 に 状態の推移 を加える /
            Iterator it = sequence.iterator();
            String r = ""; while( it.hasNext() ) { r += " → " + it.next(); }
            r += " → " + state.toString();
            answer_array.add( r.replaceFirst( "( → )+", "" ) );
    ? 状態の推移/ ArrayList sequence

    ? / WgcProcessor( ArrayList answer )
        super();
        answer_array = answer;
        sequence = new ArrayList();

    ? 渡された解の配列 / ArrayList answer_array

    * 状態 を 状態の推移 に加える /
        sequence.add( state.toString() );

    * 状態の推移 から最後の状態を除く /
           sequence.remove( sequence.size() - 1 );

    * 状態の文字列を分解・ソートして並べ直す /
            String[] s = state.state.split( "" ); Arrays.sort( s );
            String r = ""; for( int i = 0; i < s.length; i++ ) { r += s[i]; }
            return r.replaceAll( "f+" , "f" );

wgc.java

package wgc;
import java.util.Arrays;


import java.util.ArrayList;
import java.util.Iterator;

class Wgc { // したいことは ‥ 

    public static void main ( String[] args ) { // wgc問題を解く
        // タイトル を表示する
            Msg.msg( title() );
        // 初期状態 からgoal_seekerで解く
            solve( InitialState() );
        // 解 を表示する
            Msg.msg( answer() );
    }

    static WgcState InitialState() { // 初期状態
        // 状態 ( "wgcf" ) を戻す
            return new WgcState(  "wgcf" ) ;
    }

    static String title() { // タイトル 
        return "狼・山羊・キャベツの川渡し問題";
    }

    static void solve( State state ) { // ( state )からgoal_seekerで解く 
        answer_array = new ArrayList();
        new GoalSeeker( state, new WgcProcessor( answer_array ) );
    }

    static ArrayList answer() { // 解 
        // 解の配列 を戻す
            return answer_array ;
    }
    static ArrayList answer_array;  // 解の配列 
}

class WgcProcessor extends StateProcessor { // goalseekerを使うにあたって ‥ 

    boolean goal( State state ) { // ゴールか
        // ""か
            // _状態_ .equals( "" ) を戻す
                return state.state .equals( "" )  ;
    }
    String[] Actions( State state ) { // 連れて行けるものは
        // fがある ならば どれか１つ を戻す
            if( f_in( state ) ) { return 
                // _状態_ のどれか１つ
                    one_of(  state.state )
            ; }
        // そうでなければ 反対側 のどれか１つ を戻す
            else { return one_of( opposite( state ) ) ; }
    }
    State Delta( State state, String a ) { // ( a )を連れて行くと
        // 新しい状態を用意する
            state = new WgcState( state.state );
        // fがある ならば fとaを除く
            if( f_in( state ) ) { state.state = state.state.replaceAll( "[f" + a + "]", "" ); }
        // そうでなければ fとaを加える
            else { state.state += a.equals( "f" ) ? "f" : "f" + a ; }
        // 新しい状態 を戻す
            return state ;
    }
    boolean constraint( State state ) { // 制約を満たしているか
        // fがある ならば wgのどちらかがある かつ gcのどちらかがある を戻す
            if( f_in( state ) ) { return state.state.matches( ".*[wg].*" ) && state.state.matches( ".*[gc].*" ) ; }
        // そうでなければ wgがともにない かつ gcがともにない を戻す
            else { return ! state.state.matches( ".*(w.*g|g.*w).*" ) && ! state.state.matches( ".*(g.*c|c.*g).*" ) ; }
    }

    void goal_lambda( State state ) { // ゴールですること
        // 解 に 状態の推移 を加える
                Iterator it = sequence.iterator();
                String r = ""; while( it.hasNext() ) { r += " → " + it.next(); }
                r += " → " + state.toString();
                answer_array.add( r.replaceFirst( "( → )+", "" ) );
    }
    void lambda( State state ) { // 新しい状態ですること
        // 状態 を 状態の推移 に加える
            sequence.add( state.toString() );
    }
    void lambda_back( State state ) { // 前の状態に戻すには
        // 状態の推移 から最後の状態を除く
            sequence.remove( sequence.size() - 1 );
    }
    String unique( State state ) { // 状態を一意に表現するには
        // 状態の文字列を分解・ソートして並べ直す
                String[] s = state.state.split( "" ); Arrays.sort( s );
                String r = ""; for( int i = 0; i < s.length; i++ ) { r += s[i]; }
                return r.replaceAll( "f+" , "f" );
    }

    boolean f_in( State state ) { // fがある 
        // _状態_ .matches( ".*f.*" ) を戻す
            return state.state .matches( ".*f.*" )  ;
    }

    String opposite( State state ) { // 反対側 
            // String b = _状態_
                String b = state.state;
            String a = "wgcf";
            if( b.length() == 0 ) { return a; }
            return a.replaceAll( "[" + b + "]", "" );
    }

    String[] one_of( String s ) { // ( s )のどれか１つ 
            return s.split( "" );
    }

    ArrayList sequence;  // 状態の推移

    WgcProcessor( ArrayList answer ) { // 
        super();
        answer_array = answer;
        sequence = new ArrayList();
    }

    ArrayList answer_array;  // 渡された解の配列 
}

class WgcState extends State { // 状態 

    WgcState( String s ) { // 状態 *[(]( s )[)] 
        super();
        state = s;
    }

    public String toString() { // 
        return state;
    }
}

//  構文

class Msg { // メッセージを表示する 

    static void msg( String m ) { // ( m )を表示する 
        System.out.println( m );
    }

    static void msg( ArrayList m ) { // ( m )を表示する 
        Iterator it = m.iterator();
        while( it.hasNext() ) { System.out.println( it.next() ); }
    }
}

class GoalSeeker { // モデルの解を求める 

    GoalSeeker ( State state, StateProcessor p ) { // 
        processor = p;
        twice = new ArrayList();
        goal_seeker ( state );
    }

    StateProcessor processor; // 
    ArrayList twice; // 

    void goal_seeker ( State state ) { // 
        if( state == null ) { return; }
        if( twice.contains( processor.unique( state ) ) ) { return; }
        if( ! processor.constraint( state ) ) { return; }
        if( processor.goal( state ) ) { processor.goal_lambda( state ); return; }
        processor.lambda( state );
        twice.add( processor.unique( state ) );
        String[] actions = processor.Actions( state );
        for( int i = 0; i < actions.length; i++ ) {
            String a = actions[ i ];
            if( a.equals( "" ) ) { continue; }
            State new_state = processor.Delta( state, a );
            goal_seeker( new_state );
        }
        twice.remove( processor.unique( state ) );
        processor.lambda_back( state );
    }
}

abstract class State { // 
    String state;
    public String toString() { return state; }
}

abstract class StateProcessor { // 
    abstract boolean goal( State state );
    abstract void goal_lambda( State state );
    abstract void lambda( State state );
    abstract void lambda_back( State state );
    abstract String[] Actions( State state );
    abstract State Delta( State state, String action );
    abstract boolean constraint( State state );
    abstract String unique( State state );
}

perlで

wgc_index.txt 内の /use文を取り替える。
（ java と書いてあるところを perl に変える）

/use 処理の詳細 / wgc_perl.txt
/use ライブラリ / my_perl_lib.txt

wgc_perl.txt ‥ perlによる処理の詳細
my_perl_lib.txt ‥ ライブラリから
ソース言語に変換
perl codeLayouter.pl wgc_index.txt
（出力ファイル名 wgc.pl は wgc_perl.txt 内の /name文で指定）
wgc.pl ‥ ソース言語に変換された結果
もっと簡単に記述することもできますが、
サンプルの意味を兼ねて javaと同じ構造で作ってみました。

wgc_index.txt

/name wgc問題

? したいことは ‥

    ? wgc問題を解く
        / タイトル を表示する
        / 初期状態 からgoal_seekerで解く
        / 解 を表示する

    ? 初期状態
        / 状態 ( "wgcf" ) を戻す

? goalseekerを使うにあたって ‥

    ? ゴールか
        / ""か
    ? 連れて行けるものは
        / fがある ならば どれか１つ を戻す
        / そうでなければ 反対側 のどれか１つ を戻す
    ? ( a )を連れて行くと
        / 新しい状態を用意する
        / fがある ならば fとaを除く
        / そうでなければ fとaを加える
        / 新しい状態 を戻す
    ? 制約を満たしているか
        / fがある ならば wgのどちらかがある かつ gcのどちらかがある を戻す
        / そうでなければ wgがともにない かつ gcがともにない を戻す

    ? ゴールですること
        / 解 に 状態の推移 を加える
    ? 新しい状態ですること
        / 状態 を 状態の推移 に加える
    ? 前の状態に戻すには
        / 状態の推移 から最後の状態を除く
    ? 状態を一意に表現するには
        / 状態の文字列を分解・ソートして並べ直す

/use 処理の詳細 / wgc_perl.txt
/use ライブラリ / my_perl_lib.txt

my_perl_lib.txt

/? 構文

    ** ( ？？ )ならば( ？？ ) / if( $1 ) { $2 }
    ** そうでなければ( ？ ) / else { $1 }
    ** ( ？ )を戻す / return $1 ;
    ** かつ / &&

/name my_perl_lib

? メッセージを表示する / package msg

    ? ( m )を表示する / msg::msg( m )
        print $_[0]."\x0a";

? モデルの解を求める / package goal_seeker

    ? / goal_seeker()
        my ( $state, $ready, ) = @_;
        $state || return; $ready || ( $twice = {} );
        ! $twice->{ $state->unique } && $state->constraint || return;
        $state->goal && ( $state->goal_lambda, return ); $state->lambda;
        $twice->{ $state->unique } = 1;
        map do { goal_seeker( $_, 1 ); },
            map do { $state->Delta( $_ ); }, $state->Actions;
        $twice->{ $state->unique } = undef;
        $state->lambda_back;

wgc_perl.txt

/name my_perl_lib / wgc.pl

/name wgc問題 / wgc.pl
    main();

* したいことは ‥ / package main
* goalseekerを使うにあたって ‥ / package goal_seeker

? / package main

    * wgc問題を解く / main()

    ? タイトル / title()
        'wgc問題を解く';

    ? ( s )からgoal_seekerで解く / solve( s )
        $answer = "";
        $goal_seeker::debug = 1;
        $goal_seeker::sequence = "";
        goal_seeker::goal_seeker( InitialState() );

    ? 解 / answer()
        / 解の文字列 を戻す
    ? 解の文字列 / $answer

    * 初期状態 / InitialState()

? / package goal_seeker

    ? 状態 *[(]( s )[)] / goal_seeker::State( s )
        bless { state => $_[0] };

    * ゴールか / goal()
    * 連れて行けるものは / Actions()
    * ( a )を連れて行くと / Delta( a )
    * 制約を満たしているか / constraint()
    * ゴールですること /goal_lambda()
    * 新しい状態ですること / lambda()
    * 前の状態に戻すには / lambda_back()
    * 状態を一意に表現するには / unique()

    * ""か /
        $_[0]->{state} eq "";

    ? fがある / f_in( @_ )
        $_[0]->{state} =~ /f/;

    * どれか１つ /
        split "", $_[0]->{state};

    ? 反対側 / opposite( @_ )
        my $all = "wgcf";
        $_[0]->{state} eq "" || ( $all =~ s/[$_[0]->{state}]//g );
        $all;

    ? ( s )のどれか１つ / one_of( s )
        split "", $_[0];

    * 新しい状態を用意する /
        $_[2] || ( return State( $_[0]->{state} )->Delta( $_[1], 1 ) );
        $debug && print "-$_[1]\x0a";

    * fとaを除く /
        $_[0]->{state} =~ s/[f$_[1]]//g; $_[0];

    * fとaを加える /
        $_[0]->{state} .= $_[1] eq 'f' ? 'f' : 'f'.$_[1]; $_[0];

    * 新しい状態 /
        $_[0]

    * wgのどちらかがある / contain( @_, 'wg' )
    * gcのどちらかがある / contain( @_, 'gc' )
    ? / contain()
        $_[0]->{state} =~ /[$_[1]]/;

    * wgがともにない / not_contain( @_, 'wg' )
    * gcがともにない / not_contain( @_, 'gc' )
    ? / not_contain()
        my @a = ( $_[0]->{state} =~ /[$_[1]]/g );
        return @a != 2;

    * 解 に 状態の推移 を加える /
        $main::answer .= $sequence.' → '."\x0a";
        $debug && print "$_[0]->{state}\x0a";
    ? 状態の推移 / $sequence

    * 状態 を 状態の推移 に加える /
        $sequence .= ( $sequence ? ' → ' : "" ).$_[0]->{state};
        $debug && print "$_[0]->{state}\x0a";

    * 状態の推移 から最後の状態を除く / 
        $sequence =~ s/ → \w+$//;

    * 状態の文字列を分解・ソートして並べ直す /
        join "", sort split "", $_[0]->{state};

wgc.pl

main();

{ package main;  # したいことは ‥

    sub main { # wgc問題を解く
        # タイトル を表示する
            msg::msg( title() );
        # 初期状態 からgoal_seekerで解く
            solve( InitialState() );
        # 解 を表示する
            msg::msg( answer() );
    }

    sub InitialState { # 初期状態
        # 状態 ( "wgcf" ) を戻す
            return goal_seeker::State(  "wgcf" ) ;
    }
}

{ package goal_seeker;  # goalseekerを使うにあたって ‥

    sub goal { # ゴールか
        # ""か
            $_[0]->{state} eq "";
    }
    sub Actions { # 連れて行けるものは
        # fがある ならば どれか１つ を戻す
            if( f_in(  @_  ) ) { return split "", $_[0]->{state}; ; }
        # そうでなければ 反対側 のどれか１つ を戻す
            else { return one_of( opposite(  @_  ) ) ; }
    }
    sub Delta { # ( a )を連れて行くと
        # 新しい状態を用意する
            $_[2] || ( return State( $_[0]->{state} )->Delta( $_[1], 1 ) );
            $debug && print "-$_[1]\x0a";
        # fがある ならば fとaを除く
            if( f_in(  @_  ) ) { $_[0]->{state} =~ s/[f$_[1]]//g; $_[0]; }
        # そうでなければ fとaを加える
            else { $_[0]->{state} .= $_[1] eq 'f' ? 'f' : 'f'.$_[1]; $_[0]; }
        # 新しい状態 を戻す
            return $_[0] ;
    }
    sub constraint { # 制約を満たしているか
        # fがある ならば wgのどちらかがある かつ gcのどちらかがある を戻す
            if( f_in(  @_  ) ) { return contain(  @_,  'wg'  ) && contain(  @_,  'gc'  ) ; }
        # そうでなければ wgがともにない かつ gcがともにない を戻す
            else { return not_contain(  @_,  'wg'  ) && not_contain(  @_,  'gc'  ) ; }
    }

    sub goal_lambda { # ゴールですること
        # 解 に 状態の推移 を加える
            $main::answer .= $sequence.' → '."\x0a";
            $debug && print "$_[0]->{state}\x0a";
    }
    sub lambda { # 新しい状態ですること
        # 状態 を 状態の推移 に加える
            $sequence .= ( $sequence ? ' → ' : "" ).$_[0]->{state};
            $debug && print "$_[0]->{state}\x0a";
    }
    sub lambda_back { # 前の状態に戻すには
        # 状態の推移 から最後の状態を除く
            $sequence =~ s/ → \w+$//;
    }
    sub unique { # 状態を一意に表現するには
        # 状態の文字列を分解・ソートして並べ直す
            join "", sort split "", $_[0]->{state};
    }
}


{ package main;  # 

    sub title { # タイトル 
        'wgc問題を解く';
    }

    sub solve { # ( s )からgoal_seekerで解く 
        $answer = "";
        $goal_seeker::debug = 1;
        $goal_seeker::sequence = "";
        goal_seeker::goal_seeker( InitialState() );
    }

    sub answer { # 解 
        # 解の文字列 を戻す
            return $answer ;
    }
    $answer;  # 解の文字列 
}

{ package goal_seeker;  # 

    sub goal_seeker::State { # 状態 *[(]( s )[)] 
        bless { state => $_[0] };
    }

    sub f_in { # fがある 
        $_[0]->{state} =~ /f/;
    }

    sub opposite { # 反対側 
        my $all = "wgcf";
        $_[0]->{state} eq "" || ( $all =~ s/[$_[0]->{state}]//g );
        $all;
    }

    sub one_of { # ( s )のどれか１つ 
        split "", $_[0];
    }

    sub contain { # 
        $_[0]->{state} =~ /[$_[1]]/;
    }

    sub not_contain { # 
        my @a = ( $_[0]->{state} =~ /[$_[1]]/g );
        return @a != 2;
    }

    $sequence;  # 状態の推移 
}

#  構文

{ package msg;  # メッセージを表示する 

    sub msg::msg { # ( m )を表示する 
        print $_[0]."\x0a";
    }
}

{ package goal_seeker;  # モデルの解を求める 

    sub goal_seeker { # 
        my ( $state, $ready, ) = @_;
        $state || return; $ready || ( $twice = {} );
        ! $twice->{ $state->unique } && $state->constraint || return;
        $state->goal && ( $state->goal_lambda, return ); $state->lambda;
        $twice->{ $state->unique } = 1;
        map do { goal_seeker( $_, 1 ); },
            map do { $state->Delta( $_ ); }, $state->Actions;
        $twice->{ $state->unique } = undef;
        $state->lambda_back;
    }
}

Edit

「構造と処理を別の言語で書いて組合せる２」をウィキ内検索

人気記事ランキング

最近更新されたページ

急上昇Wikiランキング

急上昇中のWikiランキングです。今注目を集めている話題をチェックしてみよう！

人気Wikiランキング

atwikiでよく見られているWikiのランキングです。新しい情報を発見してみよう！

新規Wikiランキング

最近作成されたWikiのアクセスランキングです。見るだけでなく加筆してみよう！

全体ページランキング

最近アクセスの多かったページランキングです。話題のページを見に行こう！

構造と処理を別の言語で書いて組合せる ２

javaで

perlで

更新履歴

構造と処理を別の言語で書いて組合せる２