MaplePrimes - answers and comments on Question, How do I use system of Krylov functions?

create a conversion

Joe Riel — Sat, 02 Apr 2011 09:51:21 Z

What do you plan to do with them? You might consider writing a simple module that provides some conversions. For example,

krylov := module()
option package;

global K1,K2,K3,K4;

export To, From, Simplify, Evalf;

local ModuleLoad, removeImaginary;

    ModuleLoad := proc()
    global `convert/tokrylov`, `convert/fromkrylov`, `simplify/krylov`
        , `evalf/K1`, `evalf/K2`, `evalf/K3`, `evalf/K4`;

        `convert/tokrylov`   := To;
        `convert/fromkrylov` := From;
        `simplify/krylov`    := Simplify;
        `evalf/K1`           := x -> Evalf(K1(x));
        `evalf/K2`           := x -> Evalf(K2(x));
        `evalf/K3`           := x -> Evalf(K3(x));
        `evalf/K4`           := x -> Evalf(K3(x));

    end proc;

    To := proc(ex)
        eval(ex, [cos = K1-K3,
                  sin = K2-K4,
                  cosh = K1+K3,
                  sinh = K2+K4
                 ]);
    end proc:

    From := proc(ex)
        eval(ex, [K1 = 1/2*cosh + 1/2*cos,
                  K2 = 1/2*sinh + 1/2*sin,
                  K3 = 1/2*cosh - 1/2*cos,
                  K4 = 1/2*sinh - 1/2*sin
                 ]);
    end proc:

    Evalf := proc(ex)
        evalf(From(ex), _rest);
    end proc;

    Simplify := proc(ex)
        # a very basic simplification, Kx(I*z) --> Kx(z)
        evalindets(ex
                   , 'specfunc(anything,{K1,K2,K3,K4})'
                   , fx -> op(0,fx)(removeImaginary(op(1,ex)))
                  );
    end proc:

    removeImaginary := proc(ex)
        if ex :: imaginary
        or ex :: `*` and ormap(type,ex,imaginary)
        then
            return ex/I;
        else
            return ex;
        end if;
    end proc:

    ModuleLoad();

end module:

with(krylov):

Simplify(K1(I*x));
                                     K1(x)

convert(exp(2*x),'compose,trigh,tokrylov');
                     K1(2 x) + K3(2 x) + K2(2 x) + K4(2 x)

evalf(K1(Pi/2 + K3(3)),30);
                        303.220352664355942804059979113

This is just something I threw together in a few minutes; you'd want to rewrite it to do something useful

Thanks for the code! I think I get the idea

Marten — Sat, 02 Apr 2011 17:18:30 Z

Thanks for the code! I think I get the idea now.

>>What do you plan to do with them?

I just need to make Maple understand that (K1)' = K4, (K2)' = K1, etc. Just like it operates with sinh and cosh.

extending diffs

Joe Riel — Sat, 02 Apr 2011 20:09:37 Z

You could add the following to the module (assigned in the ModuleLoad procedure). Or, if that is all you need, just use these by themselves:

        `diff/K1`  := ex -> K4(ex)*diff(ex,_rest);
        `diff/K2`  := ex -> K1(ex)*diff(ex,_rest);
        `diff/K3`  := ex -> K2(ex)*diff(ex,_rest);
        `diff/K4`  := ex -> K3(ex)*diff(ex,_rest);

If you put them in the module, you'll also need to declare them as global, similar to the evalf extensions.

Thanks! It works fine, but now I have another

Marten — Mon, 04 Apr 2011 20:01:38 Z

Thanks! It works fine, but now I have another difficulties. How can I make automatic substitution of zero argument, i.e. K1(0) = 1, K2(0)=K3(0)=K4(0)=0? Also, fsolve doesn't seem to work with these functions. And another problem:

when I try to solve it with respect to a*l Maple can't seem to recognize that a^3*l^3 = (a*l)^3, what should I do?

Thanks in advance.

extending krylov

Joe Riel — Mon, 04 Apr 2011 21:22:03 Z

@Marten To get fsolve to handle the krylov functions, the procedures need to be assigned. That has to be done in a way such that if the argument is non-numeric, the call is returned unevaluated. The basic idea is

    K1 := proc(ex)
        if ex = 0 then
            return 1;
        elif ex :: float then
            return Evalf('procname'(ex));
        else
            return 'procname'(ex);
        end if;
    end proc;

The updated module follows. I made K1,...,K4 exports rather than globals.

krylov := module()
option package;

export K1,K2,K3,K4,To, From, Simplify, Evalf;

local ModuleLoad, removeImaginary;

    ModuleLoad := proc()
    global `convert/tokrylov`, `convert/fromkrylov`, `simplify/krylov`
        , `evalf/K1`, `evalf/K2`, `evalf/K3`, `evalf/K4`
        , `diff/K1`, `diff/K2`, `diff/K3`, `diff/K4`
        ;

        `convert/tokrylov`   := To;
        `convert/fromkrylov` := From;
        `simplify/krylov`    := Simplify;
        `evalf/K1`           := x -> Evalf(K1(x));
        `evalf/K2`           := x -> Evalf(K2(x));
        `evalf/K3`           := x -> Evalf(K3(x));
        `evalf/K4`           := x -> Evalf(K3(x));
        `diff/K1`            := ex -> K4(ex)*diff(ex,_rest);
        `diff/K2`            := ex -> K1(ex)*diff(ex,_rest);
        `diff/K3`            := ex -> K2(ex)*diff(ex,_rest);
        `diff/K4`            := ex -> K3(ex)*diff(ex,_rest);

    end proc;

    To := proc(ex)
        eval(ex, [cos = K1-K3,
                  sin = K2-K4,
                  cosh = K1+K3,
                  sinh = K2+K4
                 ]);
    end proc:

    From := proc(ex)
        eval(ex, [K1 = 1/2*cosh + 1/2*cos,
                  K2 = 1/2*sinh + 1/2*sin,
                  K3 = 1/2*cosh - 1/2*cos,
                  K4 = 1/2*sinh - 1/2*sin
                 ]);
    end proc:

    Evalf := proc(ex)
        evalf(From(ex), _rest);
    end proc;

    Simplify := proc(ex)
        # a very basic simplification, Kx(I*z) --> Kx(z)
        evalindets(ex
                   , 'specfunc(anything,{K1,K2,K3,K4})'
                   , fx -> op(0,fx)(removeImaginary(op(1,ex)))
                  );
    end proc:

    removeImaginary := proc(ex)
        if ex :: imaginary
        or ex :: `*` and ormap(type,ex,imaginary)
        then
            return ex/I;
        else
            return ex;
        end if;
    end proc;

    K1 := proc(ex)
        if ex = 0 then
            return 1;
        elif ex :: float then
            return Evalf('procname'(ex));
        else
            return 'procname'(ex);
        end if;
    end proc;

    K2 := proc(ex)
        if ex = 0 then
            return 0;
        elif ex :: float then
            return Evalf('procname'(ex));
        else
            return 'procname'(ex);
        end if;
    end proc;

    K3 := proc(ex)
        if ex = 0 then
            return 0;
        elif ex :: float then
            return Evalf('procname'(ex));
        else
            return 'procname'(ex);
        end if;
    end proc;

    K4 := proc(ex)
        if ex = 0 then
            return 0;
        elif ex :: float then
            return Evalf('procname'(ex));
        else
            return 'procname'(ex);
        end if;
    end proc;

    ModuleLoad();

end module:

You can now do

with(krylov):
fsolve(K1(x)+K2(x) = 0.5);
                                 -0.5023876680

Probably some of the code in the Simplify routine should be moved into the assignments to K1, etc.