In C How To Print A Number In Full Form Without Exponential

Problem with calculus and exponential decay?

So the question is "Suppose the amount of oil pumped from one of the canyon wells in Whittier, California decrases at the continuous rate of 10% per year. When will the well's output fall to 60% of its present value?"

We're using the equation y=C*e^(kt)
Where C is the original amount, k is the rate of change, and t, in this problem, is measured in years.

I think that k would come out to -.1 since it's a decay function and losing 10%.

Here's how I tried to solve the equation.

y=.60C
.60C=C*e^(-.1*t)
ln(.60) = ln(e^(-.1*t))
ln(.60) = -.1*t
t=(ln(.60)/(-.1) = 5.10826

That seems like it would be right to me, and it's worked this way for the other equations I've done similar to this, but for some reason this one is incorrect. Does anyone know why?

How does an exponential amplifier work?

The current through the diode increases exponentially with voltage applied across the diode. Because there is negative feedback (a connection from Vout to the - terminal), the amplifier drives Vout to maintain the - terminal at the same voltage as the + terminal, i.e., maintains it at ground potential. The - and + terminals have negligible input current, so practically all of the current that passes through the diode also passes through resistor R. Resistor R develops a voltage drop proportional to the current, which is exponentially related to the voltage across the diode D. The voltage at Vout is negative for forward current through the diode, and is virtually equal to the drop across resistor R. The voltage across the diode D (to which the drop is exponentially related) is also equal Vin, since the - terminal is held at ground potential.

Note how a diode characteristic curve appears exponential near the origin:
http://www.tpub.com/neets/book7/0023.GIF

Here is an equation that models the diode characteristic:
http://en.wikipedia.org/wiki/Diode#Shock...

I would guess that an exponential amplifier is good for inverting the output of a logarithmic amplifier. The two type of amplifiers, plus a summer, can be used to perform analog multiplication (and division) of two or more voltage signals. Analog computers were used for this task using non-linear amplifier circuits, prior to the advent of digital computers. The following math principle was its basis:
C=AxB
logC=log(AB)=logA+logB
C=antilog(logA + logB)

Write a C program that takes a 5 digit number and calculates 2 power?

I deeply love you for posting a C question. Do you mean calculate the 2nd power? Here's how we'd do that:

#include
#include

int main(int argc,char**argv){
long int n=atol(argv[1]);
printf("%ld",n*n);
return 0;
}

Supply the number as the first arg on the command line.

And how does it work? The first arg is argv[1], and the atol function converts that string to a "long int" (which is just a 32-bit signed binary number), which is stored in the variable called 'n'. Then we print n*n to the screen. That's n squared.

Instead of n*n, we could say pow(n,2) if we also #include, but n*n is easier and faster in this case.

The rest of the program is just mandatory crap, the #includes make certain functions available. The "main" thing is the start of the program, and the "return 0;" is the end of the program. The zero is the error code returned.

How do you calculate exponents and roots in C programming without using math.h functions?

There are several ways to calculate powers. You have chosen a recursion method which works quite well. Unfortunately that method only takes integer exponents. For another quick way using integers is just a standard for loop such as:

double pow(double a; int n){
double ans = a;
for (int i=1;ians *= a;
return ans;
}

Root finding algorithms are more difficult, but can be done by a number of fast solvers toward a convergence value. That is normally what we do in numerical analysis. A Newton-Raphson method can be employed here and is described in detail on the wikipedia page: http://en.wikipedia.org/wiki/Newton's_me...

Simple root finding for a square root, cube root, quad root can be found by the following with quadratic convergence.


double NewtonRaphson(double a, int n){
//n is the root mechanism (2 = square root, 3 = cube root)
double x0 = 10.0; // random initial guess. Shouldn't be a big deal for this problem.
double x1;
double f = 0.0,fp = 100.0; // some random starting values
double cx = 10.0; // random value above tolerance
double tol = 1E-7;
do {
f = pow(x0,n) - a;
fp = (double)n * pow(x0,n-1);
cx = -f/fp; // x1 - x0 = -f(x0)/fp(x0)
x0 += cx;
cx = cx < 0.0 ? -cx : cx; // just an round-about abs()
} while (cx > tol);

return x0;
}

Here is a link to ideone where you can see source code and output.

http://ideone.com/xmP7J

EDIT:
Looking closer at your code, remember that C/C++ does not accept nested functions. All functions must be declared outside of each other. so your code structure would be something like

#include

double power(double a, double n);
double root(double a, double n);

int main(int argc, char *argv[]){
char op;
switch(op){
case '^':
...
case '!': // something for sqrt
...
case default:
printf("Unknown operator");
return -1;
}
return 0;
}

double power( double a, int n) {
...
return ans;
}

double root (double a, int n ) {
...
return ans;
}

Hopefully that gets you going a little bit easier.