Saturday, June 16, 2018

Digest for comp.lang.c++@googlegroups.com - 21 updates in 6 topics

James Kuyper <jameskuyper@alumni.caltech.edu>: Jun 15 07:54PM -0400

On 06/15/2018 05:30 PM, Ian Collins wrote:
> On 16/06/18 03:47, James Kuyper wrote:
...
> make up the code for a feature they have requested. Functions are
> tested with unit tests, features with acceptance tests. The latter are
> the customer's true requirements.
 
I suppose I am guilty of conflating them somewhat, but that's mainly
because I see no distinction between them that matters for the point I
was making. Whether you're testing a single function by calling it from
a test driver, or testing an entire system that might involve
cooperation between many different programs, and might involve real-time
processing of inputs coming from a device (including user-operated
devices as keyboards and mice), it's still a piece of software with
inputs, processing that is performed on those inputs, outputs, and
requirements that specify what the connection is supposed to be between
those inputs and those outputs.
 
I find it hard to imagine any piece of software for which a test
procedure that could execute in an acceptable amount of time could be
considered as imposing requirements semantically equivalent to the true
requirements. I find it easier to imagine such software if it has only a
small number of inputs, no more than 128 bits or so, and executes very
quickly, which is why I tend to think of small functions rather than
entire programs when I'm thinking about that possibility.
 
The key problem, as I see it, is that for such an equivalence to exist,
every case whose behavior would be defined by the English requirements
documentation, if such a document did exist, must be tested, and it's
only unusually small pieces of software for which it would be feasible
for a test to execute the piece of software with each and every one of
the possible inputs. I find it easier to imagine such software if it's
only a small subroutine, and not an entire application.
 
> snipped in my last response is in the business world (at last my parts
> of it), most requirements written at a high user experience level. They
> do not delve into the details of the code. Yes we could turn those into
 
It's not the details of the code that matter - it's the details of the
inputs to and outputs from the code. For all but the most trivial pieces
of software, the set of all inputs for which the requirements specify
what the outputs should be, is, in my experience, untestably large by
many orders of magnitude - and only a test that did execute the code for
every one of those possible inputs could justifiably be considered as
imposing the same requirements as should properly be specified in a
separate requirements document.
 
But that might be due in part to the kinds of software I've been
involved in writing. Most of my software has inputs that consist of
files megabytes in length, and a large fraction of those bytes have
values that play a role in determining what the required outputs should
be. A typical high-level requirement for the code I've been involved in,
it that is should calculate the estimated latitude and longitude and
altitude of the ground position visible in each pixel of an image of
satellite data, based upon what's known about the geometry of the
imaging instrument, and the time at which the data was collected. That
time, in turn, can be used to determine the orientation and position of
the satellite, and the orientation of the the Earth. The algorithm to be
used for calculating those outputs from those inputs is specified by the
requirements document. How the code is broken up into sub-routines to
achieve that goal is specified in other parts of the documentation, but
at the highest level the requirements only specify how the calculated
latitude, longitude and altitude should depend upon the input data.
How would you set up an acceptance test semantically equivalent to such
requirements? I'm not asking you give me something that requires you to
understand what the algorithm is, or what format the input data is in,
or what format the output data is required to be in. I just want to have
some understanding how it would be feasible to create such an acceptance
test.
Our acceptance tests sampled a large sub-set of the possible inputs,
that was still only an infinitesimal fraction of the set of all possible
inputs, and checked to see that this sub-set was handled correctly - but
passing those acceptance tests was NOT semantically equivalent to
requiring that all possible inputs be handled correctly.
legalize+jeeves@mail.xmission.com (Richard): Jun 16 12:36AM

[Please do not mail me a copy of your followup]
 
James Kuyper <jameskuyper@alumni.caltech.edu> spake the secret code
>should do, but only for those inputs; such code would not satisfy the
>English requirements, but would satisfy the requirement implicitly
>specified by such a test.
 
Interestingly enough, in TDD we do "fake it until you make it" where
an intermediate state of the code is exactly as you describe above.
It works for a small number of inputs and yet fails to meet the entire
spec. Not meeting the entire spec is how we know we're "not done
writing tests" because we haven't yet pushed the implementation to be
the minimal thing that satisfies the requirements.
--
"The Direct3D Graphics Pipeline" free book <http://tinyurl.com/d3d-pipeline>
The Terminals Wiki <http://terminals-wiki.org>
The Computer Graphics Museum <http://computergraphicsmuseum.org>
Legalize Adulthood! (my blog) <http://legalizeadulthood.wordpress.com>
legalize+jeeves@mail.xmission.com (Richard): Jun 16 12:39AM

[Please do not mail me a copy of your followup]
 
Ian Collins <ian-news@hotmail.com> spake the secret code
>write formal requirements but they do know what they want when they see
>it. This is why we encourage them to be involved with the acceptance
>tests.
 
FitNesse is a great tool for bridging this gap. Acceptance tests are
written in a tabular form within a free-form wiki. The free-form wiki
lets the stakeholder/customer/business analyst work in a form that
let's them link together all kinds of relevant information that is
useful to understand but not codified in the form of an acceptance
test directly. The tabular data is what drives the acceptance test
and this is a good bridge between people who "know the business" and
people who "know the implementation".
 
It serves as a good compromise between an executable acceptance test
specification and an English prose description of the requirements.
--
"The Direct3D Graphics Pipeline" free book <http://tinyurl.com/d3d-pipeline>
The Terminals Wiki <http://terminals-wiki.org>
The Computer Graphics Museum <http://computergraphicsmuseum.org>
Legalize Adulthood! (my blog) <http://legalizeadulthood.wordpress.com>
Ian Collins <ian-news@hotmail.com>: Jun 16 12:53PM +1200

On 16/06/18 12:36, Richard wrote:
> spec. Not meeting the entire spec is how we know we're "not done
> writing tests" because we haven't yet pushed the implementation to be
> the minimal thing that satisfies the requirements.
 
I have seen quite a few cases where the "fake" code goes into production
because the customer realises what it does is good enough to meet
current demand! This often happens when market demand changes and parts
of the requirement that were deemed essential are no longer wanted...
 
--
Ian
Vir Campestris <vir.campestris@invalid.invalid>: Jun 16 11:09PM +0100

On 14/06/2018 12:12, Paavo Helde wrote:
 
> Maybe I should have mentioned that I am a physicist by training. In
> physics, every (non-integer) number has an error margin. And the numbers
> 13.4 and 13.5 are equal if this error margin is at least 0.1.
 
Ex-biologist here. To me that measured value I'm looking at is one on a
population that's most likely on a normal distribution. So that error
margin merely covers _most_ of the indistinguishable values - not all of
them :(
 
But back to TDD. The hard problems to test for are timing issues. I have
no faith that any reasonable suite of tests will pick up complex races
or deadlocks. (Though TSAN helps)
 
Andy
Rosario19 <Ros@invalid.invalid>: Jun 16 10:55AM +0200

On Fri, 15 Jun 2018 12:50:00 +0100, Chris Vine wrote:
 
>Secondly and more importantly, you have already been given the answer,
>namely to use placement new, which is specifically intended to deal
>with this case,
 
i not use new() operator only malloc() or malloc like functions
the new() operator i have is not the new() library provide
 
>form is this:
 
> void* p = malloc(sizeof(T));
> T* tp = new (p) T;
 
this line what would make?
call new, pass it the pointer to void* p
call the constructor in the address of p of the compatible T
constructor?
 
> ... do something with tp ...
> tp->~T();
> free(tp);
 
this above seems to me better free(p)
 
>There is even a similar example on the link I gave you. Your approach
>does not work and demonstrates sheer pig-headed stupidity in the face
>of your attention having been drawn to the correct tool for the job.
 
in the start of the class, that use the generic T type
i could write something as
"this is ok only if type T allow the existence of one element that has
in it all memory 0"
this is equvalent to the "call one constructor on the type when the
memory exist"
 
Rosario19 <Ros@invalid.invalid>: Jun 16 11:02AM +0200

On Thu, 14 Jun 2018 22:59:14 -0700 (PDT), 嘱 Tiib wrote:
>question "how to do it?" here at the first place?
>Every regular in this group knows how to do it but it is
>pointless to answer that to you.
 
this is not true, 80% of C++ is out of my know, so i need some answer
to question as "how call one constructor in the memory return from
malloc()?"
Chris Vine <chris@cvine--nospam--.freeserve.co.uk>: Jun 16 12:37PM +0100

On Sat, 16 Jun 2018 10:55:02 +0200
> On Fri, 15 Jun 2018 12:50:00 +0100, Chris Vine wrote:
> i not use new() operator only malloc() or malloc like functions
> the new() operator i have is not the new() library provide
 
No, you have got something completely wrong, although it is difficult to
decipher your remarks to find out what. operator new() either
allocates and returns raw memory, or (when it takes a second void*
argument in connection with a placement new expression) does nothing.
In many implementations, an allocating operator new() comprises no more
than a call to malloc(). You seem to be confusing operator new() with
the new expression, which is something different. operator new()
returns raw uninitialized memory. The new expression constructs an
object in that memory.
 
> call new, pass it the pointer to void* p
> call the constructor in the address of p of the compatible T
> constructor?
 
It constructs an object of type T, via T's constructor, in the memory
pointed to by p, rather than calling allocating operator new() to
obtain a dynamic memory allocation and constructing it there.
 
> > tp->~T();
> > free(tp);
 
> this above seems to me better free(p)
 
No, it makes no difference. The value of p and tp is the same, but one
is of type void* and the other of type T*. Since free() takes its
argument by void* it makes zero difference.
 
> in it all memory 0"
> this is equvalent to the "call one constructor on the type when the
> memory exist"
 
This is unintelligible. Possibly you asked the wrong question and you
are not interested in placement new. Possibly you want to install your
own global operator new() for your program which always hands off to
malloc() (although that is probably what your default global operator
new() already does anyway), or possibly you want to override global
operator new for a particular class. The latter is pretty common for
types that you want to implement their own memory pools. You still use
the new expression to construct objects of such classes, but when the
new expression obtains new memory it calls the class specific version of
operator new() instead of global operator new().
 
Try getting a decent book on C++.
"Öö Tiib" <ootiib@hot.ee>: Jun 16 06:36AM -0700

On Saturday, 16 June 2018 11:57:39 UTC+3, Rosario19 wrote:
 
> this is not true, 80% of C++ is out of my know, so i need some answer
> to question as "how call one constructor in the memory return from
> malloc()?"
 
I see that Chris Vine already explained to you that with placement new.
 
// allocate memory
void* p = malloc(sizeof(T));
 
// check that allocation worked
if (p == nullptr)
return outOfMemory;
 
// construct T into that memory
T* tp = new (p) T(arguments, ofTs, constructor);
 
// ... use tp, now it points at T object ...

// destroy T
tp->~T();
 
// construct other T into same memory
T* tp = new (p) T(otherArguments, ofTs, constructor);

// ... use tp, now it points at different T object in same memory ...
 
// destroy T
tp->~T();
 
// free the memory
free(tp);
Rosario19 <Ros@invalid.invalid>: Jun 16 06:50PM +0200

On Sat, 16 Jun 2018 12:37:23 +0100, Chris Vine wrote:
 
>Try getting a decent book on C++.
 
all yours example, in this compiler: not compile
"T *pt=new(p)T;" or "T *pt=new(p)T();" or "T*pt=new(p)T(parameters);"
... possible this compiler it is a little old
or i not link any standard sys new or delete...
 
but the situation it is easier and clearer thand one all you propose
 
The step for resolve the situation are
 
1) write in the source code of the dll one use
void* _export operator new(size_t sz){return yourMalloc(sz);}
void _export operator delete(void*p){yourfree(p);}
 
2) link that .dll and not some other has different new or delete
 
write in your favorite code using memory your allocator return and
free it. example
 
template <class> i32 prova(T& a)
{T *p;
 
// this below i had seen
//1) call yourMalloc() function with argument sizeof(T)
//2) call the default void constructor inthat memory for type T to*p
//3) assing to p the address return yourMalloc
p=new T;
 
*p=a;
ooo<<"this is a:"<<*p<<"\n";
 
// this below i had seen
// 1) apply to *p the destructor for T
// 2) call yourfree(p) for free the memory
delete p;
}
 
so no memory leak and memory it seems correct used
-------------------------------
 
in the dll had seen too
void * _export operator new[](size_t sz){return yourMalloc(sz);}
void _export operator delete[](void* pv){yourFree(pv);}
 
but i have some doubit they are wrong....
are these right or wrong?
Rosario19 <Ros@invalid.invalid>: Jun 16 06:53PM +0200

On Sat, 16 Jun 2018 06:36:06 -0700 (PDT), 嘱 Tiib wrote:
 
here this
 
> // construct T into that memory
> T* tp = new (p) T(arguments, ofTs, constructor);
 
not compile
the same "p=malloc(sizeof(T));T* tp=new(p)T();"
not compile
Rosario19 <Ros@invalid.invalid>: Jun 16 06:58PM +0200

On Sat, 16 Jun 2018 18:53:01 +0200, Rosario19 wrote:
 
 
>not compile
>the same "p=malloc(sizeof(T));T* tp=new(p)T();"
>not compile
 
"T *p=(T*)malloc(sizeof(T));T* tp=new(p)T();"
 
not compile
"Öö Tiib" <ootiib@hot.ee>: Jun 16 10:06AM -0700

On Saturday, 16 June 2018 19:54:29 UTC+3, Rosario19 wrote:
> >not compile
 
> "T *p=(T*)malloc(sizeof(T));T* tp=new(p)T();"
 
> not compile
 
But it has been in C++ for ages wher you got so old compiler?
Oh, sorry, forgot to tell that you need to #include <new>
Also it seems that the cppreference does not state that anywhere.
No wonder that you were confused.
 
Otherwise it shoud work in C++2003 at least. Demo here:
http://coliru.stacked-crooked.com/a/0a4465d8d6d90e0b
Compiles and runs.
Rosario19 <Ros@invalid.invalid>: Jun 16 07:18PM +0200

On Sat, 16 Jun 2018 10:06:51 -0700 (PDT), 嘱 Tiib <ootiib@hot.ee>
wrote:
 
 
>> not compile
 
>But it has been in C++ for ages wher you got so old compiler?
>Oh, sorry, forgot to tell that you need to #include <new>
 
yes i not include any "<new>" header
it would be for this
 
Chris Vine <chris@cvine--nospam--.freeserve.co.uk>: Jun 16 07:39PM +0100

On Sat, 16 Jun 2018 18:50:25 +0200
> "T *pt=new(p)T;" or "T *pt=new(p)T();" or "T*pt=new(p)T(parameters);"
> ... possible this compiler it is a little old
> or i not link any standard sys new or delete...
 
As I said:
 
"Try getting a decent book on C++."
 
If you had done so, it would have told you to include the <new> header
in order to use placement new. (Also include this header if you want
to override global or class operator new()/delete() - see below.)
 
 
> 1) write in the source code of the dll one use
> void* _export operator new(size_t sz){return yourMalloc(sz);}
> void _export operator delete(void*p){yourfree(p);}
[More of the same elided]
 
As I said:
 
"Possibly you asked the wrong question and you are not interested in
placement new. Possibly you want to install your own global operator
new() for your program which always hands off to malloc() (although
that is probably what your default global operator new() already does
anyway), or possibly you want to override global operator new for a
particular class."
 
Instead of being a total dick and ignoring all the advice you have been
given by at least two people who know what they are talking about,
consider this:
 
1. Not everyone else is an idiot. Possibly you have it wrong and you
are the idiot.
 
2. When someone gives you advice, think about it and read up about it,
because you are probably wrong and they are probably right.
 
3. If you are a beginner, adopt a better attitude and you will learn
more.
Rosario19 <Ros@invalid.invalid>: Jun 16 09:14PM +0200

On Sat, 16 Jun 2018 18:50:25 +0200, Rosario19 wrote:
 
>void _export operator delete[](void* pv){yourFree(pv);}
 
>but i have some doubit they are wrong....
>are these right or wrong?
 
no doubit
 
i debugged these above, at last delete[], possible i'm not smart
enought but for me they are really miracolous
how correctly free all and call recursivly the destructors of
subtypes...
no leak nothing wrong...thank you C++, thank you to all...
 
new and delete are not simple operators they seems something more, as
one infrastructure one sys (they are not the code one see)
 
i had seen in the debugger somehting as
 
thisType *p;
 
p=new thisType[10];
....
delete p;
Rosario19 <Ros@invalid.invalid>: Jun 16 09:18PM +0200

On Sat, 16 Jun 2018 21:14:48 +0200, Rosario19 <Ros@invalid.invalid>
wrote:
 
 
>p=new thisType[10];
>....
>delete p;
 
thisType *p;
 
p=new thisType[10];
....
delete [] p;
Sky89 <Sky89@sky68.com>: Jun 16 04:55PM -0400

Hello..
 
 
My C++ synchronization objects library for Windows and Linux was updated..
 
There was a bug in some of scalable Rwlock variants and i have corrected
this bug and now i think that all my scalable RWLocks are working correctly.
 
 
You can download my new updated C++ synchronization objects library from:
 
https://sites.google.com/site/scalable68/c-synchronization-objects-library
 
 
Thank you,
Amine Moulay Ramdane.
Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk>: Jun 16 01:59PM +0100

Screenshot "Black (Emoji Reprise)": https://i.imgur.com/Rq6s22t.png
 
TV ad: https://www.youtube.com/watch?v=IXvKOwQ4mvY
 
/Flibble
 
--
"Suppose it's all true, and you walk up to the pearly gates, and are
confronted by God," Bryne asked on his show The Meaning of Life. "What
will Stephen Fry say to him, her, or it?"
"I'd say, bone cancer in children? What's that about?" Fry replied.
"How dare you? How dare you create a world to which there is such misery
that is not our fault. It's not right, it's utterly, utterly evil."
"Why should I respect a capricious, mean-minded, stupid God who creates a
world that is so full of injustice and pain. That's what I would say."
Rosario19 <Ros@invalid.invalid>: Jun 16 10:05AM +0200

On Fri, 15 Jun 2018 13:01:14 +0200, Rosario19 wrote:
 
> res->a=res->b=res->c=res->dD=0;
> r2=-f.b;
 
> v=fr(&r, r2, f.c, f.dD);
 
one error was here because the above should be something as
"v=fr(&r, r2, f.c, sqrti64(f.dD))"
 
> res->dD=r2-fc4*res->c;
> R 0;
>}
 
i64 gcdi64(i64 u, i64 v)
{i64 t;
if(u==0||v==0) R 0;
W(u>0){if(u<v){t=u; u=v; v=t;}
u = u%v;
}
R v;
}
 
void print(i64& n)
{char p[128];
*p=0;
_i64toa(n, p, 10);
P("%s", p);
}
 
#include <math.h>
 
#define sqrti64(x) ((i64) sqrtl((long double) x) )
#define absi64(x) (x>=0?x:-x)
 
 
class form{
i64 a;
i64 b;
i64 c;
 
i32 IsReduced(void){i64 t, dD; dD=b*b-4*a*c;t=dD-2*absi64(a);R
absi64(t)<b && b<dD;}
 
form(){a=b=c=0;}
form(i64& fa,i64& fb,i64& fc){a=fa; b=fb; c=fc;}
void assign(i64& fa,i64& fb,i64& fc){a=fa; b=fb; c=fc;}
 
friend ostream& operator<<(ostream& o,const form& x)
{i64 dD=x.b*x.b-4*x.a*x.c;
o<<"("<<(long double)x.a<<", "<<(long double)x.b<<", "<<(long
double)x.c<<", "<<(long double)dD<<")";
R o;
}
 
friend i32 fr(i64* res, i64& xb, i64& xa, i64& xdD)
{i64 a2,absa,r,k;
 
if(res==0) R -1;
*res=0;
if(xa ==0) R -1;
r=xb; a2=2*xa; absa=absi64(xa);
if(absa==xdD)R -1;
if(absa>xdD)
{if(xa>0) k=((-xa-xb)/a2)+1;
else k=(( xa-xb)/a2)-1;
r=xb+k*a2;
if(r> absa)
r-=absi64(a2);
//if(r> absa)R -1;
//if(r<=-absa)R -1;
}
else
{if(xa>0) k=((xdD-a2-xb)/a2)+1;
else k=((xdD+a2-xb)/a2)-1;
r=xb+k*a2;
if(r> xdD) r-=absi64(a2);
//if(r> xdD) R -1;
//if(r<=xdD-2*absa) R -1;
}
*res=r;
R 0;
}
 
 
friend i32 rhoF(form* res, form& f, i64& delta, i64& sqrtdelta)
{i64 r, r2, fc4;
i32 v;
 
if(res== 0)R -1;
if(f.c== 0)R -1;
res->a=res->b=res->c=0;
r2=-f.b;
v=fr(&r, r2, f.c, sqrtdelta);
if(v ==-1)R -1;
res->a =f.c; res->b=r;
r2=r*r; fc4=4*f.c;
res->c =(r2-delta)/fc4;
R 0;
}
 
 
// suppone che i numeri a esso passato nn siano primi
// Ritorna -1 per errore, altrimenti ritorna il numero dei loop
effettuati e in res,
// un fattore di n
friend i32 Squfof(i64* res, i64& n)
{i64 xdD,xb,dd,t,x, m, bound, l, gx, b1, ve[512];
i32 r;
u32 i,v;
form f,g, h;
Mset<i64> buf;
 
if(n<=1||res==0)R -1;
*res=0; dd=sqrti64(n);
if(dd*dd==n){*res=dd; R 0;}
 
if(n%4==1){xdD= n; m=1; xb=(dd-1)/2; xb=2*xb+1;}
else {xdD=4*n; m=2;dd=sqrti64(xdD); xb= dd /2; xb=2*xb ;}
f.a=1; f.b=xb; f.c=(xb*xb-xdD)/4; l=sqrti64(dd); bound=4*l;
t=absi64( f.c );
if(t==0)R -1;
gx=gcdi64(t,m); gx=t/gx;
buf.assegnaMem(ve, 512);
 
if(gx<=l)
{r=buf.add1(gx);
if(r==-1)R -1;
}
F(i=2;i<bound;++i)
{
r=rhoF(&g,f, xdD, dd);if(r==-1)R -1;
f=g;
t=absi64(f.c);
if(i%2==0)
{ooo<<"i="<<i<<" f="<<f<<"\n";
x=sqrti64(t);
if(x<=1) R -1;
if(x*x==t && !buf.is(x))
break;
}
gx=gcdi64(t,m); gx=t/gx;
if(gx<=l){r=buf.add1(gx);
if(r==-1)
R -1;
}
}
if(i>=bound)
R -1;
v=i;
if(f.c>0)
{h.a= x*f.a; h.b=-f.b; h.c=x;}
else {h.a=-x*f.a; h.b=-f.b; h.c=x;}
// h.dD=h.b*h.b-4*h.a*h.c= f.b^2-4*x^2*f.a
r=rhoF(&g, h, xdD, dd);if(r==-1) R -1;
i=0;
la: b1=g.b; r=rhoF(&h, g, xdD, dd);
if(i%2==0)ooo<<"i="<<i<<" g="<<g<<"\n";
if(r==-1) R -1;
g=h;++i;if(b1!=g.b)G la;
ooo<<"i="<<i<<" g="<<g<<"\n";
t=absi64(g.a); v+=i;
if(t<=1) R -1;
if(t%2==0) t=t/2;
x=n/t; m=x>t?t:x;
if(x*t!=n)R -1;
*res=m; R v;
}
 
 
};
 
#undef sqrti64
#undef absi64
 
i32 main96()
{i64 m1, m2, mm;
u32 i,j;
i32 r;
u8 *pc;
Mset<snum> bu;
 
mm=633003781;
r=Squfof(&m1, mm);
if(r==-1) ooo<<"Error\n";
else ooo<<"loop Conter="<<r<<" res=";print(m1);P("\n");
R 0;
}
 
i=2 f=(-7125.000000, 17591.000000, 11353.000000, 633003781.000000)
i=4 f=(-13363.000000, 21611.000000, 3105.000000, 633003781.000000)
i=6 f=(-12495.000000, 3131.000000, 12469.000000, 633003781.000000)
i=8 f=(-3157.000000, 22391.000000, 10425.000000, 633003781.000000)
i=10 f=(-6239.000000, 18125.000000, 12201.000000, 633003781.000000)
i=12 f=(-12163.000000, 18049.000000, 6315.000000, 633003781.000000)
i=14 f=(-9475.000000, 18059.000000, 8097.000000, 633003781.000000)
i=16 f=(-13205.000000, 12081.000000, 9221.000000, 633003781.000000)
i=18 f=(-483.000000, 24463.000000, 17891.000000, 633003781.000000)
i=20 f=(-7055.000000, 16901.000000, 12309.000000, 633003781.000000)
i=22 f=(-11647.000000, 15577.000000, 8379.000000, 633003781.000000)
i=24 f=(-9285.000000, 19201.000000, 7117.000000, 633003781.000000)
i=26 f=(-2835.000000, 21859.000000, 13685.000000, 633003781.000000)
i=28 f=(-11009.000000, 16507.000000, 8187.000000, 633003781.000000)
i=30 f=(-11275.000000, 6309.000000, 13153.000000, 633003781.000000)
i=32 f=(-4431.000000, 24313.000000, 2363.000000, 633003781.000000)
i=34 f=(-11261.000000, 22097.000000, 3213.000000, 633003781.000000)
i=36 f=(-8503.000000, 11127.000000, 14971.000000, 633003781.000000)
i=38 f=(-4659.000000, 18457.000000, 15687.000000, 633003781.000000)
i=40 f=(-7429.000000, 16799.000000, 11805.000000, 633003781.000000)
i=42 f=(-12423.000000, 18035.000000, 6193.000000, 633003781.000000)
i=44 f=(-10791.000000, 24041.000000, 1275.000000, 633003781.000000)
i=46 f=(-7295.000000, 19361.000000, 8847.000000, 633003781.000000)
i=48 f=(-10629.000000, 5231.000000, 14245.000000, 633003781.000000)
i=50 f=(-1615.000000, 21961.000000, 23331.000000, 633003781.000000)
i=52 f=(-245.000000, 24789.000000, 18887.000000, 633003781.000000)
i=54 f=(-6147.000000, 23897.000000, 2519.000000, 633003781.000000)
i=56 f=(-17181.000000, 12917.000000, 6783.000000, 633003781.000000)
i=58 f=(-15883.000000, 17551.000000, 5115.000000, 633003781.000000)
i=60 f=(-4247.000000, 19101.000000, 15785.000000, 633003781.000000)
i=62 f=(-7563.000000, 17783.000000, 10471.000000, 633003781.000000)
i=64 f=(-1245.000000, 23209.000000, 18945.000000, 633003781.000000)
i=66 f=(-5509.000000, 18373.000000, 13407.000000, 633003781.000000)
i=68 f=(-10475.000000, 12509.000000, 11373.000000, 633003781.000000)
i=70 f=(-11611.000000, 12985.000000, 9999.000000, 633003781.000000)
i=72 f=(-14597.000000, 22181.000000, 2415.000000, 633003781.000000)
i=74 f=(-18611.000000, 15933.000000, 5093.000000, 633003781.000000)
i=76 f=(-855.000000, 24779.000000, 5557.000000, 633003781.000000)
i=78 f=(-11059.000000, 24559.000000, 675.000000, 633003781.000000)
i=80 f=(-20383.000000, 16725.000000, 4333.000000, 633003781.000000)
i=82 f=(-17955.000000, 17971.000000, 4317.000000, 633003781.000000)
i=84 f=(-20767.000000, 24969.000000, 115.000000, 633003781.000000)
i=86 f=(-23805.000000, 22669.000000, 1251.000000, 633003781.000000)
i=88 f=(-2905.000000, 21611.000000, 14283.000000, 633003781.000000)
i=90 f=(-10233.000000, 13511.000000, 11005.000000, 633003781.000000)
i=92 f=(-12739.000000, 16979.000000, 6765.000000, 633003781.000000)
i=94 f=(-2791.000000, 21045.000000, 17029.000000, 633003781.000000)
i=96 f=(-6807.000000, 14215.000000, 15827.000000, 633003781.000000)
i=98 f=(-5195.000000, 24121.000000, 2463.000000, 633003781.000000)
i=100 f=(-105.000000, 25051.000000, 12979.000000, 633003781.000000)
i=102 f=(-12177.000000, 23447.000000, 1709.000000, 633003781.000000)
i=104 f=(-5471.000000, 19363.000000, 11793.000000, 633003781.000000)
i=106 f=(-13041.000000, 21859.000000, 2975.000000, 633003781.000000)
i=108 f=(-20279.000000, 20767.000000, 2487.000000, 633003781.000000)
i=110 f=(-5735.000000, 21881.000000, 6723.000000, 633003781.000000)
i=112 f=(-10871.000000, 25027.000000, 153.000000, 633003781.000000)
i=114 f=(-211.000000, 25061.000000, 5865.000000, 633003781.000000)
i=116 f=(-6615.000000, 17831.000000, 11907.000000, 633003781.000000)
i=118 f=(-12539.000000, 19095.000000, 5351.000000, 633003781.000000)
i=120 f=(-3303.000000, 22529.000000, 9495.000000, 633003781.000000)
i=122 f=(-10381.000000, 5311.000000, 14565.000000, 633003781.000000)
i=124 f=(-1127.000000, 23515.000000, 17757.000000, 633003781.000000)
i=126 f=(-6885.000000, 15541.000000, 14215.000000, 633003781.000000)
i=128 f=(-8211.000000, 19955.000000, 7149.000000, 633003781.000000)
i=130 f=(-3735.000000, 21881.000000, 10323.000000, 633003781.000000)
i=132 f=(-6205.000000, 17819.000000, 12711.000000, 633003781.000000)
i=134 f=(-11313.000000, 15023.000000, 9001.000000, 633003781.000000)
i=136 f=(-5355.000000, 21859.000000, 7245.000000, 633003781.000000)
i=138 f=(-5727.000000, 24205.000000, 2057.000000, 633003781.000000)
i=140 f=(-23085.000000, 25121.000000, 21.000000, 633003781.000000)
i=142 f=(-3933.000000, 22043.000000, 9351.000000, 633003781.000000)
i=144 f=(-10615.000000, 5869.000000, 14097.000000, 633003781.000000)
i=146 f=(-2387.000000, 20641.000000, 21675.000000, 633003781.000000)
i=148 f=(-1353.000000, 23293.000000, 16711.000000, 633003781.000000)
i=150 f=(-7935.000000, 21611.000000, 5229.000000, 633003781.000000)
i=152 f=(-10715.000000, 22639.000000, 2811.000000, 633003781.000000)
i=154 f=(-11923.000000, 1509.000000, 13225.000000, 633003781.000000)
i=156 f=(-207.000000, 25153.000000, 399.000000, 633003781.000000)
i=158 f=(-1215.000000, 23479.000000, 16819.000000, 633003781.000000)
i=160 f=(-7875.000000, 21341.000000, 5637.000000, 633003781.000000)
i=162 f=(-3047.000000, 24997.000000, 669.000000, 633003781.000000)
i=164 f=(-12075.000000, 23791.000000, 1387.000000, 633003781.000000)
i=166 f=(-15679.000000, 7991.000000, 9075.000000, 633003781.000000)
i=168 f=(-14595.000000, 19031.000000, 4639.000000, 633003781.000000)
i=170 f=(-16495.000000, 14909.000000, 6225.000000, 633003781.000000)
i=172 f=(-5197.000000, 19135.000000, 12837.000000, 633003781.000000)
i=174 f=(-11495.000000, 16451.000000, 7881.000000, 633003781.000000)
i=176 f=(-12873.000000, 10673.000000, 10081.000000, 633003781.000000)
i=178 f=(-13465.000000, 17441.000000, 6105.000000, 633003781.000000)
i=180 f=(-10843.000000, 24183.000000, 1111.000000, 633003781.000000)
i=182 f=(-5145.000000, 16459.000000, 17595.000000, 633003781.000000)
i=184 f=(-4009.000000, 21359.000000, 11025.000000, 633003781.000000)
i=186 f=(-2627.000000, 24545.000000, 2907.000000, 633003781.000000)
i=188 f=(-12939.000000, 3911.000000, 11935.000000, 633003781.000000)
i=190 f=(-4915.000000, 19361.000000, 13131.000000, 633003781.000000)
i=192 f=(-11145.000000, 15389.000000, 8887.000000, 633003781.000000)
i=194 f=(-6375.000000, 18091.000000, 11989.000000, 633003781.000000)
i=196 f=(-12477.000000, 19067.000000, 5399.000000, 633003781.000000)
i=198 f=(-2361.000000, 23095.000000, 10549.000000, 633003781.000000)
i=200 f=(-6355.000000, 19029.000000, 10657.000000, 633003781.000000)
i=202 f=(-1785.000000, 22811.000000, 15779.000000, 633003781.000000)
i=204 f=(-8817.000000, 8887.000000, 15709.000000, 633003781.000000)
i=206 f=(-1995.000000, 21359.000000, 22155.000000, 633003781.000000)
i=208 f=(-1199.000000, 25009.000000, 1575.000000, 633003781.000000)
i=210 f=(-21959.000000, 21677.000000, 1857.000000, 633003781.000000)
i=212 f=(-14675.000000, 6459.000000, 10073.000000, 633003781.000000)
i=214 f=(-11061.000000, 8435.000000, 12699.000000, 633003781.000000)
i=216 f=(-6797.000000, 23819.000000, 2415.000000, 633003781.000000)
i=218 f=(-3487.000000, 24337.000000, 2919.000000, 633003781.000000)
i=220 f=(-11367.000000, 23101.000000, 2185.000000, 633003781.000000)
i=222 f=(-1093.000000, 23123.000000, 22491.000000, 633003781.000000)
i=224 f=(-1725.000000, 22991.000000, 15133.000000, 633003781.000000)
i=226 f=(-9583.000000, 11891.000000, 12825.000000, 633003781.000000)
i=228 f=(-8649.000000, 20837.000000, 5747.000000, 633003781.000000)
i=230 f=(-45.000000, 25081.000000, 21929.000000, 633003781.000000)
i=232 f=(-3197.000000, 19587.000000, 19499.000000, 633003781.000000)
i=234 f=(-3285.000000, 20009.000000, 17705.000000, 633003781.000000)
i=236 f=(-5589.000000, 18133.000000, 13607.000000, 633003781.000000)
i=238 f=(-10115.000000, 11149.000000, 12573.000000, 633003781.000000)
i=240 f=(-8691.000000, 20767.000000, 5803.000000, 633003781.000000)
i=242 f=(-18765.000000, 23479.000000, 1089.000000, 633003781.000000)
i=0 g=(33.000000, 25129.000000, -11645.000000, 633003781.000000)
i=2 g=(3711.000000, 23081.000000, -6755.000000, 633003781.000000)
i=4 g=(12159.000000, 6869.000000, -12045.000000, 633003781.000000)
i=6 g=(6983.000000, 24677.000000, -861.000000, 633003781.000000)
i=8 g=(22915.000000, 22291.000000, -1485.000000, 633003781.000000)
i=10 g=(23155.000000, 24051.000000, -589.000000, 633003781.000000)
i=12 g=(19137.000000, 14027.000000, -5699.000000, 633003781.000000)
i=14 g=(9927.000000, 19541.000000, -6325.000000, 633003781.000000)
i=16 g=(11625.000000, 4841.000000, -13109.000000, 633003781.000000)
i=18 g=(3357.000000, 18907.000000, -20519.000000, 633003781.000000)
i=20 g=(1745.000000, 23239.000000, -13317.000000, 633003781.000000)
i=22 g=(11667.000000, 19939.000000, -5045.000000, 633003781.000000)
i=24 g=(10703.000000, 22391.000000, -3075.000000, 633003781.000000)
i=26 g=(16765.000000, 12871.000000, -6969.000000, 633003781.000000)
i=28 g=(14631.000000, 14257.000000, -7343.000000, 633003781.000000)
i=30 g=(13773.000000, 12431.000000, -8685.000000, 633003781.000000)
i=32 g=(3895.000000, 24431.000000, -2319.000000, 633003781.000000)
i=34 g=(16305.000000, 10661.000000, -7963.000000, 633003781.000000)
i=36 g=(5775.000000, 25009.000000, -327.000000, 633003781.000000)
i=38 g=(17707.000000, 10719.000000, -7315.000000, 633003781.000000)
i=40 g=(9885.000000, 20999.000000, -4857.000000, 633003781.000000)
i=42 g=(16169.000000, 14481.000000, -6545.000000, 633003781.000000)
i=44 g=(707.000000, 24701.000000, -8085.000000, 633003781.000000)
i=46 g=(2045.000000, 21181.000000, -22539.000000, 633003781.000000)
i=48 g=(687.000000, 24193.000000, -17359.000000, 633003781.000000)
i=50 g=(7521.000000, 19559.000000, -8325.000000, 633003781.000000)
i=52 g=(13339.000000, 12937.000000, -8727.000000, 633003781.000000)
i=54 g=(4305.000000, 21079.000000, -10957.000000, 633003781.000000)
i=56 g=(2635.000000, 24681.000000, -2263.000000, 633003781.000000)
i=58 g=(303.000000, 24587.000000, -23501.000000, 633003781.000000)
i=60 g=(1389.000000, 24811.000000, -3135.000000, 633003781.000000)
i=62 g=(21451.000000, 23823.000000, -763.000000, 633003781.000000)
i=64 g=(2475.000000, 24491.000000, -3353.000000, 633003781.000000)
i=66 g=(9615.000000, 16009.000000, -9795.000000, 633003781.000000)
i=68 g=(2453.000000, 20983.000000, -19641.000000, 633003781.000000)
i=70 g=(3795.000000, 19651.000000, -16261.000000, 633003781.000000)
i=72 g=(7185.000000, 15869.000000, -13263.000000, 633003781.000000)
i=74 g=(9791.000000, 8925.000000, -14129.000000, 633003781.000000)
i=76 g=(4587.000000, 17363.000000, -18069.000000, 633003781.000000)
i=78 g=(3881.000000, 20035.000000, -14919.000000, 633003781.000000)
i=80 g=(8997.000000, 8191.000000, -15725.000000, 633003781.000000)
i=82 g=(1463.000000, 23557.000000, -13341.000000, 633003781.000000)
i=84 g=(11679.000000, 20233.000000, -4787.000000, 633003781.000000)
i=86 g=(16019.000000, 13975.000000, -6831.000000, 633003781.000000)
i=88 g=(16645.000000, 19941.000000, -3535.000000, 633003781.000000)
i=90 g=(9031.000000, 13645.000000, -12369.000000, 633003781.000000)
i=92 g=(10307.000000, 9521.000000, -13155.000000, 633003781.000000)
i=94 g=(6673.000000, 23249.000000, -3465.000000, 633003781.000000)
i=96 g=(21427.000000, 24523.000000, -369.000000, 633003781.000000)
i=98 g=(8027.000000,
ram@zedat.fu-berlin.de (Stefan Ram): Jun 15 11:28PM

>defining the same requirement that would be conveyed by a corresponding
>English document that specifies what the code being tested is required
>to do with every possible value of it's inputs.
 
"Abstraction" is hard for some programmers or programming aspirants.
They prefer "programming by example".
 
For one - exaggerated - example: Some people cannot create a
sentence like, "I want the program to remove every other letter.".
 
Instead they come into a newsgroup and say: I want the input
 
abcdef
 
be mapped to
 
ace
 
. They expect other people to create the abstract wording
"remove every other letter" for them from the example.
However, there are infinitely many different specifications
that would all yield "ace" for the above input. Therefore,
examples can never replace a specification by rules.
 
Writing tests must appeal to those people more than writing
abstract specifications! But programming ultimately is about
writing general rules.
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.
Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)