Skip to content

[BUG] arm64 CPU backend fails JIT compile when using Float16 #3080

@Joannis

Description

@Joannis

Describe the bug
When you configure MLX (through MLX-Swift in my case) to run on a arm64 Linux machine, JIT compilation fails when it involves a float16.

To Reproduce
I have a draft PR for MLX-swift-LM that demonstrates this in a Dockerfile:
ml-explore/mlx-swift-lm#87

Expected behavior
CPU backend, although slow, successfully JIT compiles the code and runs some inference.

Desktop (please complete the following information):

FROM --platform=linux/arm64 swift:6.2.3-jammy AS base

RUN apt-get update && apt-get install -y \
    libblas-dev \
    liblapack-dev \
    liblapacke-dev \
    libopenblas-dev \
    gfortran \
    g++ \
    && rm -rf /var/lib/apt/lists/* 

WORKDIR /app

FROM base AS builder

COPY . .
RUN swift build --product WebExample --static-swift-stdlib -Xlinker -s -v

# Final image
FROM base

# Copy executable from SwiftPM build directory
COPY --from=builder /app/.build/debug/WebExample /app/WebExample

EXPOSE 8080

CMD ["./WebExample"]

Additional context

MLX/ErrorHandler.swift:343: Fatal error: [Compile::eval_cpu] Failed to compile function     
  Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous: Failed to execute             
  command with return code 1: "g++ -std=c++17 -O3 -Wall -fPIC -shared                         
  "/tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp"      
  -o "/tmp/mlx/0.24.2/cpu/libBf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous     
  .so" 2>&1", the output is: /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188     
  972423790_contiguous.cpp:10:9: error: 'float16_t' has not been declared in '::'             
  10 | using ::float16_t;                                                                     
  |         ^~~~~~~~~                                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:74     
  :14: error: declaration of 'operator+' as non-function                                      
  74 | inline float operator+(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }           
  |              ^~~~~~~~                                                                     
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:74     
  :24: error: 'float16_t' was not declared in this scope; did you mean 'bfloat16_t'?          
  74 | inline float operator+(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }           
  |                        ^~~~~~~~~                                                          
  |                        bfloat16_t                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:74     
  :50: error: expected primary-expression before 'rhs'                                        
  74 | inline float operator+(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }           
  |                                                  ^~~                                      
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:74     
  :156: error: 'float16_t' has not been declared                                              
  74 | inline float operator+(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~~                                                                                   
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:74     
  :130: error: ambiguating new declaration of 'float                                          
  mlx::core::operator+(mlx::core::bfloat16_t, int)'                                           
  74 | inline float operator+(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:46     
  :869: note: old declaration 'mlx::core::_MLX_BFloat16                                       
  mlx::core::operator+(mlx::core::_MLX_BFloat16, int32_t)'                                    
  46 | inline _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return          
  static_cast<float>(lhs) + static_cast<float>(rhs); }; inline float                          
  operator+(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) +                  
  static_cast<float>(rhs); } inline float operator+(float lhs, _MLX_BFloat16 rhs) {           
  return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline double                  
  operator+(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) +                
  static_cast<double>(rhs); } inline double operator+(double lhs, _MLX_BFloat16 rhs) {        
  return static_cast<double>(lhs) + static_cast<double>(rhs); }; inline _MLX_BFloat16         
  operator+(_MLX_BFloat16 lhs, bool rhs) { return static_cast<float>(lhs) +                   
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator+(bool lhs, _MLX_BFloat16 rhs)      
  { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline _MLX_BFloat16         
  operator+(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) +                
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator+(int32_t lhs, _MLX_BFloat16        
  rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline                  
  _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, uint32_t rhs) { return                           
  static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_BFloat16                   
  operator+(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) +               
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, int64_t       
  rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator+(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) +                
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, uint64_t      
  rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator+(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) +               
  static_cast<float>(rhs); };;                                                                
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:75     
  :14: error: declaration of 'operator-' as non-function                                      
  75 | inline float operator-(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }           
  |              ^~~~~~~~                                                                     
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:75     
  :24: error: 'float16_t' was not declared in this scope; did you mean 'bfloat16_t'?          
  75 | inline float operator-(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }           
  |                        ^~~~~~~~~                                                          
  |                        bfloat16_t                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:75     
  :50: error: expected primary-expression before 'rhs'                                        
  75 | inline float operator-(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }           
  |                                                  ^~~                                      
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:75     
  :156: error: 'float16_t' has not been declared                                              
  75 | inline float operator-(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~~                                                                                   
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:75     
  :130: error: ambiguating new declaration of 'float                                          
  mlx::core::operator-(mlx::core::bfloat16_t, int)'                                           
  75 | inline float operator-(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:47     
  :869: note: old declaration 'mlx::core::_MLX_BFloat16                                       
  mlx::core::operator-(mlx::core::_MLX_BFloat16, int32_t)'                                    
  47 | inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return          
  static_cast<float>(lhs) - static_cast<float>(rhs); }; inline float                          
  operator-(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) -                  
  static_cast<float>(rhs); } inline float operator-(float lhs, _MLX_BFloat16 rhs) {           
  return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline double                  
  operator-(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) -                
  static_cast<double>(rhs); } inline double operator-(double lhs, _MLX_BFloat16 rhs) {        
  return static_cast<double>(lhs) - static_cast<double>(rhs); }; inline _MLX_BFloat16         
  operator-(_MLX_BFloat16 lhs, bool rhs) { return static_cast<float>(lhs) -                   
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator-(bool lhs, _MLX_BFloat16 rhs)      
  { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline _MLX_BFloat16         
  operator-(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) -                
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator-(int32_t lhs, _MLX_BFloat16        
  rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline                  
  _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, uint32_t rhs) { return                           
  static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_BFloat16                   
  operator-(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) -               
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, int64_t       
  rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator-(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) -                
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, uint64_t      
  rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator-(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) -               
  static_cast<float>(rhs); };;                                                                
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:76     
  :14: error: declaration of 'operator*' as non-function                                      
  76 | inline float operator*(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }           
  |              ^~~~~~~~                                                                     
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:76     
  :24: error: 'float16_t' was not declared in this scope; did you mean 'bfloat16_t'?          
  76 | inline float operator*(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }           
  |                        ^~~~~~~~~                                                          
  |                        bfloat16_t                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:76     
  :50: error: expected primary-expression before 'rhs'                                        
  76 | inline float operator*(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }           
  |                                                  ^~~                                      
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:76     
  :156: error: 'float16_t' has not been declared                                              
  76 | inline float operator*(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~~                                                                                   
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:76     
  :130: error: ambiguating new declaration of 'float                                          
  mlx::core::operator*(mlx::core::bfloat16_t, int)'                                           
  76 | inline float operator*(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:48     
  :869: note: old declaration 'mlx::core::_MLX_BFloat16                                       
  mlx::core::operator*(mlx::core::_MLX_BFloat16, int32_t)'                                    
  48 | inline _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return          
  static_cast<float>(lhs) * static_cast<float>(rhs); }; inline float                          
  operator*(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) *                  
  static_cast<float>(rhs); } inline float operator*(float lhs, _MLX_BFloat16 rhs) {           
  return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline double                  
  operator*(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) *                
  static_cast<double>(rhs); } inline double operator*(double lhs, _MLX_BFloat16 rhs) {        
  return static_cast<double>(lhs) * static_cast<double>(rhs); }; inline _MLX_BFloat16         
  operator*(_MLX_BFloat16 lhs, bool rhs) { return static_cast<float>(lhs) *                   
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator*(bool lhs, _MLX_BFloat16 rhs)      
  { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline _MLX_BFloat16         
  operator*(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) *                
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator*(int32_t lhs, _MLX_BFloat16        
  rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline                  
  _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, uint32_t rhs) { return                           
  static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_BFloat16                   
  operator*(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) *               
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, int64_t       
  rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator*(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) *                
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, uint64_t      
  rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator*(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) *               
  static_cast<float>(rhs); };;                                                                
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:77     
  :14: error: declaration of 'operator/' as non-function                                      
  77 | inline float operator/(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }           
  |              ^~~~~~~~                                                                     
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:77     
  :24: error: 'float16_t' was not declared in this scope; did you mean 'bfloat16_t'?          
  77 | inline float operator/(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }           
  |                        ^~~~~~~~~                                                          
  |                        bfloat16_t                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:77     
  :50: error: expected primary-expression before 'rhs'                                        
  77 | inline float operator/(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }           
  |                                                  ^~~                                      
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:77     
  :156: error: 'float16_t' has not been declared                                              
  77 | inline float operator/(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~~                                                                                   
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:77     
  :130: error: ambiguating new declaration of 'float                                          
  mlx::core::operator/(mlx::core::bfloat16_t, int)'                                           
  77 | inline float operator/(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:49     
  :869: note: old declaration 'mlx::core::_MLX_BFloat16                                       
  mlx::core::operator/(mlx::core::_MLX_BFloat16, int32_t)'                                    
  49 | inline _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return          
  static_cast<float>(lhs) / static_cast<float>(rhs); }; inline float                          
  operator/(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) /                  
  static_cast<float>(rhs); } inline float operator/(float lhs, _MLX_BFloat16 rhs) {           
  return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline double                  
  operator/(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) /                
  static_cast<double>(rhs); } inline double operator/(double lhs, _MLX_BFloat16 rhs) {        
  return static_cast<double>(lhs) / static_cast<double>(rhs); }; inline _MLX_BFloat16         
  operator/(_MLX_BFloat16 lhs, bool rhs) { return static_cast<float>(lhs) /                   
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator/(bool lhs, _MLX_BFloat16 rhs)      
  { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline _MLX_BFloat16         
  operator/(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) /                
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator/(int32_t lhs, _MLX_BFloat16        
  rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline                  
  _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, uint32_t rhs) { return                           
  static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_BFloat16                   
  operator/(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) /               
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, int64_t       
  rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator/(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) /                
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, uint64_t      
  rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator/(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) /               
  static_cast<float>(rhs); };;                                                                
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:13     
  7:1503: error: declaration of 'operator+' as non-function                                   
  137 | inline complex64_t operator+(const std::complex<float>& x, const complex64_t&         
  y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t                   
  operator+(const complex64_t& x, const std::complex<float>& y) { return                      
  static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const               
  complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) +        
  static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const           
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); }         
  inline complex64_t operator+(uint32_t x, const complex64_t& y) { return                     
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                  
  operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; }     
  inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x +                 
  static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const                
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); }      
  inline complex64_t operator+(int64_t x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                   
  operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y;      
  } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x +              
  static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const             
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y);     
  } inline complex64_t operator+(float x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  float y) { return x + static_cast<complex64_t>(y); }                                        
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:13     
  7:1513: error: 'float16_t' was not declared in this scope; did you mean 'bfloat16_t'?       
  137 | inline complex64_t operator+(const std::complex<float>& x, const complex64_t&         
  y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t                   
  operator+(const complex64_t& x, const std::complex<float>& y) { return                      
  static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const               
  complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) +        
  static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const           
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); }         
  inline complex64_t operator+(uint32_t x, const complex64_t& y) { return                     
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                  
  operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; }     
  inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x +                 
  static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const                
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); }      
  inline complex64_t operator+(int64_t x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                   
  operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y;      
  } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x +              
  static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const             
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y);     
  } inline complex64_t operator+(float x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  float y) { return x + static_cast<complex64_t>(y); }                                        
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~~                                                                                   
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  bfloat16_t                                                                                  
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:13     
  7:1526: error: expected primary-expression before 'const'                                   
  137 | inline complex64_t operator+(const std::complex<float>& x, const complex64_t&         
  y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t                   
  operator+(const complex64_t& x, const std::complex<float>& y) { return                      
  static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const               
  complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) +        
  static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const           
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); }         
  inline complex64_t operator+(uint32_t x, const complex64_t& y) { return                     
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                  
  operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; }     
  inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x +                 
  static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const                
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); }      
  inline complex64_t operator+(int64_t x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                   
  operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y;      
  } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x +              
  static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const             
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y);     
  } inline complex64_t operator+(float x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  float y) { return x + static_cast<complex64_t>(y); }                                        
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~                                                                                       
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:13     
  7:1643: error: 'float16_t' has not been declared                                            
  137 | inline complex64_t operator+(const std::complex<float>& x, const complex64_t&         
  y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t                   
  operator+(const complex64_t& x, const std::complex<float>& y) { return                      
  static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const               
  complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) +        
  static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const           
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); }         
  inline complex64_t operator+(uint32_t x, const complex64_t& y) { return                     
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                  
  operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; }     
  inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x +                 
  static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const                
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); }      
  inline complex64_t operator+(int64_t x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                   
  operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y;      
  } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x +              
  static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const             
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y);     
  } inline complex64_t operator+(float x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  float y) { return x + static_cast<complex64_t>(y); }                                        
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~~                                                                                   
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:13     
  7:1611: error: redefinition of 'mlx::core::complex64_t mlx::core::operator+(const           
  mlx::core::complex64_t&, int)'                                                              
  137 | inline complex64_t operator+(const std::complex<float>& x, const complex64_t&         
  y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t                   
  operator+(const complex64_t& x, const std::complex<float>& y) { return                      
  static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const               
  complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) +        
  static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const           
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); }         
  inline complex64_t operator+(uint32_t x, const complex64_t& y) { return                     
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                  
  operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; }     
  inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x +                 
  static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const                
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); }      
  inline complex64_t operator+(int64_t x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                   
  operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y;      
  } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x +              
  static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const             
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y);     
  } inline complex64_t operator+(float x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  float y) { return x + static_cast<complex64_t>(y); }                                        
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:13     
  7:1185: note: 'mlx::core::complex64_t mlx::core::operator+(const                            
  mlx::core::complex64_t&, int32_t)' previously defined here                                  
  137 | inline complex64_t operator+(const std::complex<float>& x, const complex64_t&         
  y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t                   
  operator+(const complex64_t& x, const std::complex<float>& y) { return                      
  static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const               
  complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) +        
  static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const           
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); }         
  inline complex64_t operator+(uint32_t x, const complex64_t& y) { return                     
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                  
  operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; }     
  inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x +                 
  static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const                
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); }      
  inline complex64_t operator+(int64_t x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                   
  operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y;      
  } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x +              
  static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const             
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y);     
  } inline complex64_t operator+(float x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  float y) { return x + static_cast<complex64_t>(y); }                                        
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:       
  In function 'mlx::core::simd::Simd<T, 1>                                                    
  mlx::core::simd::clamp(mlx::core::simd::Simd<T, 1>, mlx::core::simd::Simd<T, 1>,            
  mlx::core::simd::Simd<T, 1>)':                                                              
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:34     
  2:15: error: 'clamp' is not a member of 'std'; did you mean 'mlx::core::simd::clamp'?       
  342 |   return std::clamp(v.value, min.value, max.value);                                   
  |               ^~~~~                                                                       
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:34     
  1:12: note: 'mlx::core::simd::clamp' declared here                                          
  341 | Simd<T, 1> clamp(Simd<T, 1> v, Simd<T, 1> min, Simd<T, 1> max) {                      
  |            ^~~~~                                                                          
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:       
  In instantiation of 'mlx::core::simd::Simd<float, N>                                        
  mlx::core::detail::fp32_from_bits(mlx::core::simd::Simd<unsigned int, N>) [with int N =     
  1]':                                                                                        
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:62     
  0:26:   required from 'mlx::core::simd::Simd<float, N>                                      
  mlx::core::detail::FromFP8::operator()(mlx::core::simd::Simd<unsigned char, N>) [with       
  int N = 1]'                                                                                 
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:62     
  3:19:   required from here                                                                  
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:56     
  8:11: warning: dereferencing type-punned pointer will break strict-aliasing rules           
  [-Wstrict-aliasing]                                                                         
  568 |   return *(Simd<float, N>*)(&x);                                                      
  |           ^~~~~~~~~~~~~~~~~~~~~                                                           
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:56     
  8:11: warning: dereferencing type-punned pointer will break strict-aliasing rules           
  [-Wstrict-aliasing]                                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:       
  In instantiation of 'mlx::core::simd::Simd<T, N>                                            
  mlx::core::simd::exp(mlx::core::simd::Simd<T, N>) [with T = float; int N = 1]':             
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:53     
  8:38:   required from 'mlx::core::simd::Simd<T, N>                                          
  mlx::core::detail::Sigmoid::operator()(mlx::core::simd::Simd<T, N>) [with int N = 1; T      
  = float]'                                                                                   
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:54     
  1:59:   required from 'T mlx::core::detail::Sigmoid::operator()(T) [with T = float]'        
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:69     
  5:26:   required from here                                                                  
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:37     
  6:51: warning: dereferencing type-punned pointer will break strict-aliasing rules           
  [-Wstrict-aliasing]                                                                         
  376 |     auto result = select(isnan(x_init), x_init, (*(Simd<float, N>*)&epart) *          
  x);                                                                                         
  |                                                   ^~~~~~~~~~~~~~~~~~~~~~~                 
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:37     
  6:51: warning: dereferencing type-punned pointer will break strict-aliasing rules           
  [-Wstrict-aliasing]                                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:25     
  6:65: note:   initializing argument 1 of 'mlx::core::simd::Simd<decltype ((a.value *        
  b.value)), 1> mlx::core::simd::operator*(mlx::core::simd::Simd<T, 1>,                       
  mlx::core::simd::Simd<T2, 1>) [with T1 = float; T2 = float; decltype ((a.value *            
  b.value)) = float]'                                                                         
  256 | template <typename T1, typename T2> auto operator *(Simd<T1, 1> a, Simd<T2, 1>        
  b) ->Simd<decltype(a.value * b.value), 1> { return a.value * b.value; } template            
  <typename T1, typename T2> auto operator *(T1 a, Simd<T2, 1> b)->Simd<decltype(a *          
  b.value), 1> { return a * b.value; } template <typename T1, typename T2> auto operator      
  *(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value * b), 1> { return a.value * b; }              
  |                                                     ~~~~~~~~~~~~^ at                      
  /app/.build/checkouts/mlx-swift/Source/Cmlx/mlx-c/mlx/c/transforms.cpp:15

Metadata

Metadata

Assignees

No one assigned

    Labels

    Type

    No type

    Projects

    No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions