270 Reputation

13 Badges

12 years, 59 days

MaplePrimes Activity

These are replies submitted by Andriy

@Carl Love 

One moment is still unclear.

returns false and it is strange. I expected the result to be true.

@Carl Love 

I'll make a timid assumption. Physics:-`.` and Physics:-`*` in Maple 18.01 are equivalent.
For example

evalb(Physics:-`*`(ap1, am1) = Physics:-`.`(ap1, am1))

returns 'true'.

I suppose that operation Physics:-`.` is available just for backward compatibility.

By the way, what two 'anything' means in type checking

type(z1, ('`.`')(anything, anything));


@Carl Love
Thanks a lot for several tips used in your answer. I didn't know about them. The only comment, if one needs just a parity then a command

group[parity](convert([seq(pos[y], y= L2)], disjcyc))

should be placed instead of your command within the procedure.

Number of your transpositions and number of transpositions of neighboring elements has the same parity. So, in my case it doesn't matter what particular transpositions to consider.

Thank you for answer and comments.

@Alejandro Jakubi 

now the problem is formulated as:

Setup(mathematicalnotation = true);
Setup(op = A);

type(A^5, Physics:-`^`(PhysicsType:-ExtendedQuantumOperator, posint));
type(A^5, PhysicsType:-ExtendedQuantumOperator^posint);

the result is


Unfortunately, I don't know how to construct a correct type for A^n where n is some particular positive integer.

If Physics package is loaded then `*` is overloaded. Hence, distinguish `*` (overloaded) and ':-`*`' (original).

z := a*b*c;
type(z, '`*`'(name));
type(z, ':-`*`'(name));

@Alejandro Jakubi 
What exactly editor do you use?

and exhaustingly

@Carl Love 

What is the difference between this function


and this one



A reference to the documentation would be ok.

@Preben Alsholm 
@Markiyan Hirnyk
Thank you.

@Preben Alsholm
What does it mean "k is just a name"?

@Carl Love 
May be.
f:= `+`:
looks really nice.

@Markiyan Hirnyk 

thank you!

@acer, @Preben Alsholm

Thank you for clarification! However, I don't understand the sens of such design of set. But it is a rhetorical question. So I accept it as is.

@Preben Alsholm 

However it is still actual. So, now it can be formulated as

A := {a, b, c};
b := a;
for i to numelems(A) do
   print(sprintf("A[%a]=%a", i, A[i]))
end do;


for i to numelems(A)+1 do
   print(sprintf("A[%a]=%a", i, A[i]))
end do

The result:
                        A := {a, b, c}
                             b := a
                             {a, c}

What is going on with the set A?

1 2 3 4 5 6 7 Last Page 2 of 10