Re : Opérations arbitraires (fonctions, etc.) sur chaque élément d'une listeSi votre cas est comme ça, vous pourriez éventuellement éviter de boucler au moins pour la transformation en utilisant Parse() (bien qu'il puisse être plus rapide de parcourir la chaîne).
Names Default To Here(1);<BR />str = "120, 130, 160, 120, 300, 200";
numList = Parse("{" || str ||"}");
Show(numList[1], numList[2]);Comme tableau de données :
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]);Re : Opérations arbitraires (fonctions, etc.) sur chaque élément d'une listeMerci les gars!
C'est génial.
J'ai en fait trouvé JMP16 sur notre intranet, le service informatique a déclaré qu'ils étaient juste en train de préparer les instructions d'installation et de les publier officiellement. Alors je suis allé de l'avant et je l'ai quand même installé.
Ma (mes) tâche(s) réelle(s) était (étaient) un peu plus compliquée, par exemple, dans un cas, j'avais une liste de chaînes de type
"120, 130, 160, 120, 300, 200"
Les données réelles seraient une colonne avec chaque ligne ayant ce type de chaîne (seulement beaucoup plus longtemps)
J'avais besoin de transformer cela en liste de listes de nombres. J'avais donc besoin de lire cette colonne dans une liste initiale, puis d'appliquer Words () sur cette liste initiale pour obtenir la liste des listes de chaînes, puis Num () pour obtenir chaque chaîne en un nombre. Cela signifie deux boucles imbriquées.
Pour l'instant, je l'ai fait avec deux boucles For Each, mais permettez-moi d'examiner les suggestions que vous avez publiées ici. Je n'ai jamais pu comprendre Expr() - je suppose que je dois lui donner une autre chance.
Merci!
Re : Opérations arbitraires (fonctions, etc.) sur chaque élément d'une liste@miguello ,
@jthi vous a donné d'excellentes réponses (bravo).Moi aussi, j'étais tellement excité par la fonction TransformEach de JMP 16.
Vous trouverez ci-dessous une partie modifiée d'un script écrit pour des versions beaucoup plus anciennes de JMP et publié pour JMP13. Beaucoup de mes anciens collègues ont utilisé la fonction LFUNC (le nom est l'abréviation de la fonction de liste).Le nom JMP 16 "TransformEach" et la syntaxe sont si bons. Cependant, si l'un des éléments de la liste est du type incorrect pour la transformation spécifiée, une erreur est renvoyée... une fonction Try() peut résoudre ce problème.
Donc, juste au cas où cela pourrait être utile jusqu'à ce que vous arriviez à JMP 16, je le poste.Enregistrez simplement la partie de définition de fonction du code dans un fichier et utilisez Include () dans n'importe quel script dont vous avez besoin.
// 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
Re : Opérations arbitraires (fonctions, etc.) sur chaque élément d'une listeComme vous l'avez déjà remarqué, JMP16 vous aidera avec For Each et Transform Each. Si vous devez le faire plusieurs fois, vous pourriez peut-être créer des fonctions personnalisées pour effectuer les tâches ?
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);
Modifier:
Vous pouvez également créer une fonction plus compliquée qui pourrait gérer différentes transformations. Ce sera probablement exagéré et je ne le recommanderais pas vraiment (je créerais simplement différentes fonctions pour différentes transformations).
Voici un exemple de comment cela pourrait être fait :
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);
Opérations arbitraires (fonctions, etc.) sur chaque élément d'une listeExiste-t-il un moyen plus simple d'appliquer la même fonction à chaque élément d'une liste plutôt que de parcourir une liste ?
Par exemple:
stringlist = {"1", "2"};
numericlist = {};
for (i = 1, i<=N Items(stringlist), i++,
numericlist[i] = Num(stringlist[i])
);
show(numericlist);Y a-t-il quelque chose de plus simple, quelque chose comme simplement dire :
numericlist = Num(stringlist);
mais cela ne fonctionne évidemment pas. Un autre moyen ?
PS Je viens de trouver la fonction For Each nouvelle dans JMP 16, malheureusement, je suis toujours sur JMP 15
Études de consommation et de marchéConception d'expériencesIngénierie de la qualité et des procédés
