This is the first part of a multi-series article whose objective is to create a simple AI library that covers a couple of advanced AI topics such as Genetic algorithms, ANN, Fuzzy logics and other evolutionary algorithms.

''' <summary>
''' Canvas constructor function
''' </summary>
''' <param name="_width">Drawing area - Width</param>
''' <param name="_height">Drawing area - Height</param>
Public Sub New(_width As Integer, _height As Integer)
    Me._Width = _width
    Me._Height = _height
    Me._bmp = New Bitmap(_width, _height)
    g = Graphics.FromImage(_bmp)
    g.SmoothingMode = SmoothingMode.HighQuality
End Sub

Imports CommonLib.CommonLib

Public Class Form1
    ' Form-level Canvas object
    Private myCanvas As Canvas

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        myCanvas = New Canvas(PictureBox1.Width, PictureBox1.Height)
        Draw()
    End Sub

    Private Sub Draw()
        With myCanvas
            .DrawBox(50, 25, 25, Color.Black)
            .FillBox(50, 100, 25, Color.Red)
            .DrawCircle(50, 100, 200, Color.Blue)
            .FillCircle(50, 200, 200, Color.Green)
            .DrawText("Test String", 250, 200, Color.Red)
        End With
        ' To draw canvas
        PictureBox1.Image = myCanvas.Image
        ' other code
    End Sub

    Private Sub Clear()
        myCanvas.Clear()
        PictureBox1.Image = myCanvas.Image
    End Sub
End Class

''' <summary>
''' Constrains value between min and max values
'''   if less than min, return min
'''   more than max, return max
'''   otherwise return same value
''' </summary>
''' <param name="Value"></param>
''' <param name="min"></param>
''' <param name="max"></param>
''' <returns></returns>
Public Function Constraint(Value As Single, min As Single, max As Single) As Single
    If Value <= min Then
        Return min
    ElseIf Value >= max Then
        Return max
    End If
    Return Value
End Function

''' <summary>
''' Re-maps a number from one range to another. In the example above,
''' </summary>
''' <param name="value"> the incoming value to be converted </param>
''' <param name="start1"> lower bound of the value's current range </param>
''' <param name="stop1"> upper bound of the value's current range </param>
''' <param name="start2"> lower bound of the value's target range </param>
''' <param name="stop2"> upper bound of the value's target range </param>
Public Shared Function Map(ByVal value As Single, ByVal start1 As Single, _
  ByVal stop1 As Single, ByVal start2 As Single, ByVal stop2 As Single) As Single
    Dim Output As Single = start2 + (stop2 - start2) * ((value - start1) / _
                           (stop1 - start1))
    Dim errMessage As String = Nothing
    
    If Output <> Output Then
        errMessage = "NaN (not a number)"
        Throw New Exception(errMessage)
    ElseIf Output = Single.NegativeInfinity _
                    OrElse Output = Single.PositiveInfinity Then
        errMessage = "infinity"
        Throw New Exception(errMessage)
    End If
    Return Output
End Function

''' <summary>
''' Normalizes a number from another range into a value between 0 and 1.
''' Identical to map(value, low, high, 0, 1);
''' Numbers outside the range are not clamped to 0 and 1, because
''' out-of-range values are often intentional and useful.
''' </summary>
''' <param name="value"> the incoming value to be converted </param>
''' <param name="start"> lower bound of the value's current range </param>
''' <param name="stop"> upper bound of the value's current range </param>
Public Shared Function Norm(ByVal value As Single, _
                            ByVal start As Single, ByVal [stop] As Single) As Single
    Return (value - start) / ([stop] - start)
End Function

''' <summary>
''' Generates 8 bit array of an integer, value from 0 to 255
''' </summary>
''' <param name="Value"></param>
''' <returns></returns>
Public Function GetBitArray(Value As Integer) As Integer()
    Dim Result(7) As Integer
    Dim sValue As String
    Dim cValue() As Char
    
    Value = Constraint(Value, 0, 255)
    sValue = Convert.ToString(Value, 2).PadLeft(8, "0"c)
    cValue = sValue.ToArray
    For i As Integer = 0 To cValue.Count - 1
        If cValue(i) = "1"c Then
            Result(i) = 1
        Else
            Result(i) = 0
        End If
    Next
    Return Result
End Function

''' <summary>
'''   Generates normally distributed numbers using Box-Muller transform by 
'''   generating 2 random doubles
'''   Gaussian noise is statistical noise having a probability density function (PDF) 
'''   equal to that of the normal distribution, 
'''   which is also known as the Gaussian distribution.
'''   In other words, the values that the noise can take on are Gaussian-distributed.
''' </summary>
''' <param name = "Mean">Mean of the distribution, default = 0</param>
''' <param name = "StdDeviation">Standard deviation, default = 1</param>
''' <returns></returns>
Public Function NextGaussian(Optional ByVal Mean As Double = 0, _
                             Optional ByVal StdDeviation As Double = 1) As Double
    Dim X1 = _Gen.NextDouble()
    Dim X2 = _Gen.NextDouble()
    Dim StdDistribution = Math.Sqrt(-2.0 * Math.Log(X1)) * Math.Sin(2.0 * Math.PI * X2)
    Dim GaussianRnd = Mean + StdDeviation * StdDistribution
    
    Return GaussianRnd
End Function

''' <summary>
'''   Generates values from a triangular distribution
'''   Triangular distribution is a continuous probability distribution with:
'''       lower limit a
'''       upper limit b 
'''       mode c
'''   where a less than b 
'''   c is higher than or equal a but less than or equal b
''' </summary>
''' <param name = "min">Minimum</param>
''' <param name = "max">Maximum</param>
''' <param name = "mode">Mode (most frequent value)</param>
''' <returns></returns>
Public Function NextTriangular(ByVal min As Double, ByVal max As Double, _
                               ByVal mode As Double) As Double
    Dim u = _Gen.NextDouble()
    
    If (u < (mode - min) / (max - min)) Then
        Return min + Math.Sqrt(u * (max - min) * (mode - min))
    Else
        Return max - Math.Sqrt((1 - u) * (max - min) * (max - mode))
    End If
End Function

''' <summary>
'''   Shuffles a list in O(n) time by using the Fisher-Yates/Knuth algorithm
''' </summary>
''' <param name = "list"></param>
Public Sub Shuffle(ByVal list As IList)
    For i = 0 To list.Count - 1
        Dim j = _Gen.Next(0, i + 1)
        
        Dim temp = list(j)
        list(j) = list(i)
        list(i) = temp
    Next i
End Sub

''' < 요약 > ''' 캔버스 생성자 함수
 ''' < /summary > ''' < param name="_width" > 그리기 영역 - 너비 < /param > ''' < param name="_height" > 그리기 Area - Height < /param > Public Sub New (_width As Integer , _height As Integer )
     Me ._Width = _width
     Me ._Height = _height
     Me ._bmp = 새 비트맵(_width, _height) 
 
  
  
    
    g = 그래픽.FromImage(_bmp)
    g.SmoothingMode = SmoothingMode.HighQuality
 서브 끝

CommonLib.CommonLib을 가져옵니다.

Public  Class Form1
     ' 양식 수준 Canvas 객체 
    Private myCanvas As Canvas

    Private  Sub Form1_Load(sender As  Object , e As EventArgs)는 MyBase .Load를 처리합니다 . 
        myCanvas = 새 캔버스(PictureBox1.Width, PictureBox1.Height)
        그리다()
     서브 끝

     myCanvas를 사용한 비공개 하위 그리기()
        
            .DrawBox( 50 , 25 , 25 , 색상.검정색)
            .FillBox( 50 , 100 , 25 , 색상.빨간색)
            .DrawCircle( 50 , 100 , 200 , 색상.블루)
            .FillCircle( 50 , 200 , 200 , 색상.녹색)
            .DrawText( " Test String" , 250 , 200 , Color.Red)
         End  With 
        ' 캔버스를 그리려면
        PictureBox1.Image = myCanvas.Image
        ' 다른 코드 
    End  Sub

    비공개  서브 클리어()
        myCanvas.Clear()
        PictureBox1.Image = myCanvas.Image
    종료  하위 
종료  클래스

''' < 요약 > ''' 최소값과 최대값 사이의 값을 제한합니다.
 ' ''    min보다 작으면 min을 반환하고,
    max보다 크면 min을 반환하고, max를 반환하고, max
 를 반환합니다. '''    그렇지 않으면 동일한 값을 반환합니다.
 ''' < /summary > ' '' < param name="값" > < /param > ''' < param name="min" > < /param > ''' < param name="max" > < /param > ''' < 반환 > < /returns > 공용 함수 제약 조건(Value As Single , min As Single , max As Single ) As Single If Value <= min Then Return min
     ElseIf Value >= max Then Return max
     End If Return Value
 End Function 
 
  
  
  
 
     
    
        
         
     

''' < 요약 > ''' 한 범위의 숫자를 다른 범위로 다시 매핑합니다. 위의 예에서
 ''' < /summary > ''' < param name="value" > 변환할 들어오는 값 < /param > ''' < param name="start1" > 값의 현재 하한값 range < /param > ''' < param name="stop1" > 값 현재 범위의 상한 < /param > ''' < param name="start2" > 값 대상 범위의 하한 < /param > ' '' < param name="stop2" > 값의 대상 범위 상한 < /param > 공용 공유 함수 맵( ByVal value As Single , ByVal start1 As Single , _
   ByVal stop1 As Single , ByVal start2 As Single , ByVal stop2 As Single ) As Single Dim 출력 As Single = start2 + (stop2 - start2) * ((value - start1) / _ 
 
  
  
  
  
  
        
     
                           (정지1 - 시작1))
    Dim errMessage As  String = 아무것도 없음
    
    If Output <> Output Then 
        errMessage = " NaN (숫자 아님)" 
        Throw  New Exception(errMessage)
     ElseIf Output = Single .NegativeInfinity _
                     OrElse Output = Single .PositiveInfinity Then 
        errMessage = " infinity" 
        Throw  New Exception(errMessage)
     End  If 
    Return 출력
 종료  기능

''' < 요약 > ''' 다른 범위의 숫자를 0과 1 사이의 값으로 정규화합니다.
 ''' map(value, low, high, 0, 1)과 동일합니다.
''' 범위 밖의 숫자는 0과 1로 고정되지 않습니다.
 ''' 범위를 벗어난 값은 종종 의도적이고 유용하기 때문입니다.
''' < /summary > ''' < param name="value" > 변환할 들어오는 값 < /param > ''' < param name="start" > 값 현재 범위의 하한 < /param > ''' < param name="stop" > 값의 현재 범위 상한 < /param > 공용 공유 함수 Norm( ByVal value As Single , _
                             ByVal start As Single , ByVal [ stop ] As Single ) As Single 반환 (값 - 시작) / ([ 중지 ] - 시작)
 종료 기능 
 
  
  
  
      
     

''' < 요약 > ''' 0에서 255 사이의 값인 정수의 8비트 배열을 생성합니다. '
 '' < /summary > ''' < param name="Value" > < /param > ''' < return > < / returns > 공용 함수 GetBitArray(정수형 값 ) As Integer ( )
     Dim Result( 7 ) As Integer Dim sValue As String Dim cValue() As Char 
 
  
 
    
     
     
    
    값 = 제약조건(값, 0 , 255 )
    sValue = Convert.ToString(Value, 2 ).PadLeft( 8 , " 0" c)
    cValue = sValue.ToArray
    For i As  Integer = 0  To cValue.Count - 1 
        If cValue(i) = " 1" c Then 
            Result(i) = 1 
        Else 
            Result(i) = 0 
        End  If 
    Next 
    반환 결과
 End  Function

''' < 요약 > '' '    2개의 임의의 double을 생성하는
 '''    Box-Muller 변환을 사용하여 정규 분포 숫자를 생성합니다. ''' 
 가우스    잡음은 확률 밀도 함수(PDF) 
 '''    가 다음과 동일한 통계 잡음입니다. 정규 분포, 
 '''    가우스 분포라고도 알려져 있습니다.
'''    즉, 노이즈가 취할 수 있는 값은 가우스 분포입니다.
''' < /summary > ''' < param name = "Mean" > 분포 평균, 기본값 = 0 < /param > ''' < param name = "StdDeviation" > 표준 편차, 기본값 = 1 < /param > ''' < 반환 > < /returns > 공용 함수 NextGaussian( Optional ByVal Mean As Double = 0 , _
                              Optional ByVal StdDeviation As Double = 1 ) As Double Dim X1 = _Gen.NextDouble()
     Dim X2 = _Gen.NextDouble()
     Dim StdDistribution = Math.Sqrt(-2.0 * Math.Log(X1)) * Math.Sin( 2 . 0 * Math.PI * X2)
     Dim GaussianRnd = 평균 + StdDeviation * StdDistribution 
 
    
    
 
      
    
    
    GaussianRnd
 종료  함수 반환

''' < 요약 > '''    삼각 분포에서 값을 생성합니다
 . '''    삼각 분포는 다음을 갖는 연속 확률 분포입니다.
 '''        하한 a
 '''        상한 b 
 '''        모드 c
 '''    여기서 a는 더 적습니다. b보다 
 '''    c는 a보다 높거나 같지만 b보다 작거나 같습니다.
 ''' < /summary > ''' < 매개변수 이름 = "min" > 최소값 < /param > ''' < 매개 변수 이름 = "max " > 최대 < /param > ''' < param name = "mode" > 모드(가장 빈번한 값) < /param > ''' < 반환 > < /returns > Public Function NextTriangular( ByVal min As Double , ByVal max As Double , _
                                ByVal 모드 As Double ) As Double Dim u = _Gen.NextDouble() 
 
    
    
    
 
     
    
    
    If (u < (mode - min) / (max - min)) Then 
        return min + Math.Sqrt(u * (max - min) * (mode - min))
     Else 
        Return max - Math.Sqrt(( 1 - u ) * (최대 - 최소) * (최대 - 모드))
     End  If 
End  함수

''' < 요약 > '''    Fisher-Yates/Knuth 알고리즘을 사용하여 O(n) 시간에 목록을 섞습니다. ''
 ' < /summary > ''' < param name = "list" > < /param > Public Sub Shuffle( ByVal list As IList)
     For i = 0 To list.Count - 1 Dim j = _Gen. 다음 ( 0 , i + 1 ) 
 
    
  
        
        
        어두운 온도 = list(j)
        목록(j) = 목록(i)
        목록(i) = 임시
    다음 i
 End  Sub