Number(self): return the number of iterations required to step through the iterator, assuming it started at rank one.

Rank(self,L): return the rank of the current iteration. Optionally pass L, a list or one-dimensional rtable, and return its rank.

Unrank(self,rnk): return a one-dimensional Array corresponding to the iterator output with rank rnk.

alphametic := module()

export ModuleApply;
local SymbolToAlg;

    ModuleApply := proc(eq :: string
                        , base :: posint := 10
                        , { compile :: truefalse := true }
                        , $
                       )
    local chars
        , ex,i,n,vars,x,pred,iter
        , p
        ;
    uses ST=StringTools;

        # Parse the input string and convert an equation to an expression.
        ex := parse(eq);
        ex := ifelse(ex :: equation
                     , (lhs-rhs)(ex)
                     , ex
                    );

        # Extract the symbols (names).
        vars := indets(ex,symbol);

        # Convert each symbol in ex to an algebraic equivalent
        # in terms of the characters in the symbol.
        ex := subs([seq(x = SymbolToAlg(x,base), x=vars)],ex);

        # Assign vars the characters in ex
        vars := indets(ex,symbol);
        n := numelems(vars);

        if n > base then
            error "too many characters (%1) for base %2", n, base;
        end if;

        # Convert characters to indexed names of V
        ex := subs([seq(vars[i]='V'[i],i=1..n)],ex);
        ex := expand(ex);

        # Assign a predicate that returns true if the permutation
        # evaluates ex to 0 (evalb does not work in Compiler:-Compile).
        pred := subs('_ex'=ex, proc(V :: Array(datatype=integer[4]))
                               local ex := _ex;
                                   if ex=0 then
                                       return true;
                                   else
                                       return false;
                                   end if;
                               end proc
                    );

        # Optionally compile the predicate
        if compile then
            pred := Compiler:-Compile(pred);
        end if;

        # Construct an iterator to iterate over all permutations.
        iter := Iterator:-Permute(0..(base-1),n
                                  , _options['compile']
                                 );

        # Find solutions and format as equations.
        vars := map(convert,vars,string);
        chars := ST:-Explode(eq);

        seq(ifelse(pred(p)
                   , ST:-Join(subs([seq(vars[i]=convert(p[i],string), i = 1..n)]
                                   , chars)
                              ,"")
                   , NULL)
            , p=iter
           );

    end proc:

    # Convert a symbol into a multinomial
    # over the characters of the symbol.

    SymbolToAlg := proc(symb,base::posint:=10)
    local val,char;
        val := 0;
        for char in convert(symb,string) do
            val := base*val+cat(``,char);
        end do;
        val;
    end proc:

end module:

$\mathrm{alphametic}\left(''maple*sim\; =\; modelica\; +\; model''\right)$

$''16540*781\; =\; 12904836\; +\; 12904''$