9575 Reputation

19 years, 50 days

Representation...

Internally 1/(x*y) is represented as, essentially, x^(-1)*y^(-1), so there is no x*y term.

Inputs are swapped...

The first column of the spreadsheet defines the values for u, the first row defines the values for v.  You've got the inputs swapped. The y2 port of IBC1 should be connected to the u pin of VLP, the v pin should be connected to the output of the u2 constant block.  With that fixed, the output is as you expect

AC circuit analysis...

Yes, Syrup has the equivalent of the SPICE ac circuit analysis; that's probably what it is most useful for. While it does not have the ability to create a circuit via schematic capture, it does include a simple ladder notation that can be used to quickly enter and plot a schematic for a restricted class of circuits.  The latest version of Syrup is available via the Maple Cloud; open the Maple cloud dialog (upper right corner of Maple Standard), go to the public documents and search for Syrup.

The current version can convert its models to modelica, which is the modeling language used by MapleSim.

Solution...

There are a couple of issues.

The procedure boo is not an export of foo (a procedure, so it has no exports), so calling foo:-boo makes no sense.  Just call boo directly.

For a procedure to access an object's local fields, I believe it has to be a method (local or export) of the object.  The procedure boo is neither (it is local to an export of the object). A workaround is to give it a formal parameter that is passed the value of interest:

```module my_class()
option object;
local hint::string:="X"; #private variable to the object

export
foo :: static:=proc(o::my_class) #can be seen from outside
local boo; #local proc inside proc foo

boo := proc(str)
print("inside boo()");
print(str);
end proc;

print("in foo(), calling local proc boo()");
print("hint is ",o:-hint); #works OK
boo(o:-hint);
end proc;

end module:

o:=Object(my_class);
o:-foo(o);
```

Another possibility is to promote boo to be be a method of my_class; it can be local.

```restart;
module my_class()
option object;
local hint::string:="X"; #private variable to the object
export
foo :: static:=proc(o::my_class) #can be seen from outside
print("in foo(), calling local proc boo()");
print("hint is ",o:-hint); #works OK
boo(o);
end proc;
local
boo :: static := proc(o :: my_class)
print("inside boo()");
print(o:-hint);
end proc;

end module:

o := Object(my_class);
foo(o);
```

Another solution is to create a method that accesses the field of interest, than call it.

```module my_class()
option object;
local hint::string:="X";

export
foo :: static := proc(o::my_class)
local boo;

boo := proc(o)
print("inside boo()");
print(o:-GetHint(o));
end proc;

print("in foo(), calling local proc boo()");
print("hint is ", o:-hint); #works OK
boo(o);
end proc;
export
GetHint :: static := proc(o :: my_class)
o:-hint;
end proc;
end module:

obj := Object(my_class);
foo(obj);
```

ArrayTools:-Alias...

Another possibility, to avoid reallocating memory, is to use 1-D Array for the original data and then use ArrayTools:-Alias to partition it. For example:

```A := Array(1..12, i->i):
B := ArrayTools:-Alias(A, [3,4]):
B[..,3];
[7]
[ ]
[8]
[ ]
[9]
```

I set up links in ~/bin, which is in my PATH, to point to the installed scripts.  So usually do something like

```ln -s /opt/maple2020/bin/maple ~/bin/maple
ln -s /opt/maple2020/bin/mint ~/bin/mint
```

With that, tty maple can be launched using maple on the command line.

If you don't know where maple is installed, but can run it, execute kernelopts(mapledir).

Status Bar...

With recent versions of Maple Standard, the current directory is displayed in the status bar (bottom of window).  Click on the display to bring up a directory browser to change the current directory.

stack overflow untrappable...

See the help page for try/catch.  It mentions that a stack overflow is not trappable, which is reasonable.

The problem in `discont/zero` is that it factors a particular expression f into -I*(I*f) then recursively applies itself to both factors, which won't terminate.

rewrite...

Having a static module inside an object means that module will be shared by all objects of the class.  As such, it doesn't make sense to have non-static things inside the module. Specifically, big_car_name will be the same as the last assigned 'name' for all the objects.  If that is what you want, it seems better to just declare big_car_name as a static local to car_class.  However, you could still do what you want, but I'm not seeing a reason to be passing an object into big_car:-set_name.  So to keep the submodule, I'd do something like

```car_class := module()
option object;

local name :: string :="UNKNOWN";

export
set_name::static:=proc(o::car_class,nm::string)
o:-name := nm;
big_car:-set_name(nm);
end proc;

#this is module, that I want to be private to this class only
#eventually, I'd like this module be in separate mpl file also.
local
big_car :: static := module()  #module does not take arguments!

#this below should be private only to the this module
#and not seen by the enclosing object.
local big_car_name :: static(string) := "UNKNOWN";

#this export to allow parent object to call it
export set_name :: static := proc(nm :: string)
big_car_name := nm;
end proc;

end module;

end module:

o:=Object(car_class);
o:-set_name(o,"GM");
```

Note that I also renamed '_name' to 'nm'. While not an issue here, symbols with leading underscores are supposed to be reserved for Maple library stuff; it's better not to be use them.

Two Approaches...

There are a couple ways to do this.  One is to open attach a Maple worksheet to the MapleSim model, get the data for the simulation by using the LinkModel and Simulate, import the data for the comparison (using the Maple Import command, or something equivalent), then plot both in Maple.  Something like the following

```A := MapleSim:-LinkModel():
simdata := A:-Simulate('returntype=datapoint'):
extdata := Import("MyData.xls"):
# plot the x (say 2nd col) vs t (1st col) of simulation and external data
plot([simdata[..,[1,2]], extdata[..,[1,2]]]);
```

An alternative approach is to do this entirely in MapleSim. Attach the external data to the MapleSim model, then insert a time table (Signal Blocks > Interpolation Tables > Time Table) and set it to use the attached data (assuming data is in proper format). The output of the block should then reproduce the data of interest. Probe it and compare to the simulated probe.

With this second approach it is fairly easy to generate an error signal between the two (form the difference, square and integrate) and then use the ParameterSweep and Optimization apps to fit model parameters.

List constructor...

If the read command, which reads maple source code, results in assignments to EQ_1, EQ_2, etc., then you can simply do

```EQlist := [EQ_1, EQ_2, ... ];
```

sqlite...

Is that Maple15 (quite old) or Maple 2015?  Regardless, neither can read a .maple file.  The format is an sqlite database, so you should be able to use sqlite to extract the contents of the file.

Text File...

It's a standard ascii source file. Such files are not typically "opened" in Maple. Rather they are edited with a text editor and either read into Maple,

```   read "somefile.mm";
```

or loaded into a Maple archive (.mla file) which is then accessed in various ways.

Not too useful...

A long time ago I wrote a package for doing that and related stuff, such as generating a type cover for a set of expressions.  For the most part it isn't particularly useful. I haven't kept it current (with newer types).  Here's what it does with 4 (your example):

```WhatType:-WhatTypes(4);
{MVIndex, algfun, algnum, atomic, complex, even, finite, integer, literal, numeric, polynom, posint, radfun, radnum, ratpoly, scalar, type, algebraic, anything, appliable, complexcons, constant, embedded_axis, embedded_real, expanded, filedesc, monomial, nonnegative, nonnegint, operator, positive, property, radalgfun, radalgnum, rational, realcons, verification, extended_numeric, extended_rational}

WhatType:-WhatTypes(4+x);
{`+`, algfun, linear, polynom, radfun, ratpoly, scalar, algebraic, anything, appliable, expanded, radalgfun}

WhatType:-WhatTypes([4+x]);
{list, anything, appliable, indexable, sequential}
```

One method...

Guessing at what you want, here's one approach, a bit crude.

```T := table([2=3,3=2,5=6,6=5,7=9,9=7]): # define given transformations of second index
map(proc(x) local y := T[op(2,x)]; if y :: integer then B[op(1,x),y] else x end if; end proc, varA);
[A[1, 0], A[1, 1], B[1, 3], B[1, 2], A[1, 4], B[1, 6], B[1, 5], B[1, 9], A[1, 8], B[1, 7], A[2, 0], A[2, 1], B[2, 3], B[2, 2], A[2, 4], B[2, 6], B[2, 5], B[2, 9], A[2, 8], B[2, 7], A[3, 0], A[3, 1], B[3, 3], B[3, 2], A[3, 4], B[3, 6], B[3, 5], B[3, 9], A[3, 8], B[3, 7]]
```
 First 10 11 12 13 14 15 16 Last Page 12 of 114
﻿