No COVID or No dodgy investment scheme in this post!

I think this program is quite neat to solve a complex problem:

<=============================================================>
#include <stdio.h>
#include <math.h>

int main()
{ /*
This program is designed to solve:
sum = 2^0 * 2^1 + 2^2 * 2^3 + 2^4 * 2^5 + 2^6 * 2^7
The answer to this problem is: 8738
*/

double sum = 0.0;
double baseNumber = 2.0;

for (int i = 0; i < 8; i += 2)
{
sum += pow(baseNumber, i) * pow(baseNumber, i + 1);
}
printf("The sum is: %.0f", sum);
} <=============================================================>

yohan ston <yohanston5@gmail.com> writes:
>I think this program is quite neat to solve a complex problem:
....
>printf("The sum is: %.0f", sum);

You are writing to a text stream there.

A text stream is an ordered sequence of characters composed
into lines, each line consisting of zero or more characters
plus /a terminating new-line character/. Whether the last
line requires a terminating new-line character is /implementation-
defined/.

You are not writing a terminating new-line character to the
end of your last line. Therefore, your "neat" program might
violate a requirement on some implementations!

yohan ston <yohanston5@gmail.com> writes:
>sum = 2^0 * 2^1 + 2^2 * 2^3 + 2^4 * 2^5 + 2^6 * 2^7

One could also write an "evalprint" function that takes such
an expression with single-digit numbers, spaces, and the
three operators "+", "*", and "^", evaluates it, and then
prints the result. This would allow one to directly evaluate
the expression as given in the comment quoted above and
thereby minimize the risk of errors that might be introduce
when translating it into a C program manually.

#include <stdio.h>
#include <math.h>
#include <string.h>
double xpow( double const x, double const y ){ return pow( x, y ); }
double xmul( double const x, double const y ){ return x * y; }
double xadd( double const x, double const y ){ return x + y; }
typedef double( *operator )( double, double );
struct ex { char name; operator op; int left; }ex[] =
{ { 0, 0, 0 }, { '^', xpow, 0 },{ '*', xmul, 1 }, { '+', xadd, 1 }};
struct ex lookup( char const name )
{ for( size_t i = 0; i < sizeof ex/sizeof 0[ ex ]; ++i )
if( ex[ i ].name == name )return ex[ i ]; return ex[ 0 ]; }
char const * g = 0; char next( void ){ while( *g == ' ' )++g; }
char get( void ){ next(); return *g++; }
char peek( void ){ next(); return *g; }
char check( char const * const op )
{ return strchr( op, peek() ) ?get(): 0; }
double numeral( void ){ return get() - '0'; }
double parse( char const * const op, double( *next ) () )
{ double result =( *next )();
for( char sym; sym = check( op ); )result = lookup( sym ).op
( result, lookup( sym ).left?( next )(): parse( op, next ));
return result; }
double power( void ){ return parse( "^", numeral ); }
double product( void ){ return parse( "*", power ); }
double sum( void ){ return parse( "+", product ); }
double start( void ){ return sum(); }
void evalprint( char const * expression )
{ g = expression; printf( "%g\n", start() ); }
int main( void )
{ evalprint( "2^0 * 2^1 + 2^2 * 2^3 + 2^4 * 2^5 + 2^6 * 2^7" ); }

On 2/6/2022 4:39 AM, yohan ston wrote:
> No COVID or No dodgy investment scheme in this post!
>
> I think this program is quite neat to solve a complex problem:
>
> <=============================================================>
> #include <stdio.h>
> #include <math.h>
>
> int main()
> {
> /*
> This program is designed to solve:
> sum = 2^0 * 2^1 + 2^2 * 2^3 + 2^4 * 2^5 + 2^6 * 2^7
> The answer to this problem is: 8738
> */
>
> double sum = 0.0;
> double baseNumber = 2.0;
>
> for (int i = 0; i < 8; i += 2)
> {
> sum += pow(baseNumber, i) * pow(baseNumber, i + 1);
> }
> printf("The sum is: %.0f", sum);
> }
> <=============================================================>
>

#include <stdio.h>

int main()
{ /*
This program is designed to solve:
sum = 2^0 * 2^1 + 2^2 * 2^3 + 2^4 * 2^5 + 2^6 * 2^7
The answer to this problem is: 8738
*/

const int N = 8;
int sum = 0;

for (int i = 0, n = 1; N/2 > i; ++i, n *= 4)
{
sum = sum + 2*n*n;
}

printf("The sum is: %d\n", sum);
}

Apart of compactness, the advantage is full integer arithmetic, and no
pow() call.

On Sun, 06 Feb 2022 03:39:35 +0000, yohan ston wrote:

> No COVID or No dodgy investment scheme in this post!
>
> I think this program is quite neat to solve a complex problem:
>
> <=============================================================>
> #include <stdio.h>
> #include <math.h>
>
> int main()
> {
> /*
> This program is designed to solve:
> sum = 2^0 * 2^1 + 2^2 * 2^3 + 2^4 * 2^5 + 2^6 * 2^7 The answer to
> this problem is: 8738 */
>
> double sum = 0.0;
> double baseNumber = 2.0;
>
> for (int i = 0; i < 8; i += 2)
> {
> sum += pow(baseNumber, i) * pow(baseNumber, i + 1);
> }
> printf("The sum is: %.0f", sum);
> } <=============================================================>

Nope.
Mine's shorter

--------------------- code -------------------------
#include <stdio.h>

#define POW2(n,m) (1 << ((n)+(m)))

int main(void)
{
unsigned int result = POW2(0,1) + POW2(2,3) + POW2(4,5) + POW2(6,7);

printf("The sum is %u\n",result);

return 0;
}

--------------------- results -------------------------
14:08 $ ./b
The sum is 8738

--
Lew Pitcher
"In Skills, We Trust"

On Sun, 06 Feb 2022 03:39:35 +0000, yohan ston wrote:

> No COVID or No dodgy investment scheme in this post!
>
> I think this program is quite neat to solve a complex problem:
>
> <=============================================================>
> #include <stdio.h>
> #include <math.h>
>
> int main()
> {
> /*
> This program is designed to solve:
> sum = 2^0 * 2^1 + 2^2 * 2^3 + 2^4 * 2^5 + 2^6 * 2^7 The answer to
> this problem is: 8738 */
[snip]

This problem can be solved easily by recognizing the equivalences between
calculating a power-of-2 and of leftshifting 1 by a number of bits.

2^0 == 1 == 1 << 0
2^1 == 2 == 1 << 1
2^2 == 4 == 1 << 2
....
2^n == .... 1 << n

So, the individual terms of the equation can be expressed either as
powers of 2, /or/ as leftshifts of 1.

Now, we can express the equation as a sum of terms, each of which is a
power of 2 multiple of a power of 2.

So we can interpret the equation as

(2^0 * 2^1) + ... + (2^6 * 2^7)
or
((1<<0) * (1<<1)) + ... + ((1<<6) * (1<<7))

Now, each term is a power of 2 multiplied by a power of 2, so it's result
will also be a power of 2. If we look at the resulting values, we see
that, in general
((2^n) * (2^m))
can be expressed as
(1 << (n+m))
so the equivalent leftshift equation becomes
(1 << (0+1)) + (1 << (2+3)) + (1 << (4+5)) + (1 << (6+7))

and, we can compute /this/ without loops, exponentiation, or floatingpoint
arithmetic. In fact, we can compute this /statically/ within the compile
and simply output the resulting number.

HTH
--
Lew Pitcher
"In Skills, We Trust"

Am 06.02.2022 um 05:46 schrieb Stefan Ram:
> yohan ston <yohanston5@gmail.com> writes:
>> sum = 2^0 * 2^1 + 2^2 * 2^3 + 2^4 * 2^5 + 2^6 * 2^7
>
> One could also write an "evalprint" function that takes such
> an expression with single-digit numbers, spaces, and the
> three operators "+", "*", and "^", evaluates it, and then
> prints the result. This would allow one to directly evaluate
> the expression as given in the comment quoted above and
> thereby minimize the risk of errors that might be introduce
> when translating it into a C program manually.
>
> #include <stdio.h>
> #include <math.h>
> #include <string.h>
> double xpow( double const x, double const y ){ return pow( x, y ); }
> double xmul( double const x, double const y ){ return x * y; }
> double xadd( double const x, double const y ){ return x + y; }
> typedef double( *operator )( double, double );
> struct ex { char name; operator op; int left; }ex[] =
> { { 0, 0, 0 }, { '^', xpow, 0 },{ '*', xmul, 1 }, { '+', xadd, 1 }};
> struct ex lookup( char const name )
> { for( size_t i = 0; i < sizeof ex/sizeof 0[ ex ]; ++i )
> if( ex[ i ].name == name )return ex[ i ]; return ex[ 0 ]; }
> char const * g = 0; char next( void ){ while( *g == ' ' )++g; }
> char get( void ){ next(); return *g++; }
> char peek( void ){ next(); return *g; }
> char check( char const * const op )
> { return strchr( op, peek() ) ?get(): 0; }
> double numeral( void ){ return get() - '0'; }
> double parse( char const * const op, double( *next ) () )
> { double result =( *next )();
> for( char sym; sym = check( op ); )result = lookup( sym ).op
> ( result, lookup( sym ).left?( next )(): parse( op, next ));
> return result; }
> double power( void ){ return parse( "^", numeral ); }
> double product( void ){ return parse( "*", power ); }
> double sum( void ){ return parse( "+", product ); }
> double start( void ){ return sum(); }
> void evalprint( char const * expression )
> { g = expression; printf( "%g\n", start() ); }
> int main( void )
> { evalprint( "2^0 * 2^1 + 2^2 * 2^3 + 2^4 * 2^5 + 2^6 * 2^7" ); }
>

Syntax-castastrophy !