Why is a type when used as a function given a boolean true return a number?

Why are these returning a number?

$ julia
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _  |  |
  | | |_| | | | (_| |  |  Version 1.0.3 (2018-12-18)
 _/ |\__ _|_|_|\__ _|  |  Official https://julialang.org/ release
|__/                   |

julia> Float64(true)

julia> Float32(true)

julia> Int64(true)

julia> Int32(true)

julia> Float64(false)

julia> Float32(false)

julia> Int64(false)

julia> Int32(false)

Maybe I misunderstand but it’s because you are explicitly converting to numbers by calling the constructors? What did you expect?

1 Like

Please refer to this

It’s generally not good form to refer people to other unresolved questions in order to answer your question. Don’t make people do work in order to understand what you’re asking. See also: Please read: make it easier to help you

It’s pretty common in programming languages for booleans true and false to be represented by 1 and 0 respectively. In python, they are literally the same (1 == True). In Julia, they’re not the same thing, but you can convert a Bool into a number as you’ve shown. To reiterate:


A Bool already is a Number, and true and false indeed represent the numbers 1 and 0 in Julia:

julia> Bool <: Number

julia> true == 1

julia> false == 0

However, if you are in a context expecting a boolean type, e.g. an if statement, you must use a Bool and not some other number type for 0 and 1.


Prehaps I should explain myself.

I could not get a struct called mynum to have it’s inverse calculated properly as a square matrix

When I traced how a square matrix of type Float64 is transformed into its inverse

there is a strange call Float64(true)

at LinearAlgebra.jl/blob/master/src/uniformscaling.jl

## Matrix construction from UniformScaling
function Matrix{T}(s::UniformScaling, dims::Dims{2}) where {T}
    A = zeros(T, dims)
    v = T(s.λ)
    for i in diagind(dims...)
        @inbounds A[i] = v
    return A

Where " v = T(s.λ) " becomes v = Float64(true)

julia> Float64(I.λ)

julia> I.λ

and subsequently I need to create a mynum(x::Bool) before my struct mynum can have its inverse calculated.

So my question is what is the purpose of Float64(x::Bool)

Steven Siew

To convert the argument to Float64.

Please do look at the documentation, eg ?Float64 in the REPL.

As others have explained it’s an established (and quite useful) convention in programming languages, but also in mathematics, to associate true and false with the values 1 and 0. I believe what you rather want to ask is why the implementation of inv chooses to make use of this convention.

Afaik, the general convention for number types is that T(true) == one(T) and T(false) == zero(T), i.e.~you should get the neutral elements for addition and multiplication in your field / ring / approximate field, and true * x == x, and false * x == zero(typeof(x)).

Note the hard zero: E.g. 0*Inf is NaN, but false*Inf is 0.0.

1 Like

I guess that shows me for running my mouth without checking :smile:. I knew there was a way they were different from python, and this is definitely what I was thinking. Thanks for the clarification!