So here’s the rundown for this forum glitch:

Click Profile.
Click Mentions.
Have more than a single page of mentions…. I currently have 3.
Click on the button to go to another page of mentions, besides the first one.
End up at the User Profile Summary page instead.

Currently, it’s impossible to follow a link to any mention page besides the first one.

---

And unrelated, but how do we erase all these pages of mentions?  I’m not finding a Delete or Trash button anywhere on the page.

As a few members don't seem to understand the relationship between decimal values and binary representation of them via floating point values, I thought I'd toss together this quick little program so someone could play around with it and see how our values are stored in memory.


Now, the important things to keep in mind here is:

1) Your binary value is stored in formalized format.  Just as 1,234 is written as 1.234E3, the binary value of 111 (which is 7, in base-10 math) is written and stored as 1.11E2.
2) When looking at how this value is stored in memory, it's stored with:
    the first bit representing the sign.  (+ or -)
    the next 8 bits represent our exponent PLUS 127 (to store negative values)
    the remaining bits represent our formalized format
3) Now note, since formalized format will ALWAYS begin with a 1, storing that value is redundant and as such it isn't done.  We only store those values right of the period.

So, putting this together, The value for 1 would be:
0 --- 01111111 --- 0000000000000000000000

That first 0 represents that there's no negative sign.  (Toggle it and you'll see that our value swaps to become a -1)
The next 8 bits represent the value of 127; which as I mentioned before is an exponent of 0 PLUS 127.  This gives us an exponent of 0.
The rest of the bits are the mantissa, which in this case are just 0.

Put those together, and you have a binary value of: +1.0E0   (Remember, the leading 1 to the left of the period is implied and not stored.)
 

---

And, the value for 2 would be:
0 --- 10000000 --- 0000000000000000000000

That first 0 represents that there's no negative sign.  (Toggle it and you'll see that our value swaps to become a -1)
The next 8 bits represent the value of 128; which as I mentioned before is an exponent of 1 PLUS 127.  This gives us an exponent of 1.
The rest of the bits are the mantissa, which in this case are just 0.

Put those together, and you have a binary value of: +1.0E1   (Remember, the leading 1 to the left of the period is implied and not stored.)

Shift that to normalized format and the binary value is: 10.   (And, as everyone knows, 10 = 2.)

---

And, the value for 3 would be:
0 --- 10000000 --- 1000000000000000000000

That first 0 represents that there's no negative sign.  (Toggle it and you'll see that our value swaps to become a -1)
The next 8 bits represent the value of 128; which as I mentioned before is an exponent of 1 PLUS 127.  This gives us an exponent of 1.
The rest of the bits are the mantissa, which in this case are just 1, followed by a ton of zeros.

Put those together, and you have a binary value of: +1.1E1   (Remember, the leading 1 to the left of the period is implied and not stored.)

Shift that to normalized format and the binary value is: 11.   (And, as everyone knows, 11 = 3.)

---

And since we can now count from 1 to 3 in SINGLE, take a moment to look at how fractional values are stored:

0 --- 01111111 --- 1100000000000000000000

That first 0 represents that there's no negative sign.  (Toggle it and you'll see that our value swaps to become a -1)
The next 8 bits represent the value of 127; which as I mentioned before is an exponent of 0 PLUS 127.  This gives us an exponent of 0.
The rest of the bits are the mantissa, which in this case are two 1's, followed by all 0's.

Put those together, and you have a binary value of: +1.11E0   (Remember, the leading 1 to the left of the period is implied and not stored.)

In normalized format, that'd look like: 1.11 in binary.

In decimal (base-10) values, what we'd have is:
1 in the one's position.  (left of the period.)
1 in the one half's position.  (first one right of the period.)
1 in the one fourth's position.  (furthermost one on the right.)

Added together 1 + 1/2 + 1/4 = 1.75

1,11 binary (base-2) = 1.75 decimal (base-10)

---

Play around with it.  If nobody believes that our decimal values are stored as base-2 values after this, I don't know what to tell you.  Apparently I'll never be able to illustrate it, or explain it to the point where it makes sense for that person and they can connect the dots and put it all together.  I've tried, so all I can say is if this doesn't sort it out for you, "Find someone else to explain it and teach it to you."

(I'd posted this elsewhere, but thought I'd share it here so folks who might not be reading the other topic could locate this and maybe someday reference it, or make use of it, for their own stuff.)

Here's a little something which I tossed together in about 20 minutes this afternoon, which you might be able to use:


45 lines total, and  only 33 lines for our SUB, which does all the real work for us.

And what's this do, you ask?

It creates a simple, stand-alone, multi-line, POP-UP input box which we can use the arrow keys to move up and down between. 

Usage is rather simple:
1) Dim 2 arrays to hold your prompts and the results.
2) Set your prompts.
3) Call the function, get the results.

Can't be much simpler than that!

So as to not keep derailing BSpinoza's topic about Heron's Method to calculate squares, I thought I'd just start a new one here for this example, which STx might want to compare against all his fancy-pancy math formulas which estimate to .1% accuracy.  All we're doing here is some basic averaging to find an estimation which is almost comparable to that .1% accuracy -- no formulas, scribbled notes, or math text books needed!  Just add two numbers together and divide by two for the average!  :P

There's several programs out there that make use of falcon.h by now, but I wanted to take a shot at tossing in my own personal version of a simplified wrapper for the command -- QPRINT.


Instead of trying to track all sorts of parameters for uprint  -- (x&, y&, chars$, txt_len&, colour~&, max_width&)  -- I've written a wrapper to break it down to one little command QPrint text$.

If you want colors, simply use QB64's normal COLOR command.  If you want to position your text, simply use LOCATE, like you normally would with your code.  It word wraps automatically, as well as scrolls the screen for us if we end up printing down on the bottom line of the screen.   Basically, use it more or less like you would a simplified PRINT statement that can only handle a single string output.

The advantage to this little command?  (And to falcon.h, in general?)

No cutting off parts of your characters.  Some fonts are terrible about having half the letter cut off (I was using a script font the other day that lost the whole top half of my T's and F's, and their flourishes.), and you should be able to see the difference and the problem with the example code, which relies on cyberbit.ttf. 

One thing of note here:  QB64 v1.4 comes with cyberbit.ttf packaged with it.  V1.5 (the latest development build) doesn't.  If you're running the latest development build, you may want to download the file below and toss it in your folder for testing purposes. 

NOTE 2:  QPrint's LOCATE and PRINT's LOCATE are two completely different areas of your screen.  Don't expect the two to match at all for you.   With the example, QPRINT is printing a character 26 pixels high, whereas PRINT cuts off segments of it and only prints a character 20 pixels high... That difference is going to naturally lead to the rows being at different heights, so don't expect to LOCATE y,x and then QPRINT, and then LOCATE y,x and PRINT, and have the numbers match up at all.

Get a list of the available drives on your machine, and some info on what type they are.

Here's a little trick I just sat down and sorted out, that you guys who write library style code might want to get familiar with.

For your BI file, write it in a simple little $IF Wrapper, like this one:

$IF VKBI = UNDEFINED THEN 

    (put your actual BI file stuff in between the wrapper, here...)

    $LET VKBI = TRUE
$END IF

Then, at the top of your BM file, write something similar to this little snippet:

$IF VKBI = UNDEFINED THEN
    '$INCLUDE:'Virtual Keyboard.BI'
$END IF

Now, you can work in the BM file without getting type errors and such, and having to code blind.  All your references from the BI file are now included in your work, and auto-formatting and the IDE error checking works as intended, and life is good!!

---

And best of all? 

Once you're finished, you just write your main program like usual to take advantage of those libraries.

'$INCLUDE:'Virtual Keyboard.BI'

(main program code goes here)

'$INCLUDE:'Virtual Keyboard.BM'

Since your manual include of the BI file occurred already in your main program, the precompiler variable is set, and thus no longer UNDEFINED, so you won't include it twice and generate "Name already in use" errors.

---

I find, for me, this little trick takes a good bit of the hassle out of working with library creation and editing, so I thought I'd share, and maybe others would enjoy taking advantage of it as well.  ;)

And here's my newest little toy for folks to have fun and play around with -- a virtual keyboard creator!


I'll let the demo speak for itself, but if anyone has questions or ideas, I'd be more than happy to hear them.  ;)