Results 1 to 6 of 6

Thread: Boosting calculation speed using compilers DLLs (such as FreeBasic)

  1. #1

    Boosting calculation speed using compilers DLLs (such as FreeBasic)

    look at http://www.thinbasic.com/community/s...-GBuffer-tests , i have used big equations to display the simpsons figure, the calculation time is about 10 seconds so Peter have provided an animation to track the progress while you are waiting
    i was toying with freebasic dlls to see how much we can boost thinbasic speed, i have used this tutorial (Creating your own DLL for Rapid-Q using FreeBasic ) http://rapidq.phatcode.net/tutorial/..._tutorial.html ,the good think it is easier to use thinbasic to declare and use functions in other dlls
    the time of running this simpson code 1 second, compare to the previous 10 seconds. so we can use the Brain of thinbasic (with all its functions and Graphics capabilities) while when needed we seek help from the muscles of other compilers for math repetitive tasks like this one.

    notes if you want to compile the freebasic code yourself use this:
    fbc -dll dll_udt_VertexArrays.bas
    don't forget to add to the freebasic path in environment variable: (in windows xp):
    C:\FreeBASIC;C:\FreeBASIC\bin\win32

    the big size of dll_udt_VertexArrays.bas and its compiled form dll_udt_VertexArrays.dll (inside the attached rar file) is because it contains the X, Y data for the simpson shape which are too big
    Attached Files Attached Files

  2. #2
    thinBasic author ErosOlmi's Avatar
    Join Date
    Sep 2004
    Location
    Milan - Italy
    Age
    51
    Posts
    8,343
    Blog Entries
    2
    Rep Power
    10
    Great way to mix the power of different languages.

    I would be curious to see how this can be developed using thinBasic Oxygen module.
    Oxygen is a JIT (Just In Time) Compiler developed by Charles Pegge.
    It can take a BASIC Like syntax very close to thinBasic language and compile it on the fly in machine code.
    Usually execution speed is 100 times faster than thinBasic execution speed that is parsing/interpreting source code directly over and over.
    It is also possible to interact between thinBasic and Oxygen variables.

    If someone has some time ...

    Ciao
    Eros
    www.thinbasic.com | www.thinbasic.com/community/ | psch.thinbasic.com
    Win10Pro 64bit - 8GB Ram - Intel i7 M620 2.67GHz - NVIDIA Quadro FX1800M 1GB

  3. #3
    Super Moderator Petr Schreiber's Avatar
    Join Date
    Aug 2005
    Location
    Brno - Czech Republic
    Posts
    6,839
    Blog Entries
    3
    Rep Power
    697
    Thanks for nice FreeBasic - ThinBASIC interop example!

    Here is how you can just-in-time compile and execute super fast code via Oxygen:
    Uses "TBGL", "math", "Oxygen"
    
    Function TBMain()
      Local hWnd      As DWord
      Local FrameRate As Double
       
      ' -- Create and show window
      hWnd = TBGL_CreateWindowEx("Plotting 3D Data in an array using GBuffers- Calculate with Oxygen JIT ..Esc to quit", 600, 600, 32, %TBGL_WS_WINDOWED Or %TBGL_WS_CLOSEBOX) 
      TBGL_ShowWindow  
       
      TBGL_BackColor 255,255,255 
      'TBGL_SetDrawDistance 250
     
      ' -- Create 3D points buffer
      DWord gbPoints = TBGL_GBufferCreate(%TBGL_POINTS, %TBGL_3D)
        
      Global Nb As DWord = 22619 ' 72*pi/0.01
      ' -- Define data for it
      Global VertexA(Nb) As TBGL_TVECTOR3F ' single
      Global ColorA(Nb)  As TBGL_TRGB      ' Byte
     
      FillArrays()
      
      ' -- Create buffer dynamically linked to the arrays above
      TBGL_GBufferDefineFromArray(gbPoints, %TBGL_DYNAMIC, CountOf(VertexA), VertexA(1), ColorA(1))
      
      ' -- Resets status of all keys 
      TBGL_ResetKeyState()
      'TBGL_PointSize 2
      
      ' -- Main loop
      While TBGL_IsWindow(hWnd)
      'init 
        FrameRate = TBGL_GetFrameRate
        
        TBGL_ClearFrame
          TBGL_Camera(0, 0, 90, 0, 0, 0)
           
          ' -- Turn triangle
          TBGL_Rotate GetTickCount/50, 0, 1, 0
          TBGL_Scale 0.6, 0.6, 0.6
                                         
          ' -- Render it                              
          TBGL_GBufferRender(gbPoints)   
            
        TBGL_DrawFrame
     
        ' -- ESCAPE key to exit application
        If TBGL_GetWindowKeyState(hWnd, %VK_ESCAPE) Then Exit While
     
      Wend        
      ' -- Destroying the buffer is not necessary,
      ' -- the garbage collector will take care of it
     
      ' -- Destroy window
      TBGL_DestroyWindow
    End Function   
    
    Function FillArrays()
    
      String src = "
      basic
      
      ' -- Re-declare types
      Type TBGL_TRGB
        r As Byte
        g As Byte
        b As Byte
      End Type
      
      Type TBGL_TVECTOR3F
        x As Single
        y As Single
        z As Single
      end type
      
      Function theta(a As Single) As Single
         
        If a<=0 Then
          Function = 0
        Else
          Function = 1
        End If
      
      End Function
      
      ' -- Link variables  
      dim oVertexA(30159) At #VertexA As TBGL_TVECTOR3F
      dim oColorA(30159) At #ColorA As TBGL_TRGB
        
         
      Single x, y, z, t
      DWord N = 1
      
      While t <= 72*3.14
                
                x = ((-5/37 *Sin(61/42-8 *t)-112/41 *Sin(36/23-7 *t)-62/37 *Sin(14/9-6 *t)-31/7 *Sin(69/44-5 *t)-275/13 *Sin(47/30-3 *t)-23/38 *Sin(48/31-2 *t)+461/10 *Sin(t+107/68)+8/23 *Sin(4 *t+179/38)-2345/18) *theta(71 *Pi-t) *theta(t-67 *Pi)+(-41/74 *Sin(112/75-17 *t)-274/37 *Sin(17/11-11 *t)-907/30 *Sin(36/23-5 *t)+623/15 *Sin(t+47/30)+684/29 *Sin(2 *t+212/45)+3864/25 *Sin(3 *t+63/40)+1513/78 *Sin(4 *t+19/12)+269/45 *Sin(6 *t+14/9)+66/25 *Sin(7 *t+155/33)+121/35 *Sin(8 *t+27/17)+44/13 *Sin(9 *t+35/22)+71/7 *Sin(10 *t+30/19)+87/40 *Sin(12 *t+57/37)+61/62 *Sin(13 *t+47/28)+43/65 *Sin(14 *t+31/20)+54/37 *Sin(15 *t+127/27)+56/27 *Sin(16 *t+30/19)+11843/35) *theta(67 *Pi-t) *theta(t-63 *Pi)+(-119/55 *Sin(65/43-13 *t)-78/11 *Sin(82/55-12 *t)-25/31 *Sin(36/23-11 *t)-70/9 *Sin(31/20-9 *t)-707/65 *Sin(47/30-7 *t)-953/22 *Sin(45/29-5 *t)+962/15 *Sin(t+113/72)+1091/30 *Sin(2 *t+212/45)+3177/26 *Sin(3 *t+27/17)+1685/22 *Sin(4 *t+43/27)+143/27 *Sin(6 *t+49/32)+203/27 *Sin(8 *t+27/17)+411/37 *Sin(10 *t+50/31)+65/27 *Sin(14 *t+33/20)+8/19 *Sin(15 *t+13/7)+3/11 *Sin(16 *t+43/33)-11597/35) *theta(63 *Pi-t) *theta(t-59 *Pi)+(-1/7 *Sin(41/81-30 *t)-8/27 *Sin(3/28-28 *t)-10/23 *Sin(3/26-26 *t)+2377/13 *Sin(t+33/28)+43/15 *Sin(2 *t+26/7)+131/18 *Sin(3 *t+3/25)+45/41 *Sin(4 *t+105/32)+43/14 *Sin(5 *t+87/23)+135/136 *Sin(6 *t+51/20)+51/14 *Sin(7 *t+118/43)+19/18 *Sin(8 *t+23/18)+49/23 *Sin(9 *t+25/12)+14/19 *Sin(10 *t+63/55)+54/49 *Sin(11 *t+68/41)+32/37 *Sin(12 *t+30/29)+5/12 *Sin(13 *t+43/24)+34/45 *Sin(14 *t+15/17)+13/30 *Sin(15 *t+67/23)+21/31 *Sin(16 *t+43/60)+25/62 *Sin(17 *t+89/34)+9/20 *Sin(18 *t+11/26)+4/17 *Sin(19 *t+55/28)+26/51 *Sin(20 *t+4/17)+2/33 *Sin(21 *t+247/62)+14/31 *Sin(22 *t+9/44)+5/26 *Sin(23 *t+113/34)+9/17 *Sin(24 *t+3/10)+4/25 *Sin(25 *t+99/32)+6/23 *Sin(27 *t+548/183)+10/33 *Sin(29 *t+129/37)+5/12 *Sin(31 *t+127/39)-9719/87) *theta(59 *Pi-t) *theta(t-55 *Pi)+(228/65 *Sin(t+116/33)+353/40 *Sin(2 *t+33/19)+107/24 *Sin(3 *t+58/33)+58/21 *Sin(4 *t+519/130)+19/15 *Sin(5 *t+45/37)+13/12 *Sin(6 *t+145/38)+43/42 *Sin(7 *t+25/99)+11/19 *Sin(8 *t+105/44)+203/19) *theta(55 *Pi-t) *theta(t-51 *Pi)+(-23/10 *Sin(22/17-4 *t)-159/17 *Sin(156/125-3 *t)+523/112 *Sin(t+80/21)+111/23 *Sin(2 *t+25/24)+92/79 *Sin(5 *t+57/32)+58/37 *Sin(6 *t+159/35)+18/31 *Sin(7 *t+27/43)-7563/28) *theta(51 *Pi-t) *_
                theta(t-47 *Pi)+(-76/17 *Sin(42/41-14 *t)-154/31 *Sin(37/38-11 *t)+10820/41 *Sin(t+25/34)+1476/31 *Sin(2 *t+36/19)+595/12 *Sin(3 *t+67/43)+3568/67 *Sin(4 *t+282/77)+974/59 *Sin(5 *t+40/19)+427/18 *Sin(6 *t+47/25)+454/23 *Sin(7 *t+20/27)+41/40 *Sin(8 *t+9/2)+139/22 *Sin(9 *t+99/26)+276/37 *Sin(10 *t+37/29)+113/25 *Sin(12 *t+61/30)+37/29 *Sin(13 *t+37/31)+51/19 *Sin(15 *t+127/34)+115/72 *Sin(16 *t+7/38)+162/43 *Sin(17 *t+67/21)+26/33 *Sin(18 *t+194/45)-3614/99) *theta(47 *Pi-t) *theta(t-43 *Pi)+(347/17 *Sin(t+3/13)+9951/41) *theta(43 *Pi-t) *theta(t-39 *Pi)+(760/29 *Sin(t+23/25)-6059/28) *theta(39 *Pi-t) *theta(t-35 *Pi)+(-106/41 *Sin(7/13-18 *t)-55/38 *Sin(13/29-16 *t)-173/19 *Sin(34/29-7 *t)-484/31 *Sin(13/16-5 *t)-1193/17 *Sin(97/83-2 *t)+6885/26 *Sin(t+41/48)+99/5 *Sin(3 *t+5/16)+751/36 *Sin(4 *t+73/18)+129/40 *Sin(6 *t+83/18)+327/31 *Sin(8 *t+17/23)+498/47 *Sin(9 *t+123/88)+298/49 *Sin(10 *t+54/25)+82/15 *Sin(11 *t+153/35)+106/27 *Sin(12 *t+3/32)+171/43 *Sin(13 *t+433/173)+36/11 *Sin(14 *t+98/33)+39/22 *Sin(15 *t+97/25)+68/37 *Sin(17 *t+157/34)-227/29) *theta(35 *Pi-t) *theta(t-31 *Pi)+(-2/15 *Sin(66/47-14 *t)-45/23 *Sin(5/9-11 *t)-151/43 *Sin(13/32-8 *t)-31/36 *Sin(24/19-7 *t)+2121/32 *Sin(t+45/38)+2085/47 *Sin(2 *t+299/88)+1321/43 *Sin(3 *t+72/25)+557/37 *Sin(4 *t+74/21)+205/17 *Sin(5 *t+27/23)+13/9 *Sin(6 *t+113/32)+35/17 *Sin(9 *t+7/22)+93/26 *Sin(10 *t+112/25)+11/14 *Sin(12 *t+58/17)+8/15 *Sin(13 *t+47/30)+33/20 *Sin(15 *t+32/25)+31/94 *Sin(16 *t+192/59)+35/31 *Sin(17 *t+51/77)+9473/34) *theta(31 *Pi-t) *theta(t-27 *Pi)+(-33/29 *Sin(27/55-12 *t)+388/13 *Sin(t+5/13)+2087/30 *Sin(2 *t+193/55)+1311/49 *Sin(3 *t+133/30)+993/41 *Sin(4 *t+134/31)+175/17 *Sin(5 *t+73/29)+83/23 *Sin(6 *t+28/33)+9/19 *Sin(7 *t+73/36)+101/32 *Sin(8 *t+57/28)+51/25 *Sin(9 *t+106/39)+47/28 *Sin(10 *t+129/47)+17/29 *Sin(11 *t+33/17)+27/22 *Sin(13 *t+155/86)+108/65 *Sin(14 *t+8/27)+9/16 *Sin(15 *t+44/13)+11/14 *Sin(16 *t+3/19)+11/23 *Sin(17 *t+106/23)+9/64 *Sin(18 *t+97/22)-10004/35) *theta(27 *Pi-t) *theta(t-23 *Pi)+(-18/13 *Sin(7/50-18 *t)-7/5 *Sin(1/10-16 *t)-51/25 *Sin(18/19-12 *t)-219/35 *Sin(7/30-10 *t)-158/43 *_
                Sin(40/37-6 *t)-512/25 *Sin(13/16-4 *t)-289/29 *Sin(68/67-2 *t)+18315/101 *Sin(t+29/18)+664/31 *Sin(3 *t+61/23)+48/11 *Sin(5 *t+84/67)+489/49 *Sin(7 *t+11/25)+397/33 *Sin(8 *t+8/19)+73/12 *Sin(9 *t+9/53)+194/41 *Sin(11 *t+17/14)+2/3 *Sin(13 *t+149/50)+43/29 *Sin(14 *t+91/31)+61/35 *Sin(15 *t+131/56)+29/37 *Sin(17 *t+1/19)+49/43 *Sin(19 *t+65/24)+15/19 *Sin(20 *t+88/21)+11/38 *Sin(21 *t+217/50)+3917/10) *theta(23 *Pi-t) *theta(t-19 *Pi)+(-8/9 *Sin(12/23-16 *t)-504/53 *Sin(8/29-8 *t)-635/43 *Sin(32/37-4 *t)-307/41 *Sin(8/27-3 *t)-20292/91 *Sin(16/19-t)+483/19 *Sin(2 *t+41/13)+108/23 *Sin(5 *t+70/29)+74/35 *Sin(6 *t+145/34)+287/43 *Sin(7 *t+69/16)+254/39 *Sin(9 *t+5/27)+19/4 *Sin(10 *t+37/30)+129/46 *Sin(11 *t+75/32)+24/19 *Sin(12 *t+71/46)+125/52 *Sin(13 *t+87/44)+46/27 *Sin(14 *t+40/31)+26/29 *Sin(15 *t+106/27)+25/63 *Sin(17 *t+53/12)+23/22 *Sin(18 *t+9/29)+3/35 *Sin(19 *t+205/103)+200/201 *Sin(20 *t+22/25)+8/31 *Sin(21 *t+77/25)-15195/29) *theta(19 *Pi-t) *theta(t-15 *Pi)+(-15/23 *Sin(22/23-35 *t)-21/26 *Sin(13/40-30 *t)-71/64 *Sin(16/19-29 *t)-97/29 *Sin(15/41-23 *t)-57/17 *Sin(54/35-16 *t)-79/25 *Sin(41/39-14 *t)-24/11 *Sin(3/8-13 *t)-149/17 *Sin(21/62-6 *t)-613/31 *Sin(16/17-2 *t)+6033/20 *Sin(t+24/17)+631/16 *Sin(3 *t+127/30)+463/31 *Sin(4 *t+71/28)+94/23 *Sin(5 *t+98/25)+45/11 *Sin(7 *t+31/10)+39/23 *Sin(8 *t+163/39)+23/22 *Sin(9 *t+42/17)+167/44 *Sin(10 *t+232/231)+233/49 *Sin(11 *t+29/45)+194/129 *Sin(12 *t+3/5)+166/37 *Sin(15 *t+83/29)+123/35 *Sin(17 *t+136/35)+47/26 *Sin(18 *t+64/25)+72/35 *Sin(19 *t+41/14)+56/31 *Sin(20 *t+48/35)+63/25 *Sin(21 *t+2/5)+100/37 *Sin(22 *t+13/15)+4/3 *Sin(24 *t+59/19)+17/25 *Sin(25 *t+15/38)+51/19 *Sin(26 *t+68/19)+11/27 *Sin(27 *t+228/91)+19/14 *Sin(28 *t+31/9)+4/13 *Sin(31 *t+14/55)+31/37 *Sin(32 *t+2/31)+150/151 *Sin(33 *t+58/21)+41/32 *Sin(34 *t+26/11)+4/3 *Sin(36 *t+25/18)-6956/53) *theta(15 *Pi-t) *theta(t-11 *Pi)+(4337/36 *Sin(t+45/29)+265/18) *theta(11 *Pi-t) *theta(t-7 *Pi)+(-23/21 *Sin(31/61-t)-1152/11) *theta(7 *Pi-t) *theta(t-3 *Pi)+(3314/27 *Sin(t+30/31)+65/31 *Sin(2 *t+26/23)-1467/5) *theta(3 *Pi-t) *theta(t+Pi)) *theta(Sqr(Sgn(Sin(t/2))))
                
                y = ((-9/23 *Sin(38/25-6 *t)-67/38 *Sin(36/23-3 *t)+31/30 *Sin(t+14/9)+409/9 *Sin(2 *t+74/47)+493/141 *Sin(4 *t+85/54)+14/17 *Sin(5 *t+75/16)+5/46 *Sin(7 *t+21/13)+33/23 *Sin(8 *t+74/47)+14536/41) *theta(71 *Pi-t) *theta(t-67 *Pi)+(-89/29 *Sin(59/38-17 *t)-5/11 *Sin(14/9-16 *t)-99/40 *Sin(58/37-15 *t)-59/7 *Sin(25/16-11 *t)-2/35 *Sin(8/41-10 *t)-381/26 *Sin(25/16-9 *t)-67/21 *Sin(17/11-8 *t)-1706/37 *Sin(36/23-5 *t)-29/9 *Sin(29/19-4 *t)-851/29 *Sin(58/37-3 *t)+1991/30 *Sin(t+96/61)+528/17 *Sin(2 *t+85/54)+89/67 *Sin(6 *t+37/24)+102/13 *Sin(7 *t+80/17)+17/16 *Sin(12 *t+91/58)+35/12 *Sin(13 *t+37/23)+127/27 *Sin(14 *t+27/17)-26576/29) *theta(67 *Pi-t) *theta(t-63 *Pi)+(-29/14 *Sin(47/33-16 *t)-35/22 *Sin(75/52-15 *t)-236/63 *Sin(16/11-14 *t)-41/6 *Sin(34/23-13 *t)-236/29 *Sin(46/31-12 *t)-167/28 *Sin(55/37-11 *t)-259/33 *Sin(76/51-10 *t)-414/73 *Sin(56/37-9 *t)-121/28 *Sin(17/11-7 *t)-177/32 *Sin(61/41-6 *t)-1499/41 *Sin(48/31-5 *t)-647/23 *Sin(25/16-3 *t)+610/13 *Sin(t+30/19)+1474/31 *Sin(2 *t+30/19)+807/41 *Sin(4 *t+41/26)+208/31 *Sin(8 *t+43/27)-16147/17) *theta(63 *Pi-t) *theta(t-59 *Pi)+(-12/41 *Sin(1/4-28 *t)-11/43 *Sin(9/14-26 *t)-17/41 *Sin(14/13-24 *t)-22/31 *Sin(17/67-22 *t)-7/10 *Sin(64/63-19 *t)-69/41 *Sin(39/31-14 *t)-86/25 *Sin(22/41-12 *t)-87/52 *Sin(31/27-9 *t)-23/15 *Sin(13/33-7 *t)-25/17 *Sin(22/25-3 *t)+159/28 *Sin(t+249/248)+571/20 *Sin(2 *t+23/26)+109/36 *Sin(4 *t+29/18)+161/58 *Sin(5 *t+31/23)+147/26 *Sin(6 *t+31/19)+199/35 *Sin(8 *t+37/42)+96/19 *Sin(10 *t+17/47)+64/27 *Sin(11 *t+337/75)+15/7 *Sin(13 *t+157/44)+Sin(15 *t+101/33)+5/38 *Sin(16 *t+1/28)+11/56 *Sin(17 *t+23/37)+6/11 *Sin(18 *t+8/9)+91/136 *Sin(20 *t+3/19)+55/54 *Sin(21 *t+102/25)+15/16 *Sin(23 *t+118/31)+22/27 *Sin(25 *t+49/15)+3/8 *Sin(27 *t+27/8)+22/43 *Sin(29 *t+57/16)+10/19 *Sin(30 *t+50/83)+5/31 *Sin(31 *t+121/38)+2727/23) *theta(59 *Pi-t) *theta(t-55 *Pi)+(-41/31 *Sin(23/21-4 *t)-85/14 *Sin(17/32-t)+407/35 *Sin(2 *t+75/22)+21/10 *Sin(3 *t+41/14)+53/54 *Sin(5 *t+54/25)+31/61 *Sin(6 *t+124/27)+5/36 *Sin(7 *t+3/19)+19/31 *Sin(8 *t+144/31)+10393/23) *theta(55 *Pi-t) *theta(t-51 *Pi)+(-36/41 *Sin(5/18-6 *t)+83/35 *_
                Sin(t+95/28)+43/37 *Sin(2 *t+66/17)+165/13 *Sin(3 *t+27/53)+79/19 *Sin(4 *t+9/17)+37/24 *Sin(5 *t+190/63)+57/58 *Sin(7 *t+267/100)+13545/31) *theta(51 *Pi-t) *theta(t-47 *Pi)+(-123/47 *_
                Sin(19/15-18 *t)-59/29 *Sin(1/49-16 *t)-213/37 *Sin(29/22-13 *t)-381/40 *Sin(4/29-11 *t)-168/29 *Sin(6/11-10 *t)-1233/44 *Sin(3/19-3 *t)-711/7 *Sin(1/39-2 *t)-5171/26 *Sin(12/19-t)+2965/57 *Sin(4 *t+89/28)+347/21 *Sin(5 *t+23/93)+1087/69 *Sin(6 *t+4/31)+760/37 *Sin(7 *t+172/53)+333/19 *Sin(8 *t+7/13)+325/81 *Sin(9 *t+96/55)+53/17 *Sin(12 *t+138/49)+73/40 *Sin(14 *t+92/67)+47/31 *Sin(15 *t+81/19)+7/11 *Sin(17 *t+29/30)-3017/19) *theta(47 *Pi-t) *theta(t-43 *Pi)+(-713/27 *Sin(22/17-t)-36840/41) *theta(43 *Pi-t) *theta(t-39 *Pi)+(-675/23 *Sin(13/16-t)-17750/19) *theta(39 *Pi-t) *theta(t-35 *Pi)+(-39/29 *Sin(11/16-17 *t)-102/37 *Sin(8/49-11 *t)-95/34 *Sin(4/13-9 *t)-71/22 *Sin(7/12-8 *t)-194/17 *Sin(29/23-7 *t)-2531/25 *Sin(13/36-t)+601/19 *Sin(2 *t+264/61)+232/5 *Sin(3 *t+53/13)+309/40 *Sin(4 *t+29/10)+266/39 *Sin(5 *t+3/16)+71/95 *Sin(6 *t+50/37)+281/44 *Sin(10 *t+33/43)+29/15 *Sin(12 *t+105/29)+39/25 *Sin(13 *t+109/36)+24/11 *Sin(14 *t+51/38)+19/9 *Sin(15 *t+38/23)+43/29 *Sin(16 *t+4)+53/74 *Sin(18 *t+74/25)-45956/91) *theta(35 *Pi-t) *theta(t-31 *Pi)+(-25/32 *Sin(4/13-15 *t)-40/43 *Sin(11/19-13 *t)-12727/115 *Sin(83/84-t)+1762/31 *Sin(2 *t+66/29)+905/78 *Sin(3 *t+46/25)+209/25 *Sin(4 *t+104/37)+103/27 *Sin(5 *t+32/17)+121/60 *Sin(6 *t+143/37)+29/7 *Sin(7 *t+45/13)+41/36 *Sin(8 *t+271/58)+125/62 *Sin(9 *t+152/33)+118/79 *Sin(10 *t+56/25)+41/24 *Sin(11 *t+108/25)+22/45 *Sin(12 *t+116/41)+43/35 *Sin(14 *t+68/19)+1/15 *Sin(16 *t+26/11)+13/43 *Sin(17 *t+53/25)-29541/41) *theta(31 *Pi-t) *theta(t-27 *Pi)+(-235/21 *Sin(5/46-5 *t)-133/13 *Sin(3/29-4 *t)-437/37 *Sin(50/37-3 *t)-2785/19 *Sin(5/4-t)+724/17 *Sin(2 *t+68/29)+211/141 *Sin(6 *t+83/44)+41/14 *Sin(7 *t+135/32)+83/20 *Sin(8 *t+135/38)+123/62 *Sin(9 *t+136/33)+304/203 *Sin(10 *t+166/47)+59/44 *Sin(11 *t+5/29)+25/36 *Sin(12 *t+102/49)+13/12 *Sin(13 *t+101/41)+23/13 *Sin(14 *t+73/26)+5/32 *Sin(15 *t+85/27)+41/61 *Sin(16 *t+56/25)+1/7 *Sin(17 *t+10/17)+7/18 *Sin(18 *t+134/51)-8059/11) *theta(27 *Pi-t) *theta(t-23 *Pi)+(-32/23 *Sin(20/27-18 *t)-31/20 *Sin(19/17-17 *t)-89/38 *Sin(30/23-13 *t)-529/122 *Sin(22/15-10 *t)-151/35 *Sin(2/27-8 *t)-417/28 *_
                Sin(43/29-4 *t)-851/35 *Sin(3/14-3 *t)-13229/88 *Sin(31/52-t)+425/12 *Sin(2 *t+37/18)+397/30 *Sin(5 *t+37/17)+299/31 *Sin(6 *t+122/41)+301/38 *Sin(7 *t+58/35)+240/43 *Sin(9 *t+118/27)+39/28 *Sin(11 *t+27/34)+82/165 *Sin(12 *t+58/27)+29/26 *Sin(14 *t+77/27)+47/19 *Sin(15 *t+7/4)+46/17 *Sin(16 *t+79/22)+46/35 *Sin(19 *t+43/21)+23/28 *Sin(20 *t+105/31)+27/23 *Sin(21 *t+184/41)-12036/55) *theta(23 *Pi-t) *theta(t-19 *Pi)+(-16/37 *Sin(42/43-19 *t)-21/23 *Sin(37/26-18 *t)-23/17 *Sin(25/56-17 *t)-46/61 *Sin(34/45-16 *t)-161/22 *Sin(1/2-6 *t)-472/43 *Sin(15/23-5 *t)-620/29 *Sin(43/60-3 *t)+2821/25 *Sin(t+167/39)+2605/88 *Sin(2 *t+89/30)+449/43 *Sin(4 *t+66/25)+37/24 *Sin(7 *t+37/33)+107/13 *Sin(8 *t+175/52)+341/128 *Sin(9 *t+188/41)+32/15 *Sin(10 *t+12/19)+208/43 *Sin(11 *t+44/73)+122/53 *Sin(12 *t+41/39)+69/40 *Sin(13 *t+9/32)+34/23 *Sin(14 *t+208/45)+19/11 *Sin(15 *t+11/36)+17/19 *Sin(20 *t+111/26)+4/15 *Sin(21 *t+26/25)-10055/37) *theta(19 *Pi-t) *theta(t-15 *Pi)+(-59/44 *Sin(173/172-36 *t)-73/31 *Sin(21/53-30 *t)-23/11 *Sin(13/12-29 *t)-133/50 *Sin(23/19-28 *t)-125/29 *Sin(108/77-24 *t)-122/33 *Sin(1/19-21 *t)-238/79 *Sin(4/7-16 *t)-141/16 *Sin(34/37-9 *t)-45/8 *Sin(16/27-7 *t)+11594/23 *Sin(t+1768/589)+1582/37 *Sin(2 *t+28/25)+771/38 *Sin(3 *t+107/31)+863/22 *Sin(4 *t+87/22)+485/29 *Sin(5 *t+63/25)+27/8 *Sin(6 *t+75/76)+106/19 *Sin(8 *t+20/23)+54/17 *Sin(10 *t+10/49)+206/61 *Sin(11 *t+106/29)+65/14 *Sin(12 *t+81/29)+80/11 *Sin(13 *t+49/43)+41/29 *Sin(14 *t+1/114)+17/38 *Sin(15 *t+97/43)+97/20 *Sin(17 *t+98/23)+77/30 *Sin(18 *t+49/19)+44/13 *Sin(19 *t+53/16)+44/19 *Sin(20 *t+95/23)+135/29 *Sin(22 *t+27/25)+243/121 *Sin(23 *t+23/17)+15/4 *Sin(25 *t+10/17)+50/13 *Sin(26 *t+75/32)+308/47 *Sin(27 *t+253/76)+65/19 *Sin(31 *t+7/15)+92/33 *Sin(32 *t+26/11)+17/15 *Sin(33 *t+74/23)+8/15 *Sin(34 *t+64/27)+17/27 *Sin(35 *t+215/72)+16757/30) *theta(15 *Pi-t) *theta(t-11 *Pi)+(1805/16 *Sin(t+1/303)+19936/43) *theta(11 *Pi-t) *theta(t-7 *Pi)+(374/65 *Sin(t+149/47)+11537/27) *theta(7 *Pi-t) *theta(t-3 *Pi)+(-15391/135 *Sin(35/71-t)+112/53 *Sin(2 *t+66/29)+13507/30) *theta(3 *Pi-t) *theta(t+Pi)) *theta(Sqr(Sgn(Sin(t/2))))
      
                oVertexA(N).x = x*0.04
                oVertexA(N).y = y*0.04
                oColorA(N).r = 255 : oColorA(N).g = 0 : oColorA(N).b = 0 
              
                t = t + 0.01 
                N = N + 1   
      end while
        
      terminate    
      "        
      
      ' -- Pass the source
      O2_Asmo src
      
      ' -- Check for errors
      If Len(o2_error) Then
        MsgBox 0, o2_error : Stop
      End If               
      
      ' -- Execute
      o2_exec 
    
    End Function
    
    It is also possible to define functions in oxygen, and call them from ThinBASIC, see thinBasic\SampleScripts\Oxygen\Examples\General\O2Functions.tBasic example.

    Oxygen compiler is so fast, that you don't need to even create DLLs! (But you can, if you want)


    Petr
    Last edited by ErosOlmi; 28-11-2015 at 10:21.
    Learn 3D graphics with ThinBASIC, learn TBGL!
    Windows 7 64bit - Intel Core 2 Duo T6600 @ 2.2GHz - 4 GB RAM - NVIDIA GeForce G210M 512MB
    Windows 8 64bit - Intel Core i5-3350P @ 3.1GHz - 8 GB RAM - NVIDIA GeForce GT640 3GB

  4. #4
    Thanks Petr for the key post about using oxygen, i was worrying about how to connect the variables or if it is reciprocal or not (still to see this) it is much more easier than using outside dlls, i have interested in Dim oVertexA(30156) At #VertexA As TBGL_TVECTOR3F so this is the way we link the two variables, it seems Dim oVertexA(0)...Dim oColorA(0).. works also, seems it is expanding as necessary depending on the subsequent code .
    i forget to ask regarding the calling freebasic dll, in the thinbasic code declaration there is:
    Declare Sub TestUDT Lib "dll_udt_VertexArrays.dll" Alias "TestUDT@8" (ByRef lpUDT As Long, ByRef lpColorUDT As Long) '@4 is 4 bytes for UDT address so we need here 4*2=8
    i am still confused about the TestUDT@8 : the addition of @8 even it is explained in the http://rapidq.phatcode.net/tutorial/..._tutorial.html search page with "mangled name" . is it the same thing we must use if the dll made by powerbasic ??
    thanks Petr again for your precious code about oxygen usage.

  5. #5
    Super Moderator Petr Schreiber's Avatar
    Join Date
    Aug 2005
    Location
    Brno - Czech Republic
    Posts
    6,839
    Blog Entries
    3
    Rep Power
    697
    Hi Primo,

    I am happy it helped
    The DLLs made by PowerBASIC do not need the @ notation at all.


    Petr
    Learn 3D graphics with ThinBASIC, learn TBGL!
    Windows 7 64bit - Intel Core 2 Duo T6600 @ 2.2GHz - 4 GB RAM - NVIDIA GeForce G210M 512MB
    Windows 8 64bit - Intel Core i5-3350P @ 3.1GHz - 8 GB RAM - NVIDIA GeForce GT640 3GB

  6. #6
    thinBasic author ErosOlmi's Avatar
    Join Date
    Sep 2004
    Location
    Milan - Italy
    Age
    51
    Posts
    8,343
    Blog Entries
    2
    Rep Power
    10
    Thanks a lot Petr for Oxygen example.
    Sometimes I forget this precious weapon we have in thinBasic arsenal able to burst execution of some part of slow scripts and reach execution speed of compiled applications.

    Oxygen Just In Time Compiler module is a generous present of Charles Pegge.
    Full info can be found in Charles web site at: http://www.oxygenbasic.org/ and his forum: http://www.oxygenbasic.org/forum/

    Have fun
    www.thinbasic.com | www.thinbasic.com/community/ | psch.thinbasic.com
    Win10Pro 64bit - 8GB Ram - Intel i7 M620 2.67GHz - NVIDIA Quadro FX1800M 1GB

Similar Threads

  1. Replies: 4
    Last Post: 04-03-2014, 16:05
  2. Fun with Riemann, problems with Freebasic DLLs
    By RobbeK in forum TBGL General
    Replies: 14
    Last Post: 25-12-2013, 21:52
  3. Basic Compilers
    By John Spikowski in forum Shout Box Area
    Replies: 25
    Last Post: 17-09-2013, 19:45
  4. Monte Carlo calculation of volumes of n-balls
    By dcromley in forum Math: all about
    Replies: 2
    Last Post: 11-12-2011, 17:55
  5. calculation failure?
    By largo_winch in forum thinBasic General
    Replies: 1
    Last Post: 19-07-2011, 13:46

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •