First, my experience with tail recursion is very limited, second, after adding the TailFact() method and a little change to Times() method in the above class, I must say, I don't see any benefit of the TailFact() method. Quite the contrary, now the function have to push two values on the stack instead of one...
/// Factorial using tail_recursion/// ClassMethod TailFact(n)
{
quit..tfact(n,1)
}
ClassMethod tfact(n, f)
{
quit$select(n>1:..tfact(n-1,f*n),1:f)
}
/// There is a noticeable time difference between MulFact() and RecFact()./// /// Recursion helps to keep an algorithm clear an simple but needs more/// resources - for a few loops it's OK, but for many loops it's a no-go/// (beside a stack space, a stack frame must be prepared for each loop cycle)ClassMethod Times(n)
{
while$zh#1 {} s t1=$zh f i=1:1:1E6 { d..MulFact(n) } s t1=$zh-t1
while$zh#1 {} s t2=$zh f i=1:1:1E6 { d..RecFact(n) } s t2=$zh-t2
while$zh#1 {} s t3=$zh f i=1:1:1E6 { d..TailFact(n) } s t3=$zh-t3
write" Fact:",$j(t1,10,4),!,"Rfact:",$j(t2,10,4),!,"Tfact:",$j(t3,10,4),!
write"RDiff:",$j(t2-t1/t1*100,8,2),"%",!,"TDiff:",$j(t3-t1/t1*100,8,2),!
}
If I understand you correctly, you want for a given number of objects all the possible combinations? That is, if we have 3 objects (3 numbers, 3 words or whatever) then you want: 1 of 3 (3 possibilities): (1) (2) (3) 2 of 3 (3 possibilities): (1,2) (1,3) (2,3) 3 of 3 (1 possibility) : (1,2,3) For 3 objects there are in sum 7 possible combinations (see above). Your ^x(1,1) string contains 137 items. I'm pretty sure, you will never see that mutch combination...
Here some numbers for all possible combinations for:
1 item : 110 items: 1,02320 items: 1,048,57550 items: 1,125,899,906,842,62375 items: 37,778,931,862,957,161,730,000100 items: 1,267,650,600,228,229,401,000,000,000,000137 items: 174,224,571,863,520,493,300,000,000,000,000,000,000,000
ObjectScript
ObjectScript
A year has 365.25*86400, that are 31,557,600 seconds. With another words, you would need a computer system, which is able to genarate 5.5 * 10^33 combinations each second! I don't have such a beast, and I'm sure, you too.
Anyway, maybe the below class gives you some clue, how to compute and how to generate combinations. One more note, recursion is the tool to make (some) solutions clear and simple but recursion in loops, especially in loops with thousands or millions of passes, isn't a good idea. Beside of resources (stack, memory) for each new call a stackframe must be prepared and after the call removed again. This costs time, much time. Try that Times() method in the below class.
/// Some math functionsClass DC.Math Extends%RegisteredObject
{
/// Factorial by multiplication (the more practical way)/// Return n!/// ClassMethod MulFact(n)
{
for i=2:1:n-1set n=n*i
quit n+'n
}
/// Factorial by recursion (the way, people learn recursion in the school)/// Return n!/// ClassMethod RecFact(n)
{
quit$select(n>1:n*..RecFact(n-1),1:1)
}
/// There is a noticeable time difference between MulFact() and RecFact()./// /// Recursion helps to keep an algorithm clear an simple but needs more/// resources - for a few loops it's OK, but for many loops it's a no-go/// (beside a stack space, a stack frame must be prepared for each loop cycle)ClassMethod Times(n)
{
while$zh#1 {} s t1=$zh f i=1:1:1E6 { d..MulFact(n) } s t1=$zh-t1
while$zh#1 {} s t2=$zh f i=1:1:1E6 { d..RecFact(n) } s t2=$zh-t2
write" Fact:",$j(t1,10,4),!,"Rfact:",$j(t2,10,4),!," Diff:",$j(t2-t1/t1*100,8,2),"%",!
}
/// The Holy Trinity of the statistic functions: permutations, combinations and variations/// /// Here we go with the combinations./// /// Return the number of combinations (without repetition) of K elements from a set of N objects/// /// The number of possible combinations is: N over K/// which is the same as: N! / (K! * (N-K)!)/// /// Note:/// one can't make a direct use of the (above) Factorial function/// because the MAXNUM limit will be hit very soonClassMethod Comb(k, n)
{
set c=1fork=1:1:k { set c=c/k*n, n=n-1 } quit c
}
/// Return the sum of all possible combinations of N objects/// i.e. (1-of-n) + (2-of-n) + (3-of-n) + ... + (n-of-n)/// ClassMethod AllComb(n)
{
sets=0for i=1:1:n { sets=s+..Comb(i,n) } quits
}
/// Generate a list of combinations for K elements of N objects/// ClassMethod GenComb(k, n)
{
for i=1:1:kset e(i)=n-k+i
sets=0, c(0)=010sets=s+1, c(s)=c(s-1)
14for c(s)=c(s)+1:1:e(s) goto10:s<kdo..work1(.c,s)
16sets=s-1ifsgoto14:c(s)<e(s),16
}
/// This method is the workhorse/// either, print the combinations (one k-tuple at time)/// or do your own task.ClassMethod work1(c, s) [ Internal ]
{
write"("for i=1:1:swrite:i>1","write c(i)
write")",!
}
/// For example, you could use that ^x(1,1) string/// ClassMethod work2(c, s)
{
set t=^x(1,1)
write"(" f i=1:1:swrite:i>1","write$p(t,",",c(i))
write")",!
}
/// save each combination (OK, c(0) should be killed)/// ClassMethod work3(c, s)
{
m ^mtemp("comb",$i(^mtemp("comb")))=c
}
}
ObjectScript
ObjectScript
write ##class(...).Comb(3,4) to compute the combinations 3-of-4 (3 items of 4 objects) write ##class(...).AllComb(3) to compute all combinations of 3 objects (1-of-3 plus 2-of-3 plus 3-of-3) do ##class(...).GenComb(3,4) to show all 3-of-4 combinations For all possible combinations of N objects you must do a loop: for i=1:1:N do ##class(...).GenComb(i,N)
Just as an info, I can read cyrillic, I can talk serbian, consequently I understand a little bit (the emphasis is on little) Russian, and Ukrainian but I can't make the difference between the two. By the way, we try to solve problems and not language differences... 😉
Your screenshot says (last line, "ДОСТУП ..." ), access denied. So please check your connection details (hostname, port) and check the Windows firewall too. I assume, you want to connect to port 1972 or 5x77x, those ports are not open by default. For the next time, please translate that error messages, not everybody is fluent in russian.
I don't see any difference between SolutinA and SolutionB.
First, $$$OK is converted at COMPILE time into 1 and second, your test code neither has an execute nor an indirection - or do I miss something? But you can try the below code for timing difference
ClassMethod XTime()
{
f i=1:1:3d..exc()
w !
f i=1:1:3d..ind()
}
ClassMethod exc()
{
s arg="s x=1234_(1/2)"while$zh["." {} s t=$zh f i=1:1:1E6 { x arg } w$zh-t,!
}
ClassMethod ind()
{
s arg="x=1234_(1/2)"while$zh["." {} s t=$zh f i=1:1:1E6 { s @arg } w$zh-t,!
}
Indirection has its rule: Indirection works with PUBLIC variables, i.e. the variable, you address, mustbe a public variable, in your case the <arg> variable. This is due to compatibility with old applications, developed before the introduction of the block structure.
You have two options
instead of using argument indirection (what you currently do), use name indirection for label and routinname, see method Test1()
@lab and @(rou) because label- and routine-names are not variables.
If you want to keep argument indirection, just tell your class, that certain variables were PUBLIC see method Test2()
In your example, you got a wrong result because, by chance the variable <arg> was defined in the terminal session with the same value as in methode code, see method Test3()
kill// we kill all local variablesdo##class(your.class).Test1() ---> argument-1killdo##class(your.class).Test2() ---> argument-2killdo##class(your.class).Test3() ---> <UNDEF> *arg ==> missing arg
killset arg="surprise"do##class(your.class).Test3() ---> surprise
// you can prove things the other way tooset arg="my-value"// variables, defined in a terminal session are publicdo##class(your.class).Test1() ---> argument-1write arg --> my-value // arg wasn't overwritten!do##class(your.class).Test2() ---> argument-2write arg --> argument-2// arg IS OVERWRITTEN
ObjectScript
ObjectScript
Method Test3() shows, indirection works with public variables
Just in case anyone is upset about "command indirection". Yes, I know the correct term is "argument indirection". It's one of those old habits that never dies...
hello ; this is my hello-testquit
say(arg)
write arg,!
quit
add(x,y) Public
{
quitx + y
}
ObjectScript
ObjectScript
and some variable, set as follows
set rou="hello"set say="say", add="add"set a1=5,a2=10, arg="Hello World"set sayall="say^hello(arg)"set addall="$$add^hello(a1,a2)"
ObjectScript
ObjectScript
then you can do things like
do @sayall ---> Hello World // command indirectiondo @say^@(rou)(arg) ---> Hello World // name-indirectiondo @say^hello(arg) ---> Hello World // name-indirectiondo say^@(rou)(arg) ---> Hello World // name-indirectiondo say^hello(arg) ---> Hello World
write @addall ---> 15// command indirectionwrite $$@add^@(rou)(a1,a2) ---> 15// name-indirectionwrite $$@add^hello(a1,a2) ---> 15// name-indirectionwrite$$add^@(rou)(a1,a2) ---> 15// name-indirectionwrite$$add^hello(a1,a2) ---> 15// Caution, you can't dowrite @addall + 3// with "+ 3", the write command is turned into an// expression, and in turn, the indirection is now// a name-indirection. That gives you a SYNTAX error// but you can dowrite $$@add^@(rou)(a1,a2) + 3 --> 18
Class DC.Encoding Extends%RegisteredObject
{
/// Take an raw stream (i.e. unencoded) and/// output a new, Base64 encoded stream./// ClassMethod ToBase64(str)
{
// Base64 encoding means:// you take 3*N characters from the source// and put 4*N characters into the destination.// If the size of the source is not a multiple of 3 then// the last one or two bytes will be padded.// // If you take an N such that 4*N less or equal 32767// (the max size of a short string) then Cache or IRIS// can work with short strings, which perform (usually)// better than long strings// // N is integer.// // A good value for N is 8190,// so you read 24570 bytes from the source and write 32760 to the destination// // Of course, you can take whatever number up to 910286// (3 * 910286 = 2730858, 4 * 910286 = 3641144)// set len=8190*3set flg=1// this flag instructs $system.Encryption.Base64Encode// not to insert linebreaks at every 76 characterssetnew=##class(%Stream.GlobalCharacter).%New()
do str.Rewind()
while 'str.AtEnd {
donew.Write($system.Encryption.Base64Encode(str.Read(len),flg))
}
quitnew
}
/// Take a Base64 encoded stream/// and decode it to a new stream/// /// The method itself has no information about the decoded data/// hence it assumens binary data, but you, the caller (hopefully)/// knows more about your data and can provide the correct stream/// type for the decoder./// For exaple a character stream instead of binary.ClassMethod FromBase64(str, new = 0)
{
// Base64 decoding means:// you take 4*N characters from the source// and put 3*N characters into the destination// // If you take an N such that 4*N less or equal 32767// (the max size of a short string) then Cache or IRIS// can work with short strings, which perform (usually)// better than long strings// // N is integer.// // A good value for N is 8190,// so you read 24570 bytes from the source and write 32760 to the destination// // Of course, you can take whatever number up to 910286// (3 * 910286 = 2730858, 4 * 910286 = 3641144)// set len=8190*4set:'newnew=##class(%Stream.GlobalBinary).%New()
do str.Rewind()
while 'str.AtEnd {
donew.Write($system.Encryption.Base64Decode(str.Read(len)))
}
quitnew
}
ClassMethod Test(file)
{
set str=##class(%Stream.FileBinary).%New()
do str.LinkToFile(file)
write str.Size,!
set enc=..ToBase64(str)
write enc.Size,!
set dec=..FromBase64(enc)
write dec.Size,!
}
}
Class Example.Test Extends%Persistent
{
Property BodyText As list Of MyList;
}
Class Example.MyList Extends%SerialObject
{
Property Text As list Of %String;
}
ObjectScript
ObjectScript
The steps to add data:
set test=##class(Example.Test).%New()
set list1=##class(Example.MyList).%New()
do list1.Text.Insert("red")
do list1.Text.Insert("green")
do list1.Text.Insert("blue")
do test.BodyText.Insert(list1)
set list2=##class(Example.MyList).%New()
do list2.Text.Insert("Joe")
do list2.Text.Insert("Paul")
do list2.Text.Insert("Bob")
do test.BodyText.Insert(list2)
write test.%Save() --> 1zw^Example.TestD
^Example.TestD=1^Example.TestD(1)=$lb("",$lb($lb($lb($lb("red","green","blue"))),$lb($lb($lb("Joe","Paul","Bob")))))
zso test
BodyText(1).Text(1).: red
BodyText(1).Text(2).: green
BodyText(1).Text(3).: blue
BodyText(2).Text(1).: Joe
BodyText(2).Text(2).: Paul
BodyText(2).Text(3).: Bob
Assuming, your input value is an integer, you have , along with the other solutions, one more:
// this works as long as len < 145//set len = 120set inp = 12345write$e(1E120_inp,*-len+1,*)
// of course, if the len is shorter than, say 10,// then you can use smaller constans like//set len=10set inp=9write$e(1E10_inp,*-len+1,*)
ObjectScript
ObjectScript
A good (or even a bad) side effect of the above solution is, if you get an input value which is LONGER than the length, it will be truncated to the given length
By the way, if you need again and again a local timestamp with decimals, just create a user defined system variable. Make a one line entry into the %ZLANGV00.mac routine:
%ZLANGV00 ; User defined (system) variables// Local timestamp with decimals
ZLTS() quit$now($ztz-$s($SYSTEM.Util.IsDST():60,1:0))
ObjectScript
ObjectScript
You can use whatever name you want as long as it starts with Z, contains uppercase chars only and do not conflict with existing names. Use it as a standard $-variable
Together with $now() and timezone adjustment you can have the desired result
for time=$h, $now($ztz-$s($SYSTEM.Util.IsDST():60,1:0)) write time,?20,$zdt(time,3,1,3),!
// assuming 60 min summertime offset//// you should get an output like thisL67086,833342024-09-0323:08:54.00067086,83334.13410262024-09-0323:08:54.134
ObjectScript
ObjectScript
There is an (old) undocumented function which gives the $h value with several decimal places, unfortunately the recommended replacement is more or less the above solution instead of a simple $zlts (z-local-timestamp).
This is possible, but you have to use it the correct way. $SYSTEM.OBJ is just a shorthand for ##class(%SYSTEM.OBJECT), so the correct syntax for your desire is:
It shouldn't be invalid because there are no corresponding constraints.
At the beginning, I thought not to participate, because of the problematic specification and example, but now, as I see, I'm not the only one with questions without answers, hence I offer an 38 char solution too (including the hint to compiler flags) and a shorter version with 34 chars, a correkt result but with "a little bit" of side effect.
The problem is, the specification for this task is simple unprecise, and according to my opinion, gives a faulty example. Your exmple code has just a Set command but the task talks about "print out" - hence, I expected to see either a Write "whatever" or at last a Quit "whatever" comand. Also, if we talk about a method signature, I take in account the number of arguments (maybe their types) only and the return type but never their method keywords, as in the solution from Eduard, hence his solution is not only creative but valid too. I think, a fair way to mesure the size of a solution is, if you take the size of the routine which will be executed, and that is the INT routine, which is directly (we neglect the possible compiler optimizations, that's the compilers and not the users credit) compiled into a executable. How I got that code (some generator or via a macro or whatever other method) is actually irrelevant. A very good example for using or not using a method keyword is the "codemode=expression":
/// you save that "Quit " but have to write "codemode=expression"/// which is not taken in account by the Implementation.SizeClassMethod Test() [ codemode = expression]
{
123
}
/// you have to write "Quit " and save the writing of "codemode..."/// The Implementation.Size counts that "quit "ClassMethod Test2()
{
quit123
}
ObjectScript
ObjectScript
Whatever you choose, the corresponding INT code is always "quit ..."
So the bottom line is, either you should define all constraints and conditions or accept each end every clever solution.
go to post
First, my experience with tail recursion is very limited,
second, after adding the TailFact() method and a little change to Times() method in the above class, I must say, I don't see any benefit of the TailFact() method. Quite the contrary, now the function have to push two values on the stack instead of one...
/// Factorial using tail_recursion /// ClassMethod TailFact(n) { quit ..tfact(n,1) } ClassMethod tfact(n, f) { quit $select(n>1:..tfact(n-1,f*n),1:f) } /// There is a noticeable time difference between MulFact() and RecFact(). /// /// Recursion helps to keep an algorithm clear an simple but needs more /// resources - for a few loops it's OK, but for many loops it's a no-go /// (beside a stack space, a stack frame must be prepared for each loop cycle) ClassMethod Times(n) { while $zh#1 {} s t1=$zh f i=1:1:1E6 { d ..MulFact(n) } s t1=$zh-t1 while $zh#1 {} s t2=$zh f i=1:1:1E6 { d ..RecFact(n) } s t2=$zh-t2 while $zh#1 {} s t3=$zh f i=1:1:1E6 { d ..TailFact(n) } s t3=$zh-t3 write " Fact:",$j(t1,10,4),!,"Rfact:",$j(t2,10,4),!,"Tfact:",$j(t3,10,4),! write "RDiff:",$j(t2-t1/t1*100,8,2),"%",!,"TDiff:",$j(t3-t1/t1*100,8,2),! }and here some time values
USER>d ##class(DC.Math).Times(5) Fact: 0.3306 Rfact: 1.2199 Tfact: 1.4219 RDiff: 268.97% TDiff: 330.07 USER>d ##class(DC.Math).Times(10) Fact: 0.4433 Rfact: 2.3913 Tfact: 2.5549 RDiff: 439.40% TDiff: 476.28 USER>d ##class(DC.Math).Times(20) Fact: 0.7034 Rfact: 4.8017 Tfact: 5.2183 RDiff: 582.63% TDiff: 641.86go to post
If I understand you correctly, you want for a given number of objects all the possible combinations? That is, if we have 3 objects (3 numbers, 3 words or whatever) then you want:
1 of 3 (3 possibilities): (1) (2) (3)
2 of 3 (3 possibilities): (1,2) (1,3) (2,3)
3 of 3 (1 possibility) : (1,2,3)
For 3 objects there are in sum 7 possible combinations (see above). Your ^x(1,1) string contains 137 items. I'm pretty sure, you will never see that mutch combination...
Here some numbers for all possible combinations for: 1 item : 1 10 items: 1,023 20 items: 1,048,575 50 items: 1,125,899,906,842,623 75 items: 37,778,931,862,957,161,730,000 100 items: 1,267,650,600,228,229,401,000,000,000,000 137 items: 174,224,571,863,520,493,300,000,000,000,000,000,000,000A year has 365.25*86400, that are 31,557,600 seconds. With another words, you would need a computer system, which is able to genarate 5.5 * 10^33 combinations each second! I don't have such a beast, and I'm sure, you too.
Anyway, maybe the below class gives you some clue, how to compute and how to generate combinations. One more note, recursion is the tool to make (some) solutions clear and simple but recursion in loops, especially in loops with thousands or millions of passes, isn't a good idea. Beside of resources (stack, memory) for each new call a stackframe must be prepared and after the call removed again. This costs time, much time. Try that Times() method in the below class.
/// Some math functions Class DC.Math Extends %RegisteredObject { /// Factorial by multiplication (the more practical way) /// Return n! /// ClassMethod MulFact(n) { for i=2:1:n-1 set n=n*i quit n+'n } /// Factorial by recursion (the way, people learn recursion in the school) /// Return n! /// ClassMethod RecFact(n) { quit $select(n>1:n*..RecFact(n-1),1:1) } /// There is a noticeable time difference between MulFact() and RecFact(). /// /// Recursion helps to keep an algorithm clear an simple but needs more /// resources - for a few loops it's OK, but for many loops it's a no-go /// (beside a stack space, a stack frame must be prepared for each loop cycle) ClassMethod Times(n) { while $zh#1 {} s t1=$zh f i=1:1:1E6 { d ..MulFact(n) } s t1=$zh-t1 while $zh#1 {} s t2=$zh f i=1:1:1E6 { d ..RecFact(n) } s t2=$zh-t2 write " Fact:",$j(t1,10,4),!,"Rfact:",$j(t2,10,4),!," Diff:",$j(t2-t1/t1*100,8,2),"%",! } /// The Holy Trinity of the statistic functions: permutations, combinations and variations /// /// Here we go with the combinations. /// /// Return the number of combinations (without repetition) of K elements from a set of N objects /// /// The number of possible combinations is: N over K /// which is the same as: N! / (K! * (N-K)!) /// /// Note: /// one can't make a direct use of the (above) Factorial function /// because the MAXNUM limit will be hit very soon ClassMethod Comb(k, n) { set c=1 for k=1:1:k { set c=c/k*n, n=n-1 } quit c } /// Return the sum of all possible combinations of N objects /// i.e. (1-of-n) + (2-of-n) + (3-of-n) + ... + (n-of-n) /// ClassMethod AllComb(n) { set s=0 for i=1:1:n { set s=s+..Comb(i,n) } quit s } /// Generate a list of combinations for K elements of N objects /// ClassMethod GenComb(k, n) { for i=1:1:k set e(i)=n-k+i set s=0, c(0)=0 10 set s=s+1, c(s)=c(s-1) 14 for c(s)=c(s)+1:1:e(s) goto 10:s<k do ..work1(.c,s) 16 set s=s-1 if s goto 14:c(s)<e(s),16 } /// This method is the workhorse /// either, print the combinations (one k-tuple at time) /// or do your own task. ClassMethod work1(c, s) [ Internal ] { write "(" for i=1:1:s write:i>1 "," write c(i) write ")",! } /// For example, you could use that ^x(1,1) string /// ClassMethod work2(c, s) { set t=^x(1,1) write "(" f i=1:1:s write:i>1 "," write $p(t,",",c(i)) write ")",! } /// save each combination (OK, c(0) should be killed) /// ClassMethod work3(c, s) { m ^mtemp("comb",$i(^mtemp("comb")))=c } }write ##class(...).Comb(3,4) to compute the combinations 3-of-4 (3 items of 4 objects)
write ##class(...).AllComb(3) to compute all combinations of 3 objects (1-of-3 plus 2-of-3 plus 3-of-3)
do ##class(...).GenComb(3,4) to show all 3-of-4 combinations
For all possible combinations of N objects you must do a loop:
for i=1:1:N do ##class(...).GenComb(i,N)
go to post
Just as an info, I can read cyrillic, I can talk serbian, consequently I understand a little bit (the emphasis is on little) Russian, and Ukrainian but I can't make the difference between the two. By the way, we try to solve problems and not language differences... 😉
go to post
Your screenshot says (last line, "ДОСТУП ..." ), access denied. So please check your connection details (hostname, port) and check the Windows firewall too. I assume, you want to connect to port 1972 or 5x77x, those ports are not open by default. For the next time, please translate that error messages, not everybody is fluent in russian.
go to post
I don't see any difference between SolutinA and SolutionB.
First, $$$OK is converted at COMPILE time into 1 and second, your test code neither has an execute nor an indirection - or do I miss something? But you can try the below code for timing difference
ClassMethod XTime() { f i=1:1:3 d ..exc() w ! f i=1:1:3 d ..ind() } ClassMethod exc() { s arg="s x=1234_(1/2)" while $zh["." {} s t=$zh f i=1:1:1E6 { x arg } w $zh-t,! } ClassMethod ind() { s arg="x=1234_(1/2)" while $zh["." {} s t=$zh f i=1:1:1E6 { s @arg } w $zh-t,! }go to post
Indirection has its rule: Indirection works with PUBLIC variables,
i.e. the variable, you address, mustbe a public variable, in your case the <arg> variable.
This is due to compatibility with old applications,
developed before the introduction of the block structure.
You have two options
instead of using argument indirection (what you currently do),
use name indirection for label and routinname, see method Test1()
@lab and @(rou) because label- and routine-names are not variables.
If you want to keep argument indirection, just tell your class, that certain variables were PUBLIC
see method Test2()
In your example, you got a wrong result because, by chance the variable <arg> was defined in the terminal session with the same value as in methode code, see method Test3()
ClassMethod Test1() { s arg="argument-1" s lab="say", rou="hello" d @lab^@(rou)(arg) } ClassMethod Test2() [ PublicList = arg ] { s arg = "argument-2" s routine = "say^hello(arg)" d @routine } ClassMethod Test3() { s routine = "say^hello(arg)" d @routine }Now some tests in a terminal
kill // we kill all local variables do ##class(your.class).Test1() ---> argument-1 kill do ##class(your.class).Test2() ---> argument-2 kill do ##class(your.class).Test3() ---> <UNDEF> *arg ==> missing arg kill set arg="surprise" do ##class(your.class).Test3() ---> surprise // you can prove things the other way too set arg="my-value" // variables, defined in a terminal session are public do ##class(your.class).Test1() ---> argument-1 write arg --> my-value // arg wasn't overwritten! do ##class(your.class).Test2() ---> argument-2 write arg --> argument-2 // arg IS OVERWRITTENMethod Test3() shows, indirection works with public variables
go to post
Just in case anyone is upset about "command indirection". Yes, I know the correct term is "argument indirection". It's one of those old habits that never dies...
go to post
I assume, you have a routine 'hello' like this
hello ; this is my hello-test quit say(arg) write arg,! quit add(x,y) Public { quit x + y }and some variable, set as follows
set rou="hello" set say="say", add="add" set a1=5,a2=10, arg="Hello World" set sayall="say^hello(arg)" set addall="$$add^hello(a1,a2)"then you can do things like
do @sayall ---> Hello World // command indirection do @say^@(rou)(arg) ---> Hello World // name-indirection do @say^hello(arg) ---> Hello World // name-indirection do say^@(rou)(arg) ---> Hello World // name-indirection do say^hello(arg) ---> Hello World write @addall ---> 15 // command indirection write $$@add^@(rou)(a1,a2) ---> 15 // name-indirection write $$@add^hello(a1,a2) ---> 15 // name-indirection write $$add^@(rou)(a1,a2) ---> 15 // name-indirection write $$add^hello(a1,a2) ---> 15 // Caution, you can't do write @addall + 3 // with "+ 3", the write command is turned into an // expression, and in turn, the indirection is now // a name-indirection. That gives you a SYNTAX error // but you can do write $$@add^@(rou)(a1,a2) + 3 --> 18go to post
should do the trick.
go to post
See the example class below
Class DC.Encoding Extends %RegisteredObject { /// Take an raw stream (i.e. unencoded) and /// output a new, Base64 encoded stream. /// ClassMethod ToBase64(str) { // Base64 encoding means: // you take 3*N characters from the source // and put 4*N characters into the destination. // If the size of the source is not a multiple of 3 then // the last one or two bytes will be padded. // // If you take an N such that 4*N less or equal 32767 // (the max size of a short string) then Cache or IRIS // can work with short strings, which perform (usually) // better than long strings // // N is integer. // // A good value for N is 8190, // so you read 24570 bytes from the source and write 32760 to the destination // // Of course, you can take whatever number up to 910286 // (3 * 910286 = 2730858, 4 * 910286 = 3641144) // set len=8190*3 set flg=1 // this flag instructs $system.Encryption.Base64Encode // not to insert linebreaks at every 76 characters set new=##class(%Stream.GlobalCharacter).%New() do str.Rewind() while 'str.AtEnd { do new.Write($system.Encryption.Base64Encode(str.Read(len),flg)) } quit new } /// Take a Base64 encoded stream /// and decode it to a new stream /// /// The method itself has no information about the decoded data /// hence it assumens binary data, but you, the caller (hopefully) /// knows more about your data and can provide the correct stream /// type for the decoder. /// For exaple a character stream instead of binary. ClassMethod FromBase64(str, new = 0) { // Base64 decoding means: // you take 4*N characters from the source // and put 3*N characters into the destination // // If you take an N such that 4*N less or equal 32767 // (the max size of a short string) then Cache or IRIS // can work with short strings, which perform (usually) // better than long strings // // N is integer. // // A good value for N is 8190, // so you read 24570 bytes from the source and write 32760 to the destination // // Of course, you can take whatever number up to 910286 // (3 * 910286 = 2730858, 4 * 910286 = 3641144) // set len=8190*4 set:'new new=##class(%Stream.GlobalBinary).%New() do str.Rewind() while 'str.AtEnd { do new.Write($system.Encryption.Base64Decode(str.Read(len))) } quit new } ClassMethod Test(file) { set str=##class(%Stream.FileBinary).%New() do str.LinkToFile(file) write str.Size,! set enc=..ToBase64(str) write enc.Size,! set dec=..FromBase64(enc) write dec.Size,! } }go to post
In case, you talk about Cache/IRIS-Classes:
Class Example.Test Extends %Persistent { Property BodyText As list Of MyList; } Class Example.MyList Extends %SerialObject { Property Text As list Of %String; }The steps to add data:
set test=##class(Example.Test).%New() set list1=##class(Example.MyList).%New() do list1.Text.Insert("red") do list1.Text.Insert("green") do list1.Text.Insert("blue") do test.BodyText.Insert(list1) set list2=##class(Example.MyList).%New() do list2.Text.Insert("Joe") do list2.Text.Insert("Paul") do list2.Text.Insert("Bob") do test.BodyText.Insert(list2) write test.%Save() --> 1 zw ^Example.TestD ^Example.TestD=1 ^Example.TestD(1)=$lb("",$lb($lb($lb($lb("red","green","blue"))),$lb($lb($lb("Joe","Paul","Bob"))))) zso test BodyText(1).Text(1).: red BodyText(1).Text(2).: green BodyText(1).Text(3).: blue BodyText(2).Text(1).: Joe BodyText(2).Text(2).: Paul BodyText(2).Text(3).: Bobgo to post
Assuming, your input value is an integer, you have , along with the other solutions, one more:
// this works as long as len < 145 // set len = 120 set inp = 12345 write $e(1E120_inp,*-len+1,*) // of course, if the len is shorter than, say 10, // then you can use smaller constans like // set len=10 set inp=9 write $e(1E10_inp,*-len+1,*)A good (or even a bad) side effect of the above solution is, if you get an input value which is LONGER than the length, it will be truncated to the given length
go to post
By the way, if you need again and again a local timestamp with decimals, just create a user defined system variable. Make a one line entry into the %ZLANGV00.mac routine:
%ZLANGV00 ; User defined (system) variables // Local timestamp with decimals ZLTS() quit $now($ztz-$s($SYSTEM.Util.IsDST():60,1:0))You can use whatever name you want as long as it starts with Z, contains uppercase chars only and do not conflict with existing names. Use it as a standard $-variable
write $zlts, $zdt($zlts,3,1,3) 67086,85681.092746 2024-09-03 23:48:01.092go to post
Together with $now() and timezone adjustment you can have the desired result
for time=$h, $now($ztz-$s($SYSTEM.Util.IsDST():60,1:0)) write time,?20,$zdt(time,3,1,3),! // assuming 60 min summertime offset // // you should get an output like thisL 67086,83334 2024-09-03 23:08:54.000 67086,83334.1341026 2024-09-03 23:08:54.134There is an (old) undocumented function which gives the $h value with several decimal places, unfortunately the recommended replacement is more or less the above solution instead of a simple $zlts (z-local-timestamp).
go to post
This is possible, but you have to use it the correct way. $SYSTEM.OBJ is just a shorthand for ##class(%SYSTEM.OBJECT), so the correct syntax for your desire is:
job ##class(%SYSTEM.OBJ).Export("yourRoutine.mac","yourPathAndFilename.xml")go to post
in a routine or class, the line
ClassMethod ALine() { quit $st($st,"MCODE") }gives you the line quit $st($st,"MCODE")
The systemvariable $zname gives you the name of the routine, where you reference $zname and in a classmethod $this gives you the name of the class
go to post
We need the source code, so the compiler flag for keeping the source must be on. The 38 char version does the job
ClassMethod ascii() [ ProcedureBlock = 0 ] { x n i f i=32:1:126 w:$t(x)'[$c(i) *i }The 34-character version does the job too has a side effect (leaving the variable i with the last value)
ClassMethod ascii() [ ProcedureBlock = 0 ] { y f i=32:1:126 w:$t(y)'[$c(i) *i }go to post
It shouldn't be invalid because there are no corresponding constraints.
At the beginning, I thought not to participate, because of the problematic specification and example, but now, as I see, I'm not the only one with questions without answers, hence I offer an 38 char solution too (including the hint to compiler flags) and a shorter version with 34 chars, a correkt result but with "a little bit" of side effect.
go to post
The problem is, the specification for this task is simple unprecise, and according to my opinion, gives a faulty example. Your exmple code has just a Set command but the task talks about "print out" - hence, I expected to see either a Write "whatever" or at last a Quit "whatever" comand.
Also, if we talk about a method signature, I take in account the number of arguments (maybe their types) only and the return type but never their method keywords, as in the solution from Eduard, hence his solution is not only creative but valid too.
I think, a fair way to mesure the size of a solution is, if you take the size of the routine which will be executed, and that is the INT routine, which is directly (we neglect the possible compiler optimizations, that's the compilers and not the users credit) compiled into a executable. How I got that code (some generator or via a macro or whatever other method) is actually irrelevant.
A very good example for using or not using a method keyword is the "codemode=expression":
/// you save that "Quit " but have to write "codemode=expression" /// which is not taken in account by the Implementation.Size ClassMethod Test() [ codemode = expression] { 123 } /// you have to write "Quit " and save the writing of "codemode..." /// The Implementation.Size counts that "quit " ClassMethod Test2() { quit 123 }Whatever you choose, the corresponding INT code is always "quit ..."
So the bottom line is, either you should define all constraints and conditions or accept each end every clever solution.
go to post
ClassMethod TimeDiff(inpTime = "2024-08-07 17:58:51.563") { set current=$h // or $now(tz-offset) set inpTime=$zdth(inpTime,3) quit current-inpTime*86400+$p(current,",",2)-$p(inpTime,",",2) }