00:00:00 --- log: started forth/18.11.10
00:04:20 --- quit: wa5qjh (Remote host closed the connection)
00:08:35 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
00:09:29 --- quit: wa5qjh (Remote host closed the connection)
00:14:48 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
00:19:59 --- quit: wa5qjh (Remote host closed the connection)
00:22:46 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
00:30:23 --- join: dys (~dys@tmo-115-88.customers.d1-online.com) joined #forth
00:31:38 --- quit: nighty- (Quit: Disappears in a puff of smoke)
01:35:57 --- quit: wa5qjh (Remote host closed the connection)
01:38:09 --- join: wa5qjh (~quassel@175.158.225.202) joined #forth
01:38:09 --- quit: wa5qjh (Changing host)
01:38:10 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
01:57:55 --- quit: wa5qjh (Remote host closed the connection)
02:01:02 --- join: wa5qjh (~quassel@175.158.225.202) joined #forth
02:01:02 --- quit: wa5qjh (Changing host)
02:01:02 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
02:03:30 --- quit: wa5qjh (Remote host closed the connection)
02:04:10 --- quit: ashirase (Ping timeout: 272 seconds)
02:08:09 --- join: wa5qjh (~quassel@175.158.225.202) joined #forth
02:08:09 --- quit: wa5qjh (Changing host)
02:08:09 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
02:08:20 --- quit: wa5qjh (Remote host closed the connection)
02:08:23 --- join: ashirase (~ashirase@modemcable098.166-22-96.mc.videotron.ca) joined #forth
02:44:16 --- join: wa5qjh (~quassel@175.158.225.202) joined #forth
02:44:16 --- quit: wa5qjh (Changing host)
02:44:16 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
02:45:04 --- join: nighty- (~nighty@s229123.ppp.asahi-net.or.jp) joined #forth
02:59:03 --- join: ncv_ (~neceve@2a02:c7d:c5c9:a900:1ec6:932f:1b02:d27e) joined #forth
02:59:03 --- quit: ncv_ (Changing host)
02:59:03 --- join: ncv_ (~neceve@unaffiliated/neceve) joined #forth
03:00:28 --- quit: ncv (Ping timeout: 252 seconds)
03:07:18 --- quit: ncv_ (Remote host closed the connection)
03:07:39 --- join: ncv_ (~neceve@unaffiliated/neceve) joined #forth
03:17:02 --- quit: wa5qjh (Remote host closed the connection)
03:19:08 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
03:27:39 --- quit: wa5qjh (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.)
03:28:00 --- join: SopaXorzTaker (~SopaXorzT@unaffiliated/sopaxorztaker) joined #forth
03:52:34 --- nick: TheCephalopod -> john_cephalopoda
03:52:57 <john_cephalopoda> dave0: Hey, you missed my solution to your getline program: https://thecutecuttlefish.org/tmp/getline.fth
03:54:29 <dave0> cool!
03:56:41 <john_cephalopoda> I handled c-addr as offset and n as size that I increment.
03:58:03 <dave0> WilhelmVonWeiner did that too
03:58:26 <dave0> then there's only 1 number to worry about
03:59:07 <dave0> you indented your code like C code
03:59:18 <dave0> i laughed when KipIngram pointed out that i indent like c heh
04:07:50 <john_cephalopoda> I followed the code style that you had.
04:08:13 <dave0> ah :-)
04:08:23 <john_cephalopoda> Usually I indent, too, but a little differently: https://thecutecuttlefish.org/mandelbrot1.html
04:12:30 <dave0> that's cool
04:16:17 <dave0> i like how the main loop is like   right? left? up? down?    really simple-looking
04:32:47 <john_cephalopoda> Have you tried it out yet?
04:33:23 <john_cephalopoda> With "p" you can print the current view into a farbfeld image.
04:52:01 <WilhelmVonWeiner> You're storing the image in memory with a header?
04:52:36 <WilhelmVonWeiner> I would just write out the bytes to the destination file
04:53:38 <WilhelmVonWeiner> you might like the word C' which I define as `: C' DUP POSTPONE [CHAR] ; IMMEDIATE` john_cephalopoda 
04:53:58 --- quit: ncv_ (Ping timeout: 252 seconds)
04:54:03 <WilhelmVonWeiner> saves you typing dup [char] every time 
04:54:27 <WilhelmVonWeiner> or just use the decimal codes lol
04:54:53 --- join: Mat4 (~eh@ip5b409c40.dynamic.kabel-deutschland.de) joined #forth
04:57:07 <Mat4> hello
04:57:14 <WilhelmVonWeiner> ello ello
05:00:08 --- join: ncv (~neceve@90.194.11.55) joined #forth
05:00:08 --- quit: ncv (Changing host)
05:00:08 --- join: ncv (~neceve@unaffiliated/neceve) joined #forth
05:05:59 <Mat4> ‚you forget the H’ term.Ln +; ° :loop
05:08:47 <Mat4> sorry … term.Ln +; term.out ° :loop
05:10:35 <SopaXorzTaker> What's up with colorForth?
05:11:24 <WilhelmVonWeiner> nothing at the moment, never really caught on
05:11:48 <SopaXorzTaker> I kind of like Charles Moore for being so religiously obsessed with it
05:12:38 <SopaXorzTaker> First, he designed colorForth, then he wrote a Forth OS. Next he wrote a VLSI CAD in it to design CPUs that run Forth.
05:13:55 <WilhelmVonWeiner> I think that's in reverse. OKAD for his VLSI I believe was pre-CF 
05:14:19 <WilhelmVonWeiner> and Forth OSes have been around the longest.
05:14:31 <Mat4> there is some development incorporating some concepts of colorForth. The prefix handling oft Retro is an example
05:15:17 <WilhelmVonWeiner> I would write colorForth if I had a floppy of it to run.
05:15:48 <Mat4> you can use RainbowForth instead
05:16:32 <WilhelmVonWeiner> I run OpenBSD lol.
05:17:04 <john_cephalopoda> I'd like to have an OS written in ANS Forth.
05:17:23 <john_cephalopoda> With a minimal core in ASM or C. 
05:17:40 <john_cephalopoda> Device drivers written in Forth.
05:19:22 <WilhelmVonWeiner> Why ANS Forth?
05:19:49 <WilhelmVonWeiner> Why not just "The fastest, most complete, most relevant Forth"
05:20:43 <john_cephalopoda> WilhelmVonWeiner: And what is "The fastest, most complete, most relevant Forth"?
05:20:50 <WilhelmVonWeiner> And I mean, if it's a self-contained OS, why would it need to be ANS
05:21:21 <Mat4> WilhelmVonWeiner: Habe not looked St the sources for Quote some time. Anyhow, a port would require only minor changes
05:21:26 <WilhelmVonWeiner> john_cephalopoda: that's my point, ANS is nonspecific
05:21:42 <john_cephalopoda> WilhelmVonWeiner: But ANS is standardized.
05:22:12 * Mat4 this autocorrection nerves
05:22:19 <WilhelmVonWeiner> http://www.ultratechnology.com/antiansi.htm
05:22:19 <john_cephalopoda> I don't say that extensions shouldn't be possible. I'd definitely add some additional APIs to do things.
05:22:23 <WilhelmVonWeiner>  ANSI Forth is ANTI Forth
05:23:01 <WilhelmVonWeiner> an interesting line:
05:23:04 <WilhelmVonWeiner> "What I say is that ANSI Forth is just way too big and gives people way way too much room to stay with their bad programming habits from other languages. It certifies and standardizes on lots of bad habits."
05:23:21 <Mat4> ah yes
05:28:05 <john_cephalopoda> I think that retro definitely has some good ideas. Like the one to have some kind of namespaces like f: and c:.
05:28:38 <WilhelmVonWeiner> those are really just word names, I don't think they have actual namespacing
05:28:58 <WilhelmVonWeiner> crc was working on actual namespaces for words actually
05:29:16 <WilhelmVonWeiner> and {{ ---reveal--- }} lets you scope words
05:29:34 <john_cephalopoda> What would actual namespaces do different?
05:30:17 <WilhelmVonWeiner> personally, no idea
05:31:06 <john_cephalopoda> Hmm, the only issue with f:, c: and so on is, that common actions are prefix-less.
05:31:36 <WilhelmVonWeiner> those aren't prefixes (by default)
05:32:08 <WilhelmVonWeiner> unless you were to define a :prefix:c and :prefix:f
05:32:27 <Mat4> exporting sets of specific words for example. However I doubt ANSI Forth support such features .. at least in a well defined way 
05:34:00 <john_cephalopoda> In C++, you got stuff like "using namespace std;" - If you don't do that, you'll have to write "std::cout" etc. all the time.
05:34:15 <john_cephalopoda> This is useful when you want to avoid collisions between words.
05:34:22 <WilhelmVonWeiner> I mean, just name your words better
05:34:25 <WilhelmVonWeiner> use less words
05:34:49 <WilhelmVonWeiner> or do what Retro has done and, since it's forth, use whatever characters you want in a word name
05:34:55 <john_cephalopoda> One thing that is pretty useless is S" imo.
05:35:13 <WilhelmVonWeiner> `:std::cout s:put ;` lol
05:35:28 <WilhelmVonWeiner> what's wrong with s"?
05:35:41 <john_cephalopoda> S" puts a string into scratch, which is some memory space with undefined length.
05:35:50 <john_cephalopoda> (>= 80 chars)
05:35:58 <Mat4> namespaces allow higher level abstractions which is useful for larger programs
05:36:12 <john_cephalopoda> Let's just write a new, better Forth standard :þ
05:36:22 <john_cephalopoda> And then write an OS on top of that.
05:37:01 <WilhelmVonWeiner> Mat4: do they do anything vocabularies don't?
05:37:30 <john_cephalopoda> Brb, going for food.
05:37:53 --- join: rdrop-exit (~markwilli@112.201.162.180) joined #forth
05:39:28 <Mat4> yes. There allow specific assemblations of the visible word list though intersections and so on ... but as written this is likely impossible to implement for an ANS Forth
05:40:38 <WilhelmVonWeiner> honestly just sounds like you're never going to ever in your life need it
05:41:40 <WilhelmVonWeiner> grab the token by parsing the input stream and prepend std:: or math:: before executing it if you're dying to, right?
05:41:44 <WilhelmVonWeiner> lol.
05:42:13 <Mat4> as written it is of use for larger programs epbecause such possibility allows higher level organisations of the source code
05:43:15 <WilhelmVonWeiner> honestly sounds like Forth is a square peg and namespacing is your series of non-square holes
05:43:28 <WilhelmVonWeiner> non-rectangular holes
05:44:09 <Mat4> a somewhat useful general purpose operating system would benefit for example
05:44:46 <WilhelmVonWeiner> You mean like the namespaceless C kernels such as 4.4BSD and Linux
05:44:50 <WilhelmVonWeiner> or Minix
05:49:27 <Mat4> the thing is that Forth require some naming convention for structuring the source code. Why not incorporate this convention to the language? This is not a problem for small programs.
05:50:24 <rdrop-exit> Forth doesn't require a naming convention
05:50:41 <rdrop-exit> You're free to use any naming convention you like
05:51:05 --- join: dddddd (~dddddd@unaffiliated/dddddd) joined #forth
05:53:36 <Mat4> lol
05:53:49 <Mat4> ciao
05:53:54 --- quit: Mat4 (Quit: Yaaic - Yet another Android IRC client - http://www.yaaic.org)
05:54:28 <rdrop-exit> Well that escalated quickly
05:55:17 <WilhelmVonWeiner> rdrop-exit: It's the ANS curse!
05:55:42 <WilhelmVonWeiner> Java has `static public template generator`s, we need them in Forth
05:57:39 <rdrop-exit> Oh well
05:58:04 <john_cephalopoda> Imo having naming _conventions_ is a nice thing.
05:58:53 <john_cephalopoda> E.g. saying "If you are writing a library, please invent a prefix and append them to your word".
05:59:24 <WilhelmVonWeiner> Well we kind-of do - char words start with C, string or single with S, Floats with F, Return stack wih R
05:59:53 <WilhelmVonWeiner> Prefixes get annoying. It's why in Python you can can `from x import y as z`.
06:00:12 <john_cephalopoda> Yup. "numpy as np" :þ
06:00:28 <WilhelmVonWeiner> I kind of like your idea in that `requires` or `include` could prefix the filename or the first line of a file as a word prefix.
06:01:04 <WilhelmVonWeiner> `import random.fs` and then you have RANDOM.RANDOM, RANDOM.RND etc etc, but seems pointless in practice
06:10:33 --- quit: pierpal (Quit: Poof)
06:10:53 --- join: pierpal (~pierpal@host192-32-dynamic.1-87-r.retail.telecomitalia.it) joined #forth
06:16:27 <rdrop-exit> If I were to use library in a Forth, the first step would be to load it into a vocabulary.
06:31:53 <rdrop-exit> chat later, gotta run
06:32:00 --- quit: rdrop-exit (Quit: Lost terminal)
06:32:29 <WilhelmVonWeiner> dave9: https://ghostbin.com/paste/n5ws3/raw
06:32:51 <WilhelmVonWeiner> This version takes a maximum length parameter and doesn't allow the buffer to extend past it
06:33:50 * dave0 clicks
06:35:22 <WilhelmVonWeiner> I would actually change `: LIMITER 2DUP >= ` to `: LIMITER 2DUP =` that way you can set -1 and have an <integer>-long input string overflowing your buffer
06:36:48 <dave0> it's way different style to me
06:37:28 <dave0> CRNL? BS? PRINTABLE?    is cool
06:41:47 <WilhelmVonWeiner> I think I learned it from Sam Falvo's programming video on Youtube
06:41:57 <WilhelmVonWeiner> there's one that's like an hour long but so worth it
06:42:13 <WilhelmVonWeiner> and then you see a tree diagram in Starting Forth and it all makes sense
07:28:19 --- quit: dys (Ping timeout: 245 seconds)
07:48:46 --- join: rdrop-exit (~markwilli@112.201.162.180) joined #forth
07:57:29 --- quit: SopaXorzTaker (Quit: Leaving)
08:02:47 <rdrop-exit> There seems to be a lot of unecessary stack movement in that program.
08:03:55 <rdrop-exit> You should almost never have 2 stack operators back to back.
08:06:41 <rdrop-exit> e.g. "dup dup 10 = swap 13 = or" could be "dup 10 =  over 13 = or"
08:08:31 --- join: Mat4 (~eh@ip5b409c40.dynamic.kabel-deutschland.de) joined #forth
08:09:18 <rdrop-exit> Also where are the stack comments?
08:13:28 <KipIngram> I have conditional operators that keep one of the stack items.  So I could write your second revision above instead of
08:13:33 <KipIngram> dup 10 = over 13 = or
08:13:38 <KipIngram> 10 .= over 13 = or
08:14:27 <KipIngram> I noticed I was writing a lot of "dup <conditional>" bits, so I've wound up using those new conditionals a lot.
08:14:51 <KipIngram> But what I'm prone to do is avoid the or as well.
08:15:02 <KipIngram> I factor that stuff into a word and use conditional returns.
08:15:10 <KipIngram> Overall shortens the code even more.
08:15:26 <KipIngram> I'd have something like
08:15:56 <KipIngram> 10 .= 0=; 13 = 0=; ...code...
08:16:16 <rdrop-exit> I use conditional returns as well 0; ?; ?bail; 0bail; etc...
08:16:19 <KipIngram> Actually that's not quite right - it would need to be this:
08:16:39 <KipIngram> 10 .= 0=; 13 .= 0=; ...code...
08:16:51 <Mat4> ah, that's my programming style as well
08:16:58 <KipIngram> The data would still be on the stack if either of the 0=; items returned.
08:17:00 <rdrop-exit> I'd expect a word whose name ends in "?" to return a flag
08:19:54 <KipIngram> I expect words with ? to make a decision in some way, but returning a flag is just one way.
08:20:09 <KipIngram> It could also be "do something if the decision goes one way; return otherwise."
08:20:29 <KipIngram> So I guess I look at it in a bit more abstract way, but I generally agree ? should imply "decision related."
08:20:45 <rdrop-exit> I would factor the question from the action.
08:22:17 <rdrop-exit> Or rather I should say that when I have a name ending in "?" it's that I've factored the condition from the actions.
08:23:50 <Mat4> ??-nn 13 10 Π | ...code...
08:24:22 <rdrop-exit> huh?
08:24:26 <KipIngram> Oh - you're somehow comparing against both at once?
08:24:45 <KipIngram> Do ??-nn and ? work together somehow?
08:25:13 <Mat4> yes, there are packed as vector
08:25:22 <KipIngram> Interesting.  :-)
08:25:31 <KipIngram> I'm going to have to think about that sort of thing.
08:26:11 <KipIngram> rdop-exit: So I guess I also regard ? as fair naming for words that optionally do something.
08:27:05 <Mat4> ??-nn convert the topmost two stack items of any data format into two cardinal values
08:27:31 <rdrop-exit> Wow, overhead.
08:28:05 <Mat4> yes because all values are implicit typed
08:28:34 <rdrop-exit> You mean explicitly typed?
08:29:53 <rdrop-exit> When I choose to treat a machine word as a 2's complement number, I consider that an implicit type
08:29:55 <Mat4> both: the number 1234 will be of type cardinal, 1.23i will be of type complex for example
08:30:26 <rdrop-exit> So you're explicitly storing type information somewhere?
08:34:04 <KipIngram> rdrop-exit: The stack comment for .= would be like so:
08:34:22 <KipIngram> : .=  ( data compare_value -- data flag) ... ;
08:34:36 <KipIngram> It's useful when I need to compare the data to several different things.
08:35:03 <KipIngram> .=; has this:
08:35:23 <KipIngram> : .=;  ( data compare_value -- data) ... ;
08:35:33 <KipIngram> Doesn't leave a flag - it just returns or not based on the comparison.
08:36:09 <Mat4> the type is selected dependent of the data format and tagged for it stack position though the parser. The stack itself is virtual as each parsed token is compiled beside parsing
08:37:25 <KipIngram> rdrop-exit: My own thoughts an types are that I'll eventually add a "type stack" that's managed completely by the interpreter/compiler.  It will just get updated based on type info in stack comments.
08:37:37 <KipIngram> And will affect what words are found during dictionary searches.
08:37:58 <KipIngram> Once a word is compiled, it will no longer be relevant - that word will run exactly as it does in a regular system.
08:38:27 <KipIngram> It just automated things like "I just entered to integers, so I need +" vs. "I just entered two floats so I needd F+"
08:38:32 <rdrop-exit> I don't see the point, too much under the hood
08:38:50 <KipIngram> The compiler will just see that the top two items are floats, so it will look for a word + that takes two floats and compile that.
08:39:04 <rdrop-exit> You'd end up with the equivalent of casting
08:39:09 <KipIngram> The point for me is to enable implementation of environments like Matlab / Octave.
08:39:26 <KipIngram> I don't want the type stack in my base system - it will be an add-on that's used in certain applications.
08:39:45 <KipIngram> Yes, if you had a float and needed an int you'd need a "cast."
08:39:49 <rdrop-exit> If the application requires it then that's a different story.
08:40:00 <KipIngram> But we have that anyway in the form of s>f and f>s.
08:40:15 <KipIngram> Right - I view it as an application support extension.
08:40:19 <KipIngram> Not part of "the system."
08:40:25 <rdrop-exit> We do, but it doesn't happen under the hood.
08:40:26 <KipIngram> I have nothing along those lines in my Forth right now.
08:41:14 <KipIngram> I don't mind contemplating extensions to the compiler/interpreter.
08:41:32 <KipIngram> But I guard run-time execution pretty strongly.
08:41:43 <KipIngram> I don't want anything that winds up adding run-time overhead.
08:41:58 <rdrop-exit> Makes sense
08:43:13 <KipIngram> Having stack effects documented in the headers in a compiler-accessible way brings other benefits too.
08:43:23 <KipIngram> For example, you'd be able to pretty much guarantee no underflow.
08:43:48 <KipIngram> The dictonary search just wouldn't FIND a word that needed more arguments than are present.
08:44:16 <rdrop-exit> I use circular stacks
08:44:22 <KipIngram> Ah, right.
08:44:23 <KipIngram> I don't.
08:45:08 <KipIngram> So when I get that stuff all working, I'll be able to do something like this:
08:45:26 <rdrop-exit> They can never physically underflow or underflow. If they logically overflow or underflow you have a bug.
08:45:30 <KipIngram> [ [ 1 2 3 ] [ 12 14 9 ] [ 16 32 64 ] ] LU
08:45:38 <KipIngram> And have it take the LU factorization of that matrix.
08:46:01 <KipIngram> Right - you're protecting other regions of memory.
08:46:06 <KipIngram> Which is a nice thing.
08:46:38 <KipIngram> You know, it's too bad oru processors don't give us a way to implement that in hardware.
08:46:57 <KipIngram> As it is, you have to have a wrap check in all of your primitives (all that move the stack pointer, at least).
08:47:03 <rdrop-exit> Chuck's processors do
08:47:14 <KipIngram> It would be neat if you could program a max limit and have it wrap in that range.
08:47:22 <KipIngram> Right - his truly ARE circular buffers.
08:48:12 <rdrop-exit> You could even do without stack pointers
08:48:19 <KipIngram> Power of two size makes that easy, but I've been studying error coding recently, and they do a lot with the "Fp" finite fields.
08:48:29 <KipIngram> usually represented by { 0 ... p-1 } where p is prime.
08:48:54 <KipIngram> it would also be awfully neat to be able to define a variable as over some field Fp and have the arithmetic "just work."
08:49:04 <KipIngram> In such a field + and * are the usual + and *, except modulo p.
08:49:25 <KipIngram> If p isn't prime, it's not a field.
08:50:04 <KipIngram> So in F5, for example, 2 and 3 are each other's inverse.
08:50:22 <KipIngram> Because 2*3 = 6, and 6 modulo 5 is 1.  That's the definition - a and b are inverses if a*b = 1.
08:50:55 <john_cephalopoda> Shouldn't be hard to implement circular buffer management in gforth.
08:51:54 <john_cephalopoda> You just do mod n every time you increment or decrement.
08:51:59 <rdrop-exit> You could implement a hardware stack using a shift register, no stack pointers needed
08:52:20 <KipIngram> Right - that's how I did mine in my FPGA Forth thoughts.
08:52:49 <KipIngram> One down side of that is that you're moving every stack item every time, which raises power consumption.
08:53:53 <rdrop-exit> True, but if you're implementing on an FPGA power consumption can't be your priority
08:54:02 <KipIngram> Exactly.
08:54:03 <KipIngram> :-)
08:54:09 <rdrop-exit> ;-)
08:55:04 <Mat4> I have just separating parsing from the execution environment which just executed a packed immediate representation of the source code. The entire type system inclusive all type checking and number transformation is part of the editor. This includes the stack model. The execution environment is not a stack VM
08:55:09 <KipIngram> So, anyway, when I set up that type handling one of the things I'll be interested in is handling those finite fields.
08:56:00 <KipIngram> Some of the error coding is also done with finite fields over polynomials.
08:56:34 <KipIngram> The Fp integer finite fields --> BCH codes; over polynomial fields --> Reed-Solomon codes.
08:58:30 <rdrop-exit> Mat4, what is the execution environment?
09:02:36 <Mat4> an AOT compiler which just process packet sequences dependent of specific prefixes
09:04:14 <rdrop-exit> Your execution environment is a compiler?
09:06:18 <rdrop-exit> Your system isn't interactive?
09:07:33 <Mat4> yes, a very fast one. The editor transform the source code into a 3d cube of sequences which can either be compiled to native code or directly expected though a special configured FPGA.
09:08:23 <Mat4> this is all I can write without sacrificed by my wife I think ;)
09:09:29 <Mat4> executed, sorry ... wrong autocorrection
09:11:33 <rdrop-exit> Ah, you're system is tethered like mine.
09:13:56 <Mat4> ... I think the right idiomatic expression would be crucified like ...
09:14:14 <Mat4> in english
09:15:59 <Mat4> it's still a design study at current for research
09:16:10 <rdrop-exit> By tethered (aka umbilical) I mean you're system talks back and forth to the target over a serial line, i.e. interactive and incremental cross-assembly and/or cross-compilation.
09:17:40 <rdrop-exit> Like Forth Inc's SwiftX product, or MPE's Forth 7.
09:21:19 <rdrop-exit> *your system, not "you're system"
09:23:33 <rdrop-exit> Kip, I wouldn't have the energy or courage to make my own symbolic math package. Kudos.
09:28:48 <rdrop-exit> It's 1:30am, I better sleep. Chat again soon.
09:28:49 --- quit: Mat4 (Read error: Connection reset by peer)
09:29:02 --- quit: rdrop-exit (Quit: Lost terminal)
09:43:56 --- join: Mat4 (~eh@ip5b409c40.dynamic.kabel-deutschland.de) joined #forth
09:50:47 --- quit: dddddd (Remote host closed the connection)
10:05:16 <KipIngram> Oh.  Well, I guess he's gone now.  But what I wasn't describing isn't a symbolic math package.
10:05:30 <KipIngram> Just a numeric package that works in other "domains."
10:05:38 <KipIngram> Not really any different from real -> complex.
10:05:43 --- join: [1]MrMobius (~default@c-73-134-82-217.hsd1.va.comcast.net) joined #forth
10:06:05 <KipIngram> I guess if you're manipulating polynomial representations that's "a little symbolic," but still not really I don't think.
10:06:18 <KipIngram> It's just a vector of coefficients you're manipulating numerically.
10:08:23 --- quit: MrMobius (Ping timeout: 244 seconds)
10:08:23 --- nick: [1]MrMobius -> MrMobius
10:13:20 <tabemann> hey guys
10:14:01 --- quit: dave0 (Quit: dave's not here)
10:15:17 <KipIngram> Hi tabemann.
10:20:12 <tabemann> I'm wondering what to do with attoforth next
10:20:46 <tabemann> maybe complete the loose ends that I've not implemented largely because I didn't need them and they did not seem essential
10:41:11 --- quit: irsol (Ping timeout: 246 seconds)
11:07:08 --- join: irsol (~irsol@unaffiliated/contempt) joined #forth
11:21:45 --- quit: Mat4 (Read error: Connection reset by peer)
11:32:32 <john_cephalopoda> KipIngram: Complex is basically vector math.
11:38:08 --- quit: MrMobius (Ping timeout: 268 seconds)
11:39:42 --- join: MrMobius (~default@c-73-134-82-217.hsd1.va.comcast.net) joined #forth
12:17:43 <KipIngram> Well, it's more than that, since you have i^2 = -1.  Though I guess the vector cross product has similar "transformative" capabilities.
12:17:48 <KipIngram> Similar qualitatively.
12:18:10 <KipIngram> But with vectors i x j = k, etc., in a fully symmetric way all the way around.
12:18:29 <KipIngram> With complex, imaginary * imaginary = real, but real * real also is real, so it's just... "different."
12:19:06 <KipIngram> Complex analysis is really a pretty fascinating field of math.
12:20:16 <KipIngram> Maybe quaternions somewhat integrate complex analysis and vector space analysis.
12:20:58 <KipIngram> Quaternions have a "scalar" component ("real" part) and then three other components, i, j, k.
12:21:18 <KipIngram> I beleive if you set the j and k components to zero you get complex remaining.
12:21:53 <KipIngram> They're not used for much these days, though there are some things in computer graphics they handle quiet well.
12:21:55 <KipIngram> quite
12:50:17 --- quit: pierpal (Ping timeout: 268 seconds)
13:14:13 --- join: dys (~dys@p57944DEE.dip0.t-ipconnect.de) joined #forth
13:16:53 <john_cephalopoda> KipIngram: Well, when you draw the imaginary axis as X axis and the real axis as y axis you can handle it as vectors. And I'm sure that there are vector operations that are equivalent to sqrt and power of two in real/imaginary numbers.
13:40:21 --- quit: rain2 (Quit: WeeChat 2.2)
14:46:47 --- join: pierpal (~pierpal@host192-32-dynamic.1-87-r.retail.telecomitalia.it) joined #forth
14:47:22 <KipIngram> Yes, it certainly looks like a vector space.
14:48:04 <KipIngram> Here's the thing, though - all of these things are sets with various properties.  Usually the escalation of "algebraic things" that you have are groups, then rings, then fields.
14:48:38 <KipIngram> To have a field you have to associate with your set a pair of operators, that we usually call + and *, and they have to satiisfy various properties.
14:48:47 <KipIngram> As long as they do, you can call it a field.
14:49:03 <KipIngram> My point was just that the * operator for complex numbers and the * operator for vectors are different.
14:49:37 <KipIngram> Here we'd be talking about * as the vector cross product - it's necessary for the * operator to take two members of your set (vectors) and produce another member of the set.
14:49:45 <KipIngram> So the dot product doesn't do that - it produces a scalar.
14:49:57 <KipIngram> I'm just noting that the two things have different * operators, so they're different things.
14:50:30 <KipIngram> Not trying to deny that there's any similarity.
14:51:00 --- quit: pierpal (Ping timeout: 244 seconds)
14:51:49 <KipIngram> Technically the vector cross product wouldn't actually produce a vector in a 2D vector space - the product vector doesn't like in those two dimensions.
14:55:33 <KipIngram> You know, I checked some references - actually a vector space doesn't have to have a product operator of that type.  It just has to work properly with scalar multiplication, and it does.
14:55:56 <KipIngram> So technically the complex plane is a vector space, but we associate operations with it that go beyond just being a vector space.
14:56:31 <KipIngram> Complex multiplication, specifically.  And we associate the dot and cross products with our 3D vector space we're all familiar with, but those things aren't required.
14:57:00 <KipIngram> So on looking into it more, I agree with you - the complex plane meets the explicit technical definition of a vector space.
14:57:38 <KipIngram> But the full scope of what we think of as "vector algebra" (dot products, cross products, divergence, curl, etc. etc.) isn't something that complex algebra extends into.  The complex plane has its own set of "extensions."
14:57:56 <KipIngram> Requirements to be a vector space are here:
14:57:57 <KipIngram> https://en.wikipedia.org/wiki/Vector_space#Definition
15:07:58 <KipIngram> An important difference between the two is that there is no product operation in complex analysis such that a*b = 0 unless a or b (one or the other) is zero.
15:08:33 <KipIngram> The vector cross product can be zero even if a and b are both non-zero.  So that leads to some quite different behavior in the two arenas.
16:05:52 --- quit: dys (Ping timeout: 252 seconds)
16:09:47 --- quit: ncv (Remote host closed the connection)
16:18:37 --- quit: john_cephalopoda (Quit: Trees can see into your soul.)
16:48:48 --- join: pierpal (~pierpal@host192-32-dynamic.1-87-r.retail.telecomitalia.it) joined #forth
16:53:33 --- quit: pierpal (Ping timeout: 260 seconds)
17:06:41 --- join: dys (~dys@p5DD5B5A8.dip0.t-ipconnect.de) joined #forth
17:33:01 --- join: tabemann_ (~tabemann@2602:30a:c0d3:1890:1870:3255:3792:ba89) joined #forth
17:33:22 --- quit: tabemann (Ping timeout: 250 seconds)
17:40:41 --- join: pierpal (~pierpal@host192-32-dynamic.1-87-r.retail.telecomitalia.it) joined #forth
19:38:53 --- join: [1]MrMobius (~default@c-73-134-82-217.hsd1.va.comcast.net) joined #forth
19:40:49 --- quit: MrMobius (Ping timeout: 252 seconds)
19:40:50 --- nick: [1]MrMobius -> MrMobius
22:24:28 --- quit: moony (Quit: Bye!)
22:28:43 --- join: moony (moony@unaffiliated/moonythedwarf) joined #forth
22:42:29 --- join: dave0 (~dave@47.44-27-211.dynamic.dsl.syd.iprimus.net.au) joined #forth
22:47:07 <dave0> hi
23:16:46 --- join: [1]MrMobius (~default@c-73-134-82-217.hsd1.va.comcast.net) joined #forth
23:19:04 --- quit: MrMobius (Ping timeout: 272 seconds)
23:19:05 --- nick: [1]MrMobius -> MrMobius
23:27:25 --- quit: moony (Quit: Bye!)
23:31:33 --- join: moony (moony@unaffiliated/moonythedwarf) joined #forth
23:38:00 --- join: wa5qjh (~quassel@110.54.217.16) joined #forth
23:38:00 --- quit: wa5qjh (Changing host)
23:38:00 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
23:41:33 --- quit: wa5qjh (Remote host closed the connection)
23:45:31 --- join: wa5qjh (~quassel@175.158.225.205) joined #forth
23:45:31 --- quit: wa5qjh (Changing host)
23:45:32 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
23:59:59 --- log: ended forth/18.11.10