Saturday, December 3, 2016

Digest for comp.lang.c++@googlegroups.com - 20 updates in 10 topics

bleachbot <bleachbot@httrack.com>: Dec 03 10:20PM +0100

bleachbot <bleachbot@httrack.com>: Dec 03 10:39PM +0100

bleachbot <bleachbot@httrack.com>: Dec 03 11:09PM +0100

bleachbot <bleachbot@httrack.com>: Dec 03 11:52PM +0100

bleachbot <bleachbot@httrack.com>: Dec 03 11:53PM +0100

Ramine <ramine@1.1>: Dec 03 05:09PM -0500

Hello...
 
Yet about my projects...
 
Hope you have read my previous post about my projects..
 
I will add this:
 
You have to know that i have used a Top-Down methodology to design
my projects.. the Top-Down methodology begins with the overall goals
of the program- what we wich to achieve instead of how -, and after that
it gets on more details and how to implement them.
 
And i have taken care with my objects and modules of the following
characteristics:
 
- Logical coherence
 
- Independence:
 
It is like making more pure functions of functional programming to avoid
side-effects and to easy the maintenance and testing steps.
 
- Object oriented design and coding
 
- and also structure design and coding with sequence , iteration and
conditionals.
 
And about the testing phase read the following:
 
Alexandre Machado wrote:
>- You don't have both, unit and performance tests
>Have you ever considered this? I'm sure that it would make
>make it easier for other Delphi devs to start using it, no?
 
You have to know that i have also used the following method of testing
called black box testing:
 
https://en.wikipedia.org/wiki/Black-box_testing
 
This is why i have written this:
 
I have thoroughly tested and stabilized more my parallel archiver for
many years, and now i think that it is more stable and efficient, so i
think that you can be more confident with it.
 
This also true for all my other projects, i have followed the black box
testing also with them...
 
For race conditions , i think for an experienced programmer in parallel
programming like me, this is not a so difficult task to avoid race
conditions.
 
For sequential consistency i have also written this:
 
I have implemented my inventions with FreePascal and Delphi compilers
that don't reorder loads and stores even with compiler optimization, and
this is less error prone than C++ that follows a relaxed memory model
when compiled with optimization, so i have finally compiled my
algorithms implementations with FreePascal into Dynamic Link Libraries
that are used by C++ in a form of my C++ Object Synchronization Library.
 
So this is much easier to make a correct sequential consistency with
Delphi and Freepascal because it is less error prone.
 
Other than that you have to know that i am an experienced programmer in
parallel programming also, so i think that my projects are more stable
and fast.
 
You can download all my projects from:
 
https://sites.google.com/site/aminer68/
 
 
Thank you,
Amine Moulay Ramdane..
Real Troll <real.troll@trolls.com>: Dec 03 06:30PM -0400

On 03/12/2016 22:09, Ramine wrote:
 
> Thank you,
> Amine Moulay Ramdane..
 
Do you also write tutorials for Delphi or C#?
Ramine <ramine@1.1>: Dec 03 05:58PM -0500

Hello,
 
Real Troll wrote on comp.lang.c++
>Do you also write tutorials for Delphi or C#?
 
We have to be smart my dear programmer, this is
why i have easy the job for you by porting many
of my inventions to C++ in a form of
C++ synchronization objects library, please read about
it here, and the source code that i have compiled with
Freepascal is available there:
 
 
https://sites.google.com/site/aminer68/c-synchronization-objects-library
 
Also i have ported to C++ my Scalable Parallel C++ Conjugate Gradient
Linear System Solver Library:
 
https://sites.google.com/site/aminer68/scalable-parallel-c-conjugate-gradient-linear-system-solver-library
 
Also i have easy the job for you by compiling my Universal Scalability
Law for Delphi and FreePascal programs to windows 32bit and 64bit
executables, they are really fantastic and powerful, they are GUI and
command line, please read about them and download them from here:
 
https://sites.google.com/site/aminer68/universal-scalability-law-for-delphi-and-freepascal
 
 
Thank you,
Amine Moulay Ramdane.
Ramine <ramine@1.1>: Dec 03 05:58PM -0500

Hello,
 
Real Troll wrote on comp.lang.c++
>Do you also write tutorials for Delphi or C#?
 
We have to be smart my dear programmer, this is
why i have easy the job for you by porting many
of my inventions to C++ in a form of
C++ synchronization objects library, please read about
it here, and the source code that i have compiled with
Freepascal is available there:
 
 
https://sites.google.com/site/aminer68/c-synchronization-objects-library
 
Also i have ported to C++ my Scalable Parallel C++ Conjugate Gradient
Linear System Solver Library:
 
https://sites.google.com/site/aminer68/scalable-parallel-c-conjugate-gradient-linear-system-solver-library
 
Also i have easy the job for you by compiling my Universal Scalability
Law for Delphi and FreePascal programs to windows 32bit and 64bit
executables, they are really fantastic and powerful, they are GUI and
command line, please read about them and download them from here:
 
https://sites.google.com/site/aminer68/universal-scalability-law-for-delphi-and-freepascal
 
 
Thank you,
Amine Moulay Ramdane.
woodbrian77@gmail.com: Dec 03 10:54AM -0800

On Saturday, November 19, 2016 at 6:05:34 PM UTC-6, Alf P. Steinbach wrote:
 
> > Do you can a C++ link? or a GCC?
 
> Check out the SO C++ book list if you don't have a textbook.
 
> You can just google that term.
 
I suggest using an alternative to Google like
https://duckduckgo.com
. They don't keep track of your searches.
 
 
> I would suggest that you get yourself also a copy of a draft of the C++
> standard, even though the standard is written mainly for compiler
> vendors and therefore is generally not very accessible to learners.
 
This "Standard slam" video shows how lame the standard can be:
 
https://www.youtube.com/watch?v=ZLNq-4IiNTY&list=PLRyNF2Y6sca06lulacjysyu8RIwfKgYoY&index=15
 
 
Brian
Ebenezer Enterprises - In G-d we trust.
http://webEbenezer.net
David Brown <david.brown@hesbynett.no>: Dec 03 10:48PM +0100


> I suggest using an alternative to Google like
> https://duckduckgo.com
> . They don't keep track of your searches.
 
Or you can google the term - because Google is a better search engine
than duckduckgo or any other general purpose web search. It gives you
better results partly because they throw more resources at it, and
partly because they track your searches so that their engine can learn
from both you and other people.
 
Duckduckgo is a marvellous choice if you want to search for pictures of
naked mud-wrestlers without anyone following your trail, or if you are
hiding from the CIA. But for most information, google is the sensible
choice for the non-fanatic.
 
>> vendors and therefore is generally not very accessible to learners.
 
> This "Standard slam" video shows how lame the standard can be:
 
> https://www.youtube.com/watch?v=ZLNq-4IiNTY&list=PLRyNF2Y6sca06lulacjysyu8RIwfKgYoY&index=15
 
You do know that Google owns YouTube, and tracks which videos you watch?
If you are not careful, it will compile enough information about you
to recommend other C++ videos to you rather than Katty Perry tracks and
funny cat videos.
Ramine <ramine@1.1>: Dec 03 04:40PM -0500

Hello......
 
I correct my english, please read again....
 
Alexandre Machado wrote:
>- You don't have both, unit and performance tests
>Have you ever considered this? I'm sure that it would make
>make it easier for other Delphi devs to start using it, no?
 
You have to know that i have also used the following method of testing
called black box testing:
 
https://en.wikipedia.org/wiki/Black-box_testing
 
This is why i have written this:
 
I have thoroughly tested and stabilized more my parallel archiver for
many years, and now i think that it is more stable and efficient, so i
think that you can be more confident with it.
 
This also true for all my other projects, i have followed the black box
testing also with them...
 
For race conditions , i think for an experienced programmer in parallel
programming like me, this is not a so difficult task to avoid race
conditions.
 
For sequential consistency i have also written this:
 
I have implemented my inventions with FreePascal and Delphi compilers
that don't reorder loads and stores even with compiler optimization, and
this is less error prone than C++ that follows a relaxed memory model
when compiled with optimization, so i have finally compiled my
algorithms implementations with FreePascal into Dynamic Link Libraries
that are used by C++ in a form of my C++ Object Synchronization Library.
 
So this is much easier to make a correct sequential consistency with
Delphi and Freepascal because it is less error prone.
 
Other than that you have to know that i am an experienced programmer in
parallel programming also, so i think that my projects are more stable
and fast.
 
You can download all my projects from:
 
https://sites.google.com/site/aminer68/
 
 
Thank you,
Amine Moulay Ramdane..
Ramine <ramine@1.1>: Dec 03 04:21PM -0500

Hello....
 
Alexandre Machado wrote:
>- You don't have both, unit and performance tests
>Have you ever considered this? I'm sure that it would make
>make it easier for other Delphi devs to start >using it, no?
 
 
You have to know that i have also used the following method
of testing called black box testing:
 
https://en.wikipedia.org/wiki/Black-box_testing
 
 
This why i have wrote this:
 
I have thoroughly tested and stabilized more my parallel archiver for
many years, and now i think that it is more stable and efficient, so i
think that you can be more confident with it.
 
This also true for all my other projects, i have followed the black box
testing also with them...
 
For race conditions , i think for an experienced programmer in parallel
programming like me, this is not
a so difficult task to avoid race conditions.
 
For sequential consistency i have also wrote this:
 
I have implemented my inventions with FreePascal and Delphi compilers
that don't reorder loads and stores even with compiler optimization, and
this is less error prone than C++ that follows a
relaxed memory model when compiled with optimization, so i have finally
compiled my algorithms implementations with FreePascal into Dynamic Link
Libraries that are used by C++ in a form of my C++ Object
Synchronization Library.
 
So this is much easier to make a correct sequential consistency with
Delphi and Freepascal because it is less error prone.
 
Other than that you have to know that i am an experienced programmer in
parallel programming also, so i think that my projects are more stable
and fast.
 
 
You can download all my projects from:
 
https://sites.google.com/site/aminer68/
 
 
Thank you,
Amine Moulay Ramdane..
"Öö Tiib" <ootiib@hot.ee>: Dec 03 01:46AM -0800

On Friday, 2 December 2016 23:47:15 UTC+2, xerofoify wrote:
 
> I am wondering how to write quicksort by swapping the Nodes themselves
> not the data. So was wondering how to do that and make the above
> quicksort work.
 
That does not make sense logically.
A node of linked list contains data and pointers (IOW addresses) of
next and/or previous node.
So we can sort linked list by swapping data or we can sort it
by rearranging the pointers.
However if we swap both pointers and data of two nodes in list then
we just break integrity of the list instead of sorting it.
Ben Bacarisse <ben.usenet@bsb.me.uk>: Dec 03 11:07AM

xerofoify <xerofoify@gmail.com> writes:
 
There seems to be more code than I'd expect and I don't have time to go
though it but here are two remarks that jump out at me...
 
<snip>
> a = b;
> b = t;
> }
 
This function does nothing. It alters only local objects so has no
effect on the lists you are trying to alter.
 
 
> quicksort *with Node* swap not data swap which is what I want. So can
> someone point me to an example that does it by swapping the nodes and
> not the data.
 
It's not a natural list algorithm, so examples will be rare. It takes
care not to make it very inefficient on linked lists, but you can
probably find some tips about that in the literature about function
programming. Can I ask why you are using it?
 
--
Ben.
ruben safir <ruben@mrbrklyn.com>: Dec 03 01:38PM -0500

On 12/02/2016 11:44 PM, xerofoify wrote:
> for (Node *j = l; j != h; j = j->next_) {
> 163 if (j->data_ <= x) {
> I am confused about why this two lines are segfaulting for me through.
 
the same reason why they always segfault is that your trying to assign
or look into a non-allocated space.
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Dec 03 09:52AM +0100

I just sat down and started coding a little Windows desktop program
again, some days ago.
 
I remember that the macro I used for dispatching API level window
messages to C++ member functions, in C++03, was supported by some
complicated templates and was so horrendous that I posted it on Facebook
as a shock-and-awe spaghetti code joke.
 
With modern C++ it's much cleaner. Like the C++03 version this macro
also just delegates the extraction of function arguments from the
message data, to a message-specific macro from the mostly now
undocumented <windowsx.h> header, e.g. the HANDLE_WM_PAINT macro for the
WM_PAINT message. But all that old complexity for matching the
<windowsx.h> macro's call to my member function with one fewer arguments
(namely, no window handle argument at the start) is now done by
`std::mem_fn`. :)
 
[code]
#define WINAPI_DISPATCH_TO_MEMFN( message_name, memfunc, m ) \
HANDLE_ ## message_name ( \
this, m.wparam, m.lparam, std::mem_fn( &memfunc ) \
)
 
namespace my {
using cppx::No_copy_or_move;
namespace basic_main_window = winapi::basic_main_window;
 
class Main_window
: public No_copy_or_move
, private winapi::Message_handler
{
private:
winapi::Subclassing subclassing_;
 
void on_wm_paint()
{
PAINTSTRUCT state;
HDC const dc = ::BeginPaint( api_handle(), &state );
::Ellipse( dc, 10, 10, 200, 80 );
::EndPaint( api_handle(), &state );
}
 
auto on( winapi::Message const& m ) noexcept
-> winapi::Lresult override
{
switch( m.message_id )
{
//case WM_PAINT: return HANDLE_WM_PAINT(
// this,
// m.wparam, m.lparam,
// std::mem_fn( &Main_window::on_wm_paint )
// );
 
case WM_PAINT: return WINAPI_DISPATCH_TO_MEMFN(
WM_PAINT, Main_window::on_wm_paint, m
);
}
return subclassing_.original_processing( m );
}
[/code]
 
Of course it would be more nice without a macro, at all, and without
having to qualify the member function name.
 
I don't see solutions?
 
 
Cheers!,
 
- Alf
"Öö Tiib" <ootiib@hot.ee>: Dec 03 04:13AM -0800

On Saturday, 3 December 2016 10:56:18 UTC+2, Alf P. Steinbach wrote:
 
> I don't see solutions?
 
I don't really see problems. Macro looks fine. The whole puzzle of
message binding is meta-programming problem and macros are often used
in meta-programming.
"Öö Tiib" <ootiib@hot.ee>: Dec 03 01:31AM -0800

On Saturday, 3 December 2016 04:17:57 UTC+2, Mr Flibble wrote:
> are actually referring to the C++ Standard Library containers rather
> than the mathematical concepts: you should have been more clear about
> what you meant by providing appropriate qualifications.
 
Thanks guys for interesting sub-thread about different ways how to
organize the bucket of values that compare equal in a tree. Slight
miscommunication is unfortunately inevitable since it is impossible
to be precise in human language without becoming unreadable.
Stuart Redmann <DerTopper@web.de>: Dec 03 10:26AM +0100

>> On 02/12/2016 19:48, Ramine wrote:
[snip]
 
> On 12/2/2016 1:54 PM, Mr Flibble wrote:
>> Maybe someone should e-mail abuse@eternal-september.org to try and get
>> this spambot turned off?
 
 
Christopher J. Pisz <cpisz@austin.rr.com> wrote:
> I elect Mr Fibble for the task.
 
+1
 
Stuart (to be scolded by Mr. Flibble)
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)