Betreff: Beliebige Operationen (Funktionen usw.) auf jedem Element in einer ListeWenn Ihr Fall so ist, können Sie möglicherweise zumindest für die Transformation eine Schleife vermeiden, indem Sie Parse() verwenden (obwohl es möglicherweise schneller ist, die Zeichenfolge zu durchlaufen).
Names Default To Here(1);<BR />str = "120, 130, 160, 120, 300, 200";
numList = Parse("{" || str ||"}");
Show(numList[1], numList[2]);Als Datentabelle:
Names Default To Here(1);
dt = New Table("Untitled",
Add Rows(12),
Compress File When Saved(1),
New Column("Column 1",
Character,
"Nominal",
Set Values(
{"120, 130, 160, 120, 300, 200", "120, 130, 160, 120, 300, 200",
"120, 130, 160, 120, 300, 200", "120, 130, 160, 120, 300, 200",
"120, 130, 160, 120, 300, 200", "120, 130, 160, 120, 300, 200",
"120, 130, 160, 120, 300, 200", "120, 130, 160, 120, 300, 200",
"120, 130, 160, 120, 300, 200", "120, 130, 160, 120, 300, 200",
"120, 130, 160, 120, 300, 200", "120, 130, 160, 120, 300, 200"}
)
)
);
dt << New Column("numlist", Expression, << set each value(Parse("{" || :Column 1|| "}")));
numListList = dt:numList << get as matrix;
Show(numListList, numListList[1], numListList[1][1]);Betreff: Beliebige Operationen (Funktionen usw.) auf jedem Element in einer ListeDanke Leute!
Das ist fantastisch.
Ich habe JMP16 tatsächlich in unserem Intranet gefunden, die IT-Abteilung sagte, sie seien gerade dabei, Installationsanweisungen zu erstellen und es offiziell herauszugeben. Also ging ich weiter und installierte es trotzdem.
Meine eigentliche(n) Aufgabe(n) war(en) etwas komplizierter, als Beispiel hatte ich in einem Fall eine Liste von Zeichenfolgen des Typs
"120, 130, 160, 120, 300, 200"
Tatsächliche Daten wären eine Spalte mit jeder Zeile mit dieser Art von Zeichenfolge (nur viel viel länger).
Ich musste das in eine Liste von Zahlenlisten umwandeln. Also musste ich diese Spalte in eine Anfangsliste einlesen und dann Words() auf diese Anfangsliste anwenden, um eine Liste von Listen von Zeichenfolgen zu erhalten, und dann Num(), um jede Zeichenfolge in eine Zahl zu bringen. Dies bedeutet zwei verschachtelte Schleifen.
Im Moment habe ich das mit zwei For Each-Schleifen gemacht, aber lassen Sie mich die Vorschläge untersuchen, die Sie hier gepostet haben. Ich konnte Expr() nie verstehen - ich denke, ich muss ihm noch eine Chance geben.
Danke!
Betreff: Beliebige Operationen (Funktionen usw.) auf jedem Element in einer Liste@migello ,
@jthi gab Ihnen ausgezeichnete Antworten (Kudos).Auch ich war so begeistert von der Funktion TransformEach in JMP 16.
Unten sehen Sie einen modifizierten Teil eines Skripts, das für viel frühere Versionen von JMP geschrieben und für JMP13 veröffentlicht wurde. Viele meiner ehemaligen Kollegen verwendeten die LFUNC-Funktion (Name ist die Abkürzung für Listenfunktion).Der JMP 16-Name "TransformEach" und die Syntax sind so gut. Wenn jedoch eines der Listenelemente den falschen Typ für die angegebene Transformation hat, wird nur ein Fehler zurückgegeben ... eine Try()-Funktion kann das beheben.
Nur für den Fall, dass dies von Nutzen sein könnte, bis Sie zu JMP 16 kommen, poste ich es.Speichern Sie einfach den Funktionsdefinitionsteil des Codes in einer Datei und verwenden Sie Include() in jedem Skript, das Sie benötigen.
// JSL Companion: Applications of the JMP Scripting Language
// Title: JSLC_CustomListFunctions.jsl
// Version: Windows JMP® 13.2.0
// Purpose: Provides examples of writing user functions.
/*Notes:
These functions are provided for learning as well as utility.
See Chapter 5 and 5_Extra_CustomListFunctions.jsl");
The script will define 2 functions. After each is a comment
block /*: Usage & Test examples ... --- end Test*/. Remove
The comment block and run the examples one line at a time. Open
the embedded log or have the log window visible to see
the results.
Motivation:
As seen in Chapter 5, a numeric function on a single layer
list of numbers, or a vector, or a matrix, will return the
same object with the function applied to each item. For example,
xx = Sqrt({1,2,3,4,9}); //xx = {1, 1.4142135623731, 1.73205080756888, 2, 3}
We have suggested that the same apply to String functions (that operate
on a single item) on a list of text. What we would like is
xx = Substr({"Quaker", "Minnesota", "Nebraska"}, 1,1); would return
xx = {"Q", "M", "N"}. However, currently most JMP String functions do not
allow list agruments.
Functions defined here, are:
- LFunc( mylist, expr); where expression is like expr(Substr(x,1,1)).
{LIKE function notes removed}
LFunc can save writing for-loops, Like save looking up the REGEX syntax.
*/
//------LFunc-------------------------------------------------------------------
Lfunc = Function( {xList, fExpr/*ex. Expr(Contains(x,"h"))*/},
{x = {}, i = 1, errCode = 0, errStr = "\!NError bad argument", newExpr},
If( !Is List( xList ),
errCode = 1
);
If(
Type( Name Expr( fExpr ) ) == "Name",
//if Name then JMP does not recognize the function
tmp = Trim( Char( Name Expr( fExpr ) ) );
//extract the function and check if it is contained in the global namespace, if not error!
If( Namespace( "global" ) << Contains( Word( 1, tmp, ":(" ) ) == 0,
errCode = errCode + 2
);,
Type( Name Expr( fExpr ) ) != "Expression", errCode = errCode + 2
);
//catches typos, returns Name if not a valid function
//catches typos, returns Name if not a valid function
If( !Is Expr( Name Expr( fExpr ) ),
errCode = errCode + 2
); //catches syntax
If(
!errCode,
For( i = 1, i <= N Items( xList ), i++,
newExpr = Substitute( Name Expr( fExpr ), Expr( x ), xList[i] );
Insert Into( x, Try( newExpr, Empty() ) );
),
errCode == 1, Write( errStr || "(1) not a list \!N" ),
errCode == 2, Write( errStr || "(2) not a valid expression \!N" ),
errCode == 3, Write( errStr || "s (1) is not a list and (2) is not a valid expression \!N" )
);
x//return x
;
); //End Lfunc
//------------------------------------------------------------------------------
//Usage & Test ...remove the slash asterisk and run in segments, results are in the log
//------------------------------------------------------------------------------
myList1={"john", "harry", "huh","ah ha", "xyx", , "a", "h", 7, [1,7]};
/* example below returns a list of numeric values, one value for each item in the list
n =>1st location of h, 0 => does not contain "h", Empty() => the item is not
a valid argument for that expression.
*/
zz1 = Lfunc(myList1,Expr(Contains(x,"h")));
show(zz1);
myList2={"john", "harry", "huh","ah ha", "xyx", , "a", "h"};
zz2=Lfunc(myList2, Expr(Uppercase(x)));
show(zz2);
//-----------------------------------------------------------------------------------------
/* returns a list of how many words are in each string
[] -> no occurrences
Empty() => the expression is not valid for that item.
*/
zz3 = Lfunc(mylist2, expr(nitems(words(x))));
show(zz3);
//-----------------------------------------------------------------------------------------
/* This specified function requires numeric arguments
Empty() => the expression is not valid for that item.
A numeric function applied to a matrix returns a matrix
of the results applied on each element in the matrix.
Only the last 2 items are valid arguments for Log()
*/
zz4 = Lfunc(mylist1, expr(log(x)));
show(zz4);
//----------------Error Checking---------------------------------------------------------------
/* Uncomment the code below to show the error capture and reporting */
//zz = Lfunc("oh johhny", Expr(Contains(x,"h")) ); //not a list
//zz = Lfunc({"oh johhny"}, Expr(Contians(x,"h")) ); //type not a valid expr due to typo
//zz = Lfunc("oh johhny", Expr(Contians(x,"h")) ); //not a list and not a valid expr
Betreff: Beliebige Operationen (Funktionen usw.) auf jedem Element in einer ListeWie Sie bereits bemerkt haben, hilft JMP16 dabei mit For Each und Transform Each. Wenn Sie dies oft tun müssen, könnten Sie vielleicht benutzerdefinierte Funktionen erstellen, um die Aufgaben auszuführen?
Names Default To Here(1);
charToNum = function({tempList}, {Default Local},
newList = {};
For(i = 1, i <= N Items(tempList), i++,
newList[i] = Num(tempList[i]);
);
return(newList);
);
a = {"1", "2"};
b = charToNum(a);
show(b);
Bearbeiten:
Sie können auch kompliziertere Funktionen erstellen, die verschiedene Transformationen verarbeiten können. Höchstwahrscheinlich wird es übertrieben sein und ich würde es nicht wirklich empfehlen (ich würde einfach verschiedene Funktionen für verschiedene Transformationen erstellen).
Hier ist ein Beispiel, wie es gemacht werden könnte:
Names Default To Here(1);
transformList = function({tempList, transformExpression}, {Default Local},
newList = {};
For(i = 1, i <= N Items(tempList), i++,
val = tempList[i];
newList[i] = transformExpression
);
return(newList);
);
a = {"1", "2", "100"};
b = transformList(a, Expr(Num(val)));
c = transformList(b, Expr(Multiply(val, 10)));
d = transformList(c, Expr(Char(val)));
Show(a,b,c,d);
//can also use custom functions with transformList
padZero = function({tempValue}, {Default Local},
if(Length(tempValue) < 2,
tempValue = "0" || tempValue;
);
return(tempValue)
);
e = transformList(a, Expr(padZero(val)));
Show(e);
f = transformList(e, Expr(Length(val)));
Show(f);
Beliebige Operationen (Funktionen usw.) für jedes Element in einer ListeGibt es eine einfachere Möglichkeit, dieselbe Funktion auf jedes Element einer Liste anzuwenden, als eine Liste zu durchlaufen?
Zum Beispiel:
stringlist = {"1", "2"};
numericlist = {};
for (i = 1, i<=N Items(stringlist), i++,
numericlist[i] = Num(stringlist[i])
);
show(numericlist);Gibt es etwas Einfacheres, etwa einfach zu sagen:
numericlist = Num(stringlist);
aber das funktioniert offensichtlich nicht. Gibt es eine andere Möglichkeit?
PS Habe gerade die For Each-Funktion neu in JMP 16 gefunden, leider bin ich immer noch bei JMP 15
Verbraucher- und MarktforschungVersuchsplanungQualitäts- und Verfahrenstechnik
