dart_clip

"Calculator Language for Immediate Processing"

It is an engine for calculation processing in the CLIP language.

For the CLIP language, see "http://www5d.biglobe.ne.jp/~satis/clip/language_e.html".

Use this package as a library

pubspec.yaml

dependencies:
  dart_clip: ^1.0.5

---

EasyClip

It provides the ability to easily run the CLIP engine from Dart.

import 'package:dart_clip/clip.dart';

Object construction

EasyClip clip = EasyClip();

Overwriting functions

ClipProc.assertProc = (int num, String? func) {
  // Returns true if processing is stopped when assertion fails
  return false;
};
ClipProc.errorProc = (int err, int num, String func, String token) {
  // The following is an example of generating a string
  String str = (((err & ClipGlobal.procWarn) != 0) ? "warning:" : "error:") +
      ClipMath.intToString(err.toDouble(), 16, 4) + " line:$num";
};

ClipProc.printAnsComplex = (String real, String imag) {
  // The following is an example of generating a string
  String str = real + imag;
};
ClipProc.printAnsMultiPrec = (String str) {};
ClipProc.printAnsMatrix = (ClipParam param, ClipToken array) {
  // The following is an example of generating a string
  String str = EasyClip.curClip().getArrayTokenString(param, array, 0);
};
ClipProc.printWarn = (String warn, int num, String func) {
  // The following is an example of generating a string
  String str = "warning: ";
  if (func.isNotEmpty) {
    str += "$func: ";
  }
  if (num > 0) {
    str += "line:$num ";
  }
  str += warn;
};
ClipProc.printError = (String error, int num, String func) {
  // The following is an example of generating a string
  String str = "error: ";
  if (func.isNotEmpty) {
    str += "$func: ";
  }
  if (num > 0) {
    str += "line:$num ";
  }
  str += error;
};

ClipProc.doCommandClear = () {
  // Function called when command ":clear" is executed
};
ClipProc.doCommandPrint = (ClipProcPrint? topPrint, bool flag) {
  // Functions called when the commands ":print" / ":println" are executed
  // When command ":print", false is passed to flag, and when command ":println", true is passed to flag.
  // The following is an example of generating a string
  String str = "";
  ClipProcPrint? cur = topPrint;
  while (cur != null) {
    if (cur.string() != null) {
      ParamString tmp = ParamString(cur.string());
      tmp.escape().replaceNewLine("\n");
      str += tmp.str();
    }
    cur = cur.next();
  }
  if (flag) {
    str += "\n";
  }
};
ClipProc.doCommandGWorld = (int width, int height) {
  // Function called when command ":gworld" is executed
};
ClipProc.doCommandGWorld24 = (int width, int height) {
  // Function called when command ":gworld24" is executed
};

When operating the EasyClip object inside the overwrite function, get the EasyClip object as follows.

EasyClip clip = EasyClip.curClip();

When manipulating the Canvas object inside the overwrite function, get the Canvas object as follows.

Canvas canvas = EasyClip.curCanvas();

Set a value for a variable

clip.setValue( 'a', 12.345 ); // @a in CLIP
clip.setComplex( 'b', 12.3, 4.5 ); // @b in CLIP
clip.setFract( 'c', -123, 45 ); // @c in CLIP
clip.setMultiPrec( 'a', array/*MPData*/ ); // @@a in CLIP

Set values in the array

clip.setVector( 'a', [1,2,3,4,5,6] ); // @@a{1 2 3 4 5 6}
clip.setComplexVector( 'b', [1,0,2], [0,1,1] ); // @@b{1 i 2\+i}
clip.setFractVector( 'c', [1,-1], [3,3] );
clip.setMatrix( 'd', [[1,2,3],[4,5,6],[7,8,9]] ); // @@d{{1 2 3}{4 5 6}{7 8 9}}
clip.setComplexMatrix( 'e', [[3,2],[2,5]], [[0,1],[-1,0]] ); // @@e{{3 2\+i}{2\-i 5}}
clip.setFractMatrix( 'f', [[1,-1],[-2,2]], [[3,3],[3,3]] );
clip.setMatrix( 'g', matrix/*MathMatrix*/ );
clip.setArrayValue( 'h', [0, 0], 12 ); // @@h 0 0
clip.setArrayValue( 'h', [0, 1], 34 ); // @@h 0 1
clip.setArrayValue( 'h', [1, 0], 56 ); // @@h 1 0
clip.setArrayValue( 'h', [1, 1], 78 ); // @@h 1 1
clip.setArrayComplex( 'i', [0], 12.3, 4.5 ); // @@i 0
clip.setArrayFract( 'j', [2], 3, 7 ); // @@j 2
clip.setString( 's', "Hello World!!" );

Check the value of the variable

double value = clip.getValue( 'a' ).toFloat();
double value = clip.getValue( 'b' ).real();
double value = clip.getValue( 'b' ).imag();
bool isMinus = clip.getValue( 'c' ).fractMinus();
double value = clip.getValue( 'c' ).num();
double value = clip.getValue( 'c' ).denom();
MPData array = clip.getMultiPrec( 'a' ); // MPData object
String string = clip.getComplexString( 'b' );
String string = clip.getFractString( 'c', false ); // Improper
String string = clip.getFractString( 'c', true ); // Mixed
String string = clip.getMultiPrecString( 'a' );

Since the return value of the getValue function is a MathValue object, you can use functions other than the toFloat, real, imag, fractMinus, num, and denom functions.

Check the values in the array

List<dynamic> array = clip.getArray( 'a' ); // Forcibly convert to Dart Array
List<dynamic> array = clip.getArray( 'a', 1 ); // One-dimensional element
List<dynamic> array = clip.getArray( 'a', 2 ); // Two-dimensional element
List<dynamic> array = clip.getArray( 'a', N ); // N-dimensional element
String string = "@@d = ${clip.getArrayString( 'd', 6 )}";
String string = clip.getString( 's' );

Check the value of the calculation result

double value = clip.getAnsValue().toFloat();
double value = clip.getAnsValue().real();
double value = clip.getAnsValue().imag();
bool isMinus = clip.getAnsValue().fractMinus();
double value = clip.getAnsValue().num();
double value = clip.getAnsValue().denom();
MPData array = clip.getAnsMultiPrec(); // MPData object
MathMatrix matrix = clip.getAnsMatrix(); // MathMatrix object
String string = "Ans = ${clip.getAnsMatrixString( 6 )}";
String string = clip.getAnsMultiPrecString();

Since the return value of the getAnsValue function is a MathValue object, you can use functions other than the toFloat, real, imag, fractMinus, num, and denom functions.

Various settings

A group of functions that execute CLIP setting commands directly from Dart.

Type specification

clip.setMode( mode, param1, param2 );

mode	Meaning	param1	param2
ClipGlobal.modeEFloat	Double precision floating point type (exponential notation)	Display accuracy	-
ClipGlobal.modeFFloat	Double precision floating point type (decimal point notation)	Display accuracy	-
ClipGlobal.modeGFloat	Double precision floating point type	Display accuracy	-
ClipGlobal.modeEComplex	Complex type (exponential notation)	Display accuracy	-
ClipGlobal.modeFComplex	Complex type (decimal point notation)	Display accuracy	-
ClipGlobal.modeGComplex	Complex type	Display accuracy	-
ClipGlobal.modeIFract	Fractional type	-	-
ClipGlobal.modeMFract	Band Fractional Type	-	-
ClipGlobal.modeHTime	Time type (hour)	Frames per second	-
ClipGlobal.modeMTime	Time type (minutes)	Frames per second	-
ClipGlobal.modeSTime	Time type (seconds)	Frames per second	-
ClipGlobal.modeFTime	Time type (frame)	Frames per second	-
ClipGlobal.modeSChar	Signed 8-bit integer type	Radix	-
ClipGlobal.modeUChar	Unsigned 8-bit integer type	Radix	-
ClipGlobal.modeSShort	Signed 16-bit integer type	Radix	-
ClipGlobal.modeUShort	Unsigned 16-bit integer type	Radix	-
ClipGlobal.modeSLong	Signed 32-bit integer type	Radix	-
ClipGlobal.modeULong	Unsigned 32-bit integer type	Radix	-
ClipGlobal.modeFMultiPrec	Multiple-precision floating point type	precision	Rounding mode
ClipGlobal.modeIMultiPrec	Multiple-precision integer type	precision	Rounding mode

Rounding mode	Meaning
"up"	Round away from zero
"down"	Round to near zero
"ceiling"	Round to approach positive infinity
"floor"	Round to approach negative infinity
"h_up"	round up on 5 and round down on 4
"h_down"	round up on 6 and round down on 5
"h_even"	If the number in the param1 digit is odd, "h_up" is processed, and if it is even, "h_down" is processed.
"h_down2"	banker's rounding
"h_even2"	If the number in the param1 digit is odd, "h_up" is processed, and if it is even, "h_down2" is processed.

param1 and param1 can be omitted.

Immediately after building the EasyClip object: ClipGlobal.modeGFloat

Floating point display accuracy (":prec" command in CLIP)

clip.setPrec( prec );

Immediately after building the EasyClip object: 6

Frames per second (":fps" command in CLIP)

clip.setFps( fps );

Immediately after building the EasyClip object: 30.0

Radix in integer (":radix" command in CLIP)

clip.setRadix( radix );

Immediately after building the EasyClip object: 10

Angle unit specification

clip.setAngType( type );

type	Meaning
ClipMath.angTypeRad	Radian
ClipMath.angTypeDeg	Degree
ClipMath.angTypeGrad	Grazian

Immediately after building the EasyClip object: ClipMath.angTypeRad

Calculator mode specification (":calculator" command in CLIP)

clip.setCalculator( flag );

Immediately after building the EasyClip object: false

Specify the lower limit of array subscripts (":base" command in CLIP)

clip.setBase( base );

base	Meaning
0	0 origin
1	1 origin

Immediately after building the EasyClip object: 0

Specify whether to return the calculation result (":ans" command in CLIP)

clip.setAnsFlag( flag );

Immediately after building the EasyClip object: false

Specify whether diagnostic message is valid (":assert" command in CLIP)

clip.setAssertFlag( flag );

Immediately after building the EasyClip object: false

Specify whether the warning message is valid (":warn" command in CLIP)

clip.setWarnFlag( flag );

Immediately after building the EasyClip object: true

Command

We provide a function that executes some CLIP commands directly from Dart.

clip.commandGWorld( width, height );

clip.commandGWorld24( width, height );

clip.commandWindow( left, bottom, right, top );

clip.commandGClear( index );

clip.commandGColor( index );

clip.commandGPut( array/*List<List<int>>*/ );

clip.commandGPut24( array/*List<List<int>>*/ );

List<List<int>>? array = clip.commandGGet(); // null if could not be obtained

List<List<int>>? array = clip.commandGGet24(); // null if could not be obtained

Calculation

int ret = clip.procLine( line/*String*/ ); // Returns ClipGlobal.procEnd on successful completion

int ret = clip.procScript( script/*List<String>*/ ); // Returns ClipGlobal.procEnd upon normal completion

Color palette

clip.newPalette();

clip.setPalette( bgrColorArray/*List<int>*/ );

// Below is an example of setting a grayscale palette
int bgrColor;
for( int i = 0; i < 256; i++ ){
    bgrColor = (i << 16) + (i << 8) + i;
    clip.setPaletteColor( i, bgrColor );
}

int bgrColor = clip.paletteColor( index );

Canvas

Canvas canvas = clip.createCanvas( width, height );

clip.resizeCanvas( width, height );

clip.updateCanvas();
clip.updateCanvas( scale ); // If scale is specified, the image memory in the ClipGWorld object will be enlarged and drawn.

Canvas canvas = clip.canvas(); // Canvas object

Use the EasyCanvas object

After building the EasyCanvas object, CLIP graphics instructions will now be drawn directly on the canvas, eliminating the need to call the updateCanvas function.

EasyCanvas easyCanvas = EasyCanvas();

easyCanvas.setFont( size, family );

Other

• Function used to implement the printAnsMatrix function called from the ClipProc object.

String string = clip.getArrayTokenString( param, array/*ClipToken*/, indent );

You can pass the parameters param and array of the printAnsMatrix function as they are.

• Get the ClipProc object, which is the only computational main class that exists in the EasyClip object.

ClipProc proc = clip.proc();

• Get the ClipParam object, which is the only calculated parameter class that exists in the EasyClip object.

ClipParam param = clip.param();

• Get the only ClipGWorld object that exists inside the EasyClip object.

ClipGWorld gWorld = clip.gWorld();

• Get the only MultiPrec object that exists in the CLIP engine.

MultiPrec mp = ClipProc.procMultiPrec();

---

MultiPrec

MultiPrec object for multi-precision computation

import 'package:dart_clip/math/multiprec.dart';

MultiPrec object constructor

MultiPrec()

Constant definition method

Multi-precision integer

I( str )

Returns an MPData object.

If the constant is undefined, the definition is added, and if it is defined, the defined one is returned.

Multi-precision floating point number

F( str )

Returns an MPData object.

If the constant is undefined, the definition is added, and if it is defined, the defined one is returned.

Multi-precision integer arithmetic method

Convert a string to a multi-precision integer

str2num( n/*MPData*/, s )

Convert multi-precision integer to strings

num2str( n/*MPData*/ )

Returns a String object.

Substitution

set( rop/*MPData*/, op/*MPData*/ )

Large and small comparison

cmp( a/*MPData*/, b/*MPData*/ )

Returns a positive value if a is greater than b, a negative value if it is less than b, and a zero value if equal.

Addition

add( ret/*MPData*/, a/*MPData*/, b/*MPData*/ )

Subtraction

sub( ret/*MPData*/, a/*MPData*/, b/*MPData*/ )

Multiply

mul( ret/*MPData*/, a/*MPData*/, b/*MPData*/ )

Division

div( q/*MPData*/, a/*MPData*/, b/*MPData*/, r/*MPData*/ )

Get the quotient q and the remainder r. Returns true if the divisor b is 0.

r can be omitted.

Sign inversion

neg( rop/*MPData*/, op/*MPData*/ )

op can be omitted.

Absolute value

abs( rop/*MPData*/, op/*MPData*/ )

op can be omitted.

Square root

sqrt( x/*MPData*/, a/*MPData*/ )

Returns true if a is negative.

Multi-precision floating point arithmetic method

Convert strings to multi-precision floating point numbers

fstr2num( n/*MPData*/, s )

Convert multi-precision floating point numbers to strings

fnum2str( n/*MPData*/ )

Returns a String object.

Substitution

fset( rop/*MPData*/, op/*MPData*/ )

Large and small comparison

fcmp( a/*MPData*/, b/*MPData*/ )

Returns positive value if a is greater than b, negative value if it is less than b, and zero value if equal.

Addition

fadd( ret/*MPData*/, a/*MPData*/, b/*MPData*/ )

Subtraction

fsub( ret/*MPData*/, a/*MPData*/, b/*MPData*/ )

Multiply

fmul( ret/*MPData*/, a/*MPData*/, b/*MPData*/, prec )

Division

fdiv( ret/*MPData*/, a/*MPData*/, b/*MPData*/, prec )
fdiv2( ret/*MPData*/, a/*MPData*/, b/*MPData*/, prec, digit/*ParamInteger*/ )

Returns true if the divisor b is 0. digit stores the number of digits in the integer part of the divisor a.

digit can be omitted.

Sign inversion

fneg( rop/*MPData*/, op/*MPData*/ )

op can be omitted.

Absolute value

fabs( rop/*MPData*/, op/*MPData*/ )

op can be omitted.

Truncate after the decimal point

ftrunc( rop/*MPData*/, op/*MPData*/ )

Square root

fsqrt( ret/*MPData*/, a/*MPData*/, prec )
fsqrt2( ret/*MPData*/, a/*MPData*/, prec, order )
fsqrt3( ret/*MPData*/, a/*MPData*/, prec )

Returns true if a is negative.

Number of digits in the integer part

fdigit( a/*MPData*/ )

Rounding operation

fround( a/*MPData*/, prec, mode )

mode	Meaning
MultiPrec.froundUp	Round away from zero
MultiPrec.froundDown	Round to near zero
MultiPrec.froundCeiling	Round to approach positive infinity
MultiPrec.froundFloor	Round to approach negative infinity
MultiPrec.froundHalfUp	round up on 5 and round down on 4
MultiPrec.froundHalfDown	round up on 6 and round down on 5
MultiPrec.froundHalfEven	If the number in the prec digit is odd, MultiPrec.froundHalfUp is processed, and if it is even, MultiPrec.froundHalfDown is processed.
MultiPrec.froundHalfDown2	banker's rounding
MultiPrec.froundHalfEven2	If the number in the prec digit is odd, MultiPrec.froundHalfUp is processed, and if it is even, MultiPrec.froundHalfDown2 is processed.

If mode is omitted, the operation will be MultiPrec.froundHalfEven.