也问“将不同观测按要求重新组合”

1. data test;
   
2. input
   
3. n        v1        v3        v5        v8;
   
4. datalines;
   
5. 1        1        0        1        42345
   
6. 2        0        3        1        42310
   
7. 3        1        0        1        42490
   
8. 4        0        3        1        42450
   
9. 5        0        0        1        42475
   
10. 6        1        3        1        42535
    
11. 7        1        0        1        42630
    
12. 8        0        0        1        42770
    
13. 9        1        3        1        42875
    
14. 10        0        3        1        42725
    
15. 11        0        0        1        42810
    
16. 12        1        3        1        42880
    
17. 13        0        0        1        42790
    
18. 14        1        0        1        42715
    
19. 15        0        3        1        42740
    
20. 16        0        0        1        42760
    
21. 17        1        3        2        42825
    
22. ;
    
23. run;
    
24. 
    
25. data test2a test2b;
    
26.   set test;
    
27.   if (v1=1 and v3=0) or (v1=0 and v3=3) then output test2a;
    
28.   if (v1=0 and v3=0) or (v1=1 and v3=3) then output test2b;
    
29. run;
    
30. 
    
31. data test3a;
    
32.   set test2a;
    
33.   retain grp;
    
34.   lagv3=lag(v3);
    
35.   if v3=0 and v3 ne lagv3 then grp=n;
    
36. run;
    
37. 
    
38. data test3b;
    
39.   set test2b;
    
40.   retain grp;
    
41.   lagv3=lag(v3);
    
42.   if v3=0 and v3 ne lagv3 then grp=n;
    
43. run;
    
44. 
    
45. data test4;
    
46.   set test3a test3b;
    
47.   by grp;
    
48.   retain d;
    
49.   if first.grp then d+1;
    
50.   drop lagv3 grp;
    
51. run;

复制代码

这个可以实现上述例子的情况。但是对于这么一种情况：(v1,v3) = (0,0) (0,0) (1,3) (1,3) 那么我就不知道后面2次平仓分别对应的是哪个开仓。上述程序可以实现(v1,v3) = (0,0) (0,0) (1,3) 即视为最后一次平了前面连续的所有开仓。

我发现用lag多余了。。。不过就先这样吧，免得编辑了又没东西了。。。

纯粹依照楼主例子做的，没有考虑任何其他的可能情况。
楼主先试试，有问题，咱们再改改。

1. data t1;
   
2.         format n v1 v3 v5 8. v8 $10.;
   
3.         input n v1 v3 v5 v8 $;
   
4. cards;
   
5. 1 1 0 1 42345
   
6. 2 0 3 1 42310
   
7. 3 1 0 1 42490
   
8. 4 0 3 1 42450
   
9. 5 0 0 1 42475
   
10. 6 1 3 1 42535
    
11. 7 1 0 1 42630
    
12. 8 0 0 1 42770
    
13. 9 1 3 1 42875
    
14. 10 0 3 1 42725
    
15. 11 0 0 1 42810
    
16. 12 1 3 1 42880
    
17. 13 0 0 1 42790
    
18. 14 1 0 1 42715
    
19. 15 0 3 1 42740
    
20. 16 0 0 1 42760
    
21. 17 1 3 2 42825
    
22. ;run;
    
23. data t2_a1
    
24.           t2_a2
    
25.           t2_b1
    
26.           t2_b2;
    
27.         set t1;
    
28.         if v1 = 1 and v3 = 0 then do; clus = 'A1'; output t2_a1; end;
    
29.         else if v1 = 0 and v3 = 3 then do; clus = 'A2';output t2_a2; end;
    
30.         else if v1 = 0 and v3 = 0 then do; clus = 'B2';output t2_b2; end;
    
31.         else if v1 = 1 and v3 = 3 then do; clus = 'B1';output t2_b1; end;
    
32. run;
    
33. 
    
34. %macro test1(var);
    
35. proc sort data = t2_&var.1; by n; run;
    
36. proc sort data = t2_&var.2; by n; run;
    
37. data _null_;
    
38.         set t2_&var.2 nobs=nn;
    
39.         call symputx('n', nn);
    
40.         stop;
    
41. run;
    
42. %put &n.;
    
43. data t3_&var.(keep = new: d);
    
44.         array char{&n., 2} $ _temporary_;
    
45.         array num{&n.,2}  _temporary_;
    
46.         retain char;
    
47.         retain num;
    
48.         retain start_ii end_ii left_v5 d 0;
    
49.         set t2_&var.1(rename=(n=n_2 v5=v5_2 v8=v8_2 clus=clus_2));
    
50.         if _n_ = 1 then do;
    
51.                 do ii = 1 to &n.;
    
52.                         set t2_&var.2 point = ii;
    
53.                         char{ii,1} = v8;
    
54.                         char{ii,2} = clus;
    
55.                         num{ii,1} = n;
    
56.                         num{ii,2} = v5;
    
57.                 end;
    
58.                 start_ii = 1;
    
59.                 end_ii = 1;
    
60.         end;
    
61.         left_v5 = v5_2 - num{end_ii,2};
    
62.         if v5_2 < num{end_ii,2} then do;
    
63.                 left_v5 = 0;
    
64.                 num{end_ii,2} = num{end_ii,2} - v5_2;
    
65.                 d + 1;
    
66.                 new_n = n_2;
    
67.                 new_clus = clus_2;
    
68.                 new_v5 = v5_2;
    
69.                 new_v8 = v8_2;
    
70.                 output;
    
71.                 do ii = start_ii to end_ii;
    
72.                         new_n = num{ii,1};
    
73.                         new_clus = char{ii,2};
    
74.                         new_v5 = num{ii,2};
    
75.                         new_v8 = char{ii,1};
    
76.                         output;
    
77.                 end;
    
78.                 start_ii = end_ii;
    
79.         end;else if v5_2 = num{end_ii,2} then do;
    
80.                 left_v5 = 0;
    
81.                 d + 1;
    
82.                 new_n = n_2;
    
83.                 new_clus = clus_2;
    
84.                 new_v5 = v5_2;
    
85.                 new_v8 = v8_2;
    
86.                 output;
    
87.                 do ii = start_ii to end_ii;
    
88.                         new_n = num{ii,1};
    
89.                         new_clus = char{ii,2};
    
90.                         new_v5 = num{ii,2};
    
91.                         new_v8 = char{ii,1};
    
92.                         output;
    
93.                 end;
    
94.                 if end_ii > &n. then stop;
    
95.                 end_ii + 1;
    
96.                 start_ii = end_ii;
    
97.         end;else do;
    
98.                 do while( left_v5 > 0 );
    
99.                         end_ii + 1;
    
100.                         if left_v5 < num{end_ii,2} then do;
     
101.                                 left_v5 = 0;
     
102.                                 num{end_ii,2} = num{end_ii,2} - v5_2;
     
103.                                 d + 1;
     
104.                                 new_n = n_2;
     
105.                                 new_clus = clus_2;
     
106.                                 new_v5 = v5_2;
     
107.                                 new_v8 = v8_2;
     
108.                                 output;
     
109.                                 do ii = start_ii to end_ii;
     
110.                                         new_n = num{ii,1};
     
111.                                         new_clus = char{ii,2};
     
112.                                         new_v5 = num{ii,2};
     
113.                                         new_v8 = char{ii,1};
     
114.                                         output;
     
115.                                 end;
     
116.                                 start_ii = end_ii;
     
117.                         end;else if left_v5 = num{end_ii,2} then do;
     
118.                                 left_v5 = 0;
     
119.                                 d + 1;
     
120.                                 new_n = n_2;
     
121.                                 new_clus = clus_2;
     
122.                                 new_v5 = v5_2;
     
123.                                 new_v8 = v8_2;
     
124.                                 output;
     
125.                                 do ii = start_ii to end_ii;
     
126.                                         new_n = num{ii,1};
     
127.                                         new_clus = char{ii,2};
     
128.                                         new_v5 = num{ii,2};
     
129.                                         new_v8 = char{ii,1};
     
130.                                         output;
     
131.                                 end;
     
132.                                 end_ii + 1;
     
133.                                 start_ii = end_ii;
     
134.                         end;else left_v5 = left_v5 - num{end_ii,2};
     
135.                 end;
     
136.         end;
     
137. run;
     
138. %mend;
     
139. %test1(var = a);
     
140. %test1(var = b);
     
141. 
     
142. data t4;
     
143.         format d 8. new_clus $2.;
     
144.         set t3_a
     
145.                 t3_b;
     
146. run;

复制代码

zhangzachary 发表于 2013-1-21 11:49
这个可以实现上述例子的情况。但是对于这么一种情况：(v1,v3) = (0,0) (0,0) (1,3) (1,3) 那么我就不知道后 ...

你说到的这种情况，一般是先进先出，程序会有什么不同呢？如果是后进先出呢？不好意思，终于找到牛人，就允许我一次问个够吧，学习了！

maidenhan 发表于 2013-1-21 14:32
纯粹依照楼主例子做的，没有考虑任何其他的可能情况。
楼主先试试，有问题，咱们再改改。

兄弟，你太牛了，各种循环、各种宏、各种看不懂啊

denver 发表于 2013-1-21 15:13
你说到的这种情况，一般是先进先出，程序会有什么不同呢？如果是后进先出呢？不好意思，终于找到牛人，就 ...

不论先进先出后进先出，这个没关系，重点在于，如果有多个(0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,3) (1,3) (1,3)这样的话，世界就混乱啦。。。比如假设先进先出，但是我们不知道是先进4个再进1个1个的，然后1个1个1个出来，还是进3,2,1 / 2,2,2 / 1,3,2 / 1,2,3 等等。。。简单说，我们还是需要一个变量来说明对应的买入和卖出的关系，不过呢，你的问题好像就是要找出这样的关系，于是，矛盾了，就无解了。。。

zhangzachary 发表于 2013-1-21 15:35
不论先进先出后进先出，这个没关系，重点在于，如果有多个(0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (1,3) (1 ...

哈哈，别急哈，那我先研究研究哈

如果在先入先出的假设条件下， 且只考虑分组并不考虑组的顺序，这个逻辑应该不是很难。

1. data t1 t2;
   
2.         set test;
   
3. 
   
4.     if (v1 = 1 and v3 = 0) or (v1 = 0 and v3 = 3) then output t1;
   
5.         else if (v1 = 0 and v3 = 0) or (v1 = 1 and v3 = 3) then output t2;
   
6. run;
   
7. %macro test(indsn = , outdsn =);
   
8. proc sort data = &indsn; by v3 n; run;
   
9. 
   
10. data _tmp;
    
11.         set &indsn; by v3 n;
    
12.         retain cnt;
    
13.         if first.v3 then cnt = 0;
    
14.         cnt + v5;
    
15. run;
    
16. proc sort data = _tmp; by cnt v3; run;
    
17.        
    
18. data &outdsn;
    
19.         set _tmp; by cnt v3;
    
20.         retain tot_qty 0 subgrp 0;
    
21. 
    
22.         if tot_qty = 0 then do; subgrp + 1; end;
    
23. 
    
24.         if v3 = 0 then tot_qty = tot_qty + v5;
    
25.         else if v3 = 3 then tot_qty = tot_qty - v5;
    
26. 
    
27.         drop cnt tot_qty;
    
28. run;
    
29. %mend;
    
30. %test(indsn = t1, outdsn = t1_grp)
    
31. %test(indsn = t2, outdsn = t2_grp)
    
32. 
    
33. data result;
    
34.         set t1_grp(in = in1) t2_grp(in = in2);
    
35.         if in1 then part = 1;
    
36.         if in2 then part = 2;
    
37. run;

复制代码

这段代码应该至少帮助分组了。

考虑分组顺序也应该不难， 加上下面这段应该就可以了

1. proc sort data = result; by part subgrp n; run;
   
2. data result;
   
3.         set result; by part subgrp n;
   
4.         retain idx;
   
5.         if first.subgrp then idx = n;
   
6. run;
   
7. proc sort data = result; by idx n; run;
   
8. data result;
   
9.         set result; by idx n;
   
10.         retain grp 0;
    
11.         if first.idx then grp + 1;
    
12.         drop subgrp part idx;
    
13. run;

复制代码

yuerqieqie 发表于 2013-2-22 07:16
考虑分组顺序也应该不难， 加上下面这段应该就可以了

谢谢