minato posted:

After some reading and discussion, the issue I had with ServiceFinder being effectively global may not be such an issue after all. The nuance that was eluding me was that it's not important to make every single class in the app testable via dependency injections, just the classes that do meaningful work.

GrumpyDoctor posted:

Newbie Prolog question:

code:

add(A, B, Res) :- Res = A + B.

code:

12 ?- add(1, 1.5, Ans).
Ans = 1+1.5.

How do I get that to be Ans = 2.5?

Tots posted:

I'm reading through my Java book and what of the end of chapter questions has the example code in which I'm supposed to find the error:

code:

        for (k = .1 ; k != 1.0 ; k += .1)
            System.out.println( k );

Easy enough, k was never initialized... but wait! There appears to be a much more insidious error which I doubt the author intended.

The output of

code:

        for (double k = .1 ; k != 1.0 ; k += .1)
            System.out.println( k );

is:

0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999
1.0999999999999999
1.2
1.3
1.4000000000000001
1.5000000000000002
1.6000000000000003
1.7000000000000004
1.8000000000000005
1.9000000000000006
2.0000000000000004...ad infinitum.

Can anyone tell me what the hell is going on here?

Tots posted:

I'm trying to figure out a way to return the expected output based on that same for structure, but I can't think of anything that will work and not be absolutely retarded. Any ideas?

Look Around You posted:

Like I said in the last post, never test for strict (in)equality on floating point values (float or double). Check out my code that I posted for a bit better way of handling it in general. If you know you're approaching it from one side you can use a single less than (or greater than) rather than bracketing it though.

Nippashish posted:

How about abs(a-d) < 0.005, which tests from both sides? This version of "equality" also has the annoying property of being non-transitive.

Tots posted:

I get what you're all saying, but I was trying to achieve the exact output of .1 - .9 using that same basic for structure somehow... just because. Anyway, I thought about it for like half an hour then gave up after getting frustrated... My brain is sort of goop at this point from lack of sleep.


Anyway, turns out that the solution in the book doesn't actually say anything about initializing the value, rather it says "Don't use floating point numbers for a counter you fucktard."

code:

    public static void main(String[] args) {

        for (int k = 1 ;  k != 10 ; k += 1)
        {
            System.out.println( (double) k / 10);         
        }
        
    }

Look Around You posted:

This would work.

If you're using Java 1.5+ you probably have a printf function:
Try System.out.printf("%.1f\n", k); (where k in here is a double).

Tots posted:

That prints
1.0
2.0
etc...

I really need to sit down one night and learn all the printf poo poo. It looks ridiculously useful.

This works

code:

        for (int k = 1 ;  k != 10 ; k += 1)
        {
            System.out.println("0." + k);       
        }

quote:

I just had another thought. You said that when testing for equality in floating point #'s you should use a range. Is there a downside to doing this:

code:

public boolean compareDouble(double d1 , double d2)
{
       while(d1 <= 1)
        d1 *= 10;
       
       while(d2 <= 1)
        d2 *= 10;
       
       if((int)d1 == (int)d2)
        return true;
       else
        return false;
       
}

Look Around You posted:

I'm guessing you know that's not what you're looking for though, right?

The printf I had will work, but you need to cast your int into a double and divide by 10 again if you want to get the 0.1 etc... you were just passing it 1, 2, 3, [...] which got cast to doubles when passed to printf which is why it came out as 1.0, 2.0 [...]


e:


Yeah, that's not mathematically correct at all; it won't do what you're looking for... can you see why?

e2: also the initial implementation of the "range" test I put up was kind of flawed, I updated the post for a correct version that was suggested below it.

Tots posted:

Well I know that it would just drop anything after the first decimal place with a number other than 0. I guess that could end up with either more or less precision than a predefined range

Look Around You posted:

What happens if you pass it a negative number?

Tots posted:

Ah, didn't think of that.

Look Around You posted:

There's some other major flaws in it too though. Notice anything else?

(I'm not trying to be cryptic I'm just trying to get you thinking about it!)

Tots posted:

Oh, no poo poo. Even if the difference is inconceivably small it will evaluate to true.

rolleyes posted:

Just to really hammer it home most languages have built-in types specifically for dealing with situations where factions are required but which would go to hell using normal floating point representations, such handling monetary values.

I've no idea what that is in Java as I've never used it, but in C# the relevant type is decimal.

Harvey Mantaco posted:

Kind of a simple actionscript question, I'm reading some code here trying to make sense of it and I'm seeing something I don't really get....

if (a || b)
{
Blah Blah Blah
}

A and B are both Integers.

I would think this isn't complete (I would expect something like a || b = c if doing an if statement) but I guess it's a thing in this guys code that does something.... what exactly is it doing?

Edit: Not sure if I should post this here... I haven't seen this before in Java but I'm not sure if this is a common thing in a lot of languages or just specific to ac.

ultrafilter posted:

It's implicitly casting a and b to boolean values by sending zero to false and any other value to true. The condition is just checking that at least one of a and b is nonzero.

delta534 posted:

Make it

code:

add(A,B,Res):- Res is A + B.

carry on then posted:

For googling, you're a lot better off using the name "logical or" (remember to turn on verbatim.) That doesn't help when you don't know the name, though (I'm still not sure what to call '->' in PHP.)

GrumpyDoctor posted:

Ok, what about

code:

something(A, B, Res) :- Res = [A + B, A - B].

That's either two uses of is or I'm going about this the wrong way.

carry on then posted:

For googling, you're a lot better off using the name "logical or" (remember to turn on verbatim.) That doesn't help when you don't know the name, though (I'm still not sure what to call '->' in PHP.)

Look Around You posted:

Arrow operator. It's the member access operator, but I don't know if they call it that very commonly or anything. (e: I don't know because I don't actually use php because gently caress php)

carry on then posted:

Yeah that latter strategy is usually mine but it was the language in the Web Programming class I took. Thanks for the answers.

Newf posted:

Newf posted:

numerical methods for IVP ODEs.

Newf posted: