suggest adding -O2 to makeline

[jack]

in the directory qb64/internal/c are three makeline text files, makeline_win.txt, makeline_lnx.txt and makeline_osx.txt
I suggest adding -O2 after g++, that way your programs will be compiled with optimization
-O2 is a safe near optimal setting in my opinion and your programs will run much faster.
as an example here's the nbody program I translated to QB64
time before adding -O2 to makeline_osx.txt 138.84375 seconds, after adding -O2, 42.6875 seconds, that's 3.25 times faster

Code: QB64: [Select]

1. ' https://go.googlesource.com/exp/+/master/shootout/nbody.c
2. ' The Computer Language Benchmarks Game
3. ' https://benchmarksgame-team.pages.debian.net/benchmarksgame/
4.  
5. ' contributed by Christoph Bauer
6. '
7. ' translated to QB64 by Jack
8. ' modified a bit to avoid using pointer to array
9.  
10. declare FUNCTION main# (n AS LONG)
11.  
12. PRINT STR$(main(50000000)) + " seconds"
13. END
14.  
15. CONST pi = 3.141592653589793
16. CONST solar_mass = (4 * pi) * pi
17. CONST days_per_year = 365.24
18.  
19. TYPE planet
20.     x AS DOUBLE
21.     y AS DOUBLE
22.     z AS DOUBLE
23.     vx AS DOUBLE
24.     vy AS DOUBLE
25.     vz AS DOUBLE
26.     mass AS DOUBLE
27. END TYPE
28.  
29. SUB advance (nbodies AS LONG, bodies() AS planet, dt AS DOUBLE)
30.     DIM i AS LONG, j AS LONG
31.     DIM dx AS DOUBLE, dy AS DOUBLE, dz AS DOUBLE, distance AS DOUBLE, mag AS DOUBLE
32.     FOR i = 0 TO nbodies - 1
33.         FOR j = i + 1 TO nbodies - 1
34.             dx = bodies(i).x - bodies(j).x
35.             dy = bodies(i).y - bodies(j).y
36.             dz = bodies(i).z - bodies(j).z
37.             distance = SQR(((dx * dx) + (dy * dy)) + (dz * dz))
38.             mag = dt / ((distance * distance) * distance)
39.             bodies(i).vx = bodies(i).vx - (dx * bodies(j).mass) * mag
40.             bodies(i).vy = bodies(i).vy - (dy * bodies(j).mass) * mag
41.             bodies(i).vz = bodies(i).vz - (dz * bodies(j).mass) * mag
42.             bodies(j).vx = bodies(j).vx + (dx * bodies(i).mass) * mag
43.             bodies(j).vy = bodies(j).vy + (dy * bodies(i).mass) * mag
44.             bodies(j).vz = bodies(j).vz + (dz * bodies(i).mass) * mag
45.         NEXT
46.     NEXT
47.     FOR i = 0 TO nbodies - 1
48.         bodies(i).x = bodies(i).x + dt * bodies(i).vx
49.         bodies(i).y = bodies(i).y + dt * bodies(i).vy
50.         bodies(i).z = bodies(i).z + dt * bodies(i).vz
51.     NEXT
52. END SUB
53.  
54. FUNCTION energy# (nbodies AS LONG, bodies() AS planet)
55.     DIM i AS LONG, j AS LONG
56.     DIM e AS DOUBLE, dx AS DOUBLE, dy AS DOUBLE, dz AS DOUBLE, distance AS DOUBLE, mag AS DOUBLE
57.     e = 0.0
58.     FOR i = 0 TO nbodies - 1
59.         e = e + (0.5 * bodies(i).mass) * (((bodies(i).vx * bodies(i).vx) + (bodies(i).vy * bodies(i).vy)) + (bodies(i).vz * bodies(i).vz))
60.         FOR j = i + 1 TO nbodies - 1
61.             dx = bodies(i).x - bodies(j).x
62.             dy = bodies(i).y - bodies(j).y
63.             dz = bodies(i).z - bodies(j).z
64.             distance = SQR(((dx * dx) + (dy * dy)) + (dz * dz))
65.             e = e - (bodies(i).mass * bodies(j).mass) / distance
66.         NEXT
67.     NEXT
68.     energy# = e
69. END FUNCTION
70.  
71. SUB offset_momentum (nbody AS LONG, bodies() AS planet)
72.     DIM px AS DOUBLE, py AS DOUBLE, pz AS DOUBLE
73.     DIM I AS LONG
74.     FOR I = 0 TO nbody - 1
75.         px = px + bodies(I).vx * bodies(I).mass
76.         py = py + bodies(I).vy * bodies(I).mass
77.         pz = pz + bodies(I).vz * bodies(I).mass
78.     NEXT
79.     bodies(0).vx = (-px) / ((4 * pi) * pi)
80.     bodies(0).vy = (-py) / ((4 * pi) * pi)
81.     bodies(0).vz = (-pz) / ((4 * pi) * pi)
82. END SUB
83.  
84.  
85. FUNCTION main# (n AS LONG)
86.     CONST NBODIES = 5
87.     DIM bodies(0 TO 4) AS planet
88.     bodies(0).x = 0: bodies(0).y = 0: bodies(0).z = 0: bodies(0).vx = 0: bodies(0).vy = 0: bodies(0).vz = 0: bodies(0).mass = (4 * pi) * pi
89.     bodies(1).x = 4.84143144246472090D+00: bodies(1).y = -1.16032004402742839D+00: bodies(1).z = -1.03622044471123109D-01: bodies(1).vx = 1.66007664274403694D-03 * days_per_year: bodies(1).vy = 7.69901118419740425D-03 * days_per_year: bodies(1).vz = (-6.90460016972063023D-05) * days_per_year: bodies(1).mass = 9.54791938424326609D-04 * ((4 * pi) * pi)
90.     bodies(2).x = 8.34336671824457987D+00: bodies(2).y = 4.12479856412430479D+00: bodies(2).z = -4.03523417114321381D-01: bodies(2).vx = (-2.76742510726862411D-03) * days_per_year: bodies(2).vy = 4.99852801234917238D-03 * days_per_year: bodies(2).vz = 2.30417297573763929D-05 * days_per_year: bodies(2).mass = 2.85885980666130812D-04 * ((4 * pi) * pi)
91.     bodies(3).x = 1.28943695621391310D+01: bodies(3).y = -1.51111514016986312D+01: bodies(3).z = -2.23307578892655734D-01: bodies(3).vx = 2.96460137564761618D-03 * days_per_year: bodies(3).vy = 2.37847173959480950D-03 * days_per_year: bodies(3).vz = (-2.96589568540237556D-05) * days_per_year: bodies(3).mass = 4.36624404335156298D-05 * ((4 * pi) * pi)
92.     bodies(4).x = 1.53796971148509165D+01: bodies(4).y = -2.59193146099879641D+01: bodies(4).z = 1.79258772950371181D-01: bodies(4).vx = 2.68067772490389322D-03 * days_per_year: bodies(4).vy = 1.62824170038242295D-03 * days_per_year: bodies(4).vz = (-9.51592254519715870D-05) * days_per_year: bodies(4).mass = 5.15138902046611451D-05 * ((4 * pi) * pi)
93.  
94.     DIM i AS LONG
95.     DIM t AS DOUBLE
96.     t = TIMER
97.     CALL offset_momentum(NBODIES, bodies())
98.     PRINT USING "##.#########"; energy#(NBODIES, bodies())
99.     FOR i = 1 TO n
100.         CALL advance(NBODIES, bodies(), 0.01)
101.     NEXT
102.     PRINT USING "##.#########"; energy#(NBODIES, bodies())
103.     main# = TIMER - t
104. END FUNCTION
105.