marital_weeping's questions

expryDt:{[ed] (2_string ed) except "."};

// generate a formatted ticker name for an option
symbol:{[tkr;expiryDate;typ;strike]
    if[not typ in `CALL`PUT`CE`PE; show "typ is not correct. it must be either CALL or PUT or CE or PE"; exit 1];
    r: $[(typ=`CALL) or (typ=`CE); string `C; string `P];
    "" sv (string tkr; expryDt[expiryDate]; r; string strike)
 };

// test
tkr:`IBM;
expiryDate:2025.01.09;
typ:`CALL;
strike:24000i;

show symbol[tkr;expiryDate;typ;strike]; // "IBM250109C24000" OK

Meu código de teste para formatar símbolos como IBM250109C24000funciona muito bem. No entanto, quando tento aplicá-lo na tabela tabaixo, ele falha, pois minha função symbolnão é vetorizada. Como faço para que funcione?

t:([] ticker:`IBM`IBM`IBM;
      expiryDate:2025.01.09 2025.01.09 2025.01.09;
      typ:`CALL`PUT`CE;
      strike:24000 24000 24000;
      secType:`OPT`OPT`OPT);
show t;

t:update symbol:symbol[ticker;expiryDate;typ;strike] from t where secType=`OPT; // error

Recebo a seguinte saída ao executar o código acima:

"IBM250109C24000"
ticker expiryDate typ  strike secType
-------------------------------------
IBM    2025.01.09 CALL 24000  OPT    
IBM    2025.01.09 PUT  24000  OPT    
IBM    2025.01.09 CE   24000  OPT    
'type
  [3]  tv_options.q:5: symbol:{[tkr;expiryDate;typ;strike]
    if[not typ in `CALL`PUT`CE`PE; show "typ is not correct. it must be either CALL or PUT or CE or PE"; exit 1];
       ^
    r: $[(typ=`CALL) or (typ=`CE); string `C; string `P];

Dada uma lista de 0s e 1s, digamos que l: 0 0 1 1 1 0 0 1 1eu gostaria de obter uma sequência começando com 1 para cada conjunto contíguo de 1s. Portanto, a saída necessária deve ser l: 0 0 1 2 3 0 0 1 2. Como posso conseguir isso no kdb+?

w:(1 2;3 4;5 2); l:til count w; h:l+1;
show t:([] l; h; w);

l h w  
-------
0 1 1 2
1 2 3 4
2 3 5 2

Tenho uma tabela tcom uma coluna wque tem listas para linhas. Gostaria de manter apenas elementos em cada linha wque estejam entre os valores le hpara cada linha da tabela.

A saída esperada é:

l h w  
-------
0 1 ,1
1 2 ,
2 3 ,2

Eu tentei fazer

t:update w:w[where ((w>=l) and (w<=h))] from t;

mas falha com

'type
  [0]  t:update w:w[where ((w>=l) and (w<=h))] from t;

Eu tenho as seguintes funções de regressão linear

// linear regression y vs x
// returns: intercept slope
linear:{
    if[not (count x)=(count y); show "x and y must have the same length"; exit 1];
    fit:{(enlist x) lsq y xexp/:til 1+z};
    fit[x; y; 1]
 };

// takes X and Y as a list of lists
linearLL:{[X;Y] t:([] x:X; y:Y); raze {9h$linear[x`x; x`y]} each t};

\d .

e eu gostaria de obter a interceptação e a inclinação delr

/ sliding window from https://code.kx.com/q/kb/programming-idioms/
swin:{[f;w;s] f each {1_x,y}\[w#0; s]}

p:1 2 3 0N 0N 0N 4 5 0N 6 0N 0N 0N 7 8 9;
p:1f*p;
time:2024.01.01+til count p;
n:4;
t:([] p: p; time: time);

t:update c:til count t from t;
t:select from t where p>0;
t:update x:swin[::;n;c] from t;
t:update y:swin[::;n;p] from t;
/t:update y:swin[::;n;p] from t;
t:update x:1f*({distinct x} each x) from t;
t:update y:({x except 0} each y) from t;
t:update y:({x except 0N} each y) from t;
t:delete c from t;
show t:update lr:.regression.linearLL[x;y] from t;

que dá (como esperado):

p time       x           y        lr      
------------------------------------------
1 2024.01.01 ,0f         ,1f              
2 2024.01.02 0 1f        1 2f     -1   1  
3 2024.01.03 0 1 2f      1 2 3f   -1   1  
4 2024.01.07 0 1 2 6f    1 2 3 4f -2.5 1.9
5 2024.01.08 1 2 6 7f    2 3 4 5f -3.7 2.2
6 2024.01.10 2 6 7 9f    3 4 5 6f -3.9 2.2
7 2024.01.14 6 7 9 13f   4 5 6 7f -3.9 2.3
8 2024.01.15 7 9 13 14f  5 6 7 8f -5.5 2.5
9 2024.01.16 9 13 14 15f 6 7 8 9f -1.5 1.9

No entanto, recebo um 'lengtherro ao invocar:

show t:update intercept:lr[0], slope:lr[1] from t;

Estou presumindo que os elementos de lrsão uma lista de um par de elementos, mas de alguma forma esse não é o caso. Como posso extrair as informações de interceptação e declive?

Eu tenho uma mesa tcomo

q)trades: ([]
    signalTime: 2024.01.05 2024.01.12 2024.01.19 2024.01.25 2024.02.02 2024.02.09 2024.02.16 2024.02.23 2024.03.01 2024.03.07;
    exitTime: 2024.01.25 2024.02.01 2024.02.08 2024.02.15 2024.02.22 2024.02.29 2024.03.07 2024.03.14 2024.03.21 2024.03.28
 );
signalTime exitTime
----------------------
2024.01.05 2024.01.25
2024.01.12 2024.02.01
2024.01.19 2024.02.08
2024.01.25 2024.02.15
2024.02.02 2024.02.22
2024.02.09 2024.02.29
2024.02.16 2024.03.07
2024.02.23 2024.03.14
2024.03.01 2024.03.21
2024.03.07 2024.03.28

Gostaria de manter apenas as negociações cujas datas intermediárias (entre signalTimee exitTime) não se sobreponham às de nenhuma outra negociação (linhas). Como alternativa, deve haver apenas uma negociação durante qualquer data. A saída esperada deve ser

signalTime exitTime
----------------------
2024.01.05 2024.01.25
2024.02.02 2024.02.22
2024.02.23 2024.03.14

Embora eu seja capaz de conceber uma solução usando um doloop, como faço isso de forma mais eficiente e idiomática q?

Aqui está minha tentativa fraca de solução usando um doloop, embora não esteja totalmente correta.

removeOverlappingTrades:{[t]
    n: count t;
    accept: n#0b;          
    accept[0]: 1b;         
    lastExitTime: t[`exitTime][0]; 
    do[n-1; {[t;lastExitTime;accept;x]
        i: x+1;  // Current index
        if[t[`signalTime][i] >= lastExitTime;
           accept[i]: 1b;
           lastExitTime: t[`exitTime][i];
          ];
    }[t;lastExitTime;accept] each til n-1];
    t where accept
 };

Eu tenho uma mesat

t:([] x: 1 2 3 4 5; y: 5.1 2.4 3.3 4.5 1.5);
x y  
-----
1 5.1
2 2.4
3 3.3
4 4.5
5 1.5

e estou tentando redimensionar as xlinhas ye tde modo que a maior se torne 1 e a outra assuma o valor ceiling max(x;y)%min(x;y)como:

rescaledUnits:{[t]
    t:update l:max(x;y), s:min(x;y) from t;
    t:update a:ceiling l%s, ones:1 from t;
    t:update uc:ones, up:a where x>=y from t;
    t:update uc:a, up:ones where x<y from t;
    t
 };

mas ao chamá-lo eu recebo

show rescaledUnits[t]

q)

'length
    t:update a:ceiling l%s, one:1 from t;
    t:update uc:one, up:a where x>=y from t;
      ^
    t:update uc:a, up:one where x<y from t;

Como posso corrigir a função acima?

Dada a tabela t: ([] a: 1 2 3 4), como podemos obter a coluna bpara , por exemplo ,

n=2

a b
-----
1 1 2
2 2 3
3 3 4
4 ,4

n=3

a b
-------
1 1 2 3
2 2 3 4
3 3 4
4 ,4

onde né o número de elementos subsequentes de a(incluindo a) a serem incluídos b.