在大马IT工程师有前途吗

tornado

aquamax 发表于 6-7-2024 06:12 PM
可能现代化了，安迪手抄然后回家进system

直接用手机下单了，外加一粒bluetooth printer，买了直接打印收据~

lcw9988

tornado 发表于 6-7-2024 07:15 PM
不是我不要看，而是看了对我没有意义，
字体又朦又小，整7-8个loop，至少也要trace了，才能看到data flow ...

你给出的才几行? 你的有data flow ? 我又敢作出回应?

我的一百行以上你一点都看不出也回应不了? 宽以律己，严以待人, 明显是找借口而已！

tornado

lcw9988 发表于 6-7-2024 07:26 PM
你给出的才几行? 你的有data flow ? 我又敢作出回应?

我的一百行以上你一点都看不出也回应不了? 宽以律 ...

你找回那个教你的人帮你看吧，周末我去追剧更爽~

lcw9988

tornado 发表于 6-7-2024 07:30 PM
你找回那个教你的人帮你看吧，周末我去追剧更爽~

我无须再问别人, 算法是我的, 我当然知道怎样运行, 现是你没勇气回应啊 !

lcw9988

tornado 发表于 6-7-2024 07:20 PM
直接用手机下单了，外加一粒bluetooth printer，买了直接打印收据~

总让人觉得你很熟悉整個操作程序哦

tornado

lcw9988 发表于 6-7-2024 07:35 PM
总让人觉得你很熟悉整個操作程序哦

我不做非法的，不过我以前的老板有做，

机器编程也不是我的主打，在我的项目里面不到10%~

lcw9988

tornado 发表于 6-7-2024 07:46 PM
我不做非法的，不过我以前的老板有做，

机器编程也不是我的主打，在我的项目里面不到10%~

我没说你做啊, 熟悉操作方法並不代表你有做, 别慌 !

tornado

lcw9988 发表于 6-7-2024 07:53 PM
我没说你做啊, 熟悉操作方法並不代表你有做, 别慌 !

我也没说你说啊，我只是强调非法的，我不碰的~

lcw9988

tornado 发表于 7-7-2024 05:56 AM
我也没说你说啊，我只是强调非法的，我不碰的~

如果你认为我没说你, 又何必一大早你就做出反应回复我? 嘴巴没说但你这种反应说明你真的有点慌了 !

你嘴巴和行动不一致, 心里有鬼越描起黑了, 哈~

tornado

lcw9988 发表于 7-7-2024 07:10 AM
如果你认为我没说你, 又何必一大早你就做出反应回复我? 嘴巴没说但你这种反应说明你真的有点慌了 !

你 ...

我一向来早睡早起，整理好我的工作，就会来看看贴子，回复贴子，
历史回复记录可看，行得正，坐得直~

其实有时候，一根手指指向他人时，三个手指是指向自己的~

lcw9988

tornado 发表于 7-7-2024 08:43 AM
我一向来早睡早起，整理好我的工作，就会来看看贴子，回复贴子，
历史回复记录可看，行得正，坐得直~:love ...

哈哈~  我几时说你做过和指向你了? 到目前为止, 我一直也都这么认为你没做, 你上一个帖已強调我没说过,  又忘了?

我也没说你说啊，我只是强调非法的，我不碰的~

但你的反应让人觉得你在意, 没做过的人不必在意的, 坐得直不直只有自己知道, 再说一次, 我不是说你啊 !

Dogs1985

tornado 发表于 6-7-2024 09:13 AM
不就高频交易分析程式，问题是你能给出一个理由，我为什么要去了解你的程序？

老实说，你程序的var n ...

虽然不懂，但总觉得你好像对的。

是不是类似一个 portable 的 hdd，
假如 enclosure 接电脑的 cable 是可拆，坏了可以买回同样的 cable 更换。
假如 enclosure 接电脑的 cable 是一体，坏了就得更换整个 enclosure。

编程也是如此，是这样解吗？

lcw9988

Dogs1985 发表于 7-7-2024 10:24 AM
虽然不懂，但总觉得你好像对的。

是不是类似一个 portable 的 hdd，

我的软件是自用的, 每一个细节自己很清楚, 不必什么模块式, 要改能精准直接去改那一部份, 不必什么 subroutine/sub module的.

用multi threading.....更快!

tornado

Dogs1985 发表于 7-7-2024 10:24 AM
虽然不懂，但总觉得你好像对的。

是不是类似一个 portable 的 hdd，

是的，把他分解出来的好处很多，除了readability和maintainability，还有一个重要的reusability，这是编程的基本概念~

我给你一个简单的例子，如果我要写一个程序，把2个数目做一个算法，以下是没有sub function的做法：

1. class Program
   
2. {
   
3.     static void Main(string[] args)
   
4.     {
   
5.         int a = 5;
   
6.         int b = 10;
   
7.         int sum1 = a + b;
   
8.         Console.WriteLine("Result: " + sum1);
   
9. 
   
10.         int c = 7;
    
11.         int d = 3;
    
12.         int sum2 = c + d;
    
13.         Console.WriteLine("Result: " + sum2);
    
14.     }
    
15. }
    

复制代码

以下是有sub function的做法：

1. class Program
   
2. {
   
3.     static void Main(string[] args)
   
4.     {
   
5.         Console.WriteLine("Result: " + Calculate(5, 10));
   
6.         Console.WriteLine("Result: " + Calculate(7, 3));
   
7.     }
   
8. 
   
9.     static int Calculate(int num1, int num2)
   
10.     {
    
11.         return num1 + num2;
    
12.     }
    
13. }
    

复制代码

虽然两个都给出了同样的结果，不过第2个方法明显聪明多了，
他不止让程式的行数变少了，而且读起来也很舒服(readability)，
我们更可以在程式任何地方，使用这个Calculate()的function (reusability)，
要改formula也方便，譬如我要改去乘，就把num1 + num2改去num1 * num2，
我们不用去找每一行来改（maintainability），工作也变轻松了~

lcw9988

tornado 发表于 7-7-2024 02:51 PM
是的，把他分解出来的好处很多，除了readability和maintainability，还有一个重要的reusability，这是编 ...

別拿简单的例子忽悠外行人啦, 简单的当然容易简化啦, 我的代码像你说的这么简单吗? 整10个loops 环环相扣 :-

1) 要怎样简化? 谁能简化这10 loops又证实快20%我愿意付5万, 快50%以上我付10万 ! 讲到做到 !
2) 说到你这么历害, 为什么没有勇气向我代码给出评论和回应?

用我的例子, 要改的就score那两行, 再写一个 subroutine就是浪费时间 !   

1. 
   
2.         
   
3.     std::random_device rd;     // only used once to initialise (seed) engine
   
4.     std::mt19937 rng(rd());    // random-number engine used (Mersenne-Twister in this case)
   
5.     std::uniform_int_distribution<int> uni(1, 99); // guaranteed unbiased
   
6.         int const1 = 0;
   
7.         long ns = 0;
   
8.         for (int s = 1; s <= trial8; s++) { ////START OF TRIALS
   
9.                 cout << s << endl;
   
10.                 //long share[14][4] = { 0 };
    
11.                 for (int i = 1; i <= cardreq; i++) {
    
12.                         auto random_integer = uni(rng);
    
13.            
    
14.             int r = random_integer;
    
15.             long temp = b[i];
    
16.             b[i] = b[r];
    
17.             b[r] = temp;
    
18. 
    
19.             long temp1 = bsx[i];
    
20.             bsx[i] = bsx[r];
    
21.             bsx[r] = temp1;
    
22.                 }
    
23.                 for (int i = 0; i <= 5; i++) {
    
24.                         codes201[i] = 0;
    
25.                         codes101[i] = 0;
    
26.                         codes41[i] = 0;
    
27.                         codes15[i] = 0;
    
28.                         codes11[i] = 0;
    
29.                         codes9[i] = 0;
    
30.                         codes7[i] = 0;
    
31.                         codes5[i] = 0;
    
32.                         codes3[i] = 0;
    
33.                         codes1[i] = 0;
    
34.                         codes[i] = 0;
    
35.                         codes1[i] = 0;
    
36.                         codes3[i] = 0;
    
37.                         ev[i] = 0;
    
38.                 }
    
39.                 culev[0] = 0;
    
40.                 culev[1] = 0;
    
41.                 culev[2] = 0;
    
42.                 culev[3] = 0;
    
43.                 culev[4] = 0;
    
44.                 culev[5] = 0;
    
45.                 for (int i = 1; i <= 4; i++) {
    
46.                         for (int j = 2; j <= 14; j++) {
    
47.                                 share[j][i] = 1;
    
48.                         }
    
49.                 }
    
50.                 for (int i = 1; i <= 5; i++) {
    
51.                         a[i] = b[i];
    
52.                         sx[i] = bsx[i];
    
53.                         share[a[i]][sx[i]] = 0;
    
54.                         pm[i] = 0;
    
55.                
    
56.                 }
    
57.                 for (int i = 11; i <= (KLno + 1) * 5; i++) {  ///' REMOVE OTHER KLSE share FROM THE share
    
58.                         if (KLno > 1) {
    
59.                                 share[b[i]][bsx[i]] = 0;
    
60.                         }
    
61.                 }
    
62. 
    
63. ///////
    
64.                 long nss = 0;               
    
65.                
    
66.                 for (int ds = 1; ds <= 26; ds++) {    //////////aaaaaaaaaaaaaaaaaa - START
    
67.                         ns = 0;
    
68.                         if (share[px[ds]][qx[ds]] > 0){    //////////bbbbbbbbbbbbbbbbbb - START
    
69.                                 nss = nss + 1;
    
70.                                 share[px[ds]][qx[ds]] = share[px[ds]][qx[ds]] - 1;
    
71.                                 
    
72.                                 for (int h = 1 * dm[5]; h <= (99 * dm[5]); h++) {
    
73.                                         if (share[px[h]][qx[h]] > 0) {
    
74.                                                 if (h > 0) {
    
75.                                                         a[10] = px[h];
    
76.                                                         sx[10] = qx[h];
    
77.                                                 }
    
78.                                                 for (int g = (h + 1) * dm[4]; g <= 99 * dm[4]; g++) {
    
79.                                                         if (share[px[g]][qx[g]] > 0) {
    
80.                                                                 if (g > 0) {
    
81.                                                                         a[9] = px[g];
    
82.                                                                         sx[9] = qx[g];
    
83.                                                                 }
    
84.                                                                 for (int f = (g + 1) * dm[3]; f <= 99 * dm[3]; f++) {
    
85.                                                                         if (share[px[f]][qx[f]] > 0) {
    
86.                                                                                 if (f > 0) {
    
87.                                                                                         a[8] = px[f];
    
88.                                                                                         sx[8] = qx[f];
    
89.                                                                                 }
    
90.                                                                                 for (int e = (f + 1) * dm[2]; e <= 99 * dm[2]; e++) {
    
91.                                                                                        
    
92.                                                                                         if (share[px[e]][qx[e]] > 0) {
    
93.                                                                                                 if (e > 0) {
    
94.                                                                                                         a[7] = px[e];
    
95.                                                                                                         sx[7] = qx[e];
    
96.                                                                                                 }
    
97. 
    
98.                                                                                                 if (nss == 1 || h < ds) {
    
99.                                                                                                         ns = ns + 1;
    
100.                                                                                                         Lmt1 = 2;
     
101.                                                                                                         Lmt2 = 2;
     
102.                                                                                                         ////fpoints
     
103.                                                                                                         for (int m = Lmt1; m <= Lmt2; m++) {
     
104.                                                                                                                 if (m == 1) {
     
105. 
     
106. 
     
107.                                                                                                                         else {
     
108.                                                                                                                                         score = Cvalue[5] + Cvalue[4] / 100 + Cvalue[3] / 10000 + Cvalue[2] / 1000000 + Cvalue[1] / 100000000;
     
109.                                                                                                                                 }
     
110.                                                                                                                         }
     
111.                                                                                                                         else {
     
112.                                                                                                                                 int count = 1;
     
113.                                                                                                                                 for (int p = 2; p <= 14; p++) {
     
114.                                                                                                                                         if (point1[p] == 1) {
     
115.                                                                                                                                                 Cvalue[count] = p;
     
116.                                                                                                                                                 point1[p] = 0;
     
117.                                                                                                                                                 count = count + 1;
     
118.                                                                                                                                         }
     
119.                                                                                                                                 }
     
120.                                                                                                                                 if (Cvalue[5] == 14 && Cvalue[4] == 5 && Cvalue[3] == 4 && Cvalue[2] == 3 && Cvalue[1] == 2) {
     
121.                                                                                                                                         Cvalue[5] = 5;
     
122.                                                                                                                                         Cvalue[4] = 4;
     
123.                                                                                                                                         Cvalue[3] = 3;
     
124.                                                                                                                                         Cvalue[2] = 2;
     
125.                                                                                                                                         Cvalue[1] = 1;
     
126.                                                                                                                                 }
     
127.                                                                                                                                 if ((Cvalue[5] - Cvalue[1]) == 4){ ///Net EARN
     
128.                                                                                                                                         if (Cvalue[5] < 14) {
     
129.                                                                                                                                                 score = 500 + Cvalue[5];
     
130.                                                                                                                                         }
     
131.                                                                                                                                         else {
     
132.                                                                                                                                                 score = 600 + Cvalue[5];
     
133.                                                                                                                                         }
     
134.                                                                                                                                 }
     
135.                                                                                                                                 else { /// EARN
     
136.                                                                                                                                         score = 200 + Cvalue[5] + Cvalue[4] / 100 + Cvalue[3] / 10000 + Cvalue[2] / 1000000 + Cvalue[1] / 100000000;
     
137.                                                                                                                                 }
     
138.                                                                                                                         }
     
139.                                                                                                                 } ////BBBBBB END
     
140.                                                                                                                 scores[m] = score; ////scores(m) = Round(score, 8)
     
141.                                                                                                         } /////////zzzzzzz END
     
142.                                                                                                         dpoint[ds][ns] = scores[2];
     
143.                                                                                                 }else{
     
144.                                                                                                         ns = ns + 1;
     
145.                                                                                                         dpoint[ds][ns] = dpoint[const1][ns];
     
146.                                                                                                 }
     
147.                                                                                         }
     
148.                                                                                 }
     
149.                                                                         }
     
150.                                                                 }
     
151.                                                         }
     
152.                                                 }
     
153.                                         }
     
154.                                 }
     
155.                                 const1 = ds;                           
     
156.                                 share[px[ds]][qx[ds]] = share[px[ds]][qx[ds]] + 1;
     
157.                         }  ///////bbbbbbbbbbbbbbbb - END
     
158.                 } ////////aaaaaaaaaaaaaaaaaa - END               
     
159.                

复制代码

tornado

lcw9988 发表于 7-7-2024 03:48 PM
別拿简单的例子忽悠外行人啦, 简单的当然容易简化啦, 我的代码像你说的这么简单吗? 整10个loops 环环相扣  ...

难者不会，会者不难，你说不能简化，是因为你不懂简化~

这个程式是你自己写，还是之前那个教你的人写的，然后你优化的？
你把shuffle arrays，reset codes，initialize array（shares）和simulation code全部混在一起，
其实这些都可以分解出来的~

给你个例子：
int main() {
  ...
  for (int s = 1; s <= trial8; s++) {
        shuffleArrays(b, bsx, rng);
        std::array<long, 6> codes201 = {0}, codes101 = {0}, codes41 = {0}, codes15 = {0}, codes11 = {0}, codes9 = {0},
                            codes7 = {0}, codes5 = {0}, codes3 = {0}, codes1 = {0}, codes = {0}, ev = {0}, culev = {0};
        resetCodes(codes201, codes101, codes41, codes15, codes11, codes9, codes7, codes5, codes3, codes1, codes, ev, culev);
        initializeShares(share);
        performSimulation(share, b, bsx, a, sx, pm, px, qx, dm, scores, dpoint, ns, const1);
  }
}
void shuffleArrays() {...}
void resetCodes() {...}
void initializeShares() {...}
void performSimulation() {...}

我是从编程的角度，来分析你的程式，
不要问我那些formula，我是不会答你的，那是你应该懂的，
这世上有千百种应用，不见得我每个都要去分析了解，
而且我也不是做你这行的，你明白吗？

lcw9988

tornado 发表于 7-7-2024 10:02 PM
难者不会，会者不难，你说不能简化，是因为你不懂简化~

这个程式是你自己写，还是之前那个教你的人 ...

廢话, 当然是我写的啦 !

笑死人, 你说的这些都是constant, 读一次就行了, 还优化什么? 这样你也看不出, 别搞笑啦

你说的优化的意思是要排列整齐让别人容易看出來怎样运行和以后怎样修改, 挑剔一些根本对我无关疼癢的东西, 我说的优化的意思是以更快速度算出结果 ! 明白吗?

tornado

lcw9988 发表于 7-7-2024 10:15 PM
廢话, 当然是我写的啦 !

笑死人, 你说的这些都是constant, 读一次就行了, 还优化什么? 这样你也看不出,  ...

我说的是简化，不是优化，优化是问你这段程序，是不是别人的写的，然后你去优化？

我会一直回复你，也是因为你的这个破烂程序对这个贴，有讨论价值~

程式简化后，就比较整洁了，要做什么一目了然，维护也更轻松，

• shuffleArrays(b, bsx, rng);
• resetCodes(codes201, codes101, codes41, codes15, codes11, codes9, codes7, codes5, codes3, codes1, codes, ev, culev);
• initializeShares(share);
• performSimulation(share, b, bsx, a, sx, pm, px, qx, dm, scores, dpoint, ns, const1);
  

一般情况下，我们主要focus在主程式performSimulation()的6个loops就可以了~

1. for (int ds = 1; ds <= NUM_TRIALS; ds++) {
   
2.     for (int h = 1 * dm[5]; h <= 99 * dm[5]; h++) {
   
3.         for (int g = (h + 1) * dm[4]; g <= 99 * dm[4]; g++) {
   
4.             for (int f = (g + 1) * dm[3]; f <= 99 * dm[3]; f++) {
   
5.                 for (int e = (f + 1) * dm[2]; e <= 99 * dm[2]; e++) {
   
6.                     if (nss == 1 || h < ds) {
   
7.                         for (int m = Lmt1; m <= Lmt2; m++) {
   
8.                             // Perform calculations
   
9.                         }
   
10.                     }
    
11.                 }
    
12.             }
    
13.         }
    
14.     }
    
15. }
    

复制代码

其实你这个程式这么多nested loop是不正常的，应该尝试restructuring你的logic，说不定还可以找到优化的契机噢~

我已经把饭捧到你桌上了，再把饭喂到你嘴巴，就难看了~

lcw9988

tornado 发表于 8-7-2024 08:39 AM
我说的是简化，不是优化，优化是问你这段程序，是不是别人的写的，然后你去优化？

我会一直回复你 ...

第一, 再重复一次, 这8个到l10个oop当然是我原创我写的, 然后叫人优化, 这个是要用到深奥数学, 没几个码農会, 帮我的人也优化估计不到10%, 提醒一下, 看到你的回复这么多次都没提到重点, 99%肯定你也不会, 只会一直重复说简化, 整洁，维护 . . . .blah blah说一些对我没用的东西, 这些是专业码農做的, 我又不是专业码農, 我是自用我不会care这些 !


第二, 这么多nested loop不正常? 你知道我的公式要算什么吗? 你不会或没见过就说不正常? 你住在一个小盒子吗?  你继续秀下限让笑掉大牙吧 !

第三, 为什么你删除这四个, 删除就叫简化? 删除还能算出我要的结果吗? 你太好笑了, 现在的所谓的砖业码農原来是把删除当成简化的, 根本不知道整个完整algorithm, 就删除, 删除,删除 . . . 然后就没有然后了 !

tornado

lcw9988 发表于 8-7-2024 09:19 AM
第一, 再重复一次, 这8个到l10个oop当然是我原创我写的, 然后叫人优化, 这个是要用到深奥数学, 没几个码 ...

我当然知道你是想show off你那些复杂的HFT数学逻辑，

万变不离其宗，难者不会，会者不难，比这些程序复杂几倍的，我都看过，

你现在最大的问题是对编程没有概念，哪怕是叫人帮你改，把他简化，就是优化的第一步，

还有你必须去找对HFT编程有丰富经验的程序员帮你优化，

没有必要显摆，这边绝对不会有人会崇拜你~