Maple

Nem világos, mi a feladatod. Ez a kifejezés egy Fourier-sor, illetve annak h darab tagig vett részösszege. A Fourier-sorral közelíthetsz függvényeket (bizonyos feltételek teljesülése esetén). A Fourier-sor kifejezésében szereplõ a és b együtthatókat elõször ki kell számolni a konkrét közelítendõ függvény ismeretében (integrálás). Lásd a wikipédián a Fourier-sor címszót.

Sziasztok!
Egy kis segítség kellene.
Kapta az egyik ismerõsömtõl egy matematikai feladatot de sajnos nem jutok dûlõre.
f := proc (x) options operator, arrow; a<0>+sum(a*cos(n*Pi*x/L)+b*sin(n*Pi*x/L), n = 1 .. h) end proc
A solve() nem ad megoldást. Tud valaki segíteni ebben.
Ui: Sajnos instrukciókat nem kaptam a feladattal kapcsolatban.
Elõre is köszönöm.

Pl. a zip parancs segítségével:

X:=array(<1,2,3,4,5>);# Array is lehet, az újabb verziókban.
Y:=array(<1,4,9,16,25>);
XY:=zip((x,y)->,X,Y);
plot(XY);

Üdv,

Egy gyors kérdésem lenne a Maple-lel kapcsolatban. Egy számítás két eredményét (ill. eredményeit) két array-ben mentettem le. Ezeket szeretném egymás függvényében ábrázolni. Gyakorlatilag a két array megfelelõ eleme összetartozó értékpárok. Ezt az ábrázolást egy excel segítségével könnyen meg lehetne csinálni, de nem akarom átírogatni az eredményeket, ha nem muszáj :)

Tudnátok segíteni ebben?

A Segítséget elõre is köszönöm!

A checkboxargs a `student/checkboxargs`() formában továbbra is elérhetõ.

A finduni a grobner csomag része, be lehet tölteni és használni, de már az újabb Groebner csomagot ajánlott használni helyette. A finduni parancs helyett a Groebner csomag UnivariatePolynomial parancsát ajánlja a Maple.

with(grobner);
finduni(x,);

Warning, grobner is deprecated. Please, use Groebner.

Sziasztok! Úgy látszik csak én kérdezgetek már megint.
A maple korábbi verziójában benne van egy - vagy több - utasítás, ami a pl. a maple 16-ban nincs benne ilyen utasítás a finduni() vagy a student csomag checkboxargs utasítása is. Ezeket hogy lehet helyettesíteni?
<#nemtudom> <#wave>

A simplify(expr, 'symbolic') formálisan egyszerûsíti a megadott kifejezést, azaz nem ellenõrzi, hogy érvényes-e az egyszerûsítés a kifejezés minden lehetséges értékére. Pl. az sqrt(x^2) kifejezést akkor szabad formálisan x-é egyszerûsíteni, ha x valós, nemnegativ szám, emiatt a sima simplify nem fogja azt x-é alakítani.

simplify(sqrt(x^2));# az eredmény x elõjelétõl függ.

# A simplify a symbolic opcióval elvégzi az formális egyszerûsítést:
simplify(sqrt(x^2),'symbolic');

A simplify(expr, size) egyszerûsítõ parancs megpróbálja, olyan módon átalakítani a kifejezést, hogy az minél kisebb méretû, rövidebb legyen:

e1 := 1/4*exp(-1/4*x^2)*2^(1/4)*x^(3/2) +1/8*exp(1/4*x^2)*2^(3/4)*sqrt(x)*sqrt(Pi)*erf(1/2*sqrt(2)*x) +1/8*exp(1/4*x^2)*2^(3/4)*x^(5/2)*sqrt(Pi)*erf(1/2*sqrt(2)*x):

simplify(e1);

simplify(e1, size);# rövidebb alak

Sziasztok.
Lenne egy kérdésem, bár nem nagyon merem feltenni a kérdést.
Azt szeretném tudni, hogy a simplify(expr, 'symbolic') és a simplify(expr, size) utasításokat mikor kell alkalmazni vagyis mi a különbség?
Elõre is köszönöm.
Ui: Sajnos még mindig nem vagyok nagy maple felhasználó.
Üdv Imre <#worship> <#conf>

A programkód szerkesztési problémára megoldás még az újabb Maple verziókban megjelent Code Edit region-t használata, amit az Insert - Code Edit Region-nal kell beszúrni a munkalapra, és ebbe a dobozba a szokásos módon lehet gépelni, azaz az enter-re új sort kezd és nem hajtja végre illetve, használható benne a tab is igazításra. Ebbe a dobozba lehet a programkódot megadni.
Ahhoz, hogy értelmezze a Code Edit region-ba begépelt kódot a Maple, a a dobozban állva, a jobb egérgombra kattintva végre kell hajtatni (Execute Code) a Code Edit Region-t.

A programozási problémád megoldható, ha külön eljárásba teszed a hosszú számításokat és ezt eljárást újra meghívod a megnövelt értékû változóval. Ugrálni a programban nem "illik" általában, mert átláthatatlanná teszi a mûködését.

Az alábbi programszerkezettel megoldható a feladat: az ismétlõdõ számításokat egy külön eljárásba tenni és ezt meghívni a megnövelt értékekkel egy ciklusban a fõeljáráson belül.

fõeljárás:=proc(valtozók listája)

local valtozo1, valtozo2, eljaras1;

eljaras1:=proc(..)
...
end proc;

valtozo1:=kezdõérték;

valtozó2:=eljaras1(valtozo1);

while valtozó2<0 and ... do
valtozo1:=valtozo1+1;
valtozó2:=eljaras1(valtozo1);
end do;

...
end proc;

Igen, a shift+enter-t ismerem, viszont az még mindig nem teszi átláthatóbbá a programomat.

Alapvetõ baj: van egy alapadatom, amit gyakorlatilag a felada legelején ki kell számolom. Utána meg jön 10 oldalnyi egyéb, ami szintén ettõl az alapadattól függ. Vagyis ha valami nem jó, akkor ide kell visszatérni, és megnövelni az értékét.

A fõ gondom most az, hogy vagy 10 oldalt teszek be egy darab ciklus alá (ez lényegében teljesen mindegy, hogy for, if vagy proc), vagy pedig minden adat számolását min. 2-szer adok meg.

Lehetõleg mindkettõt me akarom spórolni. Ezért lenne nekem a legjobb valami olyan parancs, ami a számolást automatikusan visszaküldi az elejére. Ilyen nincs semmi?

A shift enter-rel lehet olyan új sort létrehozni, amely nem minõsül külön parancssornak, így a for ciklust is több sorba lehet tagolni.

Az ismétlõdõ programrészekre érdemes külön eljárásokat (proc) létrehozni.
Ezek egymásba is ágyazhatóak, azaz egy fõprogramban (eljárásban) lehet több alprogramot (eljárást) definiálni és használni.

Üdv!

Megint lenne pár kérdésem a maple-lel kapcsolatban.

Megpróbáltam egy optimáló programot írni magamnak, amelyben egy iterációs számítást végez el a program. Viszont egy-két elvi kérdésben megakadtam.

A számítás elég sok lépésbõl áll. Úgy vettem észre, hogy egy for vagy if ciklus csak akkor mûködik, ha az egy sorban (egy ">" jel mögött) helyezkedik el. Így viszont baromira átláthatatlan a program. Ezt meg lehet valahogy bontani?

Másik kérdésem, hogy egy ilyen ciklus után meg lehet adni valahogy, hogy korábbra térjen vissza a program? (pl. az if ciklusban kapok egy negatív eredményt, ekkor térjen vissza a program elejére, és kezdje újra a számításokat pl. növelt értékekkel)

Gondolkoztam azon is, hogy esetleg szétszedem a programot több "alcsomagra", vagyis külön-külön megírom a részeket, amiket a fõ program csak behív magának, és a másik részben végzi el a számításokat. Ezt hogyan lehet jól megoldani?

A segítséget elõre is köszönöm.

PS: Bocsi, hogy a programot nem írom le, de elég hosszú.

Köszi a segítséget, viszont egy apró hibát észrevettem a programodban. A párosra kerekítés esetén nekem mindig felfelé kell kerekítenem, és a te esetedben ez nem teljesült. Ráadásul ha már 24.6-ot adok meg 24.5 helyett, akkor 25-öt ad eredményül, ami nekem nem jó.

A párosra történõ kerekítést szerintem kétféleképpen lehet megoldani. Vagy az utolsó, 5-re, vagy 0-ra történõ kerekítést használom fel, csak 2-re:

Kerekfel50 := proc (x, y)
ceil(x/y)*y end proc;
Kerekfel50(23.5, 2);
Kerekfel50(24.5, 2);

vagy a következõ program segítségével:

> kerekparos := proc (x)
if is(ceil(x), even) then return ceil(x)
else ceil(x+1)
end if
end proc;
> kerekparos(23.8);
> kerekparos(24.5);

Gyakorlatilag a te progidat javítottam kicsit. A segítséged nélkül biztos, hogy nem tudtam volna megcsinálni. Még egyszer köszi a segítséget :)

1. A beépített round függvénnyel:
round(3.5);

2. A ceil (plafon) függvénnyel:
ceil(3.4);

3. Pl. az alábbi függvény definiálásával:

kerekpáros:=proc(x)

if abs(frac(x))=0.5 then
if is(ceil(x),even) then return ceil(x)
else return floor(x);
end if;
end if;
round(x);
end proc;

kerekpáros(23.5);
kerekpáros(24.5);



4. Pl az alábbi függvénnyel, amellyel második paramétereben megadott szám egész számú többszörösére kerekíthetünk, ha ez 5, akkor a kérdezett feladatra megoldás:

Kerekfel2:=proc(x,y)
ceil(x/y)*y;
end proc;

Kerekfel2(52.3,5);

Kerekfel2(55.6,5);

Lenne megint egy kérdésem a Maple-lel kapcsolatban.

Hogyan lehet megoldani, hogy a program kerekítsen? Ráadásul több féle kerekítést is kellene alkalmaznom.

1. Alap kerekítés, matematikai szabályok szerint (.5-tõl felfelé)
2. Felfelé egészre.
3. Felfelé egészre és párosra
4. Felfelé, egészre, és úgy hogy a szám 5-re vagy 0-ra végzõdjön (pl: 52,3 esetén 55 legyen, vagy 55,6 esetén 60 legyen a szám)

Ötletek?

Igazából egyszerûbb módszer nincs.
A szögek átszámításához használhatóak a convert( , degrees) és a convert( , radians), illetve a convert( , 'units', 'radians','degrees') parancsok:

convert(30*degrees,radians);

convert(Pi/6,degrees);

sin(convert(30*degrees,radians));

vagy így is át lehet alakítani:

convert(Pi/2, 'units', 'radians','degrees');

Másik módszer, ha a mértékegységek csomagot betöltjük:

restart;

with(Units):

sin(30*Unit(degrees));

A második kérdésre megtalálta a választ: csak lefelejtettem az if ciklus végérõl az "end if" befejezést :)

Sziasztok,

Két dolgot szeretnék kérdezni. Az egyik, hogy van-e valamilyen beépített modul a Maple-ben, amivel a szögeket át lehet számolni radiánból fokba? Írtam egy kisebb programot, abban én úgy oldottam meg, hogy definiáltam két függvényt:

deg := Pi/180: #rad átszámítása fokba
rad := 180/Pi: #fok átszámítása radiánba

Így már könnyedén megadható egy szögérték bemenõ pl. bemenõ adatként fokban. Pl:

beta := 30*deg:

Valami egyszerûbb megoldás létezik?

A másik kérdésem szintén ugyan ehhez a programhoz kapcsolódik. Meg kell határozni két szöget, majd ezt a két szöget kell egymáshoz viszonyítani. A végeredményt egy "if" függvénnyel akartam kiíratni, hogy megfelel-e vagy sem. Leírom a program adott részét, hogy érthetõ legyen.


>deg := (1/180)*Pi: rad:= 180/Pi; beta := 30*deg;
> `μt` := .2; tenyezo := .4; mu := `μt`*tenyezo;
> `μv` := evalf(mu/cos((1/2)*beta));
> `ρv` := arctan(`μv`); `ρvdeg` := evalf(`ρv`*rad);
> i := 1;
> alpha := arctan(i*P/(d2*Pi)); `αdeg` := evalf(alpha*rad);
> a := evalf(`ρvdeg`-`αdeg`);
> if rhovdeg>alphadeg then print (megfelel) else print(nem felel meg);

Az utolsó sor után a következõ hibaüzenetet kapom: "Error, unterminated 'if' statement"

Valami megoldás?

Azzal ideiglenesen azzal feloldottam a problémát, hogy a két szöget kivontam egymásból, és figyelem, hogy pozitív, vagy negatív-e, viszont feliratokkal csak elegánsabb lenne :)

PS: remélem érthetõ volt a progi, nem tudom, hogy miért vágta teli ilyen idióta jelekkel, de lusta vagyok, hogy minden kitörölgessek :)

Ez egy egyszerû függvény, az abszolút érték függvénybõl elemi transzformációkkal megkapható az ábrája. És ebbõl megválaszolhatók a kérdések.

De ha mégis Maple-ben kell :

restart;
f:=x->-2*abs(x-2)+5;

plot(f);# Elõször érdemes mindig felrajzolni a függvényt.

solve(-2*abs(x-2)+5=0,x);# nullhelyei

fsolve(-2*abs(x-2)+5=0,x=-10..10);# vagy a numerikus gyökkeresovel.

A maximum értéke, helye így is kereshetõ, megadott x tartományban:

maximize(-2*abs(x-2)+5, x=-10..10,location);

Van a Maple-ben beépített függvényvizsgáló tutor is. Ez menübõl
is elindítható, vagy az alábbi módon:
Meg kell adni a vizgálandó függvényt, és a vizsgált értelmezési
tartományt! pl. a=-5 b=5 ebben az esetben. Ezen belül keresi a maximumot, nullhelyeket stb. A számolandó paramétert ki kell választani az ablakban, és a Calculate gombbal indítható a számítás.

Student(-2*abs(x-2)+5);

Sziasztok. Egy kis segítséget kérnék.
Kaptam egy feladatot: f(x)=-2*abs(x-2)+5
Van-e a valós számokon értelmezett f(x) függvénynek
minimuma? Melyik ez a szám?
maximuma? ------||--------?
Hol van a szélsõérték helye x ben?
Mennyi ez a szélsõérték?
Hol vannak a függvény zérushelyei?
Nekem erre a solve() utasítás nem adott választ, sõt a min(), max()-ra sem kaptam választ.
Ebben kérném a segítségeteket.
Elõre is köszönöm <#conf>

Az apply command-nál be kell gépelni a kívánt maple parancsot, és ha van a paramétereit is.
pl.
(x+y)^3;
Ha erre a kifejezésre jobb klkkelsz és a "Apply a Command-to választod, akkor a megjelenõ ablakban pl. az expand parancsot begépelve elvégzi az expand mûvelet a fenti kifejezésen.

Szeretnék megint kérdezni valamit. Azt szeretném tudni, hogy hogy kell használni a Jobb klikk és abban lévõ "Apply a Command" és a "Map Command Onto" parancsokat.
Elõre is köszönöm <#worship> <#conf>

Kedves xDJCx.
Megnéztem a GF parancsot. És ezzel tényleg lehet készíteni véges testet. Viszont nem teljesen világos még a használata a help alapján sem.
Esetleg tudna errõl mondani pár szót?

Nem sajnos. Csak kipróbáltam egyszer-kétszer.

A Mathematica-ban is otthon vagy?

Nem vagyok otthon az absztrakt algebrában, próbáld meg a Maple GF (Galois Field)parancsát.
?GF

Sziasztok
Egy olyan kérdésem lenne, hogy Mapleben, hogy lehet béges testeket létrehozni? PL én egy 16 és egy 17 elemû véges testek akarok kreálni.
Ezután az összes pontpárt akarok elkészíteni, melyek a véges testbõl a véges síkot képezik.
Ezt hogy tudnám megcsinálni? Az a baj, hogy ötletem sincs hogy induljak el. :(
Elõre is köszönöm a segítséget.

Köszi a segítséget, így már tényleg megcsinálta a szükséges számításokat. Ha még lesz valami problémám a programmal, akkor írok :)

Úgy tûnik, a Maple-nek az indexelt változónevekkel van itt gondja. Próbáld meg, úgy levezetni F kifejezését, hogy ott ahol nem valódi indexelésre használod az indexes jelölésmódot, ott lecseréled a változó nevét index nélkülire. pl. r<1> helyett r1, vagy v helyett vrel.
Maple megpróbálja igazi indexként értelmezni az indexelt változónevekben szereplõ nem igazi indexeket, és ez valahol zavart okoz.

Igen, ezt én is tapasztaltam.
Valószínû a 2D-s beviteli mód hibája. Ez még nem elég kiforrott a Maple-ben. Biztosabb általában a karakteres bevitelt használni (Maple input).
Mindenesetre a solve-val és isolate-tel u-ra nyert eredmények a Maple szerint - egyszerûsítés után - azonosak, Továbbá behelyettesítve õket F kifejezésébe 0-át kapunk.

Q1:=solve(F,u);
Q2:=rhs(isolate(F,u));

verify(Q1,Q2,simplify);# azonosak-e?

simplify(eval(F,u=Q1),symbolic);# F-be helyettesítése u-nak.
simplify(eval(F,u=Q2),symbolic);# F-be helyettesítése u-nak.

Igen, ezzel kapok valami eredményt. Csak azt nem tudom, hogy jó-e. Viszont van egy másik érdekesség is. Ha megfogom, és kimásolom az F-et egy teljesen üres maple dokumentumba, akkor ott már mûködik a solve parancs.

Errõl van szó:

> F := sin(gamma)*sin(theta)*(-(1/2)*f^2*omega*`ϕ`/(Pi^2*sqrt(4*R^2-f^2*`ϕ`^2/Pi^2))+omega*(-sin(gamma)*(r*sin(theta)+u*cos(gamma)*cos(theta))-cos(gamma)*(p*(theta-z*`ϕ`)-u*sin(gamma))))+(sin(gamma)*sin(gamma)*cos(theta)-cos(gamma)*cos(gamma))*(p*z*omega*cos(gamma)-omega*(r*cos(theta)+u*cos(gamma)*sin(theta)+(1/2)*sqrt(4*R^2-f^2*`ϕ`^2/Pi^2)-R+r))+(-cos(gamma)*sin(gamma)*cos(theta)-sin(gamma)*cos(gamma))*(p*z*omega*sin(gamma)+(1/2)*f*omega/Pi);
> solve(F, u);

Egyszerûen fogalmam sincs, hogy ezt miért csinálja. Valami tipp?

Próbáld meg az isolate-tel:

isolate(F,u);

Az nekem nem jó, ha konkrét értéket adok, mert nekem csak egy teoretikus számítás kell. Egy képlet, amit késõbb fel tudok használni.

Leírom a teljes programot, remélem így többet tudsz majd mondani róla.

#
> restar; with(LinearAlgebra);
> r<1> := `<,>`([r*cos(theta)+u*cos(gamma)*sin(theta), r*sin(theta)+u*cos(gamma)*cos(theta), p*(theta-z*`ϕ`)-u*sin(gamma), 1]);
> n<1> := `<,>`([sin(gamma)*sin(theta), -sin(gamma)*cos(theta), cos(gamma)]);
> e := f*`ϕ`/(2*Pi);
> a := sqrt(R^2-e^2)-R+r;
> M<21> := Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = a, (2, 1) = 0, (2, 2) = -sin(gamma), (2, 3) = -cos(gamma), (2, 4) = 0, (3, 1) = 0, (3, 2) = cos(gamma), (3, 3) = -sin(gamma), (3, 4) = (1/2)*f*`ϕ`/Pi, (4, 1) = 0, (4, 2) = 0, (4, 3) = 0, (4, 4) = 1});
> r<2> := evalm(`&*`(M<21>, r<1>));
> M<32> := Matrix(4, 4, {(1, 1) = cos(`ϕ`), (1, 2) = sin(`ϕ`), (1, 3) = 0, (1, 4) = 0, (2, 1) = -sin(`ϕ`), (2, 2) = cos(`ϕ`), (2, 3) = 0, (2, 4) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = 1, (3, 4) = 0, (4, 1) = 0, (4, 2) = 0, (4, 3) = 0, (4, 4) = 1});
> r<3> := evalm(`&*`(M<32>, r<2>));
> L<21> := Minor(M<21>, 4, 4, output = matrix);
> n<2> := Multiply(L<21>, n<1>);
> w := `<,>`(<0, 0, omega>);
> R<2> := `<,>`([r<2><1>, r<2><2>, r<2><3>]);
> v<2> := CrossProduct(w, R<2>);
> v := `<,>`(<0, p*z*omega*cos(gamma), p*z*omega*sin(gamma)>);
> v := `<,>`(<0, 0, f*omega/(2*Pi)>);
> v := `<,>`([-v<3>*e/sqrt(R^2-e^2), 0, 0]);
> v := v+v+v-v<2>;
> F := DotProduct(v^%T, n<2>, conjugate = false);
> solve(F, u);
Error, (in simplify/table) too many levels of recursion
>

Egy-két dolgot elég furán ír ki, de remélem érthetõ lesz.

Midnen jót!

Szervusz!

Célszerû lenne F konkrét értékét megadni, így nehéz segíteni.

Sziasztok!

Látszólag kicsit halottnak tûnik a fórum, de azért hátha szerencsével járok. Szóval nem rég kezdtem el a Maple14 programmal foglalkozni, az egyetemen egy feladat megoldásához lesz rá szükségem. A teljes számolást nem írnám itt végig, mert elég hosszú.
Szóval lineáris algebrában felírtam az egyenleteimet, végig kiszámoltattam azt, ami nekem kell. A végén utolsó mûveletként kapok egy "F" nevû skalárt (skalárszorzás után), amiben van egy "u" nevû ismeretlenem. Ezt kellene "u"-ra megoldani. Ezt a solve paranccsal akartam megcsinálni, a következõ módon, majd a következõ hibaüzenetet kaptam:

> solve(F, u);
Error, (in simplify/table) too many levels of recursion

Valami megoldás erre? A segítséget elõre is köszönöm

Köszönöm a segítséget. Ezt a zip parancsot nem ismertem. Megyek próbálkozom.

A listához, az kell, hogy szögletes zárójelek között legyenek felsorolva vesszõvel az értékek.
Ha van két lista az x-ekre és y-okra, akkor pl. a zip -paranccsal lehet belõlük x,y párokat csinálni:

with(plots):
xek:=<2,4.5,-3,-5,7>;
yok:=<12,17,8,13,17>;
pontok:=zip(`[]`,xek,yok);
pointplot(pontok);

A zip parancsnál van erre példa a súgóban.

az elõzõt javítva annyi, hogy x:= ;
Nem?

Sziasztok
A következõben szeretném kérni a segítségeteket. Vannak alappontjaim x_1,x_2,...,x_30, és y_1,...,y_30 ezeket szeretném összefûzni 2 listába és utána ábrázolni õket a egy intervallumon.
Próbálkoztam már pár féle módon, elvileg sorozatba sikerült õket raknom de, valahogy úgy nem tudtam ábrázolni, aztán megpróbáltam listára alakítani, de azt meg nem értem, hogy de nem sikerült pedig az elvileg annyi, hogy pl: x := vagy tévedek?
Elõre is köszönöm a segítséget.

Köszönöm, így már rendben. A potenciális (?) felhasználóknak (??) fontos, hogy "matek óra kompatibilisen" lássanak mindent :-)))

Egyik gond, hogy a tan és cot argumentumát nem pontosan a kívánt alakban írja, azaz 2*Pi/4-et Pi/2-vé egyszerûsíti a Maple. Ebben nehéz megakadályozni. Van rá trükk pl. az alábbi forma:

tan(2*x+ 2 * ``(Pi/4));

Ez a munkalapon mûködik, a megjelenítés megfelelõ, de valamiért a mathcontainer-ben nem szépen jeleníti meg.
Ábra feliratként (pl. legend) viszont szépen megjeleníti a typeset alak használatával (lásd alább.) Így akár felesleges is a Mathcontainer-es kiíratása a képletnek.

Továbbá mivel Mathcontainer-ben és ábra feliratként nem kell a képlettel tovább számolni, ezért akár tg is írható a tan helyett ( és ctg cot helyett. Ekkor nem ismert függvényként a Maple nem alakítja át pl. cot-tá. Így felesleges az ajánlott applyrule-átalakítás.

Az ábra rácsozathoz érdemes megpróbálni a gridlines opciót.
A fentiek szerint átírtam a programot.


Do(%Plot1=plots:-pointplot());
Do(%MathContainer1=0);
Do(%MathContainer2=0);
plots:-setoptions(thickness=2,labels=["x","y"],tickmarks = ,gridlines=true);
f1:='f1';
f2:='f2';
a1:=0;a2:=0;
if Do(%CheckBox1)then
phi1:=Do(%Slider3)*Pi/4;
a1:=Do(%Slider1);
o1:=Do(%Slider2);
f1:=a1*tan(o1*x+phi1);
m1:=a1*tg(o1*x+phi1);
Do(%MathContainer1=m1);
end if;
if Do(%CheckBox2)then
phi2:=Do(%Slider6)*Pi/4;
a2:=Do(%Slider4);
o2:=Do(%Slider5);
f2:=a2*cot(o2*x+phi2);
m2:=a2*ctg(o2*x+phi2);
Do(%MathContainer2=m2);
end if;
ymax:=10;
gtan:=plot(f1,x=-2*Pi..2*Pi,y=-ymax..ymax,color="Blue",discont=true,gridlines=true,legend=typeset(a1*tg(o1*x+phi1/(Pi/4)* ``(Pi/4))));
gcot:=plot(f2,x=-2*Pi..2*Pi,y=-ymax..ymax,color="IndianRed",discont=true,gridlines=true,legend=typeset(a2*ctg(o2*x+phi2/(Pi/4)* ``(Pi/4))));

Do(%Plot1=plots:-display(gtan,gcot));
end use;

A "nem vált be" persze nem azt jelenti, hogy nem mûködik, csak azt, hogy nem úgy, ahogy szeretném. Azért küldtem el a linket, mert ha lefuttatod, jobban látod mirõl beszélek....

Nagyon köszönöm a választ. Sajnos nem vált be. (Itt van a teljes alkalmazás: ftp://jaguser:[email protected]/trigonometrikus_tancot.zip)

1)
Ezt próbáld meg:

phi1:=Do(%Slider3)*Pi/4;
a1:=Do(%Slider1);
o1:=Do(%Slider2);
f1:=a1*tan(o1*x+phi1);
f1:=applyrule(cot(x::anything)='''-tan(x-Pi/2)''',f1);
Do(%MathContainer1=f1);

Kedves Maple-tudorok!
1)
phi1:=Do(%Slider3)*Pi/4;
a1:=Do(%Slider1);
o1:=Do(%Slider2);
f1(x):=a1*tan(o1*x+phi1);
Do(%MathContainer1=f1(x));
Hogyan lehetne elérni, hogy a MathContainer1-ben pl. a1:=1, o1:=1 és phi1:=2*Pi/4-re ne azt írja ki, hogy -cot(x), hanem pl. azt, hogy tan(2*Pi/4)?
2)
Lehet e a TextArea komponensben állítani a karakterméretét (magasságát)?

Egy ötlet kapcsolódva a modulban az alábbi
... proc(p::(polynom(constant)), x::name) sorhoz:

eljárás bemeneti argumentumának meg lehet mondani, hogy legyen olyan polinom típusú, amely polinom egy szintén megadott változó függvénye:

proc(p::depends(polynom(constant,x)), x::name)

...
end proc;


A súgóban errõl itt lehet olvasni :
?Procedure Parameter Modifiers

xDJCx nagyon szépen köszönöm a segitséget. müködik a progi.
Üdv Imre

Van benne több hiba. Javítottam egy-kettõt,amit megtaláltam. Már szintaktikailag helyes, de tartalmilag még nem.
Jeleztem a javított sorokat, és azt is ami kérdéses.
Pl. boundRoots eljárás még biztos hibás: pl. a bb4: kezdetû sorban a t változó nincs elõtte definiálva és itt mindenképpen kellene neki érték.


polyops:=module()
export leen, height, qnorm, boundRoots , boundRootsDense;
options package;

leen := proc (p::(polynom(constant)), x::name)
convert(map(abs, ), `+`)
end proc;

height := proc (p::(polynom(constant)), x::name)
max(coeffs(collect(p, x, distributed, abs), x))
end proc;

qnorm := proc (p::(polynom(constant)), x::name)
sqrt(convert(map(z->z*conjugate(z) , ), `+`))
end proc;

boundRoots := proc (p::(polynom(constant)), x::name)
local q, d, s, n, t, b, b1, b2, b3, bb4;
q := collect(p, x, distributed, evalf);
d := degree(q, x);
s := lcoeff(q, x);
n := nops(q);
if d = ldegree(q, x) then RETURN(0) end if;
if s <> 1. then q := expand(q/s) end if;
b1 := 1+polyops:-height(q-x^d, x);
b2 := max(1., leen(q-x^d, x));#javítva leen ?
b := min(b1, b2);
b3 := 0;
bb4 := (n*abs(lcoeff(t, x)))^(1./(d-degree(t, x)));# mi az a t?
for t in q-x^d while b3 < b do
b3 := max(b3, bb4);
end do;
userinfo(3, polyops, );
min(b, b3);
end proc;

boundRootsDense:=proc(p::polynom(constant), x::name)
local q, d, s, k, b, b4, b5;
q:=collect(p,x, distributed,evalf);
if ldegree(q)>0 then
q:=expand(q/(x^(ldegree(q))));
end if;
if type(q, constant) then
RETURN(0);
end if;
d:=degree(q,x);
s:=lcoeff(q,x);
if s<> 1. then
q:=expand(q/(s))
end if;
b:=polyops:-boundRoots(q,x);
b4:=convert(,`+`);
if nops(q)<d+1 then b5:=infinity;
elif type(q, polynom(positive,x)) then
b5:=max(seq(coeff(q, x, k-1)/coeff(q, x, k), k=2..d));# javítva;
else
b5:=max(abs(coeff(q, x, 0)/coeff(q, x, 1)), seq(2*abs(coeff(q, x, k-1)/coeff(q, x,k)), k=2..d));#javitva
end if;
#end if; javitva
userinfo(3, polyops, );
min(b, b4, b5);# javítva
end proc;
end module;

Sziasztok!
Egy kis segitségre lenne szükségem. Itt van ez a module csak az a baj, hogy vmiért nem müködik én képtelen vagyok rájönni, hogy hol a hiba. Aki tud az kérem segítsen ebben. Elõre is köszönöm.
Itt a program:
polyops:=module()
export leen, height, qnorm, boundRoots , boundRootsDense;
options package;

leen := proc (p::(polynom(constant)), x::name)
convert(map(abs, ), `+`)
end proc;

height := proc (p::(polynom(constant)), x::name)
max(coeffs(collect(p, x, distributed, abs), x))
end proc;

qnorm := proc (p::(polynom(constant)), x::name)
sqrt(convert(map(z->z*conjugate(z) , ), `+`))
end proc;

boundRoots := proc (p::(polynom(constant)), x::name)
local q, d, s, n, t, b, b1, b2, b3, bb4;
q := collect(p, x, distributed, evalf);
d := degree(q, x);
s := lcoeff(q, x);
n := nops(q);
if d = ldegree(q, x) then RETURN(0) end if;
if s <> 1. then q := expand(q/s) end if;
b1 := 1+polyops:-height(q-x^d, x);
b2 := max(1., len(q-x^d, x));
b := min(b1, b2);
b3 := 0;
bb4 := (n*abs(lcoeff(t, x)))^(1./(d-degree(t, x)));
for t in q-x^d while b3 < b do
b3 := max(b3, bb4);
end do;
userinfo(3, polyops, );
min(b, b3);
end proc;

boundRootsDense:=proc(p::polynom(constant), x::name)
local q, d, s, k, b, b4, b5;
q:=collect(p,x, distributed,evalf);
if ldegree(q)>0 then
q:=expand(q/(x^(ldegree(q))));
end if;
if type(q, constant) then
RETURN(0);
end if;
d:=degree(q,x);
s:=lcoeff(q,x);
if s<> 1. then
q:=expand(q/(s))
end if;
b:=polyops:-boundRoots(q,x);
b4:=convert(,`+`);
if nops(q)<d+1 then b5:=infinity;
elif type(q, polynom(positive,x)) then
b5:=max(seq((coeff(q, x, k-1))/(coeff(q, x, k))), k=2..d);
else
b5: =max(abs((coeff(q, x, 0))/(coeff(q, x, 1))), seq(2*abs((coeff(q, x, k-1))/(coeff(q, x,k))), k=2..d);
end if;
end if;
userinfo(3, polyops, );
min(b, b4 b5);
end proc;
end module;