=SORT(UNIQUE({QUERY('Facility Use Requests'!A2:AC, "SELECT G, H, I, J, C, F, K, L, D, E, P, N, O WHERE G >= date '"&TEXT(TODAY(),"yyyy-mm-dd")&"'",0);QUERY('Facility Use Requests'!A2:AC, "SELECT R, S, T, J, C, F, K, L, D, E, P, N, O WHERE R >= date '"&TEXT(TODAY(),"yyyy-mm-dd")&"'",0);QUERY('Facility Use Requests'!A2:AC, "SELECT U, V, W, J, C, F, K, L, D, E, P, N, O WHERE U >= date '"&TEXT(TODAY(),"yyyy-mm-dd")&"'",0);QUERY('Facility Use Requests'!A2:AC, "SELECT X, Y, Z, J, C, F, K, L, D, E, P, N, O WHERE X >= date '"&TEXT(TODAY(),"yyyy-mm-dd")&"'",0);QUERY('Facility Use Requests'!A2:AC, "SELECT AA, AB, AC, J, C, F, K, L, D, E, P, N, O WHERE AA >= date '"&TEXT(TODAY(),"yyyy-mm-dd")&"'",0)}),1,TRUE,2,TRUE)
This is a sample of my code to arrange by date. I keep getting #VALUE! in my cell. This worked last year and all of a sudden it quit. Any help would be appreciated.
one of your queries does not output anything... use:
=SORT(UNIQUE({
IFERROR(QUERY('Facility Use Requests'!A2:AC, "SELECT G, H, I, J, C, F, K, L, D, E, P, N, O WHERE G >= date '"&TEXT(TODAY(),"yyyy-mm-dd")&"'",0), IFERROR(SEQUENCE(1,13)/0));
IFERROR(QUERY('Facility Use Requests'!A2:AC, "SELECT R, S, T, J, C, F, K, L, D, E, P, N, O WHERE R >= date '"&TEXT(TODAY(),"yyyy-mm-dd")&"'",0), IFERROR(SEQUENCE(1,13)/0));
IFERROR(QUERY('Facility Use Requests'!A2:AC, "SELECT U, V, W, J, C, F, K, L, D, E, P, N, O WHERE U >= date '"&TEXT(TODAY(),"yyyy-mm-dd")&"'",0), IFERROR(SEQUENCE(1,13)/0));
IFERROR(QUERY('Facility Use Requests'!A2:AC, "SELECT X, Y, Z, J, C, F, K, L, D, E, P, N, O WHERE X >= date '"&TEXT(TODAY(),"yyyy-mm-dd")&"'",0), IFERROR(SEQUENCE(1,13)/0));
IFERROR(QUERY('Facility Use Requests'!A2:AC, "SELECT AA, AB, AC, J, C, F, K, L, D, E, P, N, O WHERE AA >= date '"&TEXT(TODAY(),"yyyy-mm-dd")&"'",0), IFERROR(SEQUENCE(1,13)/0))}),1,TRUE,2,TRUE)
was doing a code in maple for non-linear systems using newtons
I struggled a bit with this so my friend showed me his solution. I did exactly the same and I keep getting this error. I apologize for the long code, but I figured I'd add everything needed. If needed I can shorten it. I am just trying to do 5 iterations of this method, and then this error says "(in J)" and I am not sure what they mean by the 2nd argument
restart;
g := (x, y, z) -> 3*x - cos(y*z) - 1/2;
h := (x, y, z) -> x^2 - 81*(y + 0.1)^2 + sin(z) + 1.06;
i := (x, y, z) -> exp(-y*x) + 20*z + 10/3*Pi - 1;
A := (x, y, z) -> Vector[column](3, [g(x, y, z), h(x, y, z), i(x, y, z)]);
B := (x, y, z) -> Vector[column](3, [x, y, z]);
J := Matrix(3, 3, [[diff(g(x, y, z), x), diff(g(x, y, z), y), diff(g(x, y, z), z)], [diff(h(x, y, z), x), diff(h(x, y, z), y), diff(h(x, y, z), z)], [diff(i(x, y, z), x), diff(i(x, y, z), y), diff(i(x, y, z), z)]]);
J := (x, y, z) -> Matrix(3, 3, [[diff(g(x, y, z), x), diff(g(x, y, z), y), diff(g(x, y, z), z)], [diff(h(x, y, z), x), diff(h(x, y, z), y), diff(h(x, y, z), z)], [diff(i(x, y, z), x), diff(i(x, y, z), y), diff(i(x, y, z), z)]]);
C := (x, y, z) -> LinearAlgebra[MatrixInverse](J(x, y, z));
F := (x, y, z) -> evalf(B(x, y, z) - ((C(x, y, z)) . (A(x, y, z))));
x[0] := 0.5;
y[0] := 0.5;
z[0] := -0.5;
x[1] := F(x[0], y[0], z[0]);
Error, (in J) invalid input: diff received .5, which is not valid for its 2nd argument
You could also use the Jacobian command from the VectorCalculus package, along with purely Vector form. But I'll try to make minimal changes to get your original to behave (eg. I'll leave all the unnecessary operator definitions).
The following works in my Maple 2021.0 if I Copy&Paste in as either 1D plaintext in a Worksheet or 2D Math in a Document.
restart;
g := (x,y,z) -> 3*x - cos(y*z) - 1/2:
h := (x,y,z) -> x^2 - 81*(y + 0.1)^2 + sin(z) + 1.06:
i := (x,y,z) -> exp(-y*x) + 20*z + 10/3*Pi - 1:
A := (x,y,z) -> Vector(3,[g(x,y,z),h(x,y,z),i(x,y,z)]):
B := (x,y,z) -> Vector(3,[x,y,z]):
J:=unapply(Matrix(3,3,
[[diff(g(x,y,z),x),diff(g(x,y,z),y),diff(g(x,y,z),z)],
[diff(h(x,y,z),x),diff(h(x,y,z),y),diff(h(x,y,z),z)],
[diff(i(x,y,z),x),diff(i(x,y,z),y),diff(i(x,y,z),z)]]),
[x,y,z]):
C := (x,y,z) -> LinearAlgebra:-MatrixInverse(J(x,y,z)):
F := (x,y,z) -> evalf(B(x,y,z) - ((C(x,y,z)) . (A(x,y,z)))):
x[0] := 0.5: y[0] := 0.5: z[0] := -0.5:
V[0] := Vector([x[0],y[0],z[0]]);
for ii from 1 to 7 do
V[ii] := F(V[ii-1][1], V[ii-1][2], V[ii-1][3]);
g(V[ii][1], V[ii][2], V[ii][3]),
h(V[ii][1], V[ii][2], V[ii][3]),
i(V[ii][1], V[ii][2], V[ii][3]);
end do;
Below calculation is done with uboot (2009 an older version) on iMX25 processor.
I am running sha256_process() function (sha256.c) under uboot to process 50Mbytes of data to get the hash.
It takes more than 100sec to complete the calculation. While the same hashing takes no time if run with openssl under Ubuntu (same processor).
Cross Compiler:
arm-none-linux-gnueabi-gcc 4.4.1.
Need some input on what can possibly be the problem.
Tried another arm toolchain with improvement, but still not as expected.
---sha256 code.
static void sha256_process(sha256_context *ctx, const uint8_t data[64])
{
uint32_t temp1, temp2;
uint32_t W[64];
uint32_t A, B, C, D, E, F, G, H;
GET_UINT32_BE(W[0], data, 0);
GET_UINT32_BE(W[1], data, 4);
GET_UINT32_BE(W[2], data, 8);
GET_UINT32_BE(W[3], data, 12);
GET_UINT32_BE(W[4], data, 16);
GET_UINT32_BE(W[5], data, 20);
GET_UINT32_BE(W[6], data, 24);
GET_UINT32_BE(W[7], data, 28);
GET_UINT32_BE(W[8], data, 32);
GET_UINT32_BE(W[9], data, 36);
GET_UINT32_BE(W[10], data, 40);
GET_UINT32_BE(W[11], data, 44);
GET_UINT32_BE(W[12], data, 48);
GET_UINT32_BE(W[13], data, 52);
GET_UINT32_BE(W[14], data, 56);
GET_UINT32_BE(W[15], data, 60);
#define SHR(x,n) ((x & 0xFFFFFFFF) >> n)
#define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))
#define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^ SHR(x, 3))
#define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^ SHR(x,10))
#define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
#define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
#define F0(x,y,z) ((x & y) | (z & (x | y)))
#define F1(x,y,z) (z ^ (x & (y ^ z)))
#define R(t) \
( \
W[t] = S1(W[t - 2]) + W[t - 7] + \
S0(W[t - 15]) + W[t - 16] \
)
#define P(a,b,c,d,e,f,g,h,x,K) { \
temp1 = h + S3(e) + F1(e,f,g) + K + x; \
temp2 = S2(a) + F0(a,b,c); \
d += temp1; h = temp1 + temp2; \
}
A = ctx->state[0];
B = ctx->state[1];
C = ctx->state[2];
D = ctx->state[3];
E = ctx->state[4];
F = ctx->state[5];
G = ctx->state[6];
H = ctx->state[7];
P(A, B, C, D, E, F, G, H, W[0], 0x428A2F98);
P(H, A, B, C, D, E, F, G, W[1], 0x71374491);
P(G, H, A, B, C, D, E, F, W[2], 0xB5C0FBCF);
P(F, G, H, A, B, C, D, E, W[3], 0xE9B5DBA5);
P(E, F, G, H, A, B, C, D, W[4], 0x3956C25B);
P(D, E, F, G, H, A, B, C, W[5], 0x59F111F1);
P(C, D, E, F, G, H, A, B, W[6], 0x923F82A4);
P(B, C, D, E, F, G, H, A, W[7], 0xAB1C5ED5);
P(A, B, C, D, E, F, G, H, W[8], 0xD807AA98);
P(H, A, B, C, D, E, F, G, W[9], 0x12835B01);
P(G, H, A, B, C, D, E, F, W[10], 0x243185BE);
P(F, G, H, A, B, C, D, E, W[11], 0x550C7DC3);
P(E, F, G, H, A, B, C, D, W[12], 0x72BE5D74);
P(D, E, F, G, H, A, B, C, W[13], 0x80DEB1FE);
P(C, D, E, F, G, H, A, B, W[14], 0x9BDC06A7);
P(B, C, D, E, F, G, H, A, W[15], 0xC19BF174);
P(A, B, C, D, E, F, G, H, R(16), 0xE49B69C1);
P(H, A, B, C, D, E, F, G, R(17), 0xEFBE4786);
P(G, H, A, B, C, D, E, F, R(18), 0x0FC19DC6);
P(F, G, H, A, B, C, D, E, R(19), 0x240CA1CC);
P(E, F, G, H, A, B, C, D, R(20), 0x2DE92C6F);
P(D, E, F, G, H, A, B, C, R(21), 0x4A7484AA);
P(C, D, E, F, G, H, A, B, R(22), 0x5CB0A9DC);
P(B, C, D, E, F, G, H, A, R(23), 0x76F988DA);
P(A, B, C, D, E, F, G, H, R(24), 0x983E5152);
P(H, A, B, C, D, E, F, G, R(25), 0xA831C66D);
P(G, H, A, B, C, D, E, F, R(26), 0xB00327C8);
P(F, G, H, A, B, C, D, E, R(27), 0xBF597FC7);
P(E, F, G, H, A, B, C, D, R(28), 0xC6E00BF3);
P(D, E, F, G, H, A, B, C, R(29), 0xD5A79147);
P(C, D, E, F, G, H, A, B, R(30), 0x06CA6351);
P(B, C, D, E, F, G, H, A, R(31), 0x14292967);
P(A, B, C, D, E, F, G, H, R(32), 0x27B70A85);
P(H, A, B, C, D, E, F, G, R(33), 0x2E1B2138);
P(G, H, A, B, C, D, E, F, R(34), 0x4D2C6DFC);
P(F, G, H, A, B, C, D, E, R(35), 0x53380D13);
P(E, F, G, H, A, B, C, D, R(36), 0x650A7354);
P(D, E, F, G, H, A, B, C, R(37), 0x766A0ABB);
P(C, D, E, F, G, H, A, B, R(38), 0x81C2C92E);
P(B, C, D, E, F, G, H, A, R(39), 0x92722C85);
P(A, B, C, D, E, F, G, H, R(40), 0xA2BFE8A1);
P(H, A, B, C, D, E, F, G, R(41), 0xA81A664B);
P(G, H, A, B, C, D, E, F, R(42), 0xC24B8B70);
P(F, G, H, A, B, C, D, E, R(43), 0xC76C51A3);
P(E, F, G, H, A, B, C, D, R(44), 0xD192E819);
P(D, E, F, G, H, A, B, C, R(45), 0xD6990624);
P(C, D, E, F, G, H, A, B, R(46), 0xF40E3585);
P(B, C, D, E, F, G, H, A, R(47), 0x106AA070);
P(A, B, C, D, E, F, G, H, R(48), 0x19A4C116);
P(H, A, B, C, D, E, F, G, R(49), 0x1E376C08);
P(G, H, A, B, C, D, E, F, R(50), 0x2748774C);
P(F, G, H, A, B, C, D, E, R(51), 0x34B0BCB5);
P(E, F, G, H, A, B, C, D, R(52), 0x391C0CB3);
P(D, E, F, G, H, A, B, C, R(53), 0x4ED8AA4A);
P(C, D, E, F, G, H, A, B, R(54), 0x5B9CCA4F);
P(B, C, D, E, F, G, H, A, R(55), 0x682E6FF3);
P(A, B, C, D, E, F, G, H, R(56), 0x748F82EE);
P(H, A, B, C, D, E, F, G, R(57), 0x78A5636F);
P(G, H, A, B, C, D, E, F, R(58), 0x84C87814);
P(F, G, H, A, B, C, D, E, R(59), 0x8CC70208);
P(E, F, G, H, A, B, C, D, R(60), 0x90BEFFFA);
P(D, E, F, G, H, A, B, C, R(61), 0xA4506CEB);
P(C, D, E, F, G, H, A, B, R(62), 0xBEF9A3F7);
P(B, C, D, E, F, G, H, A, R(63), 0xC67178F2);
ctx->state[0] += A;
ctx->state[1] += B;
ctx->state[2] += C;
ctx->state[3] += D;
ctx->state[4] += E;
ctx->state[5] += F;
ctx->state[6] += G;
ctx->state[7] += H;
}
Expect the hashing time to be withing a few seconds, not 100sec.
The difference in performance you did notice may be caused by one of both of the CPU Instructions/Data caches being disabled.
You can enable/disable both caches from u-boot provided that it was compiled with the icache/dcache commands.
If your u-boot does not already include the icache/dcache commands, you may have to re-compile it after having added the following line to the configuration file: CONFIG_CMD_CACHE=y.
Another option would be to enable it in your code programmatically prior to start computing the hash.
I have a List of case objects of which some values are NaNs and I have to replace them with 0.0. So far I tried this code:
var systemInformation: List[SystemInformation] = (x.getIndividualSystemInformation)
systemInformation.foreach[SystemInformation] {
_ match {
case SystemInformation(a, b, c, d, e, f, g, h, i, j, k, l, m, x) if x.isNaN()
=> SystemInformation(a, b, c, d, e, f, g, h, i, j, k, l, m, 0.0)
case SystemInformation(a, b, c, d, e, f, g, h, i, j, k, l, m, x) if !x.isNaN()
=> SystemInformation(a, b, c, d, e, f, g, h, i, j, k, l, m, x)
}
}
But that does not write the changes back to systemInformation. So I added another List but got a type mismatch:
var systemInformation: List[SystemInformation] = (x.getIndividualSystemInformation)
var systemInformationWithoutNans: ListBuffer[SystemInformation] = new ListBuffer[SystemInformation]
systemInformation.foreach[SystemInformation] {
_ match {
case SystemInformation(a, b, c, d, e, f, g, h, i, j, k, l, m, x) if x.isNaN()
=> systemInformationWithoutNans += SystemInformation(a, b, c, d, e, f, g, h, i, j, k, l, m, 0.0)
case SystemInformation(a, b, c, d, e, f, g, h, i, j, k, l, m, x) if !x.isNaN()
=> SystemInformation(a, b, c, d, e, f, g, h, i, j, k, l, m, x)
}
}
The error occurs on the line with the += and is the following:
type mismatch;
found : scala.collection.mutable.ListBuffer[com.x.interfaces.SystemInformation]
required: com.x.interfaces.SystemInformation
Why does this not work? What would be a better way to replace the NaNs with 0.0?
Use map as bluenote10 sugested, but additionally, what about:
val transformedSystemInformation = systemInformation map (_ match {
case s:SystemInformation if s.x.isNan() => s.copy(x = 0.0)
case _ => _
})
You should use map instead of foreach.
Your first solution is basically the right way to go, but foreach only iterates over all elements, whereas map allows to map the elements from type A to B returning a new collection of type B.
Since your first question is not answered above, I thought I would add that this doesn't work, because the method +=
def +=(x: A): ListBuffer.this.type
returns a ListBuffer[SystemInformation] in this case, but you have parameterized foreach by the type SystemInformation
foreach[SystemInformation]
which is why the compiler is expecting the type SystemInformation rather than ListBuffer[SystemInformation] and returns the error
type mismatch;
found : scala.collection.mutable.ListBuffer[com.x.interfaces.SystemInformation]
required: com.x.interfaces.SystemInformation
If, on the other hand, you remove the type parameterization from foreach, your example will compile:
...
systemInformation.foreach { ... }
...
For a better approach, used Ian McMahon's suggested approach.