| blob | a42f1fb1be60e9f824a1a4c3857596c89bacfa65 |
1 declare namespace liba {
2 /**
3 * square root of an unsigned integer
4 * @param x independent variable
5 * @return calculated result
6 */
7 function isqrt(x: number): number;
8 /**
9 * reciprocal of square-root
10 * @param x independent variable
11 * @return calculated result
12 */
13 function rsqrt(x: number): number;
14 /**
15 * a hash function whose prime number is 131
16 * @param block block to be processed
17 * @param value initial value
18 * @return hash value
19 */
20 function hash_bkdr(block: string, value: number): number;
21 /**
22 * a hash function whose prime number is 65599
23 * @param block block to be processed
24 * @param value initial value
25 * @return hash value
26 */
27 function hash_sdbm(block: string, value: number): number;
29 interface crc8 {
30 /** Cyclic Redundancy Check comparison table */
31 readonly table: Uint8Array;
32 /**
33 * generate for 8-bit Cyclic Redundancy Check
34 * @param poly polynomial that is CRC's divisor
35 * @param reversed is reversed?
36 */
37 gen(poly: number, reversed?: boolean): crc8;
38 /**
39 * calculate for 8-bit Cyclic Redundancy Check
40 * @param block block to be processed
41 * @param value initial value
42 * @return output value
43 */
44 eval(block: string, value: number): number;
45 /**
46 * pack a block and its CRC-8 value
47 * @param block block to be processed
48 * @param value initial value
49 * @return packed block
50 */
51 pack(block: string, value: number): Uint8Array;
52 delete(): void;
53 }
54 /** constructor for 8-bit Cyclic Redundancy Check */
55 let crc8: {
56 /**
57 * @param poly polynomial that is CRC's divisor
58 * @param reversed is reversed?
59 */
60 new(poly: number, reversed?: boolean): crc8;
61 readonly prototype: crc8;
62 };
64 interface crc16 {
65 /** Cyclic Redundancy Check comparison table */
66 readonly table: Uint16Array;
67 /**
68 * generate for 16-bit Cyclic Redundancy Check
69 * @param poly polynomial that is CRC's divisor
70 * @param reversed is reversed?
71 */
72 gen(poly: number, reversed?: boolean): crc16;
73 /**
74 * calculate for 16-bit Cyclic Redundancy Check
75 * @param block block to be processed
76 * @param value initial value
77 * @return output value
78 */
79 eval(block: string, value: number): number;
80 /**
81 * pack a block and its CRC-16 value
82 * @param block block to be processed
83 * @param value initial value
84 * @return packed block
85 */
86 pack(block: string, value: number): Uint8Array;
87 delete(): void;
88 }
89 /** constructor for 16-bit Cyclic Redundancy Check */
90 let crc16: {
91 /**
92 * @param poly polynomial that is CRC's divisor
93 * @param reversed is reversed?
94 */
95 new(poly: number, reversed?: boolean): crc16;
96 readonly prototype: crc16;
97 };
99 interface crc32 {
100 /** Cyclic Redundancy Check comparison table */
101 readonly table: Uint32Array;
102 /**
103 * generate for 32-bit Cyclic Redundancy Check
104 * @param poly polynomial that is CRC's divisor
105 * @param reversed is reversed?
106 */
107 gen(poly: number, reversed?: boolean): crc32;
108 /**
109 * calculate for 32-bit Cyclic Redundancy Check
110 * @param block block to be processed
111 * @param value initial value
112 * @return output value
113 */
114 eval(block: string, value: number): number;
115 /**
116 * pack a block and its CRC-32 value
117 * @param block block to be processed
118 * @param value initial value
119 * @return packed block
120 */
121 pack(block: string, value: number): Uint8Array;
122 delete(): void;
123 }
124 /** constructor for 32-bit Cyclic Redundancy Check */
125 let crc32: {
126 /**
127 * @param poly polynomial that is CRC's divisor
128 * @param reversed is reversed?
129 */
130 new(poly: number, reversed?: boolean): crc32;
131 readonly prototype: crc32;
132 };
134 interface crc64 {
135 /** Cyclic Redundancy Check comparison table */
136 readonly table: BigUint64Array;
137 /**
138 * generate for 64-bit Cyclic Redundancy Check
139 * @param poly polynomial that is CRC's divisor
140 * @param reversed is reversed?
141 */
142 gen(poly: bigint, reversed?: boolean): crc64;
143 /**
144 * calculate for 64-bit Cyclic Redundancy Check
145 * @param block block to be processed
146 * @param value initial value
147 * @return output value
148 */
149 eval(block: string, value: bigint): bigint;
150 /**
151 * pack a block and its CRC-64 value
152 * @param block block to be processed
153 * @param value initial value
154 * @return packed block
155 */
156 pack(block: string, value: number): Uint8Array;
157 delete(): void;
158 }
159 /** constructor for 64-bit Cyclic Redundancy Check */
160 let crc64: {
161 /**
162 * @param poly polynomial that is CRC's divisor
163 * @param reversed is reversed?
164 */
165 new(poly: bigint, reversed?: boolean): crc64;
166 readonly prototype: crc64;
167 };
169 interface hpf {
170 /** filter coefficient [0,1] */
171 readonly alpha: number;
172 /** filter output */
173 readonly output: number;
174 /** filter input */
175 readonly input: number;
176 /**
177 * generate for High Pass Filter
178 * @param fc cut-off frequency unit(hz)
179 * @param ts sampling time unit(s)
180 */
181 gen(fc: number, ts: number): hpf;
182 /**
183 * calculate for High Pass Filter
184 * @param x input value
185 * @return output value
186 */
187 iter(x: number): number;
188 /** zeroing for High Pass Filter */
189 zero(): hpf;
190 delete(): void;
191 }
192 /** constructor for High Pass Filter */
193 let hpf: {
194 /**
195 * @param fc cut-off frequency unit(hz)
196 * @param ts sampling time unit(s)
197 */
198 new(fc: number, ts: number): hpf;
199 /**
200 * @param alpha filter coefficient [0,1]
201 */
202 new(alpha: number): hpf;
203 readonly prototype: hpf;
204 };
206 interface lpf {
207 /** filter coefficient [0,1] */
208 readonly alpha: number;
209 /** filter output */
210 readonly output: number;
211 /**
212 * generate for Low Pass Filter
213 * @param fc cut-off frequency unit(hz)
214 * @param ts sampling time unit(s)
215 */
216 gen(fc: number, ts: number): lpf;
217 /**
218 * calculate for Low Pass Filter
219 * @param x input value
220 * @return output value
221 */
222 iter(x: number): number;
223 /** zeroing for Low Pass Filter */
224 zero(): lpf;
225 delete(): void;
226 }
227 /** constructor for Low Pass Filter */
228 let lpf: {
229 /**
230 * @param fc cut-off frequency unit(hz)
231 * @param ts sampling time unit(s)
232 */
233 new(fc: number, ts: number): lpf;
234 /**
235 * @param alpha filter coefficient [0,1]
236 */
237 new(alpha: number): lpf;
238 readonly prototype: lpf;
239 };
241 /** membership function */
242 let mf: {
243 /** none */
244 NUL: number;
245 /** gaussian membership function */
246 GAUSS: number;
247 /** gaussian combination membership function */
248 GAUSS2: number;
249 /** generalized bell-shaped membership function */
250 GBELL: number;
251 /** sigmoidal membership function */
252 SIG: number;
253 /** difference between two sigmoidal membership functions */
254 DSIG: number;
255 /** product of two sigmoidal membership functions */
256 PSIG: number;
257 /** trapezoidal membership function */
258 TRAP: number;
259 /** triangular membership function */
260 TRI: number;
261 /** linear s-shaped saturation membership function */
262 LINS: number;
263 /** linear z-shaped saturation membership function */
264 LINZ: number;
265 /** s-shaped membership function */
266 S: number;
267 /** z-shaped membership function */
268 Z: number;
269 /** pi-shaped membership function */
270 PI: number;
271 /**
272 * gaussian membership function
273 * @param x input value for which to compute membership value.
274 * @param sigma is the standard deviation.
275 * @param c is the mean.
276 * @return membership value.
277 */
278 gauss(x: number, sigma: number, c: number): number;
279 /**
280 * gaussian combination membership function
281 * @param x input value for which to compute membership value.
282 * @param sigma1 is the standard deviation of the left gaussian function.
283 * @param c1 is the mean of the left gaussian function.
284 * @param sigma2 is the standard deviation of the right gaussian function.
285 * @param c2 is the mean of the right gaussian function.
286 * @return membership value.
287 */
288 gauss2(x: number, sigma1: number, c1: number, sigma2: number, c2: number): number;
289 /**
290 * generalized bell-shaped membership function
291 * @param x input value for which to compute membership value.
292 * @param a defines the width of the membership function, where a larger value creates a wider membership function.
293 * @param b defines the shape of the curve on either side of the central plateau, where a larger value creates a more steep transition.
294 * @param c defines the center of the membership function.
295 * @return membership value.
296 */
297 gbell(x: number, a: number, b: number, c: number): number;
298 /**
299 * sigmoidal membership function
300 * @param x input value for which to compute membership value.
301 * @param a defines the width of the transition area.
302 * @param c defines the center of the transition area.
303 * @return membership value.
304 */
305 sig(x: number, a: number, c: number): number;
306 /**
307 * difference between two sigmoidal membership functions
308 * @param x input value for which to compute membership value.
309 * @param a1 defines the width of the first transition area.
310 * @param c1 defines the center of the first transition area.
311 * @param a2 defines the width of the second transition area.
312 * @param c2 defines the center of the second transition area.
313 * @return membership value.
314 */
315 dsig(x: number, a1: number, c1: number, a2: number, c2: number): number;
316 /**
317 * product of two sigmoidal membership functions
318 * @param x input value for which to compute membership value.
319 * @param a1 defines the width of the first transition area.
320 * @param c1 defines the center of the first transition area.
321 * @param a2 defines the width of the second transition area.
322 * @param c2 defines the center of the second transition area.
323 * @return membership value.
324 */
325 psig(x: number, a1: number, c1: number, a2: number, c2: number): number;
326 /**
327 * trapezoidal membership function
328 * @param x input value for which to compute membership value.
329 * @param a defines its left foot.
330 * @param b defines its left shoulder.
331 * @param c defines its right shoulder.
332 * @param d defines its right foot.
333 * @return membership value.
334 */
335 trap(x: number, a: number, b: number, c: number, d: number): number;
336 /**
337 * triangular membership function
338 * @param x input value for which to compute membership value.
339 * @param a defines its left foot.
340 * @param b defines its peak.
341 * @param c defines its right foot.
342 * @return membership value.
343 */
344 tri(x: number, a: number, b: number, c: number): number;
345 /**
346 * linear s-shaped saturation membership function
347 * @param x input value for which to compute membership value.
348 * @param a defines its foot.
349 * @param b defines its shoulder.
350 * @return membership value.
351 */
352 lins(x: number, a: number, b: number): number;
353 /**
354 * linear z-shaped saturation membership function
355 * @param x input value for which to compute membership value.
356 * @param a defines its shoulder.
357 * @param b defines its foot.
358 * @return membership value.
359 */
360 linz(x: number, a: number, b: number): number;
361 /**
362 * s-shaped membership function
363 * @param x input value for which to compute membership value.
364 * @param a defines its foot.
365 * @param b defines its shoulder.
366 * @return membership value.
367 */
368 s(x: number, a: number, b: number): number;
369 /**
370 * z-shaped membership function
371 * @param x input value for which to compute membership value.
372 * @param a defines its shoulder.
373 * @param b defines its foot.
374 * @return membership value.
375 */
376 z(x: number, a: number, b: number): number;
377 /**
378 * pi-shaped membership function
379 * @param x input value for which to compute membership value.
380 * @param a defines its left foot.
381 * @param b defines its left shoulder.
382 * @param c defines its right shoulder.
383 * @param d defines its right foot.
384 * @return membership value.
385 */
386 pi(x: number, a: number, b: number, c: number, d: number): number;
387 };
389 interface pid {
390 /** proportional constant */
391 kp: number;
392 /** integral constant */
393 ki: number;
394 /** derivative constant */
395 kd: number;
396 /** maximum integral output */
397 summax: number;
398 /** minimum integral output */
399 summin: number;
400 /** controller integral output */
401 readonly sum: number;
402 /** maximum final output */
403 outmax: number;
404 /** minimum final output */
405 outmin: number;
406 /** controller final output */
407 readonly out: number;
408 /** cache feedback */
409 readonly fdb: number;
410 /** cache error */
411 readonly err: number;
412 /**
413 * set proportional integral derivative constant for PID controller
414 * @param kp proportional constant
415 * @param ki integral constant
416 * @param kd derivative constant
417 */
418 kpid(kp: number, ki: number, kd: number): pid;
419 /**
420 * calculate for PID controller
421 * @param set setpoint value
422 * @param fdb feedback value
423 * @return setpoint value
424 */
425 run(set: number, fdb: number): number;
426 /**
427 * calculate for positional PID controller
428 * @param set setpoint value
429 * @param fdb feedback value
430 * @return output value
431 */
432 pos(set: number, fdb: number): number;
433 /**
434 * calculate for incremental PID controller
435 * @param set setpoint value
436 * @param fdb feedback value
437 * @return output value
438 */
439 inc(set: number, fdb: number): number;
440 /** zeroing for PID controller */
441 zero(): pid;
442 delete(): void;
443 }
444 /** constructor for proportional integral derivative controller */
445 let pid: {
446 new(): pid;
447 readonly prototype: pid;
448 };
450 interface pid_fuzzy {
451 /** proportional constant */
452 kp: number;
453 /** integral constant */
454 ki: number;
455 /** derivative constant */
456 kd: number;
457 /** maximum integral output */
458 summax: number;
459 /** minimum integral output */
460 summin: number;
461 /** controller integral output */
462 readonly sum: number;
463 /** maximum final output */
464 outmax: number;
465 /** minimum final output */
466 outmin: number;
467 /** controller final output */
468 readonly out: number;
469 /** cache feedback */
470 readonly fdb: number;
471 /** cache error */
472 readonly err: number;
473 /** number of order in the square matrix */
474 readonly order: number;
475 /** maximum number triggered by the rule */
476 block: number;
477 /**
478 * set fuzzy relational operator for fuzzy PID controller
479 * @param op enumeration for fuzzy PID controller operator
480 */
481 op(op: number): pid_fuzzy;
482 /**
483 * set rule base for fuzzy PID controller
484 * @param me e's membership function parameter table
485 * @param mec ec's membership function parameter table
486 * @param mkp Kp's rule base table which must be a square matrix
487 * @param mki Ki's rule base table which must be a square matrix
488 * @param mkd Kd's rule base table which must be a square matrix
489 */
490 rule(me: number[][], mec: number[][], mkp: number[][], mki: number[][], mkd: number[][]): pid_fuzzy;
491 /**
492 * set memory block for fuzzy PID controller
493 * @param num the maximum number triggered by the rule
494 */
495 set_block(num: number): pid_fuzzy;
496 /**
497 * set proportional integral derivative constant for fuzzy PID controller
498 * @param kp proportional learning constant
499 * @param ki integral learning constant
500 * @param kd derivative learning constant
501 */
502 kpid(kp: number, ki: number, kd: number): pid_fuzzy;
503 /**
504 * calculate for fuzzy PID controller
505 * @param set setpoint value
506 * @param fdb feedback value
507 * @return setpoint value
508 */
509 run(set: number, fdb: number): number;
510 /**
511 * calculate for positional fuzzy PID controller
512 * @param set setpoint value
513 * @param fdb feedback value
514 * @return output value
515 */
516 pos(set: number, fdb: number): number;
517 /**
518 * calculate for incremental fuzzy PID controller
519 * @param set setpoint value
520 * @param fdb feedback value
521 * @return output value
522 */
523 inc(set: number, fdb: number): number;
524 /** zeroing for fuzzy PID controller */
525 zero(): pid_fuzzy;
526 delete(): void;
527 }
528 /** constructor for fuzzy PID controller */
529 let pid_fuzzy: {
530 new(): pid_fuzzy;
531 /** min(a,b) */
532 CAP: number;
533 /** a*b */
534 CAP_ALGEBRA: number;
535 /** max(a+b-1,0) */
536 CAP_BOUNDED: number;
537 /** max(a,b) */
538 CUP: number;
539 /** a+b-a*b */
540 CUP_ALGEBRA: number;
541 /** min(a+b,1) */
542 CUP_BOUNDED: number;
543 /** sqrt(a,b)*sqrt(1-(1-a)*(1-b)) */
544 EQU: number;
545 readonly prototype: pid_fuzzy;
546 };
548 interface pid_neuro {
549 /** proportional output coefficient */
550 k: number;
551 /** proportional learning constant */
552 kp: number;
553 /** integral learning constant */
554 ki: number;
555 /** derivative learning constant */
556 kd: number;
557 /** proportional weight */
558 wp: number;
559 /** integral weight */
560 wi: number;
561 /** derivative weight */
562 wd: number;
563 /** maximum final output */
564 outmax: number;
565 /** minimum final output */
566 outmin: number;
567 /** controller final output */
568 readonly out: number;
569 /** cache feedback */
570 readonly fdb: number;
571 /** cache error */
572 readonly err: number;
573 /** error change */
574 readonly ec: number;
575 /**
576 * set proportional integral derivative constant for single neuron PID controller
577 * @param k proportional output coefficient
578 * @param kp proportional learning constant
579 * @param ki integral learning constant
580 * @param kd derivative learning constant
581 */
582 kpid(k: number, kp: number, ki: number, kd: number): pid_neuro;
583 /**
584 * set proportional integral derivative weight for single neuron PID controller
585 * @param wp proportional weight
586 * @param wi integral weight
587 * @param wd derivative weight
588 */
589 wpid(wp: number, wi: number, wd: number): pid_neuro;
590 /**
591 * calculate for single neuron PID controller
592 * @param set setpoint value
593 * @param fdb feedback value
594 * @return setpoint value
595 */
596 run(set: number, fdb: number): number;
597 /**
598 * calculate for incremental single neuron PID controller
599 * @param set setpoint value
600 * @param fdb feedback value
601 * @return output value
602 */
603 inc(set: number, fdb: number): number;
604 /** zeroing for single neuron PID controller */
605 zero(): pid_neuro;
606 delete(): void;
607 }
608 /** constructor for single neuron PID controller */
609 let pid_neuro: {
610 new(): pid_neuro;
611 readonly prototype: pid_neuro;
612 };
614 interface tf {
615 /** input for transfer function */
616 readonly input: Float64Array | Float32Array;
617 /** output for transfer function */
618 readonly output: Float64Array | Float32Array;
619 /** numerator for transfer function */
620 num: Float64Array | Float32Array;
621 /** denominator for transfer function */
622 den: Float64Array | Float32Array;
623 /**
624 * set numerator for transfer function
625 * @param num numerator
626 */
627 set_num(num: number[]): tf;
628 /**
629 * set denominator for transfer function
630 * @param den denominator
631 */
632 set_den(den: number[]): tf;
633 /**
634 * calculate for transfer function
635 * @param x controller output
636 */
637 iter(x: number): number;
638 /** zeroing for transfer function */
639 zero(): tf;
640 delete(): void;
641 }
642 /** constructor for transfer function */
643 let tf: {
644 /**
645 * @param num numerator
646 * @param den denominator
647 */
648 new(num: number[], den: number[]): tf;
649 readonly prototype: tf;
650 };
652 interface trajbell {
653 /** total duration */
654 readonly t: number;
655 /** constant velocity phase */
656 readonly tv: number;
657 /** acceleration phase */
658 readonly ta: number;
659 /** deceleration phase */
660 readonly td: number;
661 /** time-interval in which the jerk is constant (j max or j min ) during the acceleration phase */
662 readonly taj: number;
663 /** time-interval in which the jerk is constant (j max or j min ) during the deceleration phase */
664 readonly tdj: number;
665 /** initial position */
666 readonly p0: number;
667 /** final position */
668 readonly p1: number;
669 /** initial velocity */
670 readonly v0: number;
671 /** final velocity */
672 readonly v1: number;
673 /** maximum velocity */
674 readonly vm: number;
675 /** maximum jerk */
676 readonly jm: number;
677 /** maximum acceleration */
678 readonly am: number;
679 /** maximum deceleration */
680 readonly dm: number;
681 /**
682 * @param jm defines the maximum jerk during system operation
683 * @param am defines the maximum acceleration during system operation
684 * @param vm defines the maximum velocity during system operation
685 * @param p0 defines the initial position
686 * @param p1 defines the final position
687 * @param v0 defines the initial velocity
688 * @param v1 defines the final velocity
689 * @return total duration
690 */
691 gen(jm: number, am: number, vm: number, p0: number, p1: number, v0: number, v1: number): number;
692 /**
693 * calculate position for bell-shaped velocity trajectory
694 * @param dt difference between current time and initial time
695 */
696 pos(dt: number): number;
697 /**
698 * calculate velocity for bell-shaped velocity trajectory
699 * @param dt difference between current time and initial time
700 */
701 vel(dt: number): number;
702 /**
703 * calculate acceleration for bell-shaped velocity trajectory
704 * @param dt difference between current time and initial time
705 */
706 acc(dt: number): number;
707 /**
708 * calculate jerk for bell-shaped velocity trajectory
709 * @param dt difference between current time and initial time
710 */
711 jer(dt: number): number;
712 delete(): void;
713 }
714 /** constructor for bell-shaped velocity trajectory */
715 let trajbell: {
716 new(): trajbell;
717 readonly prototype: trajbell;
718 };
720 interface trajpoly3 {
721 /** coefficients of position */
722 readonly p: Float64Array | Float32Array;
723 /** coefficients of velocity */
724 readonly v: Float64Array | Float32Array;
725 /** coefficients of acceleration */
726 readonly a: Float64Array | Float32Array;
727 /**
728 * calculate position for cubic polynomial trajectory
729 * @param dt difference between current time and initial time
730 */
731 pos(dt: number): number;
732 /**
733 * calculate velocity for cubic polynomial trajectory
734 * @param dt difference between current time and initial time
735 */
736 vel(dt: number): number;
737 /**
738 * calculate acceleration for cubic polynomial trajectory
739 * @param dt difference between current time and initial time
740 */
741 acc(dt: number): number;
742 delete(): void;
743 }
744 /** constructor for cubic polynomial trajectory */
745 let trajpoly3: {
746 /**
747 * @param ts difference between final time and initial time
748 * @param p0 initial position
749 * @param p1 final position
750 */
751 new(ts: number, p0: number, p1: number): trajpoly3;
752 /**
753 * @param ts difference between final time and initial time
754 * @param p0 initial position
755 * @param p1 final position
756 * @param v0 initial velocity
757 * @param v1 final velocity
758 */
759 new(ts: number, p0: number, p1: number, v0: number, v1: number): trajpoly3;
760 readonly prototype: trajpoly3;
761 };
763 interface trajpoly5 {
764 /** coefficients of position */
765 readonly p: Float64Array | Float32Array;
766 /** coefficients of velocity */
767 readonly v: Float64Array | Float32Array;
768 /** coefficients of acceleration */
769 readonly a: Float64Array | Float32Array;
770 /**
771 * calculate position for quintic polynomial trajectory
772 * @param dt difference between current time and initial time
773 */
774 pos(dt: number): number;
775 /**
776 * calculate velocity for quintic polynomial trajectory
777 * @param dt difference between current time and initial time
778 */
779 vel(dt: number): number;
780 /**
781 * calculate acceleration for quintic polynomial trajectory
782 * @param dt difference between current time and initial time
783 */
784 acc(dt: number): number;
785 delete(): void;
786 }
787 /** constructor for quintic polynomial trajectory */
788 let trajpoly5: {
789 /**
790 * @param ts difference between final time and initial time
791 * @param p0 initial position
792 * @param p1 final position
793 */
794 new(ts: number, p0: number, p1: number): trajpoly5;
795 /**
796 * @param ts difference between final time and initial time
797 * @param p0 initial position
798 * @param p1 final position
799 * @param v0 initial velocity
800 * @param v1 final velocity
801 */
802 new(ts: number, p0: number, p1: number, v0: number, v1: number): trajpoly5;
803 /**
804 * @param ts difference between final time and initial time
805 * @param p0 initial position
806 * @param p1 final position
807 * @param v0 initial velocity
808 * @param v1 final velocity
809 * @param a0 initial acceleration
810 * @param a1 final acceleration
811 */
812 new(ts: number, p0: number, p1: number, v0: number, v1: number, a0: number, a1: number): trajpoly5;
813 readonly prototype: trajpoly5;
814 };
816 interface trajpoly7 {
817 /** coefficients of position */
818 readonly p: Float64Array | Float32Array;
819 /** coefficients of velocity */
820 readonly v: Float64Array | Float32Array;
821 /** coefficients of acceleration */
822 readonly a: Float64Array | Float32Array;
823 /** coefficients of jerk */
824 readonly j: Float64Array | Float32Array;
825 /**
826 * calculate position for hepta polynomial trajectory
827 * @param dt difference between current time and initial time
828 */
829 pos(dt: number): number;
830 /**
831 * calculate velocity for hepta polynomial trajectory
832 * @param dt difference between current time and initial time
833 */
834 vel(dt: number): number;
835 /**
836 * calculate acceleration for hepta polynomial trajectory
837 * @param dt difference between current time and initial time
838 */
839 acc(dt: number): number;
840 /**
841 * calculate jerk for hepta polynomial trajectory
842 * @param dt difference between current time and initial time
843 */
844 jer(dt: number): number;
845 delete(): void;
846 }
847 /** constructor for hepta polynomial trajectory */
848 let trajpoly7: {
849 /**
850 * @param ts difference between final time and initial time
851 * @param p0 initial position
852 * @param p1 final position
853 */
854 new(ts: number, p0: number, p1: number): trajpoly7;
855 /**
856 * @param ts difference between final time and initial time
857 * @param p0 initial position
858 * @param p1 final position
859 * @param v0 initial velocity
860 * @param v1 final velocity
861 */
862 new(ts: number, p0: number, p1: number, v0: number, v1: number): trajpoly7;
863 /**
864 * @param ts difference between final time and initial time
865 * @param p0 initial position
866 * @param p1 final position
867 * @param v0 initial velocity
868 * @param v1 final velocity
869 * @param a0 initial acceleration
870 * @param a1 final acceleration
871 */
872 new(ts: number, p0: number, p1: number, v0: number, v1: number, a0: number, a1: number): trajpoly7;
873 /**
874 * @param ts difference between final time and initial time
875 * @param p0 initial position
876 * @param p1 final position
877 * @param v0 initial velocity
878 * @param v1 final velocity
879 * @param a0 initial acceleration
880 * @param a1 final acceleration
881 * @param j0 initial jerk
882 * @param j1 final jerk
883 */
884 new(ts: number, p0: number, p1: number, v0: number, v1: number, a0: number, a1: number, j0: number, j1: number): trajpoly7;
885 readonly prototype: trajpoly7;
886 };
888 interface trajtrap {
889 /** total duration */
890 readonly t: number;
891 /** initial position */
892 readonly p0: number;
893 /** final position */
894 readonly p1: number;
895 /** initial velocity */
896 readonly v0: number;
897 /** final velocity */
898 readonly v1: number;
899 /** constant velocity */
900 readonly vc: number;
901 /** time before constant velocity */
902 readonly ta: number;
903 /** time after constant velocity */
904 readonly td: number;
905 /** position before constant velocity */
906 readonly pa: number;
907 /** position after constant velocity */
908 readonly pd: number;
909 /** acceleration before constant velocity */
910 readonly ac: number;
911 /** acceleration after constant velocity */
912 readonly de: number;
913 /**
914 * @param vm defines the maximum velocity during system operation
915 * @param ac defines the acceleration before constant velocity
916 * @param de defines the acceleration after constant velocity
917 * @param p0 defines the initial position
918 * @param p1 defines the final position
919 * @param v0 defines the initial velocity
920 * @param v1 defines the final velocity
921 * @return total duration
922 */
923 gen(vm: number, ac: number, de: number, p0: number, p1: number, v0: number, v1: number): number;
924 /**
925 * calculate position for trapezoidal velocity trajectory
926 * @param dt difference between current time and initial time
927 */
928 pos(dt: number): number;
929 /**
930 * calculate velocity for trapezoidal velocity trajectory
931 * @param dt difference between current time and initial time
932 */
933 vel(dt: number): number;
934 /**
935 * calculate acceleration for trapezoidal velocity trajectory
936 * @param dt difference between current time and initial time
937 */
938 acc(dt: number): number;
939 delete(): void;
940 }
941 /** constructor for trapezoidal velocity trajectory */
942 let trajtrap: {
943 new(): trajtrap;
944 readonly prototype: trajtrap;
945 };
947 interface version {
948 /** major number */
949 major: number;
950 /** minor number */
951 minor: number;
952 /** third number */
953 third: number;
954 /** extra number */
955 extra: number;
956 /** alphabet */
957 alpha: string;
958 /**
959 * parse for version string
960 * @param ver version string to be parsed
961 */
962 parse(ver: string): version;
963 /**
964 * compare this version with that version
965 * @param ver version to be compared
966 */
967 cmp(ver: version): number;
968 /**
969 * this version is less than that version
970 * @param ver version to be compared
971 */
972 lt(ver: version): boolean;
973 /**
974 * this version is greater than that version
975 * @param ver version to be compared
976 */
977 gt(ver: version): boolean;
978 /**
979 * this version is less than or equal to that version
980 * @param ver version to be compared
981 */
982 le(ver: version): boolean;
983 /**
984 * this version is greater than or equal to that version
985 * @param ver version to be compared
986 */
987 ge(ver: version): boolean;
988 /**
989 * this version is equal to that version
990 * @param ver version to be compared
991 */
992 eq(ver: version): boolean;
993 /**
994 * this version is not equal to that version
995 * @param ver version to be compared
996 */
997 ne(ver: version): boolean;
998 /** return string representation of version */
999 toString(): string;
1000 delete(): void;
1001 }
1002 /** constructor for version */
1003 let version: {
1004 /**
1005 * @param major major number
1006 * @param minor minor number
1007 * @param third third number
1008 * @param extra extra number
1009 */
1010 new(major?: number, minor?: number, third?: number, extra?: number): version;
1011 /**
1012 * algorithm library version check
1013 * @param major required major number
1014 * @param minor required minor number
1015 * @param patch required patch number
1016 * @returns -3(<major),-2(<minor),-1(<patch),0,+1(>patch),+2(>minor),+3(>major)
1017 */
1018 check(major: number, minor: number, patch: number): number;
1019 /** algorithm library version major */
1020 MAJOR: number;
1021 /** algorithm library version minor */
1022 MINOR: number;
1023 /** algorithm library version patch */
1024 PATCH: number;
1025 /** algorithm library version tweak */
1026 TWEAK: number;
1027 readonly prototype: version;
1028 };
1030 /** algorithm library version string */
1031 const VERSION: string;
1032 }
1033 export = liba;