View mode: basic / threaded / horizontal-split · Log in · Help
March 29, 2005
process improvement for phobos
Walter,
There's a perception (rightly or wrongly) that submissions to phobos aren't 
processed in a timely and/or fair manner. What process should we use to 
communicate phobos changes to you that would speed things up? Should the 
changes be posted to the newsgroup for vetting, for example? Do you prefer 
entire files over diffs? What about changes that touch multiple files?

Personally I find emailing entire files (eg, std.stream) with the html doc 
updates works fine (the changes appear in the next release or if not I email 
with a reminder and it gets done). When the changes involve more than bug 
fixes I post to the newsgroup to get opinions, but usually not much comes up 
because the changes were prompted by some newsgroup discussion anyway.

-Ben
March 29, 2005
Re: process improvement for phobos
"Ben Hinkle" <ben.hinkle@gmail.com> wrote in message 
news:d2bk6d$1cm9$1@digitaldaemon.com...
> What process should we use to communicate phobos changes to you that would 
> speed things up?

I suppose another board might work, as the people here seem to be pretty 
responsible as to what gets posted to what boards.  Although an official 
wiki or something would be nice.

> Do you prefer entire files over diffs?

Yes, for the simple fact that I wouldn't know what to do with a diff file, 
unless it's in the IPS format, in which case I can handle that ;)  and if 
not, it'd probably require downloading some linux tool that needs to be run 
under Cygwin.  It's a lot easier to read an actual file than to have to 
apply the diff to the existing file, and it's not like text files are all 
that big.

There'd just need to be some commenting standard, so we'd be able to see 
(and document) any changes that were made.

> What about changes that touch multiple files?

Send 'em all.
March 29, 2005
Re: process improvement for phobos
"Ben Hinkle" <ben.hinkle@gmail.com> wrote in message
news:d2bk6d$1cm9$1@digitaldaemon.com...
> Walter,
> There's a perception (rightly or wrongly) that submissions to phobos
aren't
> processed in a timely and/or fair manner. What process should we use to
> communicate phobos changes to you that would speed things up? Should the
> changes be posted to the newsgroup for vetting, for example? Do you prefer
> entire files over diffs? What about changes that touch multiple files?
>
> Personally I find emailing entire files (eg, std.stream) with the html doc
> updates works fine (the changes appear in the next release or if not I
email
> with a reminder and it gets done). When the changes involve more than bug
> fixes I post to the newsgroup to get opinions, but usually not much comes
up
> because the changes were prompted by some newsgroup discussion anyway.

I know that's an issue, and I apologize for it. It comes about because I've
been giving the compiler itself nearly all my attention, and the library
went on the back burner.

I suggest emailing me the changes and posting them to the newsgroup. The
former means I won't miss them in the flood of messages here, and the latter
means that others can use them immediately and/or comment on them. Many
proposed additions I have no idea whether they are widely useful enough to
be in Phobos or not; posting them in the n.g. will help with that. I don't
want to fill Phobos up with functions of marginal utility, it needs to be
widely useful, core building blocks. Some help making that determination
would be much appreciated.

It's fine for me if diffs are mailed, for small changes. For wholesale
changes, the whole file would be better.
March 30, 2005
Re: process improvement for phobos
In article <d2cb5d$2757$1@digitaldaemon.com>, Walter says...
>
> ...
>
>I suggest emailing me the changes and posting them to the newsgroup. The
>former means I won't miss them in the flood of messages here, and the latter
>means that others can use them immediately and/or comment on them. Many
>proposed additions I have no idea whether they are widely useful enough to
>be in Phobos or not; posting them in the n.g. will help with that. I don't
>want to fill Phobos up with functions of marginal utility, it needs to be
>widely useful, core building blocks. Some help making that determination
>would be much appreciated.
>
> ...
>
Ok, here's the code that I sent to Walter that I thought would be very useful to
all, which I thought would complete std.conv to handle all the numerical data
types. Please, feel free to improve, and / or give comments.

The original message, "Extending std.conv with floating-point wrapper functions"
posted 09.Nov.04 can be found here:
(http://www.digitalmars.com/drn-bin/wwwnews?digitalmars.D/12382)

Also I've eMailed this code below to Walter on 03.Mar.05 for extending std.conv
for floating-point conversions. 

The main point being: that since there are toString() functions in std.string to
change floating points into char[]s, why couldn't I find any functions to change
them back to floating point? Therefore, it seemed a bit odd to me why std.conv
was so incomplete...since it did only whole number conversions; so I decided to
write some D code (that's below) to solve that issue.

---------------------------------

This is same code that I eMailed to Walter for inclusion into std.conv.

# /+
#  ' Module        : convext.d - "char[] to floating-point number" 
#  '               :              wrapper functions.
#  ' Version       : v0.1 beta WIP
#  '               :
#  ' Author(s)     : David L. 'SpottedTiger' Davis for the wrapper 
#  '               : functions / unittests, Pavel "EvilOne" Minayev for 
#  '               : writing the std.math2 code that does most of the work,
#  '               : and to Walter Bright for the great D compiler, as well 
#  '               : as the D's Phobos runtime library filled with very useful
#  '               : modules and functions...of which the std.math2 module 
#  '               : is a part of.
#  '               :
#  ' Created Date  : 07.Nov.04 Complied and Tested with dmd v0.105
#  ' Modified Date : 09.Nov.04 Added unitconvext code, recompiled 
#  '               :           and tested with dmd v0.106.
#  '               : 20.Jan.05 Recompiled and tested with dmd v0.111.
#  '               :
#  ' Requirements  : std.string for the ifind() and find() functions, and 
#  '               : std.math2 for both the atof() and feq() functions.
#  '               : 
#  ' Licence       : DigitalMars (waiting for this to be included into
#  '               : std.conv.d, at which time this code will be pulled 
#  '               : totally from this site.)
#  ' -------------------------------------------------------------------------
#  ' Note: The main purpose of this code is to extend std.conv, with some
#  '       useful "char[] to floating-point number" wrapper functions...
#  '       which mainly uses the "real std.math2.atof( in char[] )" function 
#  '       for all the conversions.
#  '
#  ' To complie for a unittest:
#  ' C:\dmd>bin\dmd convext.d -debug=convext -unittest
#  '
#  ' To compile a D program that use convext.d:
#  ' C:\dmd>bin\dmd MySource.d convext.d
#  '
#  ' Public functions:
#  ' ------------------------------
#  ' 01) bit toBit( in char )
#  ' 02) bit toBit( in char[] ) 
#  ' 03) float toFloat( in char[] )
#  ' 04) double toDouble( in char[] )
#  ' 05) real toReal( in char[] )
#  ' 06) ifloat toIfloat( in char[] )
#  ' 07) idouble toIdouble( in char[] ) 
#  ' 08) ireal toIreal( in char[] )
#  ' 09) cfloat toCfloat( in char[] )
#  ' 10) cdouble toCdouble( in char[] )
#  ' 11) creal toCreal( in char[] )
#  '
#  ' Private functions:
#  ' ------------------------------
#  ' 01) void getComplexStrings( in char[], out char[], out char[] )
#  '
#  +/
# module convext;
#
# private import std.math2;
# private import std.string;
#
# debug( convext ) private import std.stdio;
#
# bit toBit( in char c )
# {
#     if ( c == 't' || c == 'T' || c == '1' || 
#          c == 'Y' || c == 'y' ) 
#         c = '1';
#             
#     return ( c == '1' ? true : false ); 
# }
#
# unittest
# {
#     debug( convext ) writefln( "convext.toBit( in char ).unittest" );
#     bit b;
#
#     b = toBit( 'T' );
#     assert( b == true );
#     b = toBit( 'f' );
#     assert( b == false );
#     b = toBit( 'x' );
#     assert( b == false );
#     b = toBit( 'n' );
#     assert( b == false );
# }
#
# bit toBit( in char[] s )
# {
#     char[] s1 = std.string.toupper( s );
#    
#     if ( s1 == "TRUE" || s1 == "T" || s1 == "1" || 
#          s1 == "Y" || s1 == "YES" || s1 == "ON" ) 
#         s1 = "1";
#             
#     return ( s1 == "1" ? true : false ); 
# }
#
# unittest
# {
#     debug( convext ) writefln( "convext.toBit( in char[] ).unittest" );
#     bit b;
#
#     b = toBit( "True" );
#     assert( b == true );
#     b = toBit( "Xta" );
#     assert( b == false );
#     b = toBit( "" );
#     assert( b == false );
#     b = toBit( "yeS" );
#     assert( b == true );
# }
# 
# float toFloat( in char[] s )
# {
#     return cast(float)std.math2.atof( s );
# }
# 
# unittest
# {
#     debug( convext ) writefln( "convext.toFloat( in char[] ).unittest" );
#     float f;
# 
#     f = toFloat( "123" );
#     assert( std.math2.feq( f, 123 ) );
#     f = toFloat( "+123" );
#     assert( std.math2.feq( f, 123 ) );
#     f = toFloat( "-123" );
#     assert( std.math2.feq( f, -123 ) );
#     f = toFloat( "123e2" );
#     assert( std.math2.feq( f, 12300 ) );
# 
#     f = toFloat( "123e-2" );
#     assert( std.math2.feq( f, 1.23 ) );
#     f = toFloat( "123." );
#     assert( std.math2.feq( f, 123 ) );
#     f = toFloat( ".456" );
#     assert( std.math2.feq( f, .456 ) );
#     f = toFloat( "1.23456E+2" );
#     //from real to float 123.456 became 123.456001
#     assert( std.math2.feq( f, 123.456, 0.0001 ) );
# }
# 
# double toDouble( in char[] s )
# {
#     return cast(double)std.math2.atof( s );
# }
# 
# unittest
# {
#     debug( convext ) writefln( "convext.toDouble( in char[] ).unittest" );
#     double d;
# 
#     d = toDouble( "123" );
#     assert( std.math2.feq( d, 123 ) );
#     d = toDouble( "+123" );
#     assert( std.math2.feq( d, 123 ) );
#     d = toDouble( "-123" );
#     assert( std.math2.feq( d, -123 ) );
#     d = toDouble( "123e2" );
#     assert( std.math2.feq( d, 12300 ) );
# 
#     d = toDouble( "123e-2" );
#     assert( std.math2.feq( d, 1.23 ) );
#     d = toDouble( "123." );
#     assert( std.math2.feq( d, 123 ) );
#     d = toDouble( ".456" );
#     assert( std.math2.feq( d, .456 ) );
#     d = toDouble( "1.23456E+2" );
#     assert( std.math2.feq( d, 123.456 ) );
# }
# 
# real toReal( in char[] s )
# {
#     return std.math2.atof( s );
# }
# 
# unittest
# {
#     debug( convext ) writefln( "convext.toReal( in char[] ).unittest" );
#     real r;
# 
#     r = toReal( "123" );
#     assert( std.math2.feq( r, 123 ) );
#     r = toReal( "+123" );
#     assert( std.math2.feq( r, 123 ) );
#     r = toReal( "-123" );
#     assert( std.math2.feq( r, -123 ) );
#     r = toReal( "123e2" );
#     assert( std.math2.feq( r, 12300 ) );
# 
#     r = toReal( "123e-2" );
#     assert( std.math2.feq( r, 1.23 ) );
#     r = toReal( "123." );
#     assert( std.math2.feq( r, 123 ) );
#     r = toReal( ".456" );
#     assert( std.math2.feq( r, .456 ) );
#     r = toReal( "1.23456E+2" );
#     assert( std.math2.feq( r, 123.456 ) );
#     r = toReal( std.string.toString( real.max / 2 ) );
#     assert( std.string.toString( r ) == 
#             std.string.toString( real.max / 2 ) );
#     r = toReal( std.string.toString( real.max ) );
#     assert( std.string.toString( r ) == std.string.toString( real.max ) );
# }
# 
# ifloat toIfloat( in char[] s )
# {
#     return std.math2.atof( s[ 0 .. s.length - 1 ] ) * 1.0i;
# }
# 
# unittest
# {
#     debug( convext ) writefln( "convext.toIfloat( in char[] ).unittest" );
#     ifloat ift;
# 
#     ift = toIfloat( std.string.toString( ifloat.min ) );
#     assert( std.string.toString( ift ) == 
#             std.string.toString( ifloat.min ) );
# 
#     ift = toIfloat( std.string.toString( ifloat.max ) );
#     assert( std.string.toString( ift ) == 
#             std.string.toString( ifloat.max ) );
# 
#     ift = toIfloat( std.string.toString( "123.45" ) );
#     assert( std.math2.feq( ift, 123.45i ) );
# }
# 
# idouble toIdouble( in char[] s )
# {
#     return std.math2.atof( s[ 0 .. s.length - 1 ] ) * 1.0i;
# }
# 
# unittest
# {
#     debug( convext ) writefln( "convext.toIdouble( in char[] ).unittest" );
#     idouble id;
# 
#     id = toIdouble( std.string.toString( idouble.min ) );
#     assert( std.string.toString( id ) == 
#             std.string.toString( idouble.min ) );
# 
#     id = toIdouble( std.string.toString( idouble.max ) );
#     assert( std.string.toString( id ) == 
#             std.string.toString( idouble.max ) );
# 
#     id = toIdouble( std.string.toString( "123.45" ) );
#     assert( std.math2.feq( id, 123.45i ) );
# }
# 
# ireal toIreal( in char[] s )
# {
#     return std.math2.atof( s[ 0 .. s.length - 1 ] ) * 1.0i;
# }
# 
# unittest
# {
#     debug( convext ) writefln( "convext.toIreal( in char[] ).unittest" );
#     ireal ir;
# 
#     ir = toIreal( std.string.toString( ireal.min ) );
#     assert( std.string.toString( ir ) == std.string.toString( ireal.min ) );
# 
#     ir = toIreal( std.string.toString( ireal.max ) );
#     assert( std.string.toString( ir ) == std.string.toString( ireal.max ) );
# 
#     ir = toIreal( std.string.toString( "123.45" ) );
#     assert( std.math2.feq( ir, 123.45i ) );
# }
# 
# cfloat toCfloat( in char[] s )
# {
#     char[] s1;
#     char[] s2;
#     
#     getComplexStrings( s, s1, s2 );
#     
#     return cast(cfloat)std.math2.atof( s1 ) + 
#            cast(cfloat)std.math2.atof( s2 ) * 1.0i;
# }
# 
# unittest
# {
#     debug( convext ) writefln( "convext.toCfloat( in char[] ).unittest" );
#     cfloat cf;
# 
#     cf = toCfloat( std.string.toString( cfloat.min ) );
#     assert( std.string.toString( cf ) == std.string.toString( cfloat.min ) );
# 
#     cf = toCfloat( std.string.toString( cfloat.max ) );
#     assert( std.string.toString( cf ) == std.string.toString( cfloat.max ) );
# 
#     cf = toCfloat( std.string.toString( "1.2345e-5+0i" ) );
#     assert( std.math2.feq( cf, 1.2345e-5+0i ) );
# }
# 
# cdouble toCdouble( in char[] s )
# {
#     char[] s1;
#     char[] s2;
#     
#     getComplexStrings( s, s1, s2 );
#     
#     return cast(cdouble)std.math2.atof( s1 ) + 
#            cast(cdouble)std.math2.atof( s2 ) * 1.0i;
# }
# 
# unittest
# {
#     debug( convext ) writefln( "convext.toCdouble( in char[] ).unittest" );
#     cdouble cd;
# 
#     cd = toCdouble( std.string.toString( cdouble.min ) );
#     assert( std.string.toString( cd ) == 
#             std.string.toString( cdouble.min ) );
# 
#     cd = toCdouble( std.string.toString( cdouble.max ) );
#     assert( std.string.toString( cd ) == 
#             std.string.toString( cdouble.max ) );
# 
#     cd = toCdouble( std.string.toString( "1.2345e-5+0i" ) );
#     assert( std.math2.feq( cd, 1.2345e-5+0i ) );
# }
# 
# creal toCreal( in char[] s )
# {
#     char[] s1;
#     char[] s2;
#     
#     getComplexStrings( s, s1, s2 );
#     
#     return cast(creal)std.math2.atof( s1 ) + 
#            cast(creal)std.math2.atof( s2 ) * 1.0i;
# }
# 
# unittest
# {
#     debug( convext ) writefln( "convext.toCreal( in char[] ).unittest" );
#     creal cr;
# 
#     cr = toCreal( std.string.toString( creal.min ) );
#     assert( std.string.toString( cr ) == std.string.toString( creal.min ) );
# 
#     cr = toCreal( std.string.toString( creal.max ) );
#     assert( std.string.toString( cr ) == std.string.toString( creal.max ) );
# 
#     cr = toCreal( std.string.toString( "1.2345e-5+0i" ) );
#     assert( std.math2.feq( cr, 1.2345e-5+0i ) );
# 
#     cr = toCreal( std.string.toString( "0.0e-0+0i" ) );
#     assert( std.math2.feq( cr, 0.0e-0+0i ) );
# }
# 
# private void getComplexStrings( in char[] s, out char[] s1, out char[] s2 )
# {
#     int iPos1 = 0;
#     int iPos2 = 0;
#     
#     s1 = s.dup;
#     s2 = "";
#     
#     iPos1 = ifind( s1, "e+" );
#     if ( iPos1 != -1 )
#         iPos2 = find( s1[ iPos1 + 3 .. s1.length ], "+" );
# 
#     if ( iPos1 == -1 )
#     {
#         iPos1 = ifind( s1, "e-" );
#         if ( iPos1 != -1 )
#             iPos2 = find( s1[ iPos1 + 3 .. s1.length ], "+" );
#     }
# 
#     if ( iPos1 == -1 )
#         s1 = "0e+0";
#  
#     if ( iPos2 != -1 )   
#     { 
#         iPos2 += iPos1;
#         s2 = s1[ iPos2 + 4 .. s1.length - 1 ].dup;
#         s1 = s1[ 0 .. iPos2 + 3 ];
#     }
#              
#     //writefln( "getComplexStrings().s1=%s, s2=%s, iPos1=%d, iPos2=%d", 
#     //          s1, s2, iPos1, iPos2 );
# 
#     if ( iPos2 == -1 )
#     {
#         s1 = s1[ 0 .. s1.length - 1 ];
#         s2 = "0";             
#     }
#     
# } // end void getComplexStrings( in char[], out char[], out char[] )
# 
# debug( convext )
# {
# int main()
# {
#     writefln( "convext.unittests done!" );
#     return 0;
# 
# } // end int main()
# }

David L.

-------------------------------------------------------------------
"Dare to reach for the Stars...Dare to Dream, Build, and Achieve!"
Top | Discussion index | About this forum | D home