SET Library (Steve's Extended Toolset)

[SMcNeill]

A collection of some of the most useful little library tools which I make use of on a regular basis, all collected and gathered together  for ease of inclusion into a program.

There's sort routines, search routines (a recent addition, tossed in and saved from the binary search topic), various text and graphic routines, extended timers, image save routines, safe font loading, spell checking, circle/ellipse filling, compression/decompression routines, conversion routines for various things...

A little bit of everything which I tend to have found useful to have at hand, from over my years of coding in QB64.

For now, there's not much written on HOW to make use of any of these, but they should be simple enough to sort out if you read the comments, like so:

Code: QB64: [Select]

1. FUNCTION ConvertOffset&& (value AS _OFFSET)
2.     $CHECKING:OFF
3.     DIM m AS _MEM 'Define a memblock
4.     m = _MEM(value) 'Point it to use value
5.     $IF 64BIT THEN
6.         'On 64 bit OSes, an OFFSET is 8 bytes in size.  We can put it directly into an Integer64
7.         _MEMGET m, m.OFFSET, ConvertOffset&& 'Get the contents of the memblock and put the values there directly into ConvertOffset&&
8.     $ELSE
9.         'However, on 32 bit OSes, an OFFSET is only 4 bytes.  We need to put it into a LONG variable first
10.         _MEMGET m, m.OFFSET, temp& 'Like this
11.         ConvertOffset&& = temp& 'And then assign that long value to ConvertOffset&&
12.     $END IF
13.     _MEMFREE m 'Free the memblock
14.     $CHECKING:ON
15. END FUNCTION

A function to Convert Offsets to Integer values...  Even without a demo, folks should be able to figure out to do something like X = ConvertOffset(Y).

For the SpellChecker, we have the following:

Code: QB64: [Select]

1. FUNCTION SpellCheck (TestWord$, CorrectWord$)
2.     'IF Spellcheck = 100, we have a perfect 100% match for our words
3.     'If the value is from -1 to -100, we have a percent match, so the routine "grades" how close the match is.
4.     'If the value is 0, the words are just too different for the routine to think it's a match at all.
5.     'Personally, I'd consider anything with an 80+ score to be a close enough match  usually.
6.  
7. ....more stuff

The comments should explain how it works well enough, I hope. 


As time (and motivation) allows, I'll post examples here of how to make use of these little routines one by one, but for the courageous who like to play around and figure things out themselves, feel free to grab it and use it in your own stuff.

If you have any questions about a routine (or set of routines), feel free to ask, and I'll explain/demo those first.

Secondary Dropbox link, in case the forum download doesn't work for everyone:

https://www.dropbox.com/s/bvyyl5i5xubrw9p/SET%20%28Steve%27s%20Extended%20Toolset%29.7z?dl=1

[bplus]

Hi Steve, I am checking out your SET and am running into difficulty with both demos I try:
 

I changed the file name both by removing the "./" and also tried adding ".dll" extension, neither work. (I have since tried adding DYNAMIC and various combos of three mods, result: can't find file.

The file is in same place as source, the whole SET folder, is it suppose to be in QB64.exe location?

[SMcNeill]

That actually needs to be a DECLARE DYNAMIC LIBRARY there.  I noticed it a while ago and will be zipping up a fixed archive soon for it. (I'm also doing a little bug hunting on edge numbers with the search.)

[bplus]

Yes, I tried DYNAMIC too.

Wait, OK now tried just DYNAMIC with original code, OK now.

[SMcNeill]

Toolset patched.  I'm thinking it should be working as advertised now, without that error.

EDIT: Add a demo to showcase how we'd both SORT and SEARCH an array:

Code: QB64: [Select]

1. '$INCLUDE:'SET.BI'
2.  
3. SCREEN _NEWIMAGE(800, 600, 32)
4. _SCREENMOVE _MIDDLE
5.  
6. DIM NumberArray(0 TO 100) AS LONG
7. DIM m AS _MEM: m = _MEM(NumberArray()) 'Get the memory location of our array so we can work with it via _MEM
8.  
9. RANDOMIZE TIMER
10.  
11. DO
12.     CLS
13.     'And now to randomize some numbers
14.     FOR i = 0 TO 20
15.         r = INT(RND * 100)
16.         NumberArray(i) = r
17.     NEXT
18.     MemSortSome m, 0, 20 'sort those 20 numbers so we can search them
19.     PRINT "Index", "Number"
20.     FOR i = 0 TO 20
21.         PRINT "      "; i, NumberArray(i)
22.     NEXT
23.     index = BinaryMemSearchSome(50, m, 0, 20) 'find 50 amongst the records from 1 to 20
24.     IF index < 0 THEN
25.         PRINT "50 was not found."
26.         PRINT "Where it should appear is after Index"; LastIndex
27.     ELSE
28.         PRINT "50 Exists, at Index"; index
29.     END IF
30.     SLEEP
31. LOOP UNTIL _KEYHIT = 27
32.  
33. '$INCLUDE:'SET.BM'

MemSort was my routine to sort a whole array, of any variable type which _MEM works with.

MemSortSome is a new routine to sort a fragment of an array, as specified from StartIndex to EndIndex.  In this case, I'm actually only sorting the first 21 records (from 0 to 20).

index = BinaryMemSearchSome(50, m, 0, 20)

BinaryMemSearch searches for a value in a mem block which points to an array.  For the above, we're searching for 50, in memblock m...

BinaryMemSearchSome adds the extra 2 parameters so we can do like MemSortSome -- specify the range of record which we want to search.  In this case, the 0 and 20 indicate that we only actually want to search the memblock starting at record 0 and ending at record 20.   

If the result is -1, we *DON'T* have a match.  Matches will start at record 0 and go up to the max of our search record...  Should we get a result of -1, then you can check with LastIndex to see exactly where the value would go after, IF it existed.

[SMcNeill]

A demo of the toolset command SafeLoadFont:

Code: QB64: [Select]

1. '$INCLUDE:'SET.BI'
2.  
3. SCREEN _NEWIMAGE(1025, 720, 32)
4. _SCREENMOVE _MIDDLE
5.  
6. C = _LOADFONT("cour.ttf", 16) 'courier
7. CB = _LOADFONT("courbd.ttf", 16) 'bold
8. CBI = _LOADFONT("courbi.ttf", 16) 'bold italic
9. CI = _LOADFONT("couri.ttf", 16) 'italic
10.  
11. _FONT C
12. PRINT "First a demo of the difference in the behavior of _FONT, and the reason why I prefer SafeLoadFont."
13. PRINT
14. PRINT "To start with, watch where the text on your screen appears from when I try to swap to a BOLD font."
15. PRINT
16. PRINT "PRESS <ANY KEY> WHEN READY.";
17. _FONT CB
18. SLEEP
19. temp$ = "THIS IS WHERE I AM NOW PRINTING"
20. COLOR Red, Blue
21. FOR i = 1 TO LEN(temp$)
22.     _DELAY .1
23.     PRINT MID$(temp$, i, 1);
24. NEXT
25. PRINT
26. PRINT "Notice what happened to our print location, just by changing the font?"
27. SLEEP
28. CLS , Black
29. COLOR White, Black
30. _FONT C
31. PRINT "Now, let's try this same routine with SafeLoadFont: ";
32. SLEEP
33. COLOR Red, Blue
34. SafeLoadFont CB
35. temp$ = "THIS IS WHERE I AM NOW PRINTING"
36. COLOR Red, Blue
37. FOR i = 1 TO LEN(temp$)
38.     _DELAY .1
39.     PRINT MID$(temp$, i, 1);
40. NEXT
41. PRINT
42. SLEEP
43. COLOR White, Black
44. PRINT
45. SafeLoadFont C
46. PRINT "Did you notice the difference in the two routines?"
47. PRINT "_FONT swaps our fonts, but it also resets our print location to 0,0 (or 1,1 in text mode)"
48. PRINT "Meaning we can't just swap fonts and keep typing with it, without using LOCATE or some"
49. PRINT "other method to keep printing in the same place."
50. PRINT
51. PRINT
52. PRINT "SafeLoadFont, however, loads our font ";
53. SafeLoadFont CBI
54. PRINT "without";
55. SafeLoadFont C
56. PRINT " destroying our print location."
57. PRINT "This makes it ";
58. SafeLoadFont CI
59. PRINT "ideal";
60. SafeLoadFont C
61. PRINT " for quickly swapping from normal text to bold or italic text."
62. PRINT
63. PRINT "As you can easily see with the sentences above."
64.  
65.  
66.  
67.  
68. '$INCLUDE:'SET.BM'
69.  

One of the handiest little routines which I use when working with various fonts -- especially bold/italic/underline versions. 

Be certain to grab the latest archive from the attachment under the first post (the toolset has been tweaked, added to, and edited a bit), and give it a quick run to see the simple -- but elegant -- difference between _FONT and SafeLoadFont.  ;)

(More demos to come later, but I thought I'd just start with this one.  I have to start somewhere, anyway. :P)

[Pete]

And the riddle for the day> How many little blue pills did it take to get Steve's toolset extended?

While you're pondering that, hey Steve... $CHECKING:OFF is used and I thought sine that's a meta command it will be invoked if you use this function, as is, in a routine. If so, and the routine hasn't been debugged, I think this could cause a problem for someone not familiar with its use... which includes me, as I have never coded with it. I thought it turned error checking off and could even cause a segfault, according to the wiki. If so, it might be a good idea to post a message about it. Anyway. throw your best pitch, and see if you can catch me off base on this one. Look at me, 90-minutes before kick off and I'm still quoting baseball :D

Pete

[SMcNeill]

$CHECKING:OFF/ON works a whole lot like DEFINT/DEFLNG/_DEFINE does --- only from that point downwards.

Try these two sets of code:

Code: QB64: [Select]

1. $CHECKING:OFF
2.  
3. $CHECKING:ON
4. RETURN

and

Code: QB64: [Select]

1. $CHECKING:OFF
2. RETURN
3. $CHECKING:ON

With the first, you see the error message, because it comes after the error checking is turned back on.  In the second, you end up in an endless loop as QB64 tries to pointless return to nowhere, and it can't inform you that there's an error in the program flow...

You'll see a lot of mem routines which contain $CHECKING:OFF and $CHECKING:ON in them, but checking should only be disabled once you're certain they work WITHOUT BUGS, and only in limited scope.  It should never really "bleed over" to affect any other part of the program.  ;)