i have one variable which has value in an array and i want to make the power of all the value of array by another variable but getting value zero.any possible solution?

alpha = [0.01 0.01 0.01 0.01]
lambda = 195
for i = 1 : 4
K(i) = alpha(i).^lambda;
end

Answer 1

[madhan ravi]

sym(alpha).^lambda % no loops needed   

Gives:

ans =
 
1/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,... % same repeats likewise

[Stephen23]

sym(alpha)

Note sure if this gives the required precision:

https://www.mathworks.com/matlabcentral/answers/57444-faq-why-is-0-3-0-2-0-1-not-equal-to-zero

One solution might be to define 0.01 exactly as the symbolic value: sym('0.01'). See:

https://www.mathworks.com/help/symbolic/sym.html

[GHUFRAN AHMAD KHAN]

for i = 1:3

U{i} = (alpha(i).^r) * V{i};

end

and V has 1X3 cell and alpha is [0.01 0.01 0.01] and r =195;

when i am giving value of r = 160 so it works but when i increase value so gives zero.

[Walter Roberson]

Stephen: applying sym() to a floating point number without any second argument to sym defaults to r (rational ) conversion . The value is first examined to see if it is close to a simple rational multiple of pi and if it is then a symbolic fraction multiplied by symbolic pi is created .If not then the input floating point number is put through a combined square completion and continued fraction analysis to see if it is approximately a rational multiple of a square root of a rational; if so then a symbolic square root times a symbolic fraction is created . Otherwise it finds a rational fraction using a tolerance . In some cases it ends up using the same fraction implied by the binary encoding.

End result: sym(0.01) or numbers sufficiently close would be converted to the symbolic fraction 1/100 exactly .

If you use sym('0.01') then symbolic floating point would be used . This is not a decimal based system . The internal encoding is not documented but it turns out to involve chunks of 31 bits at a time . If you prod it with a stick really hard you can prove that accuracy does not increase linearly with number of digits and that a binary approximation of decimal is involved .

So.... sym(0.01) will indeed happen to be represented as the infinitely precise 1/100 but sym('0.01') will be represented by a binary approximation that willl never exactly equal 1/100 if you look at it hard enough.

Which is the opposite of what you stated...

The disadvantage of the system is that sym(0.01*(1-N*eps)) will also be converted to symbolic 1/100 for N up to about 99. It is making educated guesses about what you meant and if your value was calculated very precisely then you need to use the two argument form of sym to tell it to do a binary conversion .

[madhan ravi]

Thank you very much sir Walter .

[madhan ravi]

@GHUFRAN did you try my answer first??

[GHUFRAN AHMAD KHAN]

still non of the above is working.

[Walter Roberson]

alpha = sym([0.01 0.01 0.01 0.01])
lambda = 195
for i = 1 : 4
K(i) = alpha(i).^lambda;
end

>> K

K =

[ 1/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, 1/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, 1/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, 1/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]

Looks to me like it works.

>> vpa(K)

ans =

[ 1.0e-390, 1.0e-390, 1.0e-390, 1.0e-390]

[GHUFRAN AHMAD KHAN]

thanx @Walter Roberson for help.

[madhan ravi]

@GHUFRAN if it was what you were looking for make sure to accept the answer.

[GHUFRAN AHMAD KHAN]

thanx @madhan ravi for ur help.

[madhan ravi]

Anytime :)

[Stephen23]

@Walter Roberson: thank you for the detailed explanation. To be honest I am surprised by the documentation. You wrote (emphasis added) "If you use sym('0.01') then symbolic floating point would be used . This is not a decimal based system . The internal encoding is not documented ... "

If this is not documented, how are users supposed to know that sym('0.01') is worse than supplying an imprecise double value? You yourself might have had many opportunities to "prod it with a stick really hard", but this does not seem like a reliable way to convey such information to users, especially when the documentation contains examples like these:

inaccurateNum = sym(11111111111111111111)
accurateNum = sym('11111111111111111111')

and when it explains that "Statements like pi = sym('pi') and delta = sym('1/10') create symbolic numbers that avoid the floating-point approximations inherent in the values of pi and 1/10.", then any reasonable reader would also expect that to mean that sym('0.01') would also be exact. I am surprised that the documentation is so vague on this.

[Walter Roberson]

There is some additional material on the treatment of symbolic floating point at https://www.mathworks.com/help/symbolic/mupad_ref/digits.html

Answer 2

[Stephen23]

"any possible solution?"

Solution to what, exactly? You calculate this (the loop is not required):

>> alpha.^lambda
ans =
  0  0  0  0

and the output value of zero is expected. Lets see why

>> alpha                                               % alpha.^1
alpha =
  1.0000e-002  1.0000e-002  1.0000e-002  1.0000e-002
>> alpha.*alpha                                        % alpha.^2
ans =
  1.0000e-004  1.0000e-004  1.0000e-004  1.0000e-004
>> alpha.*alpha.*alpha                                 % alpha.^3
ans =
  1.0000e-006  1.0000e-006  1.0000e-006  1.0000e-006
>> alpha.*alpha.*alpha.*alpha                          % alpha.^4
ans =
  1.0000e-008  1.0000e-008  1.0000e-008  1.0000e-008
...etc

It is clear that with alpha.^195 you would have values beyond anything that can be represented using double floating point numbers:

>> 2*195
ans = 390
>> 1e-390
ans = 0
>> realmin % smallest DOUBLE value
ans = 2.2251e-308

If you really need to calculate this value then try a higher precision numeric class:

https://www.mathworks.com/matlabcentral/fileexchange/36534-hpf-a-big-decimal-class

or the symbolic toolbox:

https://www.mathworks.com/products/symbolic.html

or change your algorithm.

[GHUFRAN AHMAD KHAN]

for i = 1:3

U{i} = (alpha(i).^r) * V{i};

end

and V has 1X3 cell and alpha is [0.01 0.01 0.01] and r =195;

when i am giving value of r = 160 so it works but when i increase value so gives zero.

[Stephen23]

"when i am giving value of r = 160 so it works but when i increase value so gives zero."

Yes. and my answer shows you why.

Note that you will need to consider the floating point error for all of your calculations.

[GHUFRAN AHMAD KHAN]

can u tell that how i can do floating point error.

[Walter Roberson]

Work in log space.

A^B = exp(B * log(A)) so log(A^B) = B * log(A) .

196 * log(0.01) is easy to compute in floating point: it is about -902. The smallest number that double precision can represent has a log of about -744