Replacement for FUNCTION 'SAP_TO_ISO_MEASURE_UNIT_CODE' in ecc 6.0

Hi all!
Can any one please tel me the replacement for FUNCTION 'SAP_TO_ISO_MEASURE_UNIT_CODE' which is oboselete in ecc 6.0. I need the revised function module for this in ecc 6.0.

You can try with this function module OIK_TO_ISO_MEASURE_UNIT_CODE.
Reward if it is useful.
Thanks,
Srinivas

Similar Messages

Replacement for FUNCTION 'DYNP_VALUES_UPDATE'in ecc 6.0

Hi all!
Can any one please tel me the replacement for FUNCTION 'DYNP_VALUES_UPDATE'which is oboselete in ecc 6.0. I need the revised function module for this in ecc 6.0.

Where do you have the information from that this function module is obsolete in ECC6. Neither the shortext nor any comments in the code nor the function module documentation states that this is obsolete (which is usually does if it is).
The only thing that the function module documentation says is that the solution was revised as well as the docu, therefore I can't see why this function module would be obsolete.
Hope that helps,
Michael

Replacement for FUNCTION 'CONVERT_DATE_INPUT' in ecc 6.0

Hi all!
Can any one please tel me the replacement for FUNCTION 'CONVERT_DATE_INPUT' which is oboselete in ecc 6.0. I need the revised function module for this in ecc 6.0.

Try with this function module - /SAPDII/SPP05_CONVERT_DATE
Reward if it is useful.
Thanks,
Srinivas

Replacement for Function Module 'SEND_TABLE_TO_EXCEL' in ECC 6.0

Hi Friends,
Can anybody help me to find the replacement of Function Module 'SEND_TABLE_TO_EXCEL' in ECC 6.0.
The Function Module exists in 4.6b. But it is no longer available in ECC 6.0.
Regards,
Vaitheeswaran.

If you want to download an internal table to excel format you can use the "GUI_DOWNLOAD" function.Some sample code is as below.
types: begin of gs_xcel,
 vkorg type vbak-vkorg,
 del1(1) type c,
 vtweg type vbak-vtweg,
 del2(1) type c,
 zzposmgr type zzsdacspo-zzposmgr,
 del3(1) type c,
 zz_region type zzsdaregn-zz_region,
 del4(1) type c,
 ename2 type pa0001-ename,
 del5(1) type c,
 zzcsospos type vbak-zzcsospos,
 del6(1) type c,
 ename type pa0001-ename,
 del7(1) type c,
 vbeln type vbfs-vbeln,
 del8(1) type c,
 text type t100-text,
 del9(1) type c,
 msgv1 type vbfs-msgv1,
 del10(1) type c,
 auart type vbak-auart,
 del11(1) type c,
 erdat type vbsk-erdat,
 del12(1) type c,
 wadat_ist type likp-wadat_ist,
 end of gs_xcel.
data: gt_xcel type table of gs_xcel,
 gws_xcel type gs_xcel.
data: v_tmp_name type string,
v_tmp_name = 'c:\sdrinver.xls'.
 call function 'GUI_DOWNLOAD'
 exporting
 BIN_FILESIZE =
 filename = v_tmp_name
 FILETYPE = 'ASC'
 APPEND = ' '
 WRITE_FIELD_SEPARATOR = ','
 HEADER = '00'
 TRUNC_TRAILING_BLANKS = ' '
 WRITE_LF = 'X'
 COL_SELECT = ' '
 COL_SELECT_MASK = ' '
 DAT_MODE = ' '
 CONFIRM_OVERWRITE = ' '
 NO_AUTH_CHECK = ' '
 CODEPAGE = ' '
 IGNORE_CERR = ABAP_TRUE
 REPLACEMENT = '#'
 WRITE_BOM = ' '
 TRUNC_TRAILING_BLANKS_EOL = 'X'
 WK1_N_FORMAT = ' '
 WK1_N_SIZE = ' '
 WK1_T_FORMAT = ' '
 WK1_T_SIZE = ' '
 IMPORTING
 FILELENGTH =
 tables
 data_tab = gt_xcel
 FIELDNAMES =
 EXCEPTIONS
 FILE_WRITE_ERROR = 1
 NO_BATCH = 2
 GUI_REFUSE_FILETRANSFER = 3
 INVALID_TYPE = 4
 NO_AUTHORITY = 5
 UNKNOWN_ERROR = 6
 HEADER_NOT_ALLOWED = 7
 SEPARATOR_NOT_ALLOWED = 8
 FILESIZE_NOT_ALLOWED = 9
 HEADER_TOO_LONG = 10
 DP_ERROR_CREATE = 11
 DP_ERROR_SEND = 12
 DP_ERROR_WRITE = 13
 UNKNOWN_DP_ERROR = 14
 ACCESS_DENIED = 15
 DP_OUT_OF_MEMORY = 16
 DISK_FULL = 17
 DP_TIMEOUT = 18
 FILE_NOT_FOUND = 19
 DATAPROVIDER_EXCEPTION = 20
 CONTROL_FLUSH_ERROR = 21
 OTHERS = 22

Replacement of Function module in ECC 6.0

Hello All,
The Function module 'NAMETAB_GET' is shown to be obsolete in ECC 6.0 .
Please suggest which of the function modules among 'DDIF_FIELDINFO_GET' and 'DDIF_NAMETAB_GET' can be used as a replacement for the same.
Also ,it would be helpful if the use of these function modules is mentioned.
Best Regards,
Lavanya.

use 'DDIF_NAMETAB_GET'
Functionality
This function module reads the runtime information (nametab) of a table or in general of any type of the ABAP Dictionary. However, the runtime information does not contain any text. You should use the function module DDIF_FIELDINFO_GET to read the runtime information including text (or to determine the domain for table fields).
The types of the ABAP Dictionary are divided into data elements, structured types and table types.
A structured type consists of a sequence of components that are each identified by a unique name. A type is defined for each of these components. In addition to the types of the ABAP Dictionary, you can also use the built-in types of the R/3 System (CHAR, NUMC,...) to define the types of the components.
All its components as well as the fields of its structured components are called the fields of a structured type. The name of a field no longer uniquely identifies it within a structured type. For example, a structured type S could have a structured component F, which itself has a component called F. In this case S would have two fields with the name F. For this reason, its long field name is used to identify a field within a structured type. The long field name is the same as the name of the components for the components of the structured type itself. For the fields of a structured component, the long field name is a concatenation of the name of this structured component, the separator '-' and the long field name of the field in the structured component.
A field whose type is defined by a data element or a built-in type is also called an elementary type. A structured type whose components are all defined as elementary types is called flat. All other structured types are called deep.
This module gets the runtime information for the type whose name is defined in the IMPORT parameter TABNAME. If there is no such type, the exception NOT_FOUND is triggered.
Caution: If the IMPORT parameter ALL_TYPES is not set, only flat structured types are taken into consideration. In this case the exception is also triggered if the specified type is a data element, deep structure or a table type.
If the IMPORT parameter LFIELDNAME is not initial, only structured types having a field with the long name defined by LFIELDNAME are taken into consideration. The exception NOT_FOUND is triggered for all other types.
The internal representation of the runtime object is returned in parameters X030L_WA and X031L_TAB. Depending on the type category, this information is then edited in the corresponding parameters (see documentation about the parameters).
Notes
1. If parameter LFIELDNAME is not initial, X031L_TAB nevertheless contains the description of all fields of the structured type. The decoded form is only determined for the specified field, and the result is copied to DFIES_WA instead of DFIES_TAB. Since decoding for all the fields often takes up most of the runtime for this module, you should set parameter LFIELDNAME if you only need information about one field of the structured type.
This module gets the runtime information about a type. This means that only the currently active version of the type is taken into consideration. If none exists, the exception NOT_FOUND is triggered.
The corresponding function module DDIF_<object type>_GET is used to read the actual definition of a type of the ABAP Dictionary.
Caution: These read modules are much less efficient than the modules for defining the runtime information. You should therefore only use them if the runtime information is not sufficient.
2. The documentation for IMPORT parameter GROUP_NAMES describes how to handle named includes.

Need replacement for function module "WWW_GET_SCRIPT_AND_HTML"

Hi,
We are upgrading the system from 4.6c to ECC 6. "WWW_GET_SCRIPT_AND_HTML" is flagged as obsolete in the ECC 6 version.Can you please give me a replacement for the above FM.The code is as follows.......thanks in advance
CALL FUNCTION 'WWW_GET_SCRIPT_AND_HTML'
       EXPORTING
            obj_name = 'SDCAS_XML_TEMPLATE'
       TABLES
            html     = xml_output.
Thanks n regards,
Indu

Hi Indu,
Did you find the answer? If so could you post it?
Thanks in Advanced!
Kind Regards,
Gerardo J

Replacement for function modules

can anyone let me know the replacement for these function modules
POPUP_TO_CONFIRM_STEP
POPUP_TO_CONFIRM_WITH_MESSAGE

It says the name of the replacement right there in the Attributes of the above FMs: POPUP_TO_CONFIRM.
Hope this helps.
Sudha

Replacement for Function module 'ADDRESS_READ_FOR_USER'

Hi,
Please let me know the replacement for the FM 'ADDRESS_READ_FOR_USER'. This is obsoletein ECC6.0.

Hi aparna,
ADDRESS_READ
Regards,
Vamshi

Utilities- need replacement for FM ISU_DER_RESET_CROSS_REF_NO

Hi experts,
The Function module ISU_DER_RESET_CROSS_REF_NO does not exist in ECC.
This FM used in 4.7 version and as part of upgradation , I need to retrofit(fix) this.
I have searched for this FM in the forum, but could not find. Documentation for this FM even in 4.7 version could not be found.
Please help me to find the replacement for this FM in ECC.

Hi,
Any idea what FM 'ISU_DER_RESET_CROSS_REF_NO' does? Check Function Group 'E21DEREG', if any FM is helpful for you.
Thanks.
Ravi

Replacement for CRM_INTLAY_GET_HEADER_GUID in WebClient UI

Two years ago we implemented a classic badi for badi definition CRM_PRODUCT_I_BADI. Within the badi we need to determine the transaction header GUID. For the last two years the badi has operated by calling function module CRM_INTLAY_GET_HEADER_GUID to retrieve the header GUID. This function module still works fine if you are processing from within SAPgui. However, if you are processing from within the WebClient UI the function module no longer works because the header GUID is no longer buffered in that function group.
I have resorted to using function module CRM_ORDERADM_H_GET_OB but I am wondering if anyone knows of a more elegant replacement for function module CRM_INTLAY_GET_HEADER_GUID that will work in the WebClient UI? Perhaps something that pulls the header GUID out of the BOL core? Thanks.

Paul,
Technically when you are in the BADI's you are below the BOL layer and have to use the one order API function modules. I prefer using the OW modules instead of the OB, and technically I believe you are supposed to use OW instead.
The CRM_ORDERADM_H_READ_OW is probably your best bet down in that layer.
Thank you,
Stephen

Replacement for HELP_VALUES_GET_WITH_MATCHCODE in ECC 6.0

Hi Friends,
should the FM HELP_VALUES_GET_WITH_MATCHCODE bereplaced with the new one in ECC 6.0 or not.if so what is the replacement for it.Please provide.
Regards,
Pradeep P

Hi,
HELP_VALUES_GET_WITH_MACO is the one which is obsolete but is called from within the HELP_VALUES_GET_WITH_MATCHCODE function module which is not obsolete. I don't why it is like that, but may be for compatibility reasons, they left it out like that.
But as of now your function module is not obsolete.
Regards
Kiran Sure

Replacement of Function Module 'www_get_mime_object' in ECC 6.0

HI,
I need an exact replacement for the Function Module 'www_get_mime_object' in ECC 6.0.
Please help it out.
Regards,
Ashok.

hey

A replacement for the Quicksort function in the C++ library

Hi every one,
I'd like to introduce and share a new Triple State Quicksort algorithm which was the result of my research in sorting algorithms during the last few years. The new algorithm reduces the number of swaps to about two thirds (2/3) of classical Quicksort. A multitude
of other improvements are implemented. Test results against the std::sort() function shows an average of 43% improvement in speed throughout various input array types. It does this by trading space for performance at the price of n/2 temporary extra spaces.
The extra space is allocated automatically and efficiently in a way that reduces memory fragmentation and optimizes performance.
Triple State Algorithm
The classical way of doing Quicksort is as follows:
- Choose one element p. Called pivot. Try to make it close to the median.
- Divide the array into two parts. A lower (left) part that is all less than p. And a higher (right) part that is all greater than p.
- Recursively sort the left and right parts using the same method above.
- Stop recursion when a part reaches a size that can be trivially sorted.
The difference between the various implementations is in how they choose the pivot p, and where equal elements to the pivot are placed. There are several schemes as follows:
[ <=p | ? | >=p ]
[ =p | ? ]
[ <=p | =p | ? | >p ]
[ =p | p ] Then swap = part to middle at the end
[ =p | p | =p ] Then swap = parts to middle at the end
Where the goal (or the ideal goal) of the above schemes (at the end of a recursive stage) is to reach the following:
[ p ]
The above would allow exclusion of the =p part from further recursive calls thus reducing the number of comparisons. However, there is a difficulty in reaching the above scheme with minimal swaps. All previous implementation of Quicksort could not immediately
put =p elements in the middle using minimal swaps, first because p might not be in the perfect middle (i.e. median), second because we don’t know how many elements are in the =p part until we finish the current recursive stage.
The new Triple State method first enters a monitoring state 1 while comparing and swapping. Elements equal to p are immediately copied to the middle if they are not already there, following this scheme:
[ p ]
Then when either the left (<p) part or the right (>p) part meet the middle (=p) part, the algorithm will jump to one of two specialized states. One state handles the case for a relatively small =p part. And the other state handles the case for a relatively
large =p part. This method adapts to the nature of the input array better than the ordinary classical Quicksort.
Further reducing number of swaps
A typical quicksort loop scans from left, then scans from right. Then swaps. As follows:
while (l<=r)
while (ar[l]<p)
l++;
while (ar[r]>p)
r--;
if (l<r)
{ Swap(ar[l],ar[r]);
l++; r--;
else if (l==r)
{ l++; r--; break;
The Swap macro above does three copy operations:
Temp=ar[l]; ar[l]=ar[r]; ar[r]=temp;
There exists another method that will almost eliminate the need for that third temporary variable copy operation. By copying only the first ar[r] that is less than or equal to p, to the temp variable, we create an empty space in the array. Then we proceed scanning
from left to find the first ar[l] that is greater than or equal to p. Then copy ar[r]=ar[l]. Now the empty space is at ar[l]. We scan from right again then copy ar[l]=ar[r] and continue as such. As long as the temp variable hasn’t been copied back to the array,
the empty space will remain there juggling left and right. The following code snippet explains.
// Pre-scan from the right
while (ar[r]>p)
r--;
temp = ar[r];
// Main loop
while (l<r)
while (l<r && ar[l]<p)
l++;
if (l<r) ar[r--] = ar[l];
while (l<r && ar[r]>p)
r--;
if (l<r) ar[l++] = ar[r];
// After loop finishes, copy temp to left side
ar[r] = temp; l++;
if (temp==p) r--;
(For simplicity, the code above does not handle equal values efficiently. Refer to the complete code for the elaborate version).
This method is not new, a similar method has been used before (read: http://www.azillionmonkeys.com/qed/sort.html)
However it has a negative side effect on some common cases like nearly sorted or nearly reversed arrays causing undesirable shifting that renders it less efficient in those cases. However, when used with the Triple State algorithm combined with further common
cases handling, it eventually proves more efficient than the classical swapping approach.
Run time tests
Here are some test results, done on an i5 2.9Ghz with 6Gb of RAM. Sorting a random array of integers. Each test is repeated 5000 times. Times shown in milliseconds.
size std::sort() Triple State QuickSort
5000 2039 1609
6000 2412 1900
7000 2733 2220
8000 2993 2484
9000 3361 2778
10000 3591 3093
It gets even faster when used with other types of input or when the size of each element is large. The following test is done for random large arrays of up to 1000000 elements where each element size is 56 bytes. Test is repeated 25 times.
size std::sort() Triple State QuickSort
100000 1607 424
200000 3165 845
300000 4534 1287
400000 6461 1700
500000 7668 2123
600000 9794 2548
700000 10745 3001
800000 12343 3425
900000 13790 3865
1000000 15663 4348
Further extensive tests has been done following Jon Bentley’s framework of tests for the following input array types:
sawtooth: ar[i] = i % arange
random: ar[i] = GenRand() % arange + 1
stagger: ar[i] = (i* arange + i) % n
plateau: ar[i] = min(i, arange)
shuffle: ar[i] = rand()%arange? (j+=2): (k+=2)
I also add the following two input types, just to add a little torture:
Hill: ar[i] = min(i<(size>>1)? i:size-i,arange);
Organ Pipes: (see full code for details)
Where each case above is sorted then reordered in 6 deferent ways then sorted again after each reorder as follows:
Sorted, reversed, front half reversed, back half reversed, dithered, fort.
Note: GenRand() above is a certified random number generator based on Park-Miller method. This is to avoid any non-uniform behavior in C++ rand().
The complete test results can be found here:
http://solostuff.net/tsqsort/Tests_Percentage_Improvement_VC++.xls
or:
https://docs.google.com/spreadsheets/d/1wxNOAcuWT8CgFfaZzvjoX8x_WpusYQAlg0bXGWlLbzk/edit?usp=sharing
Theoretical Analysis
A Classical Quicksort algorithm performs less than 2n*ln(n) comparisons on the average (check JACEK CICHON’s paper) and less than 0.333n*ln(n) swaps on the average (check Wild and Nebel’s paper). Triple state will perform about the same number of comparisons
but with less swaps of about 0.222n*ln(n) in theory. In practice however, Triple State Quicksort will perform even less comparisons in large arrays because of a new 5 stage pivot selection algorithm that is used. Here is the detailed theoretical analysis:
http://solostuff.net/tsqsort/Asymptotic_analysis_of_Triple_State_Quicksort.pdf
Using SSE2 instruction set
SSE2 uses the 128bit sized XMM registers that can do memory copy operations in parallel since there are 8 registers of them. SSE2 is primarily used in speeding up copying large memory blocks in real-time graphics demanding applications.
In order to use SSE2, copied memory blocks have to be 16byte aligned. Triple State Quicksort will automatically detect if element size and the array starting address are 16byte aligned and if so, will switch to using SSE2 instructions for extra speedup. This
decision is made only once when the function is called so it has minor overhead.
Few other notes
- The standard C++ sorting function in almost all platforms religiously takes a “call back pointer” to a comparison function that the user/programmer provides. This is obviously for flexibility and to allow closed sourced libraries. Triple State
defaults to using a call back function. However, call back functions have bad overhead when called millions of times. Using inline/operator or macro based comparisons will greatly improve performance. An improvement of about 30% to 40% can be expected. Thus,
I seriously advise against using a call back function when ever possible. You can disable the call back function in my code by #undefining CALL_BACK precompiler directive.
- Like most other efficient implementations, Triple State switches to insertion sort for tiny arrays, whenever the size of a sub-part of the array is less than TINY_THRESH directive. This threshold is empirically chosen. I set it to 15. Increasing this
threshold will improve the speed when sorting nearly sorted and reversed arrays, or arrays that are concatenations of both cases (which are common). But will slow down sorting random or other types of arrays. To remedy this, I provide a dual threshold method
that can be enabled by #defining DUAL_THRESH directive. Once enabled, another threshold TINY_THRESH2 will be used which should be set lower than TINY_THRESH. I set it to 9. The algorithm is able to “guess” if the array or sub part of the array is already sorted
or reversed, and if so will use TINY_THRESH as it’s threshold, otherwise it will use the smaller threshold TINY_THRESH2. Notice that the “guessing” here is NOT fool proof, it can miss. So set both thresholds wisely.
- You can #define the RANDOM_SAMPLES precompiler directive to add randomness to the pivoting system to lower the chances of the worst case happening at a minor performance hit.
-When element size is very large (320 bytes or more). The function/algorithm uses a new “late swapping” method. This will auto create an internal array of pointers, sort the pointers array, then swap the original array elements to sorted order using minimal
swaps for a maximum of n/2 swaps. You can change the 320 bytes threshold with the LATE_SWAP_THRESH directive.
- The function provided here is optimized to the bone for performance. It is one monolithic piece of complex code that is ugly, and almost unreadable. Sorry about that, but inorder to achieve improved speed, I had to ignore common and good coding standards
a little. I don’t advise anyone to code like this, and I my self don’t. This is really a special case for sorting only. So please don’t trip if you see weird code, most of it have a good reason.
Finally, I would like to present the new function to Microsoft and the community for further investigation and possibly, inclusion in VC++ or any C++ library as a replacement for the sorting function.
You can find the complete VC++ project/code along with a minimal test program here:
http://solostuff.net/tsqsort/
Important: To fairly compare two sorting functions, both should either use or NOT use a call back function. If one uses and another doesn’t, then you will get unfair results, the one that doesn’t use a call back function will most likely win no matter how bad
it is!!
Ammar Muqaddas

Thanks for your interest.
Excuse my ignorance as I'm not sure what you meant by "1 of 5" optimization. Did you mean median of 5 ?
Regarding swapping pointers, yes it is common sense and rather common among programmers to swap pointers instead of swapping large data types, at the small price of indirect access to the actual data through the pointers.
However, there is a rather unobvious and quite terrible side effect of using this trick. After the pointer array is sorted, sequential (sorted) access to the actual data throughout the remaining of the program will suffer heavily because of cache misses.
Memory is being accessed randomly because the pointers still point to the unsorted data causing many many cache misses, which will render the program itself slow, although the sort was fast!!.
Multi-threaded qsort is a good idea in principle and easy to implement obviously because qsort itself is recursive. The thing is Multi-threaded qsort is actually just stealing CPU time from other cores that might be busy running other apps, this might slow
down other apps, which might not be ideal for servers. The thing researchers usually try to do is to do the improvement in the algorithm it self.
I Will try to look at your sorting code, lets see if I can compile it.

Additional functionality for vendor evaluation in ECC 6.0

Hi folks,
Can any one help me in getting the information below.
Is there any additional functionality for vendor evaluation in ECC 6.0 when compared to ECC 4.7
Pls let me know the functionality and the difference.
Thanks
Vasanth.

Hi
Is there any additional functionality for vendor evaluation in ECC 6.0 when compared to ECC 4.7
The Solution Browser lets you enter start and target releases for functional areas, and provides you with the information about the new functionalities.
You find the tool from our homepage at http://service.sap.com/erp (see the tool box on the right hand side).
regards
Andreas Rudolph

Alternative for Function module 'F4_CHOOSE_MCID' in ECC 5.0?

Hi,
Can any one tell me the Alternative for Function module 'F4_CHOOSE_MCID' in ECC 5.0?
Helpful answers will be rewarded.
Thanks
Kiran

Hi,
Please use this FM UMC_NOTIF_SEND_EMAIL to send an email in ECC 5.0.
Regards,
Ferry Lianto

Replacement for FUNCTION 'SAP_TO_ISO_MEASURE_UNIT_CODE' in ecc 6.0

Similar Messages

Maybe you are looking for