diff --git a/src/ML-IAP/mliap_descriptor_so3.cpp b/src/ML-IAP/mliap_descriptor_so3.cpp
index e8bedea377..48748d8565 100644
--- a/src/ML-IAP/mliap_descriptor_so3.cpp
+++ b/src/ML-IAP/mliap_descriptor_so3.cpp
@@ -125,28 +125,27 @@ void MLIAPDescriptorSO3::read_paramfile(char *paramfilename)
 
     // check for keywords with one value per element
 
-    if (strcmp(skeywd.c_str(), "elems") == 0 || strcmp(skeywd.c_str(), "radelems") == 0 ||
-        strcmp(skeywd.c_str(), "welems") == 0) {
+    if ((skeywd == "elems") || (skeywd == "radelems") || (skeywd == "welems"))  {
 
       if (nelementsflag == 0 || nwords != nelements + 1)
         error->all(FLERR, "Incorrect SO3 parameter file");
 
-      if (strcmp(skeywd.c_str(), "elems") == 0) {
+      if (skeywd == "elems") {
         for (int ielem = 0; ielem < nelements; ielem++) {
           elements[ielem] = utils::strdup(skeyval);
           if (ielem < nelements - 1) skeyval = p.next();
         }
 
         elementsflag = 1;
-      } else if (strcmp(skeywd.c_str(), "radelems") == 0) {
+      } else if (skeywd == "radelems")  {
         for (int ielem = 0; ielem < nelements; ielem++) {
-          radelem[ielem] = utils::numeric(FLERR, skeyval.c_str(), false, lmp);
+          radelem[ielem] = utils::numeric(FLERR, skeyval, false, lmp);
           if (ielem < nelements - 1) skeyval = p.next();
         }
         radelemflag = 1;
-      } else if (strcmp(skeywd.c_str(), "welems") == 0) {
+      } else if (skeywd == "welems") {
         for (int ielem = 0; ielem < nelements; ielem++) {
-          wjelem[ielem] = utils::numeric(FLERR, skeyval.c_str(), false, lmp);
+          wjelem[ielem] = utils::numeric(FLERR, skeyval, false, lmp);
           if (ielem < nelements - 1) skeyval = p.next();
         }
         wjelemflag = 1;
@@ -158,23 +157,23 @@ void MLIAPDescriptorSO3::read_paramfile(char *paramfilename)
 
       if (nwords != 2) error->all(FLERR, "Incorrect SO3 parameter file");
 
-      if (strcmp(skeywd.c_str(), "nelems") == 0) {
-        nelements = utils::inumeric(FLERR, skeyval.c_str(), false, lmp);
+      if (skeywd == "nelems") {
+        nelements = utils::inumeric(FLERR, skeyval, false, lmp);
         elements = new char *[nelements];
         memory->create(radelem, nelements, "mliap_so3_descriptor:radelem");
         memory->create(wjelem, nelements, "mliap_so3_descriptor:wjelem");
         nelementsflag = 1;
-      } else if (strcmp(skeywd.c_str(), "rcutfac") == 0) {
-        rcutfac = utils::numeric(FLERR, skeyval.c_str(), false, lmp);
+      } else if (skeywd == "rcutfac") {
+        rcutfac = utils::numeric(FLERR, skeyval, false, lmp);
         rcutfacflag = 1;
-      } else if (strcmp(skeywd.c_str(), "nmax") == 0) {
-        nmax = utils::inumeric(FLERR, skeyval.c_str(), false, lmp);
+      } else if (skeywd == "nmax") {
+        nmax = utils::inumeric(FLERR, skeyval, false, lmp);
         nmaxflag = 1;
-      } else if (strcmp(skeywd.c_str(), "lmax") == 0) {
-        lmax = utils::inumeric(FLERR, skeyval.c_str(), false, lmp);
+      } else if (skeywd == "lmax") {
+        lmax = utils::inumeric(FLERR, skeyval, false, lmp);
         lmaxflag = 1;
-      } else if (strcmp(skeywd.c_str(), "alpha") == 0) {
-        alpha = utils::numeric(FLERR, skeyval.c_str(), false, lmp);
+      } else if (skeywd == "alpha") {
+        alpha = utils::numeric(FLERR, skeyval, false, lmp);
         alphaflag = 1;
       } else
         error->all(FLERR, "Incorrect SO3 parameter file");
diff --git a/src/ML-RANN/pair_rann.cpp b/src/ML-RANN/pair_rann.cpp
index 3e97b638dc..97a3478332 100644
--- a/src/ML-RANN/pair_rann.cpp
+++ b/src/ML-RANN/pair_rann.cpp
@@ -440,7 +440,7 @@ void PairRANN::read_mass(const std::vector<std::string> &line1, const std::vecto
   if (nelements == -1)error->one(filename,linenum-1,"atom types must be defined before mass in potential file.");
   for (int i=0;i<nelements;i++) {
     if (line1[1].compare(elements[i])==0) {
-      mass[i]=utils::numeric(filename,linenum,line2[0].c_str(),true,lmp);
+      mass[i]=utils::numeric(filename,linenum,line2[0],true,lmp);
       return;
     }
   }
@@ -452,7 +452,7 @@ void PairRANN::read_fpe(std::vector<std::string> line,std::vector<std::string> l
   if (nelements == -1)error->one(filename,linenum-1,"atom types must be defined before fingerprints per element in potential file.");
   for (i=0;i<nelementsp;i++) {
     if (line[1].compare(elementsp[i])==0) {
-      fingerprintperelement[i] = utils::inumeric(filename,linenum,line1[0].c_str(),true,lmp);
+      fingerprintperelement[i] = utils::inumeric(filename,linenum,line1[0],true,lmp);
       fingerprints[i] = new RANN::Fingerprint *[fingerprintperelement[i]];
       for (int j=0;j<fingerprintperelement[i];j++) {
         fingerprints[i][j]=new RANN::Fingerprint(this);
@@ -491,7 +491,7 @@ void PairRANN::read_fingerprints(std::vector<std::string> line,std::vector<std::
     fingerprints[i][i1] = create_fingerprint(line1[k].c_str());
     if (fingerprints[i][i1]->n_body_type!=nwords-1) {error->one(filename,linenum,"invalid fingerprint for element combination");}
     k++;
-    fingerprints[i][i1]->init(atomtypes,utils::inumeric(filename,linenum,line1[k++].c_str(),true,lmp));
+    fingerprints[i][i1]->init(atomtypes,utils::inumeric(filename,linenum,line1[k++],true,lmp));
     fingerprintcount[i]++;
   }
   delete[] atomtypes;
@@ -523,7 +523,7 @@ void PairRANN::read_fingerprint_constants(std::vector<std::string> line,std::vec
     for (j=0;j<n_body_type;j++) {
       if (fingerprints[i][k]->atomtypes[j]!=atomtypes[j]) {break;}
       if (j==n_body_type-1) {
-        if (line[nwords-3].compare(fingerprints[i][k]->style)==0 && utils::inumeric(filename,linenum,line[nwords-2].c_str(),true,lmp)==fingerprints[i][k]->id) {
+        if (line[nwords-3].compare(fingerprints[i][k]->style)==0 && utils::inumeric(filename,linenum,line[nwords-2],true,lmp)==fingerprints[i][k]->id) {
           found=true;
           i1 = k;
           break;
@@ -542,7 +542,7 @@ void PairRANN::read_network_layers(std::vector<std::string> line,std::vector<std
   if (nelements == -1)error->one(filename,linenum-1,"atom types must be defined before network layers in potential file.");
   for (i=0;i<nelements;i++) {
     if (line[1].compare(elements[i])==0) {
-      net[i].layers = utils::inumeric(filename,linenum,line1[0].c_str(),true,lmp);
+      net[i].layers = utils::inumeric(filename,linenum,line1[0],true,lmp);
       if (net[i].layers < 1)error->one(filename,linenum,"invalid number of network layers");
       delete[] net[i].dimensions;
       weightdefined[i] = new bool [net[i].layers];
@@ -570,9 +570,9 @@ void PairRANN::read_layer_size(std::vector<std::string> line,std::vector<std::st
   for (i=0;i<nelements;i++) {
     if (line[1].compare(elements[i])==0) {
       if (net[i].layers==0)error->one(filename,linenum-1,"networklayers for each atom type must be defined before the corresponding layer sizes.");
-      int j = utils::inumeric(filename,linenum,line[2].c_str(),true,lmp);
+      int j = utils::inumeric(filename,linenum,line[2],true,lmp);
       if (j>=net[i].layers || j<0) {error->one(filename,linenum,"invalid layer in layer size definition");};
-      net[i].dimensions[j]= utils::inumeric(filename,linenum,line1[0].c_str(),true,lmp);
+      net[i].dimensions[j]= utils::inumeric(filename,linenum,line1[0],true,lmp);
       return;
     }
   }
@@ -587,7 +587,7 @@ void PairRANN::read_weight(std::vector<std::string> line,std::vector<std::string
   for (l=0;l<nelements;l++) {
     if (line[1].compare(elements[l])==0) {
       if (net[l].layers==0)error->one(filename,*linenum-1,"networklayers must be defined before weights.");
-      i=utils::inumeric(filename,*linenum,line[2].c_str(),true,lmp);
+      i=utils::inumeric(filename,*linenum,line[2],true,lmp);
       if (i>=net[l].layers || i<0)error->one(filename,*linenum-1,"invalid weight layer");
       if (net[l].dimensions[i]==0 || net[l].dimensions[i+1]==0) error->one(filename,*linenum-1,"network layer sizes must be defined before corresponding weight");
       net[l].Weights[i] = new double[net[l].dimensions[i]*net[l].dimensions[i+1]];
@@ -595,7 +595,7 @@ void PairRANN::read_weight(std::vector<std::string> line,std::vector<std::string
       nwords = line1.size();
       if (nwords != net[l].dimensions[i])error->one(filename,*linenum,"invalid weights per line");
       for (k=0;k<net[l].dimensions[i];k++) {
-        net[l].Weights[i][k] = utils::numeric(filename,*linenum,line1[k].c_str(),true,lmp);
+        net[l].Weights[i][k] = utils::numeric(filename,*linenum,line1[k],true,lmp);
       }
       for (j=1;j<net[l].dimensions[i+1];j++) {
         ptr = fgets(linetemp,longline,fp);
@@ -606,7 +606,7 @@ void PairRANN::read_weight(std::vector<std::string> line,std::vector<std::string
         nwords = line1.size();
         if (nwords != net[l].dimensions[i])error->one(filename,*linenum,"invalid weights per line");
         for (k=0;k<net[l].dimensions[i];k++) {
-          net[l].Weights[i][j*net[l].dimensions[i]+k] = utils::numeric(filename,*linenum,line1[k].c_str(),true,lmp);
+          net[l].Weights[i][j*net[l].dimensions[i]+k] = utils::numeric(filename,*linenum,line1[k],true,lmp);
         }
       }
       return;
@@ -621,19 +621,19 @@ void PairRANN::read_bias(std::vector<std::string> line,std::vector<std::string>
   for (l=0;l<nelements;l++) {
     if (line[1].compare(elements[l])==0) {
       if (net[l].layers==0)error->one(filename,*linenum-1,"networklayers must be defined before biases.");
-      i=utils::inumeric(filename,*linenum,line[2].c_str(),true,lmp);
+      i=utils::inumeric(filename,*linenum,line[2],true,lmp);
       if (i>=net[l].layers || i<0)error->one(filename,*linenum-1,"invalid bias layer");
       if (net[l].dimensions[i]==0) error->one(filename,*linenum-1,"network layer sizes must be defined before corresponding bias");
       biasdefined[l][i] = true;
       net[l].Biases[i] = new double[net[l].dimensions[i+1]];
-      net[l].Biases[i][0] = utils::numeric(filename,*linenum,line1[0].c_str(),true,lmp);
+      net[l].Biases[i][0] = utils::numeric(filename,*linenum,line1[0],true,lmp);
       for (j=1;j<net[l].dimensions[i+1];j++) {
         ptr=fgets(linetemp,MAXLINE,fp);
         if (ptr==nullptr)error->one(filename,*linenum,"unexpected end of potential file!");
         (*linenum)++;
         Tokenizer values1 = Tokenizer(linetemp,": ,\t_\n");
         line1 = values1.as_vector();
-        net[l].Biases[i][j] = utils::numeric(filename,*linenum,line1[0].c_str(),true,lmp);
+        net[l].Biases[i][j] = utils::numeric(filename,*linenum,line1[0],true,lmp);
       }
       return;
     }
@@ -680,10 +680,10 @@ void PairRANN::read_screening(std::vector<std::string> line,std::vector<std::str
   k = atomtypes[2];
   int index = i*nelements*nelements+j*nelements+k;
   if (line[4].compare("Cmin")==0)  {
-    screening_min[index] = utils::numeric(filename,linenum,line1[0].c_str(),true,lmp);
+    screening_min[index] = utils::numeric(filename,linenum,line1[0],true,lmp);
   }
   else if (line[4].compare("Cmax")==0) {
-    screening_max[index] = utils::numeric(filename,linenum,line1[0].c_str(),true,lmp);
+    screening_max[index] = utils::numeric(filename,linenum,line1[0],true,lmp);
   }
   else error->one(filename,linenum-1,"unrecognized screening keyword");
   delete[] atomtypes;
diff --git a/src/ML-SNAP/pair_snap.cpp b/src/ML-SNAP/pair_snap.cpp
index 1eb078bc61..eafb27f5ba 100644
--- a/src/ML-SNAP/pair_snap.cpp
+++ b/src/ML-SNAP/pair_snap.cpp
@@ -570,8 +570,8 @@ void PairSNAP::read_files(char *coefffilename, char *paramfilename)
     else
       elementflags[jelem] = 1;
 
-    radelem[jelem] = utils::numeric(FLERR,words[1].c_str(),false,lmp);
-    wjelem[jelem] = utils::numeric(FLERR,words[2].c_str(),false,lmp);
+    radelem[jelem] = utils::numeric(FLERR,words[1],false,lmp);
+    wjelem[jelem] = utils::numeric(FLERR,words[2],false,lmp);
 
     if (comm->me == 0)
       utils::logmesg(lmp,"SNAP Element = {}, Radius {}, Weight {}\n",
@@ -672,34 +672,33 @@ void PairSNAP::read_files(char *coefffilename, char *paramfilename)
       utils::logmesg(lmp,"SNAP keyword {} {}\n",keywd,keyval);
 
     if (keywd == "rcutfac") {
-      rcutfac = utils::numeric(FLERR,keyval.c_str(),false,lmp);
+      rcutfac = utils::numeric(FLERR,keyval,false,lmp);
       rcutfacflag = 1;
     } else if (keywd == "twojmax") {
-      twojmax = utils::inumeric(FLERR,keyval.c_str(),false,lmp);
+      twojmax = utils::inumeric(FLERR,keyval,false,lmp);
       twojmaxflag = 1;
     } else if (keywd == "rfac0")
-      rfac0 = utils::numeric(FLERR,keyval.c_str(),false,lmp);
+      rfac0 = utils::numeric(FLERR,keyval,false,lmp);
     else if (keywd == "rmin0")
-      rmin0 = utils::numeric(FLERR,keyval.c_str(),false,lmp);
+      rmin0 = utils::numeric(FLERR,keyval,false,lmp);
     else if (keywd == "switchflag")
-      switchflag = utils::inumeric(FLERR,keyval.c_str(),false,lmp);
+      switchflag = utils::inumeric(FLERR,keyval,false,lmp);
     else if (keywd == "bzeroflag")
-      bzeroflag = utils::inumeric(FLERR,keyval.c_str(),false,lmp);
+      bzeroflag = utils::inumeric(FLERR,keyval,false,lmp);
     else if (keywd == "quadraticflag")
-      quadraticflag = utils::inumeric(FLERR,keyval.c_str(),false,lmp);
+      quadraticflag = utils::inumeric(FLERR,keyval,false,lmp);
     else if (keywd == "chemflag")
-      chemflag = utils::inumeric(FLERR,keyval.c_str(),false,lmp);
+      chemflag = utils::inumeric(FLERR,keyval,false,lmp);
     else if (keywd == "bnormflag")
-      bnormflag = utils::inumeric(FLERR,keyval.c_str(),false,lmp);
+      bnormflag = utils::inumeric(FLERR,keyval,false,lmp);
     else if (keywd == "wselfallflag")
-      wselfallflag = utils::inumeric(FLERR,keyval.c_str(),false,lmp);
+      wselfallflag = utils::inumeric(FLERR,keyval,false,lmp);
     else if (keywd == "chunksize")
-      chunksize = utils::inumeric(FLERR,keyval.c_str(),false,lmp);
+      chunksize = utils::inumeric(FLERR,keyval,false,lmp);
     else if (keywd == "parallelthresh")
-      parallel_thresh = utils::inumeric(FLERR,keyval.c_str(),false,lmp);
+      parallel_thresh = utils::inumeric(FLERR,keyval,false,lmp);
     else
-      error->all(FLERR,"Unknown parameter '{}' in SNAP "
-                                   "parameter file", keywd);
+      error->all(FLERR,"Unknown parameter '{}' in SNAP parameter file", keywd);
   }
 
   if (rcutfacflag == 0 || twojmaxflag == 0)
diff --git a/src/atom.cpp b/src/atom.cpp
index bf791b8c35..438dcd4870 100644
--- a/src/atom.cpp
+++ b/src/atom.cpp
@@ -1144,9 +1144,9 @@ void Atom::data_atoms(int n, char *buf, tagint id_offset, tagint mol_offset,
 
     int imx = 0, imy = 0, imz = 0;
     if (imageflag) {
-      imx = utils::inumeric(FLERR,values[iptr].c_str(),false,lmp);
-      imy = utils::inumeric(FLERR,values[iptr+1].c_str(),false,lmp);
-      imz = utils::inumeric(FLERR,values[iptr+2].c_str(),false,lmp);
+      imx = utils::inumeric(FLERR,values[iptr],false,lmp);
+      imy = utils::inumeric(FLERR,values[iptr+1],false,lmp);
+      imz = utils::inumeric(FLERR,values[iptr+2],false,lmp);
       if ((domain->dimension == 2) && (imz != 0))
         error->all(FLERR,"Z-direction image flag must be 0 for 2d-systems");
       if ((!domain->xperiodic) && (imx != 0)) { reset_image_flag[0] = true; imx = 0; }
@@ -1157,9 +1157,9 @@ void Atom::data_atoms(int n, char *buf, tagint id_offset, tagint mol_offset,
         (((imageint) (imy + IMGMAX) & IMGMASK) << IMGBITS) |
         (((imageint) (imz + IMGMAX) & IMGMASK) << IMG2BITS);
 
-    xdata[0] = utils::numeric(FLERR,values[xptr].c_str(),false,lmp);
-    xdata[1] = utils::numeric(FLERR,values[xptr+1].c_str(),false,lmp);
-    xdata[2] = utils::numeric(FLERR,values[xptr+2].c_str(),false,lmp);
+    xdata[0] = utils::numeric(FLERR,values[xptr],false,lmp);
+    xdata[1] = utils::numeric(FLERR,values[xptr+1],false,lmp);
+    xdata[2] = utils::numeric(FLERR,values[xptr+2],false,lmp);
     if (shiftflag) {
       xdata[0] += shift[0];
       xdata[1] += shift[1];
diff --git a/src/atom_vec.cpp b/src/atom_vec.cpp
index cfecfa4d48..f80d25b706 100644
--- a/src/atom_vec.cpp
+++ b/src/atom_vec.cpp
@@ -1732,7 +1732,7 @@ void AtomVec::data_atom(double *coord, imageint imagetmp, const std::vector<std:
     if (datatype == Atom::DOUBLE) {
       if (cols == 0) {
         double *vec = *((double **) pdata);
-        vec[nlocal] = utils::numeric(FLERR,values[ivalue++].c_str(),true,lmp);
+        vec[nlocal] = utils::numeric(FLERR,values[ivalue++],true,lmp);
       } else {
         double **array = *((double ***) pdata);
         if (array == atom->x) {      // x was already set by coord arg
@@ -1740,25 +1740,25 @@ void AtomVec::data_atom(double *coord, imageint imagetmp, const std::vector<std:
           continue;
         }
         for (m = 0; m < cols; m++)
-          array[nlocal][m] = utils::numeric(FLERR,values[ivalue++].c_str(),true,lmp);
+          array[nlocal][m] = utils::numeric(FLERR,values[ivalue++],true,lmp);
       }
     } else if (datatype == Atom::INT) {
       if (cols == 0) {
         int *vec = *((int **) pdata);
-        vec[nlocal] = utils::inumeric(FLERR,values[ivalue++].c_str(),true,lmp);
+        vec[nlocal] = utils::inumeric(FLERR,values[ivalue++],true,lmp);
       } else {
         int **array = *((int ***) pdata);
         for (m = 0; m < cols; m++)
-          array[nlocal][m] = utils::inumeric(FLERR,values[ivalue++].c_str(),true,lmp);
+          array[nlocal][m] = utils::inumeric(FLERR,values[ivalue++],true,lmp);
       }
     } else if (datatype == Atom::BIGINT) {
       if (cols == 0) {
         bigint *vec = *((bigint **) pdata);
-        vec[nlocal] = utils::bnumeric(FLERR,values[ivalue++].c_str(),true,lmp);
+        vec[nlocal] = utils::bnumeric(FLERR,values[ivalue++],true,lmp);
       } else {
         bigint **array = *((bigint ***) pdata);
         for (m = 0; m < cols; m++)
-          array[nlocal][m] = utils::bnumeric(FLERR,values[ivalue++].c_str(),true,lmp);
+          array[nlocal][m] = utils::bnumeric(FLERR,values[ivalue++],true,lmp);
       }
     }
   }