no, it is not. There is a "hidden" "one" bit, the fraction part "XXX..." of the IEEE 754 float represents 1.XXXX... to be multiplied by the (offset) exponent. The exponent for the integer 2 in f64 is different from the exponent section for the integer 1, this is easy to verify:

    const std=@import("std");

    test "IEEE fp representation" {
      std.debug.print("\n{x}\n", .{@bitCast(u64, @as(f64, 1.0))});
      std.debug.print("\n{x}\n", .{@bitCast(u64, @as(f64, 2.0))});
    }
    

gives

    3ff0000000000000
    4000000000000000

note that the fraction parts for both 1.0 and 2.0 are entirely zero, as they are powers of two times [1].00000000...

The "hidden bit", while tricky and hard to understand, is probably one of the few truly good decisions that IEEE-754 comittee made out of a lot of kludgey compromises. Note that if they had done it the way you suggest, there would be degenerate representations for the same number, leading to a much smaller total possible representations for the same bitspace (this is a minor problem for most object-based "Decimal" number systems used for financial Txs -- you often need to use a specialized equality function instead of the language builtin), the "hidden one" ensures that every binary form has a uniquely represented value, not counting craziness with NaNs, and plus/minus zero, sigh.