fastest way to randomize case on string - string

Question

For some protocol testing I need to randomize the case of each character in a lot of strings.
The strings are commands, created by my application, which will be sent via a winsock control to a client.
As it involves a lot of strings I want each part to be as fast as possible.
Right now I have:
Private Function RandomCaps(strText As String) As String
Dim lngChar As Long
Dim strLower As String, strUpper As String
Dim strRandom As String
strRandom = ""
strLower = LCase$(strText)
strUpper = UCase$(strText)
For lngChar = 1 To Len(strText)
If Int(2 * Rnd) = 0 Then
strRandom = strRandom & Mid$(strLower, lngChar, 1)
Else
strRandom = strRandom & Mid$(strUpper, lngChar, 1)
End If
Next lngChar
RandomCaps = strRandom
End Function
This is pretty straightforward, but probably not the fastest way.
What could I do to improve its speed?

Answer 1

Instead of concatenating strings together, use Mid to change the string in-place:
Private Function RandomCaps(s As String) As String
Dim uc As String
Dim i As Long
RandomCaps = LCase$(s)
uc = UCase$(s)
For i = 1 To Len(s)
If Rnd < 0.5 Then
Mid(RandomCaps, i, 1) = Mid(uc, i, 1)
End If
Next i
End Function
You can try using MidB, but it hardly makes any difference – and since it works with individual bytes, you're in for some nasty surprises if you don't know how VB6 stores strings.

Answer 2

Use MidB() instead of Mid.
MidB is a bit faster.
The other solution could be to copy the stringpointer into an Array of integer.
for example:
Public Type TUDTPtr
pSA As Long
Reserved As Long ' z.B. für vbVarType oder IRecordInfo
cDims As Integer
fFeatures As Integer
cbElements As Long
cLocks As Long
pvData As Long
cElements As Long
lLBound As Long
End Type
Public Type TCharPointer
pudt As TUDTPtr
Chars() As Integer
End Type
Public Enum SAFeature
FADF_AUTO = &H1
FADF_STATIC = &H2
FADF_EMBEDDED = &H4
FADF_FIXEDSIZE = &H10
FADF_RECORD = &H20
FADF_HAVEIID = &H40
FADF_HAVEVARTYPE = &H80
FADF_BSTR = &H100
FADF_UNKNOWN = &H200
FADF_DISPATCH = &H400
FADF_VARIANT = &H800
FADF_RESERVED = &HF008
End Enum
Public Declare Sub RtlMoveMemory Lib "kernel32" ( _
ByRef pDst As Any, _
ByRef pSrc As Any, _
ByVal bLength As Long)
Public Declare Sub RtlZeroMemory Lib "kernel32" ( _
ByRef pDst As Any, _
ByVal bLength As Long)
Public Declare Function ArrPtr Lib "msvbvm60" _
Alias "VarPtr" ( _
ByRef pArr() As Any) As Long
Public Sub New_UDTPtr(ByRef this As TUDTPtr, _
ByVal Feature As SAFeature, _
ByVal bytesPerElement As Long, _
Optional ByVal CountElements As Long = 1, _
Optional ByVal lLBound As Long = 0)
With this
.pSA = VarPtr(.cDims)
.cDims = 1
.cbElements = bytesPerElement
.fFeatures = CInt(Feature)
.cElements = CountElements
.lLBound = lLBound
End With
End Sub
Public Sub New_CharPointer(ByRef this As TCharPointer, ByRef StrVal As String)
With this
Call New_UDTPtr(.pudt, FADF_AUTO Or FADF_FIXEDSIZE, 2, Len(StrVal), 1)
With .pudt
.pvData = StrPtr(StrVal)
End With
Call RtlMoveMemory(ByVal ArrPtr(.Chars), ByVal VarPtr(.pudt), 4)
End With
End Sub
Public Sub DeleteCharPointer(ByRef this As TCharPointer)
With this
Call RtlZeroMemory(ByVal ArrPtr(.Chars), 4)
End With
End Sub
your function then could look like:
Private Sub RandomCapsX(strText As String) 'As String
Dim i As Long
Dim p As TCharPointer: Call MCharPointer.New_CharPointer(p, strText)
For i = 1 To p.pudt.cElements
Select Case p.Chars(i)
Case 65 To 90
'Uppercase
p.Chars(i) = p.Chars(i) + Int(2 * Rnd) * 32
Case 97 To 122
'lowercase
p.Chars(i) = p.Chars(i) - Int(2 * Rnd) * 32
End Select
Next
Call MCharPointer.DeleteCharPointer(p)
End Sub

Answer 3

To optimize code by RDHS, you don't really need to keep an uppercase version of the string. I think this is as optimized as you can get.
CODE 1:
Private Function RandomCaps(s As String) As String
Dim i As Long
RandomCaps = LCase$(s)
For i = 1 To Len(s)
If Rnd < 0.5 Then
Mid(RandomCaps, i, 1) = UCase(Mid(RandomCaps, i, 1))
End If
Next i
End Function
The code above is good, however, in the case of really really large strings, you might wanna try this (not tested for performance vs RDHS's code):
CODE 2:
Private Function RandomCaps(s As String) As String
Dim b() As Byte
b = StrConv(Text1.Text, vbFromUnicode)
Dim i As Long
For i = 0 To UBound(b) - 1
If Rnd < 0.5 Then
If UCase(Chr(b(i))) = Chr(b(i)) Then
'original char is uppercase, make it lowercase
b(i) = Asc(LCase(Chr(b(i))))
Else
'original char is lowercase, make it uppercase
b(i) = Asc(UCase(Chr(b(i))))
End If
End If
Next i
RandomCaps = StrConv(b, vbUnicode)
End Function
EDIT:
I did some performance testing and the difference between the two codes above is negligible: the 2nd code block is only about 1% faster then the first one.
EDIT 2:
Disregard my previous edit. Code 2 is approximately 50% less efficient as Code 1. however, as RDHS suggested, I adjusted code 2 to compare the values instead of going back and forth from CHR to ASC and it is more efficient starting with input strings that are approximately 40 characters long. The longer the input string, the better code 3 performance. With an input string that is 944640 characters long, Code 3 is 57% faster then Code 1.
Statistics:
First column is the length of the input string (in chars)
Second column is Code 3 efficiency compared to Code 2.
As you can see, with string length of 5 chars, Code 2 is 46% more efficient. Starting with string length around 40, Code 3 becomes more and more efficient.
5 -46.80%
50 6.22%
100 21.50%
500 38.54%
1000 41.11%
10000 44.87%
100000 43.25%
1260000 43.02%
CODE 3:
Private Function RandomCaps(s As String) As String
Dim b() As Byte
b = StrConv(Text1.Text, vbFromUnicode)
Dim i As Long
For i = 0 To UBound(b) - 1
If Rnd < 0.5 Then
If b(i) >= 64 And b(i) <= 90 Then
'A to Z
b(i) = b(i) + 32
ElseIf b(i) >= 97 And b(i) <= 122 Then
'a to z
b(i) = b(i) - 32
Else
'everything else
End If
End If
Next i
RandomCaps = StrConv(b, vbUnicode)
End Function